diff options
Diffstat (limited to '')
63 files changed, 25894 insertions, 0 deletions
diff --git a/tools/editor/plugins/SCsub b/tools/editor/plugins/SCsub new file mode 100644 index 000000000..b525fb3f7 --- /dev/null +++ b/tools/editor/plugins/SCsub @@ -0,0 +1,7 @@ +Import('env') +Export('env') +env.add_source_files(env.tool_sources,"*.cpp") + + + + diff --git a/tools/editor/plugins/animation_data_editor_plugin.cpp b/tools/editor/plugins/animation_data_editor_plugin.cpp new file mode 100644 index 000000000..17f17bba7 --- /dev/null +++ b/tools/editor/plugins/animation_data_editor_plugin.cpp @@ -0,0 +1,33 @@ +/*************************************************************************/ +/* animation_data_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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_data_editor_plugin.h"
+
+AnimationDataEditorPlugin::AnimationDataEditorPlugin()
+{
+}
diff --git a/tools/editor/plugins/animation_data_editor_plugin.h b/tools/editor/plugins/animation_data_editor_plugin.h new file mode 100644 index 000000000..2fd3d5b32 --- /dev/null +++ b/tools/editor/plugins/animation_data_editor_plugin.h @@ -0,0 +1,38 @@ +/*************************************************************************/ +/* animation_data_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef ANIMATION_DATA_EDITOR_PLUGIN_H
+#define ANIMATION_DATA_EDITOR_PLUGIN_H
+
+class AnimationDataEditorPlugin
+{
+public:
+ AnimationDataEditorPlugin();
+};
+
+#endif // ANIMATION_DATA_EDITOR_PLUGIN_H
diff --git a/tools/editor/plugins/animation_editor_plugin.cpp b/tools/editor/plugins/animation_editor_plugin.cpp new file mode 100644 index 000000000..bd27fa7da --- /dev/null +++ b/tools/editor/plugins/animation_editor_plugin.cpp @@ -0,0 +1,806 @@ +/*************************************************************************/ +/* animation_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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_editor_plugin.h" +#include "io/resource_loader.h" + + +class AnimationEditor_TrackEditor : public Object { + + OBJ_TYPE(AnimationEditor_TrackEditor,Object); + +protected: + + bool _set(const StringName& p_name, const Variant& p_value) { + + if (anim.is_null()) + return false; + String name=p_name; + + if (name=="track/interpolation") { + + anim_editor->_internal_set_interpolation_type(track,Animation::InterpolationType(p_value.operator int())); + + } else if (name.begins_with("keys/")) { + + int key = name.get_slice("/",1).to_int(); + ERR_FAIL_INDEX_V( key,anim->track_get_key_count(track), false ); + String what = name.get_slice("/",2); + float time = anim->track_get_key_time(track,key); + float transition = anim->track_get_key_transition(track,key); + + if (what=="time") { + Variant v = anim->track_get_key_value(track,key); + anim_editor->_internal_set_key(track,time,transition,v); + return true; + } + if (what=="transition") { + transition=p_value; + Variant v = anim->track_get_key_value(track,key); + anim_editor->_internal_set_key(track,time,transition,v); + return true; + } + + switch(anim->track_get_type(track)) { + + case Animation::TYPE_TRANSFORM: { + + Vector3 scale,loc; + Quat rot; + anim->transform_track_get_key(track,key,&loc,&rot,&scale); + + + if (what=="loc") { + loc=p_value; + } else if (what=="scale") { + scale=p_value; + } else if (what=="rot") { + rot=p_value; + } else { + return false; //meh + } + + Dictionary k; + k["rot"]=rot; + k["loc"]=loc; + k["scale"]=scale; + anim_editor->_internal_set_key(track,time,transition,k); + + } break; + case Animation::TYPE_METHOD: { + + } break; + case Animation::TYPE_VALUE: { + + if (what=="value") + anim_editor->_internal_set_key(track,time,transition,p_value); + } break; + default: { return false; } + + } + + } else + return false; + + return true; + } + + bool _get(const StringName& p_name,Variant &r_ret) const { + + if (anim.is_null()) + return false; + String name=p_name; + + if (name=="track/interpolation") { + + r_ret=anim->track_get_interpolation_type(track); + + } else if (name.begins_with("keys/")) { + + int key = name.get_slice("/",1).to_int(); + ERR_FAIL_INDEX_V( key,anim->track_get_key_count(track), Variant() ); + String what = name.get_slice("/",2); + + if (what=="time") { + r_ret=anim->track_get_key_time(track,key); + return true; + } + + if (what=="transition") { + r_ret=anim->track_get_key_transition(track,key); + return true; + } + + switch(anim->track_get_type(track)) { + + case Animation::TYPE_TRANSFORM: { + + Vector3 scale,loc; + Quat rot; + anim->transform_track_get_key(track,key,&loc,&rot,&scale); + + + if (what=="loc") { + r_ret= loc; + } else if (what=="scale") { + r_ret= scale; + } else if (what=="rot") { + r_ret= rot; + } + + } break; + case Animation::TYPE_METHOD: { + + } break; + case Animation::TYPE_VALUE: { + + if (what=="value") + r_ret= anim->track_get_key_value(track,key); + } break; + default: { return false; } + + } + } else + return false; + + return true; + } + void _get_property_list( List<PropertyInfo> *p_list) const { + + p_list->push_back(PropertyInfo(Variant::INT,"track/interpolation",PROPERTY_HINT_ENUM,"Nearest,Linear,Cubic") ); + + if (anim.is_null()) + return; + + int keycount = anim->track_get_key_count(track); + + for(int i=0;i<keycount;i++) { + + p_list->push_back(PropertyInfo(Variant::REAL,"keys/"+itos(i)+"/time",PROPERTY_HINT_RANGE,"0,3600,0.001") ); + p_list->push_back(PropertyInfo(Variant::REAL,"keys/"+itos(i)+"/transition",PROPERTY_HINT_EXP_EASING) ); + switch(anim->track_get_type(track)) { + + case Animation::TYPE_TRANSFORM: { + + p_list->push_back(PropertyInfo(Variant::VECTOR3,"keys/"+itos(i)+"/loc" ) ); + p_list->push_back(PropertyInfo(Variant::QUAT,"keys/"+itos(i)+"/rot" ) ); + p_list->push_back(PropertyInfo(Variant::VECTOR3,"keys/"+itos(i)+"/scale" ) ); + + } break; + case Animation::TYPE_METHOD: { + + } break; + case Animation::TYPE_VALUE: { + + + Variant v = anim->track_get_key_value(track,i); + + PropertyHint hint=PROPERTY_HINT_NONE; + String hint_string; + if (v.get_type()==Variant::INT) { + hint=PROPERTY_HINT_RANGE; + hint_string="-16384,16384,1"; + } else if (v.get_type()==Variant::REAL) { + hint=PROPERTY_HINT_RANGE; + hint_string="-16384,16384,0.001"; + } else if (v.get_type()==Variant::OBJECT) { + hint=PROPERTY_HINT_RESOURCE_TYPE; + hint_string="Resource"; + } + + + + p_list->push_back(PropertyInfo(v.get_type(),"keys/"+itos(i)+"/value",hint,hint_string ) ); + + + + } break; + + } + } + + } + +public: + + AnimationEditor *anim_editor; + + Ref<Animation> anim; + int track; + AnimationEditor_TrackEditor() { } + +}; + + +void AnimationEditor::update_anim() { + + tracks->clear(); + key_editor->edit(NULL); + TreeItem *root = tracks->create_item(NULL); + + TreeItem *sel=NULL; + int selected_track=-1; + if (animation->has_meta("_anim_editor_selected_track_")) + selected_track=animation->get_meta("_anim_editor_selected_track_"); + + for(int i=0;i<animation->get_track_count();i++) { + + String path = animation->track_get_path(i); + TreeItem *track = tracks->create_item(root); + track->set_text(0,itos(i)); + track->set_editable(0,false); + track->set_text(1,path); + track->set_editable(1,true); + track->set_metadata(0,i); + if (selected_track==i) + sel=track; + + switch(animation->track_get_type(i)) { + + case Animation::TYPE_TRANSFORM: { + + track->set_icon(0,get_icon("Matrix","EditorIcons")); + + } break; + case Animation::TYPE_METHOD: { + track->set_icon(0,get_icon("TrackMethod","EditorIcons")); + } break; + case Animation::TYPE_VALUE: { + + track->set_icon(0,get_icon("TrackValue","EditorIcons")); + } break; + + + } + + } + + if (sel) { + sel->select(1); + _update_track_keys(); + } else { + selected_track=-1; + } +} + +void AnimationEditor::_update_track_keys() { + if (selected_track<0 || selected_track>=animation->get_track_count()) + return; + track_editor->anim=animation; + track_editor->track=selected_track; + key_editor->edit(NULL); + key_editor->edit(track_editor); + + if (animation->track_get_type(selected_track)==Animation::TYPE_VALUE) { + key_time->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,160); + key_type->show(); + } else { + key_time->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,60); + key_type->hide(); + } + + +} + +void AnimationEditor::_track_path_changed() { + + TreeItem *ti=tracks->get_edited(); + int track=ti->get_metadata(0); + String path=ti->get_text(1); + if (track<0 || track>=animation->get_track_count()) + return; + undo_redo->create_action("Create Anim Track"); + undo_redo->add_do_method(animation.ptr(),"track_set_path",track,path); + undo_redo->add_undo_method(animation.ptr(),"track_set_path",track,animation->track_get_path(track)); + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + undo_redo->commit_action(); + +} + +void AnimationEditor::_track_selected() { + + TreeItem *ti=tracks->get_selected(); + if(!ti) + return; + selected_track=ti->get_metadata(0); + animation->set_meta("_anim_editor_selected_track_",selected_track); + _update_track_keys(); +} + +void AnimationEditor::_track_added() { + + undo_redo->create_action("Create Anim Track"); + undo_redo->add_do_method(animation.ptr(),"add_track",track_type->get_selected(),-1); + undo_redo->add_undo_method(animation.ptr(),"remove_track",animation->get_track_count()); + undo_redo->add_do_method(this,"_internal_set_selected_track",animation->get_track_count(),animation); + undo_redo->add_undo_method(this,"_internal_set_selected_track",selected_track,animation); + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + undo_redo->commit_action(); + update_anim(); +} + +void AnimationEditor::_track_removed() { + + if (selected_track<0 || selected_track>=animation->get_track_count()) + return; + + undo_redo->create_action("Remove Anim Track"); + undo_redo->add_do_method(animation.ptr(),"remove_track",selected_track); + undo_redo->add_undo_method(animation.ptr(),"add_track",animation->track_get_type(selected_track),selected_track); + undo_redo->add_undo_method(animation.ptr(),"track_set_path",selected_track,animation->track_get_path(selected_track)); + //todo interpolation + for(int i=0;i<animation->track_get_key_count(selected_track);i++) { + + Variant v = animation->track_get_key_value(selected_track,i); + float time = animation->track_get_key_time(selected_track,i); + + undo_redo->add_undo_method(animation.ptr(),"track_insert_key",selected_track,time,v); + + } + + int old_track=selected_track; + if (selected_track>0) + selected_track--; + if (selected_track<0 || selected_track>=(animation->get_track_count()-1)) + selected_track=-1; + + undo_redo->add_do_method(this,"_internal_set_selected_track",selected_track,animation); + undo_redo->add_undo_method(this,"_internal_set_selected_track",old_track,animation); + + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + undo_redo->commit_action(); + +} + +void AnimationEditor::_internal_set_interpolation_type(int p_track,Animation::InterpolationType p_type) { + + undo_redo->create_action("Set Interpolation"); + undo_redo->add_do_method(animation.ptr(),"track_set_interpolation_type",p_track,p_type); + undo_redo->add_undo_method(animation.ptr(),"track_set_interpolation_type",p_track,animation->track_get_interpolation_type(p_track)); + undo_redo->add_do_method(this,"_internal_set_selected_track",selected_track,animation); + undo_redo->add_undo_method(this,"_internal_set_selected_track",selected_track,animation); + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + undo_redo->commit_action(); + +} + +void AnimationEditor::_internal_set_selected_track(int p_which,const Ref<Animation>& p_anim) { + + if (is_visible() && animation==p_anim) { + selected_track=p_which; + animation->set_meta("_anim_editor_selected_track_",selected_track); + } +} + +void AnimationEditor::_track_moved_up() { + + + if (selected_track<0 || selected_track>=animation->get_track_count()) + return; + + if (selected_track<(animation->get_track_count()-1)) { + undo_redo->create_action("Move Up Track"); + undo_redo->add_do_method(animation.ptr(),"track_move_up",selected_track); + undo_redo->add_undo_method(animation.ptr(),"track_move_down",selected_track+1); + undo_redo->add_do_method(this,"_internal_set_selected_track",selected_track+1,animation); + undo_redo->add_undo_method(this,"_internal_set_selected_track",selected_track,animation); + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + undo_redo->commit_action(); + } +} + +void AnimationEditor::_track_moved_down() { + + + + if (selected_track<0 || selected_track>=animation->get_track_count()) + return; + if (selected_track>0) { + undo_redo->create_action("Move Down Track"); + undo_redo->add_do_method(animation.ptr(),"track_move_down",selected_track); + undo_redo->add_undo_method(animation.ptr(),"track_move_up",selected_track-1); + undo_redo->add_do_method(this,"_internal_set_selected_track",selected_track-1,animation); + undo_redo->add_undo_method(this,"_internal_set_selected_track",selected_track,animation); + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + undo_redo->commit_action(); + } + + +} + +void AnimationEditor::_key_added() { + + if (selected_track<0 || selected_track>=animation->get_track_count()) + return; + + bool need_variant= animation->track_get_type(selected_track)==Animation::TYPE_VALUE; + + Variant v; + + if (need_variant) { + + switch(key_type->get_selected()) { + + case Variant::NIL: v=Variant(); break; + case Variant::BOOL: v=false; break; + case Variant::INT: v=0; break; + case Variant::REAL: v=0.0; break; + case Variant::STRING: v=""; break; + case Variant::VECTOR2: v=Vector2(); break; // 5 + case Variant::RECT2: v=Rect2(); break; + case Variant::VECTOR3: v=Vector3(); break; + case Variant::PLANE: v=Plane(); break; + case Variant::QUAT: v=Quat(); break; + case Variant::_AABB: v=AABB(); break; //sorry naming convention fail :( not like it's used often // 10 + case Variant::MATRIX3: v=Matrix3(); break; + case Variant::TRANSFORM: v=Transform(); break; + case Variant::COLOR: v=Color(); break; + case Variant::IMAGE: v=Image(); break; + case Variant::NODE_PATH: v=NodePath(); break; // 15 + case Variant::_RID: v=RID(); break; + case Variant::OBJECT: v=Variant(); break; + case Variant::INPUT_EVENT: v=InputEvent(); break; + case Variant::DICTIONARY: v=Dictionary(); break; // 20 + case Variant::ARRAY: v=Array(); break; + case Variant::RAW_ARRAY: v=DVector<uint8_t>(); break; + case Variant::INT_ARRAY: v=DVector<int>(); break; + case Variant::REAL_ARRAY: v=DVector<real_t>(); break; + case Variant::STRING_ARRAY: v=DVector<String>(); break; //25 + case Variant::VECTOR3_ARRAY: v=DVector<Vector3>(); break; + case Variant::COLOR_ARRAY: v=DVector<Color>(); break; + default: v=Variant(); break; + } + } + + float time = key_time->get_text().to_double(); + + switch(animation->track_get_type(selected_track)) { + case Animation::TYPE_TRANSFORM: { + + Dictionary d; + d["loc"]=Vector3(); + d["rot"]=Quat(); + d["scale"]=Vector3(1,1,1); + v=d; + + } break; + case Animation::TYPE_VALUE: { + //v=v + } break; + case Animation::TYPE_METHOD: { + + return; //not do anything yet + } break; + } + + _internal_set_key(selected_track,time,1.0,v); + + _update_track_keys(); +} + + + +void AnimationEditor::_internal_check_update(Ref<Animation> p_anim) { + + if (is_visible() && p_anim==animation) { + update_anim(); + } +} + +void AnimationEditor::_internal_set_key(int p_track, float p_time, float p_transition,const Variant& p_value) { + + int prev = animation->track_find_key(p_track,p_time); + bool existing = (prev>=0) && (animation->track_get_key_time(p_track,prev)==p_time); + + undo_redo->create_action("Insert Key"); + + undo_redo->add_do_method(animation.ptr(),"track_insert_key",p_track,p_time,p_value,p_transition); + if (existing) + undo_redo->add_undo_method(animation.ptr(),"track_insert_key",p_track,p_time,animation->track_get_key_value(p_track,existing),animation->track_get_key_transition(p_track,existing)); + else + undo_redo->add_undo_method(animation.ptr(),"track_remove_key",p_track,prev+1); + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + + undo_redo->commit_action(); +} + +void AnimationEditor::_key_removed() { + + if (selected_track<0 || selected_track>=animation->get_track_count()) + return; + + String sel=key_editor->get_selected_path(); + if (sel.get_slice_count("/")<2) + return; + if (sel.get_slice("/",0)!="keys") + return; + int key = sel.get_slice("/",1).to_int(); + if (key<0 || key>=animation->track_get_key_count(selected_track)) + return; + + + undo_redo->create_action("Remove Key"); + + Variant data = animation->track_get_key_value(selected_track,key); + float time = animation->track_get_key_time(selected_track,key); + undo_redo->add_do_method(animation.ptr(),"track_remove_key",selected_track,key); + undo_redo->add_undo_method(animation.ptr(),"track_insert_key",selected_track,time,data); + undo_redo->add_do_method(this,"_internal_check_update",animation); + undo_redo->add_undo_method(this,"_internal_check_update",animation); + undo_redo->commit_action(); + + _update_track_keys(); +} + + + +void AnimationEditor::edit(const Ref<Animation>& p_animation) { + + + animation=p_animation; + if (!animation.is_null()) + update_anim(); + + +} + + + +void AnimationEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_track_selected"),&AnimationEditor::_track_selected); + ObjectTypeDB::bind_method(_MD("_track_added"),&AnimationEditor::_track_added); + ObjectTypeDB::bind_method(_MD("_track_removed"),&AnimationEditor::_track_removed); + ObjectTypeDB::bind_method(_MD("_track_moved_up"),&AnimationEditor::_track_moved_up); + ObjectTypeDB::bind_method(_MD("_track_moved_down"),&AnimationEditor::_track_moved_down); + ObjectTypeDB::bind_method(_MD("_track_path_changed"),&AnimationEditor::_track_path_changed); + ObjectTypeDB::bind_method(_MD("_key_added"),&AnimationEditor::_key_added); + ObjectTypeDB::bind_method(_MD("_key_removed"),&AnimationEditor::_key_removed); + ObjectTypeDB::bind_method(_MD("_internal_check_update"),&AnimationEditor::_internal_check_update); + ObjectTypeDB::bind_method(_MD("_internal_set_selected_track"),&AnimationEditor::_internal_set_selected_track); + +} + +void AnimationEditor::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + add_track->set_icon( get_icon("Add","EditorIcons") ); + remove_track->set_icon( get_icon("Del","EditorIcons") ); + move_up_track->set_icon( get_icon("Up","EditorIcons") ); + move_down_track->set_icon( get_icon("Down","EditorIcons") ); + time_icon->set_texture( get_icon("Time","EditorIcons") ); + + add_key->set_icon( get_icon("Add","EditorIcons") ); + remove_key->set_icon( get_icon("Del","EditorIcons") ); + + } break; + } +} + +AnimationEditor::AnimationEditor() { + + panel = memnew( Panel ); + add_child(panel); + panel->set_area_as_parent_rect(); + + Control *left_pane = memnew( Control ); + panel->add_child(left_pane); + left_pane->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_RATIO,0.5); + left_pane->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,0); + + Label *l = memnew( Label ); + l->set_text("Track List:"); + l->set_pos(Point2(5,5)); + left_pane->add_child(l); + + /* + track_name = memnew( LineEdit ); + track_name->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,10); + track_name->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + track_name->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,80); + track_name->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + left_pane->add_child(track_name); +*/ + + track_type = memnew( OptionButton ); + track_type->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,10); + track_type->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + track_type->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,115); + track_type->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + left_pane->add_child(track_type); + track_type->add_item("Transform",Animation::TYPE_TRANSFORM); + track_type->add_item("Value",Animation::TYPE_VALUE); + track_type->add_item("Method",Animation::TYPE_METHOD); + + + add_track = memnew( Button ); + add_track->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,110); + add_track->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + add_track->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,90); + add_track->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + left_pane->add_child(add_track); + + remove_track = memnew( Button ); + remove_track->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,85); + remove_track->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + remove_track->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,60); + remove_track->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + left_pane->add_child(remove_track); + + move_up_track = memnew( Button ); + move_up_track->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,55); + move_up_track->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + move_up_track->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,30); + move_up_track->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + left_pane->add_child(move_up_track); + + move_down_track = memnew( Button ); + move_down_track->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,25); + move_down_track->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + move_down_track->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0); + move_down_track->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + left_pane->add_child(move_down_track); + + tracks = memnew(Tree); + tracks->set_columns(2); + tracks->set_column_expand(0,false); + tracks->set_column_min_width(0,55); + tracks->set_column_expand(1,true); + tracks->set_column_min_width(1,100); + tracks->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,55); + tracks->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0); + tracks->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,10); + tracks->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,5); + tracks->set_hide_root(true); + left_pane->add_child(tracks); + + + Control *right_pane = memnew( Control ); + panel->add_child(right_pane); + right_pane->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_RATIO,0.5); + right_pane->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,5); + right_pane->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,0); + + l = memnew( Label ); + l->set_text("Track Keys:"); + l->set_pos(Point2(5,5)); + right_pane->add_child(l); + + time_icon = memnew( TextureFrame ); + time_icon->set_pos(Point2(8,28)); + right_pane->add_child(time_icon); + + key_time = memnew( LineEdit ); + key_time->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,24); + key_time->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,160); + key_time->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + key_time->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + key_time->set_text("0.0"); + right_pane->add_child(key_time); + + key_type = memnew( OptionButton ); + key_type->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,160); + key_type->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,60); + key_type->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + key_type->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + right_pane->add_child(key_type); + + for(int i=0;i<Variant::VARIANT_MAX;i++) { + + key_type->add_item(Variant::get_type_name(Variant::Type(i))); + } + + add_key = memnew( Button ); + add_key->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,55); + add_key->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,30); + add_key->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + add_key->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + right_pane->add_child(add_key); + + remove_key = memnew( Button ); + remove_key->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,25); + remove_key->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0); + remove_key->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,25); + remove_key->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,45); + right_pane->add_child(remove_key); + + key_editor = memnew(PropertyEditor); + key_editor->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,55); + key_editor->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0); + key_editor->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,10); + key_editor->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,5); + key_editor->hide_top_label(); + + right_pane->add_child(key_editor); + + track_editor = memnew( AnimationEditor_TrackEditor ); + track_editor->anim_editor=this; + selected_track=-1; + + add_track->connect("pressed", this,"_track_added"); + remove_track->connect("pressed", this,"_track_removed"); + move_up_track->connect("pressed", this,"_track_moved_up"); + move_down_track->connect("pressed", this,"_track_moved_down"); + tracks->connect("cell_selected", this,"_track_selected"); + tracks->connect("item_edited", this,"_track_path_changed"); + add_key->connect("pressed", this,"_key_added"); + remove_key->connect("pressed", this,"_key_removed"); +} + +AnimationEditor::~AnimationEditor() { + + memdelete(track_editor); +} + +void AnimationEditorPlugin::edit(Object *p_node) { + + animation_editor->set_undo_redo(&get_undo_redo()); + if (p_node && p_node->cast_to<Animation>()) { + animation_editor->edit( p_node->cast_to<Animation>() ); + animation_editor->show(); + } else + animation_editor->hide(); +} + +bool AnimationEditorPlugin::handles(Object *p_node) const{ + + return p_node->is_type("Animation"); +} + +void AnimationEditorPlugin::make_visible(bool p_visible){ + + if (p_visible) + animation_editor->show(); + else + animation_editor->hide(); +} + +AnimationEditorPlugin::AnimationEditorPlugin(EditorNode *p_node) { + + animation_editor = memnew( AnimationEditor ); + + p_node->get_viewport()->add_child(animation_editor); + animation_editor->set_area_as_parent_rect(); + animation_editor->hide(); + + + + +} + + diff --git a/tools/editor/plugins/animation_editor_plugin.h b/tools/editor/plugins/animation_editor_plugin.h new file mode 100644 index 000000000..82edef756 --- /dev/null +++ b/tools/editor/plugins/animation_editor_plugin.h @@ -0,0 +1,123 @@ +/*************************************************************************/ +/* animation_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef ANIMATION_EDITOR_PLUGIN_H +#define ANIMATION_EDITOR_PLUGIN_H + +#include "scene/resources/animation.h" +#include "scene/gui/texture_frame.h" +#include "scene/gui/option_button.h" +#include "tools/editor/editor_node.h" +#include "tools/editor/property_editor.h" +#include "undo_redo.h" +class AnimationEditor_TrackEditor; + +class AnimationEditor : public Control { + + OBJ_TYPE( AnimationEditor, Control ); + + Panel *panel; + Ref<Animation> animation; + + Button *add_track; + Button *remove_track; + Button *move_up_track; + Button *move_down_track; + + Button *add_key; + Button *remove_key; + + LineEdit *key_time; + OptionButton *track_type; + OptionButton *key_type; + TextureFrame *time_icon; + + Tree *tracks; + PropertyEditor *key_editor; + AnimationEditor_TrackEditor *track_editor; + int selected_track; + + void _track_selected(); + void _track_added(); + void _track_removed(); + void _track_moved_up(); + void _track_moved_down(); + void _track_path_changed(); + + void _key_added(); + void _key_removed(); + + + void _update_track_keys(); + void update_anim(); + + UndoRedo *undo_redo; + + void _internal_set_selected_track(int p_which,const Ref<Animation>& p_anim); + void _internal_check_update(Ref<Animation> p_anim); + +friend class AnimationEditor_TrackEditor; + void _internal_set_key(int p_track, float p_time, float p_transition,const Variant& p_value); + void _internal_set_interpolation_type(int p_track,Animation::InterpolationType p_type); + +protected: + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_undo_redo(UndoRedo *p_undo_redo) { undo_redo=p_undo_redo; } + void edit(const Ref<Animation>& p_animation); + + AnimationEditor(); + ~AnimationEditor(); +}; + + + +class AnimationEditorPlugin : public EditorPlugin { + + OBJ_TYPE( AnimationEditorPlugin, EditorPlugin ); + + AnimationEditor *animation_editor; + EditorNode *editor; + +public: + + + virtual String get_name() const { return "Animation"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + AnimationEditorPlugin(EditorNode *p_node); + +}; + + +#endif diff --git a/tools/editor/plugins/animation_player_editor_plugin.cpp b/tools/editor/plugins/animation_player_editor_plugin.cpp new file mode 100644 index 000000000..0d709b9a7 --- /dev/null +++ b/tools/editor/plugins/animation_player_editor_plugin.cpp @@ -0,0 +1,1157 @@ +/*************************************************************************/ +/* animation_player_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "io/resource_loader.h" + + +void AnimationPlayerEditor::_node_removed(Node *p_node) { + + if (player && player == p_node) { + player=NULL; + hide(); + set_process(false); + if (edit_anim->is_pressed()) { + + editor->get_animation_editor()->set_animation(Ref<Animation>()); + editor->get_animation_editor()->set_root(NULL); + editor->animation_editor_make_visible(false); + edit_anim->set_pressed(false); + } + } +} + +void AnimationPlayerEditor::_input_event(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<Animation> anim = player->get_animation(animname); + if (!anim.is_null()) { + + seek->set_max(anim->get_length()); + } + } + } + seek->set_val(player->get_current_animation_pos()); + if (edit_anim->is_pressed()) + editor->get_animation_editor()->set_anim_pos(player->get_current_animation_pos()); + } else if (last_active) { + //need the last frame after it stopped + + seek->set_val(player->get_current_animation_pos()); + } + + last_active=player->is_playing(); + //seek->set_val(player->get_pos()); + updating = false; + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + 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") ); + remove_anim->set_icon( get_icon("Del","EditorIcons") ); + edit_anim->set_icon( get_icon("Edit","EditorIcons") ); + blend_anim->set_icon( get_icon("Blend","EditorIcons") ); + play->set_icon( get_icon("Play","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_normal_texture(get_icon("Pin","EditorIcons") ); + pin->set_pressed_texture( get_icon("PinPressed","EditorIcons") ); + + blend_editor.next->connect("text_changed",this,"_blend_editor_next_changed"); + +/* + 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")); +*/ + } + + if (p_what==NOTIFICATION_READY) { + + get_scene()->connect("node_removed",this,"_node_removed"); + } + + if (p_what==NOTIFICATION_DRAW) { + + } +} + +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("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("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()<animation->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::_stop_pressed() { + + player->stop(); + 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()<animation->get_item_count()) { + + current = animation->get_item_text( animation->get_selected() ); + } + + if (current!="") { + + + player->set_current_animation( current ); + + Ref<Animation> anim = player->get_animation(current); + if (edit_anim->is_pressed()) { + Ref<Animation> anim = player->get_animation(current); + editor->get_animation_editor()->set_animation(anim); + Node *root = player->get_node(player->get_root()); + if (root) { + editor->get_animation_editor()->set_root(root); + } + } + seek->set_max(anim->get_length()); + + + } else { + if (edit_anim->is_pressed()) { + editor->get_animation_editor()->set_animation(Ref<Animation>()); + editor->get_animation_editor()->set_root(NULL); + } + + } + + + autoplay->set_pressed(current==player->get_autoplay()); +} + +void AnimationPlayerEditor::_animation_new() { + + renaming=false; + name_title->set_text("New Animation Name:"); + + int count=1; + String base="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("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( FileDialog::MODE_OPEN_FILE ); + file->clear_filters(); + List<String> extensions; + + ResourceLoader::get_recognized_extensions_for_type("Animation",&extensions); + for (List<String>::Element *E=extensions.front();E;E=E->next()) { + + file->add_filter("*."+E->get()+" ; "+E->get().to_upper() ); + + } + + file->popup_centered_ratio(); + + +} +void AnimationPlayerEditor::_animation_remove() { + + if (animation->get_item_count()==0) + return; + + String current = animation->get_item_text(animation->get_selected()); + Ref<Animation> anim = player->get_animation(current); + + + undo_redo->create_action("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;i<animation->get_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("ERROR: Invalid animation name!"); + error_dialog->popup_centered(Size2(300,70)); + 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("ERROR: Animation Name Already Exists!"); + error_dialog->popup_centered(Size2(300,70)); + return; + } + + if (renaming) { + String current = animation->get_item_text(animation->get_selected()); + Ref<Animation> anim = player->get_animation(current); + + undo_redo->create_action("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<Animation> new_anim = Ref<Animation>(memnew( Animation )); + new_anim->set_name(new_name); + + undo_redo->create_action("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 String& p_string) { + + if (animation->get_item_count()==0) + return; + + String current = animation->get_item_text(animation->get_selected()); + player->animation_set_next(current,p_string); + +} + +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<StringName> anims; + player->get_animation_list(&anims); + TreeItem *root = blend_editor.tree->create_item(); + updating_blends=true; + + for(List<StringName>::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)); + } + + blend_editor.next->set_text( player->animation_get_next(current) ); + + 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("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() { + + _animation_edit(); +} + +void AnimationPlayerEditor::_animation_resource_edit() { + + if (animation->get_item_count()) { + String current = animation->get_item_text(animation->get_selected()); + Ref<Animation> anim = player->get_animation(current); + editor->edit_resource(anim); + } + +} + +void AnimationPlayerEditor::_animation_edit() { + +// if (animation->get_item_count()==0) +// return; + + if (edit_anim->is_pressed()) { + editor->animation_editor_make_visible(true); + + //editor->get_animation_editor()->set_root(player->get_roo); - get root pending + if (animation->get_item_count()) { + String current = animation->get_item_text(animation->get_selected()); + Ref<Animation> anim = player->get_animation(current); + editor->get_animation_editor()->set_animation(anim); + Node *root = player->get_node(player->get_root()); + if (root) { + editor->get_animation_editor()->set_root(root); + } + + } else { + + editor->get_animation_editor()->set_animation(Ref<Animation>()); + editor->get_animation_editor()->set_root(NULL); + + } + } else { + editor->animation_editor_make_visible(false); + editor->get_animation_editor()->set_animation(Ref<Animation>()); + editor->get_animation_editor()->set_root(NULL); + } + + //get_scene()->get_root_node()->call("_resource_selected",anim,""); + +} +void AnimationPlayerEditor::_file_selected(String p_file) { + + ERR_FAIL_COND(!player); + + Ref<Resource> res = ResourceLoader::load(p_file,"Animation"); + ERR_FAIL_COND(res.is_null()); + ERR_FAIL_COND( !res->is_type("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("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(); + +} + +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;i<animation->get_item_count();i++) { + + if (animation->get_item_text(i)==current) { + animation->select(i); + break; + } + } + + updating=false; +} + +void AnimationPlayerEditor::_update_player() { + + if (!player) + return; + + updating=true; + List<StringName> animlist; + player->get_animation_list(&animlist); + + animation->clear(); + nodename->set_text(player->get_name()); + + stop->set_disabled(animlist.size()==0); + play->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); + + int active_idx=-1; + for (List<StringName>::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; + + } + + 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 (edit_anim->is_pressed()) { + + if (animation->get_item_count()) { + String current = animation->get_item_text(animation->get_selected()); + Ref<Animation> anim = player->get_animation(current); + editor->get_animation_editor()->set_animation(anim); + Node *root = player->get_node(player->get_root()); + if (root) { + editor->get_animation_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(); + else { + +// hide(); + + } + +} + + +void AnimationPlayerEditor::_animation_duplicate() { + + + if (!animation->get_item_count()) + return; + + String current = animation->get_item_text(animation->get_selected()); + Ref<Animation> anim = player->get_animation(current); + if (!anim.is_valid()) + return; + + Ref<Animation> new_anim = memnew( Animation ); + List<PropertyInfo> plist; + anim->get_property_list(&plist); + for (List<PropertyInfo>::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("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(this,"_animation_player_changed",player); + undo_redo->add_undo_method(this,"_animation_player_changed",player); + undo_redo->commit_action(); + + + for(int i=0;i<animation->get_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) { + + 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<Animation> anim; + anim=player->get_animation(current); + + float pos = anim->get_length() * (p_value / seek->get_max()); + + if (player->is_valid()) { + float cpos = player->get_current_animation_pos(); + + player->seek_delta(pos,pos-cpos); + } else { + player->seek(pos,true); + } + + if (edit_anim->is_pressed()) + editor->get_animation_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<Animation> anim = player->get_animation(current); + + if (editor->get_animation_editor()->get_current_animation()==anim) + return; //already there + + + undo_redo->create_action("Store anim in editor"); + undo_redo->add_do_method(editor->get_animation_editor(),"set_animation",anim); + undo_redo->add_undo_method(editor->get_animation_editor(),"remove_animation",anim); + undo_redo->commit_action(); +} + +void AnimationPlayerEditor::_editor_load(){ + + Ref<Animation> anim = editor->get_animation_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) { + + seek->set_max(p_len); + +} + + +void AnimationPlayerEditor::_animation_key_editor_seek(float p_pos) { + + if (!is_visible()) + return; + if (!player) + return; + + if (player->is_playing() ) + return; + + seek->set_val(p_pos); + + + //seekit +} + +void AnimationPlayerEditor::_hide_anim_editors() { + + player=NULL; + hide(); + set_process(false); + if (edit_anim->is_pressed()) { + + editor->get_animation_editor()->set_animation(Ref<Animation>()); + editor->get_animation_editor()->set_root(NULL); + editor->animation_editor_make_visible(false); + edit_anim->set_pressed(false); + } +} + +void AnimationPlayerEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_input_event"),&AnimationPlayerEditor::_input_event); + ObjectTypeDB::bind_method(_MD("_node_removed"),&AnimationPlayerEditor::_node_removed); + ObjectTypeDB::bind_method(_MD("_play_pressed"),&AnimationPlayerEditor::_play_pressed); + ObjectTypeDB::bind_method(_MD("_stop_pressed"),&AnimationPlayerEditor::_stop_pressed); + ObjectTypeDB::bind_method(_MD("_autoplay_pressed"),&AnimationPlayerEditor::_autoplay_pressed); + ObjectTypeDB::bind_method(_MD("_pause_pressed"),&AnimationPlayerEditor::_pause_pressed); + ObjectTypeDB::bind_method(_MD("_animation_selected"),&AnimationPlayerEditor::_animation_selected); + ObjectTypeDB::bind_method(_MD("_animation_name_edited"),&AnimationPlayerEditor::_animation_name_edited); + ObjectTypeDB::bind_method(_MD("_animation_new"),&AnimationPlayerEditor::_animation_new); + ObjectTypeDB::bind_method(_MD("_animation_rename"),&AnimationPlayerEditor::_animation_rename); + ObjectTypeDB::bind_method(_MD("_animation_load"),&AnimationPlayerEditor::_animation_load); + ObjectTypeDB::bind_method(_MD("_animation_remove"),&AnimationPlayerEditor::_animation_remove); + ObjectTypeDB::bind_method(_MD("_animation_blend"),&AnimationPlayerEditor::_animation_blend); + ObjectTypeDB::bind_method(_MD("_animation_edit"),&AnimationPlayerEditor::_animation_edit); + ObjectTypeDB::bind_method(_MD("_animation_resource_edit"),&AnimationPlayerEditor::_animation_resource_edit); + ObjectTypeDB::bind_method(_MD("_file_selected"),&AnimationPlayerEditor::_file_selected); + ObjectTypeDB::bind_method(_MD("_seek_value_changed"),&AnimationPlayerEditor::_seek_value_changed); + ObjectTypeDB::bind_method(_MD("_animation_player_changed"),&AnimationPlayerEditor::_animation_player_changed); + ObjectTypeDB::bind_method(_MD("_blend_edited"),&AnimationPlayerEditor::_blend_edited); +// ObjectTypeDB::bind_method(_MD("_seek_frame_changed"),&AnimationPlayerEditor::_seek_frame_changed); + ObjectTypeDB::bind_method(_MD("_scale_changed"),&AnimationPlayerEditor::_scale_changed); + //ObjectTypeDB::bind_method(_MD("_editor_store_all"),&AnimationPlayerEditor::_editor_store_all); + ///jectTypeDB::bind_method(_MD("_editor_load_all"),&AnimationPlayerEditor::_editor_load_all); + ObjectTypeDB::bind_method(_MD("_list_changed"),&AnimationPlayerEditor::_list_changed); + ObjectTypeDB::bind_method(_MD("_animation_key_editor_seek"),&AnimationPlayerEditor::_animation_key_editor_seek); + ObjectTypeDB::bind_method(_MD("_animation_key_editor_anim_len_changed"),&AnimationPlayerEditor::_animation_key_editor_anim_len_changed); + ObjectTypeDB::bind_method(_MD("_hide_anim_editors"),&AnimationPlayerEditor::_hide_anim_editors); + ObjectTypeDB::bind_method(_MD("_animation_duplicate"),&AnimationPlayerEditor::_animation_duplicate); + ObjectTypeDB::bind_method(_MD("_blend_editor_next_changed"),&AnimationPlayerEditor::_blend_editor_next_changed); + + + + +} + +AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor) { + editor=p_editor; + + 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); + + + add_anim = memnew( Button ); + add_anim->set_tooltip("Create new animation in player."); + + hb->add_child(add_anim); + + + + load_anim = memnew( Button ); + load_anim->set_tooltip("Load an animation from disk."); + hb->add_child(load_anim); + + duplicate_anim = memnew( Button ); + hb->add_child(duplicate_anim); + duplicate_anim->set_tooltip("Duplicate Animation"); + + animation = memnew( OptionButton ); + hb->add_child(animation); + animation->set_h_size_flags(SIZE_EXPAND_FILL); + animation->set_tooltip("Display list of animations in player."); + + autoplay = memnew( Button ); + hb->add_child(autoplay); + autoplay->set_tooltip("Autoplay On Load"); + + + rename_anim = memnew( Button ); + hb->add_child(rename_anim); + rename_anim->set_tooltip("Rename Animation"); + + remove_anim = memnew( Button ); + + hb->add_child(remove_anim); + remove_anim->set_tooltip("Remove Animation"); + + blend_anim = memnew( Button ); + hb->add_child(blend_anim); + blend_anim->set_tooltip("Edit Target Blend Times"); + + + + edit_anim = memnew( Button ); + edit_anim->set_toggle_mode(true); + hb->add_child(edit_anim); + edit_anim->set_tooltip("Open animation editor.\nProperty editor will displays all editable keys too."); + + + hb = memnew (HBoxContainer); + add_child(hb); + + play = memnew( Button ); + play->set_tooltip("Play selected animation."); + + hb->add_child(play); + + stop = memnew( Button ); + stop->set_toggle_mode(true); + hb->add_child(stop); + play->set_tooltip("Stop animation playback."); + + //pause = memnew( Button ); + //pause->set_toggle_mode(true); + //hb->add_child(pause); + + seek = memnew( HSlider ); + seek->set_val(0); + seek->set_step(0.01); + hb->add_child(seek); + seek->set_h_size_flags(SIZE_EXPAND_FILL); + seek->set_stretch_ratio(8); + seek->set_tooltip("Seek animation (when stopped)."); + + frame = memnew( SpinBox ); + hb->add_child(frame); + frame->set_h_size_flags(SIZE_EXPAND_FILL); + frame->set_stretch_ratio(2); + frame->set_tooltip("Animation position (in seconds)."); + seek->share(frame); + + + + scale = memnew( LineEdit ); + hb->add_child(scale); + scale->set_h_size_flags(SIZE_EXPAND_FILL); + scale->set_stretch_ratio(1); + scale->set_tooltip("Scale animation playback globally for the node."); + scale->hide(); + + resource_edit_anim= memnew( Button ); + hb->add_child(resource_edit_anim); + + + file = memnew(FileDialog); + add_child(file); + + name_dialog = memnew( ConfirmationDialog ); + 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("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("Close"); + //error_dialog->get_cancel()->set_text("Close"); + error_dialog->set_text("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("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("Blend Times: ",blend_editor.tree,true); + blend_editor.next = memnew( LineEdit ); + blend_vb->add_margin_child("Next (Auto Queue):",blend_editor.next); + blend_editor.dialog->set_title("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"); + 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"); + edit_anim->connect("pressed", this,"_animation_edit"); + blend_anim->connect("pressed", this,"_animation_blend"); + remove_anim->connect("pressed", this,"_animation_remove"); + animation->connect("item_selected", this,"_animation_selected",Vector<Variant>(),true); + resource_edit_anim->connect("pressed", this,"_animation_resource_edit"); + file->connect("file_selected", this,"_file_selected"); + seek->connect("value_changed", this, "_seek_value_changed",Vector<Variant>(),true); + scale->connect("text_entered", this, "_scale_changed",Vector<Variant>(),true); + editor->get_animation_editor()->connect("timeline_changed",this,"_animation_key_editor_seek"); + editor->get_animation_editor()->connect("animation_len_changed",this,"_animation_key_editor_anim_len_changed"); + + HBoxContainer *ahb = editor->get_animation_panel_hb(); + nodename = memnew( Label ); + ahb->add_child(nodename); + nodename->set_h_size_flags(SIZE_EXPAND_FILL); + nodename->set_opacity(0.5); + pin = memnew( TextureButton ); + pin->set_toggle_mode(true); + ahb->add_child(pin); + + renaming=false; + last_active=false; +} + + +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<AnimationPlayer>()); +} + +bool AnimationPlayerEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("AnimationPlayer"); +} + +void AnimationPlayerEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + anim_editor->show(); + 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) ); + editor->get_animation_panel()->add_child(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() +{ +} + + diff --git a/tools/editor/plugins/animation_player_editor_plugin.h b/tools/editor/plugins/animation_player_editor_plugin.h new file mode 100644 index 000000000..2c6bcae97 --- /dev/null +++ b/tools/editor/plugins/animation_player_editor_plugin.h @@ -0,0 +1,166 @@ +/*************************************************************************/ +/* animation_player_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef ANIMATION_PLAYER_EDITOR_PLUGIN_H +#define ANIMATION_PLAYER_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/animation/animation_player.h" +#include "scene/gui/dialogs.h" +#include "scene/gui/texture_button.h" +#include "scene/gui/slider.h" +#include "scene/gui/spin_box.h" + + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class AnimationPlayerEditor : public VBoxContainer { + + OBJ_TYPE(AnimationPlayerEditor, VBoxContainer ); + + EditorNode *editor; + AnimationPlayer *player; + + + OptionButton *animation; + Button *stop; + Button *play; +// Button *pause; + Button *add_anim; + Button *autoplay; + Button *rename_anim; + Button *duplicate_anim; + Button *edit_anim; + Button *resource_edit_anim; + Button *load_anim; + Button *blend_anim; + Button *remove_anim; + TextureButton *pin; + Label *nodename; + SpinBox *frame; + HSlider *seek; + LineEdit *scale; + LineEdit *name; + Label *name_title; + UndoRedo *undo_redo; + Ref<Texture> autoplay_icon; + bool last_active; + + FileDialog *file; + + struct BlendEditor { + + AcceptDialog * dialog; + Tree *tree; + LineEdit *next; + + } blend_editor; + + + ConfirmationDialog *name_dialog; + ConfirmationDialog *error_dialog; + bool renaming; + + + bool updating; + bool updating_blends; + + void _select_anim_by_name(const String& p_anim); + void _play_pressed(); + void _autoplay_pressed(); + void _stop_pressed(); + void _pause_pressed(); + void _animation_selected(int p_which); + void _animation_new(); + void _animation_rename(); + void _animation_name_edited(); + void _animation_load(); + void _animation_remove(); + void _animation_blend(); + void _animation_edit(); + void _animation_duplicate(); + void _animation_resource_edit(); + void _scale_changed(const String& p_scale); + void _file_selected(String p_file); + void _seek_frame_changed(const String& p_frame); + void _seek_value_changed(float p_value); + void _blend_editor_next_changed(const String& p_string); + + void _list_changed(); + void _update_animation(); + void _update_player(); + void _blend_edited(); + + + void _hide_anim_editors(); + + void _animation_player_changed(Object *p_pl); + + void _animation_key_editor_seek(float p_pos); + void _animation_key_editor_anim_len_changed(float p_new); + + AnimationPlayerEditor(); +protected: + + void _notification(int p_what); + void _input_event(InputEvent p_event); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + void ensure_visibility(); + + void set_undo_redo(UndoRedo *p_undo_redo) { undo_redo=p_undo_redo; } + void edit(AnimationPlayer *p_player); + AnimationPlayerEditor(EditorNode *p_editor); +}; + +class AnimationPlayerEditorPlugin : public EditorPlugin { + + OBJ_TYPE( AnimationPlayerEditorPlugin, EditorPlugin ); + + AnimationPlayerEditor *anim_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Anim"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + AnimationPlayerEditorPlugin(EditorNode *p_node); + ~AnimationPlayerEditorPlugin(); + +}; + +#endif // ANIMATION_PLAYER_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/animation_tree_editor_plugin.cpp b/tools/editor/plugins/animation_tree_editor_plugin.cpp new file mode 100644 index 000000000..aeef59309 --- /dev/null +++ b/tools/editor/plugins/animation_tree_editor_plugin.cpp @@ -0,0 +1,1535 @@ +/*************************************************************************/ +/* animation_tree_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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_tree_editor_plugin.h" + +#include "scene/gui/menu_button.h" +#include "scene/gui/panel.h" +#include "scene/main/viewport.h" +#include "core/io/resource_loader.h" +#include "core/globals.h" +#include "os/input.h" +#include "os/keyboard.h" + +void AnimationTreeEditor::edit(AnimationTreePlayer* p_anim_tree) { + + + anim_tree=p_anim_tree; + + if (!anim_tree) { + hide(); + } else { + order.clear(); + p_anim_tree->get_node_list(&order); + /* + for(List<StringName>::Element* E=order.front();E;E=E->next()) { + + if (E->get() >= (int)last_id) + last_id=E->get()+1; + }*/ + play_button->set_pressed(p_anim_tree->is_active()); + //read the orders + } + +} + +Size2 AnimationTreeEditor::_get_maximum_size() { + + Size2 max; + + for(List<StringName>::Element *E=order.front();E;E=E->next()) { + + Point2 pos = anim_tree->node_get_pos(E->get()); + + if (click_type==CLICK_NODE && click_node==E->get()) { + + pos+=click_motion-click_pos; + } + pos+=get_node_size(E->get()); + if (pos.x>max.x) + max.x=pos.x; + if (pos.y>max.y) + max.y=pos.y; + + } + + return max; +} + + +const char* AnimationTreeEditor::_node_type_names[]={"Output","Animation","OneShot","Mix","Blend2","Blend3","Blend4","TimeScale","TimeSeek","Transition"}; + +Size2 AnimationTreeEditor::get_node_size(const StringName& p_node) const { + + AnimationTreePlayer::NodeType type=anim_tree->node_get_type(p_node); + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Ref<Font> font = get_font("font","PopupMenu"); + Color font_color = get_color("font_color","PopupMenu"); + + Size2 size = style->get_minimum_size(); + + int count=2; // title and name + int inputs = anim_tree->node_get_input_count(p_node); + count += inputs?inputs:1; + String name = p_node; + + + float name_w = font->get_string_size( name ).width; + float type_w = font->get_string_size( String(_node_type_names[type]) ).width; + float max_w=MAX(name_w,type_w); + + + + switch(type) { + case AnimationTreePlayer::NODE_TIMESEEK: + case AnimationTreePlayer::NODE_OUTPUT: {} break; + case AnimationTreePlayer::NODE_ANIMATION: + case AnimationTreePlayer::NODE_ONESHOT: + case AnimationTreePlayer::NODE_MIX: + case AnimationTreePlayer::NODE_BLEND2: + case AnimationTreePlayer::NODE_BLEND3: + case AnimationTreePlayer::NODE_BLEND4: + case AnimationTreePlayer::NODE_TIMESCALE: + case AnimationTreePlayer::NODE_TRANSITION: { + + + size.height+=font->get_height(); + } break; + case AnimationTreePlayer::NODE_MAX: {} + } + + size.x+=max_w+20; + size.y+=count*(font->get_height()+get_constant("vseparation","PopupMenu")); + + return size; +} + + +void AnimationTreeEditor::_edit_dialog_changede(String) { + + edit_dialog->hide(); +} + +void AnimationTreeEditor::_edit_dialog_changeds(String s) { + + _edit_dialog_changed(); +} + +void AnimationTreeEditor::_edit_dialog_changedf(float) { + + _edit_dialog_changed(); +} + +void AnimationTreeEditor::_edit_dialog_changed() { + + if (updating_edit) + return; + + if (renaming_edit) { + + if (anim_tree->node_rename(edited_node,edit_line[0]->get_text())==OK) { + for(List<StringName>::Element* E=order.front();E;E=E->next()) { + + if (E->get() == edited_node) + E->get()=edit_line[0]->get_text(); + } + edited_node=edit_line[0]->get_text(); + } + update(); + return; + } + + AnimationTreePlayer::NodeType type=anim_tree->node_get_type(edited_node); + + switch(type) { + + case AnimationTreePlayer::NODE_TIMESCALE: + anim_tree->timescale_node_set_scale(edited_node,edit_line[0]->get_text().to_double()); + break; + case AnimationTreePlayer::NODE_ONESHOT: + anim_tree->oneshot_node_set_fadein_time(edited_node,edit_line[0]->get_text().to_double()); + anim_tree->oneshot_node_set_fadeout_time(edited_node,edit_line[1]->get_text().to_double()); + anim_tree->oneshot_node_set_autorestart_delay(edited_node,edit_line[2]->get_text().to_double()); + anim_tree->oneshot_node_set_autorestart_random_delay(edited_node,edit_line[3]->get_text().to_double()); + anim_tree->oneshot_node_set_autorestart(edited_node,edit_check->is_pressed()); + anim_tree->oneshot_node_set_mix_mode(edited_node,edit_option->get_selected()); + + break; + + case AnimationTreePlayer::NODE_MIX: + + anim_tree->mix_node_set_amount(edited_node,edit_scroll[0]->get_val()); + break; + case AnimationTreePlayer::NODE_BLEND2: + anim_tree->blend2_node_set_amount(edited_node,edit_scroll[0]->get_val()); + + break; + + case AnimationTreePlayer::NODE_BLEND3: + anim_tree->blend3_node_set_amount(edited_node,edit_scroll[0]->get_val()); + + break; + case AnimationTreePlayer::NODE_BLEND4: + + anim_tree->blend4_node_set_amount(edited_node,Point2(edit_scroll[0]->get_val(),edit_scroll[1]->get_val())); + + break; + + case AnimationTreePlayer::NODE_TRANSITION: { + anim_tree->transition_node_set_xfade_time(edited_node,edit_line[0]->get_text().to_double()); + if (anim_tree->transition_node_get_current(edited_node)!=edit_option->get_selected()) + anim_tree->transition_node_set_current(edited_node,edit_option->get_selected()); + } break; + default: {} + } + +} + +void AnimationTreeEditor::_edit_dialog_animation_changed() { + + + Ref<Animation> anim = property_editor->get_variant().operator RefPtr(); + anim_tree->animation_node_set_animation(edited_node,anim); + update(); +} + +void AnimationTreeEditor::_edit_dialog_edit_animation() { + + if (get_scene()->is_editor_hint()) { + get_scene()->get_root()->get_child(0)->call("_resource_selected", property_editor->get_variant().operator RefPtr()); + }; +}; + +void AnimationTreeEditor::_edit_oneshot_start() { + + anim_tree->oneshot_node_start(edited_node); +} + +void AnimationTreeEditor::_play_toggled() { + + anim_tree->set_active(play_button->is_pressed()); +} + + +void AnimationTreeEditor::_master_anim_menu_item(int p_item) { + + String str = master_anim_popup->get_item_text(p_item); + anim_tree->animation_node_set_master_animation(edited_node,str); + update(); +} + +void AnimationTreeEditor::_popup_edit_dialog() { + + updating_edit=true; + + for(int i=0;i<2;i++) + edit_scroll[i]->hide(); + + for(int i=0;i<4;i++) { + + edit_line[i]->hide(); + edit_label[i]->hide(); + } + + edit_option->hide(); + edit_button->hide();; + filter_button->hide(); + edit_check->hide();; + + Point2 pos = anim_tree->node_get_pos(edited_node)-Point2(h_scroll->get_val(),v_scroll->get_val()); + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Size2 size = get_node_size(edited_node); + Point2 popup_pos( pos.x+style->get_margin(MARGIN_LEFT), pos.y+size.y-style->get_margin(MARGIN_BOTTOM)); + popup_pos+=get_global_pos(); + + if (renaming_edit) { + + edit_label[0]->set_text("New name:"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_line[0]->set_begin(Point2(15,25)); + edit_line[0]->set_text(edited_node); + edit_line[0]->show(); + edit_dialog->set_size(Size2(150,50)); + + } else { + + AnimationTreePlayer::NodeType type=anim_tree->node_get_type(edited_node); + + + switch(type) { + + case AnimationTreePlayer::NODE_ANIMATION: + + if (anim_tree->get_master_player()!=NodePath() && anim_tree->has_node(anim_tree->get_master_player()) && anim_tree->get_node(anim_tree->get_master_player())->cast_to<AnimationPlayer>()) { + + AnimationPlayer *ap = anim_tree->get_node(anim_tree->get_master_player())->cast_to<AnimationPlayer>(); + master_anim_popup->clear(); + List<StringName> sn; + ap->get_animation_list(&sn); + sn.sort_custom<StringName::AlphCompare>(); + for (List<StringName>::Element *E=sn.front();E;E=E->next()) { + master_anim_popup->add_item(E->get()); + } + + master_anim_popup->set_pos(popup_pos); + master_anim_popup->popup(); + } else { + property_editor->edit(this,"",Variant::OBJECT,anim_tree->animation_node_get_animation(edited_node),PROPERTY_HINT_RESOURCE_TYPE,"Animation"); + property_editor->set_pos(popup_pos); + property_editor->popup(); + updating_edit=false; + } + return; + case AnimationTreePlayer::NODE_TIMESCALE: + edit_label[0]->set_text("Scale:"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_line[0]->set_begin(Point2(15,25)); + edit_line[0]->set_text(rtos(anim_tree->timescale_node_get_scale(edited_node))); + edit_line[0]->show(); + edit_dialog->set_size(Size2(150,50)); + break; + case AnimationTreePlayer::NODE_ONESHOT: + edit_label[0]->set_text("Fade In (s):"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_line[0]->set_begin(Point2(15,25)); + edit_line[0]->set_text(rtos(anim_tree->oneshot_node_get_fadein_time(edited_node))); + edit_line[0]->show(); + edit_label[1]->set_text("Fade Out (s):"); + edit_label[1]->set_pos(Point2(5,55)); + edit_label[1]->show(); + edit_line[1]->set_begin(Point2(15,75)); + edit_line[1]->set_text(rtos(anim_tree->oneshot_node_get_fadeout_time(edited_node))); + edit_line[1]->show(); + + edit_option->clear(); + edit_option->add_item("Blend",0); + edit_option->add_item("Mix",1); + edit_option->set_begin(Point2(15,105)); + + edit_option->select( anim_tree->oneshot_node_get_mix_mode(edited_node)); + edit_option->show(); + + edit_check->set_text("Auto Restart:"); + edit_check->set_begin(Point2(15,125)); + edit_check->set_pressed(anim_tree->oneshot_node_has_autorestart(edited_node)); + edit_check->show(); + + edit_label[2]->set_text("Restart (s):"); + edit_label[2]->set_pos(Point2(5,145)); + edit_label[2]->show(); + edit_line[2]->set_begin(Point2(15,165)); + edit_line[2]->set_text(rtos(anim_tree->oneshot_node_get_autorestart_delay(edited_node))); + edit_line[2]->show(); + edit_label[3]->set_text("Random Restart (s):"); + edit_label[3]->set_pos(Point2(5,195)); + edit_label[3]->show(); + edit_line[3]->set_begin(Point2(15,215)); + edit_line[3]->set_text(rtos(anim_tree->oneshot_node_get_autorestart_random_delay(edited_node))); + edit_line[3]->show(); + + filter_button->set_begin(Point2(10,245)); + filter_button->show(); + + edit_button->set_begin(Point2(10,268)); + edit_button->set_text("Start!"); + + edit_button->show(); + + edit_dialog->set_size(Size2(180,293)); + + break; + + case AnimationTreePlayer::NODE_MIX: + + edit_label[0]->set_text("Amount:"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_scroll[0]->set_min(0); + edit_scroll[0]->set_max(1); + edit_scroll[0]->set_val(anim_tree->mix_node_get_amount(edited_node)); + edit_scroll[0]->set_begin(Point2(15,25)); + edit_scroll[0]->show(); + edit_dialog->set_size(Size2(150,50)); + + break; + case AnimationTreePlayer::NODE_BLEND2: + edit_label[0]->set_text("Blend:"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_scroll[0]->set_min(0); + edit_scroll[0]->set_max(1); + edit_scroll[0]->set_val(anim_tree->blend2_node_get_amount(edited_node)); + edit_scroll[0]->set_begin(Point2(15,25)); + edit_scroll[0]->show(); + filter_button->set_begin(Point2(10,47)); + filter_button->show(); + edit_dialog->set_size(Size2(150,74)); + + break; + + case AnimationTreePlayer::NODE_BLEND3: + edit_label[0]->set_text("Blend:"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_scroll[0]->set_min(-1); + edit_scroll[0]->set_max(1); + edit_scroll[0]->set_val(anim_tree->blend3_node_get_amount(edited_node)); + edit_scroll[0]->set_begin(Point2(15,25)); + edit_scroll[0]->show(); + edit_dialog->set_size(Size2(150,50)); + + break; + case AnimationTreePlayer::NODE_BLEND4: + + edit_label[0]->set_text("Blend 0:"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_scroll[0]->set_min(0); + edit_scroll[0]->set_max(1); + edit_scroll[0]->set_val(anim_tree->blend4_node_get_amount(edited_node).x); + edit_scroll[0]->set_begin(Point2(15,25)); + edit_scroll[0]->show(); + edit_label[1]->set_text("Blend 1:"); + edit_label[1]->set_pos(Point2(5,55)); + edit_label[1]->show(); + edit_scroll[1]->set_min(0); + edit_scroll[1]->set_max(1); + edit_scroll[1]->set_val(anim_tree->blend4_node_get_amount(edited_node).y); + edit_scroll[1]->set_begin(Point2(15,75)); + edit_scroll[1]->show(); + edit_dialog->set_size(Size2(150,100)); + + break; + + case AnimationTreePlayer::NODE_TRANSITION: { + + + edit_label[0]->set_text("X-Fade Time (s):"); + edit_label[0]->set_pos(Point2(5,5)); + edit_label[0]->show(); + edit_line[0]->set_begin(Point2(15,25)); + edit_line[0]->set_text(rtos(anim_tree->transition_node_get_xfade_time(edited_node))); + edit_line[0]->show(); + + edit_label[1]->set_text("Current:"); + edit_label[1]->set_pos(Point2(5,55)); + edit_label[1]->show(); + edit_option->set_begin(Point2(15,75)); + + edit_option->clear();; + + for(int i=0;i<anim_tree->transition_node_get_input_count(edited_node);i++) { + edit_option->add_item(itos(i),i); + } + + edit_option->select(anim_tree->transition_node_get_current(edited_node)); + edit_option->show(); + edit_dialog->set_size(Size2(150,100)); + + } break; + default: {} + + } + + } + + + + edit_dialog->set_pos(popup_pos); + edit_dialog->popup(); + + updating_edit=false; +} + +void AnimationTreeEditor::_draw_node(const StringName& p_node) { + + RID ci = get_canvas_item(); + AnimationTreePlayer::NodeType type=anim_tree->node_get_type(p_node); + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Ref<Font> font = get_font("font","PopupMenu"); + Color font_color = get_color("font_color","PopupMenu"); + Color font_color_title = get_color("font_color_hover","PopupMenu"); + font_color_title.a*=0.8; + Ref<Texture> slot_icon = get_icon("NodeRealSlot","EditorIcons"); + + + Size2 size=get_node_size(p_node); + Point2 pos = anim_tree->node_get_pos(p_node); + if (click_type==CLICK_NODE && click_node==p_node) { + + pos+=click_motion-click_pos; + if (pos.x<5) + pos.x=5; + if (pos.y<5) + pos.y=5; + + } + + pos-=Point2(h_scroll->get_val(),v_scroll->get_val()); + + style->draw(ci,Rect2(pos,size)); + + float w = size.width-style->get_minimum_size().width; + float h = font->get_height()+get_constant("vseparation","PopupMenu"); + + Point2 ofs=style->get_offset()+pos; + Point2 ascofs(0,font->get_ascent()); + + Color bx = font_color_title; + bx.a*=0.1; + draw_rect(Rect2(ofs,Size2(size.width-style->get_minimum_size().width,font->get_height())),bx); + font->draw_halign(ci,ofs+ascofs,HALIGN_CENTER,w,String(_node_type_names[type]),font_color_title); + + ofs.y+=h; + font->draw_halign(ci,ofs+ascofs,HALIGN_CENTER,w,p_node,font_color); + ofs.y+=h; + + int count=2; // title and name + int inputs = anim_tree->node_get_input_count(p_node); + count += inputs?inputs:1; + + float icon_h_ofs = Math::floor(( font->get_height()-slot_icon->get_height())/2.0 )+1; + + if (type!=AnimationTreePlayer::NODE_OUTPUT) + slot_icon->draw(ci,ofs+Point2(w,icon_h_ofs)); //output + + if (inputs) { + for(int i=0;i<inputs;i++) { + + slot_icon->draw(ci,ofs+Point2(-slot_icon->get_width(),icon_h_ofs)); + String text; + switch(type) { + + case AnimationTreePlayer::NODE_TIMESCALE: + case AnimationTreePlayer::NODE_TIMESEEK: text="in"; break; + case AnimationTreePlayer::NODE_OUTPUT: text="out"; break; + case AnimationTreePlayer::NODE_ANIMATION: break; + case AnimationTreePlayer::NODE_ONESHOT: text=(i==0?"in":"add"); break; + case AnimationTreePlayer::NODE_BLEND2: + case AnimationTreePlayer::NODE_MIX: text=(i==0?"a":"b"); break; + case AnimationTreePlayer::NODE_BLEND3: + switch(i) { + case 0: text="b-"; break; + case 1: text="a"; break; + case 2: text="b+"; break; + + } + break; + + + case AnimationTreePlayer::NODE_BLEND4: + switch(i) { + case 0: text="a0"; break; + case 1: text="b0"; break; + case 2: text="a1"; break; + case 3: text="b1"; break; + } + break; + + case AnimationTreePlayer::NODE_TRANSITION: + text=itos(i); + if (anim_tree->transition_node_has_input_auto_advance(p_node,i)) + text+="->"; + + break; + default: {} + } + font->draw(ci,ofs+ascofs+Point2(3,0),text,font_color); + + ofs.y+=h; + } + } else { + ofs.y+=h; + } + + Ref<StyleBox> pg_bg=get_stylebox("bg","ProgressBar"); + Ref<StyleBox> pg_fill=get_stylebox("fill","ProgressBar"); + Rect2 pg_rect(ofs,Size2(w,h)); + + bool editable=true; + switch(type) { + case AnimationTreePlayer::NODE_ANIMATION: { + + Ref<Animation> anim = anim_tree->animation_node_get_animation(p_node); + String text; + if (anim_tree->animation_node_get_master_animation(p_node)!="") + text=anim_tree->animation_node_get_master_animation(p_node); + else if (anim.is_null()) + text="load.."; + else + text=anim->get_name(); + + font->draw_halign(ci,ofs+ascofs,HALIGN_CENTER,w,text,font_color_title); + + } break; + case AnimationTreePlayer::NODE_ONESHOT: + case AnimationTreePlayer::NODE_MIX: + case AnimationTreePlayer::NODE_BLEND2: + case AnimationTreePlayer::NODE_BLEND3: + case AnimationTreePlayer::NODE_BLEND4: + case AnimationTreePlayer::NODE_TIMESCALE: + case AnimationTreePlayer::NODE_TRANSITION: { + + font->draw_halign(ci,ofs+ascofs,HALIGN_CENTER,w,"edit..",font_color_title); + } break; + default: editable=false; + } + + if (editable) { + + Ref<Texture> arrow = get_icon("arrow","Tree"); + Point2 arrow_ofs( w-arrow->get_width(),Math::floor( (h-arrow->get_height())/2) ); + arrow->draw(ci,ofs+arrow_ofs); + } +} + +#if 0 +void AnimationTreeEditor::_node_param_changed() { + +// anim_tree->node_set_param( click_node,property_editor->get_variant() ); +// update(); +// _write_anim_tree_graph(); +} +#endif + +AnimationTreeEditor::ClickType AnimationTreeEditor::_locate_click(const Point2& p_click,StringName *p_node_id,int *p_slot_index) const { + + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Ref<Font> font = get_font("font","PopupMenu"); + Color font_color = get_color("font_color","PopupMenu"); + + float h = (font->get_height()+get_constant("vseparation","PopupMenu")); + + for(const List<StringName>::Element *E=order.back();E;E=E->prev()) { + + StringName node = E->get(); + + AnimationTreePlayer::NodeType type=anim_tree->node_get_type(node); + + Point2 pos = anim_tree->node_get_pos(node); + Size2 size = get_node_size(node); + + pos-=Point2(h_scroll->get_val(),v_scroll->get_val()); + + if (!Rect2(pos,size).has_point(p_click)) + continue; + + if (p_node_id) + *p_node_id=node; + + pos=p_click-pos; + + float y = pos.y-style->get_offset().height; + + if (y<h) + return CLICK_NODE; + y-=h; + + if (y<h) + return CLICK_NODE; + + y-=h; + + int count=0; // title and name + int inputs = anim_tree->node_get_input_count(node); + count += inputs?inputs:1; + + for(int i=0;i<count;i++) { + + if (y<h) { + + if (inputs==0 || ( type!=AnimationTreePlayer::NODE_OUTPUT && pos.x > size.width/2)) { + + if (p_slot_index) + *p_slot_index=0; + return CLICK_OUTPUT_SLOT; + } else { + + if (p_slot_index) + *p_slot_index=i; + return CLICK_INPUT_SLOT; + } + } + y-=h; + } + + return (type!=AnimationTreePlayer::NODE_OUTPUT && type!=AnimationTreePlayer::NODE_TIMESEEK)?CLICK_PARAMETER:CLICK_NODE; + } + + return CLICK_NONE; +} + +Point2 AnimationTreeEditor::_get_slot_pos(const StringName& p_node,bool p_input,int p_slot) { + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Ref<Font> font = get_font("font","PopupMenu"); + Ref<Texture> slot_icon = get_icon("NodeRealSlot","EditorIcons"); + + Size2 size=get_node_size(p_node); + Point2 pos = anim_tree->node_get_pos(p_node); + + if (click_type==CLICK_NODE && click_node==p_node) { + + pos+=click_motion-click_pos; + if (pos.x<5) + pos.x=5; + if (pos.y<5) + pos.y=5; + + } + + pos-=Point2(h_scroll->get_val(),v_scroll->get_val()); + + + float w = size.width-style->get_minimum_size().width; + float h = font->get_height()+get_constant("vseparation","PopupMenu"); + + + pos+=style->get_offset(); + + pos.y+=h*2; + + pos.y+=h*p_slot; + + pos+=Point2( -slot_icon->get_width()/2.0, h/2.0).floor(); + + if(!p_input) { + pos.x+=w+slot_icon->get_width(); + + } + + return pos; + +} + +#if 0 +void AnimationTreeEditor::_node_edit_property(const StringName& p_node) { + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Size2 size = get_node_size(p_node); + Point2 pos = Point2( anim_tree->node_get_pos_x(p_node), anim_tree->node_get_pos_y(p_node) )-offset; + + VisualServer::AnimationTreeNodeType type=anim_tree->node_get_type(p_node); + + PropertyInfo ph = VisualServer::get_singleton()->anim_tree_node_get_type_info(type); + if (ph.type==Variant::NIL) + return; + if (ph.type==Variant::_RID) + ph.type=Variant::RESOURCE; + + property_editor->edit(NULL,ph.name,ph.type,anim_tree->node_get_param(p_node),ph.hint,ph.hint_string); + + Point2 popup_pos=Point2( pos.x+(size.width-property_editor->get_size().width)/2.0,pos.y+(size.y-style->get_margin(MARGIN_BOTTOM))).floor(); + popup_pos+=get_global_pos(); + property_editor->set_pos(popup_pos); + + property_editor->popup(); + +} +#endif + +void AnimationTreeEditor::_input_event(InputEvent p_event) { + + switch(p_event.type) { + + case InputEvent::MOUSE_BUTTON: { + + if (p_event.mouse_button.pressed) { + + + if (p_event.mouse_button.button_index==1) { + click_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + click_motion=click_pos; + click_type = _locate_click(click_pos,&click_node,&click_slot); + if( click_type!=CLICK_NONE) { + + order.erase(click_node); + order.push_back(click_node); + update(); + } + + switch(click_type) { + case CLICK_INPUT_SLOT: { + click_pos=_get_slot_pos(click_node,true,click_slot); + } break; + case CLICK_OUTPUT_SLOT: { + click_pos=_get_slot_pos(click_node,false,click_slot); + } break; + case CLICK_PARAMETER: { + + edited_node=click_node; + renaming_edit=false; + _popup_edit_dialog(); + //open editor + // _node_edit_property(click_node); + } break; + default:{} + } + } + if (p_event.mouse_button.button_index==2) { + + if (click_type!=CLICK_NONE) { + click_type=CLICK_NONE; + update(); + } else { + // try to disconnect/remove + + Point2 rclick_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + rclick_type = _locate_click(rclick_pos,&rclick_node,&rclick_slot); + if (rclick_type==CLICK_INPUT_SLOT || rclick_type==CLICK_OUTPUT_SLOT) { + + node_popup->clear(); + node_popup->add_item("Disconnect",NODE_DISCONNECT); + if (anim_tree->node_get_type(rclick_node)==AnimationTreePlayer::NODE_TRANSITION) { + node_popup->add_item("Add Input",NODE_ADD_INPUT); + if (rclick_type==CLICK_INPUT_SLOT) { + if (anim_tree->transition_node_has_input_auto_advance(rclick_node,rclick_slot)) + node_popup->add_item("Clear Auto-Advance",NODE_CLEAR_AUTOADVANCE); + else + node_popup->add_item("Set Auto-Advance",NODE_SET_AUTOADVANCE); + node_popup->add_item("Delete Input",NODE_DELETE_INPUT); + + } + } + + node_popup->set_pos(rclick_pos+get_global_pos()); + node_popup->popup(); + + } + + if (rclick_type==CLICK_NODE) { + node_popup->clear(); + node_popup->add_item("Rename",NODE_RENAME); + node_popup->add_item("Remove",NODE_ERASE); + if (anim_tree->node_get_type(rclick_node)==AnimationTreePlayer::NODE_TRANSITION) + node_popup->add_item("Add Input",NODE_ADD_INPUT); + node_popup->set_pos(rclick_pos+get_global_pos()); + node_popup->popup(); + } + + + } + } + } else { + + if (p_event.mouse_button.button_index==1 && click_type!=CLICK_NONE) { + + switch(click_type) { + case CLICK_INPUT_SLOT: + case CLICK_OUTPUT_SLOT: { + + Point2 dst_click_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + StringName id; + int slot; + ClickType dst_click_type = _locate_click(dst_click_pos,&id,&slot); + + if (dst_click_type==CLICK_INPUT_SLOT && click_type==CLICK_OUTPUT_SLOT) { + + anim_tree->connect(click_node,id,slot); + + } + if (click_type==CLICK_INPUT_SLOT && dst_click_type==CLICK_OUTPUT_SLOT) { + + anim_tree->connect(id,click_node,click_slot); + } + + } break; + case CLICK_NODE: { + Point2 new_pos = anim_tree->node_get_pos(click_node)+(click_motion-click_pos); + if (new_pos.x<5) + new_pos.x=5; + if (new_pos.y<5) + new_pos.y=5; + anim_tree->node_set_pos(click_node,new_pos); + + } break; + default: {} + } + + click_type=CLICK_NONE; + update(); + } + } + } + + case InputEvent::MOUSE_MOTION: { + + if (p_event.mouse_motion.button_mask&1 && click_type!=CLICK_NONE) { + + click_motion=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + update(); + } + if ((p_event.mouse_motion.button_mask&4 || Input::get_singleton()->is_key_pressed(KEY_SPACE))) { + + h_scroll->set_val( h_scroll->get_val() - p_event.mouse_motion.relative_x ); + v_scroll->set_val( v_scroll->get_val() - p_event.mouse_motion.relative_y ); + update(); + } + + } break; + } + +} + + +void AnimationTreeEditor::_draw_cos_line(const Vector2& p_from, const Vector2& p_to,const Color& p_color) { + + static const int steps = 20; + + Rect2 r; + r.pos=p_from; + r.expand_to(p_to); + Vector2 sign=Vector2((p_from.x < p_to.x) ? 1 : -1,(p_from.y < p_to.y) ? 1 : -1); + bool flip = sign.x * sign.y < 0; + + Vector2 prev; + for(int i=0;i<=steps;i++) { + + float d = i/float(steps); + float c=-Math::cos(d*Math_PI) * 0.5+0.5; + if (flip) + c=1.0-c; + Vector2 p = r.pos+Vector2(d*r.size.width,c*r.size.height); + + if (i>0) { + + draw_line(prev,p,p_color,2); + } + + prev=p; + } +} + +void AnimationTreeEditor::_notification(int p_what) { + + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + play_button->set_icon( get_icon("Play","EditorIcons") ); + add_menu->set_icon( get_icon("Add","EditorIcons") ); + } break; + case NOTIFICATION_DRAW: { + + + _update_scrollbars(); + //VisualServer::get_singleton()->canvas_item_add_rect(get_canvas_item(),Rect2(Point2(),get_size()),Color(0,0,0,1)); + get_stylebox("bg","Tree")->draw(get_canvas_item(),Rect2(Point2(),get_size())); + VisualServer::get_singleton()->canvas_item_set_clip(get_canvas_item(),true); + + for(List<StringName>::Element *E=order.front();E;E=E->next()) { + + _draw_node(E->get()); + } + + if (click_type==CLICK_INPUT_SLOT || click_type==CLICK_OUTPUT_SLOT) { + + _draw_cos_line(click_pos,click_motion,Color(0.5,1,0.5,0.8)); + } + + List<AnimationTreePlayer::Connection> connections; + anim_tree->get_connection_list(&connections); + + for(List<AnimationTreePlayer::Connection>::Element *E=connections.front();E;E=E->next()) { + + const AnimationTreePlayer::Connection &c=E->get(); + Point2 source = _get_slot_pos(c.src_node,false,0); + Point2 dest = _get_slot_pos(c.dst_node,true,c.dst_input); + Color col = Color(1,1,0.5,0.8); +/* + if (click_type==CLICK_NODE && click_node==c.src_node) { + + source+=click_motion-click_pos; + } + + if (click_type==CLICK_NODE && click_node==c.dst_node) { + + dest+=click_motion-click_pos; + }*/ + + _draw_cos_line(source,dest,col); + + } + + switch(anim_tree->get_last_error()) { + + case AnimationTreePlayer::CONNECT_OK: { + + Ref<Font> f = get_font("font","Label"); + f->draw(get_canvas_item(),Point2(5,25+f->get_ascent()),"Animation Tree is Valid.",Color(0,1,0.6,0.8)); + } break; + default: { + + Ref<Font> f = get_font("font","Label"); + f->draw(get_canvas_item(),Point2(5,25+f->get_ascent()),"Animation Tree is Invalid.",Color(1,0.6,0.0,0.8)); + } break; + } + + } break; + } + +} + +void AnimationTreeEditor::_update_scrollbars() { + + Size2 size = get_size(); + Size2 hmin = h_scroll->get_combined_minimum_size(); + Size2 vmin = v_scroll->get_combined_minimum_size(); + + v_scroll->set_begin( Point2(size.width - vmin.width, 0) ); + v_scroll->set_end( Point2(size.width, size.height) ); + + h_scroll->set_begin( Point2( 0, size.height - hmin.height) ); + h_scroll->set_end( Point2(size.width-vmin.width, size.height) ); + + + Size2 min = _get_maximum_size(); + + if (min.height < size.height - hmin.height) { + + v_scroll->hide(); + offset.y=0; + } else { + + v_scroll->show(); + v_scroll->set_max(min.height); + v_scroll->set_page(size.height - hmin.height); + offset.y=v_scroll->get_val(); + } + + if (min.width < size.width - vmin.width) { + + h_scroll->hide(); + offset.x=0; + } else { + + h_scroll->show(); + h_scroll->set_max(min.width); + h_scroll->set_page(size.width - vmin.width); + offset.x=h_scroll->get_val(); + } +} + +void AnimationTreeEditor::_scroll_moved(float) { + + offset.x=h_scroll->get_val(); + offset.y=v_scroll->get_val(); + update(); +} + + +void AnimationTreeEditor::_node_menu_item(int p_item) { + + switch(p_item) { + + case NODE_DISCONNECT: { + + if (rclick_type==CLICK_INPUT_SLOT) { + + anim_tree->disconnect(rclick_node,rclick_slot); + update(); + } + + if (rclick_type==CLICK_OUTPUT_SLOT) { + + + List<AnimationTreePlayer::Connection> connections; + anim_tree->get_connection_list(&connections); + + for(List<AnimationTreePlayer::Connection>::Element *E=connections.front();E;E=E->next()) { + + const AnimationTreePlayer::Connection &c=E->get(); + if( c.dst_node==rclick_node) { + + anim_tree->disconnect(c.dst_node,c.dst_input); + } + } + update(); + } + + } break; + case NODE_RENAME: { + + renaming_edit=true; + edited_node=rclick_node; + _popup_edit_dialog(); + + } break; + case NODE_ADD_INPUT: { + + anim_tree->transition_node_set_input_count(rclick_node, anim_tree->transition_node_get_input_count(rclick_node)+1); + update(); + } break; + case NODE_DELETE_INPUT: { + + anim_tree->transition_node_delete_input(rclick_node, rclick_slot); + update(); + } break; + case NODE_SET_AUTOADVANCE: { + + anim_tree->transition_node_set_input_auto_advance(rclick_node,rclick_slot,true); + update(); + + } break; + case NODE_CLEAR_AUTOADVANCE: { + + anim_tree->transition_node_set_input_auto_advance(rclick_node,rclick_slot,false); + update(); + + } break; + + case NODE_ERASE: { + + if (rclick_node=="out") + break; + order.erase(rclick_node); + anim_tree->remove_node(rclick_node); + update(); + } break; + } +} + +StringName AnimationTreeEditor::_add_node(int p_item) { + + static const char* bname[] = { + "out", + "anim", + "oneshot", + "mix", + "blend2", + "blend3", + "blend4", + "scale", + "seek", + "transition" + }; + + String name; + int idx=1; + + while(true) { + + name = bname[p_item]; + if (idx>1) + name+=" "+itos(idx); + if (anim_tree->node_exists(name)) + idx++; + else + break; + } + + + anim_tree->add_node((AnimationTreePlayer::NodeType)p_item,name); + anim_tree->node_set_pos(name,Point2(last_x,last_y)); + order.push_back(name); + last_x+=10; + last_y+=10; + last_x=last_x % (int)get_size().width; + last_y=last_y % (int)get_size().height; + update(); + + return name; +}; + +void AnimationTreeEditor::_file_dialog_selected(String p_path) { + + switch (file_op) { + + case MENU_IMPORT_ANIMATIONS: { + Vector<String> files = file_dialog->get_selected_files(); + + for (int i=0; i<files.size(); i++) { + + StringName node = _add_node(AnimationTreePlayer::NODE_ANIMATION); + + RES anim = ResourceLoader::load(files[i]); + anim_tree->animation_node_set_animation(node,anim); + //anim_tree->node_set_name(node, files[i].get_file()); + }; + } break; + + default: + break; + }; +}; + +void AnimationTreeEditor::_add_menu_item(int p_item) { + + if (p_item==MENU_GRAPH_CLEAR) { + + //clear + } else if (p_item == MENU_IMPORT_ANIMATIONS) { + + file_op = MENU_IMPORT_ANIMATIONS; + file_dialog->set_mode(FileDialog::MODE_OPEN_FILE); + file_dialog->popup_centered_ratio(); + + } else { + + _add_node(p_item); + } +} + +Size2 AnimationTreeEditor::get_minimum_size() const { + + return Size2(10,200); +} + +void AnimationTreeEditor::_find_paths_for_filter(const StringName& p_node,Set<String>& paths) { + + ERR_FAIL_COND( !anim_tree->node_exists(p_node) ); + + for(int i=0;i<anim_tree->node_get_input_count(p_node);i++) { + + StringName port = anim_tree->node_get_input_source(p_node,i); + if (port==StringName()) + continue; + _find_paths_for_filter(port,paths); + } + + if (anim_tree->node_get_type(p_node)==AnimationTreePlayer::NODE_ANIMATION) { + + Ref<Animation> anim = anim_tree->animation_node_get_animation(p_node); + if (anim.is_valid()) { + + for(int i=0;i<anim->get_track_count();i++) { + paths.insert(anim->track_get_path(i)); + } + } + } +} + + +void AnimationTreeEditor::_filter_edited() { + + + TreeItem *ed = filter->get_edited(); + if (!ed) + return; + + if (anim_tree->node_get_type(edited_node)==AnimationTreePlayer::NODE_ONESHOT) { + anim_tree->oneshot_node_set_filter_path(edited_node,ed->get_metadata(0),ed->is_checked(0)); + } else if (anim_tree->node_get_type(edited_node)==AnimationTreePlayer::NODE_BLEND2) { + anim_tree->blend2_node_set_filter_path(edited_node,ed->get_metadata(0),ed->is_checked(0)); + } + +} + +void AnimationTreeEditor::_edit_filters() { + + filter_dialog->popup_centered_ratio(); + filter->clear(); + + Set<String> npb; + _find_paths_for_filter(edited_node,npb); + + TreeItem *root = filter->create_item(); + filter->set_hide_root(true); + Map<String,TreeItem*> pm; + + Node *base = anim_tree->get_node( anim_tree->get_base_path() ); + + for(Set<String>::Element *E=npb.front();E;E=E->next()) { + + TreeItem *parent=root; + String descr=E->get(); + if (base) { + NodePath np = E->get(); + + if (np.get_property()!=StringName()) { + Node *n = base->get_node(np); + Skeleton *s = n->cast_to<Skeleton>(); + if (s) { + + String skelbase = E->get().substr(0,E->get().find(":")); + + + int bidx = s->find_bone(np.get_property()); + + if (bidx!=-1) { + int bparent = s->get_bone_parent(bidx); + // + if (bparent!=-1) { + + + String bpn = skelbase+":"+s->get_bone_name(bparent); + if (pm.has(bpn)) { + parent=pm[bpn]; + descr=np.get_property(); + } + } else { + + if (pm.has(skelbase)) { + parent=pm[skelbase]; + + } + } + } + } + } + } + + TreeItem *it = filter->create_item(parent); + it->set_cell_mode(0,TreeItem::CELL_MODE_CHECK); + it->set_text(0,descr); + it->set_metadata(0,NodePath(E->get())); + it->set_editable(0,true); + if (anim_tree->node_get_type(edited_node)==AnimationTreePlayer::NODE_ONESHOT) { + it->set_checked(0, anim_tree->oneshot_node_is_path_filtered(edited_node,E->get())); + } else if (anim_tree->node_get_type(edited_node)==AnimationTreePlayer::NODE_BLEND2) { + it->set_checked(0, anim_tree->blend2_node_is_path_filtered(edited_node,E->get())); + } + pm[E->get()]=it; + } + + +} + +void AnimationTreeEditor::_bind_methods() { + + ObjectTypeDB::bind_method( "_add_menu_item", &AnimationTreeEditor::_add_menu_item ); + ObjectTypeDB::bind_method( "_node_menu_item", &AnimationTreeEditor::_node_menu_item ); + ObjectTypeDB::bind_method( "_input_event", &AnimationTreeEditor::_input_event ); +// ObjectTypeDB::bind_method( "_node_param_changed", &AnimationTreeEditor::_node_param_changed ); + ObjectTypeDB::bind_method( "_scroll_moved", &AnimationTreeEditor::_scroll_moved ); + ObjectTypeDB::bind_method( "_edit_dialog_changeds", &AnimationTreeEditor::_edit_dialog_changeds ); + ObjectTypeDB::bind_method( "_edit_dialog_changede", &AnimationTreeEditor::_edit_dialog_changede ); + ObjectTypeDB::bind_method( "_edit_dialog_changedf", &AnimationTreeEditor::_edit_dialog_changedf ); + ObjectTypeDB::bind_method( "_edit_dialog_changed", &AnimationTreeEditor::_edit_dialog_changed ); + ObjectTypeDB::bind_method( "_edit_dialog_animation_changed", &AnimationTreeEditor::_edit_dialog_animation_changed ); + ObjectTypeDB::bind_method( "_edit_dialog_edit_animation", &AnimationTreeEditor::_edit_dialog_edit_animation ); + ObjectTypeDB::bind_method( "_play_toggled", &AnimationTreeEditor::_play_toggled ); + ObjectTypeDB::bind_method( "_edit_oneshot_start", &AnimationTreeEditor::_edit_oneshot_start ); + ObjectTypeDB::bind_method( "_file_dialog_selected", &AnimationTreeEditor::_file_dialog_selected); + ObjectTypeDB::bind_method( "_master_anim_menu_item", &AnimationTreeEditor::_master_anim_menu_item); + ObjectTypeDB::bind_method( "_edit_filters", &AnimationTreeEditor::_edit_filters); + ObjectTypeDB::bind_method( "_filter_edited", &AnimationTreeEditor::_filter_edited); + +} + +AnimationTreeEditor::AnimationTreeEditor() { + + set_focus_mode(FOCUS_ALL); + + PopupMenu *p; + List<PropertyInfo> defaults; + + add_menu = memnew( MenuButton ); + //add_menu->set_ + add_menu->set_pos( Point2( 0,0) ); + add_menu->set_size( Point2( 25,15) ); + add_child( add_menu ); + + p=add_menu->get_popup(); + p->add_item("Animation Node",AnimationTreePlayer::NODE_ANIMATION); + p->add_item("OneShot Node",AnimationTreePlayer::NODE_ONESHOT); + p->add_item("Mix Node",AnimationTreePlayer::NODE_MIX); + p->add_item("Blend2 Node",AnimationTreePlayer::NODE_BLEND2); + p->add_item("Blend3 Node",AnimationTreePlayer::NODE_BLEND3); + p->add_item("Blend4 Node",AnimationTreePlayer::NODE_BLEND4); + p->add_item("TimeScale Node",AnimationTreePlayer::NODE_TIMESCALE); + p->add_item("TimeSeek Node",AnimationTreePlayer::NODE_TIMESEEK); + p->add_item("Transition Node",AnimationTreePlayer::NODE_TRANSITION); + p->add_separator(); + p->add_item("Import Animations...", MENU_IMPORT_ANIMATIONS); // wtf + p->add_separator(); + p->add_item("Clear",MENU_GRAPH_CLEAR); + + p->connect("item_pressed", this,"_add_menu_item"); + + play_button = memnew(Button); + play_button->set_pos(Point2(25,0)); + play_button->set_size(Point2(25,15)); + add_child(play_button); + play_button->set_toggle_mode(true); + play_button->connect("pressed", this,"_play_toggled"); + + + + + + last_x=50; + last_y=50; + + property_editor = memnew( CustomPropertyEditor ); + add_child(property_editor); + property_editor->connect("variant_changed", this,"_edit_dialog_animation_changed"); + property_editor->connect("resource_edit_request", this, "_edit_dialog_edit_animation"); + + h_scroll = memnew( HScrollBar ); + v_scroll = memnew( VScrollBar ); + + add_child(h_scroll); + add_child(v_scroll); + + h_scroll->connect("value_changed", this,"_scroll_moved"); + v_scroll->connect("value_changed", this,"_scroll_moved"); + + node_popup= memnew(PopupMenu ); + add_child(node_popup); + node_popup->set_as_toplevel(true); + + master_anim_popup = memnew( PopupMenu ); + add_child(master_anim_popup); + master_anim_popup->connect("item_pressed",this,"_master_anim_menu_item"); + + + node_popup->connect("item_pressed", this,"_node_menu_item"); + + updating_edit=false; + + edit_dialog = memnew( PopupPanel ); +// edit_dialog->get_ok()->hide(); +// edit_dialog->get_cancel()->hide(); + add_child(edit_dialog); + + edit_option = memnew( OptionButton ); + edit_option->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + edit_option->set_margin(MARGIN_RIGHT, 10); + edit_dialog->add_child(edit_option); + edit_option->connect("item_selected", this,"_edit_dialog_changedf"); + edit_option->hide(); + + + for(int i=0;i<2;i++) { + edit_scroll[i] = memnew ( HSlider ); + edit_scroll[i]->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + edit_scroll[i]->set_margin(MARGIN_RIGHT, 10); + edit_dialog->add_child(edit_scroll[i]); + edit_scroll[i]->hide(); + edit_scroll[i]->connect("value_changed", this,"_edit_dialog_changedf"); + } + for(int i=0;i<4;i++) { + edit_line[i] = memnew ( LineEdit ); + edit_line[i]->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + edit_line[i]->set_margin(MARGIN_RIGHT, 10); + edit_dialog->add_child(edit_line[i]); + edit_line[i]->hide(); + edit_line[i]->connect("text_changed", this,"_edit_dialog_changeds"); + edit_line[i]->connect("text_entered", this,"_edit_dialog_changede"); + edit_label[i] = memnew ( Label ); + edit_dialog->add_child(edit_label[i]); + edit_label[i]->hide(); + } + + edit_button = memnew( Button ); + edit_button->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + edit_button->set_margin(MARGIN_RIGHT, 10); + edit_dialog->add_child(edit_button); + edit_button->hide();; + edit_button->connect("pressed", this,"_edit_oneshot_start"); + + edit_check = memnew( CheckButton ); + edit_check->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + edit_check->set_margin(MARGIN_RIGHT, 10); + edit_dialog->add_child(edit_check); + edit_check->hide();; + edit_check->connect("pressed", this,"_edit_dialog_changed"); + + file_dialog = memnew( FileDialog ); + file_dialog->set_enable_multiple_selection(true); + file_dialog->set_current_dir(Globals::get_singleton()->get_resource_path()); + add_child(file_dialog); + file_dialog->connect("file_selected", this, "_file_dialog_selected"); + + filter_dialog = memnew( AcceptDialog ); + filter_dialog->set_title("Edit Node Filters"); + add_child(filter_dialog); + + filter = memnew( Tree ); + filter_dialog->add_child(filter); + filter_dialog->set_child_rect(filter); + filter->connect("item_edited",this,"_filter_edited"); + + filter_button = memnew( Button ); + filter_button->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + filter_button->set_margin(MARGIN_RIGHT, 10); + edit_dialog->add_child(filter_button); + filter_button->hide();; + filter_button->set_text("Filters.."); + filter_button->connect("pressed", this,"_edit_filters"); + +} + + +void AnimationTreeEditorPlugin::edit(Object *p_object) { + + anim_tree_editor->edit(p_object->cast_to<AnimationTreePlayer>()); + +} + +bool AnimationTreeEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("AnimationTreePlayer"); +} + +void AnimationTreeEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + editor->hide_animation_player_editors(); + editor->animation_panel_make_visible(true); + anim_tree_editor->show(); + anim_tree_editor->set_fixed_process(true); + EditorNode::get_top_split()->set_collapsed(false); + + } else { + + anim_tree_editor->hide(); + anim_tree_editor->set_fixed_process(false); + editor->animation_panel_make_visible(false); + EditorNode::get_top_split()->set_collapsed(true); + } +} + +AnimationTreeEditorPlugin::AnimationTreeEditorPlugin(EditorNode *p_node) { + + editor=p_node; + anim_tree_editor = memnew( AnimationTreeEditor ); + //editor->get_viewport()->add_child(anim_tree_editor); + //anim_tree_editor->set_area_as_parent_rect(); + editor->get_animation_panel()->add_child(anim_tree_editor); + anim_tree_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL); + anim_tree_editor->hide(); + + + + +} + + +AnimationTreeEditorPlugin::~AnimationTreeEditorPlugin() +{ +} + diff --git a/tools/editor/plugins/animation_tree_editor_plugin.h b/tools/editor/plugins/animation_tree_editor_plugin.h new file mode 100644 index 000000000..21b31863b --- /dev/null +++ b/tools/editor/plugins/animation_tree_editor_plugin.h @@ -0,0 +1,193 @@ +/*************************************************************************/ +/* animation_tree_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef ANIMATION_TREE_EDITOR_PLUGIN_H +#define ANIMATION_TREE_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/animation/animation_tree_player.h" +#include "scene/gui/tree.h" +#include "scene/gui/button.h" +#include "scene/gui/popup.h" +#include "tools/editor/property_editor.h" +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class AnimationTreeEditor : public Control { + + OBJ_TYPE(AnimationTreeEditor, Control ); + + static const char* _node_type_names[]; + + enum ClickType { + CLICK_NONE, + CLICK_NAME, + CLICK_NODE, + CLICK_INPUT_SLOT, + CLICK_OUTPUT_SLOT, + CLICK_PARAMETER + }; + + enum { + + MENU_GRAPH_CLEAR=100, + MENU_IMPORT_ANIMATIONS=101, + NODE_DISCONNECT, + NODE_RENAME, + NODE_ERASE, + NODE_ADD_INPUT, + NODE_DELETE_INPUT, + NODE_SET_AUTOADVANCE, + NODE_CLEAR_AUTOADVANCE + }; + + bool renaming_edit; + StringName edited_node; + bool updating_edit; + Popup *edit_dialog; + HSlider *edit_scroll[2]; + LineEdit *edit_line[4]; + OptionButton *edit_option; + Label *edit_label[4]; + Button *edit_button; + Button *filter_button; + CheckButton *edit_check; + FileDialog* file_dialog; + int file_op; + + void _popup_edit_dialog(); + + + void _setup_edit_dialog(const StringName& p_node); + PopupMenu *master_anim_popup; + PopupMenu *node_popup; + PopupMenu *add_popup; + HScrollBar *h_scroll; + VScrollBar *v_scroll; + MenuButton* add_menu; + + CustomPropertyEditor *property_editor; + + AnimationTreePlayer* anim_tree; + List<StringName> order; + Set<StringName> active_nodes; + + int last_x,last_y; + + Point2 offset; + ClickType click_type; + Point2 click_pos; + StringName click_node; + int click_slot; + Point2 click_motion; + ClickType rclick_type; + StringName rclick_node; + int rclick_slot; + + Button *play_button; + + Size2 _get_maximum_size(); + Size2 get_node_size(const StringName &p_node) const; + void _draw_node(const StringName& p_node); + + AcceptDialog *filter_dialog; + Tree *filter; + + + + void _draw_cos_line(const Vector2& p_from, const Vector2& p_to,const Color& p_color); + void _update_scrollbars(); + void _scroll_moved(float); + void _play_toggled(); +/* + void _node_param_changed(); + void _node_add_callback(); + void _node_add(VisualServer::AnimationTreeNodeType p_type); + void _node_edit_property(const StringName& p_node); +*/ + + void _master_anim_menu_item(int p_item); + void _node_menu_item(int p_item); + void _add_menu_item(int p_item); + + + void _filter_edited(); + void _find_paths_for_filter(const StringName& p_node,Set<String>& paths); + void _edit_filters(); + + + void _edit_oneshot_start(); + void _edit_dialog_animation_changed(); + void _edit_dialog_edit_animation(); + void _edit_dialog_changeds(String); + void _edit_dialog_changede(String); + void _edit_dialog_changedf(float); + void _edit_dialog_changed(); + void _dialog_changed() const; + ClickType _locate_click(const Point2& p_click,StringName *p_node_id,int *p_slot_index) const; + Point2 _get_slot_pos(const StringName& p_node_id,bool p_input,int p_slot); + + StringName _add_node(int p_item); + void _file_dialog_selected(String p_path); + + +protected: + void _notification(int p_what); + void _input_event(InputEvent p_event); + static void _bind_methods(); +public: + + + virtual Size2 get_minimum_size() const; + void edit(AnimationTreePlayer *p_player); + AnimationTreeEditor(); +}; + +class AnimationTreeEditorPlugin : public EditorPlugin { + + OBJ_TYPE( AnimationTreeEditorPlugin, EditorPlugin ); + + AnimationTreeEditor *anim_tree_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "AnimTree"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + AnimationTreeEditorPlugin(EditorNode *p_node); + ~AnimationTreeEditorPlugin(); + +}; + +#endif // ANIMATION_TREE_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/camera_editor_plugin.cpp b/tools/editor/plugins/camera_editor_plugin.cpp new file mode 100644 index 000000000..aa7562b17 --- /dev/null +++ b/tools/editor/plugins/camera_editor_plugin.cpp @@ -0,0 +1,151 @@ +/*************************************************************************/ +/* camera_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "camera_editor_plugin.h" +#include "spatial_editor_plugin.h" + + +void CameraEditor::_notification(int p_what) { + + switch(p_what) { + +/* case NOTIFICATION_PROCESS: { + + if (preview->is_pressed() && node) + node->call("make_current"); + + } break;*/ + } + +} +void CameraEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + SpatialEditor::get_singleton()->set_custom_camera(NULL); + hide(); + } + +} + +void CameraEditor::_pressed() { + + Node *sn = (node && preview->is_pressed())?node:NULL; + SpatialEditor::get_singleton()->set_custom_camera(sn); +} + +void CameraEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_pressed"),&CameraEditor::_pressed); + +} + +void CameraEditor::edit(Node *p_camera) { + + node=p_camera; + + if (!node) { + preview->set_pressed(false); + SpatialEditor::get_singleton()->set_custom_camera(NULL); + } else { + + if (preview->is_pressed()) + SpatialEditor::get_singleton()->set_custom_camera(p_camera); + else + SpatialEditor::get_singleton()->set_custom_camera(NULL); + } +} + + +CameraEditor::CameraEditor() { + + preview = memnew( Button ); + add_child(preview); + + preview->set_text("Preview"); + preview->set_toggle_mode(true); + preview->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); + preview->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + preview->set_margin(MARGIN_LEFT,60); + preview->set_margin(MARGIN_RIGHT,0); + preview->set_margin(MARGIN_TOP,0); + preview->set_margin(MARGIN_BOTTOM,10); + preview->connect("pressed",this,"_pressed"); + +} + + +void CameraEditorPlugin::edit(Object *p_object) { + + SpatialEditor::get_singleton()->set_can_preview(p_object->cast_to<Camera>()); + //camera_editor->edit(p_object->cast_to<Node>()); +} + +bool CameraEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Camera"); +} + +void CameraEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { +// SpatialEditor::get_singleton()->set_can_preview(p_object->cast_to<Camera>()); + + } else { + + SpatialEditor::get_singleton()->set_can_preview(NULL); + } + +} + +CameraEditorPlugin::CameraEditorPlugin(EditorNode *p_node) { + + editor=p_node; +/* camera_editor = memnew( CameraEditor ); + editor->get_viewport()->add_child(camera_editor); + + camera_editor->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); + camera_editor->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + camera_editor->set_margin(MARGIN_LEFT,60); + camera_editor->set_margin(MARGIN_RIGHT,0); + camera_editor->set_margin(MARGIN_TOP,0); + camera_editor->set_margin(MARGIN_BOTTOM,10); + + + camera_editor->hide(); +*/ + + +} + + +CameraEditorPlugin::~CameraEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/camera_editor_plugin.h b/tools/editor/plugins/camera_editor_plugin.h new file mode 100644 index 000000000..5529b32e5 --- /dev/null +++ b/tools/editor/plugins/camera_editor_plugin.h @@ -0,0 +1,79 @@ +/*************************************************************************/ +/* camera_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef CAMERA_EDITOR_PLUGIN_H +#define CAMERA_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/3d/camera.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class CameraEditor : public Control { + + OBJ_TYPE(CameraEditor, Control ); + + Panel *panel; + Button * preview; + Node *node; + + void _pressed(); +protected: + void _notification(int p_what); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + void edit(Node *p_camera); + CameraEditor(); +}; + +class CameraEditorPlugin : public EditorPlugin { + + OBJ_TYPE( CameraEditorPlugin, EditorPlugin ); + +// CameraEditor *camera_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Camera"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + CameraEditorPlugin(EditorNode *p_node); + ~CameraEditorPlugin(); + +}; + +#endif // CAMERA_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/canvas_item_editor_plugin.cpp b/tools/editor/plugins/canvas_item_editor_plugin.cpp new file mode 100644 index 000000000..514409240 --- /dev/null +++ b/tools/editor/plugins/canvas_item_editor_plugin.cpp @@ -0,0 +1,2308 @@ +/*************************************************************************/ +/* canvas_item_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "canvas_item_editor_plugin.h" +#include "print_string.h" +#include "tools/editor/editor_node.h" +#include "os/keyboard.h" +#include "scene/main/viewport.h" +#include "scene/main/canvas_layer.h" +#include "scene/2d/node_2d.h" +#include "globals.h" +#include "os/input.h" + +void CanvasItemEditor::_unhandled_key_input(const InputEvent& p_ev) { + + if (!is_visible()) + return; + if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode==KEY_Q) + _tool_select(TOOL_SELECT); + if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode==KEY_W) + _tool_select(TOOL_MOVE); + if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode==KEY_E) + _tool_select(TOOL_ROTATE); + if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode==KEY_V && drag==DRAG_ALL && can_move_pivot) + drag=DRAG_PIVOT; + +} + +void CanvasItemEditor::_tool_select(int p_index) { + + + ToolButton *tb[TOOL_MAX]={select_button,move_button,rotate_button}; + for(int i=0;i<TOOL_MAX;i++) { + + tb[i]->set_pressed(i==p_index); + } + + + viewport->update(); + tool=(Tool)p_index; + +} + +Object *CanvasItemEditor::_get_editor_data(Object *p_what) { + + CanvasItem *ci = p_what->cast_to<CanvasItem>(); + if (!ci) + return NULL; + + return memnew( CanvasItemEditorSelectedItem ); +} + +bool CanvasItemEditor::is_snap_active() const { + + return edit_menu->get_popup()->is_item_checked(edit_menu->get_popup()->get_item_index(SNAP_USE)); +} + +Dictionary CanvasItemEditor::get_state() const { + + Dictionary state; + state["zoom"]=zoom; + state["ofs"]=Point2(h_scroll->get_val(),v_scroll->get_val()); + state["pixel_snap"]=pixel_snap; +// state["ofs"]=-transform.get_origin(); + return state; +} +void CanvasItemEditor::set_state(const Dictionary& p_state){ + + Dictionary state=p_state; + if (state.has("zoom")) { + zoom=p_state["zoom"]; + } + + if (state.has("ofs")) { + _update_scrollbars(); // i wonder how safe is calling this here.. + Point2 ofs=p_state["ofs"]; + h_scroll->set_val(ofs.x); + v_scroll->set_val(ofs.y); + } + + if (state.has("pixel_snap")) { + pixel_snap=state["pixel_snap"]; + int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_PIXEL); + edit_menu->get_popup()->set_item_checked(idx,pixel_snap); + + + } +} + + +void CanvasItemEditor::_add_canvas_item(CanvasItem *p_canvas_item) { + + editor_selection->add_node(p_canvas_item); +#if 0 + if (canvas_items.has(p_canvas_item)) + return; + + canvas_items.insert(p_canvas_item,p_info); + p_canvas_item->connect("hide",this,"_visibility_changed",varray(p_canvas_item->get_instance_ID()),CONNECT_ONESHOT); +#endif +} + +void CanvasItemEditor::_remove_canvas_item(CanvasItem *p_canvas_item) { + + editor_selection->remove_node(p_canvas_item); +#if 0 + p_canvas_item->disconnect("hide",this,"_visibility_changed"); + canvas_items.erase(p_canvas_item); +#endif + +} +void CanvasItemEditor::_clear_canvas_items() { + + editor_selection->clear();; +#if 0 + while(canvas_items.size()) + _remove_canvas_item(canvas_items.front()->key()); +#endif +} + +void CanvasItemEditor::_visibility_changed(ObjectID p_canvas_item) { +#if 0 + Object *c = ObjectDB::get_instance(p_canvas_item); + if (!c) + return; + CanvasItem *ct = c->cast_to<CanvasItem>(); + if (!ct) + return; + canvas_items.erase(ct); + //_remove_canvas_item(ct); + update(); +#endif +} + + +void CanvasItemEditor::_node_removed(Node *p_node) { +#if 0 + CanvasItem *canvas_item = (CanvasItem*)p_node; //not a good cast, but safe + if (canvas_items.has(canvas_item)) + _remove_canvas_item(canvas_item); + + update(); +#endif +} + +void CanvasItemEditor::_keying_changed(bool p_changed) { + + if (p_changed) + animation_menu->show(); + else + animation_menu->hide(); +} + +// slow but modern computers should have no problem +CanvasItem* CanvasItemEditor::_select_canvas_item_at_pos(const Point2& p_pos,Node* p_node,const Matrix32& p_parent_xform,const Matrix32& p_canvas_xform) { + + if (!p_node) + return NULL; + if (p_node->cast_to<Viewport>()) + return NULL; + + CanvasItem *c=p_node->cast_to<CanvasItem>(); + + + for (int i=p_node->get_child_count()-1;i>=0;i--) { + + CanvasItem *r=NULL; + + if (c && !c->is_set_as_toplevel()) + r=_select_canvas_item_at_pos(p_pos,p_node->get_child(i),p_parent_xform * c->get_transform(),p_canvas_xform); + else { + CanvasLayer *cl = p_node->cast_to<CanvasLayer>(); + if (cl) + return NULL; + r=_select_canvas_item_at_pos(p_pos,p_node->get_child(i),transform ,cl ? cl->get_transform() : p_canvas_xform); //use base transform + } + + if (r) + return r; + } + + + if (c && c->is_visible() && !c->has_meta("_edit_lock_")) { + + Rect2 rect = c->get_item_rect(); + Point2 local_pos = (p_parent_xform * p_canvas_xform * c->get_transform()).affine_inverse().xform(p_pos); + + + if (rect.has_point(local_pos)) + return c; + + } + + return NULL; +} + + +void CanvasItemEditor::_find_canvas_items_at_rect(const Rect2& p_rect,Node* p_node,const Matrix32& p_parent_xform,const Matrix32& p_canvas_xform,List<CanvasItem*> *r_items) { + + if (!p_node) + return; + if (p_node->cast_to<Viewport>()) + return; + + CanvasItem *c=p_node->cast_to<CanvasItem>(); + + + for (int i=p_node->get_child_count()-1;i>=0;i--) { + + if (c && !c->is_set_as_toplevel()) + _find_canvas_items_at_rect(p_rect,p_node->get_child(i),p_parent_xform * c->get_transform(),p_canvas_xform,r_items); + else { + CanvasLayer *cl = p_node->cast_to<CanvasLayer>(); + if (cl) + return; + _find_canvas_items_at_rect(p_rect,p_node->get_child(i),transform,cl?cl->get_transform():p_canvas_xform,r_items); + } + } + + + if (c && c->is_visible() && !c->has_meta("_edit_lock_")) { + + Rect2 rect = c->get_item_rect(); + Matrix32 xform = p_parent_xform * p_canvas_xform * c->get_transform(); + + if ( p_rect.has_point( xform.xform( rect.pos ) ) && + p_rect.has_point( xform.xform( rect.pos+Vector2(rect.size.x,0) ) ) && + p_rect.has_point( xform.xform( rect.pos+Vector2(rect.size.x,rect.size.y) ) ) && + p_rect.has_point( xform.xform( rect.pos+Vector2(0,rect.size.y) ) ) ) { + + r_items->push_back(c); + + } + } + + +} + +void CanvasItemEditor::_key_move(const Vector2& p_dir, bool p_snap) { + + + if (drag!=DRAG_NONE) + return; + + if (editor_selection->get_selected_node_list().empty()) + return; + + undo_redo->create_action("Move Action",true); + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + if (canvas_item->has_meta("_edit_lock_")) + continue; + + + Vector2 drag = transform.affine_inverse().basis_xform(p_dir); + drag = canvas_item->get_global_transform_with_canvas().affine_inverse().basis_xform(drag); + + if (p_snap) + drag*=snap; + + undo_redo->add_undo_method(canvas_item,"edit_set_state",canvas_item->edit_get_state()); + Rect2 local_rect = canvas_item->get_item_rect(); + local_rect.pos+=drag; + //canvas_item->edit_set_rect(local_rect); + undo_redo->add_do_method(canvas_item,"edit_set_rect",local_rect); + + } + + undo_redo->commit_action(); +} + +Point2 CanvasItemEditor::_find_topleftmost_point() { + + + + Vector2 tl=Point2(1e10,1e10); + Rect2 r2; + r2.pos=tl; + + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + + + Rect2 rect=canvas_item->get_item_rect(); + Matrix32 xform=canvas_item->get_global_transform_with_canvas(); + + r2.expand_to(xform.xform(rect.pos)); + r2.expand_to(xform.xform(rect.pos+Vector2(rect.size.x,0))); + r2.expand_to(xform.xform(rect.pos+rect.size)); + r2.expand_to(xform.xform(rect.pos+Vector2(0,rect.size.y))); + + } + + return r2.pos; +} + + + +int CanvasItemEditor::get_item_count() { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + int ic=0; + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + ic++; + }; + + return ic; +} + +CanvasItem *CanvasItemEditor::get_single_item() { + + + Map<Node*,Object*> &selection = editor_selection->get_selection(); + + CanvasItem *single_item=NULL; + + for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + if (single_item) + return NULL; //morethan one + + single_item=canvas_item; + }; + + return single_item; +} + +CanvasItemEditor::DragType CanvasItemEditor::_find_drag_type(const Matrix32& p_xform, const Rect2& p_local_rect, const Point2& p_click, Vector2& r_point) { + + CanvasItem *canvas_item = get_single_item(); + + ERR_FAIL_COND_V(!canvas_item,DRAG_NONE); + + Rect2 rect=canvas_item->get_item_rect(); + Matrix32 xforml=canvas_item->get_global_transform_with_canvas(); + Matrix32 xform=transform * xforml; + + Vector2 endpoints[4]={ + + xform.xform(rect.pos), + xform.xform(rect.pos+Vector2(rect.size.x,0)), + xform.xform(rect.pos+rect.size), + xform.xform(rect.pos+Vector2(0,rect.size.y)) + }; + + Vector2 endpointsl[4]={ + + xforml.xform(rect.pos), + xforml.xform(rect.pos+Vector2(rect.size.x,0)), + xforml.xform(rect.pos+rect.size), + xforml.xform(rect.pos+Vector2(0,rect.size.y)) + }; + + DragType dragger[]={ + DRAG_TOP_LEFT, + DRAG_TOP, + DRAG_TOP_RIGHT, + DRAG_RIGHT, + DRAG_BOTTOM_RIGHT, + DRAG_BOTTOM, + DRAG_BOTTOM_LEFT, + DRAG_LEFT + }; + + float radius = (select_handle->get_size().width/2)*1.5; + + //try draggers + + for(int i=0;i<4;i++) { + + int prev = (i+3)%4; + int next = (i+1)%4; + + r_point=endpointsl[i]; + + Vector2 ofs = ((endpoints[i] - endpoints[prev]).normalized() + ((endpoints[i] - endpoints[next]).normalized())).normalized(); + ofs*=1.4144*(select_handle->get_size().width/2); + + ofs+=endpoints[i]; + + if (ofs.distance_to(p_click)<radius) + return dragger[i*2]; + + ofs = (endpoints[i]+endpoints[next])/2; + ofs += (endpoints[next]-endpoints[i]).tangent().normalized()*(select_handle->get_size().width/2); + + r_point=(endpointsl[i]+endpointsl[next])/2; + + + if (ofs.distance_to(p_click)<radius) + return dragger[i*2+1]; + + } + + /* + if (rect.has_point(xform.affine_inverse().xform(p_click))) { + r_point=_find_topleftmost_point(); + return DRAG_ALL; + }*/ + + //try draggers + + return DRAG_NONE; +} + +void CanvasItemEditor::incbeg(float& beg,float &end, float inc, float minsize,bool p_symmetric) { + + if (minsize<0) { + + beg+=inc; + if (p_symmetric) + end-=inc; + } else { + + if (p_symmetric) { + beg+=inc; + end-=inc; + if (end-beg < minsize) { + float center = (beg+end)/2.0; + beg=center-minsize/2.0; + end=center+minsize/2.0; + } + + } else { + if (end-(beg+inc) < minsize) + beg=end-minsize; + else + beg+=inc; + } + + } +} + +void CanvasItemEditor::incend(float &beg,float& end, float inc, float minsize,bool p_symmetric) { + + if (minsize<0) { + + end+=inc; + if (p_symmetric) + beg-=inc; + } else { + + if (p_symmetric) { + + end+=inc; + beg-=inc; + if (end-beg < minsize) { + float center = (beg+end)/2.0; + beg=center-minsize/2.0; + end=center+minsize/2.0; + } + + } else { + if ((end+inc)-beg < minsize) + end=beg+minsize; + else + end+=inc; + } + + } +} + +void CanvasItemEditor::_append_canvas_item(CanvasItem *c) { + + editor_selection->add_node(c); + +} + + +void CanvasItemEditor::_dialog_value_changed(double) { + + if (updating_value_dialog) + return; + + switch(last_option) { + + case SNAP_CONFIGURE: { + + snap=dialog_val->get_val(); + viewport->update(); + } break; + case ZOOM_SET: { + + zoom=dialog_val->get_val()/100.0; + _update_scroll(0); + viewport->update(); + + } break; + default:{} + } +} + +bool CanvasItemEditor::get_remove_list(List<Node*> *p_list) { + + + return false;//!p_list->empty(); +} + + +void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) { + + { + + EditorNode *en = editor; + EditorPlugin *over_plugin = en->get_editor_plugin_over(); + + if (over_plugin) { + bool discard = over_plugin->forward_input_event(p_event); + if (discard) { + accept_event(); + return; + } + } + } + + + if (p_event.type==InputEvent::MOUSE_BUTTON) { + + const InputEventMouseButton &b=p_event.mouse_button; + + + if (b.button_index==BUTTON_WHEEL_DOWN) { + + zoom=zoom*0.95; + _update_scroll(0); + viewport->update(); + return; + } + + if (b.button_index==BUTTON_WHEEL_UP) { + + zoom=zoom*(1.0/0.95); + _update_scroll(0); + viewport->update(); + return; + } + + if (b.button_index==BUTTON_RIGHT) { + + if (get_item_count() > 0 && drag!=DRAG_NONE) { + //cancel drag + + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + canvas_item->edit_set_state(se->undo_state); + if (canvas_item->cast_to<Node2D>()) + canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot); + + } + + } else if (box_selecting) { + box_selecting=false; + viewport->update(); + } else if (b.pressed) { +#if 0 + ref_item = NULL; + Node* scene = get_scene()->get_root_node()->cast_to<EditorNode>()->get_edited_scene(); + if ( scene ) ref_item =_select_canvas_item_at_pos( Point2( b.x, b.y ), scene, transform ); +#endif + //popup->set_pos(Point2(b.x,b.y)); + //popup->popup(); + } + return; + } + //if (!canvas_items.size()) + // return; + + if (b.button_index!=BUTTON_LEFT || Input::get_singleton()->is_key_pressed(KEY_SPACE)) + return; + + if (!b.pressed) { + + if (drag!=DRAG_NONE) { + + if (undo_redo) { + + undo_redo->create_action("Edit CanvasItem"); + + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + Variant state=canvas_item->edit_get_state(); + undo_redo->add_do_method(canvas_item,"edit_set_state",state); + undo_redo->add_undo_method(canvas_item,"edit_set_state",se->undo_state); + if (canvas_item->cast_to<Node2D>()) { + Node2D *pvt = canvas_item->cast_to<Node2D>(); + if (pvt->edit_has_pivot()) { + undo_redo->add_do_method(canvas_item,"edit_set_pivot",pvt->edit_get_pivot()); + undo_redo->add_undo_method(canvas_item,"edit_set_pivot",se->undo_pivot); + } + } + } + undo_redo->commit_action(); + } + + drag=DRAG_NONE; + viewport->update(); + can_move_pivot=false; + + } + + if (box_selecting) { +#if 0 + if ( ! b.mod.shift ) _clear_canvas_items(); + if ( box_selection_end() ) return; +#endif + + Node* scene = editor->get_edited_scene(); + if (scene) { + + List<CanvasItem*> selitems; + + Point2 bsfrom = transform.xform(drag_from); + Point2 bsto= transform.xform(box_selecting_to); + if (bsfrom.x>bsto.x) + SWAP(bsfrom.x,bsto.x); + if (bsfrom.y>bsto.y) + SWAP(bsfrom.y,bsto.y); + + _find_canvas_items_at_rect(Rect2(bsfrom,bsto-bsfrom),scene,transform,Matrix32(),&selitems); + + for(List<CanvasItem*>::Element *E=selitems.front();E;E=E->next()) { + + _append_canvas_item(E->get()); + } + + } + + box_selecting=false; + viewport->update(); + + } + return; + } + + CanvasItem *single_item = get_single_item(); + + if (single_item) { + //try single canvas_item edit + + CanvasItem *canvas_item = single_item; + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + ERR_FAIL_COND(!se); + + + Point2 click(b.x,b.y); + + if ((b.mod.control && tool==TOOL_SELECT) || tool==TOOL_ROTATE) { + + drag=DRAG_ROTATE; + drag_from=transform.affine_inverse().xform(click); + se->undo_state=canvas_item->edit_get_state(); + if (canvas_item->cast_to<Node2D>()) + se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot(); + return; + } + + Matrix32 xform = transform * canvas_item->get_global_transform_with_canvas(); + Rect2 rect=canvas_item->get_item_rect(); + // float handle_radius = handle_len * 1.4144; //magic number, guess what it means! + + if (tool==TOOL_SELECT) { + drag = _find_drag_type(xform,rect,click,drag_point_from); + + if (b.doubleclick) { + + if (canvas_item->get_filename()!="" && canvas_item!=editor->get_edited_scene()) { + + editor->open_request(canvas_item->get_filename()); + return; + } + } + + if (drag!=DRAG_NONE) { + drag_from=transform.affine_inverse().xform(click); + se->undo_state=canvas_item->edit_get_state(); + if (canvas_item->cast_to<Node2D>()) + se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot(); + + return; + } + } else { + + drag=DRAG_NONE; + } + } + + //multi canvas_item edit + + + Point2 click=Point2(b.x,b.y); + + if ((b.mod.alt || tool==TOOL_MOVE) && get_item_count()) { + + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + se->undo_state=canvas_item->edit_get_state(); + if (canvas_item->cast_to<Node2D>()) + se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot(); + + } + + + drag=DRAG_ALL; + drag_from=transform.affine_inverse().xform(click); + drag_point_from=_find_topleftmost_point(); + viewport->update(); + return; + + } + + Node* scene = editor->get_edited_scene(); + if (!scene) + return; + + /* + if (current_window) { + //no window.... ? + click-=current_window->get_scroll(); + }*/ + CanvasItem *c=_select_canvas_item_at_pos(click, scene,transform,Matrix32()); + + + CanvasItem* cn = c; + + while(cn) { + if (cn->has_meta("_edit_group_")) { + c=cn; + } + cn=cn->get_parent_item(); + } + + Node* n = c; + + while ((n && n != scene && n->get_owner() != scene) || (n && !n->is_type("CanvasItem"))) { + n = n->get_parent(); + }; + c = n->cast_to<CanvasItem>(); +#if 0 + if ( b.pressed ) box_selection_start( click ); +#endif + if (b.mod.shift) { //additive selection + + if (!c) { + + drag_from=transform.affine_inverse().xform(click); + + box_selecting=true; + box_selecting_to=drag_from; + + return; //nothing to add + } + + if (editor_selection->is_selected(c)) { + //already in here, erase it + editor_selection->remove_node(c); + //_remove_canvas_item(c); + + viewport->update(); + return; + + } + _append_canvas_item(c); + viewport->update(); + } else { + //regular selection + + + + if (!c) { + //clear because nothing clicked + editor_selection->clear();; + + drag_from=transform.affine_inverse().xform(click); + + box_selecting=true; + box_selecting_to=drag_from; + viewport->update(); + return; + } + + if (!editor_selection->is_selected(c)) { + //select a new one and clear previous selection + editor_selection->clear(); + editor_selection->add_node(c); + //reselect + if (get_scene()->is_editor_hint()) { + editor->call("edit_node",c); + } + + } + + //prepare to move! + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + se->undo_state=canvas_item->edit_get_state(); + if (canvas_item->cast_to<Node2D>()) + se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot(); + + } + + drag=DRAG_ALL; + drag_from=transform.affine_inverse().xform(click); + drag_point_from=_find_topleftmost_point(); + viewport->update(); + + } + + } + + if (p_event.type==InputEvent::MOUSE_MOTION) { + + if (!viewport->has_focus()) + viewport->call_deferred("grab_focus"); + + const InputEventMouseMotion &m=p_event.mouse_motion; + + if (box_selecting) { + + box_selecting_to=transform.affine_inverse().xform(Point2(m.x,m.y)); + viewport->update(); + return; + + } + + + if (drag==DRAG_NONE) { + + + if (m.button_mask&BUTTON_MASK_MIDDLE || (m.button_mask&BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE))) { + + h_scroll->set_val( h_scroll->get_val() - m.relative_x/zoom); + v_scroll->set_val( v_scroll->get_val() - m.relative_y/zoom); + } + + return; + + } + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + canvas_item->edit_set_state(se->undo_state); //reset state and reapply + if (canvas_item->cast_to<Node2D>()) + canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot); + + + Vector2 dfrom = drag_from; + Vector2 dto = transform.affine_inverse().xform(Point2(m.x,m.y)); + if (canvas_item->has_meta("_edit_lock_")) + continue; + + + if (drag==DRAG_ROTATE) { + + Vector2 center = canvas_item->get_global_transform_with_canvas().get_origin(); + + Matrix32 rot; + rot.elements[1] = (dfrom - center).normalized(); + rot.elements[0] = rot.elements[1].tangent(); + float ang = rot.xform_inv(dto-center).atan2(); + canvas_item->edit_rotate(ang); + display_rotate_to = dto; + display_rotate_from = center; + + continue; + } + + if (pixel_snap || (is_snap_active() && snap>0)) { + + if (drag!=DRAG_ALL) { + dfrom=drag_point_from; + dto=snapify(dto); + } else { + + Vector2 newpos = drag_point_from + (dto-dfrom); + Vector2 disp; + if (!is_snap_active() || snap<1) { + + disp.x = Math::fposmod(newpos.x,1); + disp.y = Math::fposmod(newpos.y,1); + + } else { + disp.x = Math::fposmod(newpos.x,snap); + disp.y = Math::fposmod(newpos.y,snap); + } + dto-=disp; + } + } + + Vector2 drag_vector = + canvas_item->get_global_transform_with_canvas().affine_inverse().xform(dto) - + canvas_item->get_global_transform_with_canvas().affine_inverse().xform(dfrom); + + + Rect2 local_rect = canvas_item->get_item_rect(); + + if (false && drag!=DRAG_ALL && m.mod.alt) { + float aspect = local_rect.size.get_aspect(); + if (aspect!=0) { + if (ABS(drag_vector.x) > ABS(drag_vector.y)) { + + drag_vector.y = ABS(drag_vector.x)/aspect * SGN(drag_vector.y); + } else { + + drag_vector.x = ABS(drag_vector.y)*aspect * SGN(drag_vector.x); + } + } + } + + + + Vector2 begin=local_rect.pos; + Vector2 end=local_rect.pos+local_rect.size; + Vector2 minsize = canvas_item->edit_get_minimum_size(); + bool symmetric=m.mod.shift; + + + switch(drag) { + case DRAG_ALL: { + begin+=drag_vector; + end+=drag_vector; + } break; + case DRAG_RIGHT: { + + incend(begin.x,end.x,drag_vector.x,minsize.x,symmetric); + + } break; + case DRAG_BOTTOM: { + + incend(begin.y,end.y,drag_vector.y,minsize.y,symmetric); + + } break; + case DRAG_BOTTOM_RIGHT: { + + incend(begin.x,end.x,drag_vector.x,minsize.x,symmetric); + incend(begin.y,end.y,drag_vector.y,minsize.y,symmetric); + } break; + case DRAG_TOP_LEFT: { + incbeg(begin.x,end.x,drag_vector.x,minsize.x,symmetric); + incbeg(begin.y,end.y,drag_vector.y,minsize.y,symmetric); + } break; + case DRAG_TOP: { + + incbeg(begin.y,end.y,drag_vector.y,minsize.y,symmetric); + + } break; + case DRAG_LEFT: { + + incbeg(begin.x,end.x,drag_vector.x,minsize.x,symmetric); + + } break; + case DRAG_TOP_RIGHT: { + + incbeg(begin.y,end.y,drag_vector.y,minsize.y,symmetric); + incend(begin.x,end.x,drag_vector.x,minsize.x,symmetric); + + } break; + case DRAG_BOTTOM_LEFT: { + + incbeg(begin.x,end.x,drag_vector.x,minsize.x,symmetric); + incend(begin.y,end.y,drag_vector.y,minsize.y,symmetric); + } break; + case DRAG_PIVOT: { + + if (canvas_item->cast_to<Node2D>()) { + Node2D *n2d =canvas_item->cast_to<Node2D>(); + n2d->edit_set_pivot(se->undo_pivot+drag_vector); + + } + continue; + } break; + + default:{} + } + + + local_rect.pos=begin; + local_rect.size=end-begin; + canvas_item->edit_set_rect(local_rect); + + } + } + + if (p_event.type==InputEvent::KEY) { + + const InputEventKey &k=p_event.key; + + if (p_event.key.mod.alt || p_event.key.mod.control || p_event.key.mod.meta) + return; + + if (k.pressed && drag==DRAG_NONE) { + + if (k.scancode==KEY_UP) + _key_move(Vector2(0,-1),k.mod.shift); + else if (k.scancode==KEY_DOWN) + _key_move(Vector2(0,1),k.mod.shift); + else if (k.scancode==KEY_LEFT) + _key_move(Vector2(-1,0),k.mod.shift); + else if (k.scancode==KEY_RIGHT) + _key_move(Vector2(1,0),k.mod.shift); + else if (k.scancode==KEY_ESCAPE) { + editor_selection->clear(); + viewport->update(); + } + else + return; + + accept_event(); + } + + } + + + + +} + +void CanvasItemEditor::_viewport_draw() { + + // TODO fetch the viewport? + + Ref<Texture> pivot = get_icon("EditorPivot","EditorIcons"); + _update_scrollbars(); + RID ci=viewport->get_canvas_item(); + + if (snap>0 && is_snap_active() && true ) { + + Size2 s = viewport->get_size(); + + int last_cell; + Matrix32 xform = transform.affine_inverse(); + for(int i=0;i<s.width;i++) { + + int cell = Math::fast_ftoi(Math::floor(xform.xform(Vector2(i,0)).x/snap)); + if (i==0) + last_cell=cell; + if (last_cell!=cell) + viewport->draw_line(Point2(i,0),Point2(i,s.height),Color(0.3,0.7,1,0.3)); + last_cell=cell; + } + + for(int i=0;i<s.height;i++) { + + int cell = Math::fast_ftoi(Math::floor(xform.xform(Vector2(0,i)).y/snap)); + if (i==0) + last_cell=cell; + if (last_cell!=cell) + viewport->draw_line(Point2(0,i),Point2(s.width,i),Color(0.3,0.7,1,0.3)); + last_cell=cell; + } + + } + + if (viewport->has_focus()) { + Size2 size = viewport->get_size(); + if (v_scroll->is_visible()) + size.width-=v_scroll->get_size().width; + if (h_scroll->is_visible()) + size.height-=h_scroll->get_size().height; + + get_stylebox("EditorFocus","EditorStyles")->draw(ci,Rect2(Point2(),size)); + } + + Ref<Texture> lock = get_icon("Lock","EditorIcons"); + Ref<Texture> group = get_icon("Group","EditorIcons"); + + VisualServer::get_singleton()->canvas_item_set_clip(ci,true); + + bool single = get_single_item()!=NULL; + + Map<Node*,Object*> &selection = editor_selection->get_selection(); + + CanvasItem *single_item=NULL; + + for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) { + + + CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + + Rect2 rect=canvas_item->get_item_rect(); + + Matrix32 xform=transform * canvas_item->get_global_transform_with_canvas(); + VisualServer::get_singleton()->canvas_item_add_set_transform(ci,xform); + Point2 ofs=Point2();//get_global_pos(); + Rect2 draw_rect=rect; + Color light_edit_color=Color(1.0,0.8,0.8); + Color dark_edit_color=Color(0.4,0.1,0.1); + Size2 handle_size=Size2(handle_len,handle_len); + + //select_sb->draw(ci,draw_rect.grow(2)); + //DRAW_EMPTY_RECT( draw_rect.grow(2), light_edit_color ); + //DRAW_EMPTY_RECT( draw_rect.grow(1), dark_edit_color ); + + Vector2 endpoints[4]={ + + xform.xform(rect.pos), + xform.xform(rect.pos+Vector2(rect.size.x,0)), + xform.xform(rect.pos+rect.size), + xform.xform(rect.pos+Vector2(0,rect.size.y)) + }; + + Color c = Color(1,0.6,0.4,0.7); + + VisualServer::get_singleton()->canvas_item_add_set_transform(ci,Matrix32()); + + for(int i=0;i<4;i++) { + viewport->draw_line(endpoints[i],endpoints[(i+1)%4],c,2); + } + + if (single && (tool==TOOL_SELECT || tool == TOOL_MOVE)) { //kind of sucks + + if (canvas_item->cast_to<Node2D>()) { + + + if (canvas_item->cast_to<Node2D>()->edit_has_pivot()) { + viewport->draw_texture(pivot,xform.get_origin()+(-pivot->get_size()/2).floor()); + can_move_pivot=true; + } + + } + + + if (tool==TOOL_SELECT) { + + + for(int i=0;i<4;i++) { + + int prev = (i+3)%4; + int next = (i+1)%4; + + Vector2 ofs = ((endpoints[i] - endpoints[prev]).normalized() + ((endpoints[i] - endpoints[next]).normalized())).normalized(); + ofs*=1.4144*(select_handle->get_size().width/2); + + select_handle->draw(ci,(endpoints[i]+ofs-(select_handle->get_size()/2)).floor()); + + ofs = (endpoints[i]+endpoints[next])/2; + ofs += (endpoints[next]-endpoints[i]).tangent().normalized()*(select_handle->get_size().width/2); + + select_handle->draw(ci,(ofs-(select_handle->get_size()/2)).floor()); + + } + + } + } + + + + //DRAW_EMPTY_RECT( Rect2( current_window->get_scroll()-Point2(1,1), get_size()+Size2(2,2)), Color(0.8,0.8,1.0,0.8) ); + //E->get().last_rect = rect; + } + + VisualServer::get_singleton()->canvas_item_add_set_transform(ci,Matrix32()); + + + + Color x_axis_color(1.0,0.4,0.4,0.6); + Color y_axis_color(0.4,1.0,0.4,0.6); + Color area_axis_color(0.4,0.4,1.0,0.4); + Color rotate_color(0.4,0.7,1.0,0.8); + + VisualServer::get_singleton()->canvas_item_add_line(ci,Point2(h_scroll->get_min(),0)+transform.get_origin(),Point2(h_scroll->get_max(),0)+transform.get_origin(),x_axis_color); + VisualServer::get_singleton()->canvas_item_add_line(ci,Point2(0,v_scroll->get_min())+transform.get_origin(),Point2(0,v_scroll->get_max())+transform.get_origin(),y_axis_color); + + + if (box_selecting) { + + Point2 bsfrom = transform.xform(drag_from); + Point2 bsto= transform.xform(box_selecting_to); + + + VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(bsfrom,bsto-bsfrom),Color(0.7,0.7,1.0,0.3)); + } + + if (drag==DRAG_ROTATE) { + VisualServer::get_singleton()->canvas_item_add_line(ci,transform.xform(display_rotate_from), transform.xform(display_rotate_to),rotate_color); + } + + Size2 screen_size = Size2( Globals::get_singleton()->get("display/width"), Globals::get_singleton()->get("display/height") ); + + Vector2 screen_endpoints[4]= { + transform.xform(Vector2(0,0)), + transform.xform(Vector2(screen_size.width,0)), + transform.xform(Vector2(screen_size.width,screen_size.height)), + transform.xform(Vector2(0,screen_size.height)) + }; + + for(int i=0;i<4;i++) { + + VisualServer::get_singleton()->canvas_item_add_line(ci,screen_endpoints[i], screen_endpoints[(i+1)%4],area_axis_color); + + } + + for(List<LockList>::Element*E=lock_list.front();E;E=E->next()) { + + Vector2 ofs = transform.xform(E->get().pos); + if (E->get().lock) { + + lock->draw(ci,ofs); + ofs.x+=lock->get_width(); + } + if (E->get().group) { + + group->draw(ci,ofs); + } + + } + + +} + +void CanvasItemEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_FIXED_PROCESS) { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); + if (!se) + continue; + + Rect2 r=canvas_item->get_item_rect(); + + Matrix32 xform = canvas_item->get_transform(); + + if (r != se->prev_rect || xform!=se->prev_xform) { + viewport->update(); + se->prev_rect=r; + se->prev_xform=xform; + } + + } + + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + select_sb->set_texture( get_icon("EditorRect2D","EditorIcons") ); + for(int i=0;i<4;i++) { + select_sb->set_margin_size(Margin(i),4); + select_sb->set_default_margin(Margin(i),4); + } + + select_button->set_icon( get_icon("ToolSelect","EditorIcons")); + move_button->set_icon( get_icon("ToolMove","EditorIcons")); + rotate_button->set_icon( get_icon("ToolRotate","EditorIcons")); + select_handle=get_icon("EditorHandle","EditorIcons"); + lock_button->set_icon(get_icon("Lock","EditorIcons")); + unlock_button->set_icon(get_icon("Unlock","EditorIcons")); + group_button->set_icon(get_icon("Group","EditorIcons")); + ungroup_button->set_icon(get_icon("Ungroup","EditorIcons")); + + } + + if (p_what==NOTIFICATION_READY) { + + get_scene()->connect("node_removed",this,"_node_removed"); + } + + if (p_what==NOTIFICATION_DRAW) { + + + + } +} + +void CanvasItemEditor::edit(CanvasItem *p_canvas_item) { + + drag=DRAG_NONE; + + editor_selection->clear();//_clear_canvas_items(); + editor_selection->add_node(p_canvas_item); + //_add_canvas_item(p_canvas_item); + viewport->update(); + +} + + +void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2& r_rect, const Matrix32& p_xform) { + + + + if (!p_node) + return; + + CanvasItem *c=p_node->cast_to<CanvasItem>(); + + + for (int i=p_node->get_child_count()-1;i>=0;i--) { + +// CanvasItem *r=NULL; + + if (c && !c->is_set_as_toplevel()) + _find_canvas_items_span(p_node->get_child(i),r_rect,p_xform * c->get_transform()); + else + _find_canvas_items_span(p_node->get_child(i),r_rect,Matrix32()); + } + + + + if (c) { + + Rect2 rect = c->get_item_rect(); + Matrix32 xform = p_xform * c->get_transform(); + + + LockList lock; + lock.lock=c->has_meta("_edit_lock_"); + lock.group=c->has_meta("_edit_group_"); + + if (lock.group || lock.lock) { + lock.pos=xform.xform(rect.pos); + lock_list.push_back(lock); + } + + r_rect.expand_to( xform.xform(rect.pos) ); + r_rect.expand_to( xform.xform(rect.pos+Point2(rect.size.x,0)) ); + r_rect.expand_to( xform.xform(rect.pos+Point2(0,rect.size.y)) ); + r_rect.expand_to( xform.xform(rect.pos+rect.size) ); + + } + +} + +void CanvasItemEditor::_update_scrollbars() { + + + updating_scroll=true; + + Size2 size = viewport->get_size(); + Size2 hmin = h_scroll->get_minimum_size(); + Size2 vmin = v_scroll->get_minimum_size(); + + v_scroll->set_begin( Point2(size.width - vmin.width, 0) ); + v_scroll->set_end( Point2(size.width, size.height) ); + + h_scroll->set_begin( Point2( 0, size.height - hmin.height) ); + h_scroll->set_end( Point2(size.width-vmin.width, size.height) ); + + + Size2 screen_rect = Size2( Globals::get_singleton()->get("display/width"), Globals::get_singleton()->get("display/height") ); + + Rect2 local_rect = Rect2(Point2(),viewport->get_size()-Size2(vmin.width,hmin.height)); + + Rect2 canvas_item_rect=Rect2(Point2(),screen_rect); + + lock_list.clear();; + + if (editor->get_edited_scene()) + _find_canvas_items_span(editor->get_edited_scene(),canvas_item_rect,Matrix32()); + + + //expand area so it's easier to do animations and stuff at 0,0 + canvas_item_rect.size+=screen_rect*2; + canvas_item_rect.pos-=screen_rect; + + Point2 ofs; + + + if (canvas_item_rect.size.height <= (local_rect.size.y/zoom)) { + + v_scroll->hide(); + ofs.y=canvas_item_rect.pos.y; + } else { + + v_scroll->show(); + v_scroll->set_min(canvas_item_rect.pos.y); + v_scroll->set_max(canvas_item_rect.pos.y+canvas_item_rect.size.y); + v_scroll->set_page(local_rect.size.y/zoom); + if (first_update) { + //so 0,0 is visible + v_scroll->set_val(-10); + h_scroll->set_val(-10); + first_update=false; + + } + + ofs.y=v_scroll->get_val(); + } + + if (canvas_item_rect.size.width <= (local_rect.size.x/zoom)) { + + h_scroll->hide(); + ofs.x=canvas_item_rect.pos.x; + } else { + + h_scroll->show(); + h_scroll->set_min(canvas_item_rect.pos.x); + h_scroll->set_max(canvas_item_rect.pos.x+canvas_item_rect.size.x); + h_scroll->set_page(local_rect.size.x/zoom); + ofs.x=h_scroll->get_val(); + } + +// transform=Matrix32(); + transform.elements[2]=-ofs*zoom; + editor->get_scene_root()->set_global_canvas_transform(transform); + + + updating_scroll=false; + +// transform.scale_basis(Vector2(zoom,zoom)); + + +} + +void CanvasItemEditor::_update_scroll(float) { + + + if (updating_scroll) + return; + + Point2 ofs; + ofs.x=h_scroll->get_val(); + ofs.y=v_scroll->get_val(); + +// current_window->set_scroll(-ofs); + + transform=Matrix32(); + + transform.scale_basis(Size2(zoom,zoom)); + transform.elements[2]=-ofs; + + editor->get_scene_root()->set_global_canvas_transform(transform); + + + viewport->update(); + +} + + +Point2 CanvasItemEditor::snapify(const Point2& p_pos) const { + + bool active=is_snap_active(); + + Vector2 pos = p_pos; + + if (!active || snap<1) { + + if (pixel_snap) { + + pos.x=Math::stepify(pos.x,1); + pos.y=Math::stepify(pos.y,1); + } + + return pos; + } + + + pos.x=Math::stepify(pos.x,snap); + pos.y=Math::stepify(pos.y,snap); + return pos; + + +} + + +void CanvasItemEditor::_popup_callback(int p_op) { + + last_option=MenuOption(p_op); + switch(p_op) { + + case SNAP_USE: { + + int idx = edit_menu->get_popup()->get_item_index(SNAP_USE); + edit_menu->get_popup()->set_item_checked( idx,!edit_menu->get_popup()->is_item_checked(0)); + viewport->update(); + } break; + case SNAP_USE_PIXEL: { + pixel_snap = ! pixel_snap; + int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_PIXEL); + edit_menu->get_popup()->set_item_checked(idx,pixel_snap); + } break; + case SNAP_CONFIGURE: { + updating_value_dialog=true; + + dialog_label->set_text("Snap (Pixels):"); + dialog_val->set_min(1); + dialog_val->set_step(1); + dialog_val->set_max(4096); + dialog_val->set_val(snap); + value_dialog->popup_centered(Size2(200,85)); + updating_value_dialog=false; + + } break; + case ZOOM_IN: { + zoom=zoom*(1.0/0.5); + _update_scroll(0); + viewport->update(); + return; + } break; + case ZOOM_OUT: { + zoom=zoom*0.5; + _update_scroll(0); + viewport->update(); + return; + + } break; + case ZOOM_RESET: { + + zoom=1; + _update_scroll(0); + viewport->update(); + return; + + } break; + case ZOOM_SET: { + + updating_value_dialog=true; + + dialog_label->set_text("Zoom (%):"); + dialog_val->set_min(0.1); + dialog_val->set_step(0.1); + dialog_val->set_max(800); + dialog_val->set_val(zoom*100); + value_dialog->popup_centered(Size2(200,85)); + updating_value_dialog=false; + + + } break; + case LOCK_SELECTED: { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + canvas_item->set_meta("_edit_lock_",true); + + } + viewport->update(); + } break; + case UNLOCK_SELECTED: { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + + canvas_item->set_meta("_edit_lock_",Variant()); + + } + + viewport->update(); + + } break; + case GROUP_SELECTED: { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + canvas_item->set_meta("_edit_group_",true); + + } + viewport->update(); + } break; + case UNGROUP_SELECTED: { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + + canvas_item->set_meta("_edit_group_",Variant()); + + } + + viewport->update(); + + } break; + + case EXPAND_TO_PARENT: { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + + Control *c = canvas_item->cast_to<Control>(); + if (!c) + continue; + c->set_area_as_parent_rect(); + + } + + viewport->update(); + + } break; + + case ALIGN_VERTICAL: { +#if 0 + if ( ref_item && canvas_items.size() > 1 ) { + Vector2 ref_pos = ref_item->get_global_transform().elements[2]; + Rect2 ref_r = ref_item->get_item_rect(); + for ( CanvasItemMap::Element *E = canvas_items.front(); E; E = E->next() ) { + CanvasItem *it_curr = E->key(); + if ( it_curr == ref_item ) continue; + Vector2 v = it_curr->get_global_transform().elements[2]; + Rect2 r = it_curr->get_item_rect(); + r.pos.x = ( ref_pos.x + ref_r.size.x / 2 ) - ( v.x + r.size.x / 2 ); + it_curr->edit_set_rect( r ); + } + viewport->update(); + } +#endif + } break; + + case ALIGN_HORIZONTAL: { +#if 0 + if ( ref_item && canvas_items.size() > 1 ) { + Vector2 ref_pos = ref_item->get_global_transform().elements[2]; + Rect2 ref_r = ref_item->get_item_rect(); + for ( CanvasItemMap::Element *E = canvas_items.front(); E; E = E->next() ) { + CanvasItem *it_curr = E->key(); + if ( it_curr == ref_item ) continue; + Vector2 v = it_curr->get_global_transform().elements[2]; + Rect2 r = it_curr->get_item_rect(); + r.pos.y = ( ref_pos.y + ref_r.size.y / 2 ) - ( v.y + r.size.y / 2 ); + it_curr->edit_set_rect( r ); + } + viewport->update(); + } +#endif + } break; + + case SPACE_HORIZONTAL: { + //space_selected_items< proj_vector2_x, compare_items_x >(); + } break; + + case SPACE_VERTICAL: { + //space_selected_items< proj_vector2_y, compare_items_y >(); + } break; + case ANIM_INSERT_KEY: + case ANIM_INSERT_KEY_EXISTING: { + + bool existing = p_op==ANIM_INSERT_KEY_EXISTING; + + Map<Node*,Object*> &selection = editor_selection->get_selection(); + + for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + if (canvas_item->cast_to<Node2D>()) { + Node2D *n2d = canvas_item->cast_to<Node2D>(); + + if (key_pos) + editor->get_animation_editor()->insert_node_value_key(n2d,"transform/pos",n2d->get_pos(),existing); + if (key_rot) + editor->get_animation_editor()->insert_node_value_key(n2d,"transform/rot",Math::rad2deg(n2d->get_rot()),existing); + if (key_scale) + editor->get_animation_editor()->insert_node_value_key(n2d,"transform/scale",n2d->get_scale(),existing); + } else if (canvas_item->cast_to<Control>()) { + + Control *ctrl = canvas_item->cast_to<Control>(); + + if (key_pos) + editor->get_animation_editor()->insert_node_value_key(ctrl,"rect/pos",ctrl->get_pos(),existing); + if (key_scale) + editor->get_animation_editor()->insert_node_value_key(ctrl,"rect/size",ctrl->get_size(),existing); + } + + } + + } break; + case ANIM_INSERT_POS: + case ANIM_INSERT_ROT: + case ANIM_INSERT_SCALE: + case ANIM_INSERT_POS_ROT: + case ANIM_INSERT_POS_SCALE: + case ANIM_INSERT_ROT_SCALE: + case ANIM_INSERT_POS_ROT_SCALE: { + + static const bool key_toggles[7][3]={ + {true,false,false}, + {false,true,false}, + {false,false,true}, + {true,true,false}, + {true,false,true}, + {false,true,true}, + {true,true,true} + }; + key_pos=key_toggles[p_op-ANIM_INSERT_POS][0]; + key_rot=key_toggles[p_op-ANIM_INSERT_POS][1]; + key_scale=key_toggles[p_op-ANIM_INSERT_POS][2]; + + for(int i=ANIM_INSERT_POS;i<=ANIM_INSERT_POS_ROT_SCALE;i++) { + int idx = animation_menu->get_popup()->get_item_index(i); + animation_menu->get_popup()->set_item_checked(idx,i==p_op); + } + + } break; + case ANIM_COPY_POSE: { + + pose_clipboard.clear();; + + + Map<Node*,Object*> &selection = editor_selection->get_selection(); + + for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + + + if (canvas_item->cast_to<Node2D>()) { + + Node2D *n2d = canvas_item->cast_to<Node2D>(); + PoseClipboard pc; + pc.pos=n2d->get_pos(); + pc.rot=n2d->get_rot(); + pc.scale=n2d->get_scale(); + pc.id=n2d->get_instance_ID(); + pose_clipboard.push_back(pc); + } + } + + + } break; + case ANIM_PASTE_POSE: { + + if (!pose_clipboard.size()) + break; + + undo_redo->create_action("Paste Pose"); + for (List<PoseClipboard>::Element *E=pose_clipboard.front();E;E=E->next()) { + + Object *o = ObjectDB::get_instance(E->get().id); + if (!o) + continue; + Node2D *n2d = o->cast_to<Node2D>(); + if (!n2d) + continue; + undo_redo->add_do_method(n2d,"set_pos",E->get().pos); + undo_redo->add_do_method(n2d,"set_rot",E->get().rot); + undo_redo->add_do_method(n2d,"set_scale",E->get().scale); + undo_redo->add_undo_method(n2d,"set_pos",n2d->get_pos()); + undo_redo->add_undo_method(n2d,"set_rot",n2d->get_rot()); + undo_redo->add_undo_method(n2d,"set_scale",n2d->get_scale()); + } + undo_redo->commit_action(); + + } break; + case ANIM_CLEAR_POSE: { + + Map<Node*,Object*> &selection = editor_selection->get_selection(); + + for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) { + + CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>(); + if (!canvas_item) + continue; + if (!canvas_item->is_visible()) + continue; + + if (canvas_item->cast_to<Node2D>()) { + Node2D *n2d = canvas_item->cast_to<Node2D>(); + + if (key_pos) + n2d->set_pos(Vector2()); + if (key_rot) + n2d->set_rot(0); + if (key_scale) + n2d->set_scale(Vector2(1,1)); + } else if (canvas_item->cast_to<Control>()) { + + Control *ctrl = canvas_item->cast_to<Control>(); + + if (key_pos) + ctrl->set_pos(Point2()); + //if (key_scale) + // editor->get_animation_editor()->insert_node_value_key(ctrl,"rect/size",ctrl->get_size()); + } + + } + + + } break; + + } +} +#if 0 +template< class P, class C > void CanvasItemEditor::space_selected_items() { + P p; + if ( canvas_items.size() > 2 ) { + Vector< CanvasItem * > items; + for ( CanvasItemMap::Element *E = canvas_items.front(); E; E = E->next() ) { + CanvasItem *it_curr = E->key(); + items.push_back( it_curr ); + } + items.sort_custom< C >(); + + float width_s = p.get( items[0]->get_item_rect().size ); + float width_e = p.get( items[ items.size() - 1 ]->get_item_rect().size ); + float start_x = p.get( items[0]->get_global_transform().elements[2] ) + ( width_s / 2 ); + float end_x = p.get( items[ items.size() - 1 ]->get_global_transform().elements[2] ) + ( width_e / 2 ); + float sp = ( end_x - start_x ) / ( items.size() - 1 ); + + for ( int i = 0; i < items.size(); i++ ) { + CanvasItem *it_curr = items[i]; + Vector2 v = it_curr->get_global_transform().elements[2]; + Rect2 r = it_curr->get_item_rect(); + p.set( r.pos, ( start_x + sp * i ) - ( p.get( v ) + p.get( r.size ) / 2 ) ); + it_curr->edit_set_rect( r ); + } + viewport->update(); + } +} +#endif + +void CanvasItemEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_node_removed",&CanvasItemEditor::_node_removed); + ObjectTypeDB::bind_method("_update_scroll",&CanvasItemEditor::_update_scroll); + ObjectTypeDB::bind_method("_popup_callback",&CanvasItemEditor::_popup_callback); + ObjectTypeDB::bind_method("_visibility_changed",&CanvasItemEditor::_visibility_changed); + ObjectTypeDB::bind_method("_dialog_value_changed",&CanvasItemEditor::_dialog_value_changed); + ObjectTypeDB::bind_method("_get_editor_data",&CanvasItemEditor::_get_editor_data); + ObjectTypeDB::bind_method("_tool_select",&CanvasItemEditor::_tool_select); + ObjectTypeDB::bind_method("_keying_changed",&CanvasItemEditor::_keying_changed); + ObjectTypeDB::bind_method("_unhandled_key_input",&CanvasItemEditor::_unhandled_key_input); + ObjectTypeDB::bind_method("_viewport_draw",&CanvasItemEditor::_viewport_draw); + ObjectTypeDB::bind_method("_viewport_input_event",&CanvasItemEditor::_viewport_input_event); + + + +} + +#if 0 +void CanvasItemEditor::end_drag() { + print_line( "end drag" ); + + if (undo_redo) { + + undo_redo->create_action("Edit CanvasItem"); + for(CanvasItemMap::Element *E=canvas_items.front();E;E=E->next()) { + CanvasItem *canvas_item = E->key(); + Variant state=canvas_item->edit_get_state(); + undo_redo->add_do_method(canvas_item,"edit_set_state",state); + undo_redo->add_undo_method(canvas_item,"edit_set_state",E->get().undo_state); + } + undo_redo->commit_action(); + } + + drag=DRAG_NONE; + viewport->update(); +} + +void CanvasItemEditor::box_selection_start( Point2 &click ) { + print_line( "box selection start" ); + + drag_from=transform.affine_inverse().xform(click); + + box_selecting=true; + box_selecting_to=drag_from; + viewport->update(); +} + +bool CanvasItemEditor::box_selection_end() { + print_line( "box selection end" ); + + Node* scene = get_scene()->get_root_node()->cast_to<EditorNode>()->get_edited_scene(); + if (scene) { + + List<CanvasItem*> selitems; + + Point2 bsfrom = transform.xform(drag_from); + Point2 bsto= transform.xform(box_selecting_to); + if (bsfrom.x>bsto.x) + SWAP(bsfrom.x,bsto.x); + if (bsfrom.y>bsto.y) + SWAP(bsfrom.y,bsto.y); + + if ( bsfrom.distance_to( bsto ) < 3 ) { + print_line( "box selection too small" ); + box_selecting=false; + viewport->update(); + return false; + } + + _find_canvas_items_at_rect(Rect2(bsfrom,bsto-bsfrom),scene,transform,&selitems); + + for(List<CanvasItem*>::Element *E=selitems.front();E;E=E->next()) { + + _append_canvas_item(E->get()); + } + + } + + box_selecting=false; + viewport->update(); + + return true; +} +#endif + +void CanvasItemEditor::add_control_to_menu_panel(Control *p_control) { + + hb->add_child(p_control); +} + +CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) { + + tool = TOOL_SELECT; + undo_redo=p_editor->get_undo_redo(); + editor=p_editor; + editor_selection=p_editor->get_editor_selection(); + editor_selection->add_editor_plugin(this); + editor_selection->connect("selection_changed",this,"update"); + + + hb = memnew( HBoxContainer ); + add_child( hb ); + hb->set_area_as_parent_rect(); + + Control *vp_base = memnew (Control); + add_child(vp_base); + vp_base->set_v_size_flags(SIZE_EXPAND_FILL); + + Control *vp = memnew (Control); + vp_base->add_child(vp); + vp->set_area_as_parent_rect(); + vp->add_child(p_editor->get_scene_root()); + + viewport = memnew( Control ); + vp_base->add_child(viewport); + viewport->set_area_as_parent_rect(); + + h_scroll = memnew( HScrollBar ); + v_scroll = memnew( VScrollBar ); + + viewport->add_child(h_scroll); + viewport->add_child(v_scroll); + viewport->connect("draw",this,"_viewport_draw"); + viewport->connect("input_event",this,"_viewport_input_event"); + + + h_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),true); + v_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),true); + + h_scroll->hide(); + v_scroll->hide(); + updating_scroll=false; + viewport->set_focus_mode(FOCUS_ALL); + handle_len=10; + first_update=true; + + + select_button = memnew( ToolButton ); + select_button->set_toggle_mode(true); + hb->add_child(select_button); + select_button->connect("pressed",this,"_tool_select",make_binds(TOOL_SELECT)); + select_button->set_pressed(true); + select_button->set_tooltip("Select Mode (Q)\n"+keycode_get_string(KEY_MASK_CMD)+"Drag: Rotate\nAlt+Drag: Move\nPress 'v' to Move Pivot (while moving)"); + + move_button = memnew( ToolButton ); + move_button->set_toggle_mode(true); + hb->add_child(move_button); + move_button->connect("pressed",this,"_tool_select",make_binds(TOOL_MOVE)); + move_button->set_tooltip("Move Mode (W)"); + + rotate_button = memnew( ToolButton ); + rotate_button->set_toggle_mode(true); + hb->add_child(rotate_button); + rotate_button->connect("pressed",this,"_tool_select",make_binds(TOOL_ROTATE)); + rotate_button->set_tooltip("Rotate Mode (E)"); + + hb->add_child(memnew(VSeparator)); + + lock_button = memnew( ToolButton ); + hb->add_child(lock_button); + + lock_button->connect("pressed",this,"_popup_callback",varray(LOCK_SELECTED)); + + unlock_button = memnew( ToolButton ); + hb->add_child(unlock_button); + unlock_button->connect("pressed",this,"_popup_callback",varray(UNLOCK_SELECTED)); + + group_button = memnew( ToolButton ); + hb->add_child(group_button); + group_button->connect("pressed",this,"_popup_callback",varray(GROUP_SELECTED)); + + ungroup_button = memnew( ToolButton ); + hb->add_child(ungroup_button); + ungroup_button->connect("pressed",this,"_popup_callback",varray(UNGROUP_SELECTED)); + + hb->add_child(memnew(VSeparator)); + + edit_menu = memnew( MenuButton ); + edit_menu->set_text("Edit"); + hb->add_child(edit_menu); + edit_menu->get_popup()->connect("item_pressed", this,"_popup_callback"); + + PopupMenu *p; + p = edit_menu->get_popup(); + p->add_check_item("Use Snap",SNAP_USE); + p->add_item("Configure Snap..",SNAP_CONFIGURE); + p->add_separator(); + p->add_check_item("Use Pixel Snap",SNAP_USE_PIXEL); + p->add_separator(); + p->add_item("Expand to Parent",EXPAND_TO_PARENT,KEY_MASK_CMD|KEY_P); + + /* + p->add_item("Align Horizontal",ALIGN_HORIZONTAL); + p->add_item("Align Vertical",ALIGN_VERTICAL); + p->add_item("Space Horizontal",SPACE_HORIZONTAL); + p->add_item("Space Vertical",SPACE_VERTICAL);*/ + + view_menu = memnew( MenuButton ); + view_menu->set_text("View"); + hb->add_child(view_menu); + view_menu->get_popup()->connect("item_pressed", this,"_popup_callback"); + + p = view_menu->get_popup(); + + p->add_item("Zoom In",ZOOM_IN); + p->add_item("Zoom Out",ZOOM_OUT); + p->add_item("Zoom Reset",ZOOM_RESET); + p->add_item("Zoom Set..",ZOOM_SET); + + animation_menu = memnew( MenuButton ); + animation_menu->set_text("Animation"); + hb->add_child(animation_menu); + animation_menu->get_popup()->connect("item_pressed", this,"_popup_callback"); + + p = animation_menu->get_popup(); + + p->add_item("Insert Key",ANIM_INSERT_KEY,KEY_INSERT); + p->add_item("Insert Key (Existing Tracks)",ANIM_INSERT_KEY_EXISTING,KEY_MASK_CMD+KEY_INSERT); + p->add_separator(); + p->add_check_item("Pos",ANIM_INSERT_POS); + p->add_check_item("Rot",ANIM_INSERT_ROT); + p->add_check_item("Scale",ANIM_INSERT_SCALE); + p->add_check_item("Pos+Rot",ANIM_INSERT_POS_ROT); + p->set_item_checked(p->get_item_index(ANIM_INSERT_POS_ROT),true); + p->add_check_item("Pos+Scale",ANIM_INSERT_POS_SCALE); + p->add_check_item("Rot+Scale",ANIM_INSERT_ROT_SCALE); + p->add_check_item("Loc+Rot+Scale",ANIM_INSERT_POS_ROT_SCALE); + p->add_separator(); + p->add_item("Copy Pose",ANIM_COPY_POSE); + p->add_item("Paste Pose",ANIM_PASTE_POSE); + p->add_item("Clear Pose",ANIM_CLEAR_POSE,KEY_MASK_ALT|KEY_K); + + animation_menu->hide(); + + + value_dialog = memnew( AcceptDialog ); + value_dialog->set_title("Set a Value"); + value_dialog->get_ok()->set_text("Close"); + add_child(value_dialog); + + Label *l = memnew(Label); + l->set_text("Snap (Pixels):"); + l->set_pos(Point2(5,5)); + value_dialog->add_child(l); + dialog_label=l; + + dialog_val=memnew(SpinBox); + dialog_val->set_anchor(MARGIN_RIGHT,ANCHOR_END); + dialog_val->set_begin(Point2(15,25)); + dialog_val->set_end(Point2(10,25)); + value_dialog->add_child(dialog_val); + dialog_val->connect("value_changed",this,"_dialog_value_changed"); + select_sb = Ref<StyleBoxTexture>( memnew( StyleBoxTexture) ); + + key_pos=true; + key_rot=true; + key_scale=false; + + zoom=1; + snap=10; + updating_value_dialog=false; + box_selecting=false; + //zoom=0.5; + singleton=this; + editor->get_animation_editor()->connect("keying_changed",this,"_keying_changed"); + add_to_group("unhandled_key_input"); + can_move_pivot=false; + pixel_snap=false; + drag=DRAG_NONE; +} + +CanvasItemEditor *CanvasItemEditor::singleton=NULL; + +void CanvasItemEditorPlugin::edit(Object *p_object) { + + canvas_item_editor->set_undo_redo(&get_undo_redo()); + canvas_item_editor->edit(p_object->cast_to<CanvasItem>()); +} + +bool CanvasItemEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("CanvasItem"); +} + +void CanvasItemEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + canvas_item_editor->show(); + canvas_item_editor->set_fixed_process(true); + VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport(),false); + canvas_item_editor->viewport->grab_focus(); + + } else { + + canvas_item_editor->hide(); + canvas_item_editor->set_fixed_process(false); + VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport(),true); + } + +} + +Dictionary CanvasItemEditorPlugin::get_state() const { + + return canvas_item_editor->get_state(); +} +void CanvasItemEditorPlugin::set_state(const Dictionary& p_state) { + + canvas_item_editor->set_state(p_state); +} + +CanvasItemEditorPlugin::CanvasItemEditorPlugin(EditorNode *p_node) { + + editor=p_node; + canvas_item_editor = memnew( CanvasItemEditor(editor) ); + editor->get_viewport()->add_child(canvas_item_editor); + canvas_item_editor->set_area_as_parent_rect(); + canvas_item_editor->hide(); + +} + + +CanvasItemEditorPlugin::~CanvasItemEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/canvas_item_editor_plugin.h b/tools/editor/plugins/canvas_item_editor_plugin.h new file mode 100644 index 000000000..64c5d523c --- /dev/null +++ b/tools/editor/plugins/canvas_item_editor_plugin.h @@ -0,0 +1,339 @@ +/*************************************************************************/ +/* canvas_item_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef CONTROL_EDITOR_PLUGIN_H +#define CONTROL_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/gui/spin_box.h" +#include "scene/gui/panel_container.h" +#include "scene/gui/box_container.h" +#include "scene/2d/canvas_item.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + + + + +class CanvasItemEditorSelectedItem : public Object { + + OBJ_TYPE(CanvasItemEditorSelectedItem,Object); +public: + Variant undo_state; + Vector2 undo_pivot; + + Matrix32 prev_xform; + float prev_rot; + Rect2 prev_rect; + + CanvasItemEditorSelectedItem() { prev_rot=0; } +}; + +class CanvasItemEditor : public VBoxContainer { + + OBJ_TYPE(CanvasItemEditor, VBoxContainer ); + + EditorNode *editor; + + + enum Tool { + + TOOL_SELECT, + TOOL_MOVE, + TOOL_ROTATE, + TOOL_MAX + }; + + enum MenuOption { + SNAP_USE, + SNAP_CONFIGURE, + SNAP_USE_PIXEL, + ZOOM_IN, + ZOOM_OUT, + ZOOM_RESET, + ZOOM_SET, + LOCK_SELECTED, + UNLOCK_SELECTED, + GROUP_SELECTED, + UNGROUP_SELECTED, + ALIGN_HORIZONTAL, + ALIGN_VERTICAL, + SPACE_HORIZONTAL, + SPACE_VERTICAL, + EXPAND_TO_PARENT, + ANIM_INSERT_KEY, + ANIM_INSERT_KEY_EXISTING, + ANIM_INSERT_POS, + ANIM_INSERT_ROT, + ANIM_INSERT_SCALE, + ANIM_INSERT_POS_ROT, + ANIM_INSERT_POS_SCALE, + ANIM_INSERT_ROT_SCALE, + ANIM_INSERT_POS_ROT_SCALE, + ANIM_COPY_POSE, + ANIM_PASTE_POSE, + ANIM_CLEAR_POSE + + }; + + enum DragType { + DRAG_NONE, + DRAG_LEFT, + DRAG_TOP_LEFT, + DRAG_TOP, + DRAG_TOP_RIGHT, + DRAG_RIGHT, + DRAG_BOTTOM_RIGHT, + DRAG_BOTTOM, + DRAG_BOTTOM_LEFT, + DRAG_ALL, + DRAG_ROTATE, + DRAG_PIVOT, + + }; + + EditorSelection *editor_selection; + + Tool tool; + bool first_update; + Control *viewport; + + bool can_move_pivot; + + HScrollBar *h_scroll; + VScrollBar *v_scroll; + HBoxContainer *hb; + + Matrix32 transform; + float zoom; + int snap; + bool pixel_snap; + bool box_selecting; + Point2 box_selecting_to; + bool key_pos; + bool key_rot; + bool key_scale; + + void _tool_select(int p_index); + + + MenuOption last_option; + + struct LockList { + Point2 pos; + bool lock; + bool group; + LockList() { lock=false; group=false; } + }; + + List<LockList> lock_list; + + struct PoseClipboard { + + Vector2 pos; + Vector2 scale; + float rot; + ObjectID id; + }; + + List<PoseClipboard> pose_clipboard; + + ToolButton *select_button; + ToolButton *move_button; + ToolButton *rotate_button; + + ToolButton *lock_button; + ToolButton *unlock_button; + + ToolButton *group_button; + ToolButton *ungroup_button; + + MenuButton *edit_menu; + MenuButton *view_menu; + MenuButton *animation_menu; + //PopupMenu *popup; + DragType drag; + Point2 drag_from; + Point2 drag_point_from; + bool updating_value_dialog; + Point2 display_rotate_from; + Point2 display_rotate_to; +#if 0 + struct EditInfo { + + Variant undo_state; + + Matrix32 prev_xform; + float prev_rot; + Rect2 prev_rect; + EditInfo() { prev_rot=0; } + }; + + typedef Map<CanvasItem*,EditInfo> CanvasItemMap; + CanvasItemMap canvas_items; +#endif + Ref<StyleBoxTexture> select_sb; + Ref<Texture> select_handle; + + + int handle_len; + CanvasItem* _select_canvas_item_at_pos(const Point2 &p_pos,Node* p_node,const Matrix32& p_parent_xform,const Matrix32& p_canvas_xform); + void _find_canvas_items_at_rect(const Rect2& p_rect,Node* p_node,const Matrix32& p_parent_xform,const Matrix32& p_canvas_xform,List<CanvasItem*> *r_items); + + AcceptDialog *value_dialog; + Label *dialog_label; + SpinBox *dialog_val; + + CanvasItem *ref_item; + + void _add_canvas_item(CanvasItem *p_canvas_item); + void _remove_canvas_item(CanvasItem *p_canvas_item); + void _clear_canvas_items(); + void _visibility_changed(ObjectID p_canvas_item); + void _key_move(const Vector2& p_dir, bool p_snap); + + DragType _find_drag_type(const Matrix32& p_xform, const Rect2& p_local_rect, const Point2& p_click, Vector2& r_point); + + Point2 snapify(const Point2& p_pos) const; + void _popup_callback(int p_op); + bool updating_scroll; + void _update_scroll(float); + void _update_scrollbars(); + void incbeg(float& beg,float& end, float inc, float minsize,bool p_symmetric); + void incend(float& beg,float& end, float inc, float minsize,bool p_symmetric); + + void _append_canvas_item(CanvasItem *p_item); + void _dialog_value_changed(double); + UndoRedo *undo_redo; + + Point2 _find_topleftmost_point(); + + + void _find_canvas_items_span(Node *p_node, Rect2& r_rect, const Matrix32& p_xform); + + + Object *_get_editor_data(Object *p_what); + + CanvasItem *get_single_item(); + int get_item_count(); + void _keying_changed(bool p_changed); + + void _unhandled_key_input(const InputEvent& p_ev); + + void _viewport_input_event(const InputEvent& p_event); + void _viewport_draw(); +friend class CanvasItemEditorPlugin; +protected: + + + void _notification(int p_what); + + void _node_removed(Node *p_node); + static void _bind_methods(); + void end_drag(); + void box_selection_start( Point2 &click ); + bool box_selection_end(); + + HBoxContainer *get_panel_hb() { return hb; } + + struct compare_items_x { + bool operator()( const CanvasItem *a, const CanvasItem *b ) const { + return a->get_global_transform().elements[2].x < b->get_global_transform().elements[2].x; + } + }; + + struct compare_items_y { + bool operator()( const CanvasItem *a, const CanvasItem *b ) const { + return a->get_global_transform().elements[2].y < b->get_global_transform().elements[2].y; + } + }; + + struct proj_vector2_x { + float get( const Vector2 &v ) { return v.x; } + void set( Vector2 &v, float f ) { v.x = f; } + }; + + struct proj_vector2_y { + float get( const Vector2 &v ) { return v.y; } + void set( Vector2 &v, float f ) { v.y = f; } + }; + + template< class P, class C > void space_selected_items(); + + static CanvasItemEditor *singleton; +public: + + bool is_snap_active() const; + int get_snap() const { return snap; } + + Matrix32 get_canvas_transform() const { return transform; } + + static CanvasItemEditor *get_singleton() { return singleton; } + Dictionary get_state() const; + void set_state(const Dictionary& p_state); + + void add_control_to_menu_panel(Control *p_control); + + Control *get_viewport_control() { return viewport; } + + + bool get_remove_list(List<Node*> *p_list); + void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; } + void edit(CanvasItem *p_canvas_item); + CanvasItemEditor(EditorNode *p_editor); +}; + +class CanvasItemEditorPlugin : public EditorPlugin { + + OBJ_TYPE( CanvasItemEditorPlugin, EditorPlugin ); + + CanvasItemEditor *canvas_item_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "2D"; } + bool has_main_screen() const { return true; } + virtual void edit(Object *p_object); + virtual bool handles(Object *p_object) const; + virtual void make_visible(bool p_visible); + virtual bool get_remove_list(List<Node*> *p_list) { return canvas_item_editor->get_remove_list(p_list); } + virtual Dictionary get_state() const; + virtual void set_state(const Dictionary& p_state); + + CanvasItemEditor *get_canvas_item_editor() { return canvas_item_editor; } + + CanvasItemEditorPlugin(EditorNode *p_node); + ~CanvasItemEditorPlugin(); + +}; + +#endif diff --git a/tools/editor/plugins/collision_polygon_editor_plugin.cpp b/tools/editor/plugins/collision_polygon_editor_plugin.cpp new file mode 100644 index 000000000..e468ae573 --- /dev/null +++ b/tools/editor/plugins/collision_polygon_editor_plugin.cpp @@ -0,0 +1,479 @@ +/*************************************************************************/ +/* collision_polygon_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "collision_polygon_editor_plugin.h" +#include "canvas_item_editor_plugin.h" +#include "os/file_access.h" +#include "tools/editor/editor_settings.h" + +void CollisionPolygonEditor::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_READY: { + + button_create->set_icon( get_icon("Edit","EditorIcons")); + button_edit->set_icon( get_icon("MovePoint","EditorIcons")); + button_edit->set_pressed(true); + + + } break; + case NOTIFICATION_FIXED_PROCESS: { + + + } break; + } + +} +void CollisionPolygonEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} + + +Vector2 CollisionPolygonEditor::snap_point(const Vector2& p_point) const { + + if (canvas_item_editor->is_snap_active()) { + + return p_point.snapped(Vector2(1,1)*canvas_item_editor->get_snap()); + + } else { + return p_point; + } +} + +void CollisionPolygonEditor::_menu_option(int p_option) { + + switch(p_option) { + + case MODE_CREATE: { + + mode=MODE_CREATE; + button_create->set_pressed(true); + button_edit->set_pressed(false); + } break; + case MODE_EDIT: { + + mode=MODE_EDIT; + button_create->set_pressed(false); + button_edit->set_pressed(true); + } break; + + } +} + +void CollisionPolygonEditor::_wip_close() { + + undo_redo->create_action("Create Poly"); + undo_redo->add_undo_method(node,"set_polygon",node->get_polygon()); + undo_redo->add_do_method(node,"set_polygon",wip); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + wip.clear(); + wip_active=false; + mode=MODE_EDIT; + button_edit->set_pressed(true); + button_create->set_pressed(false); + edited_point=-1; +} + +bool CollisionPolygonEditor::forward_input_event(const InputEvent& p_event) { + + switch(p_event.type) { + + case InputEvent::MOUSE_BUTTON: { + + const InputEventMouseButton &mb=p_event.mouse_button; + + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + + + Vector2 gpoint = Point2(mb.x,mb.y); + Vector2 cpoint = xform.affine_inverse().xform(gpoint); + + Vector<Vector2> poly = node->get_polygon(); + + //first check if a point is to be added (segment split) + real_t grab_treshold=EDITOR_DEF("poly_editor/point_grab_radius",8); + + switch(mode) { + + + case MODE_CREATE: { + + if (mb.button_index==BUTTON_LEFT && mb.pressed) { + + + if (!wip_active) { + + wip.clear(); + wip.push_back( snap_point(cpoint) ); + wip_active=true; + edited_point_pos=snap_point(cpoint); + canvas_item_editor->update(); + edited_point=1; + return true; + } else { + + if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_treshold) { + //wip closed + _wip_close(); + + return true; + } else { + + wip.push_back( snap_point(cpoint) ); + edited_point=wip.size(); + canvas_item_editor->update(); + return true; + + //add wip point + } + } + } else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) { + _wip_close(); + } + + + + } break; + + case MODE_EDIT: { + + if (mb.button_index==BUTTON_LEFT) { + if (mb.pressed) { + + if (mb.mod.control) { + + + if (poly.size() < 3) { + + undo_redo->create_action("Edit Poly"); + undo_redo->add_undo_method(node,"set_polygon",poly); + poly.push_back(cpoint); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + return true; + } + + //search edges + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { + + Vector2 points[2] ={ xform.xform(poly[i]), + xform.xform(poly[(i+1)%poly.size()]) }; + + Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points); + if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2) + continue; //not valid to reuse point + + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; + } + + + } + + if (closest_idx>=0) { + + pre_move_edit=poly; + poly.insert(closest_idx+1,snap_point(xform.affine_inverse().xform(closest_pos))); + edited_point=closest_idx+1; + edited_point_pos=snap_point(xform.affine_inverse().xform(closest_pos)); + node->set_polygon(poly); + canvas_item_editor->update(); + return true; + } + } else { + + //look for points to move + + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { + + Vector2 cp =xform.xform(poly[i]); + + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; + } + + } + + if (closest_idx>=0) { + + pre_move_edit=poly; + edited_point=closest_idx; + edited_point_pos=xform.affine_inverse().xform(closest_pos); + canvas_item_editor->update(); + return true; + } + } + } else { + + if (edited_point!=-1) { + + //apply + + ERR_FAIL_INDEX_V(edited_point,poly.size(),false); + poly[edited_point]=edited_point_pos; + undo_redo->create_action("Edit Poly"); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_undo_method(node,"set_polygon",pre_move_edit); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + + edited_point=-1; + return true; + } + } + } if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) { + + + + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { + + Vector2 cp =xform.xform(poly[i]); + + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; + } + + } + + if (closest_idx>=0) { + + + undo_redo->create_action("Edit Poly (Remove Point)"); + undo_redo->add_undo_method(node,"set_polygon",poly); + poly.remove(closest_idx); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + return true; + } + + } + + + + } break; + } + + + + } break; + case InputEvent::MOUSE_MOTION: { + + const InputEventMouseMotion &mm=p_event.mouse_motion; + + if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) { + + + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + + Vector2 gpoint = Point2(mm.x,mm.y); + edited_point_pos = snap_point(xform.affine_inverse().xform(gpoint)); + canvas_item_editor->update(); + + } + + } break; + } + + return false; +} +void CollisionPolygonEditor::_canvas_draw() { + + if (!node) + return; + + + Vector<Vector2> poly; + + if (wip_active) + poly=wip; + else + poly=node->get_polygon(); + + + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Ref<Texture> handle= get_icon("EditorHandle","EditorIcons"); + + int len = poly.size(); + + for(int i=0;i<poly.size();i++) { + + + Vector2 p,p2; + p = i==edited_point ? edited_point_pos : poly[i]; + if ((wip_active && i==poly.size()-1) || (((i+1)%poly.size())==edited_point)) + p2=edited_point_pos; + else + p2 = poly[(i+1)%poly.size()]; + + Vector2 point = xform.xform(p); + Vector2 next_point = xform.xform(p2); + + Color col=Color(1,0.3,0.1,0.8); + canvas_item_editor->draw_line(point,next_point,col,2); + canvas_item_editor->draw_texture(handle,point-handle->get_size()*0.5); + } +} + + + +void CollisionPolygonEditor::edit(Node *p_collision_polygon) { + + if (!canvas_item_editor) { + canvas_item_editor=CanvasItemEditor::get_singleton(); + } + + if (p_collision_polygon) { + + node=p_collision_polygon->cast_to<CollisionPolygon2D>(); + if (!canvas_item_editor->is_connected("draw",this,"_canvas_draw")) + canvas_item_editor->connect("draw",this,"_canvas_draw"); + wip.clear(); + wip_active=false; + edited_point=-1; + + } else { + node=NULL; + + if (canvas_item_editor->is_connected("draw",this,"_canvas_draw")) + canvas_item_editor->disconnect("draw",this,"_canvas_draw"); + + } + +} + +void CollisionPolygonEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_menu_option"),&CollisionPolygonEditor::_menu_option); + ObjectTypeDB::bind_method(_MD("_canvas_draw"),&CollisionPolygonEditor::_canvas_draw); + +} + +CollisionPolygonEditor::CollisionPolygonEditor(EditorNode *p_editor) { + + canvas_item_editor=NULL; + editor=p_editor; + undo_redo = editor->get_undo_redo(); + + add_child( memnew( VSeparator )); + button_create = memnew( ToolButton ); + add_child(button_create); + button_create->connect("pressed",this,"_menu_option",varray(MODE_CREATE)); + button_create->set_toggle_mode(true); + + button_edit = memnew( ToolButton ); + add_child(button_edit); + button_edit->connect("pressed",this,"_menu_option",varray(MODE_EDIT)); + button_edit->set_toggle_mode(true); + + //add_constant_override("separation",0); + +#if 0 + options = memnew( MenuButton ); + add_child(options); + options->set_area_as_parent_rect(); + options->set_text("Polygon"); + //options->get_popup()->add_item("Parse BBCODE",PARSE_BBCODE); + options->get_popup()->connect("item_pressed", this,"_menu_option"); +#endif + + mode = MODE_EDIT; + wip_active=false; + +} + + +void CollisionPolygonEditorPlugin::edit(Object *p_object) { + + collision_polygon_editor->edit(p_object->cast_to<Node>()); +} + +bool CollisionPolygonEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("CollisionPolygon2D"); +} + +void CollisionPolygonEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + collision_polygon_editor->show(); + } else { + + collision_polygon_editor->hide(); + collision_polygon_editor->edit(NULL); + } + +} + +CollisionPolygonEditorPlugin::CollisionPolygonEditorPlugin(EditorNode *p_node) { + + editor=p_node; + collision_polygon_editor = memnew( CollisionPolygonEditor(p_node) ); + CanvasItemEditor::get_singleton()->add_control_to_menu_panel(collision_polygon_editor); + + collision_polygon_editor->hide(); + + + +} + + +CollisionPolygonEditorPlugin::~CollisionPolygonEditorPlugin() +{ +} + diff --git a/tools/editor/plugins/collision_polygon_editor_plugin.h b/tools/editor/plugins/collision_polygon_editor_plugin.h new file mode 100644 index 000000000..a05ac0f8c --- /dev/null +++ b/tools/editor/plugins/collision_polygon_editor_plugin.h @@ -0,0 +1,111 @@ +/*************************************************************************/ +/* collision_polygon_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef COLLISION_POLYGON_EDITOR_PLUGIN_H +#define COLLISION_POLYGON_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/2d/collision_polygon_2d.h" +#include "scene/gui/tool_button.h" +#include "scene/gui/button_group.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ +class CanvasItemEditor; + +class CollisionPolygonEditor : public HBoxContainer { + + OBJ_TYPE(CollisionPolygonEditor, HBoxContainer ); + + UndoRedo *undo_redo; + enum Mode { + + MODE_CREATE, + MODE_EDIT, + + }; + + Mode mode; + + ToolButton *button_create; + ToolButton *button_edit; + + CanvasItemEditor *canvas_item_editor; + EditorNode *editor; + Panel *panel; + CollisionPolygon2D *node; + MenuButton *options; + + int edited_point; + Vector2 edited_point_pos; + Vector<Vector2> pre_move_edit; + Vector<Vector2> wip; + bool wip_active; + + + void _wip_close(); + void _canvas_draw(); + void _menu_option(int p_option); + +protected: + void _notification(int p_what); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + Vector2 snap_point(const Vector2& p_point) const; + bool forward_input_event(const InputEvent& p_event); + void edit(Node *p_collision_polygon); + CollisionPolygonEditor(EditorNode *p_editor); +}; + +class CollisionPolygonEditorPlugin : public EditorPlugin { + + OBJ_TYPE( CollisionPolygonEditorPlugin, EditorPlugin ); + + CollisionPolygonEditor *collision_polygon_editor; + EditorNode *editor; + +public: + + virtual bool forward_input_event(const InputEvent& p_event) { return collision_polygon_editor->forward_input_event(p_event); } + + virtual String get_name() const { return "CollisionPolygon"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + CollisionPolygonEditorPlugin(EditorNode *p_node); + ~CollisionPolygonEditorPlugin(); + +}; + +#endif // COLLISION_POLYGON_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/control_editor_plugin.cpp b/tools/editor/plugins/control_editor_plugin.cpp new file mode 100644 index 000000000..8d8e107f4 --- /dev/null +++ b/tools/editor/plugins/control_editor_plugin.cpp @@ -0,0 +1,825 @@ +/*************************************************************************/ +/* control_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#if 0 +#include "control_editor_plugin.h" +#include "print_string.h" +#include "editor_node.h" +#include "os/keyboard.h" +#include "scene/main/viewport.h" + +void ControlEditor::_add_control(Control *p_control,const EditInfo& p_info) { + + if (controls.has(p_control)) + return; + + controls.insert(p_control,p_info); + p_control->call_deferred("connect","visibility_changed",this,"_visibility_changed",varray(p_control->get_instance_ID())); +} + +void ControlEditor::_remove_control(Control *p_control) { + + p_control->call_deferred("disconnect","visibility_changed",this,"_visibility_changed"); + controls.erase(p_control); +} +void ControlEditor::_clear_controls(){ + + while(controls.size()) + _remove_control(controls.front()->key()); +} + +void ControlEditor::_visibility_changed(ObjectID p_control) { + + Object *c = ObjectDB::get_instance(p_control); + if (!c) + return; + Control *ct = c->cast_to<Control>(); + if (!ct) + return; + + _remove_control(ct); +} + + +void ControlEditor::_node_removed(Node *p_node) { + + Control *control = (Control*)p_node; //not a good cast, but safe + if (controls.has(control)) + _remove_control(control); + + if (current_window==p_node) { + _clear_controls(); + } + update(); +} + +// slow as hell +Control* ControlEditor::_select_control_at_pos(const Point2& p_pos,Node* p_node) { + + for (int i=p_node->get_child_count()-1;i>=0;i--) { + + Control *r=_select_control_at_pos(p_pos,p_node->get_child(i)); + if (r) + return r; + } + + Control *c=p_node->cast_to<Control>(); + + if (c) { + Rect2 rect = c->get_window_rect(); + if (c->get_window()==current_window) { + rect.pos=transform.xform(rect.pos).floor(); + } + if (rect.has_point(p_pos)) + return c; + } + + return NULL; +} + + +void ControlEditor::_key_move(const Vector2& p_dir, bool p_snap) { + + if (drag!=DRAG_NONE) + return; + + Vector2 motion=p_dir; + if (p_snap) + motion*=snap_val->get_text().to_double(); + + undo_redo->create_action("Edit Control"); + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + Control *control = E->key(); + undo_redo->add_do_method(control,"set_pos",control->get_pos()+motion); + undo_redo->add_undo_method(control,"set_pos",control->get_pos()); + } + undo_redo->commit_action(); +} + + +void ControlEditor::_input_event(InputEvent p_event) { + + if (p_event.type==InputEvent::MOUSE_BUTTON) { + + const InputEventMouseButton &b=p_event.mouse_button; + + if (b.button_index==BUTTON_RIGHT) { + + if (controls.size() && drag!=DRAG_NONE) { + //cancel drag + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + Control *control = E->key(); + control->set_pos(E->get().drag_pos); + control->set_size(E->get().drag_size); + } + + } else if (b.pressed) { + popup->set_pos(Point2(b.x,b.y)); + popup->popup(); + } + return; + } + //if (!controls.size()) + // return; + + if (b.button_index!=BUTTON_LEFT) + return; + + if (!b.pressed) { + + if (drag!=DRAG_NONE) { + + if (undo_redo) { + + undo_redo->create_action("Edit Control"); + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + Control *control = E->key(); + undo_redo->add_do_method(control,"set_pos",control->get_pos()); + undo_redo->add_do_method(control,"set_size",control->get_size()); + undo_redo->add_undo_method(control,"set_pos",E->get().drag_pos); + undo_redo->add_undo_method(control,"set_size",E->get().drag_size); + } + undo_redo->commit_action(); + } + + drag=DRAG_NONE; + + } + return; + } + + + if (controls.size()==1) { + //try single control edit + Control *control = controls.front()->key(); + ERR_FAIL_COND(!current_window); + + Rect2 rect=control->get_window_rect(); + Point2 ofs=Point2();//get_global_pos(); + Rect2 draw_rect=Rect2(rect.pos-ofs,rect.size); + Point2 click=Point2(b.x,b.y); + click = transform.affine_inverse().xform(click); + Size2 handle_size=Size2(handle_len,handle_len); + + drag = DRAG_NONE; + + if (Rect2(draw_rect.pos-handle_size,handle_size).has_point(click)) + drag=DRAG_TOP_LEFT; + else if (Rect2(draw_rect.pos+draw_rect.size,handle_size).has_point(click)) + drag=DRAG_BOTTOM_RIGHT; + else if(Rect2(draw_rect.pos+Point2(draw_rect.size.width,-handle_size.y),handle_size).has_point(click)) + drag=DRAG_TOP_RIGHT; + else if (Rect2(draw_rect.pos+Point2(-handle_size.x,draw_rect.size.height),handle_size).has_point(click)) + drag=DRAG_BOTTOM_LEFT; + else if (Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),-handle_size.height),handle_size).has_point(click)) + drag=DRAG_TOP; + else if( Rect2(draw_rect.pos+Point2(-handle_size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size).has_point(click)) + drag=DRAG_LEFT; + else if ( Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),draw_rect.size.height),handle_size).has_point(click)) + drag=DRAG_BOTTOM; + else if( Rect2(draw_rect.pos+Point2(draw_rect.size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size).has_point(click)) + drag=DRAG_RIGHT; + + if (drag!=DRAG_NONE) { + drag_from=click; + controls[control].drag_pos=control->get_pos(); + controls[control].drag_size=control->get_size(); + controls[control].drag_limit=drag_from+controls[control].drag_size-control->get_minimum_size(); + return; + } + + + } + + //multi control edit + + Point2 click=Point2(b.x,b.y); + Node* scene = get_scene()->get_root_node()->cast_to<EditorNode>()->get_edited_scene(); + if (!scene) + return; + /* + if (current_window) { + //no window.... ? + click-=current_window->get_scroll(); + }*/ + Control *c=_select_control_at_pos(click, scene); + + Node* n = c; + while ((n && n != scene && n->get_owner() != scene) || (n && !n->is_type("Control"))) { + n = n->get_parent(); + }; + c = n->cast_to<Control>(); + + + if (b.mod.control) { //additive selection + + if (!c) + return; //nothing to add + + if (current_window && controls.size() && c->get_window()!=current_window) + return; //cant multiple select from multiple windows + + if (!controls.size()) + current_window=c->get_window(); + + if (controls.has(c)) { + //already in here, erase it + _remove_control(c); + update(); + return; + } + + //check parents! + Control *parent = c->get_parent()->cast_to<Control>(); + + while(parent) { + + if (controls.has(parent)) + return; //a parent is already selected, so this is pointless + parent=parent->get_parent()->cast_to<Control>(); + } + + //check childrens of everything! + List<Control*> to_erase; + + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + parent = E->key()->get_parent()->cast_to<Control>(); + while(parent) { + if (parent==c) { + to_erase.push_back(E->key()); + break; + } + parent=parent->get_parent()->cast_to<Control>(); + } + } + + while(to_erase.size()) { + _remove_control(to_erase.front()->get()); + to_erase.pop_front(); + } + + _add_control(c,EditInfo()); + update(); + } else { + //regular selection + if (!c) { + _clear_controls(); + update(); + return; + } + + if (!controls.has(c)) { + _clear_controls(); + current_window=c->get_window(); + _add_control(c,EditInfo()); + //reselect + if (get_scene()->is_editor_hint()) { + get_scene()->get_root_node()->call("edit_node",c); + } + + } + + + + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + + EditInfo &ei=E->get(); + Control *control=E->key(); + ei.drag_pos=control->get_pos(); + ei.drag_size=control->get_size(); + ei.drag_limit=drag_from+ei.drag_size-control->get_minimum_size(); + } + + drag=DRAG_ALL; + drag_from=click; + update(); + } + + } + + if (p_event.type==InputEvent::MOUSE_MOTION) { + + const InputEventMouseMotion &m=p_event.mouse_motion; + + if (drag==DRAG_NONE || !current_window) + return; + + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + + Control *control = E->key(); + Point2 control_drag_pos=E->get().drag_pos; + Point2 control_drag_size=E->get().drag_size; + Point2 control_drag_limit=E->get().drag_limit; + + Point2 pos=Point2(m.x,m.y); + pos = transform.affine_inverse().xform(pos); + + switch(drag) { + case DRAG_ALL: { + + control->set_pos( snapify(control_drag_pos+(pos-drag_from)) ); + } break; + case DRAG_RIGHT: { + + control->set_size( snapify(Size2(control_drag_size.width+(pos-drag_from).x,control_drag_size.height)) ); + } break; + case DRAG_BOTTOM: { + + control->set_size( snapify(Size2(control_drag_size.width,control_drag_size.height+(pos-drag_from).y)) ); + } break; + case DRAG_BOTTOM_RIGHT: { + + control->set_size( snapify(control_drag_size+(pos-drag_from)) ); + } break; + case DRAG_TOP_LEFT: { + + if(pos.x>control_drag_limit.x) + pos.x=control_drag_limit.x; + if(pos.y>control_drag_limit.y) + pos.y=control_drag_limit.y; + + Point2 old_size = control->get_size(); + Point2 new_pos = snapify(control_drag_pos+(pos-drag_from)); + Point2 new_size = old_size + (control->get_pos() - new_pos); + + control->set_pos( new_pos ); + control->set_size( new_size ); + } break; + case DRAG_TOP: { + + if(pos.y>control_drag_limit.y) + pos.y=control_drag_limit.y; + + Point2 old_size = control->get_size(); + Point2 new_pos = snapify(control_drag_pos+Point2(0,pos.y-drag_from.y)); + Point2 new_size = old_size + (control->get_pos() - new_pos); + + control->set_pos( new_pos ); + control->set_size( new_size ); + } break; + case DRAG_LEFT: { + + if(pos.x>control_drag_limit.x) + pos.x=control_drag_limit.x; + + Point2 old_size = control->get_size(); + Point2 new_pos = snapify(control_drag_pos+Point2(pos.x-drag_from.x,0)); + Point2 new_size = old_size + (control->get_pos() - new_pos); + + control->set_pos( new_pos ); + control->set_size( new_size ); + + } break; + case DRAG_TOP_RIGHT: { + + if(pos.y>control_drag_limit.y) + pos.y=control_drag_limit.y; + + Point2 old_size = control->get_size(); + Point2 new_pos = snapify(control_drag_pos+Point2(0,pos.y-drag_from.y)); + + float new_size_y = Point2( old_size + (control->get_pos() - new_pos)).y; + float new_size_x = snapify(control_drag_size+Point2(pos.x-drag_from.x,0)).x; + + control->set_pos( new_pos ); + control->set_size( Point2(new_size_x, new_size_y) ); + } break; + case DRAG_BOTTOM_LEFT: { + + if(pos.x>control_drag_limit.x) + pos.x=control_drag_limit.x; + + Point2 old_size = control->get_size(); + Point2 new_pos = snapify(control_drag_pos+Point2(pos.x-drag_from.x,0)); + + float new_size_y = snapify(control_drag_size+Point2(0,pos.y-drag_from.y)).y; + float new_size_x = Point2( old_size + (control->get_pos() - new_pos)).x; + + control->set_pos( new_pos ); + control->set_size( Point2(new_size_x, new_size_y) ); + + + } break; + + default:{} + } + } + } + + if (p_event.type==InputEvent::KEY) { + + const InputEventKey &k=p_event.key; + + if (k.pressed) { + + if (k.scancode==KEY_UP) + _key_move(Vector2(0,-1),k.mod.shift); + else if (k.scancode==KEY_DOWN) + _key_move(Vector2(0,1),k.mod.shift); + else if (k.scancode==KEY_LEFT) + _key_move(Vector2(-1,0),k.mod.shift); + else if (k.scancode==KEY_RIGHT) + _key_move(Vector2(1,0),k.mod.shift); + } + + } + + +} + + +bool ControlEditor::get_remove_list(List<Node*> *p_list) { + + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + + p_list->push_back(E->key()); + } + + return !p_list->empty(); +} + +void ControlEditor::_update_scroll(float) { + + if (updating_scroll) + return; + + if (!current_window) + return; + + Point2 ofs; + ofs.x=h_scroll->get_val(); + ofs.y=v_scroll->get_val(); + +// current_window->set_scroll(-ofs); + + transform=Matrix32(); + + transform.scale_basis(Size2(zoom,zoom)); + transform.elements[2]=-ofs*zoom; + + + RID viewport = editor->get_scene_root()->get_viewport(); + + VisualServer::get_singleton()->viewport_set_global_canvas_transform(viewport,transform); + + update(); + +} + +void ControlEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_PROCESS) { + + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + + Control *control = E->key(); + Rect2 r=control->get_window_rect(); + if (r != E->get().last_rect ) { + update(); + E->get().last_rect=r; + } + } + + } + + if (p_what==NOTIFICATION_CHILDREN_CONFIGURED) { + + get_scene()->connect("node_removed",this,"_node_removed"); + } + + if (p_what==NOTIFICATION_DRAW) { + + // TODO fetch the viewport? + /* + if (!control) { + h_scroll->hide(); + v_scroll->hide(); + return; + } + */ + _update_scrollbars(); + + if (!current_window) + return; + + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + + Control *control = E->key(); + + Rect2 rect=control->get_window_rect(); + RID ci=get_canvas_item(); + VisualServer::get_singleton()->canvas_item_set_clip(ci,true); + Point2 ofs=Point2();//get_global_pos(); + Rect2 draw_rect=Rect2(rect.pos-ofs,rect.size); + draw_rect.pos = transform.xform(draw_rect.pos); + Color light_edit_color=Color(1.0,0.8,0.8); + Color dark_edit_color=Color(0.4,0.1,0.1); + Size2 handle_size=Size2(handle_len,handle_len); + +#define DRAW_RECT( m_rect, m_color )\ +VisualServer::get_singleton()->canvas_item_add_rect(ci,m_rect,m_color); + +#define DRAW_EMPTY_RECT( m_rect, m_color )\ + DRAW_RECT( Rect2(m_rect.pos,Size2(m_rect.size.width,1)), m_color );\ + DRAW_RECT(Rect2(Point2(m_rect.pos.x,m_rect.pos.y+m_rect.size.height-1),Size2(m_rect.size.width,1)), m_color);\ + DRAW_RECT(Rect2(m_rect.pos,Size2(1,m_rect.size.height)), m_color);\ + DRAW_RECT(Rect2(Point2(m_rect.pos.x+m_rect.size.width-1,m_rect.pos.y),Size2(1,m_rect.size.height)), m_color); + +#define DRAW_BORDER_RECT( m_rect, m_border_color,m_color )\ + DRAW_RECT( m_rect, m_color );\ + DRAW_EMPTY_RECT( m_rect, m_border_color ); + + DRAW_EMPTY_RECT( draw_rect.grow(2), light_edit_color ); + DRAW_EMPTY_RECT( draw_rect.grow(1), dark_edit_color ); + + if (controls.size()==1) { + DRAW_BORDER_RECT( Rect2(draw_rect.pos-handle_size,handle_size), light_edit_color,dark_edit_color ); + DRAW_BORDER_RECT( Rect2(draw_rect.pos+draw_rect.size,handle_size), light_edit_color,dark_edit_color ); + DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(draw_rect.size.width,-handle_size.y),handle_size), light_edit_color,dark_edit_color ); + DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(-handle_size.x,draw_rect.size.height),handle_size), light_edit_color,dark_edit_color ); + + DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),-handle_size.height),handle_size), light_edit_color,dark_edit_color ); + DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(-handle_size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size), light_edit_color,dark_edit_color ); + DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(Math::floor((draw_rect.size.width-handle_size.x)/2.0),draw_rect.size.height),handle_size), light_edit_color,dark_edit_color ); + DRAW_BORDER_RECT( Rect2(draw_rect.pos+Point2(draw_rect.size.width,Math::floor((draw_rect.size.height-handle_size.y)/2.0)),handle_size), light_edit_color,dark_edit_color ); + } + + //DRAW_EMPTY_RECT( Rect2( current_window->get_scroll()-Point2(1,1), get_size()+Size2(2,2)), Color(0.8,0.8,1.0,0.8) ); + E->get().last_rect = rect; + } + } +} + +void ControlEditor::edit(Control *p_control) { + + drag=DRAG_NONE; + + _clear_controls(); + _add_control(p_control,EditInfo()); + current_window=p_control->get_window(); + update(); + +} + + +void ControlEditor::_find_controls_span(Node *p_node, Rect2& r_rect) { + + if (!editor->get_scene()) + return; + + if (p_node!=editor->get_edited_scene() && p_node->get_owner()!=editor->get_edited_scene()) + return; + + if (p_node->cast_to<Control>()) { + Control *c = p_node->cast_to<Control>(); + if (c->get_viewport() != editor->get_viewport()->get_viewport()) + return; //bye, it's in another viewport + + if (!c->get_parent_control()) { + + Rect2 span = c->get_subtree_span_rect(); + r_rect.merge(span); + } + } + + for(int i=0;i<p_node->get_child_count();i++) { + + _find_controls_span(p_node->get_child(i),r_rect); + } +} + +void ControlEditor::_update_scrollbars() { + + + if (!editor->get_scene()) { + h_scroll->hide(); + v_scroll->hide(); + return; + } + + updating_scroll=true; + + + Size2 size = get_size(); + Size2 hmin = h_scroll->get_minimum_size(); + Size2 vmin = v_scroll->get_minimum_size(); + + v_scroll->set_begin( Point2(size.width - vmin.width, 0) ); + v_scroll->set_end( Point2(size.width, size.height) ); + + h_scroll->set_begin( Point2( 0, size.height - hmin.height) ); + h_scroll->set_end( Point2(size.width-vmin.width, size.height) ); + + + Rect2 local_rect = Rect2(Point2(),get_size()-Size2(vmin.width,hmin.height)); + + Rect2 control_rect=local_rect; + if (editor->get_edited_scene()) + _find_controls_span(editor->get_edited_scene(),control_rect); + control_rect.pos*=zoom; + control_rect.size*=zoom; + + /* + for(ControlMap::Element *E=controls.front();E;E=E->next()) { + + Control *control = E->key(); + Rect2 r = control->get_window()->get_subtree_span_rect(); + if (E==controls.front()) { + control_rect = r.merge(local_rect); + } else { + control_rect = control_rect.merge(r); + } + } + + */ + Point2 ofs; + + + if (control_rect.size.height <= local_rect.size.height) { + + v_scroll->hide(); + ofs.y=0; + } else { + + v_scroll->show(); + v_scroll->set_min(control_rect.pos.y); + v_scroll->set_max(control_rect.pos.y+control_rect.size.y); + v_scroll->set_page(local_rect.size.y); + ofs.y=-v_scroll->get_val(); + } + + if (control_rect.size.width <= local_rect.size.width) { + + h_scroll->hide(); + ofs.x=0; + } else { + + h_scroll->show(); + h_scroll->set_min(control_rect.pos.x); + h_scroll->set_max(control_rect.pos.x+control_rect.size.x); + h_scroll->set_page(local_rect.size.x); + ofs.x=-h_scroll->get_val(); + } + +// transform=Matrix32(); + transform.elements[2]=ofs*zoom; + RID viewport = editor->get_scene_root()->get_viewport(); + VisualServer::get_singleton()->viewport_set_global_canvas_transform(viewport,transform); + +// transform.scale_basis(Vector2(zoom,zoom)); + updating_scroll=false; + +} + + +Point2i ControlEditor::snapify(const Point2i& p_pos) const { + + bool active=popup->is_item_checked(0); + int snap = snap_val->get_text().to_int(); + + if (!active || snap<1) + return p_pos; + + Point2i pos=p_pos; + pos.x-=pos.x%snap; + pos.y-=pos.y%snap; + return pos; + + +} +void ControlEditor::_popup_callback(int p_op) { + + switch(p_op) { + + case SNAP_USE: { + + popup->set_item_checked(0,!popup->is_item_checked(0)); + } break; + case SNAP_CONFIGURE: { + snap_dialog->popup_centered(Size2(200,85)); + } break; + } +} + +void ControlEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_input_event",&ControlEditor::_input_event); + ObjectTypeDB::bind_method("_node_removed",&ControlEditor::_node_removed); + ObjectTypeDB::bind_method("_update_scroll",&ControlEditor::_update_scroll); + ObjectTypeDB::bind_method("_popup_callback",&ControlEditor::_popup_callback); + ObjectTypeDB::bind_method("_visibility_changed",&ControlEditor::_visibility_changed); +} + +ControlEditor::ControlEditor(EditorNode *p_editor) { + + editor=p_editor; + h_scroll = memnew( HScrollBar ); + v_scroll = memnew( VScrollBar ); + + add_child(h_scroll); + add_child(v_scroll); + h_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),true); + v_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),true); + + + updating_scroll=false; + set_focus_mode(FOCUS_ALL); + handle_len=10; + + popup=memnew( PopupMenu ); + popup->add_check_item("Use Snap"); + popup->add_item("Configure Snap.."); + add_child(popup); + + snap_dialog = memnew( ConfirmationDialog ); + snap_dialog->get_ok()->hide(); + snap_dialog->get_cancel()->set_text("Close"); + add_child(snap_dialog); + + Label *l = memnew(Label); + l->set_text("Snap:"); + l->set_pos(Point2(5,5)); + snap_dialog->add_child(l); + + snap_val=memnew(LineEdit); + snap_val->set_text("5"); + snap_val->set_anchor(MARGIN_RIGHT,ANCHOR_END); + snap_val->set_begin(Point2(15,25)); + snap_val->set_end(Point2(10,25)); + snap_dialog->add_child(snap_val); + + popup->connect("item_pressed", this,"_popup_callback"); + current_window=NULL; + + zoom=0.5; +} + + +void ControlEditorPlugin::edit(Object *p_object) { + + control_editor->set_undo_redo(&get_undo_redo()); + control_editor->edit(p_object->cast_to<Control>()); +} + +bool ControlEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Control"); +} + +void ControlEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + control_editor->show(); + control_editor->set_process(true); + } else { + + control_editor->hide(); + control_editor->set_process(false); + } + +} + +ControlEditorPlugin::ControlEditorPlugin(EditorNode *p_node) { + + editor=p_node; + control_editor = memnew( ControlEditor(editor) ); + editor->get_viewport()->add_child(control_editor); + control_editor->set_area_as_parent_rect(); + control_editor->hide(); + + + +} + + +ControlEditorPlugin::~ControlEditorPlugin() +{ +} + + +#endif diff --git a/tools/editor/plugins/control_editor_plugin.h b/tools/editor/plugins/control_editor_plugin.h new file mode 100644 index 000000000..a22932799 --- /dev/null +++ b/tools/editor/plugins/control_editor_plugin.h @@ -0,0 +1,141 @@ +/*************************************************************************/ +/* control_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef CONTROL_EDITOR_PLUGIN_H +#define CONTROL_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +#if 0 +class ControlEditor : public Control { + + OBJ_TYPE(ControlEditor, Control ); + + EditorNode *editor; + + enum { + SNAP_USE, + SNAP_CONFIGURE + }; + + enum DragType { + DRAG_NONE, + DRAG_LEFT, + DRAG_TOP_LEFT, + DRAG_TOP, + DRAG_TOP_RIGHT, + DRAG_RIGHT, + DRAG_BOTTOM_RIGHT, + DRAG_BOTTOM, + DRAG_BOTTOM_LEFT, + DRAG_ALL + }; + + HScrollBar *h_scroll; + VScrollBar *v_scroll; + + Matrix32 transform; + float zoom; + + Control *current_window; + PopupMenu *popup; + DragType drag; + Point2 drag_from; + + struct EditInfo { + + Point2 drag_pos; + Point2 drag_size; + Point2 drag_limit; + Rect2 last_rect; + }; + + typedef Map<Control*,EditInfo> ControlMap; + ControlMap controls; + int handle_len; + Control* _select_control_at_pos(const Point2& p_pos,Node* p_node); + + ConfirmationDialog *snap_dialog; + LineEdit *snap_val; + + void _add_control(Control *p_control,const EditInfo& p_info); + void _remove_control(Control *p_control); + void _clear_controls(); + void _visibility_changed(ObjectID p_control); + void _key_move(const Vector2& p_dir, bool p_snap); + + + Point2i snapify(const Point2i& p_pos) const; + void _popup_callback(int p_op); + bool updating_scroll; + void _update_scroll(float); + void _update_scrollbars(); + UndoRedo *undo_redo; + + void _find_controls_span(Node *p_node, Rect2& r_rect); + +protected: + void _notification(int p_what); + void _input_event(InputEvent p_event); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + bool get_remove_list(List<Node*> *p_list); + void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; } + void edit(Control *p_control); + ControlEditor(EditorNode *p_editor); +}; + +class ControlEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ControlEditorPlugin, EditorPlugin ); + + ControlEditor *control_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "GUI"; } + bool has_main_screen() const { return true; } + virtual void edit(Object *p_object); + virtual bool handles(Object *p_object) const; + virtual void make_visible(bool p_visible); + virtual bool get_remove_list(List<Node*> *p_list) { return control_editor->get_remove_list(p_list); } + + + ControlEditorPlugin(EditorNode *p_node); + ~ControlEditorPlugin(); + +}; +#endif +#endif diff --git a/tools/editor/plugins/cube_grid_theme_editor_plugin.cpp b/tools/editor/plugins/cube_grid_theme_editor_plugin.cpp new file mode 100644 index 000000000..aad7cf2c6 --- /dev/null +++ b/tools/editor/plugins/cube_grid_theme_editor_plugin.cpp @@ -0,0 +1,343 @@ +/*************************************************************************/ +/* cube_grid_theme_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "cube_grid_theme_editor_plugin.h" + +#include "scene/3d/mesh_instance.h" +#include "scene/3d/physics_body.h" +#include "scene/main/viewport.h" +#include "scene/resources/packed_scene.h" +#include "tools/editor/editor_node.h" +#include "main/main.h" +#include "tools/editor/editor_settings.h" + +void MeshLibraryEditor::edit(const Ref<MeshLibrary>& p_theme) { + + theme=p_theme; + if (theme.is_valid()) + menu->get_popup()->set_item_disabled(menu->get_popup()->get_item_index(MENU_OPTION_UPDATE_FROM_SCENE),!theme->has_meta("_editor_source_scene")); + +} + +void MeshLibraryEditor::_menu_confirm() { + + + switch(option) { + + case MENU_OPTION_REMOVE_ITEM: { + + theme->remove_item(to_erase); + } break; + case MENU_OPTION_UPDATE_FROM_SCENE: { + String existing = theme->get_meta("_editor_source_scene"); + ERR_FAIL_COND(existing==""); + _import_scene_cbk(existing); + + } break; + default: {}; + } + +} + + +void MeshLibraryEditor::_import_scene(Node *p_scene, Ref<MeshLibrary> p_library, bool p_merge) { + + if (!p_merge) + p_library->clear(); + + + for(int i=0;i<p_scene->get_child_count();i++) { + + + Node *child = p_scene->get_child(i); + + if (!child->cast_to<MeshInstance>()) { + if (child->get_child_count()>0) { + child=child->get_child(0); + if (!child->cast_to<MeshInstance>()) { + continue; + } + + } else + continue; + + + } + + MeshInstance *mi = child->cast_to<MeshInstance>(); + Ref<Mesh> mesh=mi->get_mesh(); + if (mesh.is_null()) + continue; + + int id = p_library->find_item_name(mi->get_name()); + if (id<0) { + + id=p_library->get_last_unused_item_id(); + p_library->create_item(id); + p_library->set_item_name(id,mi->get_name()); + } + + + p_library->set_item_mesh(id,mesh); + + Ref<Shape> collision; + + for(int j=0;j<mi->get_child_count();j++) { +#if 1 + Node *child2 = mi->get_child(j); + if (!child2->cast_to<StaticBody>()) + continue; + StaticBody *sb = child2->cast_to<StaticBody>(); + if (sb->get_shape_count()==0) + continue; + collision=sb->get_shape(0); + if (!collision.is_null()) + break; +#endif + } + + if (!collision.is_null()) { + + p_library->set_item_shape(id,collision); + } + + } + + + //generate previews! + + if (1) { + Vector<int> ids = p_library->get_item_list(); + RID vp = VS::get_singleton()->viewport_create(); + VS::ViewportRect vr; + vr.x=0; + vr.y=0; + vr.width=EditorSettings::get_singleton()->get("grid_map/preview_size"); + vr.height=EditorSettings::get_singleton()->get("grid_map/preview_size"); + VS::get_singleton()->viewport_set_rect(vp,vr); + VS::get_singleton()->viewport_set_as_render_target(vp,true); + VS::get_singleton()->viewport_set_render_target_update_mode(vp,VS::RENDER_TARGET_UPDATE_ALWAYS); + RID scen = VS::get_singleton()->scenario_create(); + VS::get_singleton()->viewport_set_scenario(vp,scen); + RID cam = VS::get_singleton()->camera_create(); + VS::get_singleton()->camera_set_transform(cam, Transform() ); + VS::get_singleton()->viewport_attach_camera(vp,cam); + RID light = VS::get_singleton()->light_create(VS::LIGHT_DIRECTIONAL); + RID lightinst = VS::get_singleton()->instance_create2(light,scen); + VS::get_singleton()->camera_set_orthogonal(cam,1.0,0.01,1000.0); + + + EditorProgress ep("mlib","Creating Mesh Library",ids.size()); + + for(int i=0;i<ids.size();i++) { + + int id=ids[i]; + Ref<Mesh> mesh = p_library->get_item_mesh(id); + if (!mesh.is_valid()) + continue; + AABB aabb= mesh->get_aabb(); + print_line("aabb: "+aabb); + Vector3 ofs = aabb.pos + aabb.size*0.5; + aabb.pos-=ofs; + Transform xform; + xform.basis=Matrix3().rotated(Vector3(0,1,0),Math_PI*0.25); + xform.basis = Matrix3().rotated(Vector3(1,0,0),-Math_PI*0.25)*xform.basis; + AABB rot_aabb = xform.xform(aabb); + print_line("rot_aabb: "+rot_aabb); + float m = MAX(rot_aabb.size.x,rot_aabb.size.y)*0.5; + if (m==0) + continue; + m=1.0/m; + m*=0.5; + print_line("scale: "+rtos(m)); + xform.basis.scale(Vector3(m,m,m)); + xform.origin=-xform.basis.xform(ofs); //-ofs*m; + xform.origin.z-=rot_aabb.size.z*2; + RID inst = VS::get_singleton()->instance_create2(mesh->get_rid(),scen); + VS::get_singleton()->instance_set_transform(inst,xform); + ep.step("Thumbnail..",i); + VS::get_singleton()->viewport_queue_screen_capture(vp); + Main::iteration(); + Image img = VS::get_singleton()->viewport_get_screen_capture(vp); + ERR_CONTINUE(img.empty()); + Ref<ImageTexture> it( memnew( ImageTexture )); + it->create_from_image(img); + p_library->set_item_preview(id,it); + +// print_line("loaded image, size: "+rtos(m)+" dist: "+rtos(dist)+" empty?"+itos(img.empty())+" w: "+itos(it->get_width())+" h: "+itos(it->get_height())); + VS::get_singleton()->free(inst); + } + + VS::get_singleton()->free(lightinst); + VS::get_singleton()->free(light); + VS::get_singleton()->free(vp); + VS::get_singleton()->free(cam); + VS::get_singleton()->free(scen); + } + + +} + + +void MeshLibraryEditor::_import_scene_cbk(const String& p_str) { + + + print_line("Impot Callback!"); + + Ref<PackedScene> ps = ResourceLoader::load(p_str,"PackedScene"); + ERR_FAIL_COND(ps.is_null()); + Node *scene = ps->instance(); + + _import_scene(scene,theme,option==MENU_OPTION_UPDATE_FROM_SCENE); + + memdelete(scene); + theme->set_meta("_editor_source_scene",p_str); + menu->get_popup()->set_item_disabled(menu->get_popup()->get_item_index(MENU_OPTION_UPDATE_FROM_SCENE),false); + +} + +Error MeshLibraryEditor::update_library_file(Node *p_base_scene, Ref<MeshLibrary> ml,bool p_merge) { + + _import_scene(p_base_scene,ml,p_merge); + return OK; +} + + +void MeshLibraryEditor::_menu_cbk(int p_option) { + + option=p_option; + switch(p_option) { + + case MENU_OPTION_ADD_ITEM: { + + theme->create_item(theme->get_last_unused_item_id()); + } break; + case MENU_OPTION_REMOVE_ITEM: { + + String p = editor->get_property_editor()->get_selected_path(); + if (p.begins_with("/MeshLibrary/item") && p.get_slice_count("/")>=3) { + + to_erase = p.get_slice("/",3).to_int(); + cd->set_text("Remove Item "+itos(to_erase)+"?"); + cd->popup_centered(Size2(300,60)); + } + } break; + case MENU_OPTION_IMPORT_FROM_SCENE: { + + file->popup_centered_ratio(); + } break; + case MENU_OPTION_UPDATE_FROM_SCENE: { + + cd->set_text("Update from existing scene?:\n"+String(theme->get_meta("_editor_source_scene"))); + cd->popup_centered(Size2(500,60)); + } break; + } +} + + +void MeshLibraryEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_menu_cbk",&MeshLibraryEditor::_menu_cbk); + ObjectTypeDB::bind_method("_menu_confirm",&MeshLibraryEditor::_menu_confirm); + ObjectTypeDB::bind_method("_import_scene_cbk",&MeshLibraryEditor::_import_scene_cbk); +} + +MeshLibraryEditor::MeshLibraryEditor(EditorNode *p_editor) { + + file = memnew( FileDialog ); + file->set_mode(FileDialog::MODE_OPEN_FILE); + //not for now? + List<String> extensions; + ResourceLoader::get_recognized_extensions_for_type("PackedScene",&extensions); + file->clear_filters(); + file->set_title("Import Scene"); + for(int i=0;i<extensions.size();i++) { + + file->add_filter("*."+extensions[i]+" ; "+extensions[i].to_upper()); + } + add_child(file); + file->connect("file_selected",this,"_import_scene_cbk"); + + Panel *panel = memnew( Panel ); + panel->set_area_as_parent_rect(); + add_child(panel); + MenuButton * options = memnew( MenuButton ); + panel->add_child(options); + options->set_pos(Point2(1,1)); + options->set_text("Theme"); + options->get_popup()->add_item("Add Item",MENU_OPTION_ADD_ITEM); + options->get_popup()->add_item("Remove Selected Item",MENU_OPTION_REMOVE_ITEM); + options->get_popup()->add_separator(); + options->get_popup()->add_item("Import from Scene",MENU_OPTION_IMPORT_FROM_SCENE); + options->get_popup()->add_item("Update from Scene",MENU_OPTION_UPDATE_FROM_SCENE); + options->get_popup()->set_item_disabled(options->get_popup()->get_item_index(MENU_OPTION_UPDATE_FROM_SCENE),true); + options->get_popup()->connect("item_pressed", this,"_menu_cbk"); + menu=options; + editor=p_editor; + cd = memnew(ConfirmationDialog); + add_child(cd); + cd->get_ok()->connect("pressed", this,"_menu_confirm"); + +} + +void MeshLibraryEditorPlugin::edit(Object *p_node) { + + if (p_node && p_node->cast_to<MeshLibrary>()) { + theme_editor->edit( p_node->cast_to<MeshLibrary>() ); + theme_editor->show(); + } else + theme_editor->hide(); +} + +bool MeshLibraryEditorPlugin::handles(Object *p_node) const{ + + return p_node->is_type("MeshLibrary"); +} + +void MeshLibraryEditorPlugin::make_visible(bool p_visible){ + + if (p_visible) + theme_editor->show(); + else + theme_editor->hide(); +} + +MeshLibraryEditorPlugin::MeshLibraryEditorPlugin(EditorNode *p_node) { + + EDITOR_DEF("grid_map/preview_size",64); + theme_editor = memnew( MeshLibraryEditor(p_node) ); + + p_node->get_viewport()->add_child(theme_editor); + theme_editor->set_area_as_parent_rect(); + theme_editor->set_anchor( MARGIN_RIGHT, Control::ANCHOR_END ); + theme_editor->set_anchor( MARGIN_BOTTOM, Control::ANCHOR_BEGIN ); + theme_editor->set_end( Point2(0,22) ); + theme_editor->hide(); + +} + diff --git a/tools/editor/plugins/cube_grid_theme_editor_plugin.h b/tools/editor/plugins/cube_grid_theme_editor_plugin.h new file mode 100644 index 000000000..0dab1d12b --- /dev/null +++ b/tools/editor/plugins/cube_grid_theme_editor_plugin.h @@ -0,0 +1,95 @@ +/*************************************************************************/ +/* cube_grid_theme_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef CUBE_GRID_THEME_EDITOR_PLUGIN_H +#define CUBE_GRID_THEME_EDITOR_PLUGIN_H + +#include "scene/resources/mesh_library.h" +#include "tools/editor/editor_node.h" + + +class MeshLibraryEditor : public Control { + + OBJ_TYPE( MeshLibraryEditor, Control ); + + Ref<MeshLibrary> theme; + + EditorNode *editor; + MenuButton *menu; + ConfirmationDialog *cd; + FileDialog *file; + int to_erase; + + enum { + + MENU_OPTION_ADD_ITEM, + MENU_OPTION_REMOVE_ITEM, + MENU_OPTION_UPDATE_FROM_SCENE, + MENU_OPTION_IMPORT_FROM_SCENE + }; + + int option; + void _import_scene_cbk(const String& p_str); + void _menu_cbk(int p_option); + void _menu_confirm(); + + static void _import_scene(Node *p_scene, Ref<MeshLibrary> p_library, bool p_merge); + +protected: + static void _bind_methods(); +public: + + void edit(const Ref<MeshLibrary>& p_theme); + static Error update_library_file(Node *p_base_scene, Ref<MeshLibrary> ml,bool p_merge=true); + + MeshLibraryEditor(EditorNode *p_editor); +}; + + + +class MeshLibraryEditorPlugin : public EditorPlugin { + + OBJ_TYPE( MeshLibraryEditorPlugin, EditorPlugin ); + + MeshLibraryEditor *theme_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "MeshLibrary"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + MeshLibraryEditorPlugin(EditorNode *p_node); + +}; + + +#endif // CUBE_GRID_THEME_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/font_editor_plugin.cpp b/tools/editor/plugins/font_editor_plugin.cpp new file mode 100644 index 000000000..d85226959 --- /dev/null +++ b/tools/editor/plugins/font_editor_plugin.cpp @@ -0,0 +1,905 @@ +/*************************************************************************/ +/* font_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "font_editor_plugin.h" +#include "os/file_access.h" +#ifdef FREETYPE_ENABLED + +#include <ft2build.h> +#include FT_FREETYPE_H + +#endif + +#include "core/io/resource_saver.h" + +void FontEditor::edit(const Ref<Font>& p_font) { + + font=p_font; + label->add_font_override("font",font); +} + +void FontEditor::_preview_text_changed(const String& p_text) { + + label->set_text(p_text); +} +struct FontData { + + Vector<uint8_t> bitmap; + int width,height; + int ofs_x; //ofset to center, from ABOVE + int ofs_y; //ofset to begining, from LEFT + int valign; //vertical alignment + int halign; + int advance; + int character; + int glyph; + + int texture; +// bool printable; + +}; + + +struct FontDataSort { + + bool operator()(const FontData *p_A,const FontData *p_B) const { + return p_A->height > p_B->height; + }; +}; + +struct KerningKey { + + CharType A,B; + bool operator<(const KerningKey& p_k) const { return (A==p_k.A)?(B<p_k.B):(A<p_k.A); } + +}; + +void FontEditor::_export_fnt(const String& p_name, Ref<Font> p_font) { + + String fnt_name = p_name + ".fnt"; + FileAccess* f = FileAccess::open(fnt_name, FileAccess::WRITE); + ERR_FAIL_COND(!f); + + f->store_string(String("info face=\"") + p_font->get_name() + "\" size=" + String::num_real(font->get_height()) + " bold=0 italic=0 charset=\"\" unicode=0 stretchH=100 smooth=1 aa=1 padding=0,0,0,0 spacing=4,4\n"); + + Vector2 size = p_font->get_texture(0)->get_size(); + f->store_string(String("common lineHeight=") + String::num(font->get_height()) + " base=" + String::num(font->get_ascent()) + " scaleW=" + String::num(size.x) + " scaleH=" + String::num(size.y) + " pages="+String::num(p_font->get_texture_count()) + " packed=0\n"); + + for (int i=0; i<p_font->get_texture_count(); i++) { + + f->store_string(String("page id=")+String::num(i)+ " file=\""+ p_name.get_file() + "_" +String::num(i)+".png\"\n"); + }; + + f->store_string(String("chars count=")+String::num(p_font->get_character_count()) + "\n"); + + Vector<CharType> keys = p_font->get_char_keys(); + keys.sort(); + for (int i=0; i<keys.size(); i++) { + + Font::Character c = p_font->get_character(keys[i]); + int width = c.rect.size.x; + if (keys[i] == 32) { + width = c.advance; + }; + f->store_string(String("char id=") + String::num(keys[i]) + " x=" + String::num(c.rect.pos.x) + " y=" + String::num(c.rect.pos.y) + + " width=" + String::num(width) + " height=" + String::num(c.rect.size.y) + + " xoffset=" + String::num(c.h_align) + " yoffset=" + String::num(c.v_align) + + " xadvance=" + String::num(c.advance) + " page=" + String::num(c.texture_idx) + + " chnl=0 letter=\"\"\n"); + }; + + f->close(); + + for (int i=0; i<p_font->get_texture_count(); i++) { + + ResourceSaver::save(p_name + "_" + String::num(i) + ".png", p_font->get_texture(i)); + }; +}; + +void FontEditor::_import_fnt(const String& p_string) { + //fnt format used by angelcode bmfont + //http://www.angelcode.com/products/bmfont/ + + FileAccess *f = FileAccess::open(p_string,FileAccess::READ); + + if (!f) { + + ERR_EXPLAIN("Can't open font: "+p_string); + ERR_FAIL(); + } + + + font->clear(); + + while(true) { + + String line=f->get_line(); + + int delimiter=line.find(" "); + String type=line.substr(0,delimiter); + int pos = delimiter+1; + Map<String,String> keys; + + while (pos < line.size() && line[pos]==' ') + pos++; + + + while(pos<line.size()) { + + int eq = line.find("=",pos); + if (eq==-1) + break; + String key=line.substr(pos,eq-pos); + int end=-1; + String value; + if (line[eq+1]=='"') { + end=line.find("\"",eq+2); + if (end==-1) + break; + value=line.substr(eq+2,end-1-eq-1); + pos=end+1; + } else { + end=line.find(" ",eq+1); + if (end==-1) + end=line.size(); + + value=line.substr(eq+1,end-eq); + + pos=end; + + } + + while (pos<line.size() && line[pos]==' ') + pos++; + + + keys[key]=value; + + } + + + if (type=="info") { + + if (keys.has("face")) + font->set_name(keys["face"]); + //if (keys.has("size")) + // font->set_height(keys["size"].to_int()); + + } else if (type=="common") { + + if (keys.has("lineHeight")) + font->set_height(keys["lineHeight"].to_int()); + if (keys.has("base")) + font->set_ascent(keys["base"].to_int()); + + } else if (type=="page") { + + if (keys.has("file")) { + + String file = keys["file"]; + file=p_string.get_base_dir()+"/"+file; + Ref<Texture> tex = ResourceLoader::load(file); + if (tex.is_null()) { + ERR_PRINT("Can't load font texture!"); + } else { + font->add_texture(tex); + } + } + } else if (type=="char") { + + CharType idx=0; + if (keys.has("id")) + idx=keys["id"].to_int(); + + Rect2 rect; + + if (keys.has("x")) + rect.pos.x=keys["x"].to_int(); + if (keys.has("y")) + rect.pos.y=keys["y"].to_int(); + if (keys.has("width")) + rect.size.width=keys["width"].to_int(); + if (keys.has("height")) + rect.size.height=keys["height"].to_int(); + + Point2 ofs; + + if (keys.has("xoffset")) + ofs.x=keys["xoffset"].to_int(); + if (keys.has("yoffset")) + ofs.y=keys["yoffset"].to_int(); + + int texture=0; + if (keys.has("page")) + texture=keys["page"].to_int(); + int advance=-1; + if (keys.has("xadvance")) + advance=keys["xadvance"].to_int(); + + font->add_char(idx,texture,rect,ofs,advance); + + } else if (type=="kerning") { + + CharType first=0,second=0; + int k=0; + + if (keys.has("first")) + first=keys["first"].to_int(); + if (keys.has("second")) + second=keys["second"].to_int(); + if (keys.has("amount")) + k=keys["amount"].to_int(); + + font->add_kerning_pair(first,second,-k); + + } + + if (f->eof_reached()) + break; + } + + + + memdelete(f); + + + +} + +void FontEditor::_import_ttf(const String& p_string) { + +#ifdef FREETYPE_ENABLED + FT_Library library; /* handle to library */ + FT_Face face; /* handle to face object */ + + Vector<FontData*> font_data_list; + + int error = FT_Init_FreeType( &library ); + + ERR_EXPLAIN("Error initializing FreeType."); + ERR_FAIL_COND( error !=0 ); + + + error = FT_New_Face( library, p_string.utf8().get_data(),0,&face ); + + if ( error == FT_Err_Unknown_File_Format ) { + ERR_EXPLAIN("Unknown font format."); + FT_Done_FreeType( library ); + } else if ( error ) { + + ERR_EXPLAIN("Error loading font."); + FT_Done_FreeType( library ); + + } + + ERR_FAIL_COND(error); + + + int height=0; + int ascent=0; + int font_spacing=0; + + int size=font_size->get_text().to_int(); + + error = FT_Set_Char_Size(face,0,64*size,512,512); + + if ( error ) { + FT_Done_FreeType( library ); + ERR_EXPLAIN("Invalid font size. "); + ERR_FAIL_COND( error ); + + } + + error = FT_Set_Pixel_Sizes(face,0,size); + + FT_GlyphSlot slot = face->glyph; + +// error = FT_Set_Charmap(face,ft_encoding_unicode ); /* encoding.. */ + + + /* PRINT CHARACTERS TO INDIVIDUAL BITMAPS */ + + +// int space_size=5; //size for space, if none found.. 5! +// int min_valign=500; //some ridiculous number + + FT_ULong charcode; + FT_UInt gindex; + + int max_up=-1324345; ///gibberish + int max_down=124232; + + Map<KerningKey,int> kerning_map; + + charcode = FT_Get_First_Char( face, &gindex ); + + int xsize=0; + while ( gindex != 0 ) + { + + bool skip=false; + error = FT_Load_Char( face, charcode, FT_LOAD_RENDER ); + if (error) skip=true; + else error = FT_Render_Glyph( face->glyph, ft_render_mode_normal ); + if (error) skip=true; + + + if (!skip && (import_chars.has(charcode) && import_chars[charcode] != 0)) { + + skip = false; + + } else { + if (import_option->get_selected() == 0 && charcode>127) + skip=true; + if (import_option->get_selected() == 1 && charcode>0xFE) + skip=true; + }; + + if (charcode<=32) // + skip=true; + + if (skip) { + charcode=FT_Get_Next_Char(face,charcode,&gindex); + continue; + } + + FontData * fdata = memnew( FontData ); + fdata->bitmap.resize( slot->bitmap.width*slot->bitmap.rows ); + fdata->width=slot->bitmap.width; + fdata->height=slot->bitmap.rows; + fdata->character=charcode; + fdata->glyph=FT_Get_Char_Index(face,charcode); + if (charcode=='x') + xsize=slot->bitmap.width; + + + if (charcode<127) { + if (slot->bitmap_top>max_up) { + + max_up=slot->bitmap_top; + } + + + if ( (slot->bitmap_top - fdata->height)<max_down ) { + + max_down=slot->bitmap_top - fdata->height; + } + } + + + fdata->valign=slot->bitmap_top; + fdata->halign=slot->bitmap_left; + fdata->advance=(slot->advance.x+(1<<5))>>6; + fdata->advance+=font_spacing; + + for (int i=0;i<slot->bitmap.width;i++) { + for (int j=0;j<slot->bitmap.rows;j++) { + + fdata->bitmap[j*slot->bitmap.width+i]=slot->bitmap.buffer[j*slot->bitmap.width+i]; + } + } + + font_data_list.push_back(fdata); + charcode=FT_Get_Next_Char(face,charcode,&gindex); +// printf("reading char %i\n",charcode); + } + + /* SPACE */ + + FontData *spd = memnew( FontData ); + spd->advance=0; + spd->character=' '; + spd->halign=0; + spd->valign=0; + spd->width=0; + spd->height=0; + spd->ofs_x=0; + spd->ofs_y=0; + + if (!FT_Load_Char( face, ' ', FT_LOAD_RENDER ) && !FT_Render_Glyph( face->glyph, ft_render_mode_normal )) { + + spd->advance = slot->advance.x>>6; + spd->advance+=font_spacing; + } else { + + spd->advance=xsize; + spd->advance+=font_spacing; + } + + font_data_list.push_back(spd); + + Map<CharType, bool> exported; + for (int i=0; i<font_data_list.size(); i++) { + exported[font_data_list[i]->character] = true; + }; + int missing = 0; + for(Map<CharType,int>::Element *E=import_chars.front();E;E=E->next()) { + CharType c = E->key(); + if (!exported.has(c)) { + CharType str[2] = {c, 0}; + printf("** Warning: character %i (%ls) not exported\n", (int)c, str); + ++missing; + }; + }; + printf("total %i/%i\n", missing, import_chars.size()); + + /* KERNING */ + + + for(int i=0;i<font_data_list.size();i++) { + + for(int j=0;j<font_data_list.size();j++) { + + FT_Vector delta; + FT_Get_Kerning( face, font_data_list[i]->glyph,font_data_list[j]->glyph, FT_KERNING_DEFAULT, &delta ); + + if (delta.x!=0) { + + KerningKey kpk; + kpk.A = font_data_list[i]->character; + kpk.B = font_data_list[j]->character; + int kern = ((-delta.x)+(1<<5))>>6; + + if (kern==0) + continue; + kerning_map[kpk]=kern; + } + } + } + + height=max_up-max_down; + ascent=max_up; + + /* FIND OUT WHAT THE FONT HEIGHT FOR THIS IS */ + + /* ADJUST THE VALIGN FOR EACH CHARACTER */ + + for (int i=0;i<(int)font_data_list.size();i++) { + + font_data_list[i]->valign=max_up-font_data_list[i]->valign; + } + + + + /* ADD THE SPACEBAR CHARACTER */ +/* + FontData * fdata = new FontData; + + fdata->character=32; + fdata->bitmap=0; + fdata->width=xsize; + fdata->height=1; + fdata->valign=0; + + font_data_list.push_back(fdata); +*/ + /* SORT BY HEIGHT, SO THEY FIT BETTER ON THE TEXTURE */ + + font_data_list.sort_custom<FontDataSort>(); + + int spacing=2; + + + int use_width=256; + int use_max_height=256; +// int surf_idx=-1; + + List<Size2> tex_sizes; +// int current_texture=0; + + Size2 first(use_width,nearest_power_of_2( font_data_list[0]->height + spacing )); + Size2 *curtex=&tex_sizes.push_back(first)->get(); + + Point2 tex_ofs; + + /* FIT (NOT COPY YEY) FACES IN TEXTURES */ + + int current_height=font_data_list[0]->height + spacing; + + int font_margin=2; + + + for(int i=0;i<font_data_list.size();i++) { + + FontData *fd=font_data_list[i]; + + if (tex_ofs.x+fd->width >= use_width) { + //end of column, advance a row + tex_ofs.x=0; + tex_ofs.y+=current_height+font_margin; + current_height=fd->height + spacing; + + int new_tex_h = curtex->height; + + while( tex_ofs.y+current_height > new_tex_h ) { + + if (curtex->height * 2 > use_max_height) { + //oops, can't use this texture anymore.. + Size2 newtex( use_width, nearest_power_of_2( fd->height + spacing )); + new_tex_h=newtex.height; + curtex=&tex_sizes.push_back(newtex)->get(); + tex_ofs=Point2(0,0); + + } else { + + new_tex_h*=2; + } + } + + curtex->height=new_tex_h; + + } + + fd->ofs_x=tex_ofs.x; + fd->ofs_y=tex_ofs.y; + fd->texture=tex_sizes.size()-1; + + tex_ofs.x+=fd->width+font_margin; + + + } + + /* WRITE FACES IN TEXTURES */ + + // create textures + + Vector<DVector<uint8_t> >image_data; + Vector<int> image_widths; + Vector<DVector<uint8_t>::Write> image_ptrs; + image_ptrs.resize(tex_sizes.size()); + + for(int i=0;i<tex_sizes.size();i++) { + + DVector<uint8_t> pixels; + int texsize=tex_sizes[i].width * tex_sizes[i].height * 2; + pixels.resize(texsize ); + + image_data.push_back(pixels); + image_widths.push_back( tex_sizes[i].width ); + image_ptrs[i] = image_data[i].write(); + for(int j=0;j<texsize;j++) { + + image_ptrs[i][j]=0; + } + + } + + //blit textures with fonts + for(int i=0;i<font_data_list.size();i++) { + + FontData *fd=font_data_list[i]; + + uint8_t *pixels = image_ptrs[fd->texture].ptr(); + int width = image_widths[fd->texture]; + + for(int y=0;y<fd->height;y++) { + + const uint8_t *src = &fd->bitmap[y*fd->width]; + uint8_t *dst = &pixels[((fd->ofs_y+y)*width+fd->ofs_x)*2]; + + + for(int x=0;x<fd->width;x++) { + + dst[x<<1]=255; //white always + dst[(x<<1) +1]=src[x]; + + } + } + } + + //unlock writing + for(int i=0;i<image_ptrs.size();i++) + image_ptrs[i]=DVector<uint8_t>::Write(); + + /* CREATE FONT */ + + font->clear(); + font->set_height(height); + font->set_ascent(ascent); + + //register texures + for(int i=0;i<tex_sizes.size();i++) { + Image img(tex_sizes[i].width,tex_sizes[i].height,0,Image::FORMAT_GRAYSCALE_ALPHA,image_data[i]); + Ref<ImageTexture> tex = memnew( ImageTexture ); + tex->create_from_image(img,0); //no filter, no repeat + font->add_texture(tex); + //tframe->set_texture(tex); + + } + + //register characters + + for(int i=0;i<font_data_list.size();i++) { + FontData *fd=font_data_list[i]; + + font->add_char(fd->character,fd->texture,Rect2( fd->ofs_x, fd->ofs_y, fd->width, fd->height),Point2(fd->halign,fd->valign), fd->advance); + memdelete(fd); + } + + for(Map<KerningKey,int>::Element *E=kerning_map.front();E;E=E->next()) { + + font->add_kerning_pair(E->key().A,E->key().B,E->get()); + } + + FT_Done_FreeType( library ); +#endif +} + +void FontEditor::_add_source() { + + _source_file->popup_centered_ratio(); +}; + +void FontEditor::_add_source_accept(const String& p_file) { + + FileAccess* f = FileAccess::open(p_file, FileAccess::READ); + ERR_FAIL_COND(!f); + + String line; + while ( !f->eof_reached() ) { + + line = f->get_line(); + for (int i=0; i<line.length(); i++) { + + if (import_chars.has(line[i])) { + import_chars[line[i]] = import_chars[line[i]] + 1; + } else { + import_chars[line[i]] = 1; + }; + }; + }; +}; + +void FontEditor::_export_fnt_pressed() { + + _export_file->popup_centered_ratio(); +}; + +void FontEditor::_export_fnt_accept(const String& p_file) { + + String name = p_file.replace(".fnt", ""); + _export_fnt(name, font); +}; + +void FontEditor::_import_accept(const String& p_string) { + +#ifdef FREETYPE_ENABLED + + if (p_string.extension().nocasecmp_to("ttf")==0 || p_string.extension().nocasecmp_to("otf")==0) { + + _import_ttf(p_string); + } +#endif + + if (p_string.extension().nocasecmp_to("fnt")==0) { + + _import_fnt(p_string); + } + + label->add_font_override("font",font); + label->notification(Control::NOTIFICATION_THEME_CHANGED); + label->update(); +} + +void FontEditor::_import() { + + + file->popup_centered_ratio(); +} + +void FontEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_import",&FontEditor::_import); + ObjectTypeDB::bind_method("_import_accept",&FontEditor::_import_accept); + ObjectTypeDB::bind_method("_preview_text_changed",&FontEditor::_preview_text_changed); + ObjectTypeDB::bind_method("_add_source",&FontEditor::_add_source); + ObjectTypeDB::bind_method("_add_source_accept",&FontEditor::_add_source_accept); + ObjectTypeDB::bind_method("_export_fnt_pressed",&FontEditor::_export_fnt_pressed); + ObjectTypeDB::bind_method("_export_fnt_accept",&FontEditor::_export_fnt_accept); +} + +FontEditor::FontEditor() { + + panel = memnew( Panel ); + add_child(panel); + panel->set_area_as_parent_rect(); + + /* + tframe = memnew( TextureFrame ); + + tframe->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + tframe->set_anchor( MARGIN_BOTTOM, ANCHOR_END ); + + tframe->set_begin( Point2(5, 40 ) ); + tframe->set_end( Point2(5,55 ) ); + + panel->add_child(tframe); +*/ + + Label *l = memnew( Label ); + l->set_pos( Point2(5,13 ) ); + l->set_text("Import: "); + + panel->add_child(l); + + l = memnew( Label ); + l->set_pos( Point2(25,37 ) ); + l->set_text("Size: "); + + panel->add_child(l); + + font_size = memnew( LineEdit ); + font_size->set_text("12"); + font_size->set_pos( Point2(70,35 ) ); + font_size->set_size( Size2(40,10 ) ); + panel->add_child(font_size); + + l = memnew( Label ); + l->set_pos( Point2(140,37 ) ); + l->set_text("Encoding: "); + + panel->add_child(l); + + import_option = memnew( OptionButton ); + import_option->add_item("Ascii"); + import_option->add_item("Latin"); + import_option->add_item("Full Unicode"); + import_option->select(1); + + import_option->set_pos( Point2( 215,35 ) ); + import_option->set_size( Point2( 100,12 ) ); + + panel->add_child(import_option); + + Button* import = memnew( Button ); + import->set_text("Import:.."); + import->set_begin( Point2(80,35) ); + import->set_end( Point2(10,45) ); + + import->set_anchor( MARGIN_LEFT, ANCHOR_END ); + import->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + + panel->add_child(import); + + Button* add_source = memnew( Button ); + add_source->set_text("Add Source..."); + add_source->set_begin( Point2(180,35) ); + add_source->set_end( Point2(90,45) ); + add_source->set_anchor( MARGIN_LEFT, ANCHOR_END ); + add_source->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + + panel->add_child(add_source); + + file = memnew( FileDialog ); + file->set_access(FileDialog::ACCESS_FILESYSTEM); + + _source_file = memnew( FileDialog ); + _source_file->set_access(FileDialog::ACCESS_FILESYSTEM); + _source_file->set_mode(FileDialog::MODE_OPEN_FILE); + _source_file->connect("file_selected", this, "_add_source_accept"); + panel->add_child( _source_file ); + + Button* export_fnt = memnew(Button); + export_fnt->set_text("Export fnt"); + export_fnt->set_begin(Point2(80, 65)); + export_fnt->set_end(Point2(10, 75)); + export_fnt->set_anchor( MARGIN_LEFT, ANCHOR_END ); + export_fnt->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + export_fnt->connect("pressed", this, "_export_fnt_pressed"); + panel->add_child( export_fnt ); + + _export_file = memnew(FileDialog); + _export_file->set_access(FileDialog::ACCESS_FILESYSTEM); + _export_file->set_mode(FileDialog::MODE_SAVE_FILE); + _export_file->connect("file_selected", this, "_export_fnt_accept"); + panel->add_child(_export_file); + + l = memnew( Label ); + l->set_pos( Point2(5,65 ) ); + l->set_text("Preview Text: "); + + panel->add_child(l); + + preview_text = memnew( LineEdit ); + preview_text->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + preview_text->set_begin( Point2(25,85 ) ); + preview_text->set_end( Point2(10,95 ) ); + panel->add_child(preview_text); + preview_text->connect("text_changed", this,"_preview_text_changed"); + preview_text->set_text("The quick brown fox jumped over the lazy dog."); + + l = memnew( Label ); + l->set_pos( Point2(5,115 ) ); + l->set_text("Preview: "); + + panel->add_child(l); + + label = memnew( Label ); + label->set_autowrap(true); + + label->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + label->set_anchor( MARGIN_BOTTOM, ANCHOR_END ); + + label->set_begin( Point2(5, 135 ) ); + label->set_end( Point2(5,5 ) ); + + label->set_text("The quick brown fox jumped over the lazy dog."); + label->set_align( Label::ALIGN_CENTER ); + + panel->add_child(label); + +#ifdef FREETYPE_ENABLED + + file->add_filter("*.ttf"); + file->add_filter("*.otf"); +#endif + file->add_filter("*.fnt ; AngelCode BMFont"); + + file->set_mode(FileDialog::MODE_OPEN_FILE); + panel->add_child( file ); + + import->connect("pressed", this,"_import"); + file->connect("file_selected", this,"_import_accept"); + add_source->connect("pressed", this, "_add_source"); +} + +void FontEditorPlugin::edit(Object *p_node) { + + if (p_node && p_node->cast_to<Font>()) { + font_editor->edit( p_node->cast_to<Font>() ); + font_editor->show(); + } else + font_editor->hide(); +} + +bool FontEditorPlugin::handles(Object *p_node) const{ + + return p_node->is_type("Font"); +} + +void FontEditorPlugin::make_visible(bool p_visible){ + + if (p_visible) + font_editor->show(); + else + font_editor->hide(); +} + +FontEditorPlugin::FontEditorPlugin(EditorNode *p_node) { + + font_editor = memnew( FontEditor ); + + p_node->get_viewport()->add_child(font_editor); + font_editor->set_area_as_parent_rect(); + font_editor->hide(); + + + + +} + diff --git a/tools/editor/plugins/font_editor_plugin.h b/tools/editor/plugins/font_editor_plugin.h new file mode 100644 index 000000000..fe51ce36e --- /dev/null +++ b/tools/editor/plugins/font_editor_plugin.h @@ -0,0 +1,100 @@ +/*************************************************************************/ +/* font_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef FONT_EDITOR_PLUGIN_H +#define FONT_EDITOR_PLUGIN_H + +#include "scene/resources/font.h" +#include "scene/gui/texture_frame.h" +#include "scene/gui/option_button.h" +#include "tools/editor/editor_node.h" + + +class FontEditor : public Control { + + OBJ_TYPE( FontEditor, Control ); + + Panel *panel; + LineEdit *font_size; + //TextureFrame *tframe; //for debug + Label *label; + LineEdit *preview_text; + FileDialog *file; + FileDialog* _source_file; + FileDialog* _export_file; + OptionButton *import_option; + + Ref<Font> font; + + Map<CharType, int> import_chars; + + void _export_fnt(const String& p_name, Ref<Font> p_font); + void _export_fnt_pressed(); + void _export_fnt_accept(const String& p_file); + + void _import_ttf(const String& p_string); + void _import_fnt(const String& p_string); + void _preview_text_changed(const String& p_text); + + void _add_source(); + void _add_source_accept(const String& p_file); + + void _import_accept(const String&); + void _import(); +protected: + static void _bind_methods(); +public: + + void edit(const Ref<Font>& p_font); + + FontEditor(); +}; + + + +class FontEditorPlugin : public EditorPlugin { + + OBJ_TYPE( FontEditorPlugin, EditorPlugin ); + + FontEditor *font_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Font"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + FontEditorPlugin(EditorNode *p_node); + +}; + + +#endif // FONT_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/item_list_editor_plugin.cpp b/tools/editor/plugins/item_list_editor_plugin.cpp new file mode 100644 index 000000000..a059470ce --- /dev/null +++ b/tools/editor/plugins/item_list_editor_plugin.cpp @@ -0,0 +1,415 @@ +/*************************************************************************/ +/* item_list_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "item_list_editor_plugin.h" + +#include "io/resource_loader.h" + + +bool ItemListPlugin::_set(const StringName& p_name, const Variant& p_value) { + + String name = p_name; + int idx = name.get_slice("/",0).to_int(); + String what=name.get_slice("/",1); + + if (what=="text") + set_item_text(idx,p_value); + else if (what=="icon") + set_item_icon(idx,p_value); + else if (what=="checkable") + set_item_checkable(idx,p_value); + else if (what=="checked") + set_item_checked(idx,p_value); + else if (what=="enabled") + set_item_enabled(idx,p_value); + else if (what=="accel") + set_item_accel(idx,p_value); + else if (what=="id") + set_item_id(idx,p_value); + else if (what=="separator") + set_item_separator(idx,p_value); + else + return false; + + return true; +} + +bool ItemListPlugin::_get(const StringName& p_name,Variant &r_ret) const { + String name = p_name; + int idx = name.get_slice("/",0).to_int(); + String what=name.get_slice("/",1); + + if (what=="text") + r_ret=get_item_text(idx); + else if (what=="icon") + r_ret=get_item_icon(idx); + else if (what=="checkable") + r_ret=is_item_checkable(idx); + else if (what=="checked") + r_ret=is_item_checked(idx); + else if (what=="enabled") + r_ret=is_item_enabled(idx); + else if (what=="accel") + r_ret=get_item_accel(idx); + else if (what=="id") + r_ret=get_item_id(idx); + else if (what=="separator") + r_ret=is_item_separator(idx); + else + return false; + + return true; +} +void ItemListPlugin::_get_property_list( List<PropertyInfo> *p_list) const { + + for(int i=0;i<get_item_count();i++) { + + String base=itos(i)+"/"; + + p_list->push_back( PropertyInfo(Variant::STRING,base+"text") ); + p_list->push_back( PropertyInfo(Variant::OBJECT,base+"icon",PROPERTY_HINT_RESOURCE_TYPE,"Texture") ); + if (get_flags()&FLAG_CHECKABLE) { + + p_list->push_back( PropertyInfo(Variant::BOOL,base+"checkable") ); + p_list->push_back( PropertyInfo(Variant::BOOL,base+"checked") ); + + } + if (get_flags()&FLAG_ENABLE) { + + p_list->push_back( PropertyInfo(Variant::BOOL,base+"enabled") ); + + } + if (get_flags()&FLAG_ACCEL) { + + p_list->push_back( PropertyInfo(Variant::INT,base+"accel",PROPERTY_HINT_KEY_ACCEL) ); + + } + if (get_flags()&FLAG_ID) { + + p_list->push_back( PropertyInfo(Variant::INT,base+"id",PROPERTY_HINT_RANGE,"-1,4096") ); + + } + if (get_flags()&FLAG_SEPARATOR) { + + p_list->push_back( PropertyInfo(Variant::BOOL,base+"separator") ); + + } + } +} + +void ItemListEditor::_node_removed(Node *p_node) { + + if(p_node==item_list) { + item_list=NULL; + hide(); + dialog->hide(); + } + + +} + +void ItemListEditor::_delete_pressed() { + + String p = prop_editor->get_selected_path(); + + if (p.find("/")!=-1) { + + if (selected_idx<0 || selected_idx>=item_plugins.size()) + return; + + item_plugins[selected_idx]->erase(p.get_slice("/",0).to_int());; + } + +} + +void ItemListEditor::_add_pressed() { + + if (selected_idx<0 || selected_idx>=item_plugins.size()) + return; + + item_plugins[selected_idx]->add_item(); +} + +void ItemListEditor::_notification(int p_notification) { + + if (p_notification==NOTIFICATION_ENTER_SCENE) { + + add_button->set_icon(get_icon("Add","EditorIcons")); + del_button->set_icon(get_icon("Del","EditorIcons")); + } +} + + +void ItemListEditor::_menu_option(int p_option) { + + + switch(p_option) { + + case MENU_EDIT_ITEMS: { + + dialog->popup_centered_ratio(); + } break; + } +} + + +void ItemListEditor::edit(Node *p_item_list) { + + item_list=p_item_list; + + for(int i=0;i<item_plugins.size();i++) { + if (item_plugins[i]->handles(p_item_list)) { + + item_plugins[i]->set_object(p_item_list); + prop_editor->edit(item_plugins[i]); + selected_idx=i; + return; + } + } + + selected_idx=-1; + + prop_editor->edit(NULL); + +} + + +void ItemListEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_menu_option",&ItemListEditor::_menu_option); + ObjectTypeDB::bind_method("_add_button",&ItemListEditor::_add_pressed); + ObjectTypeDB::bind_method("_delete_button",&ItemListEditor::_delete_pressed); + + //ObjectTypeDB::bind_method("_populate",&ItemListEditor::_populate); + +} + +bool ItemListEditor::handles(Object *p_object) const { + for(int i=0;i<item_plugins.size();i++) { + if (item_plugins[i]->handles(p_object)) { + return true; + } + } + + return false; + +} +ItemListEditor::ItemListEditor() { + + selected_idx=-1; + options = memnew( MenuButton ); + add_child(options); + options->set_area_as_parent_rect(); + + options->set_text("Items"); + options->get_popup()->add_item("Edit Items",MENU_EDIT_ITEMS); + //options->get_popup()->add_item("Clear",MENU_CLEAR); + + options->get_popup()->connect("item_pressed", this,"_menu_option"); + + dialog = memnew( AcceptDialog ); + add_child( dialog ); + + + + HBoxContainer *hbc = memnew( HBoxContainer ); + + dialog->add_child(hbc); + dialog->set_child_rect(hbc); + + prop_editor = memnew( PropertyEditor ); + + hbc->add_child(prop_editor); + prop_editor->set_h_size_flags(SIZE_EXPAND_FILL); + + VBoxContainer *vbc = memnew( VBoxContainer ); + hbc->add_child(vbc); + + add_button = memnew( Button ); + //add_button->set_text("Add"); + add_button->connect("pressed",this,"_add_button"); + vbc->add_child(add_button); + + del_button = memnew( Button ); + //del_button->set_text("Del"); + del_button->connect("pressed",this,"_delete_button"); + vbc->add_child(del_button); + + dialog->set_title("Item List"); + prop_editor->hide_top_label(); + + + +} + + +void ItemListEditorPlugin::edit(Object *p_object) { + + item_list_editor->edit(p_object->cast_to<Node>()); +} + +bool ItemListEditorPlugin::handles(Object *p_object) const { + + return item_list_editor->handles(p_object); +} + +void ItemListEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + item_list_editor->show(); + } else { + + item_list_editor->hide(); + item_list_editor->edit(NULL); + } + +} + + +ItemListEditor::~ItemListEditor() { + + for(int i=0;i<item_plugins.size();i++) + memdelete( item_plugins[i] ); +} + +///////////////////////// PLUGINS ///////////////////////////// +///////////////////////// PLUGINS ///////////////////////////// +///////////////////////// PLUGINS ///////////////////////////// +///////////////////////// PLUGINS ///////////////////////////// +///////////////////////// PLUGINS ///////////////////////////// + + +class ItemListOptionButtonPlugin : public ItemListPlugin { + + OBJ_TYPE(ItemListOptionButtonPlugin,ItemListPlugin); + + OptionButton *ob; +public: + + virtual void set_object(Object *p_object) { ob = p_object->cast_to<OptionButton>(); } + + virtual bool handles(Object *p_object) const { return p_object->cast_to<OptionButton>()!=NULL; } + + virtual int get_flags() const { return FLAG_ICON|FLAG_ID|FLAG_ENABLE; } + + virtual void set_item_text(int p_idx,const String& p_text){ ob->set_item_text(p_idx,p_text);} + virtual void set_item_icon(int p_idx,const Ref<Texture>& p_tex){ ob->set_item_icon(p_idx,p_tex);} + virtual void set_item_enabled(int p_idx,int p_enabled){ ob->set_item_disabled(p_idx,!p_enabled);} + virtual void set_item_id(int p_idx,int p_id){ ob->set_item_ID(p_idx,p_id);} + + + virtual String get_item_text(int p_idx) const{ return ob->get_item_text(p_idx); }; + virtual Ref<Texture> get_item_icon(int p_idx) const{ return ob->get_item_icon(p_idx); }; + virtual bool is_item_enabled(int p_idx) const{ return !ob->is_item_disabled(p_idx); }; + virtual int get_item_id(int p_idx) const{ return ob->get_item_ID(p_idx); }; + + virtual void add_item() { ob->add_item( "New Item "+itos(ob->get_item_count())); _change_notify();} + virtual int get_item_count() const { return ob->get_item_count(); } + virtual void erase(int p_idx) { ob->remove_item(p_idx); _change_notify();} + + + ItemListOptionButtonPlugin() { ob=NULL; } +}; + +class ItemListPopupMenuPlugin : public ItemListPlugin { + + OBJ_TYPE(ItemListPopupMenuPlugin,ItemListPlugin); + + PopupMenu *pp; +public: + + virtual void set_object(Object *p_object) { + if (p_object->cast_to<MenuButton>()) + pp = p_object->cast_to<MenuButton>()->get_popup(); + else + pp = p_object->cast_to<PopupMenu>(); + } + + virtual bool handles(Object *p_object) const { return p_object->cast_to<PopupMenu>()!=NULL || p_object->cast_to<MenuButton>()!=NULL; } + + virtual int get_flags() const { return FLAG_ICON|FLAG_ID|FLAG_ENABLE|FLAG_CHECKABLE|FLAG_SEPARATOR|FLAG_ACCEL; } + + virtual void set_item_text(int p_idx,const String& p_text){ pp->set_item_text(p_idx,p_text); } + virtual void set_item_icon(int p_idx,const Ref<Texture>& p_tex){ pp->set_item_icon(p_idx,p_tex);} + virtual void set_item_checkable(int p_idx,bool p_check){ pp->set_item_as_checkable(p_idx,p_check);} + virtual void set_item_checked(int p_idx,bool p_checked){ pp->set_item_checked(p_idx,p_checked);} + virtual void set_item_accel(int p_idx,int p_accel){ pp->set_item_accelerator(p_idx,p_accel);} + virtual void set_item_enabled(int p_idx,int p_enabled){ pp->set_item_disabled(p_idx,!p_enabled);} + virtual void set_item_id(int p_idx,int p_id){ pp->set_item_ID(p_idx,p_idx);} + virtual void set_item_separator(int p_idx,bool p_separator){ pp->set_item_as_separator(p_idx,p_separator);} + + + virtual String get_item_text(int p_idx) const{ return pp->get_item_text(p_idx); }; + virtual Ref<Texture> get_item_icon(int p_idx) const{ return pp->get_item_icon(p_idx); }; + virtual bool is_item_checkable(int p_idx) const{ return pp->is_item_checkable(p_idx); }; + virtual bool is_item_checked(int p_idx) const{ return pp->is_item_checked(p_idx); }; + virtual int get_item_accel(int p_idx) const{ return pp->get_item_accelerator(p_idx); }; + virtual bool is_item_enabled(int p_idx) const{ return !pp->is_item_disabled(p_idx); }; + virtual int get_item_id(int p_idx) const{ return pp->get_item_ID(p_idx); }; + virtual bool is_item_separator(int p_idx) const{ return pp->is_item_separator(p_idx); }; + + + + virtual void add_item() { pp->add_item( "New Item "+itos(pp->get_item_count())); _change_notify();} + virtual int get_item_count() const { return pp->get_item_count(); } + virtual void erase(int p_idx) { pp->remove_item(p_idx); _change_notify();} + + + ItemListPopupMenuPlugin() { pp=NULL; } +}; + + + + + + +ItemListEditorPlugin::ItemListEditorPlugin(EditorNode *p_node) { + + editor=p_node; + item_list_editor = memnew( ItemListEditor ); + editor->get_viewport()->add_child(item_list_editor); + +// item_list_editor->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); +// item_list_editor->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + item_list_editor->set_margin(MARGIN_LEFT,180); + item_list_editor->set_margin(MARGIN_RIGHT,230); + item_list_editor->set_margin(MARGIN_TOP,0); + item_list_editor->set_margin(MARGIN_BOTTOM,10); + + + item_list_editor->hide(); + item_list_editor->add_plugin( memnew( ItemListOptionButtonPlugin) ); + item_list_editor->add_plugin( memnew( ItemListPopupMenuPlugin) ); +} + + +ItemListEditorPlugin::~ItemListEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/item_list_editor_plugin.h b/tools/editor/plugins/item_list_editor_plugin.h new file mode 100644 index 000000000..6b4d26fb4 --- /dev/null +++ b/tools/editor/plugins/item_list_editor_plugin.h @@ -0,0 +1,164 @@ +/*************************************************************************/ +/* item_list_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef ITEM_LIST_EDITOR_PLUGIN_H +#define ITEM_LIST_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/gui/option_button.h" +#include "scene/gui/menu_button.h" +#include "scene/gui/popup_menu.h" +#include "scene/gui/spin_box.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + + +class ItemListPlugin : public Object { + + OBJ_TYPE(ItemListPlugin,Object); + +protected: + + bool _set(const StringName& p_name, const Variant& p_value); + bool _get(const StringName& p_name,Variant &r_ret) const; + void _get_property_list( List<PropertyInfo> *p_list) const; + + +public: + + enum Flags { + + FLAG_ICON=1, + FLAG_CHECKABLE=2, + FLAG_ACCEL=4, + FLAG_ID=8, + FLAG_ENABLE=16, + FLAG_SEPARATOR=32 + }; + + virtual void set_object(Object *p_object)=0; + + virtual bool handles(Object *p_object) const=0; + + virtual int get_flags() const=0; + + virtual void set_item_text(int p_idx,const String& p_text){} + virtual void set_item_icon(int p_idx,const Ref<Texture>& p_tex){} + virtual void set_item_checkable(int p_idx,bool p_check){} + virtual void set_item_checked(int p_idx,bool p_checked){} + virtual void set_item_accel(int p_idx,int p_accel){} + virtual void set_item_enabled(int p_idx,int p_enabled){} + virtual void set_item_id(int p_idx,int p_id){} + virtual void set_item_separator(int p_idx,bool p_separator){} + + + virtual String get_item_text(int p_idx) const{ return ""; }; + virtual Ref<Texture> get_item_icon(int p_idx) const{ return Ref<Texture>(); }; + virtual bool is_item_checkable(int p_idx) const{ return false; }; + virtual bool is_item_checked(int p_idx) const{ return false; }; + virtual int get_item_accel(int p_idx) const{ return 0; }; + virtual bool is_item_enabled(int p_idx) const{ return false; }; + virtual int get_item_id(int p_idx) const{ return -1; }; + virtual bool is_item_separator(int p_idx) const{ return false; }; + + virtual void add_item()=0; + virtual int get_item_count() const=0; + virtual void erase(int p_idx)=0; + + ItemListPlugin() {} +}; + +class ItemListEditor : public Control { + + OBJ_TYPE(ItemListEditor, Control ); + + Node *item_list; + + enum { + + MENU_EDIT_ITEMS, + MENU_CLEAR + }; + + AcceptDialog *dialog; + + PropertyEditor *prop_editor; + + MenuButton * options; + int selected_idx; + + Button *add_button; + Button *del_button; + + +// FileDialog *emission_file_dialog; + void _menu_option(int); + + Vector<ItemListPlugin*> item_plugins; + + void _node_removed(Node *p_node); + void _add_pressed(); + void _delete_pressed(); +protected: + + void _notification(int p_notification); + + static void _bind_methods(); +public: + + void edit(Node *p_item_list); + bool handles(Object *p_object) const; + void add_plugin(ItemListPlugin* p_plugin) { item_plugins.push_back(p_plugin); } + ItemListEditor(); + ~ItemListEditor(); +}; + +class ItemListEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ItemListEditorPlugin, EditorPlugin ); + + ItemListEditor *item_list_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "ItemList"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + ItemListEditorPlugin(EditorNode *p_node); + ~ItemListEditorPlugin(); + +}; + +#endif // ITEM_LIST_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/multimesh_editor_plugin.cpp b/tools/editor/plugins/multimesh_editor_plugin.cpp new file mode 100644 index 000000000..b2b6cbe9b --- /dev/null +++ b/tools/editor/plugins/multimesh_editor_plugin.cpp @@ -0,0 +1,470 @@ +/*************************************************************************/ +/* multimesh_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "multimesh_editor_plugin.h" +#include "scene/gui/box_container.h" +#include "scene/3d/mesh_instance.h" + + + +void MultiMeshEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} + + +void MultiMeshEditor::_populate() { + + if(!node) + return; + + + Ref<Mesh> mesh; + + if (mesh_source->get_text()=="") { + + Ref<MultiMesh> multimesh; + multimesh = node->get_multimesh(); + if (multimesh.is_null()) { + + err_dialog->set_text("No mesh source specified (and no MultiMesh set in node)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + if (multimesh->get_mesh().is_null()) { + + err_dialog->set_text("No mesh source specified (and MultiMesh contains no Mesh)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + mesh = multimesh->get_mesh(); + } else { + + Node *ms_node = node->get_node(mesh_source->get_text()); + + if (!ms_node) { + + err_dialog->set_text("Mesh source is invalid (Invalid Path)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + MeshInstance *ms_instance = ms_node->cast_to<MeshInstance>(); + + if (!ms_instance) { + + err_dialog->set_text("Mesh source is invalid (Not a MeshInstance)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + mesh=ms_instance->get_mesh(); + + if (mesh.is_null()) { + + err_dialog->set_text("Mesh source is invalid (Contains no Mesh resource)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + } + + if (surface_source->get_text()=="") { + + err_dialog->set_text("No surface source specified."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + Node *ss_node = node->get_node(surface_source->get_text()); + + if (!ss_node) { + + err_dialog->set_text("Surface source is invalid (Invalid Path)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + GeometryInstance *ss_instance = ss_node->cast_to<MeshInstance>(); + + if (!ss_instance) { + + err_dialog->set_text("Surface source is invalid (Not Geometry)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + Transform geom_xform = node->get_global_transform().affine_inverse() * ss_instance->get_global_transform(); + + DVector<Face3> geometry = ss_instance->get_faces(VisualInstance::FACES_SOLID); + + if (geometry.size()==0) { + + err_dialog->set_text("Surface source is invalid (No Faces)."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + //make all faces local + + int gc = geometry.size(); + DVector<Face3>::Write w = geometry.write(); + + for(int i=0;i<gc;i++) { + for(int j=0;j<3;j++) { + w[i].vertex[j] = geom_xform.xform( w[i].vertex[j] ); + } + } + + + + w = DVector<Face3>::Write(); +#if 0 + node->get_multimesh()->set_instance_count(populate_amount->get_val()); + node->populate_parent(populate_rotate_random->get_val(),populate_tilt_random->get_val(),populate_scale_random->get_val(),populate_scale->get_val()); + + + ERR_EXPLAIN("Parent is not of type VisualInstance."); + ERR_FAIL_COND(!get_parent() || !get_parent()->is_type("VisualInstance")); + + ERR_EXPLAIN("Multimesh not present"); + ERR_FAIL_COND(multimesh.is_null()); + + VisualInstance *vi = get_parent()->cast_to<VisualInstance>(); + ERR_EXPLAIN("Parent is not of type VisualInstance, can't be populated."); + ERR_FAIL_COND(!vi); + +#endif + DVector<Face3> faces = geometry; + ERR_EXPLAIN("Parent has no solid faces to populate."); + int facecount=faces.size(); + ERR_FAIL_COND(!facecount); + + DVector<Face3>::Read r = faces.read(); + + + + float area_accum=0; + Map<float,int> triangle_area_map; + for(int i=0;i<facecount;i++) { + + float area = r[i].get_area();; + if (area<CMP_EPSILON) + continue; + triangle_area_map[area_accum]=i; + area_accum+=area; + } + + ERR_EXPLAIN("Couldn't map area"); + ERR_FAIL_COND(triangle_area_map.size()==0); + ERR_EXPLAIN("Couldn't map area"); + ERR_FAIL_COND(area_accum==0); + + + Ref<MultiMesh> multimesh = memnew( MultiMesh ); + multimesh->set_mesh(mesh); + + int instance_count=populate_amount->get_val(); + + multimesh->set_instance_count(instance_count); + + float _tilt_random = populate_tilt_random->get_val(); + float _rotate_random = populate_rotate_random->get_val(); + float _scale_random = populate_scale_random->get_val(); + float _scale = populate_scale->get_val(); + int axis = populate_axis->get_selected(); + + Transform axis_xform; + if (axis==Vector3::AXIS_Z) { + axis_xform.rotate(Vector3(1,0,0),Math_PI*0.5); + } + if (axis==Vector3::AXIS_X) { + axis_xform.rotate(Vector3(0,0,1),Math_PI*0.5); + } + + for(int i=0;i<instance_count;i++) { + + float areapos = Math::random(0,area_accum); + + Map<float,int>::Element *E = triangle_area_map.find_closest(areapos); + ERR_FAIL_COND(!E) + int index = E->get(); + ERR_FAIL_INDEX(index,facecount); + + // ok FINALLY get face + Face3 face = r[index]; + //now compute some position inside the face... + + Vector3 pos = face.get_random_point_inside(); + Vector3 normal = face.get_plane().normal; + Vector3 op_axis = (face.vertex[0]-face.vertex[1]).normalized(); + + Transform xform; + + xform.set_look_at(pos, pos+op_axis,normal); + xform = xform * axis_xform; + + + Matrix3 post_xform; + + post_xform.rotate(xform.basis.get_axis(0),Math::random(-_tilt_random,_tilt_random)*Math_PI); + post_xform.rotate(xform.basis.get_axis(2),Math::random(-_tilt_random,_tilt_random)*Math_PI); + post_xform.rotate(xform.basis.get_axis(1),Math::random(-_rotate_random,_rotate_random)*Math_PI); + xform.basis = post_xform * xform.basis; + //xform.basis.orthonormalize(); + + + xform.basis.scale(Vector3(1,1,1)*(_scale+Math::random(-_scale_random,_scale_random))); + + + multimesh->set_instance_transform(i,xform); + multimesh->set_instance_color(i,Color(1,1,1,1)); + } + + multimesh->generate_aabb(); + + node->set_multimesh(multimesh); + +} + +void MultiMeshEditor::_browsed(const NodePath& p_path) { + + + NodePath path = node->get_path_to( get_node(p_path) ); + + if (browsing_source) + mesh_source->set_text(path); + else + surface_source->set_text(path); +} + +void MultiMeshEditor::_menu_option(int p_option) { + + + switch(p_option) { + + + case MENU_OPTION_POPULATE: { + + if (_last_pp_node!=node) { + + + surface_source->set_text(".."); + mesh_source->set_text(".."); + populate_axis->select(1); + populate_rotate_random->set_val(0); + populate_tilt_random->set_val(0); + populate_scale_random->set_val(0); + populate_scale->set_val(1); + populate_amount->set_val(128); + + _last_pp_node=node; + } + populate_dialog->popup_centered(Size2(250,395)); + + } break; + } +} + + +void MultiMeshEditor::edit(MultiMeshInstance *p_multimesh) { + + node=p_multimesh; + +} + +void MultiMeshEditor::_browse(bool p_source) { + + browsing_source=p_source; + std->get_tree()->set_marked(node,false); + std->popup_centered_ratio(); + if (p_source) + std->set_title("Select a Source Mesh:"); + else + std->set_title("Select a Target Surface:"); +} + +void MultiMeshEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_menu_option",&MultiMeshEditor::_menu_option); + ObjectTypeDB::bind_method("_populate",&MultiMeshEditor::_populate); + ObjectTypeDB::bind_method("_browsed",&MultiMeshEditor::_browsed); + ObjectTypeDB::bind_method("_browse",&MultiMeshEditor::_browse); +} + +MultiMeshEditor::MultiMeshEditor() { + + + options = memnew( MenuButton ); + add_child(options); + options->set_area_as_parent_rect(); + + options->set_text("MultiMesh"); + options->get_popup()->add_item("Populate Surface"); + options->get_popup()->connect("item_pressed", this,"_menu_option"); + + populate_dialog = memnew( ConfirmationDialog ); + populate_dialog->set_title("Populate MultiMesh"); + add_child(populate_dialog); + + VBoxContainer *vbc = memnew( VBoxContainer ); + populate_dialog->add_child(vbc); + populate_dialog->set_child_rect(vbc); + + + HBoxContainer *hbc = memnew( HBoxContainer ); + + surface_source = memnew( LineEdit ); + hbc->add_child(surface_source); + surface_source->set_h_size_flags(SIZE_EXPAND_FILL); + Button *b = memnew( Button ); + hbc->add_child(b); + b->set_text(".."); + b->connect("pressed",this,"_browse",make_binds(false)); + + vbc->add_margin_child("Target Surface:",hbc); + + hbc = memnew( HBoxContainer ); + mesh_source = memnew( LineEdit ); + hbc->add_child(mesh_source); + mesh_source->set_h_size_flags(SIZE_EXPAND_FILL); + b = memnew( Button ); + hbc->add_child(b); + b->set_text(".."); + vbc->add_margin_child("Source Mesh:",hbc); + b->connect("pressed",this,"_browse",make_binds(true)); + + + populate_axis = memnew( OptionButton ); + populate_axis->add_item("X-Axis"); + populate_axis->add_item("Y-Axis"); + populate_axis->add_item("Z-Axis"); + populate_axis->select(2); + vbc->add_margin_child("Mesh Up Axis:",populate_axis); + + populate_rotate_random = memnew( HScrollBar ); + populate_rotate_random->set_max(1); + populate_rotate_random->set_step(0.01); + vbc->add_margin_child("Random Rotation:",populate_rotate_random); + + populate_tilt_random = memnew( HScrollBar ); + populate_tilt_random->set_max(1); + populate_tilt_random->set_step(0.01); + vbc->add_margin_child("Random Tilt:",populate_tilt_random); + + + populate_scale_random = memnew( SpinBox ); + populate_scale_random->set_min(0); + populate_scale_random->set_max(1); + populate_scale_random->set_val(0); + + vbc->add_margin_child("Random Scale:",populate_scale_random); + + populate_scale = memnew( SpinBox ); + populate_scale->set_min(0.001); + populate_scale->set_max(4096); + populate_scale->set_val(1); + + vbc->add_margin_child("Scale:",populate_scale); + + + populate_amount = memnew( SpinBox ); + populate_amount->set_anchor(MARGIN_RIGHT,ANCHOR_END); + populate_amount->set_begin( Point2(20,232)); + populate_amount->set_end( Point2(5,237)); + populate_amount->set_min(1); + populate_amount->set_max(65536); + populate_amount->set_val(128); + vbc->add_margin_child("Amount:",populate_amount); + + populate_dialog->get_ok()->set_text("Populate"); + + populate_dialog->get_ok()->connect("pressed", this,"_populate"); + std = memnew( SceneTreeDialog ); + populate_dialog->add_child(std); + std->connect("selected",this,"_browsed"); + + _last_pp_node=NULL; + //options->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); + //options->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + err_dialog = memnew( AcceptDialog ); + add_child(err_dialog); +} + + +void MultiMeshEditorPlugin::edit(Object *p_object) { + + multimesh_editor->edit(p_object->cast_to<MultiMeshInstance>()); +} + +bool MultiMeshEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("MultiMeshInstance"); +} + +void MultiMeshEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + multimesh_editor->show(); + } else { + + multimesh_editor->hide(); + multimesh_editor->edit(NULL); + } + +} + +MultiMeshEditorPlugin::MultiMeshEditorPlugin(EditorNode *p_node) { + + editor=p_node; + multimesh_editor = memnew( MultiMeshEditor ); + editor->get_viewport()->add_child(multimesh_editor); + +// multimesh_editor->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); +// multimesh_editor->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + multimesh_editor->set_margin(MARGIN_LEFT,253); + multimesh_editor->set_margin(MARGIN_RIGHT,310); + multimesh_editor->set_margin(MARGIN_TOP,0); + multimesh_editor->set_margin(MARGIN_BOTTOM,10); + + + + multimesh_editor->hide(); +} + + +MultiMeshEditorPlugin::~MultiMeshEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/multimesh_editor_plugin.h b/tools/editor/plugins/multimesh_editor_plugin.h new file mode 100644 index 000000000..a4d5f9bd3 --- /dev/null +++ b/tools/editor/plugins/multimesh_editor_plugin.h @@ -0,0 +1,107 @@ +/*************************************************************************/ +/* multimesh_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef MULTIMESH_EDITOR_PLUGIN_H +#define MULTIMESH_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/3d/multimesh_instance.h" +#include "scene/gui/spin_box.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class MultiMeshEditor : public Control { + + OBJ_TYPE(MultiMeshEditor, Control ); + + + AcceptDialog *err_dialog; + + MultiMeshInstance *_last_pp_node; + bool browsing_source; + + Panel *panel; + MenuButton * options; + MultiMeshInstance *node; + + LineEdit *surface_source; + LineEdit *mesh_source; + + SceneTreeDialog *std; + + ConfirmationDialog *populate_dialog; + OptionButton *populate_axis; + HScrollBar *populate_rotate_random; + HScrollBar *populate_tilt_random; + SpinBox *populate_scale_random; + SpinBox *populate_scale; + SpinBox *populate_amount; + + enum Menu { + + MENU_OPTION_POPULATE + }; + + void _browsed(const NodePath& p_path); + void _menu_option(int); + void _populate(); + void _browse(bool p_source); + +protected: + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + void edit(MultiMeshInstance *p_multimesh); + MultiMeshEditor(); +}; + +class MultiMeshEditorPlugin : public EditorPlugin { + + OBJ_TYPE( MultiMeshEditorPlugin, EditorPlugin ); + + MultiMeshEditor *multimesh_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "MultiMesh"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + MultiMeshEditorPlugin(EditorNode *p_node); + ~MultiMeshEditorPlugin(); + +}; + +#endif // MULTIMESH_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/particles_2d_editor_plugin.cpp b/tools/editor/plugins/particles_2d_editor_plugin.cpp new file mode 100644 index 000000000..b23847231 --- /dev/null +++ b/tools/editor/plugins/particles_2d_editor_plugin.cpp @@ -0,0 +1,198 @@ +/*************************************************************************/ +/* particles_2d_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "particles_2d_editor_plugin.h"
+#include "canvas_item_editor_plugin.h"
+#include "io/image_loader.h"
+
+
+void Particles2DEditorPlugin::edit(Object *p_object) {
+
+ if (p_object) {
+ particles=p_object->cast_to<Particles2D>();
+ } else {
+ particles=NULL;
+ }
+}
+
+bool Particles2DEditorPlugin::handles(Object *p_object) const {
+
+ return p_object->is_type("Particles2D");
+}
+
+void Particles2DEditorPlugin::make_visible(bool p_visible) {
+
+ if (p_visible) {
+
+ sep->show();
+ menu->show();
+ } else {
+
+ menu->hide();
+ sep->hide();
+ }
+
+}
+
+void Particles2DEditorPlugin::_file_selected(const String& p_file) {
+
+ print_line("file: "+p_file);
+
+ int epc=epoints->get_val();
+
+ Image img;
+ Error err = ImageLoader::load_image(p_file,&img);
+ ERR_EXPLAIN("Error loading image: "+p_file);
+ ERR_FAIL_COND(err!=OK);
+
+ img.convert(Image::FORMAT_GRAYSCALE_ALPHA);
+ ERR_FAIL_COND(img.get_format()!=Image::FORMAT_GRAYSCALE_ALPHA);
+ Size2i s = Size2(img.get_width(),img.get_height());
+ ERR_FAIL_COND(s.width==0 || s.height==0);
+
+ DVector<uint8_t> data = img.get_data();
+ DVector<uint8_t>::Read r = data.read();
+
+ Vector<Point2i> valid_positions;
+ valid_positions.resize(s.width*s.height);
+ int vpc=0;
+
+
+ for(int i=0;i<s.width*s.height;i++) {
+
+ uint8_t a = r[i*2+1];
+ if (a>128) {
+ valid_positions[vpc++]=Point2i(i%s.width,i/s.width);
+ }
+ }
+
+ valid_positions.resize(vpc);
+
+ ERR_EXPLAIN("No pixels with transparency > 128 in image..");
+ ERR_FAIL_COND(valid_positions.size()==0);
+
+ DVector<Point2> epoints;
+ epoints.resize(epc);
+ DVector<Point2>::Write w = epoints.write();
+
+ Size2 extents = Size2(img.get_width()*0.5,img.get_height()*0.5);
+
+ for(int i=0;i<epc;i++) {
+
+ Point2 p = valid_positions[Math::rand()%vpc];
+ p-=s/2;
+ w[i]=p/extents;
+ }
+
+ w = DVector<Point2>::Write();
+
+ undo_redo->create_action("Set Emission Mask");
+ undo_redo->add_do_method(particles,"set_emission_points",epoints);
+ undo_redo->add_do_method(particles,"set_emission_half_extents",extents);
+ undo_redo->add_undo_method(particles,"set_emission_points",particles->get_emission_points());
+ undo_redo->add_undo_method(particles,"set_emission_half_extents",particles->get_emission_half_extents());
+ undo_redo->commit_action();
+
+}
+
+void Particles2DEditorPlugin::_menu_callback(int p_idx) {
+
+ switch(p_idx) {
+ case MENU_LOAD_EMISSION_MASK: {
+
+
+ file->popup_centered_ratio();
+
+ } break;
+ case MENU_CLEAR_EMISSION_MASK: {
+
+ undo_redo->create_action("Clear Emission Mask");
+ undo_redo->add_do_method(particles,"set_emission_points",DVector<Vector2>());
+ undo_redo->add_undo_method(particles,"set_emission_points",particles->get_emission_points());
+ undo_redo->commit_action();
+ } break;
+ }
+
+}
+
+
+void Particles2DEditorPlugin::_notification(int p_what) {
+
+ if (p_what==NOTIFICATION_ENTER_SCENE) {
+
+ menu->get_popup()->connect("item_pressed",this,"_menu_callback");
+ file->connect("file_selected",this,"_file_selected");
+ }
+}
+
+void Particles2DEditorPlugin::_bind_methods() {
+
+ ObjectTypeDB::bind_method(_MD("_menu_callback"),&Particles2DEditorPlugin::_menu_callback);
+ ObjectTypeDB::bind_method(_MD("_file_selected"),&Particles2DEditorPlugin::_file_selected);
+}
+
+
+
+Particles2DEditorPlugin::Particles2DEditorPlugin(EditorNode *p_node) {
+
+ particles=NULL;
+ editor=p_node;
+ undo_redo=editor->get_undo_redo();
+ sep = memnew( VSeparator );
+ CanvasItemEditor::get_singleton()->add_control_to_menu_panel(sep);
+ sep->hide();
+
+ menu = memnew( MenuButton );
+ menu->get_popup()->add_item("Load Emission Mask",MENU_LOAD_EMISSION_MASK);
+ menu->get_popup()->add_item("Clear Emission Mask",MENU_CLEAR_EMISSION_MASK);
+ menu->set_text("Particles");
+
+ file = memnew(FileDialog);
+ add_child(file);
+ List<String> ext;
+ ImageLoader::get_recognized_extensions(&ext);
+ for(List<String>::Element *E=ext.front();E;E=E->next()) {
+ file->add_filter("*."+E->get()+"; "+E->get().to_upper());
+ }
+ file->set_mode(FileDialog::MODE_OPEN_FILE);
+ CanvasItemEditor::get_singleton()->add_control_to_menu_panel(menu);
+ epoints = memnew( SpinBox );
+ epoints->set_min(1);
+ epoints->set_max(8192);
+ epoints->set_step(1);
+ epoints->set_val(512);
+ file->get_vbox()->add_margin_child("Generated Point Count:",epoints);
+ menu->hide();
+
+}
+
+
+Particles2DEditorPlugin::~Particles2DEditorPlugin()
+{
+}
+
diff --git a/tools/editor/plugins/particles_2d_editor_plugin.h b/tools/editor/plugins/particles_2d_editor_plugin.h new file mode 100644 index 000000000..b824774d0 --- /dev/null +++ b/tools/editor/plugins/particles_2d_editor_plugin.h @@ -0,0 +1,82 @@ +/*************************************************************************/ +/* particles_2d_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef PARTICLES_2D_EDITOR_PLUGIN_H
+#define PARTICLES_2D_EDITOR_PLUGIN_H
+
+#include "tools/editor/editor_plugin.h"
+#include "tools/editor/editor_node.h"
+#include "scene/2d/collision_polygon_2d.h"
+
+#include "scene/gui/separator.h"
+#include "scene/gui/file_dialog.h"
+#include "scene/2d/particles_2d.h"
+
+class Particles2DEditorPlugin : public EditorPlugin {
+
+ OBJ_TYPE( Particles2DEditorPlugin, EditorPlugin );
+
+ enum {
+
+ MENU_LOAD_EMISSION_MASK,
+ MENU_CLEAR_EMISSION_MASK
+ };
+
+
+ FileDialog *file;
+ EditorNode *editor;
+
+ MenuButton *menu;
+
+ VSeparator *sep;
+ Particles2D *particles;
+ SpinBox *epoints;
+
+ UndoRedo *undo_redo;
+ void _file_selected(const String& p_file);
+ void _menu_callback(int p_idx);
+protected:
+ void _notification(int p_what);
+ static void _bind_methods();
+
+public:
+
+
+ virtual String get_name() const { return "Particles2D"; }
+ bool has_main_screen() const { return false; }
+ virtual void edit(Object *p_node);
+ virtual bool handles(Object *p_node) const;
+ virtual void make_visible(bool p_visible);
+
+ Particles2DEditorPlugin(EditorNode *p_node);
+ ~Particles2DEditorPlugin();
+
+};
+
+
+#endif // PARTICLES_2D_EDITOR_PLUGIN_H
diff --git a/tools/editor/plugins/particles_editor_plugin.cpp b/tools/editor/plugins/particles_editor_plugin.cpp new file mode 100644 index 000000000..38781d93b --- /dev/null +++ b/tools/editor/plugins/particles_editor_plugin.cpp @@ -0,0 +1,462 @@ +/*************************************************************************/ +/* particles_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "particles_editor_plugin.h" +#include "io/resource_loader.h" +#include "servers/visual/particle_system_sw.h" + + +void ParticlesEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} + + +void ParticlesEditor::_resource_seleted(const String& p_res) { + + //print_line("selected resource path: "+p_res); +} + +void ParticlesEditor::_node_selected(const NodePath& p_path){ + + + Node *sel = get_node(p_path); + if (!sel) + return; + + VisualInstance *vi = sel->cast_to<VisualInstance>(); + if (!vi) { + + err_dialog->set_text("Node does not contain geometry."); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + geometry = vi->get_faces(VisualInstance::FACES_SOLID); + + if (geometry.size()==0) { + + err_dialog->set_text("Node does not contain geometry (faces)."); + err_dialog->popup_centered(Size2(300,100)); + return; + + } + + Transform geom_xform = node->get_global_transform().affine_inverse() * vi->get_global_transform(); + + int gc = geometry.size(); + DVector<Face3>::Write w = geometry.write(); + + + for(int i=0;i<gc;i++) { + for(int j=0;j<3;j++) { + w[i].vertex[j] = geom_xform.xform( w[i].vertex[j] ); + } + } + + + w = DVector<Face3>::Write(); + + emission_dialog->popup_centered(Size2(300,130)); +} + + +/* + +void ParticlesEditor::_populate() { + + if(!node) + return; + + + if (node->get_particles().is_null()) + return; + + node->get_particles()->set_instance_count(populate_amount->get_text().to_int()); + node->populate_parent(populate_rotate_random->get_val(),populate_tilt_random->get_val(),populate_scale_random->get_text().to_double(),populate_scale->get_text().to_double()); + +} +*/ + +void ParticlesEditor::_notification(int p_notification) { + + if (p_notification==NOTIFICATION_ENTER_SCENE) { + + } +} + + +void ParticlesEditor::_menu_option(int p_option) { + + + switch(p_option) { + + case MENU_OPTION_GENERATE_AABB: { + + Transform globalizer = node->get_global_transform(); + ParticleSystemSW pssw; + for(int i=0;i<VS::PARTICLE_VAR_MAX;i++) { + + pssw.particle_vars[i]=node->get_variable((Particles::Variable)i); + pssw.particle_randomness[i]=node->get_randomness((Particles::Variable)i); + } + + pssw.emission_half_extents=node->get_emission_half_extents(); + pssw.emission_points=node->get_emission_points(); + pssw.emission_base_velocity=node->get_emission_base_velocity(); + pssw.amount=node->get_amount(); + pssw.gravity_normal=node->get_gravity_normal(); + pssw.emitting=true; + pssw.height_from_velocity=node->has_height_from_velocity(); + pssw.color_phase_count=1; + + + ParticleSystemProcessSW pp; + float delta=0.01; + float lifetime=pssw.particle_vars[VS::PARTICLE_LIFETIME]; + + + Transform localizer = globalizer.affine_inverse(); + AABB aabb; + for(float t=0;t<lifetime;t+=delta) { + + pp.process(&pssw,globalizer,delta); + for(int i=0;i<pp.particle_data.size();i++) { + + Vector3 p = localizer.xform(pp.particle_data[i].pos); + + if (t==0 && i==0) + aabb.pos=p; + else + aabb.expand_to(p); + } + } + + aabb.grow_by( aabb.get_longest_axis_size()*0.2); + + node->set_visibility_aabb(aabb); + + + } break; + case MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_MESH: { + + + emission_file_dialog->popup_centered_ratio(); + + } break; + + case MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE: { +/* + Node *root = get_scene()->get_root_node(); + ERR_FAIL_COND(!root); + EditorNode *en = root->cast_to<EditorNode>(); + ERR_FAIL_COND(!en); + Node * node = en->get_edited_scene(); +*/ + emission_tree_dialog->popup_centered_ratio(); + + } break; + } +} + + +void ParticlesEditor::edit(Particles *p_particles) { + + node=p_particles; + +} + +void ParticlesEditor::_generate_emission_points() { + + /// hacer codigo aca + DVector<Vector3> points; + + if (emission_fill->get_selected()==0) { + + float area_accum=0; + Map<float,int> triangle_area_map; + print_line("geometry size: "+itos(geometry.size())); + + for(int i=0;i<geometry.size();i++) { + + float area = geometry[i].get_area();; + if (area<CMP_EPSILON) + continue; + triangle_area_map[area_accum]=i; + area_accum+=area; + } + + if (!triangle_area_map.size() || area_accum==0) { + + err_dialog->set_text("Faces contain no area!"); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + int emissor_count=emission_amount->get_val(); + + for(int i=0;i<emissor_count;i++) { + + float areapos = Math::random(0,area_accum); + + Map<float,int>::Element *E = triangle_area_map.find_closest(areapos); + ERR_FAIL_COND(!E) + int index = E->get(); + ERR_FAIL_INDEX(index,geometry.size()); + + // ok FINALLY get face + Face3 face = geometry[index]; + //now compute some position inside the face... + + Vector3 pos = face.get_random_point_inside(); + + points.push_back(pos); + } + } else { + + int gcount = geometry.size(); + + if (gcount==0) { + + err_dialog->set_text("No Faces!"); + err_dialog->popup_centered(Size2(300,100)); + return; + } + + DVector<Face3>::Read r = geometry.read(); + + AABB aabb; + + for(int i=0;i<gcount;i++) { + + for(int j=0;j<3;j++) { + + if (i==0 && j==0) + aabb.pos=r[i].vertex[j]; + else + aabb.expand_to(r[i].vertex[j]); + } + } + + int emissor_count=emission_amount->get_val(); + + for(int i=0;i<emissor_count;i++) { + + int attempts=5; + + for(int j=0;j<attempts;j++) { + + Vector3 dir; + dir[Math::rand()%3]=1.0; + Vector3 ofs = Vector3(1,1,1)-dir; + ofs=(Vector3(1,1,1)-dir)*Vector3(Math::randf(),Math::randf(),Math::randf())*aabb.size; + ofs+=aabb.pos; + + Vector3 dirv = -dir; + Vector3 ofsv = ofs + aabb.size * dir; + + //space it a little + ofs -= dir; + ofsv += dir; + + float max=-1e7,min=1e7; + + for(int k=0;k<gcount;k++) { + + const Face3& f3 = r[k]; + + Vector3 res; + if (f3.intersects_segment(ofs,ofsv,&res)) { + + res-=ofs; + float d = dir.dot(res); + + if (d<min) + min=d; + if (d>max) + max=d; + + } + } + + + if (max<min) + continue; //lost attempt + + float val = min + (max-min)*Math::randf(); + + Vector3 point = ofs + dir * val; + + points.push_back(point); + break; + } + } + } + + //print_line("point count: "+itos(points.size())); + node->set_emission_points(points); + +} + +void ParticlesEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_menu_option",&ParticlesEditor::_menu_option); + ObjectTypeDB::bind_method("_resource_seleted",&ParticlesEditor::_resource_seleted); + ObjectTypeDB::bind_method("_node_selected",&ParticlesEditor::_node_selected); + ObjectTypeDB::bind_method("_generate_emission_points",&ParticlesEditor::_generate_emission_points); + + //ObjectTypeDB::bind_method("_populate",&ParticlesEditor::_populate); + +} + +ParticlesEditor::ParticlesEditor() { + + options = memnew( MenuButton ); + add_child(options); + options->set_area_as_parent_rect(); + + options->set_text("Particles"); + options->get_popup()->add_item("Generate AABB",MENU_OPTION_GENERATE_AABB); + options->get_popup()->add_separator(); + options->get_popup()->add_item("Create Emitter From Mesh",MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_MESH); + options->get_popup()->add_item("Create Emitter From Node",MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE); + options->get_popup()->add_item("Clear Emitter",MENU_OPTION_CLEAR_EMISSION_VOLUME); + + options->get_popup()->connect("item_pressed", this,"_menu_option"); + + emission_dialog = memnew( ConfirmationDialog ); + emission_dialog->set_title("Create Emitter"); + add_child(emission_dialog); + Label *l = memnew(Label); + l->set_pos(Point2(5,5)); + l->set_text("Emission Positions:"); + emission_dialog->add_child(l); + + + emission_amount = memnew( SpinBox ); + emission_amount->set_anchor(MARGIN_RIGHT,ANCHOR_END); + emission_amount->set_begin( Point2(20,23)); + emission_amount->set_end( Point2(5,25)); + emission_amount->set_min(1); + emission_amount->set_max(65536); + emission_amount->set_val(512); + emission_dialog->add_child(emission_amount); + emission_dialog->get_ok()->set_text("Create"); + emission_dialog->connect("confirmed",this,"_generate_emission_points"); + + l = memnew(Label); + l->set_pos(Point2(5,50)); + l->set_text("Emission Fill:"); + emission_dialog->add_child(l); + + emission_fill = memnew( OptionButton ); + emission_fill->set_anchor(MARGIN_RIGHT,ANCHOR_END); + emission_fill->set_begin( Point2(20,70)); + emission_fill->set_end( Point2(5,75)); + emission_fill->add_item("Surface"); + emission_fill->add_item("Volume"); + emission_dialog->add_child(emission_fill); + + err_dialog = memnew( ConfirmationDialog ); + //err_dialog->get_cancel()->hide(); + add_child(err_dialog); + + + emission_file_dialog = memnew( FileDialog ); + add_child(emission_file_dialog); + emission_file_dialog->connect("file_selected",this,"_resource_seleted"); + emission_tree_dialog = memnew( SceneTreeDialog ); + add_child(emission_tree_dialog); + emission_tree_dialog->connect("selected",this,"_node_selected"); + + List<String> extensions; + ResourceLoader::get_recognized_extensions_for_type("Mesh",&extensions); + + emission_file_dialog->clear_filters(); + for(int i=0;i<extensions.size();i++) { + + emission_file_dialog->add_filter("*."+extensions[i]+" ; "+extensions[i].to_upper()); + } + + emission_file_dialog->set_mode(FileDialog::MODE_OPEN_FILE); + + //options->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); + //options->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + +} + + +void ParticlesEditorPlugin::edit(Object *p_object) { + + particles_editor->edit(p_object->cast_to<Particles>()); +} + +bool ParticlesEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Particles"); +} + +void ParticlesEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + particles_editor->show(); + } else { + + particles_editor->hide(); + particles_editor->edit(NULL); + } + +} + +ParticlesEditorPlugin::ParticlesEditorPlugin(EditorNode *p_node) { + + editor=p_node; + particles_editor = memnew( ParticlesEditor ); + editor->get_viewport()->add_child(particles_editor); + +// particles_editor->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); +// particles_editor->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + particles_editor->set_margin(MARGIN_LEFT,253); + particles_editor->set_margin(MARGIN_RIGHT,280); + particles_editor->set_margin(MARGIN_TOP,0); + particles_editor->set_margin(MARGIN_BOTTOM,10); + + + particles_editor->hide(); +} + + +ParticlesEditorPlugin::~ParticlesEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/particles_editor_plugin.h b/tools/editor/plugins/particles_editor_plugin.h new file mode 100644 index 000000000..ba655c9b3 --- /dev/null +++ b/tools/editor/plugins/particles_editor_plugin.h @@ -0,0 +1,112 @@ +/*************************************************************************/ +/* particles_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef PARTICLES_EDITOR_PLUGIN_H +#define PARTICLES_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/3d/particles.h" +#include "scene/gui/spin_box.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class ParticlesEditor : public Control { + + OBJ_TYPE(ParticlesEditor, Control ); + + Panel *panel; + MenuButton * options; + Particles *node; + + + FileDialog *emission_file_dialog; + SceneTreeDialog *emission_tree_dialog; + + ConfirmationDialog *err_dialog; + + ConfirmationDialog *emission_dialog; + SpinBox *emission_amount; + OptionButton *emission_fill; + + + + + enum Menu { + + MENU_OPTION_GENERATE_AABB, + MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_NODE, + MENU_OPTION_CREATE_EMISSION_VOLUME_FROM_MESH, + MENU_OPTION_CLEAR_EMISSION_VOLUME, + + }; + + DVector<Face3> geometry; + + void _generate_emission_points(); + void _resource_seleted(const String& p_res); + void _node_selected(const NodePath& p_path); + + void _menu_option(int); + + void _populate(); + +protected: + + void _notification(int p_notification); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + void edit(Particles *p_particles); + ParticlesEditor(); +}; + +class ParticlesEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ParticlesEditorPlugin, EditorPlugin ); + + ParticlesEditor *particles_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Particles"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + ParticlesEditorPlugin(EditorNode *p_node); + ~ParticlesEditorPlugin(); + +}; + +#endif // PARTICLES_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/path_2d_editor_plugin.cpp b/tools/editor/plugins/path_2d_editor_plugin.cpp new file mode 100644 index 000000000..e83fed5ce --- /dev/null +++ b/tools/editor/plugins/path_2d_editor_plugin.cpp @@ -0,0 +1,604 @@ +/*************************************************************************/ +/* path_2d_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "path_2d_editor_plugin.h" + +#include "canvas_item_editor_plugin.h" +#include "os/file_access.h" +#include "tools/editor/editor_settings.h" + +void Path2DEditor::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_READY: { + +// button_create->set_icon( get_icon("Edit","EditorIcons")); + //button_edit->set_icon( get_icon("MovePoint","EditorIcons")); + //set_pressed_button(button_edit); + //button_edit->set_pressed(true); + + + } break; + case NOTIFICATION_FIXED_PROCESS: { + + + } break; + } + +} +void Path2DEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} + + +Vector2 Path2DEditor::snap_point(const Vector2& p_point) const { + + if (canvas_item_editor->is_snap_active()) { + + return p_point.snapped(Vector2(1,1)*canvas_item_editor->get_snap()); + + } else { + return p_point; + } +} + +bool Path2DEditor::forward_input_event(const InputEvent& p_event) { + + if (!node) + return false; + + if (!node->get_curve().is_valid()) + return false; + + switch(p_event.type) { + + case InputEvent::MOUSE_BUTTON: { + + const InputEventMouseButton &mb=p_event.mouse_button; + + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + + + Vector2 gpoint = Point2(mb.x,mb.y); + Vector2 cpoint = xform.affine_inverse().xform(gpoint); + + //first check if a point is to be added (segment split) + real_t grab_treshold=EDITOR_DEF("poly_editor/point_grab_radius",8); + + + + // Test move point!! + + if ( mb.pressed && mb.button_index==BUTTON_LEFT ) { + + Ref<Curve2D> curve = node->get_curve(); + + for(int i=0;i<curve->get_point_count();i++) { + + bool pointunder=false; + + { + Point2 p = xform.xform( curve->get_point_pos(i) ); + if (gpoint.distance_to(p) < grab_treshold ) { + + if (!mb.mod.control) { + + action=ACTION_MOVING_POINT; + action_point=i; + moving_from=curve->get_point_pos(i); + moving_screen_from=gpoint; + return true; + } else + pointunder=true; + } + } + + if (i<(curve->get_point_count()-1)) { + Point2 p = xform.xform( curve->get_point_pos(i)+curve->get_point_out(i) ); + if (gpoint.distance_to(p) < grab_treshold ) { + + action=ACTION_MOVING_OUT; + action_point=i; + moving_from=curve->get_point_out(i); + moving_screen_from=gpoint; + return true; + } + } + + if (i>0) { + Point2 p = xform.xform( curve->get_point_pos(i)+curve->get_point_in(i) ); + if (gpoint.distance_to(p) < grab_treshold ) { + + action=ACTION_MOVING_IN; + action_point=i; + moving_from=curve->get_point_in(i); + moving_screen_from=gpoint; + return true; + } + } + + if (pointunder) + return true; + + } + + } + + // Test add point in empty space! + + if ( mb.pressed && mb.mod.control && mb.button_index==BUTTON_LEFT ) { + + Ref<Curve2D> curve = node->get_curve(); + + undo_redo->create_action("Add Point to Curve"); + undo_redo->add_do_method(curve.ptr(),"add_point",cpoint); + undo_redo->add_undo_method(curve.ptr(),"remove_point",curve->get_point_count()); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + + action=ACTION_MOVING_POINT; + action_point=curve->get_point_count()-1; + moving_from=curve->get_point_pos(action_point); + moving_screen_from=gpoint; + + return true; + } + + if ( !mb.pressed && mb.button_index==BUTTON_LEFT && action!=ACTION_NONE) { + + + Ref<Curve2D> curve = node->get_curve(); + + Vector2 new_pos = moving_from + xform.basis_xform( gpoint - moving_screen_from ); + switch(action) { + + case ACTION_MOVING_POINT: { + + + undo_redo->create_action("Move Point in Curve"); + undo_redo->add_do_method(curve.ptr(),"set_point_pos",action_point,new_pos); + undo_redo->add_undo_method(curve.ptr(),"set_point_pos",action_point,moving_from); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + + } break; + case ACTION_MOVING_IN: { + + undo_redo->create_action("Move In-Control in Curve"); + undo_redo->add_do_method(curve.ptr(),"set_point_in",action_point,new_pos); + undo_redo->add_undo_method(curve.ptr(),"set_point_in",action_point,moving_from); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + + } break; + case ACTION_MOVING_OUT: { + + undo_redo->create_action("Move Out-Control in Curve"); + undo_redo->add_do_method(curve.ptr(),"set_point_out",action_point,new_pos); + undo_redo->add_undo_method(curve.ptr(),"set_point_out",action_point,moving_from); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + + } break; + + } + + action=ACTION_NONE; + + return true; + } + + +#if 0 + switch(mode) { + + + case MODE_CREATE: { + + if (mb.button_index==BUTTON_LEFT && mb.pressed) { + + + if (!wip_active) { + + wip.clear(); + wip.push_back( snap_point(cpoint) ); + wip_active=true; + edited_point_pos=snap_point(cpoint); + canvas_item_editor->update(); + edited_point=1; + return true; + } else { + + if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_treshold) { + //wip closed + _wip_close(); + + return true; + } else { + + wip.push_back( snap_point(cpoint) ); + edited_point=wip.size(); + canvas_item_editor->update(); + return true; + + //add wip point + } + } + } else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) { + _wip_close(); + } + + + + } break; + + case MODE_EDIT: { + + if (mb.button_index==BUTTON_LEFT) { + if (mb.pressed) { + + if (mb.mod.control) { + + + if (poly.size() < 3) { + + undo_redo->create_action("Edit Poly"); + undo_redo->add_undo_method(node,"set_polygon",poly); + poly.push_back(cpoint); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + return true; + } + + //search edges + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { + + Vector2 points[2] ={ xform.xform(poly[i]), + xform.xform(poly[(i+1)%poly.size()]) }; + + Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points); + if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2) + continue; //not valid to reuse point + + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; + } + + + } + + if (closest_idx>=0) { + + pre_move_edit=poly; + poly.insert(closest_idx+1,snap_point(xform.affine_inverse().xform(closest_pos))); + edited_point=closest_idx+1; + edited_point_pos=snap_point(xform.affine_inverse().xform(closest_pos)); + node->set_polygon(poly); + canvas_item_editor->update(); + return true; + } + } else { + + //look for points to move + + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { + + Vector2 cp =xform.xform(poly[i]); + + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; + } + + } + + if (closest_idx>=0) { + + pre_move_edit=poly; + edited_point=closest_idx; + edited_point_pos=xform.affine_inverse().xform(closest_pos); + canvas_item_editor->update(); + return true; + } + } + } else { + + if (edited_point!=-1) { + + //apply + + ERR_FAIL_INDEX_V(edited_point,poly.size(),false); + poly[edited_point]=edited_point_pos; + undo_redo->create_action("Edit Poly"); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_undo_method(node,"set_polygon",pre_move_edit); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + + edited_point=-1; + return true; + } + } + } if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) { + + + + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { + + Vector2 cp =xform.xform(poly[i]); + + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; + } + + } + + if (closest_idx>=0) { + + + undo_redo->create_action("Edit Poly (Remove Point)"); + undo_redo->add_undo_method(node,"set_polygon",poly); + poly.remove(closest_idx); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_do_method(canvas_item_editor,"update"); + undo_redo->add_undo_method(canvas_item_editor,"update"); + undo_redo->commit_action(); + return true; + } + + } + + + + } break; + } + + +#endif + } break; + case InputEvent::MOUSE_MOTION: { + + const InputEventMouseMotion &mm=p_event.mouse_motion; + + + if ( action!=ACTION_NONE) { + + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Vector2 gpoint = Point2(mm.x,mm.y); + + Ref<Curve2D> curve = node->get_curve(); + + + Vector2 new_pos = moving_from + xform.basis_xform( gpoint - moving_screen_from ); + + switch(action) { + + case ACTION_MOVING_POINT: { + + curve->set_point_pos(action_point,new_pos); + } break; + case ACTION_MOVING_IN: { + + curve->set_point_in(action_point,new_pos); + + } break; + case ACTION_MOVING_OUT: { + + curve->set_point_out(action_point,new_pos); + + } break; + } + + + canvas_item_editor->update(); + return true; + } + +#if 0 + if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) { + + + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + + Vector2 gpoint = Point2(mm.x,mm.y); + edited_point_pos = snap_point(xform.affine_inverse().xform(gpoint)); + canvas_item_editor->update(); + + } +#endif + } break; + } + + return false; +} +void Path2DEditor::_canvas_draw() { + + if (!node) + return ; + + if (!node->get_curve().is_valid()) + return ; + + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Ref<Texture> handle= get_icon("EditorHandle","EditorIcons"); + + Ref<Curve2D> curve = node->get_curve(); + + int len = curve->get_point_count(); + RID ci = canvas_item_editor->get_canvas_item(); + + for(int i=0;i<len;i++) { + + + Vector2 point = xform.xform(curve->get_point_pos(i)); + handle->draw(ci,point-handle->get_size()*0.5,Color(1,1,1,0.3)); + + if (i<len-1) { + Vector2 pointout = xform.xform(curve->get_point_pos(i)+curve->get_point_out(i)); + canvas_item_editor->draw_line(point,pointout,Color(0.5,0.5,1.0,0.8),1.0); + handle->draw(ci,pointout-handle->get_size()*0.5,Color(1,0.5,1,0.3)); + } + + if (i>0) { + Vector2 pointin = xform.xform(curve->get_point_pos(i)+curve->get_point_in(i)); + canvas_item_editor->draw_line(point,pointin,Color(0.5,0.5,1.0,0.8),1.0); + handle->draw(ci,pointin-handle->get_size()*0.5,Color(1,0.5,1,0.3)); + } + + } + +} + + + +void Path2DEditor::edit(Node *p_collision_polygon) { + + if (!canvas_item_editor) { + canvas_item_editor=CanvasItemEditor::get_singleton(); + } + + if (p_collision_polygon) { + + node=p_collision_polygon->cast_to<Path2D>(); + if (!canvas_item_editor->is_connected("draw",this,"_canvas_draw")) + canvas_item_editor->connect("draw",this,"_canvas_draw"); + + + } else { + node=NULL; + if (canvas_item_editor->is_connected("draw",this,"_canvas_draw")) + canvas_item_editor->disconnect("draw",this,"_canvas_draw"); + + } + +} + +void Path2DEditor::_bind_methods() { + + //ObjectTypeDB::bind_method(_MD("_menu_option"),&Path2DEditor::_menu_option); + ObjectTypeDB::bind_method(_MD("_canvas_draw"),&Path2DEditor::_canvas_draw); + +} + +Path2DEditor::Path2DEditor(EditorNode *p_editor) { + + canvas_item_editor=NULL; + editor=p_editor; + undo_redo = editor->get_undo_redo(); + + + action=ACTION_NONE; +#if 0 + options = memnew( MenuButton ); + add_child(options); + options->set_area_as_parent_rect(); + options->set_text("Polygon"); + //options->get_popup()->add_item("Parse BBCODE",PARSE_BBCODE); + options->get_popup()->connect("item_pressed", this,"_menu_option"); +#endif + + + +} + + +void Path2DEditorPlugin::edit(Object *p_object) { + + collision_polygon_editor->edit(p_object->cast_to<Node>()); +} + +bool Path2DEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Path2D"); +} + +void Path2DEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + collision_polygon_editor->show(); + } else { + + collision_polygon_editor->hide(); + collision_polygon_editor->edit(NULL); + } + +} + +Path2DEditorPlugin::Path2DEditorPlugin(EditorNode *p_node) { + + editor=p_node; + collision_polygon_editor = memnew( Path2DEditor(p_node) ); + editor->get_viewport()->add_child(collision_polygon_editor); + + collision_polygon_editor->set_margin(MARGIN_LEFT,200); + collision_polygon_editor->set_margin(MARGIN_RIGHT,230); + collision_polygon_editor->set_margin(MARGIN_TOP,0); + collision_polygon_editor->set_margin(MARGIN_BOTTOM,10); + + + collision_polygon_editor->hide(); + + + +} + + +Path2DEditorPlugin::~Path2DEditorPlugin() +{ +} + diff --git a/tools/editor/plugins/path_2d_editor_plugin.h b/tools/editor/plugins/path_2d_editor_plugin.h new file mode 100644 index 000000000..3f917f29d --- /dev/null +++ b/tools/editor/plugins/path_2d_editor_plugin.h @@ -0,0 +1,107 @@ +/*************************************************************************/ +/* path_2d_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef PATH_2D_EDITOR_PLUGIN_H +#define PATH_2D_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/2d/path_2d.h" +#include "scene/gui/tool_button.h" +#include "scene/gui/button_group.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ +class CanvasItemEditor; + +class Path2DEditor : public ButtonGroup { + + OBJ_TYPE(Path2DEditor, ButtonGroup ); + + UndoRedo *undo_redo; + + CanvasItemEditor *canvas_item_editor; + EditorNode *editor; + Panel *panel; + Path2D *node; + + enum Action { + + ACTION_NONE, + ACTION_MOVING_POINT, + ACTION_MOVING_IN, + ACTION_MOVING_OUT, + }; + + + Action action; + int action_point; + Point2 moving_from; + Point2 moving_screen_from; + + + void _canvas_draw(); + +protected: + void _notification(int p_what); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + Vector2 snap_point(const Vector2& p_point) const; + bool forward_input_event(const InputEvent& p_event); + void edit(Node *p_collision_polygon); + Path2DEditor(EditorNode *p_editor); +}; + +class Path2DEditorPlugin : public EditorPlugin { + + OBJ_TYPE( Path2DEditorPlugin, EditorPlugin ); + + Path2DEditor *collision_polygon_editor; + EditorNode *editor; + +public: + + virtual bool forward_input_event(const InputEvent& p_event) { return collision_polygon_editor->forward_input_event(p_event); } + + virtual String get_name() const { return "Path2D"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + Path2DEditorPlugin(EditorNode *p_node); + ~Path2DEditorPlugin(); + +}; + + + +#endif // PATH_2D_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/path_editor_plugin.cpp b/tools/editor/plugins/path_editor_plugin.cpp new file mode 100644 index 000000000..1c910e543 --- /dev/null +++ b/tools/editor/plugins/path_editor_plugin.cpp @@ -0,0 +1,598 @@ +/*************************************************************************/ +/* path_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "path_editor_plugin.h"
+#include "spatial_editor_plugin.h"
+#include "scene/resources/curve.h"
+#include "os/keyboard.h"
+
+String PathSpatialGizmo::get_handle_name(int p_idx) const {
+
+ Ref<Curve3D> c = path->get_curve();
+ if (c.is_null())
+ return "";
+
+ if (p_idx<c->get_point_count()) {
+
+ return "Curve Point #"+itos(p_idx);
+ }
+
+ p_idx=p_idx-c->get_point_count()+1;
+
+ int idx=p_idx/2;
+ int t=p_idx%2;
+ String n = "Curve Point #"+itos(idx);
+ if (t==0)
+ n+=" In";
+ else
+ n+=" Out";
+
+ return n;
+
+
+}
+Variant PathSpatialGizmo::get_handle_value(int p_idx) const{
+
+ Ref<Curve3D> c = path->get_curve();
+ if (c.is_null())
+ return Variant();
+
+ if (p_idx<c->get_point_count()) {
+
+ original=c->get_point_pos(p_idx);
+ return original;
+ }
+
+ p_idx=p_idx-c->get_point_count()+1;
+
+ int idx=p_idx/2;
+ int t=p_idx%2;
+
+ Vector3 ofs;
+ if (t==0)
+ ofs=c->get_point_in(idx);
+ else
+ ofs= c->get_point_out(idx);
+
+ original=ofs+c->get_point_pos(idx);
+
+ return ofs;
+
+}
+void PathSpatialGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point){
+
+ Ref<Curve3D> c = path->get_curve();
+ if (c.is_null())
+ return;
+
+ Transform gt = path->get_global_transform();
+ Transform gi = gt.affine_inverse();
+ Vector3 ray_from = p_camera->project_ray_origin(p_point);
+ Vector3 ray_dir = p_camera->project_ray_normal(p_point);
+
+ if (p_idx<c->get_point_count()) {
+
+ Plane p(gt.xform(original),p_camera->get_transform().basis.get_axis(2));
+
+ Vector3 inters;
+
+ if (p.intersects_ray(ray_from,ray_dir,&inters)) {
+
+ Vector3 local = gi.xform(inters);
+ c->set_point_pos(p_idx,local);
+ }
+
+ return;
+ }
+
+ p_idx=p_idx-c->get_point_count()+1;
+
+ int idx=p_idx/2;
+ int t=p_idx%2;
+
+ Vector3 base = c->get_point_pos(idx);
+
+ Plane p(gt.xform(original),p_camera->get_transform().basis.get_axis(2));
+
+ Vector3 inters;
+
+ if (p.intersects_ray(ray_from,ray_dir,&inters)) {
+
+ Vector3 local = gi.xform(inters)-base;
+ if (t==0) {
+ c->set_point_in(idx,local);
+ } else {
+ c->set_point_out(idx,local);
+ }
+ }
+
+}
+
+void PathSpatialGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){
+
+ Ref<Curve3D> c = path->get_curve();
+ if (c.is_null())
+ return;
+
+ UndoRedo *ur = SpatialEditor::get_singleton()->get_undo_redo();
+
+ if (p_idx<c->get_point_count()) {
+
+ if (p_cancel) {
+
+ c->set_point_pos(p_idx,p_restore);
+ return;
+ }
+ ur->create_action("Set Curve Point Pos");
+ ur->add_do_method(c.ptr(),"set_point_pos",p_idx,c->get_point_pos(p_idx));
+ ur->add_undo_method(c.ptr(),"set_point_pos",p_idx,p_restore);
+ ur->commit_action();
+
+ return;
+ }
+
+ p_idx=p_idx-c->get_point_count()+1;
+
+ int idx=p_idx/2;
+ int t=p_idx%2;
+
+ Vector3 ofs;
+
+ if (p_cancel) {
+
+
+
+ return;
+ }
+
+
+
+ if (t==0) {
+
+ if (p_cancel) {
+
+ c->set_point_in(p_idx,p_restore);
+ return;
+ }
+ ur->create_action("Set Curve In Pos");
+ ur->add_do_method(c.ptr(),"set_point_in",idx,c->get_point_in(idx));
+ ur->add_undo_method(c.ptr(),"set_point_in",idx,p_restore);
+ ur->commit_action();
+
+
+ } else {
+ if (p_cancel) {
+
+ c->set_point_out(idx,p_restore);
+ return;
+ }
+ ur->create_action("Set Curve Out Pos");
+ ur->add_do_method(c.ptr(),"set_point_out",idx,c->get_point_out(idx));
+ ur->add_undo_method(c.ptr(),"set_point_out",idx,p_restore);
+ ur->commit_action();
+
+ }
+
+}
+
+
+void PathSpatialGizmo::redraw(){
+
+ clear();
+
+ Ref<Curve3D> c = path->get_curve();
+ if (c.is_null())
+ return;
+
+ Vector3Array v3a=c->tesselate();
+ //Vector3Array v3a=c->get_baked_points();
+
+ int v3s = v3a.size();
+ if (v3s==0)
+ return;
+ Vector<Vector3> v3p;
+ Vector3Array::Read r = v3a.read();
+
+ for(int i=0;i<v3s-1;i++) {
+
+ v3p.push_back(r[i]);
+ v3p.push_back(r[i+1]);
+ //v3p.push_back(r[i]);
+ //v3p.push_back(r[i]+Vector3(0,0.2,0));
+ }
+
+ add_lines(v3p,PathEditorPlugin::singleton->path_material);
+ add_collision_segments(v3p);
+
+ if (PathEditorPlugin::singleton->get_edited_path()==path) {
+ v3p.clear();
+ Vector<Vector3> handles;
+ Vector<Vector3> sec_handles;
+
+ for(int i=0;i<c->get_point_count();i++) {
+
+ Vector3 p = c->get_point_pos(i);
+ handles.push_back(p);
+ if (i>0) {
+ v3p.push_back(p);
+ v3p.push_back(p+c->get_point_in(i));
+ sec_handles.push_back(p+c->get_point_in(i));
+ }
+
+ if (i<c->get_point_count()-1) {
+ v3p.push_back(p);
+ v3p.push_back(p+c->get_point_out(i));
+ sec_handles.push_back(p+c->get_point_out(i));
+ }
+ }
+
+ add_lines(v3p,PathEditorPlugin::singleton->path_thin_material);
+ add_handles(handles);
+ add_handles(sec_handles,false,true);
+ }
+
+}
+
+PathSpatialGizmo::PathSpatialGizmo(Path* p_path){
+
+ path=p_path;
+ set_spatial_node(p_path);
+
+
+
+}
+
+bool PathEditorPlugin::create_spatial_gizmo(Spatial* p_spatial) {
+
+ if (p_spatial->cast_to<Path>()) {
+
+
+ Ref<PathSpatialGizmo> psg = memnew( PathSpatialGizmo(p_spatial->cast_to<Path>()));
+ p_spatial->set_gizmo(psg);
+ return true;
+ }
+
+ return false;
+}
+
+bool PathEditorPlugin::forward_spatial_input_event(Camera* p_camera,const InputEvent& p_event) {
+
+ if (!path)
+ return false;
+ Ref<Curve3D> c=path->get_curve();
+ if (c.is_null())
+ return false;
+ Transform gt = path->get_global_transform();
+ Transform it = gt.affine_inverse();
+
+ static const int click_dist = 10; //should make global
+
+
+ if (p_event.type==InputEvent::MOUSE_BUTTON) {
+
+ const InputEventMouseButton &mb=p_event.mouse_button;
+ Point2 mbpos(mb.x,mb.y);
+
+ if (mb.pressed && mb.button_index==BUTTON_LEFT && (curve_create->is_pressed() || (curve_edit->is_pressed() && mb.mod.control))) {
+ //click into curve, break it down
+ Vector3Array v3a = c->tesselate();
+ int idx=0;
+ int rc=v3a.size();
+ int closest_seg=-1;
+ Vector3 closest_seg_point;
+ float closest_d=1e20;
+
+ if (rc>=2) {
+ Vector3Array::Read r = v3a.read();
+
+ if (p_camera->unproject_position(gt.xform(c->get_point_pos(0))).distance_to(mbpos)<click_dist)
+ return false; //nope, existing
+
+
+ for(int i=0;i<c->get_point_count()-1;i++) {
+ //find the offset and point index of the place to break up
+ int j=idx;
+ if (p_camera->unproject_position(gt.xform(c->get_point_pos(i+1))).distance_to(mbpos)<click_dist)
+ return false; //nope, existing
+
+
+ while(j<rc && c->get_point_pos(i+1)!=r[j]) {
+
+ Vector3 from =r[j];
+ Vector3 to =r[j+1];
+ real_t cdist = from.distance_to(to);
+ from=gt.xform(from);
+ to=gt.xform(to);
+ if (cdist>0) {
+ Vector2 s[2];
+ s[0] = p_camera->unproject_position(from);
+ s[1] = p_camera->unproject_position(to);
+ Vector2 inters = Geometry::get_closest_point_to_segment_2d(mbpos,s);
+ float d = inters.distance_to(mbpos);
+
+ if (d<10 && d<closest_d) {
+
+
+ closest_d=d;
+ closest_seg=i;
+ Vector3 ray_from=p_camera->project_ray_origin(mbpos);
+ Vector3 ray_dir=p_camera->project_ray_normal(mbpos);
+
+ Vector3 ra,rb;
+ Geometry::get_closest_points_between_segments(ray_from,ray_from+ray_dir*4096,from,to,ra,rb);
+
+ closest_seg_point=it.xform(rb);
+ }
+
+ }
+ j++;
+
+ }
+ if (idx==j)
+ idx++; //force next
+ else
+ idx=j; //swap
+
+
+ if (j==rc)
+ break;
+ }
+ }
+
+ UndoRedo *ur = editor->get_undo_redo();
+ if (closest_seg!=-1) {
+ //subdivide
+
+ ur->create_action("Split Path");
+ ur->add_do_method(c.ptr(),"add_point",closest_seg_point,Vector3(),Vector3(),closest_seg+1);
+ ur->add_undo_method(c.ptr(),"remove_point",closest_seg+1);
+ ur->commit_action();;
+ return true;
+
+ } else {
+
+ Vector3 org;
+ if (c->get_point_count()==0)
+ org=path->get_transform().get_origin();
+ else
+ org=gt.xform(c->get_point_pos(c->get_point_count()));
+ Plane p(org,p_camera->get_transform().basis.get_axis(2));
+ Vector3 ray_from=p_camera->project_ray_origin(mbpos);
+ Vector3 ray_dir=p_camera->project_ray_normal(mbpos);
+
+ Vector3 inters;
+ if (p.intersects_ray(ray_from,ray_dir,&inters)) {
+
+ ur->create_action("Add Point to Curve");
+ ur->add_do_method(c.ptr(),"add_point",it.xform(inters),Vector3(),Vector3(),-1);
+ ur->add_undo_method(c.ptr(),"remove_point",c->get_point_count());
+ ur->commit_action();;
+ return true;
+ }
+
+ //add new at pos
+ }
+
+ } else if (mb.pressed && ((mb.button_index==BUTTON_LEFT && curve_del->is_pressed()) || (mb.button_index==BUTTON_RIGHT && curve_edit->is_pressed()))) {
+
+ int erase_idx=-1;
+ for(int i=0;i<c->get_point_count();i++) {
+ //find the offset and point index of the place to break up
+ if (p_camera->unproject_position(gt.xform(c->get_point_pos(i))).distance_to(mbpos)<click_dist) {
+
+ erase_idx=i;
+ break;
+ }
+ }
+
+ if (erase_idx!=-1) {
+
+ UndoRedo *ur = editor->get_undo_redo();
+ ur->create_action("Remove Path Point");
+ ur->add_do_method(c.ptr(),"remove_point",erase_idx);
+ ur->add_undo_method(c.ptr(),"add_point",c->get_point_pos(erase_idx),c->get_point_in(erase_idx),c->get_point_out(erase_idx),erase_idx);
+ ur->commit_action();
+ return true;
+ }
+ }
+
+ }
+
+ return false;
+}
+
+
+void PathEditorPlugin::edit(Object *p_object) {
+
+ if (p_object) {
+ path=p_object->cast_to<Path>();
+ if (path) {
+
+ if (path->get_curve().is_valid()) {
+ path->get_curve()->emit_signal("changed");
+ }
+ }
+ } else {
+ Path *pre=path;
+ path=NULL;
+ if (pre) {
+ pre->get_curve()->emit_signal("changed");
+ }
+ }
+// collision_polygon_editor->edit(p_object->cast_to<Node>());
+}
+
+bool PathEditorPlugin::handles(Object *p_object) const {
+
+ return p_object->is_type("Path");
+}
+
+void PathEditorPlugin::make_visible(bool p_visible) {
+
+ if (p_visible) {
+
+ curve_create->show();
+ curve_edit->show();
+ curve_del->show();
+ curve_close->show();
+ sep->show();
+ } else {
+
+ curve_create->hide();
+ curve_edit->hide();
+ curve_del->hide();
+ curve_close->hide();
+ sep->hide();
+
+ {
+ Path *pre=path;
+ path=NULL;
+ if (pre && pre->get_curve().is_valid()) {
+ pre->get_curve()->emit_signal("changed");
+ }
+ }
+ }
+
+}
+
+void PathEditorPlugin::_mode_changed(int p_idx) {
+
+ curve_create->set_pressed(p_idx==0);
+ curve_edit->set_pressed(p_idx==1);
+ curve_del->set_pressed(p_idx==2);
+}
+
+void PathEditorPlugin::_close_curve() {
+
+ Ref<Curve3D> c = path->get_curve();
+ if (c.is_null())
+ return ;
+ if (c->get_point_count()<2)
+ return;
+ c->add_point(c->get_point_pos(0),c->get_point_in(0),c->get_point_out(0));
+
+}
+
+void PathEditorPlugin::_notification(int p_what) {
+
+ if (p_what==NOTIFICATION_ENTER_SCENE) {
+
+ curve_create->connect("pressed",this,"_mode_changed",make_binds(0));
+ curve_edit->connect("pressed",this,"_mode_changed",make_binds(1));
+ curve_del->connect("pressed",this,"_mode_changed",make_binds(2));
+ curve_close->connect("pressed",this,"_close_curve");
+ }
+}
+
+void PathEditorPlugin::_bind_methods() {
+
+ ObjectTypeDB::bind_method(_MD("_mode_changed"),&PathEditorPlugin::_mode_changed);
+ ObjectTypeDB::bind_method(_MD("_close_curve"),&PathEditorPlugin::_close_curve);
+}
+
+PathEditorPlugin* PathEditorPlugin::singleton=NULL;
+
+
+PathEditorPlugin::PathEditorPlugin(EditorNode *p_node) {
+
+ path=NULL;
+ editor=p_node;
+ singleton=this;
+
+ path_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
+ path_material->set_parameter( FixedMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.8) );
+ path_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
+ path_material->set_line_width(3);
+ path_material->set_flag(Material::FLAG_DOUBLE_SIDED,true);
+ path_material->set_flag(Material::FLAG_UNSHADED,true);
+
+ path_thin_material = Ref<FixedMaterial>( memnew( FixedMaterial ));
+ path_thin_material->set_parameter( FixedMaterial::PARAM_DIFFUSE,Color(0.5,0.5,1.0,0.4) );
+ path_thin_material->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true);
+ path_thin_material->set_line_width(1);
+ path_thin_material->set_flag(Material::FLAG_DOUBLE_SIDED,true);
+ path_thin_material->set_flag(Material::FLAG_UNSHADED,true);
+
+ SpatialEditor::get_singleton()->add_gizmo_plugin(this);
+
+ sep = memnew( VSeparator);
+ sep->hide();
+ SpatialEditor::get_singleton()->add_control_to_menu_panel(sep);
+ curve_edit = memnew( ToolButton );
+ curve_edit->set_icon(SpatialEditor::get_singleton()->get_icon("CurveEdit","EditorIcons"));
+ curve_edit->set_toggle_mode(true);
+ curve_edit->hide();
+ curve_edit->set_focus_mode(Control::FOCUS_NONE);
+ curve_edit->set_tooltip("Select Points\nShift+Drag: Select Control Points\n"+keycode_get_string(KEY_MASK_CMD)+"Click: Add Point\nRight Click: Delete Point.");
+ SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_edit);
+ curve_create = memnew( ToolButton );
+ curve_create->set_icon(SpatialEditor::get_singleton()->get_icon("CurveCreate","EditorIcons"));
+ curve_create->set_toggle_mode(true);
+ curve_create->hide();
+ curve_create->set_focus_mode(Control::FOCUS_NONE);
+ curve_create->set_tooltip("Add Point (in empty space)\nSplit Segment (in curve).");
+ SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_create);
+ curve_del = memnew( ToolButton );
+ curve_del->set_icon(SpatialEditor::get_singleton()->get_icon("CurveDelete","EditorIcons"));
+ curve_del->set_toggle_mode(true);
+ curve_del->hide();
+ curve_del->set_focus_mode(Control::FOCUS_NONE);
+ curve_del->set_tooltip("Delete Point.");
+ SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_del);
+ curve_close = memnew( ToolButton );
+//curve_close->set_icon(SpatialEditor::get_singleton()->get_icon("CurveDelete","EditorIcons"));
+ curve_close->set_text("close");
+ curve_close->hide();
+ curve_close->set_focus_mode(Control::FOCUS_NONE);
+ curve_close->set_tooltip("Close Curve");
+ SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_close);
+
+
+
+ curve_edit->set_pressed(true);
+ /*
+ collision_polygon_editor = memnew( PathEditor(p_node) );
+ editor->get_viewport()->add_child(collision_polygon_editor);
+
+ collision_polygon_editor->set_margin(MARGIN_LEFT,200);
+ collision_polygon_editor->set_margin(MARGIN_RIGHT,230);
+ collision_polygon_editor->set_margin(MARGIN_TOP,0);
+ collision_polygon_editor->set_margin(MARGIN_BOTTOM,10);
+
+
+ collision_polygon_editor->hide();
+ */
+
+
+}
+
+
+PathEditorPlugin::~PathEditorPlugin()
+{
+}
+
diff --git a/tools/editor/plugins/path_editor_plugin.h b/tools/editor/plugins/path_editor_plugin.h new file mode 100644 index 000000000..b938358d3 --- /dev/null +++ b/tools/editor/plugins/path_editor_plugin.h @@ -0,0 +1,99 @@ +/*************************************************************************/ +/* path_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef PATH_EDITOR_PLUGIN_H
+#define PATH_EDITOR_PLUGIN_H
+
+
+#include "tools/editor/spatial_editor_gizmos.h"
+#include "scene/3d/path.h"
+class PathSpatialGizmo : public SpatialGizmoTool {
+
+ OBJ_TYPE(PathSpatialGizmo,SpatialGizmoTool);
+
+ Path* path;
+ mutable Vector3 original;
+
+public:
+
+ virtual String get_handle_name(int p_idx) const;
+ virtual Variant get_handle_value(int p_idx) const;
+ virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
+ virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
+
+ void redraw();
+ PathSpatialGizmo(Path* p_path=NULL);
+
+};
+
+class PathEditorPlugin : public EditorPlugin {
+
+ OBJ_TYPE( PathEditorPlugin, EditorPlugin );
+
+
+ Separator *sep;
+ ToolButton *curve_create;
+ ToolButton *curve_edit;
+ ToolButton *curve_del;
+ ToolButton *curve_close;
+
+ EditorNode *editor;
+
+
+ Path *path;
+
+ void _mode_changed(int p_idx);
+ void _close_curve();
+protected:
+ void _notification(int p_what);
+ static void _bind_methods();
+
+public:
+
+ Path *get_edited_path() { return path; }
+
+ static PathEditorPlugin* singleton;
+ Ref<FixedMaterial> path_material;
+ Ref<FixedMaterial> path_thin_material;
+ virtual bool forward_spatial_input_event(Camera* p_camera,const InputEvent& p_event);
+
+// virtual bool forward_input_event(const InputEvent& p_event) { return collision_polygon_editor->forward_input_event(p_event); }
+ virtual bool create_spatial_gizmo(Spatial* p_spatial);
+ virtual String get_name() const { return "Path"; }
+ bool has_main_screen() const { return false; }
+ virtual void edit(Object *p_node);
+ virtual bool handles(Object *p_node) const;
+ virtual void make_visible(bool p_visible);
+
+ PathEditorPlugin(EditorNode *p_node);
+ ~PathEditorPlugin();
+
+};
+
+
+#endif // PATH_EDITOR_PLUGIN_H
diff --git a/tools/editor/plugins/resource_preloader_editor_plugin.cpp b/tools/editor/plugins/resource_preloader_editor_plugin.cpp new file mode 100644 index 000000000..b0841933e --- /dev/null +++ b/tools/editor/plugins/resource_preloader_editor_plugin.cpp @@ -0,0 +1,388 @@ +/*************************************************************************/ +/* resource_preloader_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "resource_preloader_editor_plugin.h" +#include "io/resource_loader.h" +#include "globals.h" +#include "tools/editor/editor_settings.h" +#include "scene/resources/scene_preloader.h" + + + +void ResourcePreloaderEditor::_input_event(InputEvent p_event) { + + +} + +void ResourcePreloaderEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_FIXED_PROCESS) { + + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + load->set_icon( get_icon("Folder","EditorIcons") ); + _delete->set_icon( get_icon("Del","EditorIcons") ); + } + + if (p_what==NOTIFICATION_READY) { + +// NodePath("/root")->connect("node_removed", this,"_node_removed",Vector<Variant>(),true); + } + + if (p_what==NOTIFICATION_DRAW) { + + } +} + +void ResourcePreloaderEditor::_file_load_request(const String& p_path) { + + + RES resource; + + resource = ResourceLoader::load(p_path); + + if (resource.is_null()) { + dialog->set_text("ERROR: Couldn't load resource!"); + dialog->set_title("Error!"); + //dialog->get_cancel()->set_text("Close"); + dialog->get_ok()->set_text("Close"); + dialog->popup_centered(Size2(300,60)); + return; ///beh should show an error i guess + } + + String basename = p_path.get_file().basename(); + String name=basename; + int counter=1; + while(preloader->has_resource(name)) { + counter++; + name=basename+" "+itos(counter); + } + + undo_redo->create_action("Add Resource"); + undo_redo->add_do_method(preloader,"add_resource",name,resource); + undo_redo->add_undo_method(preloader,"remove_resource",name); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); +} + +void ResourcePreloaderEditor::_load_pressed() { + + loading_scene=false; + + file->clear_filters(); + List<String> extensions; + ResourceLoader::get_recognized_extensions_for_type("",&extensions); + for(int i=0;i<extensions.size();i++) + file->add_filter("*."+extensions[i]); + + file->set_mode(FileDialog::MODE_OPEN_FILE); + + file->popup_centered_ratio(); + +} + + +void ResourcePreloaderEditor::_item_edited() { + + if (!tree->get_selected()) + return; + + TreeItem *s = tree->get_selected(); + + if (tree->get_selected_column()==0) { + // renamed + String old_name=s->get_metadata(0); + String new_name=s->get_text(0); + if (old_name==new_name) + return; + + if (new_name=="" || new_name.find("\\")!=-1 || new_name.find("/")!=-1 || preloader->has_resource(new_name)) { + + s->set_text(0,old_name); + return; + } + + RES samp = preloader->get_resource(old_name); + undo_redo->create_action("Rename Resource"); + undo_redo->add_do_method(preloader,"remove_resource",old_name); + undo_redo->add_do_method(preloader,"add_resource",new_name,samp); + undo_redo->add_undo_method(preloader,"remove_resource",new_name); + undo_redo->add_undo_method(preloader,"add_resource",old_name,samp); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + + } + + +} + +void ResourcePreloaderEditor::_delete_confirm_pressed() { + + if (!tree->get_selected()) + return; + + String to_remove = tree->get_selected()->get_text(0); + undo_redo->create_action("Delete Resource"); + undo_redo->add_do_method(preloader,"remove_resource",to_remove); + undo_redo->add_undo_method(preloader,"add_resource",to_remove,preloader->get_resource(to_remove)); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); +} + + +void ResourcePreloaderEditor::_paste_pressed() { + + RES r=EditorSettings::get_singleton()->get_resource_clipboard(); + if (!r.is_valid()) { + dialog->set_text("Resource clipboard is empty!"); + dialog->set_title("Error!"); + //dialog->get_cancel()->set_text("Close"); + dialog->get_ok()->set_text("Close"); + dialog->popup_centered(Size2(300,60)); + return; ///beh should show an error i guess + } + + String name = r->get_name(); + if (name=="") + name=r->get_path().get_file(); + if (name=="") + name=r->get_type(); + + String basename = name; + int counter=1; + while(preloader->has_resource(name)) { + counter++; + name=basename+" "+itos(counter); + } + + undo_redo->create_action("Paste Resource"); + undo_redo->add_do_method(preloader,"add_resource",name,r); + undo_redo->add_undo_method(preloader,"remove_resource",name); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + +} + + +void ResourcePreloaderEditor::_delete_pressed() { + + + if (!tree->get_selected()) + return; + + _delete_confirm_pressed(); //it has undo.. why bother with a dialog.. + /* + dialog->set_title("Confirm..."); + dialog->set_text("Remove Resource '"+tree->get_selected()->get_text(0)+"' ?"); + //dialog->get_cancel()->set_text("Cancel"); + //dialog->get_ok()->show(); + dialog->get_ok()->set_text("Remove"); + dialog->popup_centered(Size2(300,60));*/ + +} + + +void ResourcePreloaderEditor::_update_library() { + + tree->clear(); + tree->set_hide_root(true); + TreeItem *root = tree->create_item(NULL); + + List<StringName> rnames; + preloader->get_resource_list(&rnames); + + List<String> names; + for(List<StringName>::Element *E=rnames.front();E;E=E->next()) { + names.push_back(E->get()); + } + + names.sort(); + + for(List<String>::Element *E=names.front();E;E=E->next()) { + + TreeItem *ti = tree->create_item(root); + ti->set_cell_mode(0,TreeItem::CELL_MODE_STRING); + ti->set_editable(0,true); + ti->set_selectable(0,true); + ti->set_text(0,E->get()); + ti->set_metadata(0,E->get()); + + + + RES r = preloader->get_resource(E->get()); + + ERR_CONTINUE(r.is_null()); + + ti->set_tooltip(0,r->get_path()); + String type = r->get_type(); + ti->set_text(1,type); + ti->set_selectable(1,false); + + if (has_icon(type,"EditorIcons")) + ti->set_icon( 1, get_icon(type,"EditorIcons") ); + + } + + //player->add_resource("default",resource); +} + + + +void ResourcePreloaderEditor::edit(ResourcePreloader* p_preloader) { + + preloader=p_preloader; + + + if (p_preloader) { + _update_library(); + } else { + + hide(); + set_fixed_process(false); + } + +} + + + +void ResourcePreloaderEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_input_event"),&ResourcePreloaderEditor::_input_event); + ObjectTypeDB::bind_method(_MD("_load_pressed"),&ResourcePreloaderEditor::_load_pressed); + ObjectTypeDB::bind_method(_MD("_item_edited"),&ResourcePreloaderEditor::_item_edited); + ObjectTypeDB::bind_method(_MD("_delete_pressed"),&ResourcePreloaderEditor::_delete_pressed); + ObjectTypeDB::bind_method(_MD("_paste_pressed"),&ResourcePreloaderEditor::_paste_pressed); + ObjectTypeDB::bind_method(_MD("_delete_confirm_pressed"),&ResourcePreloaderEditor::_delete_confirm_pressed); + ObjectTypeDB::bind_method(_MD("_file_load_request"),&ResourcePreloaderEditor::_file_load_request); + ObjectTypeDB::bind_method(_MD("_update_library"),&ResourcePreloaderEditor::_update_library); +} + +ResourcePreloaderEditor::ResourcePreloaderEditor() { + + //add_style_override("panel", get_stylebox("panel","Panel")); + + VBoxContainer *vbc = memnew( VBoxContainer ); + add_child(vbc); + + HBoxContainer *hbc = memnew( HBoxContainer ); + vbc->add_child(hbc); + + load = memnew( Button ); + load->set_tooltip("Load Resource"); + hbc->add_child(load); + + + + _delete = memnew( Button ); + hbc->add_child(_delete); + + paste = memnew( Button ); + paste->set_text("Paste"); + hbc->add_child(paste); + + file = memnew( FileDialog ); + add_child(file); + + + tree = memnew( Tree ); + tree->set_columns(2); + tree->set_column_min_width(0,3); + tree->set_column_min_width(1,1); + tree->set_column_expand(0,true); + tree->set_column_expand(1,true); + tree->set_v_size_flags(SIZE_EXPAND_FILL); + + vbc->add_child(tree); + + dialog = memnew( AcceptDialog ); + add_child( dialog ); + + load->connect("pressed", this,"_load_pressed"); + _delete->connect("pressed", this,"_delete_pressed"); + paste->connect("pressed", this,"_paste_pressed"); + file->connect("file_selected", this,"_file_load_request"); + //dialog->connect("confirmed", this,"_delete_confirm_pressed"); + tree->connect("item_edited", this,"_item_edited"); + loading_scene=false; + +} + + +void ResourcePreloaderEditorPlugin::edit(Object *p_object) { + + preloader_editor->set_undo_redo(&get_undo_redo()); + ResourcePreloader * s = p_object->cast_to<ResourcePreloader>(); + if (!s) + return; + + preloader_editor->edit(s); +} + +bool ResourcePreloaderEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("ResourcePreloader"); +} + +void ResourcePreloaderEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + preloader_editor->show(); +// preloader_editor->set_process(true); + } else { + + preloader_editor->hide(); +// preloader_editor->set_process(false); + } + +} + +ResourcePreloaderEditorPlugin::ResourcePreloaderEditorPlugin(EditorNode *p_node) { + + editor=p_node; + preloader_editor = memnew( ResourcePreloaderEditor ); + editor->get_viewport()->add_child(preloader_editor); + preloader_editor->set_area_as_parent_rect(); +// preloader_editor->set_anchor( MARGIN_TOP, Control::ANCHOR_END); +// preloader_editor->set_margin( MARGIN_TOP, 120 ); + preloader_editor->hide(); + + + +} + + +ResourcePreloaderEditorPlugin::~ResourcePreloaderEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/resource_preloader_editor_plugin.h b/tools/editor/plugins/resource_preloader_editor_plugin.h new file mode 100644 index 000000000..e3178bc8f --- /dev/null +++ b/tools/editor/plugins/resource_preloader_editor_plugin.h @@ -0,0 +1,102 @@ +/*************************************************************************/ +/* resource_preloader_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef RESOURCE_PRELOADER_EDITOR_PLUGIN_H +#define RESOURCE_PRELOADER_EDITOR_PLUGIN_H + + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/gui/tree.h" +#include "scene/main/resource_preloader.h" +#include "scene/gui/file_dialog.h" +#include "scene/gui/dialogs.h" + + +class ResourcePreloaderEditor : public PanelContainer { + + OBJ_TYPE(ResourcePreloaderEditor, PanelContainer ); + + Button *load; + Button *_delete; + Button *paste; + Tree *tree; + bool loading_scene; + + + FileDialog *file; + + AcceptDialog *dialog; + + ResourcePreloader *preloader; + + + void _load_pressed(); + void _load_scene_pressed(); + void _file_load_request(const String& p_path); + void _paste_pressed(); + void _delete_pressed(); + void _delete_confirm_pressed(); + void _update_library(); + void _item_edited(); + + UndoRedo *undo_redo; + +protected: + void _notification(int p_what); + void _input_event(InputEvent p_event); + static void _bind_methods(); +public: + + void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; } + + void edit(ResourcePreloader* p_preloader); + ResourcePreloaderEditor(); +}; + +class ResourcePreloaderEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ResourcePreloaderEditorPlugin, EditorPlugin ); + + ResourcePreloaderEditor *preloader_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "ResourcePreloader"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + ResourcePreloaderEditorPlugin(EditorNode *p_node); + ~ResourcePreloaderEditorPlugin(); + +}; + +#endif // RESOURCE_PRELOADER_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/rich_text_editor_plugin.cpp b/tools/editor/plugins/rich_text_editor_plugin.cpp new file mode 100644 index 000000000..58b3636dc --- /dev/null +++ b/tools/editor/plugins/rich_text_editor_plugin.cpp @@ -0,0 +1,163 @@ +/*************************************************************************/ +/* rich_text_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "rich_text_editor_plugin.h" +#include "os/file_access.h" +void RichTextEditor::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_FIXED_PROCESS: { + + + } break; + } + +} +void RichTextEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} + + +void RichTextEditor::_file_selected(const String& p_path) { + + CharString cs; + FileAccess *fa = FileAccess::open(p_path,FileAccess::READ); + if (!fa) { + ERR_FAIL(); + } + + while(!fa->eof_reached()) + cs.push_back(fa->get_8()); + cs.push_back(0); + memdelete(fa); + + String bbcode; + bbcode.parse_utf8(&cs[0]); + node->parse_bbcode(bbcode); + +} + +void RichTextEditor::_menu_option(int p_option) { + + switch(p_option) { + + case PARSE_BBCODE: { + + file_dialog->popup_centered_ratio(); + } break; + case CLEAR: { + + node->clear(); + + } break; + + } +} + +void RichTextEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_menu_option"),&RichTextEditor::_menu_option); + ObjectTypeDB::bind_method(_MD("_file_selected"),&RichTextEditor::_file_selected); + +} + +void RichTextEditor::edit(Node *p_rich_text) { + + node=p_rich_text->cast_to<RichTextLabel>(); + +} +RichTextEditor::RichTextEditor() { + + options = memnew( MenuButton ); + add_child(options); + options->set_area_as_parent_rect(); + + options->set_text("RichText"); + options->get_popup()->add_item("Parse BBCODE",PARSE_BBCODE); + options->get_popup()->add_item("Clear",CLEAR); + + options->get_popup()->connect("item_pressed", this,"_menu_option"); + file_dialog = memnew( FileDialog ); + add_child(file_dialog); + file_dialog->add_filter("*.txt"); + file_dialog->set_mode(FileDialog::MODE_OPEN_FILE); + file_dialog->connect("file_selected",this,"_file_selected"); +} + + +void RichTextEditorPlugin::edit(Object *p_object) { + + rich_text_editor->edit(p_object->cast_to<Node>()); +} + +bool RichTextEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("RichTextLabel"); +} + +void RichTextEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + rich_text_editor->show(); + } else { + + rich_text_editor->hide(); + rich_text_editor->edit(NULL); + } + +} + +RichTextEditorPlugin::RichTextEditorPlugin(EditorNode *p_node) { + + editor=p_node; + rich_text_editor = memnew( RichTextEditor ); + editor->get_viewport()->add_child(rich_text_editor); + + rich_text_editor->set_margin(MARGIN_LEFT,184); + rich_text_editor->set_margin(MARGIN_RIGHT,230); + rich_text_editor->set_margin(MARGIN_TOP,0); + rich_text_editor->set_margin(MARGIN_BOTTOM,10); + + + rich_text_editor->hide(); + + + +} + + +RichTextEditorPlugin::~RichTextEditorPlugin() +{ +} + diff --git a/tools/editor/plugins/rich_text_editor_plugin.h b/tools/editor/plugins/rich_text_editor_plugin.h new file mode 100644 index 000000000..e51e0653b --- /dev/null +++ b/tools/editor/plugins/rich_text_editor_plugin.h @@ -0,0 +1,89 @@ +/*************************************************************************/ +/* rich_text_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef RICH_TEXT_EDITOR_PLUGIN_H +#define RICH_TEXT_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/gui/rich_text_label.h" +#include "scene/gui/file_dialog.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class RichTextEditor : public Control { + + OBJ_TYPE(RichTextEditor, Control ); + + enum { + + PARSE_BBCODE, + CLEAR + }; + + Panel *panel; + RichTextLabel *node; + MenuButton *options; + FileDialog *file_dialog; + + void _file_selected(const String& p_path); + void _menu_option(int p_option); + +protected: + void _notification(int p_what); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + void edit(Node *p_rich_text); + RichTextEditor(); +}; + +class RichTextEditorPlugin : public EditorPlugin { + + OBJ_TYPE( RichTextEditorPlugin, EditorPlugin ); + + RichTextEditor *rich_text_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "RichText"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + RichTextEditorPlugin(EditorNode *p_node); + ~RichTextEditorPlugin(); + +}; + +#endif // RICH_TEXT_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/sample_editor_plugin.cpp b/tools/editor/plugins/sample_editor_plugin.cpp new file mode 100644 index 000000000..f55d6640c --- /dev/null +++ b/tools/editor/plugins/sample_editor_plugin.cpp @@ -0,0 +1,326 @@ +/*************************************************************************/ +/* sample_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "sample_editor_plugin.h" + +#include "io/resource_loader.h" +#include "globals.h" +#include "tools/editor/editor_settings.h" + + + + +void SampleEditor::_input_event(InputEvent p_event) { + + +} + +void SampleEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_FIXED_PROCESS) { + + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + play->set_icon( get_icon("Play","EditorIcons") ); + stop->set_icon( get_icon("Stop","EditorIcons") ); + } + + if (p_what==NOTIFICATION_READY) { + + //get_scene()->connect("node_removed",this,"_node_removed"); + + } + + if (p_what==NOTIFICATION_DRAW) { + + } +} + +void SampleEditor::_play_pressed() { + + player->play("default",true); + stop->set_pressed(false); + play->set_pressed(true); +} +void SampleEditor::_stop_pressed() { + + player->stop_all(); + play->set_pressed(false); +} + +void SampleEditor::generate_preview_texture(const Ref<Sample>& p_sample,Ref<ImageTexture> &p_texture) { + + + DVector<uint8_t> data = p_sample->get_data(); + + DVector<uint8_t> img; + int w = p_texture->get_width(); + int h = p_texture->get_height(); + img.resize(w*h*3); + DVector<uint8_t>::Write imgdata = img.write(); + uint8_t * imgw = imgdata.ptr(); + DVector<uint8_t>::Read sampledata = data.read(); + const uint8_t *sdata=sampledata.ptr(); + + bool stereo = p_sample->is_stereo(); + bool _16=p_sample->get_format()==Sample::FORMAT_PCM16; + int len = p_sample->get_length(); + + if (len<1) + return; + + for(int i=0;i<w;i++) { + // i trust gcc will optimize this loop + float max[2]={-1e10,-1e10}; + float min[2]={1e10,1e10}; + int c=stereo?2:1; + int from = i*len/w; + int to = (i+1)*len/w; + if (to>=len) + to=len-1; + + if (_16) { + const int16_t*src =(const int16_t*)sdata; + + for(int j=0;j<c;j++) { + + for(int k=from;k<=to;k++) { + + float v = src[k*c+j]/32768.0; + if (v>max[j]) + max[j]=v; + if (v<min[j]) + min[j]=v; + } + + } + } else { + + const int8_t*src =(const int8_t*)sdata; + + for(int j=0;j<c;j++) { + + for(int k=from;k<=to;k++) { + + float v = src[k*c+j]/128.0; + if (v>max[j]) + max[j]=v; + if (v<min[j]) + min[j]=v; + } + + } + } + + if (!stereo) { + for(int j=0;j<h;j++) { + float v = (j/(float)h) * 2.0 - 1.0; + uint8_t* imgofs = &imgw[(j*w+i)*3]; + if (v>min[0] && v<max[0]) { + imgofs[0]=255; + imgofs[1]=150; + imgofs[2]=80; + } else { + imgofs[0]=0; + imgofs[1]=0; + imgofs[2]=0; + } + } + } else { + + for(int j=0;j<h;j++) { + + int half,ofs; + float v; + if (j<(h/2)) { + half=0; + ofs=0; + v = (j/(float)(h/2)) * 2.0 - 1.0; + } else { + half=1; + ofs=h/2; + v = ((j-(h/2))/(float)(h/2)) * 2.0 - 1.0; + } + + uint8_t* imgofs = &imgw[(j*w+i)*3]; + if (v>min[half] && v<max[half]) { + imgofs[0]=255; + imgofs[1]=150; + imgofs[2]=80; + } else { + imgofs[0]=0; + imgofs[1]=0; + imgofs[2]=0; + } + } + + } + + } + + imgdata = DVector<uint8_t>::Write(); + + + p_texture->set_data(Image(w,h,0,Image::FORMAT_RGB,img)); + +} + +void SampleEditor::_update_sample() { + + player->stop_all(); + if (sample->get_format()==Sample::FORMAT_IMA_ADPCM) + return; //bye or unsupported + + generate_preview_texture(sample,peakdisplay); + info_label->set_text("Length: "+itos(sample->get_length())+" frames ("+String::num(sample->get_length()/(float)sample->get_mix_rate(),2)+" s), "+(sample->get_format()==Sample::FORMAT_PCM16?"16 Bits, ":"8 bits, ")+(sample->is_stereo()?"Stereo.":"Mono.")); + + library->add_sample("default",sample); +} + + + +void SampleEditor::edit(Ref<Sample> p_sample) { + + sample=p_sample; + + if (!sample.is_null()) + _update_sample(); + else { + + hide(); + set_fixed_process(false); + } + +} + + + +void SampleEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_input_event"),&SampleEditor::_input_event); + ObjectTypeDB::bind_method(_MD("_play_pressed"),&SampleEditor::_play_pressed); + ObjectTypeDB::bind_method(_MD("_stop_pressed"),&SampleEditor::_stop_pressed); + +} + +SampleEditor::SampleEditor() { + + player = memnew(SamplePlayer); + add_child(player); + add_style_override("panel", get_stylebox("panel","Panel")); + library = Ref<SampleLibrary>(memnew(SampleLibrary)); + player->set_sample_library(library); + sample_texframe = memnew( TextureFrame ); + add_child(sample_texframe); + sample_texframe->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,5); + sample_texframe->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,5); + sample_texframe->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,30); + sample_texframe->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,5); + + info_label = memnew( Label ); + sample_texframe->add_child(info_label); + info_label->set_area_as_parent_rect(); + info_label->set_anchor_and_margin(MARGIN_TOP,ANCHOR_END,15); + info_label->set_margin(MARGIN_BOTTOM,4); + info_label->set_margin(MARGIN_RIGHT,4); + info_label->set_align(Label::ALIGN_RIGHT); + + + play = memnew( Button ); + + play->set_pos(Point2( 5, 5 )); + play->set_size( Size2(1,1 ) ); + play->set_toggle_mode(true); + add_child(play); + + stop = memnew( Button ); + + stop->set_pos(Point2( 35, 5 )); + stop->set_size( Size2(1,1 ) ); + stop->set_toggle_mode(true); + add_child(stop); + + peakdisplay=Ref<ImageTexture>( memnew( ImageTexture) ); + peakdisplay->create( EDITOR_DEF("audio/sample_editor_preview_width",512),EDITOR_DEF("audio/sample_editor_preview_height",128),Image::FORMAT_RGB); + sample_texframe->set_expand(true); + sample_texframe->set_texture(peakdisplay); + + play->connect("pressed", this,"_play_pressed"); + stop->connect("pressed", this,"_stop_pressed"); + +} + + +void SampleEditorPlugin::edit(Object *p_object) { + + Sample * s = p_object->cast_to<Sample>(); + if (!s) + return; + + sample_editor->edit(Ref<Sample>(s)); +} + +bool SampleEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Sample"); +} + +void SampleEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + sample_editor->show(); +// sample_editor->set_process(true); + } else { + + sample_editor->hide(); +// sample_editor->set_process(false); + } + +} + +SampleEditorPlugin::SampleEditorPlugin(EditorNode *p_node) { + + editor=p_node; + sample_editor = memnew( SampleEditor ); + editor->get_viewport()->add_child(sample_editor); + sample_editor->set_area_as_parent_rect(); + sample_editor->set_anchor( MARGIN_TOP, Control::ANCHOR_END); + sample_editor->set_margin( MARGIN_TOP, 120 ); + sample_editor->hide(); + + + +} + + +SampleEditorPlugin::~SampleEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/sample_editor_plugin.h b/tools/editor/plugins/sample_editor_plugin.h new file mode 100644 index 000000000..78d5ed401 --- /dev/null +++ b/tools/editor/plugins/sample_editor_plugin.h @@ -0,0 +1,90 @@ +/*************************************************************************/ +/* sample_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SAMPLE_EDITOR_PLUGIN_H +#define SAMPLE_EDITOR_PLUGIN_H + + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/audio/sample_player.h" +#include "scene/resources/sample.h" +#include "scene/resources/sample_library.h" + + +class SampleEditor : public Panel { + + OBJ_TYPE(SampleEditor, Panel ); + + + SamplePlayer *player; + Label *info_label; + Ref<ImageTexture> peakdisplay; + Ref<Sample> sample; + Ref<SampleLibrary> library; + TextureFrame *sample_texframe; + Button *stop; + Button *play; + + void _play_pressed(); + void _stop_pressed(); + void _update_sample(); + +protected: + void _notification(int p_what); + void _input_event(InputEvent p_event); + static void _bind_methods(); +public: + + static void generate_preview_texture(const Ref<Sample>& p_sample,Ref<ImageTexture> &p_texture); + void edit(Ref<Sample> p_sample); + SampleEditor(); +}; + + +class SampleEditorPlugin : public EditorPlugin { + + OBJ_TYPE( SampleEditorPlugin, EditorPlugin ); + + SampleEditor *sample_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Sample"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + SampleEditorPlugin(EditorNode *p_node); + ~SampleEditorPlugin(); + +}; + +#endif // SAMPLE_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/sample_library_editor_plugin.cpp b/tools/editor/plugins/sample_library_editor_plugin.cpp new file mode 100644 index 000000000..86ac1671a --- /dev/null +++ b/tools/editor/plugins/sample_library_editor_plugin.cpp @@ -0,0 +1,449 @@ +/*************************************************************************/ +/* sample_library_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "sample_library_editor_plugin.h" + +#include "io/resource_loader.h" +#include "globals.h" +#include "tools/editor/editor_settings.h" +#include "scene/main/viewport.h" +#include "sample_editor_plugin.h" + + + +void SampleLibraryEditor::_input_event(InputEvent p_event) { + + +} + +void SampleLibraryEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_FIXED_PROCESS) { + + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + play->set_icon( get_icon("Play","EditorIcons") ); + stop->set_icon( get_icon("Stop","EditorIcons") ); + load->set_icon( get_icon("Folder","EditorIcons") ); + _delete->set_icon( get_icon("Del","EditorIcons") ); + } + + if (p_what==NOTIFICATION_READY) { + +// NodePath("/root")->connect("node_removed", this,"_node_removed",Vector<Variant>(),true); + } + + if (p_what==NOTIFICATION_DRAW) { + + } +} + +void SampleLibraryEditor::_play_pressed() { + + if (!tree->get_selected()) + return; + + String to_play = tree->get_selected()->get_text(0); + + player->play(to_play,true); + play->set_pressed(false); + stop->set_pressed(false); +} +void SampleLibraryEditor::_stop_pressed() { + + player->stop_all(); + play->set_pressed(false); +} + +void SampleLibraryEditor::_file_load_request(const DVector<String>& p_path) { + + + for(int i=0;i<p_path.size();i++) { + + String path = p_path[i]; + Ref<Sample> sample = ResourceLoader::load(path,"Sample"); + if (sample.is_null()) { + dialog->set_text("ERROR: Couldn't load sample!"); + dialog->set_title("Error!"); + //dialog->get_cancel()->set_text("Close"); + dialog->get_ok()->set_text("Close"); + dialog->popup_centered(Size2(300,60)); + return; ///beh should show an error i guess + } + String basename = path.get_file().basename(); + String name=basename; + int counter=0; + while(sample_library->has_sample(name)) { + counter++; + name=basename+"_"+itos(counter); + } + + undo_redo->create_action("Add Sample"); + undo_redo->add_do_method(sample_library.operator->(),"add_sample",name,sample); + undo_redo->add_undo_method(sample_library.operator->(),"remove_sample",name); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + } +} + +void SampleLibraryEditor::_load_pressed() { + + file->popup_centered_ratio(); + +} + +void SampleLibraryEditor::_button_pressed(Object *p_item,int p_column, int p_id) { + + TreeItem *ti=p_item->cast_to<TreeItem>(); + String name = ti->get_text(0); + + if (p_column==0) { + + player->play(name,true); + } else if (p_column==1) { + + get_scene()->get_root()->get_child(0)->call("_resource_selected",sample_library->get_sample(name)); + + } + + +} + + + + + +void SampleLibraryEditor::_item_edited() { + + if (!tree->get_selected()) + return; + + TreeItem *s = tree->get_selected(); + + if (tree->get_selected_column()==0) { + // renamed + String old_name=s->get_metadata(0); + String new_name=s->get_text(0); + if (old_name==new_name) + return; + + if (new_name=="" || new_name.find("\\")!=-1 || new_name.find("/")!=-1 || sample_library->has_sample(new_name)) { + + s->set_text(0,old_name); + return; + } + + Ref<Sample> samp = sample_library->get_sample(old_name); + undo_redo->create_action("Rename Sample"); + undo_redo->add_do_method(sample_library.operator->(),"remove_sample",old_name); + undo_redo->add_do_method(sample_library.operator->(),"add_sample",new_name,samp); + undo_redo->add_undo_method(sample_library.operator->(),"remove_sample",new_name); + undo_redo->add_undo_method(sample_library.operator->(),"add_sample",old_name,samp); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + + } else if (tree->get_selected_column()==3) { + + StringName n = s->get_text(0); + sample_library->sample_set_volume_db(n,s->get_range(3)); + + } else if (tree->get_selected_column()==4) { + + StringName n = s->get_text(0); + sample_library->sample_set_pitch_scale(n,s->get_range(4)); + + } else if (tree->get_selected_column()==5) { + + //edit + + Ref<Sample> samp = sample_library->get_sample(tree->get_selected()->get_metadata(0)); + + get_scene()->get_root()->get_child(0)->call("_resource_selected",samp); + } + + +} + +void SampleLibraryEditor::_delete_confirm_pressed() { + + if (!tree->get_selected()) + return; + + String to_remove = tree->get_selected()->get_text(0); + undo_redo->create_action("Delete Sample"); + undo_redo->add_do_method(sample_library.operator->(),"remove_sample",to_remove); + undo_redo->add_undo_method(sample_library.operator->(),"add_sample",to_remove,sample_library->get_sample(to_remove)); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); +} + + +void SampleLibraryEditor::_delete_pressed() { + + + if (!tree->get_selected()) + return; + + _delete_confirm_pressed(); //it has undo.. why bother with a dialog.. + /* + dialog->set_title("Confirm..."); + dialog->set_text("Remove Sample '"+tree->get_selected()->get_text(0)+"' ?"); + //dialog->get_cancel()->set_text("Cancel"); + //dialog->get_ok()->show(); + dialog->get_ok()->set_text("Remove"); + dialog->popup_centered(Size2(300,60));*/ + +} + + +void SampleLibraryEditor::_update_library() { + + player->stop_all(); + + tree->clear(); + tree->set_hide_root(true); + TreeItem *root = tree->create_item(NULL); + + List<StringName> names; + sample_library->get_sample_list(&names); + + for(List<StringName>::Element *E=names.front();E;E=E->next()) { + + TreeItem *ti = tree->create_item(root); + ti->set_cell_mode(0,TreeItem::CELL_MODE_STRING); + ti->set_editable(0,true); + ti->set_selectable(0,true); + ti->set_text(0,E->get()); + ti->set_metadata(0,E->get()); + ti->add_button(0,get_icon("Play","EditorIcons"),0); + ti->add_button(1,get_icon("Edit","EditorIcons"),1); + + Ref<Sample> smp = sample_library->get_sample(E->get()); + + Ref<ImageTexture> preview( memnew( ImageTexture )); + preview->create(128,16,Image::FORMAT_RGB); + SampleEditor::generate_preview_texture(smp,preview); + ti->set_cell_mode(1,TreeItem::CELL_MODE_ICON); + ti->set_selectable(1,false); + ti->set_editable(1,false); + ti->set_icon(1,preview); + + + ti->set_cell_mode(2,TreeItem::CELL_MODE_STRING); + ti->set_editable(2,false); + ti->set_selectable(2,false); + Ref<Sample> s = sample_library->get_sample(E->get()); + ti->set_text(2,String()+/*itos(s->get_length())+" frames ("+String::num(s->get_length()/(float)s->get_mix_rate(),2)+" s), "+*/(s->get_format()==Sample::FORMAT_PCM16?"16 Bits, ":"8 bits, ")+(s->is_stereo()?"Stereo":"Mono")); + + ti->set_cell_mode(3,TreeItem::CELL_MODE_RANGE); + ti->set_range_config(3,-60,24,0.01); + ti->set_selectable(3,true); + ti->set_editable(3,true); + ti->set_range(3,sample_library->sample_get_volume_db(E->get())); + + ti->set_cell_mode(4,TreeItem::CELL_MODE_RANGE); + ti->set_range_config(4,0.01,100,0.01); + ti->set_selectable(4,true); + ti->set_editable(4,true); + ti->set_range(4,sample_library->sample_get_pitch_scale(E->get())); + + //ti->set_cell_mode(5,TreeItem::CELL_MODE_CUSTOM); + //ti->set_text(5,"Edit.."); + //ti->set_selectable(5,true); + //ti->set_editable(5,true); + } + + //player->add_sample("default",sample); +} + + + +void SampleLibraryEditor::edit(Ref<SampleLibrary> p_sample_library) { + + sample_library=p_sample_library; + + + if (!sample_library.is_null()) { + player->set_sample_library(sample_library); + _update_library(); + } else { + + hide(); + set_fixed_process(false); + } + +} + + + +void SampleLibraryEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_input_event"),&SampleLibraryEditor::_input_event); + ObjectTypeDB::bind_method(_MD("_play_pressed"),&SampleLibraryEditor::_play_pressed); + ObjectTypeDB::bind_method(_MD("_stop_pressed"),&SampleLibraryEditor::_stop_pressed); + ObjectTypeDB::bind_method(_MD("_load_pressed"),&SampleLibraryEditor::_load_pressed); + ObjectTypeDB::bind_method(_MD("_item_edited"),&SampleLibraryEditor::_item_edited); + ObjectTypeDB::bind_method(_MD("_delete_pressed"),&SampleLibraryEditor::_delete_pressed); + ObjectTypeDB::bind_method(_MD("_delete_confirm_pressed"),&SampleLibraryEditor::_delete_confirm_pressed); + ObjectTypeDB::bind_method(_MD("_file_load_request"),&SampleLibraryEditor::_file_load_request); + ObjectTypeDB::bind_method(_MD("_update_library"),&SampleLibraryEditor::_update_library); + ObjectTypeDB::bind_method(_MD("_button_pressed"),&SampleLibraryEditor::_button_pressed); +} + +SampleLibraryEditor::SampleLibraryEditor() { + + player = memnew(SamplePlayer); + add_child(player); + add_style_override("panel", get_stylebox("panel","Panel")); + + + play = memnew( Button ); + + play->set_pos(Point2( 5, 5 )); + play->set_size( Size2(1,1 ) ); + play->set_toggle_mode(true); + //add_child(play); + + stop = memnew( Button ); + + stop->set_pos(Point2( 5, 5 )); + stop->set_size( Size2(1,1 ) ); + //stop->set_toggle_mode(true); + add_child(stop); + + load = memnew( Button ); + + load->set_pos(Point2( 35, 5 )); + load->set_size( Size2(1,1 ) ); + add_child(load); + + _delete = memnew( Button ); + + file = memnew( FileDialog ); + add_child(file); + List<String> extensions; + ResourceLoader::get_recognized_extensions_for_type("Sample",&extensions); + for(int i=0;i<extensions.size();i++) + file->add_filter("*."+extensions[i]); + file->set_mode(FileDialog::MODE_OPEN_FILES); + + _delete->set_pos(Point2( 65, 5 )); + _delete->set_size( Size2(1,1 ) ); + add_child(_delete); + + tree = memnew( Tree ); + tree->set_columns(5); + add_child(tree); + tree->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,5); + tree->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,5); + tree->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,30); + tree->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,5); + tree->set_column_titles_visible(true); + tree->set_column_title(0,"Name"); + + tree->set_column_title(1,"Preview"); + tree->set_column_title(2,"Format"); + tree->set_column_title(3,"dB"); + tree->set_column_title(4,"PScale"); + tree->set_column_min_width(1,150); + tree->set_column_min_width(2,100); + tree->set_column_min_width(3,50); + tree->set_column_min_width(4,50); + tree->set_column_expand(1,false); + tree->set_column_expand(2,false); + tree->set_column_expand(3,false); + tree->set_column_expand(4,false); + + dialog = memnew( ConfirmationDialog ); + add_child( dialog ); + + tree->connect("button_pressed",this,"_button_pressed"); + play->connect("pressed", this,"_play_pressed"); + stop->connect("pressed", this,"_stop_pressed"); + load->connect("pressed", this,"_load_pressed"); + _delete->connect("pressed", this,"_delete_pressed"); + file->connect("files_selected", this,"_file_load_request"); + //dialog->connect("confirmed", this,"_delete_confirm_pressed"); + tree->connect("item_edited", this,"_item_edited"); + + +} + + +void SampleLibraryEditorPlugin::edit(Object *p_object) { + + sample_library_editor->set_undo_redo(&get_undo_redo()); + SampleLibrary * s = p_object->cast_to<SampleLibrary>(); + if (!s) + return; + + sample_library_editor->edit(Ref<SampleLibrary>(s)); +} + +bool SampleLibraryEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("SampleLibrary"); +} + +void SampleLibraryEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + sample_library_editor->show(); +// sample_library_editor->set_process(true); + } else { + + sample_library_editor->hide(); +// sample_library_editor->set_process(false); + } + +} + +SampleLibraryEditorPlugin::SampleLibraryEditorPlugin(EditorNode *p_node) { + + editor=p_node; + sample_library_editor = memnew( SampleLibraryEditor ); + editor->get_viewport()->add_child(sample_library_editor); + sample_library_editor->set_area_as_parent_rect(); +// sample_library_editor->set_anchor( MARGIN_TOP, Control::ANCHOR_END); +// sample_library_editor->set_margin( MARGIN_TOP, 120 ); + sample_library_editor->hide(); + + + +} + + +SampleLibraryEditorPlugin::~SampleLibraryEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/sample_library_editor_plugin.h b/tools/editor/plugins/sample_library_editor_plugin.h new file mode 100644 index 000000000..a6ce764b9 --- /dev/null +++ b/tools/editor/plugins/sample_library_editor_plugin.h @@ -0,0 +1,107 @@ +/*************************************************************************/ +/* sample_library_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SAMPLE_LIBRARY_EDITOR_PLUGIN_H +#define SAMPLE_LIBRARY_EDITOR_PLUGIN_H + + + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/audio/sample_player.h" +#include "scene/resources/sample.h" +#include "scene/gui/tree.h" +#include "scene/gui/file_dialog.h" +#include "scene/gui/dialogs.h" + + +class SampleLibraryEditor : public Panel { + + OBJ_TYPE(SampleLibraryEditor, Panel ); + + + + SamplePlayer *player; + Ref<SampleLibrary> sample_library; + Button *stop; + Button *play; + Button *load; + Button *_delete; + Tree *tree; + + FileDialog *file; + + ConfirmationDialog *dialog; + + + void _play_pressed(); + void _stop_pressed(); + void _load_pressed(); + void _file_load_request(const DVector<String>& p_path); + void _delete_pressed(); + void _delete_confirm_pressed(); + void _update_library(); + void _item_edited(); + + UndoRedo *undo_redo; + + void _button_pressed(Object *p_item,int p_column, int p_id); + +protected: + void _notification(int p_what); + void _input_event(InputEvent p_event); + static void _bind_methods(); +public: + + void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; } + + void edit(Ref<SampleLibrary> p_sample); + SampleLibraryEditor(); +}; + +class SampleLibraryEditorPlugin : public EditorPlugin { + + OBJ_TYPE( SampleLibraryEditorPlugin, EditorPlugin ); + + SampleLibraryEditor *sample_library_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "SampleLibrary"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + SampleLibraryEditorPlugin(EditorNode *p_node); + ~SampleLibraryEditorPlugin(); + +}; + +#endif // SAMPLE_LIBRARY_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/sample_player_editor_plugin.cpp b/tools/editor/plugins/sample_player_editor_plugin.cpp new file mode 100644 index 000000000..fa8a285e4 --- /dev/null +++ b/tools/editor/plugins/sample_player_editor_plugin.cpp @@ -0,0 +1,192 @@ +/*************************************************************************/ +/* sample_player_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "sample_player_editor_plugin.h" +#include "scene/resources/sample_library.h" + + +void SamplePlayerEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_ENTER_SCENE) { + play->set_icon( get_icon("Play","EditorIcons") ); + stop->set_icon( get_icon("Stop","EditorIcons") ); + } + +} + +void SamplePlayerEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} + +void SamplePlayerEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_play"),&SamplePlayerEditor::_play); + ObjectTypeDB::bind_method(_MD("_stop"),&SamplePlayerEditor::_stop); + +} + + +void SamplePlayerEditor::_play() { + + if (!node) + return; + if (samples->get_item_count()<=0) + return; + + node->call("play",samples->get_item_text( samples->get_selected() )); +} + +void SamplePlayerEditor::_stop() { + + if (!node) + return; + if (samples->get_item_count()<=0) + return; + + node->call("stop_all"); + +} + + +void SamplePlayerEditor::_update_sample_library() { + + samples->clear(); + Ref<SampleLibrary> sl = node->call("get_sample_library"); + if (sl.is_null()) { + samples->add_item("<NO SAMPLE LIBRARY>"); + return; //no sample library;; + } + + List<StringName> samplenames; + sl->get_sample_list(&samplenames); + for(List<StringName>::Element *E=samplenames.front();E;E=E->next()) { + samples->add_item(E->get()); + } + +} + +void SamplePlayerEditor::edit(Node *p_sample_player) { + + node=p_sample_player; + if (node) { + _update_sample_library(); + } + +} +SamplePlayerEditor::SamplePlayerEditor() { + + + play = memnew( Button ); + + play->set_pos(Point2( 5, 5 )); + play->set_toggle_mode(true); + play->set_anchor_and_margin(MARGIN_LEFT,Control::ANCHOR_END,250); + play->set_anchor_and_margin(MARGIN_RIGHT,Control::ANCHOR_END,230); + play->set_anchor_and_margin(MARGIN_TOP,Control::ANCHOR_BEGIN,0); + play->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_BEGIN,0); + + add_child(play); + + stop = memnew( Button ); + + stop->set_pos(Point2( 35, 5 )); + stop->set_toggle_mode(true); + stop->set_anchor_and_margin(MARGIN_LEFT,Control::ANCHOR_END,220); + stop->set_anchor_and_margin(MARGIN_RIGHT,Control::ANCHOR_END,200); + stop->set_anchor_and_margin(MARGIN_TOP,Control::ANCHOR_BEGIN,0); + stop->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_BEGIN,0); + add_child(stop); + + samples = memnew( OptionButton ); + samples->set_anchor_and_margin(MARGIN_LEFT,Control::ANCHOR_END,190); + samples->set_anchor_and_margin(MARGIN_RIGHT,Control::ANCHOR_END,5); + samples->set_anchor_and_margin(MARGIN_TOP,Control::ANCHOR_BEGIN,0); + samples->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_BEGIN,0); + add_child(samples); + + play->connect("pressed", this,"_play"); + stop->connect("pressed", this,"_stop"); + +} + + +void SamplePlayerEditorPlugin::edit(Object *p_object) { + + sample_player_editor->edit(p_object->cast_to<Node>()); +} + +bool SamplePlayerEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("SamplePlayer2D") || p_object->is_type("SamplePlayer") || p_object->is_type("SpatialSamplePlayer"); +} + +void SamplePlayerEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + sample_player_editor->show(); + sample_player_editor->set_fixed_process(true); + } else { + + sample_player_editor->hide(); + sample_player_editor->set_fixed_process(false); + sample_player_editor->edit(NULL); + } + +} + +SamplePlayerEditorPlugin::SamplePlayerEditorPlugin(EditorNode *p_node) { + + editor=p_node; + sample_player_editor = memnew( SamplePlayerEditor ); + editor->get_viewport()->add_child(sample_player_editor); + + sample_player_editor->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); + sample_player_editor->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + sample_player_editor->set_margin(MARGIN_LEFT,250); + sample_player_editor->set_margin(MARGIN_RIGHT,0); + sample_player_editor->set_margin(MARGIN_TOP,0); + sample_player_editor->set_margin(MARGIN_BOTTOM,10); + + + sample_player_editor->hide(); + + + +} + + +SamplePlayerEditorPlugin::~SamplePlayerEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/sample_player_editor_plugin.h b/tools/editor/plugins/sample_player_editor_plugin.h new file mode 100644 index 000000000..4e35e4d8b --- /dev/null +++ b/tools/editor/plugins/sample_player_editor_plugin.h @@ -0,0 +1,87 @@ +/*************************************************************************/ +/* sample_player_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SAMPLE_PLAYER_EDITOR_PLUGIN_H +#define SAMPLE_PLAYER_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/3d/spatial_sample_player.h" +#include "scene/gui/option_button.h" +#include "scene/audio/sample_player.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class SamplePlayerEditor : public Control { + + OBJ_TYPE(SamplePlayerEditor, Control ); + + Panel *panel; + Button * play; + Button * stop; + OptionButton *samples; + Node *node; + + + void _update_sample_library(); + void _play(); + void _stop(); + +protected: + void _notification(int p_what); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + void edit(Node *p_sample_player); + SamplePlayerEditor(); +}; + +class SamplePlayerEditorPlugin : public EditorPlugin { + + OBJ_TYPE( SamplePlayerEditorPlugin, EditorPlugin ); + + SamplePlayerEditor *sample_player_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "SamplePlayer"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + SamplePlayerEditorPlugin(EditorNode *p_node); + ~SamplePlayerEditorPlugin(); + +}; + +#endif // SAMPLE_PLAYER_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/script_editor_plugin.cpp b/tools/editor/plugins/script_editor_plugin.cpp new file mode 100644 index 000000000..1a1791639 --- /dev/null +++ b/tools/editor/plugins/script_editor_plugin.cpp @@ -0,0 +1,1519 @@ +/*************************************************************************/ +/* script_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "script_editor_plugin.h" +#include "tools/editor/editor_settings.h" +#include "io/resource_loader.h" +#include "io/resource_saver.h" +#include "os/keyboard.h" +#include "os/os.h" +#include "tools/editor/editor_node.h" +#include "tools/editor/script_editor_debugger.h" +#include "globals.h" +#include "os/file_access.h" +#include "scene/main/viewport.h" +#include "os/keyboard.h" +/*** SCRIPT EDITOR ****/ + + + + +void ScriptEditorQuickOpen::popup(const Vector<String>& p_functions, bool p_dontclear) { + + popup_centered_ratio(0.6); + if (p_dontclear) + search_box->select_all(); + else + search_box->clear(); + search_box->grab_focus(); + functions=p_functions; + _update_search(); + + +} + + +void ScriptEditorQuickOpen::_text_changed(const String& p_newtext) { + + _update_search(); +} + +void ScriptEditorQuickOpen::_sbox_input(const InputEvent& p_ie) { + + if (p_ie.type==InputEvent::KEY && ( + p_ie.key.scancode == KEY_UP || + p_ie.key.scancode == KEY_DOWN || + p_ie.key.scancode == KEY_PAGEUP || + p_ie.key.scancode == KEY_PAGEDOWN ) ) { + + search_options->call("_input_event",p_ie); + search_box->accept_event(); + } + +} + + + +void ScriptEditorQuickOpen::_update_search() { + + + search_options->clear(); + TreeItem *root = search_options->create_item(); + + for(int i=0;i<functions.size();i++) { + + String file = functions[i]; + if ((search_box->get_text()=="" || file.findn(search_box->get_text())!=-1)) { + + TreeItem *ti = search_options->create_item(root); + ti->set_text(0,file); + if (root->get_children()==ti) + ti->select(0); + + } + } + + get_ok()->set_disabled(root->get_children()==NULL); + +} + +void ScriptEditorQuickOpen::_confirmed() { + + TreeItem *ti = search_options->get_selected(); + if (!ti) + return; + int line = ti->get_text(0).get_slice(":",1).to_int(); + + emit_signal("goto_line",line-1); + hide(); +} + +void ScriptEditorQuickOpen::_notification(int p_what) { + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + connect("confirmed",this,"_confirmed"); + } +} + + + + +void ScriptEditorQuickOpen::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_text_changed"),&ScriptEditorQuickOpen::_text_changed); + ObjectTypeDB::bind_method(_MD("_confirmed"),&ScriptEditorQuickOpen::_confirmed); + ObjectTypeDB::bind_method(_MD("_sbox_input"),&ScriptEditorQuickOpen::_sbox_input); + + ADD_SIGNAL(MethodInfo("goto_line",PropertyInfo(Variant::INT,"line"))); + +} + + +ScriptEditorQuickOpen::ScriptEditorQuickOpen() { + + + VBoxContainer *vbc = memnew( VBoxContainer ); + add_child(vbc); + set_child_rect(vbc); + search_box = memnew( LineEdit ); + vbc->add_margin_child("Search:",search_box); + search_box->connect("text_changed",this,"_text_changed"); + search_box->connect("input_event",this,"_sbox_input"); + search_options = memnew( Tree ); + vbc->add_margin_child("Matches:",search_options,true); + get_ok()->set_text("Open"); + get_ok()->set_disabled(true); + register_text_enter(search_box); + set_hide_on_ok(false); + search_options->connect("item_activated",this,"_confirmed"); + search_options->set_hide_root(true); +} + + +///////////////////////////////// + +ScriptEditor *ScriptEditor::script_editor=NULL; + +Vector<String> ScriptTextEditor::get_functions() { + + + String errortxt; + int line=-1,col; + TextEdit *te=get_text_edit(); + String text = te->get_text(); + List<String> fnc; + + if (script->get_language()->validate(text,line,col,errortxt,script->get_path(),&fnc)) { + + //if valid rewrite functions to latest + functions.clear(); + for (List<String>::Element *E=fnc.front();E;E=E->next()) { + + functions.push_back(E->get()); + } + + + } + + return functions; +} + +void ScriptTextEditor::apply_code() { + + if (script.is_null()) + return; + script->set_source_code(get_text_edit()->get_text()); +} + +Ref<Script> ScriptTextEditor::get_edited_script() const { + + return script; +} + +void ScriptTextEditor::_load_theme_settings() { + + get_text_edit()->clear_colors(); + + /* keyword color */ + + + get_text_edit()->set_custom_bg_color(EDITOR_DEF("text_editor/background_color",Color(0,0,0,0))); + get_text_edit()->add_color_override("font_color",EDITOR_DEF("text_editor/text_color",Color(0,0,0))); + get_text_edit()->add_color_override("font_selected_color",EDITOR_DEF("text_editor/text_selected_color",Color(1,1,1))); + get_text_edit()->add_color_override("selection_color",EDITOR_DEF("text_editor/selection_color",Color(0.2,0.2,1))); + + Color keyword_color= EDITOR_DEF("text_editor/keyword_color",Color(0.5,0.0,0.2)); + + get_text_edit()->set_syntax_coloring(true); + List<String> keywords; + script->get_language()->get_reserved_words(&keywords); + for(List<String>::Element *E=keywords.front();E;E=E->next()) { + + get_text_edit()->add_keyword_color(E->get(),keyword_color); + } + + //colorize core types + Color basetype_color= EDITOR_DEF("text_editor/base_type_color",Color(0.3,0.3,0.0)); + + get_text_edit()->add_keyword_color("Vector2",basetype_color); + get_text_edit()->add_keyword_color("Vector3",basetype_color); + get_text_edit()->add_keyword_color("Plane",basetype_color); + get_text_edit()->add_keyword_color("Quat",basetype_color); + get_text_edit()->add_keyword_color("AABB",basetype_color); + get_text_edit()->add_keyword_color("Matrix3",basetype_color); + get_text_edit()->add_keyword_color("Transform",basetype_color); + get_text_edit()->add_keyword_color("Color",basetype_color); + get_text_edit()->add_keyword_color("Image",basetype_color); + get_text_edit()->add_keyword_color("InputEvent",basetype_color); + + //colorize engine types + Color type_color= EDITOR_DEF("text_editor/engine_type_color",Color(0.0,0.2,0.4)); + + List<String> types; + ObjectTypeDB::get_type_list(&types); + + for(List<String>::Element *E=types.front();E;E=E->next()) { + + get_text_edit()->add_keyword_color(E->get(),type_color); + } + + //colorize comments + Color comment_color = EDITOR_DEF("text_editor/comment_color",Color::hex(0x797e7eff)); + List<String> comments; + script->get_language()->get_comment_delimiters(&comments); + + for(List<String>::Element *E=comments.front();E;E=E->next()) { + + String comment = E->get(); + String beg = comment.get_slice(" ",0); + String end = comment.get_slice_count(" ")>1?comment.get_slice(" ",1):String(); + + get_text_edit()->add_color_region(beg,end,comment_color,end==""); + } + + //colorize strings + Color string_color = EDITOR_DEF("text_editor/string_color",Color::hex(0x6b6f00ff)); + List<String> strings; + script->get_language()->get_string_delimiters(&strings); + + for (List<String>::Element *E=strings.front();E;E=E->next()) { + + String string = E->get(); + String beg = string.get_slice(" ",0); + String end = string.get_slice_count(" ")>1?string.get_slice(" ",1):String(); + get_text_edit()->add_color_region(beg,end,string_color,end==""); + } + + //colorize symbols + Color symbol_color= EDITOR_DEF("text_editor/symbol_color",Color::hex(0x005291ff)); + get_text_edit()->set_symbol_color(symbol_color); + +} + + +void ScriptTextEditor::reload_text() { + + ERR_FAIL_COND(script.is_null()) ; + + get_text_edit()->set_text(script->get_source_code()); + get_text_edit()->clear_undo_history(); + _line_col_changed(); + +} + +void ScriptTextEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_READY) { + + _update_name(); + } +} + +void ScriptTextEditor::_update_name() { + + String name; + + if (script->get_path().find("local://")==-1 && script->get_path().find("::")==-1) { + name=script->get_path().get_file(); + if (get_text_edit()->get_version()!=get_text_edit()->get_saved_version()) { + name+="(*)"; + } + } else if (script->get_name()!="") + name=script->get_name(); + else + name=script->get_type()+"("+itos(script->get_instance_ID())+")"; + + + if (name!=String(get_name())) { + + set_name(name); + + } + + if (!has_meta("_tab_icon")) { + if (get_parent_control() && get_parent_control()->has_icon(script->get_type(),"EditorIcons")) { + set_meta("_tab_icon",get_parent_control()->get_icon(script->get_type(),"EditorIcons")); + } + } + + +} + +void ScriptTextEditor::set_edited_script(const Ref<Script>& p_script) { + + ERR_FAIL_COND(!script.is_null()); + + script=p_script; + + + _load_theme_settings(); + + get_text_edit()->set_text(script->get_source_code()); + get_text_edit()->clear_undo_history(); + get_text_edit()->tag_saved_version(); + + + _update_name(); + + _line_col_changed(); +} + + +void ScriptTextEditor::_validate_script() { + + String errortxt; + int line=-1,col; + TextEdit *te=get_text_edit(); + + String text = te->get_text(); + List<String> fnc; + + if (!script->get_language()->validate(text,line,col,errortxt,script->get_path(),&fnc)) { + String error_text="error("+itos(line)+","+itos(col)+"): "+errortxt; + set_error(error_text); + } else { + set_error(""); + line=-1; + if (!script->is_tool()) { + script->set_source_code(text); + script->reload(); //will update all the variables in property editors + } + + functions.clear(); + for (List<String>::Element *E=fnc.front();E;E=E->next()) { + + functions.push_back(E->get()); + } + + } + + line--; + for(int i=0;i<te->get_line_count();i++) { + te->set_line_as_marked(i,line==i); + } + + _update_name(); +} + +void ScriptTextEditor::_code_complete_script(const String& p_code, const String& p_keyword,int p_line, List<String>* r_options) { + + Error err = script->get_language()->complete_keyword(p_code,p_line,script->get_path().get_base_dir(),p_keyword,r_options); + +} + +ScriptTextEditor::ScriptTextEditor() { + + get_text_edit()->set_draw_tabs(true); +} + +/*** SCRIPT EDITOR ******/ + + +String ScriptEditor::_get_debug_tooltip(const String&p_text,Node *_ste) { + + ScriptTextEditor *ste=_ste->cast_to<ScriptTextEditor>(); + + String val = debugger->get_var_value(p_text); + if (val!=String()) { + return p_text+": "+val; + } else { + + return String(); + } +} + +void ScriptEditor::_breaked(bool p_breaked,bool p_can_debug) { + + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_NEXT), !(p_breaked && p_can_debug)); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_STEP), !(p_breaked && p_can_debug) ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_BREAK), p_breaked ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_CONTINUE), !p_breaked ); + +} + +void ScriptEditor::_show_debugger(bool p_show) { + + debug_menu->get_popup()->set_item_checked( debug_menu->get_popup()->get_item_index(DEBUG_SHOW), p_show); + +} + +void ScriptEditor::_goto_script_line2(int p_line) { + + int selected = tab_container->get_current_tab(); + if (selected<0 || selected>=tab_container->get_child_count()) + return; + + ScriptTextEditor *current = tab_container->get_child(selected)->cast_to<ScriptTextEditor>(); + if (!current) + return; + + current->get_text_edit()->cursor_set_line(p_line); + +} + +void ScriptEditor::_goto_script_line(REF p_script,int p_line) { + + + editor->push_item(p_script.ptr()); + _goto_script_line2(p_line); + +} + +void ScriptEditor::_close_current_tab() { + + int selected = tab_container->get_current_tab(); + if (selected<0 || selected>=tab_container->get_child_count()) + return; + + ScriptTextEditor *current = tab_container->get_child(selected)->cast_to<ScriptTextEditor>(); + if (!current) + return; + + apply_scripts(); + + int idx = tab_container->get_current_tab(); + memdelete(current); + if (idx>=tab_container->get_child_count()) + idx=tab_container->get_child_count()-1; + if (idx>=0) + tab_container->set_current_tab(idx); + + _update_window_menu(); + _save_files_state(); + +} + + +void ScriptEditor::_resave_scripts(const String& p_str) { + + apply_scripts(); + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + + Ref<Script> script = ste->get_edited_script(); + + if (script->get_path()=="" || script->get_path().find("local://")!=-1 || script->get_path().find("::")!=-1) + continue; //internal script, who cares + + + editor->save_resource(script); + ste->get_text_edit()->tag_saved_version(); + } + + disk_changed->hide(); + +} + +void ScriptEditor::_reload_scripts(){ + + + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) { + + continue; + } + + + Ref<Script> script = ste->get_edited_script(); + + if (script->get_path()=="" || script->get_path().find("local://")!=-1 || script->get_path().find("::")!=-1) { + + continue; //internal script, who cares + } + + + Ref<Script> rel_script = ResourceLoader::load(script->get_path(),script->get_type(),true); + ERR_CONTINUE(!rel_script.is_valid()); + script->set_source_code( rel_script->get_source_code() ); + script->set_last_modified_time( rel_script->get_last_modified_time() ); + script->reload(); + ste->reload_text(); + + + } + + disk_changed->hide(); + +} + + + +void ScriptEditor::_res_saved_callback(const Ref<Resource>& p_res) { + + + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) { + + continue; + } + + + Ref<Script> script = ste->get_edited_script(); + + if (script->get_path()=="" || script->get_path().find("local://")!=-1 || script->get_path().find("::")!=-1) { + continue; //internal script, who cares + } + + if (script==p_res) { + + ste->get_text_edit()->tag_saved_version(); + } + + ste->_update_name(); + + } + +} + +bool ScriptEditor::_test_script_times_on_disk() { + + + disk_changed_list->clear(); + TreeItem *r = disk_changed_list->create_item(); + disk_changed_list->set_hide_root(true); + + bool all_ok=true; + + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + + Ref<Script> script = ste->get_edited_script(); + + if (script->get_path()=="" || script->get_path().find("local://")!=-1 || script->get_path().find("::")!=-1) + continue; //internal script, who cares + + + uint64_t last_date = script->get_last_modified_time(); + uint64_t date = FileAccess::get_modified_time(script->get_path()); + + //printf("last date: %lli vs date: %lli\n",last_date,date); + if (last_date!=date) { + + TreeItem *ti = disk_changed_list->create_item(r); + ti->set_text(0,script->get_path().get_file()); + all_ok=false; + //r->set_metadata(0,); + } + } + + + + if (!all_ok) + disk_changed->call_deferred("popup_centered_ratio",0.5); + + return all_ok; +} + +void ScriptEditor::_menu_option(int p_option) { + + + if (p_option==FILE_OPEN) { + + editor->open_resource("Script"); + return; + } + int selected = tab_container->get_current_tab(); + if (selected<0 || selected>=tab_container->get_child_count()) + return; + + ScriptTextEditor *current = tab_container->get_child(selected)->cast_to<ScriptTextEditor>(); + if (!current) + return; + + switch(p_option) { + case FILE_SAVE: { + + if (!_test_script_times_on_disk()) + return; + editor->save_resource( current->get_edited_script() ); + + } break; + case FILE_SAVE_AS: { + + editor->save_resource_as( current->get_edited_script() ); + + } break; + case FILE_SAVE_ALL: { + + if (!_test_script_times_on_disk()) + return; + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + + Ref<Script> script = ste->get_edited_script(); + + if (script->get_path()=="" || script->get_path().find("local://")!=-1 || script->get_path().find("::")!=-1) + continue; //internal script, who cares + + + editor->save_resource( script ); + } + + + } break; + case EDIT_UNDO: { + + + current->get_text_edit()->undo(); + } break; + case EDIT_REDO: { + current->get_text_edit()->redo(); + + } break; + case EDIT_CUT: { + + current->get_text_edit()->cut(); + } break; + case EDIT_COPY: { + current->get_text_edit()->copy(); + + } break; + case EDIT_PASTE: { + current->get_text_edit()->paste(); + + } break; + case EDIT_SELECT_ALL: { + + current->get_text_edit()->select_all(); + + } break; + case EDIT_COMPLETE: { + + current->get_text_edit()->query_code_comple(); + + } break; + case SEARCH_FIND: { + + find_replace_dialog->set_text_edit(current->get_text_edit()); + find_replace_dialog->popup_search(); + } break; + case SEARCH_FIND_NEXT: { + + find_replace_dialog->set_text_edit(current->get_text_edit()); + find_replace_dialog->search_next(); + } break; + case SEARCH_REPLACE: { + + find_replace_dialog->set_text_edit(current->get_text_edit()); + find_replace_dialog->popup_replace(); + } break; + case SEARCH_LOCATE_FUNCTION: { + + if (!current) + return; + quick_open->popup(current->get_functions()); + } break; + case SEARCH_GOTO_LINE: { + + goto_line_dialog->popup_find_line(current->get_text_edit()); + } break; + case DEBUG_TOGGLE_BREAKPOINT: { + int line=current->get_text_edit()->cursor_get_line(); + bool dobreak = !current->get_text_edit()->is_line_set_as_breakpoint(line); + current->get_text_edit()->set_line_as_breakpoint(line,dobreak); + } break; + case DEBUG_NEXT: { + + if (debugger) + debugger->debug_next(); + } break; + case DEBUG_STEP: { + + if (debugger) + debugger->debug_step(); + + } break; + case DEBUG_BREAK: { + + if (debugger) + debugger->debug_break(); + + } break; + case DEBUG_CONTINUE: { + + if (debugger) + debugger->debug_continue(); + + } break; + case DEBUG_SHOW: { + if (debugger) { + bool visible = debug_menu->get_popup()->is_item_checked( debug_menu->get_popup()->get_item_index(DEBUG_SHOW) ); + debug_menu->get_popup()->set_item_checked( debug_menu->get_popup()->get_item_index(DEBUG_SHOW), !visible); + if (visible) + debugger->hide(); + else + debugger->show(); + } + } break; + case WINDOW_CLOSE: { + + erase_tab_confirm->set_text("Close Tab?:\n\""+current->get_name()+"\""); + erase_tab_confirm->popup_centered(Point2(250,80)); + } break; + case WINDOW_MOVE_LEFT: { + + if (tab_container->get_current_tab()>0) { + tab_container->call_deferred("set_current_tab",tab_container->get_current_tab()-1); + tab_container->move_child(current,tab_container->get_current_tab()-1); + _update_window_menu(); + } + } break; + case WINDOW_MOVE_RIGHT: { + + if (tab_container->get_current_tab()<tab_container->get_child_count()-1) { + tab_container->call_deferred("set_current_tab",tab_container->get_current_tab()+1); + tab_container->move_child(current,tab_container->get_current_tab()+1); + _update_window_menu(); + } + + + } break; + default: { + + if (p_option>=WINDOW_SELECT_BASE) { + + tab_container->set_current_tab(p_option-WINDOW_SELECT_BASE); + } + } + } + +} + +void ScriptEditor::_tab_changed(int p_which) { + + ensure_select_current(); +} + +void ScriptEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + editor->connect("play_pressed",this,"_editor_play"); + editor->connect("pause_pressed",this,"_editor_pause"); + editor->connect("stop_pressed",this,"_editor_stop"); + editor->connect("script_add_function_request",this,"_add_callback"); + editor->connect("resource_saved",this,"_res_saved_callback"); + + + } + + if (p_what==NOTIFICATION_READY) { + _update_window_menu(); + } + + if (p_what==NOTIFICATION_EXIT_SCENE) { + + editor->disconnect("play_pressed",this,"_editor_play"); + editor->disconnect("pause_pressed",this,"_editor_pause"); + editor->disconnect("stop_pressed",this,"_editor_stop"); + + } + + if (p_what==MainLoop::NOTIFICATION_WM_FOCUS_IN) { + + _test_script_times_on_disk(); + } + + if (p_what==NOTIFICATION_PROCESS) { + + } + +} + + +static const Node * _find_node_with_script(const Node* p_node, const RefPtr & p_script) { + + if (p_node->get_script()==p_script) + return p_node; + + for(int i=0;i<p_node->get_child_count();i++) { + + const Node *result = _find_node_with_script(p_node->get_child(i),p_script); + if (result) + return result; + } + + return NULL; +} + +Dictionary ScriptEditor::get_state() const { + + apply_scripts(); + + Dictionary state; + + Array paths; + int open=-1; + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + + Ref<Script> script = ste->get_edited_script(); + if (script->get_path()!="" && script->get_path().find("local://")==-1 && script->get_path().find("::")==-1) { + + paths.push_back(script->get_path()); + } else { + + + const Node *owner = _find_node_with_script(get_scene()->get_root(),script.get_ref_ptr()); + if (owner) + paths.push_back(owner->get_path()); + + } + + if (i==tab_container->get_current_tab()) + open=i; + } + + if (paths.size()) + state["sources"]=paths; + if (open!=-1) + state["current"]=open; + + + return state; +} +void ScriptEditor::set_state(const Dictionary& p_state) { + + + print_line("attempt set state: "+String(Variant(p_state))); + + if (!p_state.has("sources")) + return; //bleh + + Array sources = p_state["sources"]; + for(int i=0;i<sources.size();i++) { + + Variant source=sources[i]; + + Ref<Script> script; + + if (source.get_type()==Variant::NODE_PATH) { + + + Node *owner=get_scene()->get_root()->get_node(source); + if (!owner) + continue; + + script = owner->get_script(); + } else if (source.get_type()==Variant::STRING) { + + + script = ResourceLoader::load(source,"Script"); + } + + + if (script.is_null()) //ah well.. + continue; + + editor->call("_resource_selected",script); + } + + if (p_state.has("current")) { + tab_container->set_current_tab(p_state["current"]); + } + +} +void ScriptEditor::clear() { + + List<ScriptTextEditor*> stes; + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + stes.push_back(ste); + + } + + while(stes.size()) { + + memdelete(stes.front()->get()); + stes.pop_front(); + } + + int idx = tab_container->get_current_tab(); + if (idx>=tab_container->get_child_count()) + idx=tab_container->get_child_count()-1; + if (idx>=0) + tab_container->set_current_tab(idx); + + _update_window_menu(); + + +} + +void ScriptEditor::_save_files_state() { + + return; //no thank you + + String rpath="_open_scripts_"+Globals::get_singleton()->get_resource_path(); + rpath=rpath.replace("\\","_-_"); + rpath=rpath.replace("/","_-_"); + rpath=rpath.replace(":","_"); + + Vector<String> scripts; + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + + Ref<Script> script = ste->get_edited_script(); + if (script->get_path()!="" && script->get_path().find("local://")==-1 && script->get_path().find("::")==-1) { + + + scripts.push_back(script->get_path()); + } + } + + + EditorSettings::get_singleton()->set(rpath,scripts); + EditorSettings::get_singleton()->save(); + +} + +void ScriptEditor::_load_files_state() { + return; + + String rpath="_open_scripts_"+Globals::get_singleton()->get_resource_path(); + rpath=rpath.replace("\\","_-_"); + rpath=rpath.replace("/","_-_"); + rpath=rpath.replace(":","_"); + + if (EditorSettings::get_singleton()->has(rpath)) { + + Vector<String> open_files=EditorSettings::get_singleton()->get("rpath"); + for(int i=0;i<open_files.size();i++) { + Ref<Script> scr = ResourceLoader::load(open_files[i]); + if (!scr.is_valid()) + continue; + + editor->edit_resource(scr); + } + } + +} + +void ScriptEditor::get_breakpoints(List<String> *p_breakpoints) { + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + List<int> bpoints; + ste->get_text_edit()->get_breakpoints(&bpoints); + + Ref<Script> script = ste->get_edited_script(); + String base = script->get_path(); + ERR_CONTINUE( base.begins_with("local://") || base=="" ); + + for(List<int>::Element *E=bpoints.front();E;E=E->next()) { + + p_breakpoints->push_back(base+":"+itos(E->get()+1)); + } + } + +} + + + +void ScriptEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_tab_changed",&ScriptEditor::_tab_changed); + ObjectTypeDB::bind_method("_menu_option",&ScriptEditor::_menu_option); + ObjectTypeDB::bind_method("_close_current_tab",&ScriptEditor::_close_current_tab); + ObjectTypeDB::bind_method("_editor_play",&ScriptEditor::_editor_play); + ObjectTypeDB::bind_method("_editor_pause",&ScriptEditor::_editor_pause); + ObjectTypeDB::bind_method("_editor_stop",&ScriptEditor::_editor_stop); + ObjectTypeDB::bind_method("_add_callback",&ScriptEditor::_add_callback); + ObjectTypeDB::bind_method("_reload_scripts",&ScriptEditor::_reload_scripts); + ObjectTypeDB::bind_method("_resave_scripts",&ScriptEditor::_resave_scripts); + ObjectTypeDB::bind_method("_res_saved_callback",&ScriptEditor::_res_saved_callback); + ObjectTypeDB::bind_method("_goto_script_line",&ScriptEditor::_goto_script_line); + ObjectTypeDB::bind_method("_goto_script_line2",&ScriptEditor::_goto_script_line2); + ObjectTypeDB::bind_method("_breaked",&ScriptEditor::_breaked); + ObjectTypeDB::bind_method("_show_debugger",&ScriptEditor::_show_debugger); + ObjectTypeDB::bind_method("_get_debug_tooltip",&ScriptEditor::_get_debug_tooltip); + + + + +} + + +void ScriptEditor::ensure_focus_current() { + + int cidx = tab_container->get_current_tab(); + if (cidx<0 || cidx>=tab_container->get_tab_count()); + Control *c = tab_container->get_child(cidx)->cast_to<Control>(); + if (!c) + return; + ScriptTextEditor *ste = c->cast_to<ScriptTextEditor>(); + if (!ste) + return; + ste->get_text_edit()->grab_focus(); +} + +void ScriptEditor::ensure_select_current() { + + + if (tab_container->get_child_count() && tab_container->get_current_tab()>=0) { + + ScriptTextEditor *ste = tab_container->get_child(tab_container->get_current_tab())->cast_to<ScriptTextEditor>(); + if (!ste) + return; + Ref<Script> script = ste->get_edited_script(); + editor->call("_resource_selected",script); + } +} + +void ScriptEditor::edit(const Ref<Script>& p_script) { + + if (p_script.is_null()) + return; + + // see if already has it + + if (p_script->get_path().is_resource_file() && bool(EditorSettings::get_singleton()->get("external_editor/use_external_editor"))) { + + String path = EditorSettings::get_singleton()->get("external_editor/exec_path"); + String flags = EditorSettings::get_singleton()->get("external_editor/exec_flags"); + List<String> args; + flags=flags.strip_edges(); + if (flags!=String()) { + Vector<String> flagss = flags.split(" ",false); + for(int i=0;i<flagss.size();i++) + args.push_back(flagss[i]); + } + + args.push_back(Globals::get_singleton()->globalize_path(p_script->get_path())); + Error err = OS::get_singleton()->execute(path,args,false); + if (err==OK) + return; + WARN_PRINT("Couldn't open external text editor, using internal"); + } + + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + if (ste->get_edited_script()==p_script) { + + if (tab_container->get_current_tab()!=i) + tab_container->set_current_tab(i); + ste->get_text_edit()->grab_focus(); + return; + } + } + + // doesn't have it, make a new one + + ScriptTextEditor *ste = memnew( ScriptTextEditor ); + ste->set_edited_script(p_script); + ste->get_text_edit()->set_tooltip_request_func(this,"_get_debug_tooltip",ste); + tab_container->add_child(ste); + tab_container->set_current_tab(tab_container->get_tab_count()-1); + + _update_window_menu(); + _save_files_state(); + +} + +void ScriptEditor::save_external_data() { + + apply_scripts(); + + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + + Ref<Script> script = ste->get_edited_script(); + if (script->get_path()!="" && script->get_path().find("local://")==-1 &&script->get_path().find("::")==-1) { + //external script, save it + editor->save_resource(script); + //ResourceSaver::save(script->get_path(),script); + } + } + +} + +void ScriptEditor::apply_scripts() const { + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + ste->apply_code(); + } + +} + +void ScriptEditor::_editor_play() { + + debugger->start(); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_NEXT), true ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_STEP), true ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_BREAK), false ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_CONTINUE), true ); + + //debugger_gui->start_listening(Globals::get_singleton()->get("debug/debug_port")); +} + +void ScriptEditor::_editor_pause() { + + +} +void ScriptEditor::_editor_stop() { + + debugger->stop(); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_NEXT), true ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_STEP), true ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_BREAK), true ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_CONTINUE), true ); +} + +void ScriptEditor::_update_window_menu() { + + int idx=0; + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + idx++; + } + + if (idx==0) { + window_menu->set_disabled(true); + edit_menu->set_disabled(true); + search_menu->set_disabled(true); + return; + } else { + + window_menu->set_disabled(false); + edit_menu->set_disabled(false); + search_menu->set_disabled(false); + } + + window_menu->get_popup()->clear(); + window_menu->get_popup()->add_item("Close",WINDOW_CLOSE,KEY_MASK_CMD|KEY_W); + window_menu->get_popup()->add_separator(); + window_menu->get_popup()->add_item("Move Left",WINDOW_MOVE_LEFT,KEY_MASK_CMD|KEY_LEFT); + window_menu->get_popup()->add_item("Move Right",WINDOW_MOVE_RIGHT,KEY_MASK_CMD|KEY_RIGHT); + window_menu->get_popup()->add_separator(); + + idx=0; + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + String n = ste->get_name(); + uint32_t accel=0; + if (idx<9) { + accel=KEY_MASK_ALT|(KEY_1+idx); + } + window_menu->get_popup()->add_item(n,WINDOW_SELECT_BASE+idx,accel); + idx++; + } +} + +void ScriptEditor::_add_callback(Object *p_obj, const String& p_function, const StringArray& p_args) { + + print_line("add callback! hohoho"); + ERR_FAIL_COND(!p_obj); + Ref<Script> script = p_obj->get_script(); + ERR_FAIL_COND( !script.is_valid() ); + + editor->push_item(script.ptr()); + + for(int i=0;i<tab_container->get_child_count();i++) { + + ScriptTextEditor *ste = tab_container->get_child(i)->cast_to<ScriptTextEditor>(); + if (!ste) + continue; + if (ste->get_edited_script()!=script) + continue; + + String code = ste->get_text_edit()->get_text(); + int pos = script->get_language()->find_function(code,p_function); + if (pos==-1) { + //does not exist + + pos=ste->get_text_edit()->get_line_count()+2; + String func = script->get_language()->make_function("",p_function,p_args); + //code=code+func; + ste->get_text_edit()->cursor_set_line(pos+1); + ste->get_text_edit()->cursor_set_column(1000000); //none shall be that big + ste->get_text_edit()->insert_text_at_cursor("\n\n"+func); + } + + tab_container->set_current_tab(i); + ste->get_text_edit()->cursor_set_line(pos); + ste->get_text_edit()->cursor_set_column(1); + + break; + + } + +} + +ScriptEditor::ScriptEditor(EditorNode *p_editor) { + + editor=p_editor; + + menu_hb = memnew( HBoxContainer ); + add_child(menu_hb); + + v_split = memnew( VSplitContainer ); + add_child(v_split); + v_split->set_v_size_flags(SIZE_EXPAND_FILL); + + tab_container = memnew( TabContainer ); + v_split->add_child(tab_container); + tab_container->set_v_size_flags(SIZE_EXPAND_FILL); + + file_menu = memnew( MenuButton ); + menu_hb->add_child(file_menu); + file_menu->set_text("File"); + file_menu->get_popup()->add_item("Open",FILE_OPEN); + file_menu->get_popup()->add_item("Save",FILE_SAVE,KEY_MASK_ALT|KEY_S); + file_menu->get_popup()->add_item("Save As..",FILE_SAVE_AS); + file_menu->get_popup()->add_item("Save All",FILE_SAVE_ALL,KEY_MASK_CMD|KEY_MASK_SHIFT|KEY_S); + file_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + edit_menu = memnew( MenuButton ); + menu_hb->add_child(edit_menu); + edit_menu->set_text("Edit"); + edit_menu->get_popup()->add_item("Undo"); + edit_menu->get_popup()->add_item("Redo"); + edit_menu->get_popup()->add_separator(); + edit_menu->get_popup()->add_item("Cut",EDIT_CUT,KEY_MASK_CMD|KEY_X); + edit_menu->get_popup()->add_item("Copy",EDIT_COPY,KEY_MASK_CMD|KEY_C); + edit_menu->get_popup()->add_item("Paste",EDIT_PASTE,KEY_MASK_CMD|KEY_V); + edit_menu->get_popup()->add_separator(); + edit_menu->get_popup()->add_item("Select All",EDIT_SELECT_ALL,KEY_MASK_CMD|KEY_A); + edit_menu->get_popup()->add_separator(); + edit_menu->get_popup()->add_item("Complete Symbol",EDIT_COMPLETE,KEY_MASK_CMD|KEY_SPACE); + edit_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + + search_menu = memnew( MenuButton ); + menu_hb->add_child(search_menu); + search_menu->set_text("Search"); + search_menu->get_popup()->add_item("Find..",SEARCH_FIND,KEY_MASK_CMD|KEY_F); + search_menu->get_popup()->add_item("Find Next",SEARCH_FIND_NEXT,KEY_MASK_CMD|KEY_G); + search_menu->get_popup()->add_item("Replace..",SEARCH_REPLACE,KEY_MASK_CMD|KEY_R); + search_menu->get_popup()->add_separator(); + search_menu->get_popup()->add_item("Goto Function..",SEARCH_LOCATE_FUNCTION,KEY_MASK_SHIFT|KEY_MASK_CMD|KEY_F); + search_menu->get_popup()->add_item("Goto Line..",SEARCH_GOTO_LINE,KEY_MASK_CMD|KEY_L); + search_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + debug_menu = memnew( MenuButton ); + menu_hb->add_child(debug_menu); + debug_menu->set_text("Debug"); + debug_menu->get_popup()->add_item("Toggle Breakpoint",DEBUG_TOGGLE_BREAKPOINT,KEY_F9); + debug_menu->get_popup()->add_separator(); + debug_menu->get_popup()->add_item("Step Over",DEBUG_NEXT,KEY_F10); + debug_menu->get_popup()->add_item("Step Into",DEBUG_STEP,KEY_F11); + debug_menu->get_popup()->add_separator(); + debug_menu->get_popup()->add_item("Break",DEBUG_BREAK); + debug_menu->get_popup()->add_item("Continue",DEBUG_CONTINUE); + debug_menu->get_popup()->add_separator(); + debug_menu->get_popup()->add_check_item("Show Debugger",DEBUG_SHOW); + debug_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_NEXT), true); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_STEP), true ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_BREAK), true ); + debug_menu->get_popup()->set_item_disabled( debug_menu->get_popup()->get_item_index(DEBUG_CONTINUE), true ); + + + window_menu = memnew( MenuButton ); + menu_hb->add_child(window_menu); + window_menu->set_text("Window"); + window_menu->get_popup()->add_item("Close",WINDOW_CLOSE,KEY_MASK_CMD|KEY_W); + window_menu->get_popup()->add_separator(); + window_menu->get_popup()->add_item("Move Left",WINDOW_MOVE_LEFT,KEY_MASK_CMD|KEY_LEFT); + window_menu->get_popup()->add_item("Move Right",WINDOW_MOVE_RIGHT,KEY_MASK_CMD|KEY_RIGHT); + window_menu->get_popup()->add_separator(); + window_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + tab_container->connect("tab_changed", this,"_tab_changed"); + + find_replace_dialog = memnew(FindReplaceDialog); + add_child(find_replace_dialog); + + erase_tab_confirm = memnew( ConfirmationDialog ); + add_child(erase_tab_confirm); + erase_tab_confirm->connect("confirmed", this,"_close_current_tab"); + + + goto_line_dialog = memnew(GotoLineDialog); + add_child(goto_line_dialog); + + debugger = memnew( ScriptEditorDebugger(editor) ); + debugger->connect("goto_script_line",this,"_goto_script_line"); + debugger->connect("show_debugger",this,"_show_debugger"); + + disk_changed = memnew( ConfirmationDialog ); + { + VBoxContainer *vbc = memnew( VBoxContainer ); + disk_changed->add_child(vbc); + disk_changed->set_child_rect(vbc); + + Label *dl = memnew( Label ); + dl->set_text("The following files are newer on disk.\nWhat action should be taken?:"); + vbc->add_child(dl); + + disk_changed_list = memnew( Tree ); + vbc->add_child(disk_changed_list); + disk_changed_list->set_v_size_flags(SIZE_EXPAND_FILL); + + disk_changed->connect("confirmed",this,"_reload_scripts"); + disk_changed->get_ok()->set_text("Reload"); + + disk_changed->add_button("Resave",!OS::get_singleton()->get_swap_ok_cancel(),"resave"); + disk_changed->connect("custom_action",this,"_resave_scripts"); + + + } + + add_child(disk_changed); + + script_editor=this; + + quick_open = memnew( ScriptEditorQuickOpen ); + add_child(quick_open); + + quick_open->connect("goto_line",this,"_goto_script_line2"); + + v_split->add_child(debugger); + debugger->connect("breaked",this,"_breaked"); +// debugger_gui->hide(); +} + + +void ScriptEditorPlugin::edit(Object *p_object) { + + if (!p_object->cast_to<Script>()) + return; + + script_editor->edit(p_object->cast_to<Script>()); + +} + +bool ScriptEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Script"); +} + +void ScriptEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + script_editor->show(); + script_editor->set_process(true); + script_editor->ensure_select_current(); + } else { + + script_editor->hide(); + script_editor->set_process(false); + } + +} + +void ScriptEditorPlugin::selected_notify() { + + script_editor->ensure_select_current(); +} + +Dictionary ScriptEditorPlugin::get_state() const { + + return script_editor->get_state(); +} + +void ScriptEditorPlugin::set_state(const Dictionary& p_state) { + + script_editor->set_state(p_state); +} +void ScriptEditorPlugin::clear() { + + script_editor->clear(); +} + +void ScriptEditorPlugin::save_external_data() { + + script_editor->save_external_data(); +} + +void ScriptEditorPlugin::apply_changes() { + + script_editor->apply_scripts(); +} + +void ScriptEditorPlugin::restore_global_state() { + + if (bool(EDITOR_DEF("text_editor/restore_scripts_on_load",true))) { + script_editor->_load_files_state(); + } + +} + +void ScriptEditorPlugin::save_global_state() { + + if (bool(EDITOR_DEF("text_editor/restore_scripts_on_load",true))) { + script_editor->_save_files_state(); + } + +} + +void ScriptEditorPlugin::get_breakpoints(List<String> *p_breakpoints) { + + + return script_editor->get_breakpoints(p_breakpoints); +} + +ScriptEditorPlugin::ScriptEditorPlugin(EditorNode *p_node) { + + editor=p_node; + script_editor = memnew( ScriptEditor(p_node) ); + editor->get_viewport()->add_child(script_editor); + script_editor->set_area_as_parent_rect(); + + script_editor->hide(); + + EDITOR_DEF("external_editor/use_external_editor",false); + EDITOR_DEF("external_editor/exec_path",""); + EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING,"external_editor/exec_path",PROPERTY_HINT_FILE)); + EDITOR_DEF("external_editor/exec_flags",""); + +} + + +ScriptEditorPlugin::~ScriptEditorPlugin() +{ +} + diff --git a/tools/editor/plugins/script_editor_plugin.h b/tools/editor/plugins/script_editor_plugin.h new file mode 100644 index 000000000..898ad1daf --- /dev/null +++ b/tools/editor/plugins/script_editor_plugin.h @@ -0,0 +1,250 @@ +/*************************************************************************/ +/* script_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SCRIPT_EDITOR_PLUGIN_H +#define SCRIPT_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "scene/gui/tab_container.h" +#include "scene/gui/text_edit.h" +#include "scene/gui/menu_button.h" +#include "scene/gui/tree.h" +#include "scene/main/timer.h" +#include "script_language.h" +#include "tools/editor/code_editor.h" +#include "scene/gui/split_container.h" + + +class ScriptEditorQuickOpen : public ConfirmationDialog { + + OBJ_TYPE(ScriptEditorQuickOpen,ConfirmationDialog ) + + LineEdit *search_box; + Tree *search_options; + String function; + + void _update_search(); + + void _sbox_input(const InputEvent& p_ie); + Vector<String> functions; + + + void _confirmed(); + void _text_changed(const String& p_newtext); + +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + void popup(const Vector<String>& p_base,bool p_dontclear=false); + ScriptEditorQuickOpen(); +}; + + +class ScriptEditorDebugger; + +class ScriptTextEditor : public CodeTextEditor { + + OBJ_TYPE( ScriptTextEditor, CodeTextEditor ); + + Ref<Script> script; + + + Vector<String> functions; + +protected: + + + + virtual void _validate_script(); + virtual void _code_complete_script(const String& p_code,const String& p_keyword, int p_line, List<String>* r_options); + virtual void _load_theme_settings(); + void _notification(int p_what); + + +public: + + virtual void apply_code(); + Ref<Script> get_edited_script() const; + Vector<String> get_functions() ; + void set_edited_script(const Ref<Script>& p_script); + void reload_text(); + void _update_name(); + + ScriptTextEditor(); + +}; + +class ScriptEditor : public VBoxContainer { + + OBJ_TYPE(ScriptEditor, VBoxContainer ); + + + EditorNode *editor; + enum { + + FILE_OPEN, + FILE_SAVE, + FILE_SAVE_AS, + FILE_SAVE_ALL, + EDIT_UNDO, + EDIT_REDO, + EDIT_CUT, + EDIT_COPY, + EDIT_PASTE, + EDIT_SELECT_ALL, + EDIT_COMPLETE, + SEARCH_FIND, + SEARCH_FIND_NEXT, + SEARCH_REPLACE, + SEARCH_LOCATE_FUNCTION, + SEARCH_GOTO_LINE, + DEBUG_TOGGLE_BREAKPOINT, + DEBUG_NEXT, + DEBUG_STEP, + DEBUG_BREAK, + DEBUG_CONTINUE, + DEBUG_SHOW, + WINDOW_CLOSE, + WINDOW_MOVE_LEFT, + WINDOW_MOVE_RIGHT, + WINDOW_SELECT_BASE=100 + }; + + HBoxContainer *menu_hb; + MenuButton *file_menu; + MenuButton *edit_menu; + MenuButton *search_menu; + MenuButton *window_menu; + MenuButton *debug_menu; + uint64_t idle; + + TabContainer *tab_container; + FindReplaceDialog *find_replace_dialog; + GotoLineDialog *goto_line_dialog; + ConfirmationDialog *erase_tab_confirm; + ScriptEditorDebugger* debugger; + + void _tab_changed(int p_which); + void _menu_option(int p_optin); + + Tree *disk_changed_list; + ConfirmationDialog *disk_changed; + + VSplitContainer *v_split; + + String _get_debug_tooltip(const String&p_text,Node *_ste); + + void _resave_scripts(const String& p_str); + void _reload_scripts(); + + bool _test_script_times_on_disk(); + + void _close_current_tab(); + + ScriptEditorQuickOpen *quick_open; + + + void _editor_play(); + void _editor_pause(); + void _editor_stop(); + + void _add_callback(Object *p_obj, const String& p_function, const StringArray& p_args); + void _res_saved_callback(const Ref<Resource>& p_res); + + void _goto_script_line2(int p_line); + void _goto_script_line(REF p_script,int p_line); + void _breaked(bool p_breaked,bool p_can_debug); + void _show_debugger(bool p_show); + void _update_window_menu(); + static ScriptEditor *script_editor; +protected: + void _notification(int p_what); + static void _bind_methods(); +public: + + static ScriptEditor *get_singleton() { return script_editor; } + void _save_files_state(); + void _load_files_state(); + + + void ensure_focus_current(); + void apply_scripts() const; + + void ensure_select_current(); + void edit(const Ref<Script>& p_script); + + Dictionary get_state() const; + void set_state(const Dictionary& p_state); + void clear(); + + void get_breakpoints(List<String> *p_breakpoints); + + + + void save_external_data(); + + ScriptEditor(EditorNode *p_editor); +}; + +class ScriptEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ScriptEditorPlugin, EditorPlugin ); + + ScriptEditor *script_editor; + EditorNode *editor; +public: + + virtual String get_name() const { return "Script"; } + bool has_main_screen() const { return true; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + virtual void selected_notify(); + + Dictionary get_state() const; + virtual void set_state(const Dictionary& p_state); + virtual void clear(); + + virtual void save_external_data(); + virtual void apply_changes(); + + virtual void restore_global_state(); + virtual void save_global_state(); + + virtual void get_breakpoints(List<String> *p_breakpoints); + + + ScriptEditorPlugin(EditorNode *p_node); + ~ScriptEditorPlugin(); + +}; + +#endif // SCRIPT_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/shader_editor_plugin.cpp b/tools/editor/plugins/shader_editor_plugin.cpp new file mode 100644 index 000000000..4670005cf --- /dev/null +++ b/tools/editor/plugins/shader_editor_plugin.cpp @@ -0,0 +1,598 @@ +/*************************************************************************/ +/* shader_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "shader_editor_plugin.h" +#include "tools/editor/editor_settings.h" + +#include "spatial_editor_plugin.h" +#include "io/resource_loader.h" +#include "io/resource_saver.h" +#include "os/keyboard.h" +#include "tools/editor/editor_node.h" +#include "tools/editor/property_editor.h" +#include "os/os.h" + + +/*** SETTINGS EDITOR ****/ + + + + +/*** SCRIPT EDITOR ****/ + + +Ref<Shader> ShaderTextEditor::get_edited_shader() const { + + return shader; +} +void ShaderTextEditor::set_edited_shader(const Ref<Shader>& p_shader,ShaderLanguage::ShaderType p_type) { + + shader=p_shader; + type=p_type; + + _load_theme_settings(); + + if (p_type==ShaderLanguage::SHADER_MATERIAL_VERTEX) + get_text_edit()->set_text(shader->get_vertex_code()); + else + get_text_edit()->set_text(shader->get_fragment_code()); + + _line_col_changed(); + + +} + + +void ShaderTextEditor::_load_theme_settings() { + + get_text_edit()->clear_colors(); + + /* keyword color */ + + get_text_edit()->set_custom_bg_color(EDITOR_DEF("text_editor/background_color",Color(0,0,0,0))); + get_text_edit()->add_color_override("font_color",EDITOR_DEF("text_editor/text_color",Color(0,0,0))); + get_text_edit()->add_color_override("font_selected_color",EDITOR_DEF("text_editor/text_selected_color",Color(1,1,1))); + get_text_edit()->add_color_override("selection_color",EDITOR_DEF("text_editor/selection_color",Color(0.2,0.2,1))); + + Color keyword_color= EDITOR_DEF("text_editor/keyword_color",Color(0.5,0.0,0.2)); + + get_text_edit()->set_syntax_coloring(true); + + + List<String> keywords; + ShaderLanguage::get_keyword_list(type,&keywords); + + + for(List<String>::Element *E=keywords.front();E;E=E->next()) { + + get_text_edit()->add_keyword_color(E->get(),keyword_color); + } + + //colorize core types +// Color basetype_color= EDITOR_DEF("text_editor/base_type_color",Color(0.3,0.3,0.0)); + + + //colorize comments + Color comment_color = EDITOR_DEF("text_editor/comment_color",Color::hex(0x797e7eff)); + + get_text_edit()->add_color_region("/*","*/",comment_color,false); + get_text_edit()->add_color_region("//","",comment_color,false); + //colorize strings + Color string_color = EDITOR_DEF("text_editor/string_color",Color::hex(0x6b6f00ff)); + /* + List<String> strings; + shader->get_shader_mode()->get_string_delimiters(&strings); + + for (List<String>::Element *E=strings.front();E;E=E->next()) { + + String string = E->get(); + String beg = string.get_slice(" ",0); + String end = string.get_slice_count(" ")>1?string.get_slice(" ",1):String(); + get_text_edit()->add_color_region(beg,end,string_color,end==""); + }*/ + + //colorize symbols + Color symbol_color= EDITOR_DEF("text_editor/symbol_color",Color::hex(0x005291ff)); + get_text_edit()->set_symbol_color(symbol_color); + +} + + +void ShaderTextEditor::_validate_script() { + + String errortxt; + int line,col; + + String code; + if (type==ShaderLanguage::SHADER_MATERIAL_VERTEX) + code=get_text_edit()->get_text(); + else + code=get_text_edit()->get_text(); + + //List<StringName> params; + //shader->get_param_list(¶ms); + + Error err = ShaderLanguage::compile(code,type,NULL,NULL,&errortxt,&line,&col); + + if (err!=OK) { + String error_text="error("+itos(line)+","+itos(col)+"): "+errortxt; + set_error(error_text); + + } else { + set_error(""); + } + + emit_signal("script_changed"); +} + +void ShaderTextEditor::_bind_methods() { + + + ADD_SIGNAL( MethodInfo("script_changed") ); + +} + +ShaderTextEditor::ShaderTextEditor() { + + +} + +/*** SCRIPT EDITOR ******/ + + + +void ShaderEditor::_menu_option(int p_option) { + + int selected = tab_container->get_current_tab(); + if (selected<0 || selected>=tab_container->get_child_count()) + return; + + ShaderTextEditor *current = tab_container->get_child(selected)->cast_to<ShaderTextEditor>(); + if (!current) + return; + + switch(p_option) { + case EDIT_UNDO: { + + + current->get_text_edit()->undo(); + } break; + case EDIT_REDO: { + current->get_text_edit()->redo(); + + } break; + case EDIT_CUT: { + + current->get_text_edit()->cut(); + } break; + case EDIT_COPY: { + current->get_text_edit()->copy(); + + } break; + case EDIT_PASTE: { + current->get_text_edit()->paste(); + + } break; + case EDIT_SELECT_ALL: { + + current->get_text_edit()->select_all(); + + } break; + case SEARCH_FIND: { + + find_replace_dialog->set_text_edit(current->get_text_edit()); + find_replace_dialog->popup_search(); + } break; + case SEARCH_FIND_NEXT: { + + find_replace_dialog->set_text_edit(current->get_text_edit()); + find_replace_dialog->search_next(); + } break; + case SEARCH_REPLACE: { + + find_replace_dialog->set_text_edit(current->get_text_edit()); + find_replace_dialog->popup_replace(); + } break; +// case SEARCH_LOCATE_SYMBOL: { + +// } break; + case SEARCH_GOTO_LINE: { + + goto_line_dialog->popup_find_line(current->get_text_edit()); + } break; + case SHADER_POST_PROCESS_MODE:{ + + fragment_editor->set_edited_shader(shader,ShaderLanguage::SHADER_POST_PROCESS); + fragment_editor->_validate_script(); + apply_shaders(); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_MATERIAL_MODE), false); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_POST_PROCESS_MODE), true); + + + } break; + case SHADER_MATERIAL_MODE: { + + fragment_editor->set_edited_shader(shader,ShaderLanguage::SHADER_MATERIAL_FRAGMENT); + fragment_editor->_validate_script(); + apply_shaders(); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_MATERIAL_MODE), true); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_POST_PROCESS_MODE), false); + + } break; + } +} + +void ShaderEditor::_tab_changed(int p_which) { + + ensure_select_current(); +} + +void ShaderEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + close->set_normal_texture( get_icon("Close","EditorIcons")); + close->set_hover_texture( get_icon("CloseHover","EditorIcons")); + close->set_pressed_texture( get_icon("Close","EditorIcons")); + close->connect("pressed",this,"_close_callback"); + + } + if (p_what==NOTIFICATION_DRAW) { + + RID ci = get_canvas_item(); + Ref<StyleBox> style = get_stylebox("panel","Panel"); + style->draw( ci, Rect2( Point2(), get_size() ) ); + + } + +} + + + +Dictionary ShaderEditor::get_state() const { +#if 0 + apply_shaders(); + + Dictionary state; + + Array paths; + int open=-1; + + for(int i=0;i<tab_container->get_child_count();i++) { + + ShaderTextEditor *ste = tab_container->get_child(i)->cast_to<ShaderTextEditor>(); + if (!ste) + continue; + + + Ref<Shader> shader = ste->get_edited_shader(); + if (shader->get_path()!="" && shader->get_path().find("local://")==-1 && shader->get_path().find("::")==-1) { + + paths.push_back(shader->get_path()); + } else { + + + const Node *owner = _find_node_with_shader(get_root_node(),shader.get_ref_ptr()); + if (owner) + paths.push_back(owner->get_path()); + + } + + if (i==tab_container->get_current_tab()) + open=i; + } + + if (paths.size()) + state["sources"]=paths; + if (open!=-1) + state["current"]=open; + + + return state; +#endif + return Dictionary(); +} +void ShaderEditor::set_state(const Dictionary& p_state) { +#if 0 + print_line("setting state.."); + if (!p_state.has("sources")) + return; //bleh + + Array sources = p_state["sources"]; + for(int i=0;i<sources.size();i++) { + + Variant source=sources[i]; + + Ref<Shader> shader; + + if (source.get_type()==Variant::NODE_PATH) { + + print_line("cain find owner at path "+String(source)); + Node *owner=get_root_node()->get_node(source); + if (!owner) + continue; + + shader = owner->get_shader(); + } else if (source.get_type()==Variant::STRING) { + + print_line("loading at path "+String(source)); + shader = ResourceLoader::load(source,"Shader"); + } + + print_line("found shader at "+String(source)+"? - "+itos(shader.is_null())); + if (shader.is_null()) //ah well.. + continue; + + get_scene()->get_root_node()->call("_resource_selected",shader); + } + + if (p_state.has("current")) + tab_container->set_current_tab(p_state["current"]); +#endif +} +void ShaderEditor::clear() { + +} + +void ShaderEditor::_params_changed() { + + + fragment_editor->_validate_script(); + vertex_editor->_validate_script(); +} + + +void ShaderEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_tab_changed",&ShaderEditor::_tab_changed); + ObjectTypeDB::bind_method("_menu_option",&ShaderEditor::_menu_option); + ObjectTypeDB::bind_method("_params_changed",&ShaderEditor::_params_changed); + ObjectTypeDB::bind_method("_close_callback",&ShaderEditor::_close_callback); + ObjectTypeDB::bind_method("apply_shaders",&ShaderEditor::apply_shaders); +// ObjectTypeDB::bind_method("_close_current_tab",&ShaderEditor::_close_current_tab); +} + +void ShaderEditor::ensure_select_current() { + +/* + if (tab_container->get_child_count() && tab_container->get_current_tab()>=0) { + + ShaderTextEditor *ste = tab_container->get_child(tab_container->get_current_tab())->cast_to<ShaderTextEditor>(); + if (!ste) + return; + Ref<Shader> shader = ste->get_edited_shader(); + get_scene()->get_root_node()->call("_resource_selected",shader); + }*/ +} + +void ShaderEditor::edit(const Ref<Shader>& p_shader) { + + if (p_shader.is_null()) + return; + + + shader=p_shader; + + if (shader->get_mode()==Shader::MODE_MATERIAL) { + fragment_editor->set_edited_shader(p_shader,ShaderLanguage::SHADER_MATERIAL_FRAGMENT); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_MATERIAL_MODE), true); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_POST_PROCESS_MODE), false); + } else { + + fragment_editor->set_edited_shader(p_shader,ShaderLanguage::SHADER_POST_PROCESS); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_MATERIAL_MODE), false); + settings_menu->get_popup()->set_item_checked( settings_menu->get_popup()->get_item_index(SHADER_POST_PROCESS_MODE), true); + } + + vertex_editor->set_edited_shader(shader,ShaderLanguage::SHADER_MATERIAL_VERTEX); + // see if already has it + + +} + +void ShaderEditor::save_external_data() { + + if (shader.is_null()) + return; + apply_shaders(); + + if (shader->get_path()!="" && shader->get_path().find("local://")==-1 &&shader->get_path().find("::")==-1) { + //external shader, save it + ResourceSaver::save(shader->get_path(),shader); + } +} + +void ShaderEditor::apply_shaders() { + + + if (shader.is_valid()) + shader->set_code(vertex_editor->get_text_edit()->get_text(),fragment_editor->get_text_edit()->get_text(),0,0); +} + +void ShaderEditor::_close_callback() { + + hide(); +} + + +ShaderEditor::ShaderEditor() { + + tab_container = memnew( TabContainer ); + add_child(tab_container); + tab_container->set_area_as_parent_rect(); + tab_container->set_begin(Point2(0,0)); + //tab_container->set_begin(Point2(0,0)); + + close = memnew( TextureButton ); + close->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,20); + close->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,4); + close->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,2); + add_child(close); + + + + edit_menu = memnew( MenuButton ); + add_child(edit_menu); + edit_menu->set_pos(Point2(5,-1)); + edit_menu->set_text("Edit"); + edit_menu->get_popup()->add_item("Undo",EDIT_UNDO,KEY_MASK_CMD|KEY_Z); + edit_menu->get_popup()->add_item("Redo",EDIT_REDO,KEY_MASK_CMD|KEY_MASK_SHIFT|KEY_Z); + edit_menu->get_popup()->add_separator(); + edit_menu->get_popup()->add_item("Cut",EDIT_CUT,KEY_MASK_CMD|KEY_X); + edit_menu->get_popup()->add_item("Copy",EDIT_COPY,KEY_MASK_CMD|KEY_C); + edit_menu->get_popup()->add_item("Paste",EDIT_PASTE,KEY_MASK_CMD|KEY_V); + edit_menu->get_popup()->add_separator(); + edit_menu->get_popup()->add_item("Select All",EDIT_SELECT_ALL,KEY_MASK_CMD|KEY_A); + edit_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + + search_menu = memnew( MenuButton ); + add_child(search_menu); + search_menu->set_pos(Point2(38,-1)); + search_menu->set_text("Search"); + search_menu->get_popup()->add_item("Find..",SEARCH_FIND,KEY_MASK_CMD|KEY_F); + search_menu->get_popup()->add_item("Find Next",SEARCH_FIND_NEXT,KEY_F3); + search_menu->get_popup()->add_item("Replace..",SEARCH_REPLACE,KEY_MASK_CMD|KEY_R); + search_menu->get_popup()->add_separator(); +// search_menu->get_popup()->add_item("Locate Symbol..",SEARCH_LOCATE_SYMBOL,KEY_MASK_CMD|KEY_K); + search_menu->get_popup()->add_item("Goto Line..",SEARCH_GOTO_LINE,KEY_MASK_CMD|KEY_G); + search_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + settings_menu = memnew( MenuButton ); + add_child(settings_menu); + settings_menu->set_pos(Point2(90,-1)); + settings_menu->set_text("Shader"); + settings_menu->get_popup()->add_check_item("Material Mode",SHADER_MATERIAL_MODE); + settings_menu->get_popup()->set_item_checked(settings_menu->get_popup()->get_item_index(SHADER_MATERIAL_MODE),true); + settings_menu->get_popup()->add_check_item("Post Process Mode",SHADER_POST_PROCESS_MODE); + + settings_menu->get_popup()->connect("item_pressed", this,"_menu_option"); + + tab_container->connect("tab_changed", this,"_tab_changed"); + + find_replace_dialog = memnew(FindReplaceDialog); + add_child(find_replace_dialog); + + erase_tab_confirm = memnew( ConfirmationDialog ); + add_child(erase_tab_confirm); + erase_tab_confirm->connect("confirmed", this,"_close_current_tab"); + + + goto_line_dialog = memnew(GotoLineDialog); + add_child(goto_line_dialog); + + vertex_editor = memnew( ShaderTextEditor ); + tab_container->add_child(vertex_editor); + vertex_editor->set_name("Vertex"); + + fragment_editor = memnew( ShaderTextEditor ); + tab_container->add_child(fragment_editor); + fragment_editor->set_name("Fragment"); + + tab_container->set_current_tab(1); + + + vertex_editor->connect("script_changed", this,"apply_shaders"); + fragment_editor->connect("script_changed", this,"apply_shaders"); +} + + +void ShaderEditorPlugin::edit(Object *p_object) { + + if (!p_object->cast_to<Shader>()) + return; + + shader_editor->edit(p_object->cast_to<Shader>()); + +} + +bool ShaderEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Shader"); +} + +void ShaderEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + shader_editor->show(); + //shader_editor->set_process(true); + } else { + + shader_editor->apply_shaders(); + //shader_editor->hide(); + //shader_editor->set_process(false); + } + +} + +void ShaderEditorPlugin::selected_notify() { + + shader_editor->ensure_select_current(); +} + +Dictionary ShaderEditorPlugin::get_state() const { + + return shader_editor->get_state(); +} + +void ShaderEditorPlugin::set_state(const Dictionary& p_state) { + + shader_editor->set_state(p_state); +} +void ShaderEditorPlugin::clear() { + + shader_editor->clear(); +} + +void ShaderEditorPlugin::save_external_data() { + + shader_editor->save_external_data(); +} + +void ShaderEditorPlugin::apply_changes() { + + shader_editor->apply_shaders(); +} + +ShaderEditorPlugin::ShaderEditorPlugin(EditorNode *p_node) { + + editor=p_node; + shader_editor = memnew( ShaderEditor ); + + SpatialEditor::get_singleton()->get_shader_split()->add_child(shader_editor); +// editor->get_viewport()->add_child(shader_editor); +// shader_editor->set_area_as_parent_rect(); + + shader_editor->hide(); + +} + + +ShaderEditorPlugin::~ShaderEditorPlugin() { +} + diff --git a/tools/editor/plugins/shader_editor_plugin.h b/tools/editor/plugins/shader_editor_plugin.h new file mode 100644 index 000000000..8d5f2dae4 --- /dev/null +++ b/tools/editor/plugins/shader_editor_plugin.h @@ -0,0 +1,158 @@ +/*************************************************************************/ +/* shader_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SHADER_EDITOR_PLUGIN_H +#define SHADER_EDITOR_PLUGIN_H + +#include "tools/editor/code_editor.h" +#include "tools/editor/editor_plugin.h" +#include "scene/gui/tab_container.h" +#include "scene/gui/text_edit.h" +#include "scene/gui/menu_button.h" +#include "scene/main/timer.h" +#include "scene/resources/shader.h" +#include "servers/visual/shader_language.h" + + +class ShaderTextEditor : public CodeTextEditor { + + OBJ_TYPE( ShaderTextEditor, CodeTextEditor ); + + Ref<Shader> shader; + ShaderLanguage::ShaderType type; + +protected: + + static void _bind_methods(); + virtual void _load_theme_settings(); +public: + + virtual void _validate_script(); + + + Ref<Shader> get_edited_shader() const; + void set_edited_shader(const Ref<Shader>& p_shader,ShaderLanguage::ShaderType p_type); + ShaderTextEditor(); + +}; + + +class ShaderEditor : public Control { + + OBJ_TYPE(ShaderEditor, Control ); + + enum { + + EDIT_UNDO, + EDIT_REDO, + EDIT_CUT, + EDIT_COPY, + EDIT_PASTE, + EDIT_SELECT_ALL, + SEARCH_FIND, + SEARCH_FIND_NEXT, + SEARCH_REPLACE, + //SEARCH_LOCATE_SYMBOL, + SEARCH_GOTO_LINE, + SHADER_MATERIAL_MODE, + SHADER_POST_PROCESS_MODE, + SHADER_SHADE_MODEL_MODE, + + }; + + MenuButton *edit_menu; + MenuButton *search_menu; + MenuButton *settings_menu; + uint64_t idle; + + TabContainer *tab_container; + FindReplaceDialog *find_replace_dialog; + GotoLineDialog *goto_line_dialog; + ConfirmationDialog *erase_tab_confirm; + + TextureButton *close; + + ShaderTextEditor *vertex_editor; + ShaderTextEditor *fragment_editor; + + void _tab_changed(int p_which); + void _menu_option(int p_optin); + void _params_changed(); + mutable Ref<Shader> shader; + + void _close_callback(); + + + +protected: + void _notification(int p_what); + static void _bind_methods(); +public: + + void apply_shaders(); + + void ensure_select_current(); + void edit(const Ref<Shader>& p_shader); + + Dictionary get_state() const; + void set_state(const Dictionary& p_state); + void clear(); + + virtual Size2 get_minimum_size() const { return Size2(0,200); } + void save_external_data(); + + ShaderEditor(); +}; + +class ShaderEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ShaderEditorPlugin, EditorPlugin ); + + ShaderEditor *shader_editor; + EditorNode *editor; +public: + + virtual String get_name() const { return "Shader"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + virtual void selected_notify(); + + Dictionary get_state() const; + virtual void set_state(const Dictionary& p_state); + virtual void clear(); + + virtual void save_external_data(); + virtual void apply_changes(); + + ShaderEditorPlugin(EditorNode *p_node); + ~ShaderEditorPlugin(); + +}; +#endif diff --git a/tools/editor/plugins/shader_graph_editor_plugin.cpp b/tools/editor/plugins/shader_graph_editor_plugin.cpp new file mode 100644 index 000000000..2686ca895 --- /dev/null +++ b/tools/editor/plugins/shader_graph_editor_plugin.cpp @@ -0,0 +1,1109 @@ +/*************************************************************************/ +/* shader_graph_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "shader_graph_editor_plugin.h" + +#if 0 +#include "scene/gui/menu_button.h" +#include "scene/gui/panel.h" + +class _ShaderTester : public ShaderCodeGenerator { +public: + + Set<int> *_set; + + virtual void begin() {} + virtual Error add_node(VS::ShaderNodeType p_type,int p_node_pos,int p_id,const Variant& p_param,const Vector<int>& p_in_connections,const Vector<int>& p_out_connections,const Vector<int>& p_out_connection_outputs) { if (_set) _set->insert(p_id); return OK; } + virtual void end() {} + + _ShaderTester() { _set=NULL; } +}; + + + +void ShaderEditor::edit(Ref<Shader> p_shader) { + + + shader=p_shader; + + if (shader.is_null()) + hide(); + else { + _read_shader_graph(); + } + +} + +Size2 ShaderEditor::_get_maximum_size() { + + Size2 max; + + for(List<int>::Element *E=order.front();E;E=E->next()) { + + Point2 pos = Point2( shader_graph.node_get_pos_x(E->get()), shader_graph.node_get_pos_y(E->get()) ); + + if (click_type==CLICK_NODE && click_node==E->get()) { + + pos+=click_motion-click_pos; + } + pos+=get_node_size(E->get()); + if (pos.x>max.x) + max.x=pos.x; + if (pos.y>max.y) + max.y=pos.y; + + } + + return max; +} + +Size2 ShaderEditor::get_node_size(int p_node) const { + + VisualServer::ShaderNodeType type=shader_graph.node_get_type(p_node); + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Ref<Font> font = get_font("font","PopupMenu"); + Color font_color = get_color("font_color","PopupMenu"); + + Size2 size = style->get_minimum_size(); + + int count=1; // title + count += VisualServer::shader_get_input_count( type) + VisualServer::shader_get_output_count( type); + + float max_w=font->get_string_size( VisualServer::shader_node_get_type_info(type).name ).width; + + for(int i=0;i<VisualServer::shader_get_input_count(type);i++) + max_w = MAX( max_w, font->get_string_size( VisualServer::shader_get_input_name(type,i) ).width ); + + + for(int i=0;i<VisualServer::shader_get_output_count(type);i++) + max_w = MAX( max_w, font->get_string_size( VisualServer::shader_get_output_name(type,i) ).width ); + + + + + switch(type) { + + case VS::NODE_IN: + case VS::NODE_OUT: + case VS::NODE_VEC_IN: + case VS::NODE_VEC_OUT: + case VS::NODE_PARAMETER: + case VS::NODE_VEC_PARAMETER: + case VS::NODE_COLOR_PARAMETER: + case VS::NODE_TEXTURE_PARAMETER: + case VS::NODE_TEXTURE_2D_PARAMETER: + case VS::NODE_TEXTURE_CUBE_PARAMETER: + case VS::NODE_TRANSFORM_PARAMETER: + case VS::NODE_LABEL: { + + max_w=MAX( max_w, font->get_string_size( shader_graph.node_get_param(p_node) ).width ); + count++; + } break; + case VS::NODE_TIME: + case VS::NODE_CONSTANT: + case VS::NODE_VEC_CONSTANT: + case VS::NODE_COLOR_CONSTANT: + case VS::NODE_TRANSFORM_CONSTANT: { + count++; + } break; + case VS::NODE_TEXTURE: + case VS::NODE_VEC_TEXTURE_2D: + case VS::NODE_VEC_TEXTURE_CUBE: { + + RefPtr res = shader_graph.node_get_param(p_node); + Ref<Texture> texture = res; + if (texture.is_null() || texture->get_width()==0) { + + size.y+=max_w; + } else { + + size.y+=max_w * texture->get_height() / texture->get_width(); + } + } break; + default: {} + + } + + size.x+=max_w; + size.y+=count*(font->get_height()+get_constant("vseparation","PopupMenu")); + + return size; +} + + +Error ShaderEditor::validate_graph() { + + _ShaderTester st; + active_nodes.clear(); + st._set=&active_nodes; + return shader_graph.generate(&st); +} + +void ShaderEditor::_draw_node(int p_node) { + + VisualServer::ShaderNodeType type=shader_graph.node_get_type(p_node); + Ref<StyleBox> style = active_nodes.has(p_node)?get_stylebox("panel","PopupMenu"):get_stylebox("panel_disabled","PopupMenu"); + Ref<Font> font = get_font("font","PopupMenu"); + Color font_color = get_color("font_color","PopupMenu"); + Color font_color_title = get_color("font_color_hover","PopupMenu"); + Size2 size=get_node_size(p_node); + Point2 pos = Point2( shader_graph.node_get_pos_x(p_node), shader_graph.node_get_pos_y(p_node) )-offset; + + if (click_type==CLICK_NODE && click_node==p_node) { + + pos+=click_motion-click_pos; + } + + RID ci = get_canvas_item(); + style->draw(ci,Rect2(pos,size)); + + Point2 ofs=style->get_offset()+pos; + Point2 ascent=Point2(0,font->get_ascent()); + float w = size.width-style->get_minimum_size().width; + float h = font->get_height()+get_constant("vseparation","PopupMenu"); + + font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, VisualServer::shader_node_get_type_info(type).name,font_color_title); + ofs.y+=h; + + Ref<Texture> vec_icon = get_icon("NodeVecSlot","EditorIcons"); + Ref<Texture> real_icon = get_icon("NodeRealSlot","EditorIcons"); + float icon_h_ofs = Math::floor(( font->get_height()-vec_icon->get_height())/2.0 )+1; + + + for(int i=0;i<VisualServer::shader_get_input_count(type);i++) { + + String name = VisualServer::shader_get_input_name(type,i); + font->draw_halign( ci, ofs+ascent, HALIGN_LEFT,w, name,font_color); + Ref<Texture> icon = VisualServer::shader_is_input_vector(type,i)?vec_icon:real_icon; + icon->draw(ci,ofs+Point2(-real_icon->get_width(),icon_h_ofs)); + ofs.y+=h; + } + + for(int i=0;i<VisualServer::shader_get_output_count(type);i++) { + + String name = VisualServer::shader_get_output_name(type,i); + font->draw_halign( ci, ofs+ascent, HALIGN_RIGHT,w, name,font_color); + Ref<Texture> icon = VisualServer::shader_is_output_vector(type,i)?vec_icon:real_icon; + icon->draw(ci,ofs+Point2(w,icon_h_ofs)); + ofs.y+=h; + } + + switch(type) { + + case VS::NODE_IN: + case VS::NODE_OUT: + case VS::NODE_PARAMETER: + case VS::NODE_VEC_IN: + case VS::NODE_COLOR_PARAMETER: + case VS::NODE_VEC_OUT: + case VS::NODE_TEXTURE_PARAMETER: + case VS::NODE_TEXTURE_2D_PARAMETER: + case VS::NODE_TEXTURE_CUBE_PARAMETER: + case VS::NODE_TRANSFORM_CONSTANT: + case VS::NODE_TRANSFORM_PARAMETER: + case VS::NODE_VEC_PARAMETER: + case VS::NODE_LABEL: { + String text = shader_graph.node_get_param(p_node); + font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, text,font_color); + } break; + case VS::NODE_TIME: + case VS::NODE_CONSTANT: { + String text = rtos(shader_graph.node_get_param(p_node)); + font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, text,font_color); + + } break; + case VS::NODE_VEC_CONSTANT: { + String text = Vector3(shader_graph.node_get_param(p_node)); + font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, text,font_color); + } break; + case VS::NODE_COLOR_CONSTANT: { + + Color color = shader_graph.node_get_param(p_node); + Rect2 r(ofs,Size2(w,h)); + VisualServer::get_singleton()->canvas_item_add_rect(ci,r,color); + } break; + case VS::NODE_TEXTURE: + case VS::NODE_VEC_TEXTURE_2D: + case VS::NODE_VEC_TEXTURE_CUBE: { + + Rect2 r(ofs,Size2(w,(pos.y+size.y-style->get_margin(MARGIN_BOTTOM))-ofs.y)); + Vector<Point2> points; + Vector<Point2> uvs; + points.resize(4); + uvs.resize(4); + points[0]=r.pos; + points[1]=r.pos+Point2(r.size.x,0); + points[2]=r.pos+r.size; + points[3]=r.pos+Point2(0,r.size.y); + uvs[0]=Point2(0,0); + uvs[1]=Point2(1,0); + uvs[2]=Point2(1,1); + uvs[3]=Point2(0,1); + + Ref<Texture> texture = shader_graph.node_get_param(p_node).operator RefPtr(); + if (texture.is_null() || texture->get_width()==0) { + texture=get_icon("Click2Edit","EditorIcons"); + } + + VisualServer::get_singleton()->canvas_item_add_primitive(ci,points,Vector<Color>(),uvs,texture->get_rid()); + } break; + default: {} + } +} + +void ShaderEditor::_node_param_changed() { + + shader_graph.node_set_param( click_node,property_editor->get_variant() ); + update(); + _write_shader_graph(); +} + +ShaderEditor::ClickType ShaderEditor::_locate_click(const Point2& p_click,int *p_node_id,int *p_slot_index) const { + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Ref<Texture> real_icon = get_icon("NodeRealSlot","EditorIcons"); + Ref<Font> font = get_font("font","PopupMenu"); + float h = font->get_height()+get_constant("vseparation","PopupMenu"); + float extra_left=MAX( real_icon->get_width()-style->get_margin(MARGIN_LEFT), 0 ); + float extra_right=MAX( real_icon->get_width()-style->get_margin(MARGIN_RIGHT), 0 ); + + + for(const List<int>::Element *E=order.back();E;E=E->prev()) { + + Size2 size=get_node_size(E->get()); + size.width+=extra_left+extra_right; + Point2 pos = Point2( shader_graph.node_get_pos_x(E->get()), shader_graph.node_get_pos_y(E->get()) )-offset; + pos.x-=extra_left; + + Rect2 rect( pos, size ); + if (!rect.has_point(p_click)) + continue; + VisualServer::ShaderNodeType type=shader_graph.node_get_type(E->get()); + if (p_node_id) + *p_node_id=E->get(); + float y=p_click.y-(pos.y+style->get_margin(MARGIN_TOP)); + if (y<h) + return CLICK_NODE; + y-=h; + + for(int i=0;i<VisualServer::shader_get_input_count(type);i++) { + + if (y<h) { + if (p_slot_index) + *p_slot_index=i; + return CLICK_INPUT_SLOT; + } + y-=h; + } + + for(int i=0;i<VisualServer::shader_get_output_count(type);i++) { + + if (y<h) { + if (p_slot_index) + *p_slot_index=i; + return CLICK_OUTPUT_SLOT; + } + y-=h; + } + + if (p_click.y<(rect.pos.y+rect.size.height-style->get_margin(MARGIN_BOTTOM))) + return CLICK_PARAMETER; + else + return CLICK_NODE; + + } + + return CLICK_NONE; + +} + +Point2 ShaderEditor::_get_slot_pos(int p_node_id,bool p_input,int p_slot) { + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + float w = get_node_size(p_node_id).width; + Ref<Font> font = get_font("font","PopupMenu"); + float h = font->get_height()+get_constant("vseparation","PopupMenu"); + Ref<Texture> vec_icon = get_icon("NodeVecSlot","EditorIcons"); + Point2 pos = Point2( shader_graph.node_get_pos_x(p_node_id), shader_graph.node_get_pos_y(p_node_id) )-offset; + pos+=style->get_offset(); + pos.y+=h; + + if(p_input) { + + pos.y+=p_slot*h; + pos+=Point2( -vec_icon->get_width()/2.0, h/2.0).floor(); + return pos; + } else { + + pos.y+=VisualServer::shader_get_input_count( shader_graph.node_get_type(p_node_id ) )*h; + } + + pos.y+=p_slot*h; + pos+=Point2( w-style->get_minimum_size().width+vec_icon->get_width()/2.0, h/2.0).floor(); + + return pos; + +} + +void ShaderEditor::_node_edit_property(int p_node) { + + Ref<StyleBox> style = get_stylebox("panel","PopupMenu"); + Size2 size = get_node_size(p_node); + Point2 pos = Point2( shader_graph.node_get_pos_x(p_node), shader_graph.node_get_pos_y(p_node) )-offset; + + VisualServer::ShaderNodeType type=shader_graph.node_get_type(p_node); + + PropertyInfo ph = VisualServer::get_singleton()->shader_node_get_type_info(type); + if (ph.type==Variant::NIL) + return; + if (ph.type==Variant::_RID) + ph.type=Variant::OBJECT; + + property_editor->edit(NULL,ph.name,ph.type,shader_graph.node_get_param(p_node),ph.hint,ph.hint_string); + + Point2 popup_pos=Point2( pos.x+(size.width-property_editor->get_size().width)/2.0,pos.y+(size.y-style->get_margin(MARGIN_BOTTOM))).floor(); + popup_pos+=get_global_pos(); + property_editor->set_pos(popup_pos); + + property_editor->popup(); + +} + +bool ShaderEditor::has_point(const Point2& p_point) const { + + int n,si; + + return _locate_click(p_point,&n,&si)!=CLICK_NONE; +} + +void ShaderEditor::_input_event(InputEvent p_event) { + + switch(p_event.type) { + + case InputEvent::MOUSE_BUTTON: { + + if (p_event.mouse_button.pressed) { + + + if (p_event.mouse_button.button_index==1) { + click_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + click_motion=click_pos; + click_type = _locate_click(click_pos,&click_node,&click_slot); + if( click_type!=CLICK_NONE) { + + order.erase(click_node); + order.push_back(click_node); + update(); + } + switch(click_type) { + case CLICK_INPUT_SLOT: { + click_pos=_get_slot_pos(click_node,true,click_slot); + } break; + case CLICK_OUTPUT_SLOT: { + click_pos=_get_slot_pos(click_node,false,click_slot); + } break; + case CLICK_PARAMETER: { + //open editor + _node_edit_property(click_node); + } break; + } + } + if (p_event.mouse_button.button_index==2) { + + if (click_type!=CLICK_NONE) { + click_type=CLICK_NONE; + update(); + } else { + // try to disconnect/remove + + Point2 rclick_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + rclick_type = _locate_click(rclick_pos,&rclick_node,&rclick_slot); + if (rclick_type==CLICK_INPUT_SLOT || rclick_type==CLICK_OUTPUT_SLOT) { + + node_popup->clear(); + node_popup->add_item("Disconnect",NODE_DISCONNECT); + node_popup->set_pos(rclick_pos); + node_popup->popup(); + + } + + if (rclick_type==CLICK_NODE) { + node_popup->clear(); + node_popup->add_item("Remove",NODE_ERASE); + node_popup->set_pos(rclick_pos); + node_popup->popup(); + } + + + } + } + } else { + + if (p_event.mouse_button.button_index==1 && click_type!=CLICK_NONE) { + + switch(click_type) { + case CLICK_INPUT_SLOT: + case CLICK_OUTPUT_SLOT: { + + Point2 dst_click_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + int id; + int slot; + ClickType dst_click_type = _locate_click(dst_click_pos,&id,&slot); + if (dst_click_type==CLICK_INPUT_SLOT && click_type==CLICK_OUTPUT_SLOT) { + + shader_graph.connect(click_node,click_slot,id,slot); + + Error err = validate_graph(); + if (err==ERR_CYCLIC_LINK) + shader_graph.disconnect(click_node,click_slot,id,slot); + _write_shader_graph(); + + } + if (click_type==CLICK_INPUT_SLOT && dst_click_type==CLICK_OUTPUT_SLOT) { + + shader_graph.connect(id,slot,click_node,click_slot); + + Error err = validate_graph(); + if (err==ERR_CYCLIC_LINK) + shader_graph.disconnect(id,slot,click_node,click_slot); + _write_shader_graph(); + } + + } break; + case CLICK_NODE: { + int new_x=shader_graph.node_get_pos_x(click_node)+(click_motion.x-click_pos.x); + int new_y=shader_graph.node_get_pos_y(click_node)+(click_motion.y-click_pos.y); + shader_graph.node_set_pos(click_node,new_x,new_y); + _write_shader_graph(); + + } break; + } + + click_type=CLICK_NONE; + update(); + } + } + + } + + case InputEvent::MOUSE_MOTION: { + + if (p_event.mouse_motion.button_mask&1 && click_type!=CLICK_NONE) { + + click_motion=Point2(p_event.mouse_button.x,p_event.mouse_button.y); + update(); + } + + } break; + } +} + +void ShaderEditor::_notification(int p_what) { + + + switch(p_what) { + + case NOTIFICATION_DRAW: { + + _update_scrollbars(); + //VisualServer::get_singleton()->canvas_item_add_rect(get_canvas_item(),Rect2(Point2(),get_size()),Color(0,0,0,1)); + + for(List<int>::Element *E=order.front();E;E=E->next()) { + + _draw_node(E->get()); + } + + if (click_type==CLICK_INPUT_SLOT || click_type==CLICK_OUTPUT_SLOT) { + + VisualServer::get_singleton()->canvas_item_add_line(get_canvas_item(),click_pos,click_motion,Color(0.5,1,0.5,0.8),2); + } + + List<ShaderGraph::Connection> connections = shader_graph.get_connection_list(); + for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) { + + const ShaderGraph::Connection &c=E->get(); + Point2 source = _get_slot_pos(c.src_id,false,c.src_slot); + Point2 dest = _get_slot_pos(c.dst_id,true,c.dst_slot); + bool vec = VisualServer::shader_is_input_vector( shader_graph.node_get_type(c.dst_id), c.dst_slot ); + Color col = vec?Color(1,0.5,0.5,0.8):Color(1,1,0.5,0.8); + + if (click_type==CLICK_NODE && click_node==c.src_id) { + + source+=click_motion-click_pos; + } + + if (click_type==CLICK_NODE && click_node==c.dst_id) { + + dest+=click_motion-click_pos; + } + + VisualServer::get_singleton()->canvas_item_add_line(get_canvas_item(),source,dest,col,2); + + } + } break; + } + +} + +void ShaderEditor::_update_scrollbars() { + + Size2 size = get_size(); + Size2 hmin = h_scroll->get_minimum_size(); + Size2 vmin = v_scroll->get_minimum_size(); + + v_scroll->set_begin( Point2(size.width - vmin.width, 0) ); + v_scroll->set_end( Point2(size.width, size.height) ); + + h_scroll->set_begin( Point2( 0, size.height - hmin.height) ); + h_scroll->set_end( Point2(size.width-vmin.width, size.height) ); + + + Size2 min = _get_maximum_size(); + + if (min.height < size.height - hmin.height) { + + v_scroll->hide(); + offset.y=0; + } else { + + v_scroll->show(); + v_scroll->set_max(min.height); + v_scroll->set_page(size.height - hmin.height); + offset.y=v_scroll->get_val(); + } + + if (min.width < size.width - vmin.width) { + + h_scroll->hide(); + offset.x=0; + } else { + + h_scroll->show(); + h_scroll->set_max(min.width); + h_scroll->set_page(size.width - vmin.width); + offset.x=h_scroll->get_val(); + } +} + +void ShaderEditor::_scroll_moved() { + + offset.x=h_scroll->get_val(); + offset.y=v_scroll->get_val(); + update(); +} + +void ShaderEditor::_bind_methods() { + + ObjectTypeDB::bind_method( "_node_menu_item", &ShaderEditor::_node_menu_item ); + ObjectTypeDB::bind_method( "_node_add_callback", &ShaderEditor::_node_add_callback ); + ObjectTypeDB::bind_method( "_input_event", &ShaderEditor::_input_event ); + ObjectTypeDB::bind_method( "_node_param_changed", &ShaderEditor::_node_param_changed ); + ObjectTypeDB::bind_method( "_scroll_moved", &ShaderEditor::_scroll_moved ); + ObjectTypeDB::bind_method( "_vertex_item", &ShaderEditor::_vertex_item ); + ObjectTypeDB::bind_method( "_fragment_item", &ShaderEditor::_fragment_item ); + ObjectTypeDB::bind_method( "_post_item", &ShaderEditor::_post_item ); +} + +void ShaderEditor::_read_shader_graph() { + + shader_graph.clear();; + order.clear(); + List<int> nodes; + shader->get_node_list(&nodes); + int larger_id=0; + for(List<int>::Element *E=nodes.front();E;E=E->next()) { + + if (E->get() > larger_id) + larger_id = E->get(); + + shader_graph.node_add( (VS::ShaderNodeType)shader->node_get_type(E->get()), E->get() ); + shader_graph.node_set_param( E->get(), shader->node_get_param( E->get() ) ); + Point2 pos = shader->node_get_pos(E->get()); + shader_graph.node_set_pos( E->get(), pos.x,pos.y ); + order.push_back(E->get()); + } + + last_id=larger_id+1; + + List<Shader::Connection> connections; + shader->get_connections(&connections); + + for(List<Shader::Connection>::Element *E=connections.front();E;E=E->next()) { + + Shader::Connection &c=E->get(); + shader_graph.connect(c.src_id,c.src_slot,c.dst_id,c.dst_slot); + } + + validate_graph(); + update(); +} + +void ShaderEditor::_write_shader_graph() { + + shader->clear(); + List<int> nodes; + shader_graph.get_node_list(&nodes); + for(List<int>::Element *E=nodes.front();E;E=E->next()) { + + shader->node_add((Shader::NodeType)shader_graph.node_get_type(E->get()),E->get()); + shader->node_set_param(E->get(),shader_graph.node_get_param(E->get())); + shader->node_set_pos(E->get(),Point2( shader_graph.node_get_pos_x(E->get()),shader_graph.node_get_pos_y(E->get()) ) ); + } + + List<ShaderGraph::Connection> connections = shader_graph.get_connection_list(); + for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) { + + const ShaderGraph::Connection &c=E->get(); + shader->connect(c.src_id,c.src_slot,c.dst_id,c.dst_slot); + } +} + +void ShaderEditor::_add_node_from_text(const String& p_text) { + + ERR_FAIL_COND( p_text.get_slice_count(" ") != 3 ); + bool input = p_text.get_slice(" ",0)=="In:"; + String name = p_text.get_slice(" ",1); + bool vec = p_text.get_slice(" ",2)=="(vec3)"; + + _node_add( input? + ( vec? VisualServer::NODE_VEC_IN : VisualServer::NODE_IN ) : + ( vec? VisualServer::NODE_VEC_OUT : VisualServer::NODE_OUT ) ); + + shader_graph.node_set_param( last_id-1,name ); + _write_shader_graph(); +} + +void ShaderEditor::_vertex_item(int p_item) { + + _add_node_from_text(vertex_popup->get_item_text(p_item)); +} +void ShaderEditor::_fragment_item(int p_item) { + + _add_node_from_text(fragment_popup->get_item_text(p_item)); +} +void ShaderEditor::_post_item(int p_item) { + + _add_node_from_text(post_popup->get_item_text(p_item)); +} + + +void ShaderEditor::_node_menu_item(int p_item) { + + switch(p_item) { + + case GRAPH_ADD_NODE: { + add_popup->popup_centered_ratio(); + validate_graph(); + } break; + case NODE_DISCONNECT: { + + if (rclick_type==CLICK_INPUT_SLOT) { + + List<ShaderGraph::Connection> connections = shader_graph.get_connection_list(); + for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) { + + const ShaderGraph::Connection &c=E->get(); + if( c.dst_id==rclick_node && c.dst_slot==rclick_slot) { + + shader_graph.disconnect(c.src_id,c.src_slot,c.dst_id,c.dst_slot); + } + } + update(); + _write_shader_graph(); + validate_graph(); + } + + if (rclick_type==CLICK_OUTPUT_SLOT) { + + List<ShaderGraph::Connection> connections = shader_graph.get_connection_list(); + for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) { + + const ShaderGraph::Connection &c=E->get(); + if( c.src_id==rclick_node && c.src_slot==rclick_slot) { + + shader_graph.disconnect(c.src_id,c.src_slot,c.dst_id,c.dst_slot); + } + } + update(); + _write_shader_graph(); + validate_graph(); + } + + } break; + case NODE_ERASE: { + + order.erase(rclick_node); + shader_graph.node_remove(rclick_node); + update(); + _write_shader_graph(); + validate_graph(); + } break; + case GRAPH_CLEAR: { + + order.clear(); + shader_graph.clear(); + last_id=1; + last_x=20; + last_y=20; + update(); + _write_shader_graph(); + validate_graph(); + + } break; + } +} + +void ShaderEditor::_node_add(VisualServer::ShaderNodeType p_type) { + + shader_graph.node_add(p_type,last_id ); + shader_graph.node_set_pos(last_id ,last_x,last_y); + String test_param; + + switch(p_type) { + case VS::NODE_PARAMETER: { + + test_param="param"; + } break; + case VS::NODE_VEC_PARAMETER: { + + test_param="vec"; + } break; + case VS::NODE_COLOR_PARAMETER: { + + test_param="color"; + } break; + case VS::NODE_TEXTURE_PARAMETER: { + + test_param="tex"; + } break; + case VS::NODE_TEXTURE_2D_PARAMETER: { + + test_param="tex2D"; + } break; + case VS::NODE_TEXTURE_CUBE_PARAMETER: { + + test_param="cubemap"; + } break; + case VS::NODE_TRANSFORM_PARAMETER: { + test_param="xform"; + } break; + case VS::NODE_LABEL: { + + test_param="label"; + } break; + } + + if(test_param!="") { + + int iter=0; + List<int> l; + + shader_graph.get_node_list(&l); + + bool found; + String test; + do { + iter++; + test=test_param; + if (iter>1) + test+="_"+itos(iter); + found=false; + for(List<int>::Element *E=l.front();E;E=E->next()) { + + + String param = shader_graph.node_get_param( E->get() ); + if (param==test) { + found=true; + break; + } + } + + } while (found); + + + shader_graph.node_set_param(last_id,test); + + } + order.push_back(last_id); + last_x+=10; + last_y+=10; + last_id++; + last_x=last_x % (int)get_size().width; + last_y=last_y % (int)get_size().height; + update(); + add_popup->hide();; + _write_shader_graph(); + +} + +void ShaderEditor::_node_add_callback() { + + TreeItem * item = add_types->get_selected(); + ERR_FAIL_COND(!item); + _node_add((VisualServer::ShaderNodeType)(int)item->get_metadata(0)); + add_popup->hide() ; +} + +ShaderEditor::ShaderEditor() { + + set_focus_mode(FOCUS_ALL); + + Panel* menu_panel = memnew( Panel ); + menu_panel->set_anchor( MARGIN_RIGHT, Control::ANCHOR_END ); + menu_panel->set_end( Point2(0,22) ); + + add_child( menu_panel ); + + PopupMenu *p; + List<PropertyInfo> defaults; + + MenuButton* node_menu = memnew( MenuButton ); + node_menu->set_text("Graph"); + node_menu->set_pos( Point2( 5,0) ); + menu_panel->add_child( node_menu ); + + p=node_menu->get_popup(); + p->add_item("Add Node",GRAPH_ADD_NODE); + p->add_separator(); + p->add_item("Clear",GRAPH_CLEAR); + p->connect("item_pressed", this,"_node_menu_item"); + + MenuButton* vertex_menu = memnew( MenuButton ); + vertex_menu->set_text("Vertex"); + vertex_menu->set_pos( Point2( 49,0) ); + menu_panel->add_child( vertex_menu ); + + p=vertex_menu->get_popup(); + defaults.clear(); + VisualServer::shader_get_default_input_nodes(VisualServer::SHADER_VERTEX,&defaults); + + int id=0; + for(int i=0;i<defaults.size();i++) { + + p->add_item("In: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++); + } + p->add_separator(); + id++; + + defaults.clear(); + VisualServer::shader_get_default_output_nodes(VisualServer::SHADER_VERTEX,&defaults); + + for(int i=0;i<defaults.size();i++) { + + p->add_item("Out: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++); + } + + vertex_popup=p; + vertex_popup->connect("item_pressed", this,"_vertex_item"); + MenuButton* fragment_menu = memnew( MenuButton ); + fragment_menu->set_text("Fragment"); + fragment_menu->set_pos( Point2( 95 ,0) ); + menu_panel->add_child( fragment_menu ); + + p=fragment_menu->get_popup(); + defaults.clear(); + VisualServer::shader_get_default_input_nodes(VisualServer::SHADER_FRAGMENT,&defaults); + id=0; + for(int i=0;i<defaults.size();i++) { + + p->add_item("In: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++); + } + p->add_separator(); + id++; + defaults.clear(); + VisualServer::shader_get_default_output_nodes(VisualServer::SHADER_FRAGMENT,&defaults); + + for(int i=0;i<defaults.size();i++) { + + p->add_item("Out: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++); + } + + fragment_popup=p; + fragment_popup->connect("item_pressed", this,"_fragment_item"); + + MenuButton* post_menu = memnew( MenuButton ); + post_menu->set_text("Post"); + post_menu->set_pos( Point2( 161,0) ); + menu_panel->add_child( post_menu ); + + p=post_menu->get_popup(); + defaults.clear(); + VisualServer::shader_get_default_input_nodes(VisualServer::SHADER_POST_PROCESS,&defaults); + id=0; + for(int i=0;i<defaults.size();i++) { + + p->add_item("In: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++); + } + p->add_separator(); + id++; + + defaults.clear(); + VisualServer::shader_get_default_output_nodes(VisualServer::SHADER_POST_PROCESS,&defaults); + + for(int i=0;i<defaults.size();i++) { + + p->add_item("Out: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++); + } + + post_popup=p; + post_popup->connect("item_pressed", this,"_post_item"); + + + /* add popup */ + + add_popup = memnew( Popup ); + add_child(add_popup); + add_popup->set_as_toplevel(true); + Panel *add_panel = memnew( Panel ); + add_popup->add_child(add_panel); + add_panel->set_area_as_parent_rect(); + + Label *add_label = memnew (Label ); + add_label->set_pos(Point2(5,5)); + add_label->set_text("Available Nodes:"); + add_panel->add_child(add_label); + + + add_types = memnew( Tree ); + add_types->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + add_types->set_anchor( MARGIN_BOTTOM, ANCHOR_END ); + add_types->set_begin( Point2( 20,25 ) ); + add_types->set_end( Point2( 10, 30 ) ); + add_types->set_hide_root(true); + add_types->set_columns(4); + add_types->set_select_mode(Tree::SELECT_ROW); + + + TreeItem *add_types_root = add_types->create_item(NULL); + TreeItem *info_item = add_types->create_item(add_types_root); + + for(int i=0;i<VisualServer::NODE_TYPE_MAX;i++) { + + TreeItem *item = add_types->create_item(add_types_root); + PropertyInfo prop = VisualServer::shader_node_get_type_info((VisualServer::ShaderNodeType)i); + item->set_text(0,prop.name); + item->set_text(1,itos(VisualServer::shader_get_input_count((VisualServer::ShaderNodeType)i))); + item->set_text(2,itos(VisualServer::shader_get_output_count((VisualServer::ShaderNodeType)i))); + String hint = (prop.type==Variant::_RID)?prop.hint_string:Variant::get_type_name(prop.type); + item->set_text(3,hint); + item->set_metadata(0,i); + } + info_item->set_text(0,"::NODE::"); + info_item->set_custom_color(0,Color(0.6,0.1,0.1)); + info_item->set_text(1,"::INPUTS::"); + info_item->set_custom_color(1,Color(0.6,0.1,0.1)); + info_item->set_text(2,"::OUTPUTS::"); + info_item->set_custom_color(2,Color(0.6,0.1,0.1)); + info_item->set_text(3,"::PARAM::"); + info_item->set_custom_color(3,Color(0.6,0.1,0.1)); + info_item->set_selectable(0,false); + info_item->set_selectable(1,false); + info_item->set_selectable(2,false); + info_item->set_selectable(3,false); + + add_panel->add_child(add_types); + + add_confirm = memnew( Button ); + add_confirm->set_anchor( MARGIN_LEFT, ANCHOR_END ); + add_confirm->set_anchor( MARGIN_TOP, ANCHOR_END ); + add_confirm->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + add_confirm->set_anchor( MARGIN_BOTTOM, ANCHOR_END ); + add_confirm->set_begin( Point2( 75, 29 ) ); + add_confirm->set_end( Point2( 10, 15 ) ); + add_confirm->set_text("Add"); + add_panel->add_child(add_confirm); + add_confirm->connect("pressed", this,"_node_add_callback"); + + last_id=1; + last_x=20; + last_y=20; + + property_editor = memnew( CustomPropertyEditor ); + add_child(property_editor); + property_editor->connect("variant_changed", this,"_node_param_changed"); + + h_scroll = memnew( HScrollBar ); + v_scroll = memnew( VScrollBar ); + + add_child(h_scroll); + add_child(v_scroll); + + h_scroll->connect("value_changed", this,"_scroll_moved"); + v_scroll->connect("value_changed", this,"_scroll_moved"); + + node_popup= memnew(PopupMenu ); + add_child(node_popup); + node_popup->set_as_toplevel(true); + + node_popup->connect("item_pressed", this,"_node_menu_item"); + +} + + +void ShaderEditorPlugin::edit(Object *p_object) { + + shader_editor->edit(p_object->cast_to<Shader>()); +} + +bool ShaderEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Shader"); +} + +void ShaderEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + shader_editor->show(); + shader_editor->set_process(true); + } else { + + shader_editor->hide(); + shader_editor->set_process(false); + } + +} + +ShaderEditorPlugin::ShaderEditorPlugin(EditorNode *p_node) { + + editor=p_node; + shader_editor = memnew( ShaderEditor ); + editor->get_viewport()->add_child(shader_editor); + shader_editor->set_area_as_parent_rect(); + shader_editor->hide(); + + + +} + + +ShaderEditorPlugin::~ShaderEditorPlugin() +{ +} + + +#endif diff --git a/tools/editor/plugins/shader_graph_editor_plugin.h b/tools/editor/plugins/shader_graph_editor_plugin.h new file mode 100644 index 000000000..5b0767dc8 --- /dev/null +++ b/tools/editor/plugins/shader_graph_editor_plugin.h @@ -0,0 +1,150 @@ +/*************************************************************************/ +/* shader_graph_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SHADER_GRAPH_EDITOR_PLUGIN_H +#define SHADER_GRAPH_EDITOR_PLUGIN_H + +#if 0 +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/resources/shader.h" +#include "servers/visual/shader_graph.h" +#include "scene/gui/tree.h" +#include "scene/gui/button.h" +#include "scene/gui/popup.h" +#include "tools/editor/property_editor.h" +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class ShaderEditor : public Control { + + OBJ_TYPE(ShaderEditor, Control ); + + enum MenuAction { + + GRAPH_ADD_NODE, + GRAPH_CLEAR, + NODE_DISCONNECT, + NODE_ERASE, + + }; + + enum ClickType { + CLICK_NONE, + CLICK_NODE, + CLICK_INPUT_SLOT, + CLICK_OUTPUT_SLOT, + CLICK_PARAMETER + }; + + PopupMenu *node_popup; + Popup *add_popup; + PopupMenu *vertex_popup; + PopupMenu *fragment_popup; + PopupMenu *post_popup; + Tree *add_types; + Button *add_confirm; + HScrollBar *h_scroll; + VScrollBar *v_scroll; + + Ref<Shader> shader; + List<int> order; + Set<int> active_nodes; + ShaderGraph shader_graph; + int last_x,last_y; + uint32_t last_id; + + CustomPropertyEditor *property_editor; + + Point2 offset; + ClickType click_type; + Point2 click_pos; + int click_node; + int click_slot; + Point2 click_motion; + ClickType rclick_type; + int rclick_node; + int rclick_slot; + + Size2 _get_maximum_size(); + Size2 get_node_size(int p_node) const; + void _draw_node(int p_node); + + void _add_node_from_text(const String& p_text); + void _update_scrollbars(); + void _scroll_moved(); + void _node_param_changed(); + void _node_add_callback(); + void _node_add(VisualServer::ShaderNodeType p_type); + void _node_edit_property(int p_node); + void _node_menu_item(int p_item); + void _vertex_item(int p_item); + void _fragment_item(int p_item); + void _post_item(int p_item); + + ClickType _locate_click(const Point2& p_click,int *p_node_id,int *p_slot_index) const; + Point2 _get_slot_pos(int p_node_id,bool p_input,int p_slot); + + Error validate_graph(); + + void _read_shader_graph(); + void _write_shader_graph(); + + virtual bool has_point(const Point2& p_point) const; +protected: + void _notification(int p_what); + void _input_event(InputEvent p_event); + static void _bind_methods(); +public: + + void edit(Ref<Shader> p_shader); + ShaderEditor(); +}; + +class ShaderEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ShaderEditorPlugin, EditorPlugin ); + + ShaderEditor *shader_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Shader"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + ShaderEditorPlugin(EditorNode *p_node); + ~ShaderEditorPlugin(); + +}; +#endif +#endif // SHADER_GRAPH_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/spatial_editor_plugin.cpp b/tools/editor/plugins/spatial_editor_plugin.cpp new file mode 100644 index 000000000..be7214aaa --- /dev/null +++ b/tools/editor/plugins/spatial_editor_plugin.cpp @@ -0,0 +1,3311 @@ +/*************************************************************************/ +/* spatial_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "spatial_editor_plugin.h" +#include "print_string.h" + +#include "os/keyboard.h" +#include "scene/3d/visual_instance.h" +#include "scene/3d/camera.h" +#include "camera_matrix.h" +#include "sort.h" +#include "tools/editor/editor_node.h" +#include "tools/editor/editor_settings.h" +#include "scene/resources/surface_tool.h" +#include "tools/editor/spatial_editor_gizmos.h" + +#define DISTANCE_DEFAULT 4 + + +#define GIZMO_ARROW_SIZE 0.3 +#define GIZMO_RING_HALF_WIDTH 0.1 +//#define GIZMO_SCALE_DEFAULT 0.28 +#define GIZMO_SCALE_DEFAULT 0.15 + + +//void SpatialEditorViewport::_update_camera(); + +String SpatialEditorGizmo::get_handle_name(int p_idx) const { + + return ""; +} + +Variant SpatialEditorGizmo::get_handle_value(int p_idx) const{ + + return Variant(); +} + +void SpatialEditorGizmo::set_handle(int p_idx,Camera *p_camera, const Point2& p_point) { + +} + +void SpatialEditorGizmo::commit_handle(int p_idx,const Variant& p_restore,bool p_cancel){ + + +} + +bool SpatialEditorGizmo::intersect_frustum(const Camera *p_camera,const Vector<Plane> &p_frustum) { + + return false; +} + +bool SpatialEditorGizmo::intersect_ray(const Camera *p_camera, const Point2 &p_point, Vector3& r_pos, Vector3& r_normal,int *r_gizmo_handle,bool p_sec_first) { + + return false; +} + +SpatialEditorGizmo::SpatialEditorGizmo(){ + + +} + + + +int SpatialEditorViewport::get_selected_count() const { + + + Map<Node*,Object*> &selection = editor_selection->get_selection(); + + int count=0; + + for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->key()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + count++; + } + + return count; +} + + + +float SpatialEditorViewport::get_znear() const { + + float val = spatial_editor->get_znear(); + if (val<0.001) + val=0.001; + return val; +} +float SpatialEditorViewport::get_zfar() const{ + + float val = spatial_editor->get_zfar(); + if (val<0.001) + val=0.001; + return val; + +} +float SpatialEditorViewport::get_fov() const{ + + float val = spatial_editor->get_fov(); + if (val<0.001) + val=0.001; + if (val>89) + val=89; + return val; + +} + + + +Transform SpatialEditorViewport::_get_camera_transform() const { + + return camera->get_global_transform(); +} + +Vector3 SpatialEditorViewport::_get_camera_pos() const { + + return _get_camera_transform().origin; +} + +Point2 SpatialEditorViewport::_point_to_screen(const Vector3& p_point) { + + return camera->unproject_position(p_point); + +} + +Vector3 SpatialEditorViewport::_get_ray_pos(const Vector2& p_pos) const { + + return camera->project_ray_origin(p_pos); +} + + +Vector3 SpatialEditorViewport::_get_camera_normal() const { + + return -_get_camera_transform().basis.get_axis(2); +} + +Vector3 SpatialEditorViewport::_get_ray(const Vector2& p_pos) { + + + return camera->project_ray_normal(p_pos); + + +} +/* +void SpatialEditorViewport::_clear_id(Spatial *p_node) { + + + editor_selection->remove_node(p_node); + + +} +*/ +void SpatialEditorViewport::_clear_selected() { + + editor_selection->clear(); +} + + + +void SpatialEditorViewport::_select_clicked(bool p_append,bool p_single) { + + if (!clicked) + return; + + Object *obj = ObjectDB::get_instance(clicked); + if (!obj) + return; + + + Spatial *sp = obj->cast_to<Spatial>(); + if (!sp) + return; + + _select(sp, clicked_wants_append,true); +} + + + +void SpatialEditorViewport::_select(Spatial *p_node, bool p_append,bool p_single) { + + + if (!p_append) { + + // should not modify the selection.. + + editor_selection->clear(); + editor_selection->add_node(p_node); + + } else { + + if (editor_selection->is_selected(p_node) && p_single) { + //erase + editor_selection->remove_node(p_node); + } else { + + editor_selection->add_node(p_node); + } + + } + +} + + +struct _RayResult { + + Spatial* item; + float depth; + int handle; + _FORCE_INLINE_ bool operator<(const _RayResult& p_rr) const { return depth<p_rr.depth; } +}; + +ObjectID SpatialEditorViewport::_select_ray(const Point2& p_pos, bool p_append,bool &r_includes_current,int *r_gizmo_handle,bool p_alt_select) { + + if (r_gizmo_handle) + *r_gizmo_handle=-1; + + Vector3 ray=_get_ray(p_pos); + Vector3 pos=_get_ray_pos(p_pos); + + Vector<RID> instances=VisualServer::get_singleton()->instances_cull_ray(pos,ray,get_scene()->get_root()->get_world()->get_scenario() ); + Set<Ref<SpatialEditorGizmo> > found_gizmos; + + //uint32_t closest=0; +// float closest_dist=0; + + r_includes_current=false; + + List<_RayResult> results; + Vector3 cn=_get_camera_normal(); + Plane cplane(pos,cn.normalized()); + + float min_d=1e20; + + for (int i=0;i<instances.size();i++) { + + uint32_t id=VisualServer::get_singleton()->instance_get_object_instance_ID(instances[i]); + Object *obj=ObjectDB::get_instance(id); + if (!obj) + continue; + + Spatial *spat=obj->cast_to<Spatial>(); + + if (!spat) + continue; + + Ref<SpatialEditorGizmo> seg = spat->get_gizmo(); + + if (!seg.is_valid()) + continue; + + if (found_gizmos.has(seg)) + continue; + + found_gizmos.insert(seg); + Vector3 point; + Vector3 normal; + + int handle=-1; + bool inters = seg->intersect_ray(camera,p_pos,point,normal,&handle,p_alt_select); + + if (!inters) + continue; + + float dist = pos.distance_to(point); + + if (dist<0) + continue; + + + + if (editor_selection->is_selected(spat)) + r_includes_current=true; + + _RayResult res; + res.item=spat; + res.depth=dist; + res.handle=handle; + results.push_back(res); + } + + + if (results.empty()) + return 0; + + results.sort(); + Spatial *s=NULL; + + + if (!r_includes_current || results.size()==1 || (r_gizmo_handle && results.front()->get().handle>=0)) { + + //return the nearest one + s = results.front()->get().item; + if (r_gizmo_handle) + *r_gizmo_handle=results.front()->get().handle; + + } else { + + //returns the next one from a curent selection + List<_RayResult>::Element *E=results.front(); + List<_RayResult>::Element *S=NULL; + + + while(true) { + + //very strange loop algorithm that complies with object selection standards (tm). + + if (S==E) { + //went all around and anothing was found + //since can't rotate the selection + //just return the first one + + s=results.front()->get().item; + break; + + } + + if (!S && editor_selection->is_selected(E->get().item)) { + //found an item currently in the selection, + //so start from this one + S=E; + } + + if (S && !editor_selection->is_selected(E->get().item)) { + // free item after a selected item, this one is desired. + s=E->get().item; + break; + } + + E=E->next(); + if (!E) { + + if (!S) { + //did a loop but nothing was selected, select first + s=results.front()->get().item; + break; + + } + E=results.front(); + } + } + } + + if (!s) + return 0; + + return s->get_instance_ID(); + +} + + +Vector3 SpatialEditorViewport::_get_screen_to_space(const Vector3& p_pos) { + + + CameraMatrix cm; + cm.set_perspective(get_fov(),get_size().get_aspect(),get_znear(),get_zfar()); + float screen_w,screen_h; + cm.get_viewport_size(screen_w,screen_h); + + Transform camera_transform; + camera_transform.translate( cursor.pos ); + camera_transform.basis.rotate(Vector3(0,1,0),cursor.y_rot); + camera_transform.basis.rotate(Vector3(1,0,0),cursor.x_rot); + camera_transform.translate(0,0,cursor.distance); + + return camera_transform.xform(Vector3( ((p_pos.x/get_size().width)*2.0-1.0)*screen_w, ((1.0-(p_pos.y/get_size().height))*2.0-1.0)*screen_h,-get_znear())); + +} + + +void SpatialEditorViewport::_select_region() { + + if (cursor.region_begin==cursor.region_end) + return; //nothing really + + Vector3 box[4]={ + Vector3( + MIN( cursor.region_begin.x, cursor.region_end.x), + MIN( cursor.region_begin.y, cursor.region_end.y), + 0 + ), + Vector3( + MAX( cursor.region_begin.x, cursor.region_end.x), + MIN( cursor.region_begin.y, cursor.region_end.y), + 0 + ), + Vector3( + MAX( cursor.region_begin.x, cursor.region_end.x), + MAX( cursor.region_begin.y, cursor.region_end.y), + 0 + ), + Vector3( + MIN( cursor.region_begin.x, cursor.region_end.x), + MAX( cursor.region_begin.y, cursor.region_end.y), + 0 + ) + }; + + Vector<Plane> frustum; + + Vector3 cam_pos=_get_camera_pos(); + Set<Ref<SpatialEditorGizmo> > found_gizmos; + + for(int i=0;i<4;i++) { + + Vector3 a=_get_screen_to_space(box[i]); + Vector3 b=_get_screen_to_space(box[(i+1)%4]); + frustum.push_back( Plane(a,b,cam_pos) ); + } + + Plane near( cam_pos, -_get_camera_normal() ); + near.d-=get_znear(); + + frustum.push_back( near ); + + Plane far=-near; + far.d+=500.0; + + frustum.push_back( far ); + + Vector<RID> instances=VisualServer::get_singleton()->instances_cull_convex(frustum,get_scene()->get_root()->get_world()->get_scenario()); + + + for (int i=0;i<instances.size();i++) { + + uint32_t id=VisualServer::get_singleton()->instance_get_object_instance_ID(instances[i]); + + Object *obj=ObjectDB::get_instance(id); + if (!obj) + continue; + Spatial *sp = obj->cast_to<Spatial>(); + if (!sp) + continue; + + Ref<SpatialEditorGizmo> seg = sp->get_gizmo(); + + if (!seg.is_valid()) + continue; + + if (found_gizmos.has(seg)) + continue; + + if (seg->intersect_frustum(camera,frustum)) + _select(sp,true,false); + } + +} + + +void SpatialEditorViewport::_compute_edit(const Point2& p_point) { + + _edit.click_ray=_get_ray( Vector2( p_point.x, p_point.y ) ); + _edit.click_ray_pos=_get_ray_pos( Vector2( p_point.x, p_point.y ) ); + _edit.plane=TRANSFORM_VIEW; + spatial_editor->update_transform_gizmo(); + _edit.center=spatial_editor->get_gizmo_transform().origin; + + List<Node*> &selection = editor_selection->get_selected_node_list(); + +// Vector3 center; +// int nc=0; + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + se->original=se->sp->get_global_transform(); +// center+=se->original.origin; +// nc++; + } + + +// if (nc) +// _edit.center=center/float(nc); + + + +} + +static int _get_key_modifier(const String& p_property) { + + switch(EditorSettings::get_singleton()->get(p_property).operator int()) { + + case 0: return 0; + case 1: return KEY_SHIFT; + case 2: return KEY_ALT; + case 3: return KEY_META; + case 4: return KEY_CONTROL; + } + return 0; +} + + +bool SpatialEditorViewport::_gizmo_select(const Vector2& p_screenpos,bool p_hilite_only) { + + if (!spatial_editor->is_gizmo_visible()) + return false; + if (get_selected_count()==0) { + if (p_hilite_only) + spatial_editor->select_gizmo_hilight_axis(-1); + return false; + } + + + Vector3 ray_pos=_get_ray_pos( Vector2( p_screenpos.x, p_screenpos.y ) ); + Vector3 ray=_get_ray( Vector2( p_screenpos.x, p_screenpos.y ) ); + + Vector3 cn=_get_camera_normal(); + Plane cplane(ray_pos,cn.normalized()); + + Transform gt = spatial_editor->get_gizmo_transform(); + float gs=0; + if (orthogonal) { + gs= cursor.distance/surface->get_size().get_aspect(); + + } else { + gs = cplane.distance_to(gt.origin); + } + + gs*=GIZMO_SCALE_DEFAULT; + + + if (spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_SELECT || spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_MOVE) { + + int col_axis=-1; + float col_d=1e20; + + for(int i=0;i<3;i++) { + + Vector3 grabber_pos = gt.origin+gt.basis.get_axis(i)*gs; + float grabber_radius = gs*GIZMO_ARROW_SIZE; + + Vector3 r; + if (Geometry::segment_intersects_sphere(ray_pos,ray_pos+ray*10000.0,grabber_pos,grabber_radius,&r)) { + float d = r.distance_to(ray_pos); + if (d<col_d) { + col_d=d; + col_axis=i; + } + } + } + + if (col_axis!=-1) { + + + if (p_hilite_only) { + + spatial_editor->select_gizmo_hilight_axis(col_axis); + + + } else { + //handle rotate + _edit.mode=TRANSFORM_TRANSLATE; + _compute_edit(Point2(p_screenpos.x,p_screenpos.y)); + _edit.plane=TransformPlane(TRANSFORM_X_AXIS+col_axis); + } + return true; + + + } + + } + + + if (spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_SELECT || spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_ROTATE) { + + int col_axis=-1; + float col_d=1e20; + + for(int i=0;i<3;i++) { + + Plane plane(gt.origin,gt.basis.get_axis(i).normalized()); + Vector3 r; + if (!plane.intersects_ray(ray_pos,ray,&r)) + continue; + + float dist = r.distance_to(gt.origin); + + + + if (dist > gs*(1-GIZMO_RING_HALF_WIDTH) && dist < gs *(1+GIZMO_RING_HALF_WIDTH)) { + + float d = ray_pos.distance_to(r); + if (d<col_d) { + col_d=d; + col_axis=i; + } + } + } + + if (col_axis!=-1) { + + if (p_hilite_only) { + + spatial_editor->select_gizmo_hilight_axis(col_axis+3); + } else { + //handle rotate + _edit.mode=TRANSFORM_ROTATE; + _compute_edit(Point2(p_screenpos.x,p_screenpos.y)); + _edit.plane=TransformPlane(TRANSFORM_X_AXIS+col_axis); + } + return true; + } + } + + + if (p_hilite_only) + spatial_editor->select_gizmo_hilight_axis(-1); + + return false; + +} + + +void SpatialEditorViewport::_smouseenter() { + + surface->grab_focus(); +} + +void SpatialEditorViewport::_sinput(const InputEvent &p_event) { + + if (previewing) + return; //do NONE + + + { + + EditorNode *en = editor; + EditorPlugin *over_plugin = en->get_editor_plugin_over(); + + if (over_plugin) { + bool discard = over_plugin->forward_spatial_input_event(camera,p_event); + if (discard) + return; + } + } + + + switch(p_event.type) { + case InputEvent::MOUSE_BUTTON: { + + const InputEventMouseButton &b=p_event.mouse_button; + + switch(b.button_index) { + + case BUTTON_WHEEL_UP: { + + cursor.distance/=1.08; + } break; + case BUTTON_WHEEL_DOWN: { + + cursor.distance*=1.08; + + } break; + case BUTTON_RIGHT: { + + + if (b.pressed && _edit.gizmo.is_valid()) { + //restore + _edit.gizmo->commit_handle(_edit.gizmo_handle,_edit.gizmo_initial_value,true); + _edit.gizmo=Ref<SpatialEditorGizmo>(); + } + + if (_edit.mode==TRANSFORM_NONE && b.pressed) { + + Plane cursor_plane(cursor.cursor_pos,_get_camera_normal()); + + Vector3 ray_origin = _get_ray_pos(Vector2(b.x,b.y)); + Vector3 ray_dir = _get_ray(Vector2(b.x,b.y)); + + + //gizmo modify + + if (b.mod.control) { + + Vector<RID> instances=VisualServer::get_singleton()->instances_cull_ray(ray_origin,ray_dir,get_scene()->get_root()->get_world()->get_scenario() ); + + Plane p(ray_origin,_get_camera_normal()); + + float min_d=1e10; + bool found=false; + + for (int i=0;i<instances.size();i++) { + + uint32_t id=VisualServer::get_singleton()->instance_get_object_instance_ID(instances[i]); + Object *obj=ObjectDB::get_instance(id); + if (!obj) + continue; + + VisualInstance *vi=obj->cast_to<VisualInstance>(); + if (!vi) + continue; + + //optimize by checking AABB (although should pre sort by distance) + AABB aabb = vi->get_global_transform().xform(vi->get_aabb()); + if (p.distance_to(aabb.get_support(-ray_dir))>min_d) + continue; + + DVector<Face3> faces = vi->get_faces(VisualInstance::FACES_SOLID); + int c = faces.size(); + if (c>0) { + DVector<Face3>::Read r = faces.read(); + + for(int j=0;j<c;j++) { + + Vector3 inters; + if (r[j].intersects_ray(ray_origin,ray_dir,&inters)) { + + float d = p.distance_to(inters); + if (d<0) + continue; + + if (d<min_d) { + min_d=d; + found=true; + } + } + + } + } + + } + + if (found) { + + //cursor.cursor_pos=ray_origin+ray_dir*min_d; + //VisualServer::get_singleton()->instance_set_transform(cursor_instance,Transform(Matrix3(),cursor.cursor_pos)); + + } + + } else { + Vector3 new_pos; + if (cursor_plane.intersects_ray(ray_origin,ray_dir,&new_pos)) { + + //cursor.cursor_pos=new_pos; + //VisualServer::get_singleton()->instance_set_transform(cursor_instance,Transform(Matrix3(),cursor.cursor_pos)); + } + } + } + + if (_edit.mode!=TRANSFORM_NONE && b.pressed) { + //cancel motion + _edit.mode=TRANSFORM_NONE; + //_validate_selection(); + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + sp->set_global_transform( se->original ); + + } + surface->update(); + //VisualServer::get_singleton()->poly_clear(indicators); + set_message("Transform Aborted.",3); + } + } break; + case BUTTON_MIDDLE: { + + if (b.pressed && _edit.mode!=TRANSFORM_NONE) { + + switch(_edit.plane ) { + + case TRANSFORM_VIEW: { + + _edit.plane=TRANSFORM_X_AXIS; + set_message("View Plane Transform.",2); + } break; + case TRANSFORM_X_AXIS: { + + _edit.plane=TRANSFORM_Y_AXIS; + set_message("X-Axis Transform.",2); + + } break; + case TRANSFORM_Y_AXIS: { + + _edit.plane=TRANSFORM_Z_AXIS; + set_message("Y-Axis Transform.",2); + + } break; + case TRANSFORM_Z_AXIS: { + + _edit.plane=TRANSFORM_VIEW; + set_message("Z-Axis Transform.",2); + + } break; + } + + } + } break; + case BUTTON_LEFT: { + + if (b.pressed) { + + _edit.mouse_pos=Point2(b.x,b.y); + _edit.snap=false; + _edit.mode=TRANSFORM_NONE; + + //gizmo has priority over everything + + if (_gizmo_select(_edit.mouse_pos)) + break; + + clicked=0; + clicked_includes_current=false; + + + if ((spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_SELECT && b.mod.control) || spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_ROTATE) { + + /* HANDLE ROTATION */ + if (get_selected_count()==0) + break; //bye + //handle rotate + _edit.mode=TRANSFORM_ROTATE; + _compute_edit(Point2(b.x,b.y)); + break; + + } + + if (spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_MOVE) { + + if (get_selected_count()==0) + break; //bye + //handle rotate + _edit.mode=TRANSFORM_TRANSLATE; + _compute_edit(Point2(b.x,b.y)); + break; + + + } + + + if (spatial_editor->get_tool_mode()==SpatialEditor::TOOL_MODE_SCALE) { + + if (get_selected_count()==0) + break; //bye + //handle rotate + _edit.mode=TRANSFORM_SCALE; + _compute_edit(Point2(b.x,b.y)); + break; + + + } + + + + // todo scale + + int gizmo_handle=-1; + + clicked=_select_ray(Vector2( b.x, b.y ),b.mod.shift,clicked_includes_current,&gizmo_handle,b.mod.shift); + + //clicking is always deferred to either move or release + + clicked_wants_append=b.mod.shift; + + if (!clicked) { + + if (!clicked_wants_append) + _clear_selected(); + + //default to regionselect + cursor.region_select=true; + cursor.region_begin=Point2(b.x,b.y); + cursor.region_end=Point2(b.x,b.y); + } + + if (clicked && gizmo_handle>=0) { + + Object *obj=ObjectDB::get_instance(clicked); + if (obj) { + + Spatial *spa = obj->cast_to<Spatial>(); + if (spa) { + + Ref<SpatialEditorGizmo> seg=spa->get_gizmo(); + if (seg.is_valid()) { + + _edit.gizmo=seg; + _edit.gizmo_handle=gizmo_handle; + //_edit.gizmo_initial_pos=seg->get_handle_pos(gizmo_handle); + _edit.gizmo_initial_value=seg->get_handle_value(gizmo_handle); + //print_line("GIZMO: "+itos(gizmo_handle)+" FROMPOS: "+_edit.orig_gizmo_pos); + break; + + } + } + + } + //_compute_edit(Point2(b.x,b.y)); //in case a motion happens.. + } + + + + surface->update(); + } else { + + + if (_edit.gizmo.is_valid()) { + + _edit.gizmo->commit_handle(_edit.gizmo_handle,_edit.gizmo_initial_value,false); + _edit.gizmo=Ref<SpatialEditorGizmo>(); + break; + } + if (clicked) { + _select_clicked(clicked_wants_append,true); + //clickd processing was deferred + clicked=0; + + + } + + if (cursor.region_select) { + _select_region(); + cursor.region_select=false; + surface->update(); + } + + + if (_edit.mode!=TRANSFORM_NONE) { + + + static const char* _transform_name[4]={"None","Rotate","Translate","Scale"}; + undo_redo->create_action(_transform_name[_edit.mode]); + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + undo_redo->add_do_method(sp,"set_global_transform",sp->get_global_transform()); + undo_redo->add_undo_method(sp,"set_global_transform",se->original); + } + undo_redo->commit_action(); + _edit.mode=TRANSFORM_NONE; + //VisualServer::get_singleton()->poly_clear(indicators); + set_message(""); + } + + + surface->update(); + } + } break; + } + } break; + case InputEvent::MOUSE_MOTION: { + + const InputEventMouseMotion &m=p_event.mouse_motion; + _edit.mouse_pos=Point2(p_event.mouse_motion.x,p_event.mouse_motion.y); + + if (!(m.button_mask&1) && !_edit.gizmo.is_valid()) { + + _gizmo_select(_edit.mouse_pos,true); + + } + + + if (_edit.gizmo.is_valid()) { + + Plane plane=Plane(_edit.gizmo_initial_pos,_get_camera_normal()); + + + Vector3 ray_pos=_get_ray_pos( Vector2( m.x, m.y ) ); + Vector3 ray=_get_ray( Vector2( m.x, m.y ) ); + + //Vector3 intersection; + //if (!plane.intersects_ray(ray_pos,ray,&intersection)) + // break; + + _edit.gizmo->set_handle(_edit.gizmo_handle,camera,Vector2(m.x,m.y)); + Variant v = _edit.gizmo->get_handle_value(_edit.gizmo_handle); + String n = _edit.gizmo->get_handle_name(_edit.gizmo_handle); + set_message(n+": "+String(v)); + + } else if (m.button_mask&1) { + + if (clicked) { + + if (!clicked_includes_current) { + + _select_clicked(clicked_wants_append,true); + //clickd processing was deferred + } + + + _compute_edit(_edit.mouse_pos); + clicked=0; + + _edit.mode=TRANSFORM_TRANSLATE; + + } + + if (cursor.region_select) { + + cursor.region_end=Point2(m.x,m.y); + surface->update(); + return; + } + + if (_edit.mode==TRANSFORM_NONE) + break; + + Vector3 ray_pos=_get_ray_pos( Vector2( m.x, m.y ) ); + Vector3 ray=_get_ray( Vector2( m.x, m.y ) ); + + + switch(_edit.mode) { + + case TRANSFORM_SCALE: { + + + Plane plane=Plane(_edit.center,_get_camera_normal()); + + + Vector3 intersection; + if (!plane.intersects_ray(ray_pos,ray,&intersection)) + break; + + Vector3 click; + if (!plane.intersects_ray(_edit.click_ray_pos,_edit.click_ray,&click)) + break; + + float center_click_dist = click.distance_to(_edit.center); + float center_inters_dist = intersection.distance_to(_edit.center); + if (center_click_dist==0) + break; + + float scale = (center_inters_dist / center_click_dist)*100.0; + + if (_edit.snap || spatial_editor->is_snap_enabled()) { + + scale = Math::stepify(scale,spatial_editor->get_scale_snap()); + } + + set_message("Scaling to "+String::num(scale,1)+"%."); + scale/=100.0; + + Transform r; + r.basis.scale(Vector3(scale,scale,scale)); + + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + + Transform original=se->original; + + Transform base=Transform( Matrix3(), _edit.center); + Transform t=base * (r * (base.inverse() * original)); + + sp->set_global_transform(t); + } + + surface->update(); + + } break; + + case TRANSFORM_TRANSLATE: { + + + Vector3 motion_mask; + Plane plane; + + switch( _edit.plane ) { + case TRANSFORM_VIEW: + motion_mask=Vector3(0,0,0); + plane=Plane(_edit.center,_get_camera_normal()); + break; + case TRANSFORM_X_AXIS: + motion_mask=spatial_editor->get_gizmo_transform().basis.get_axis(0); + plane=Plane(_edit.center,motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); + break; + case TRANSFORM_Y_AXIS: + motion_mask=spatial_editor->get_gizmo_transform().basis.get_axis(1); + plane=Plane(_edit.center,motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); + break; + case TRANSFORM_Z_AXIS: + motion_mask=spatial_editor->get_gizmo_transform().basis.get_axis(2); + plane=Plane(_edit.center,motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); + break; + } + + Vector3 intersection; + if (!plane.intersects_ray(ray_pos,ray,&intersection)) + break; + + Vector3 click; + if (!plane.intersects_ray(_edit.click_ray_pos,_edit.click_ray,&click)) + break; + + //_validate_selection(); + Vector3 motion = intersection-click; + if (motion_mask!=Vector3()) { + motion=motion_mask.dot(motion)*motion_mask; + } + + float snap=0; + + if (_edit.snap || spatial_editor->is_snap_enabled()) { + + snap = spatial_editor->get_translate_snap(); + motion.snap(snap); + } + + //set_message("Translating: "+motion); + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) { + continue; + } + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) { + continue; + } + + Transform t=se->original; + t.origin+=motion; + sp->set_global_transform(t); + } + } break; + + case TRANSFORM_ROTATE: { + + + Plane plane; + + switch( _edit.plane ) { + case TRANSFORM_VIEW: + plane=Plane(_edit.center,_get_camera_normal()); + break; + case TRANSFORM_X_AXIS: + plane=Plane(_edit.center,spatial_editor->get_gizmo_transform().basis.get_axis(0)); + break; + case TRANSFORM_Y_AXIS: + plane=Plane(_edit.center,spatial_editor->get_gizmo_transform().basis.get_axis(1)); + break; + case TRANSFORM_Z_AXIS: + plane=Plane(_edit.center,spatial_editor->get_gizmo_transform().basis.get_axis(2)); + break; + } + + Vector3 intersection; + if (!plane.intersects_ray(ray_pos,ray,&intersection)) + break; + + Vector3 click; + if (!plane.intersects_ray(_edit.click_ray_pos,_edit.click_ray,&click)) + break; + + + Vector3 y_axis=(click-_edit.center).normalized(); + Vector3 x_axis=plane.normal.cross(y_axis).normalized(); + + float angle=Math::atan2( x_axis.dot(intersection-_edit.center), y_axis.dot(intersection-_edit.center) ); + if (_edit.snap || spatial_editor->is_snap_enabled()) { + + float snap = spatial_editor->get_rotate_snap(); + + if (snap) { + angle=Math::rad2deg(angle)+snap*0.5; //else it wont reach +180 + angle-=Math::fmod(angle,snap); + set_message("Rotating "+rtos(angle)+" degrees."); + angle=Math::deg2rad(angle); + } else + set_message("Rotating "+rtos(Math::rad2deg(angle))+" degrees."); + + } else { + set_message("Rotating "+rtos(Math::rad2deg(angle))+" degrees."); + } + + + + + Transform r; + r.basis.rotate(plane.normal,-angle); + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + + Transform original=se->original; + + Transform base=Transform( Matrix3(), _edit.center); + Transform t=base * (r * (base.inverse() * original)); + + sp->set_global_transform(t); + } + + surface->update(); + /* + VisualServer::get_singleton()->poly_clear(indicators); + + Vector<Vector3> points; + Vector<Vector3> empty; + Vector<Color> colors; + points.push_back(intersection); + points.push_back(_edit.original.origin); + colors.push_back( Color(255,155,100) ); + colors.push_back( Color(255,155,100) ); + VisualServer::get_singleton()->poly_add_primitive(indicators,points,empty,colors,empty); + */ + } break; + default:{} + } + + } else if (m.button_mask&4) { + + + int mod = 0; + if (m.mod.shift) + mod=KEY_SHIFT; + if (m.mod.alt) + mod=KEY_ALT; + if (m.mod.control) + mod=KEY_CONTROL; + if (m.mod.meta) + mod=KEY_META; + + + + if (mod == _get_key_modifier("3d_editor/pan_modifier")) { + + + Transform camera_transform; + + camera_transform.translate(cursor.pos); + camera_transform.basis.rotate(Vector3(0,1,0),cursor.y_rot); + camera_transform.basis.rotate(Vector3(1,0,0),cursor.x_rot); + Vector3 translation(-m.relative_x/150.0,m.relative_y/150.0,0); + translation*=cursor.distance/DISTANCE_DEFAULT; + camera_transform.translate(translation); + cursor.pos=camera_transform.origin; + + } else if (mod == _get_key_modifier("3d_editor/zoom_modifier")) { + + if ( m.relative_y > 0) + cursor.distance*=1+m.relative_y/80.0; + else if (m.relative_y < 0) + cursor.distance/=1-m.relative_y/80.0; + + } else if (mod == _get_key_modifier("3d_editor/orbit_modifier")) { + cursor.x_rot+=m.relative_y/80.0; + cursor.y_rot+=m.relative_x/80.0; + if (cursor.x_rot>Math_PI/2.0) + cursor.x_rot=Math_PI/2.0; + if (cursor.x_rot<-Math_PI/2.0) + cursor.x_rot=-Math_PI/2.0; + + } + } + + } break; + + case InputEvent::KEY: { + + const InputEventKey &k = p_event.key; + switch(k.scancode) { + + case KEY_S: { + + if (_edit.mode!=TRANSFORM_NONE) { + + _edit.snap=true; + } + } break; + case KEY_KP_7: { + + cursor.y_rot=0; + if (k.mod.shift) { + cursor.x_rot=-Math_PI/2.0; + set_message("Bottom View.",2); + } else { + cursor.x_rot=Math_PI/2.0; + set_message("Top View.",2); + } + } break; + case KEY_KP_1: { + + cursor.x_rot=0; + if (k.mod.shift) { + cursor.y_rot=Math_PI; + set_message("Rear View.",2); + + } else { + cursor.y_rot=0; + set_message("Front View.",2); + } + + } break; + case KEY_KP_3: { + + cursor.x_rot=0; + if (k.mod.shift) { + cursor.y_rot=Math_PI/2.0; + set_message("Left View.",2); + } else { + cursor.y_rot=-Math_PI/2.0; + set_message("Right View.",2); + } + + } break; + case KEY_KP_5: { + + orthogonal = !orthogonal; + _menu_option(orthogonal?VIEW_PERSPECTIVE:VIEW_ORTHOGONAL); + + } break; + case KEY_K: { + + if (!get_selected_count() || _edit.mode!=TRANSFORM_NONE) + break; + + if (!editor->get_animation_editor()->has_keying()) { + set_message("Keying is disabled (no key inserted)."); + break; + } + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + emit_signal("transform_key_request",sp,"",sp->get_transform()); + } + + + set_message("Animation Key Inserted."); + + + + } break; + + } + + + } break; + + } + +} + +void SpatialEditorViewport::set_message(String p_message,float p_time) { + + message=p_message; + message_time=p_time; + +} + + + +void SpatialEditorViewport::_notification(int p_what) { + + + if (p_what==NOTIFICATION_VISIBILITY_CHANGED) { + + bool visible=is_visible(); + + set_process(visible); + } + + if (p_what==NOTIFICATION_PROCESS) { + + + //force editr camera + /* + current_camera=get_root_node()->get_current_camera(); + if (current_camera!=camera) { + + + } + */ + + if (orthogonal) { + Size2 size=get_size(); + Size2 vpsize = Point2(cursor.distance*size.get_aspect(),cursor.distance/size.get_aspect()); + //camera->set_orthogonal(size.width*cursor.distance,get_znear(),get_zfar()); + camera->set_orthogonal(2*cursor.distance,0.1,8192); + } else + camera->set_perspective(get_fov(),get_znear(),get_zfar()); + + Transform camera_transform; + camera_transform.translate( cursor.pos ); + camera_transform.basis.rotate(Vector3(0,1,0),cursor.y_rot); + camera_transform.basis.rotate(Vector3(1,0,0),cursor.x_rot); + + if (orthogonal) + camera_transform.translate(0,0,4096); + else + camera_transform.translate(0,0,cursor.distance); + + if (camera->get_global_transform()!=camera_transform) { + camera->set_global_transform( camera_transform ); + //_update_transform_gizmo_view(); + } + + Map<Node*,Object*> &selection = editor_selection->get_selection(); + + bool changed=false; + bool exist=false; + + for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->key()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + + /* + ?? + if (!se->poly_instance.is_valid()) + continue; + if (!ObjectDB::get_instance( E->key() )) { + VisualServer::get_singleton()->free( se->poly_instance ); + se->poly_instance=RID(); + continue; + } + */ + VisualInstance *vi=sp->cast_to<VisualInstance>(); + + + if (se->aabb.has_no_surface()) { + + se->aabb=vi?vi->get_aabb():AABB( Vector3(-0.2,-0.2,-0.2),Vector3(0.4,0.4,0.4)); + } + + Transform t=sp->get_global_transform(); + t.translate(se->aabb.pos); + t.basis.scale( se->aabb.size ); + + exist=true; + if (se->last_xform==t) + continue; + changed=true; + se->last_xform=t; + VisualServer::get_singleton()->instance_set_transform(se->sbox_instance,t); + + } + + if (changed || (spatial_editor->is_gizmo_visible() && !exist)) { + spatial_editor->update_transform_gizmo(); + } + + if (message_time>0) { + + if (message!=last_message) { + surface->update(); + last_message=message; + } + + message_time-=get_fixed_process_delta_time(); + if (message_time<0) + surface->update(); + } + + //grid + Vector3 grid_cam_axis=_get_camera_normal(); + /* + for(int i=0;i<3;i++) { + + + Vector3 axis; + axis[i]=1; + + bool should_be_visible= grid_enabled && (grid_enable[i] || (Math::abs(grid_cam_axis.dot(axis))>0.99 && orthogonal)); + + if (should_be_visible!=grid_visible[i]) { + + VisualServer::get_singleton()->instance_geometry_set_flag(grid_instance[i],VS::INSTANCE_FLAG_VISIBLE,should_be_visible); + grid_visible[i]=should_be_visible; + } + } + + if (last_grid_snap!=spatial_editor->get_translate_snap()) { + + + last_grid_snap=spatial_editor->get_translate_snap() + Transform gridt; + gridt.basis.scale(Vector3(last_grid_snap,last_grid_snap,last_grid_snap)); + for(int i=0;i<3;i++) + VisualServer::get_singleton()->instance_set_transform(grid_instance[i],gridt); + + }*/ + + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + surface->connect("draw",this,"_draw"); + surface->connect("input_event",this,"_sinput"); + surface->connect("mouse_enter",this,"_smouseenter"); + preview_camera->set_icon(get_icon("Camera","EditorIcons")); + + } + + if (p_what==NOTIFICATION_MOUSE_ENTER) { + + + } + + + if (p_what==NOTIFICATION_DRAW) { + + + + } + +} + +void SpatialEditorViewport::_draw() { + + if (surface->has_focus()) { + Size2 size = surface->get_size(); + Rect2 r =Rect2(Point2(),size); + get_stylebox("EditorFocus","EditorStyles")->draw(surface->get_canvas_item(),r); + } + + + RID ci=surface->get_canvas_item(); + + if (cursor.region_select) { + + VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(cursor.region_begin,cursor.region_end-cursor.region_begin),Color(0.7,0.7,1.0,0.3)); + } + + if (message_time>0) { + Ref<Font> font = get_font("font","Label"); + Point2 msgpos=Point2(5,get_size().y-20); + font->draw(ci,msgpos+Point2(1,1),message,Color(0,0,0,0.8)); + font->draw(ci,msgpos+Point2(-1,-1),message,Color(0,0,0,0.8)); + font->draw(ci,msgpos,message,Color(1,1,1,1)); + } + + + if (_edit.mode==TRANSFORM_ROTATE) { + + Point2 center = _point_to_screen(_edit.center); + VisualServer::get_singleton()->canvas_item_add_line(ci,_edit.mouse_pos, center, Color(0.4,0.7,1.0,0.8)); + + + } + +} + + +void SpatialEditorViewport::_menu_option(int p_option) { + + switch(p_option) { + + case VIEW_TOP: { + + cursor.x_rot=Math_PI/2.0; + cursor.y_rot=0; + } break; + case VIEW_BOTTOM: { + + cursor.x_rot=-Math_PI/2.0; + cursor.y_rot=0; + + } break; + case VIEW_LEFT: { + + cursor.y_rot=Math_PI/2.0; + cursor.x_rot=0; + + } break; + case VIEW_RIGHT: { + + cursor.y_rot=-Math_PI/2.0; + cursor.x_rot=0; + + } break; + case VIEW_FRONT: { + + cursor.y_rot=0; + cursor.x_rot=0; + + } break; + case VIEW_REAR: { + + cursor.y_rot=Math_PI; + cursor.x_rot=0; + + } break; + case VIEW_CENTER_TO_SELECTION: { + + if (!get_selected_count()) + break; + + Vector3 center; + int count=0; + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + center+=sp->get_global_transform().origin; + count++; + } + + center/=float(count); + + cursor.pos=center; + } break; + case VIEW_ENVIRONMENT: { + + int idx = view_menu->get_popup()->get_item_index(VIEW_ENVIRONMENT); + bool current = view_menu->get_popup()->is_item_checked( idx ); + current=!current; + if (current) { + + camera->set_environment(RES()); + } else { + + camera->set_environment(SpatialEditor::get_singleton()->get_viewport_environment()); + } + + view_menu->get_popup()->set_item_checked( idx, current ); + + + } break; + case VIEW_PERSPECTIVE: { + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_PERSPECTIVE), true ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_ORTHOGONAL), false ); + orthogonal=false; + } break; + case VIEW_ORTHOGONAL: { + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_PERSPECTIVE), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_ORTHOGONAL), true ); + orthogonal=true; + + } break; + + } + +} + + +void SpatialEditorViewport::_preview_exited_scene() { + + preview_camera->set_pressed(false); + _toggle_camera_preview(false); + view_menu->show(); +} + + +void SpatialEditorViewport::_toggle_camera_preview(bool p_activate) { + + + ERR_FAIL_COND(p_activate && !preview); + ERR_FAIL_COND(!p_activate && !previewing); + + if (!p_activate) { + + previewing->disconnect("exit_scene",this,"_preview_exited_scene"); + previewing=NULL; + VS::get_singleton()->viewport_attach_camera( viewport->get_viewport(), camera->get_camera() ); //restore + if (!preview) + preview_camera->hide(); + view_menu->show(); + + } else { + + previewing=preview; + previewing->connect("exit_scene",this,"_preview_exited_scene"); + VS::get_singleton()->viewport_attach_camera( viewport->get_viewport(), preview->get_camera() ); //replace + view_menu->hide(); + + } +} + +void SpatialEditorViewport::set_can_preview(Camera* p_preview) { + + preview=p_preview; + + if (!preview_camera->is_pressed()) { + + if (p_preview) { + preview_camera->show(); + } else { + preview_camera->hide(); + } + } +} + +void SpatialEditorViewport::set_state(const Dictionary& p_state) { + + cursor.pos=p_state["pos"]; + cursor.x_rot=p_state["x_rot"]; + cursor.y_rot=p_state["y_rot"]; + cursor.distance=p_state["distance"]; + bool env = p_state["use_environment"]; + bool orth = p_state["use_orthogonal"]; + if (orth) + _menu_option(VIEW_ORTHOGONAL); + else + _menu_option(VIEW_PERSPECTIVE); + if (env != camera->get_environment().is_valid()) + _menu_option(VIEW_ENVIRONMENT); + + +} + +Dictionary SpatialEditorViewport::get_state() const { + + Dictionary d; + d["pos"]=cursor.pos; + d["x_rot"]=cursor.x_rot; + d["y_rot"]=cursor.y_rot; + d["distance"]=cursor.distance; + d["use_environment"]=camera->get_environment().is_valid(); + d["use_orthogonal"]=camera->get_projection()==Camera::PROJECTION_ORTHOGONAL; + return d; +} + + +void SpatialEditorViewport::_bind_methods(){ + + ObjectTypeDB::bind_method(_MD("_draw"),&SpatialEditorViewport::_draw); + ObjectTypeDB::bind_method(_MD("_smouseenter"),&SpatialEditorViewport::_smouseenter); + ObjectTypeDB::bind_method(_MD("_sinput"),&SpatialEditorViewport::_sinput); + ObjectTypeDB::bind_method(_MD("_menu_option"),&SpatialEditorViewport::_menu_option); + ObjectTypeDB::bind_method(_MD("_toggle_camera_preview"),&SpatialEditorViewport::_toggle_camera_preview); + ObjectTypeDB::bind_method(_MD("_preview_exited_scene"),&SpatialEditorViewport::_preview_exited_scene); + +} + + + + +SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor,EditorNode *p_editor) { + + editor=p_editor; + editor_selection=editor->get_editor_selection();; + undo_redo=editor->get_undo_redo(); + clicked=0; + clicked_includes_current=false; + orthogonal=false; + message_time=0; + + spatial_editor=p_spatial_editor; + Control *c=memnew(Control); + add_child(c); + c->set_area_as_parent_rect(); + viewport = memnew( Viewport ); + c->add_child(viewport); + surface = memnew( Control ); + add_child(surface); + surface->set_area_as_parent_rect(); + camera = memnew(Camera); + camera->set_disable_gizmo(true); + //camera->set_environment(SpatialEditor::get_singleton()->get_viewport_environment()); + viewport->add_child(camera); + camera->make_current(); + surface->set_focus_mode(FOCUS_ALL); + + view_menu = memnew( MenuButton ); + surface->add_child(view_menu); + view_menu->set_pos( Point2(4,4)); + view_menu->set_text("[view]"); + view_menu->set_self_opacity(0.5); + + view_menu->get_popup()->add_item("Top",VIEW_TOP); + view_menu->get_popup()->add_item("Bottom",VIEW_BOTTOM); + view_menu->get_popup()->add_item("Left",VIEW_LEFT); + view_menu->get_popup()->add_item("Right",VIEW_RIGHT); + view_menu->get_popup()->add_item("Front",VIEW_FRONT); + view_menu->get_popup()->add_item("Rear",VIEW_REAR); + view_menu->get_popup()->add_separator(); + view_menu->get_popup()->add_check_item("Perspective",VIEW_PERSPECTIVE); + view_menu->get_popup()->add_check_item("Orthogonal",VIEW_ORTHOGONAL); + view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(VIEW_PERSPECTIVE),true); + view_menu->get_popup()->add_separator(); + view_menu->get_popup()->add_check_item("Environment",VIEW_ENVIRONMENT); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(VIEW_ENVIRONMENT),true); + view_menu->get_popup()->add_separator(); + view_menu->get_popup()->add_item("Selection",VIEW_CENTER_TO_SELECTION); + view_menu->get_popup()->connect("item_pressed",this,"_menu_option"); + + preview_camera = memnew( Button ); + preview_camera->set_toggle_mode(true); + preview_camera->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,90); + preview_camera->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,10); + preview_camera->set_text("preview"); + surface->add_child(preview_camera); + preview_camera->hide(); + preview_camera->connect("toggled",this,"_toggle_camera_preview"); + previewing=NULL; + preview=NULL; + +} + + + + + + + +SpatialEditor *SpatialEditor::singleton=NULL; + +SpatialEditorSelectedItem::~SpatialEditorSelectedItem() { + + if (sbox_instance.is_valid()) + VisualServer::get_singleton()->free(sbox_instance); +} + + +void SpatialEditor::_update_transform_gizmo_view() { + + + Transform xform = gizmo.transform; + +/* + Transform camera_xform = camera->get_transform(); + Vector3 camz = -camera_xform.get_basis().get_axis(2).normalized(); + Vector3 camy = -camera_xform.get_basis().get_axis(1).normalized(); + Plane p(camera_xform.origin,camz); + float gizmo_d = Math::abs( p.distance_to(xform.origin )); + float d0 = camera->unproject_position(camera_xform.origin+camz*gizmo_d).y; + float d1 = camera->unproject_position(camera_xform.origin+camz*gizmo_d+camy).y; + float dd = Math::abs(d0-d1); + if (dd==0) + dd=0.0001; + + gizmo.scale=(60.0/Math::abs(dd)); + Vector3 scale = Vector3(1,1,1) * gizmo.scale; + + //xform.basis.scale(scale); +*/ + xform.basis.scale(GIZMO_SCALE_DEFAULT*Vector3(1,1,1)); + + + for(int i=0;i<3;i++) { + VisualServer::get_singleton()->instance_set_transform(move_gizmo_instance[i], xform ); + VisualServer::get_singleton()->instance_geometry_set_flag(move_gizmo_instance[i],VS::INSTANCE_FLAG_VISIBLE,gizmo.visible && (tool_mode==TOOL_MODE_SELECT || tool_mode==TOOL_MODE_MOVE) ); + VisualServer::get_singleton()->instance_set_transform(rotate_gizmo_instance[i], xform ); + VisualServer::get_singleton()->instance_geometry_set_flag(rotate_gizmo_instance[i],VS::INSTANCE_FLAG_VISIBLE,gizmo.visible && (tool_mode==TOOL_MODE_SELECT || tool_mode==TOOL_MODE_ROTATE) ); + } + +} + +void SpatialEditor::select_gizmo_hilight_axis(int p_axis) { + + + for(int i=0;i<3;i++) { + + move_gizmo[i]->surface_set_material(0,i==p_axis?gizmo_hl:gizmo_color[i]); + rotate_gizmo[i]->surface_set_material(0,(i+3)==p_axis?gizmo_hl:gizmo_color[i]); + } + +} + +void SpatialEditor::update_transform_gizmo() { + + List<Node*> &selection = editor_selection->get_selected_node_list(); + AABB center; + bool first=true; + + Matrix3 gizmo_basis; + bool local_gizmo_coords = transform_menu->get_popup()->is_item_checked( transform_menu->get_popup()->get_item_index(MENU_TRANSFORM_LOCAL_COORDS) ); + + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + Transform xf = se->sp->get_global_transform(); + if (first) { + center.pos=xf.origin; + first=false; + if (local_gizmo_coords) { + gizmo_basis=xf.basis; + gizmo_basis.orthonormalize(); + } + } else { + center.expand_to(xf.origin); + gizmo_basis=Matrix3(); + } +// count++; + } + + Vector3 pcenter = center.pos+center.size*0.5; + gizmo.visible=!first; + gizmo.transform.origin=pcenter; + gizmo.transform.basis=gizmo_basis; + + _update_transform_gizmo_view(); + +} + + +Object *SpatialEditor::_get_editor_data(Object *p_what) { + + Spatial *sp = p_what->cast_to<Spatial>(); + if (!sp) + return NULL; + + + SpatialEditorSelectedItem *si = memnew( SpatialEditorSelectedItem ); + + si->sp=sp; + si->sbox_instance=VisualServer::get_singleton()->instance_create2(selection_box->get_rid(),sp->get_world()->get_scenario()); + VS::get_singleton()->instance_geometry_set_flag(si->sbox_instance,VS::INSTANCE_FLAG_CAST_SHADOW,false); + + RID inst = sp->call("_get_visual_instance_rid"); + +// if (inst.is_valid()) +// si->aabb = VisualServer::get_singleton()->instance_get_base_aabb(inst); + + + if (get_scene()->is_editor_hint()) + editor->call("edit_node",sp); + + + return si; +} + +void SpatialEditor::_generate_selection_box() { + + AABB aabb( Vector3(), Vector3(1,1,1) ); + aabb.grow_by( aabb.get_longest_axis_size()/20.0 ); + + Ref<SurfaceTool> st = memnew( SurfaceTool ); + + st->begin(Mesh::PRIMITIVE_LINES); + for (int i=0;i<12;i++) { + + Vector3 a,b; + aabb.get_edge(i,a,b); + + /*Vector<Vector3> points; + Vector<Color> colors; + points.push_back(a); + points.push_back(b);*/ + + st->add_color( Color(1.0,1.0,0.8,0.8) ); + st->add_vertex(a); + st->add_color( Color(1.0,1.0,0.8,0.4) ); + st->add_vertex(a.linear_interpolate(b,0.2)); + + st->add_color( Color(1.0,1.0,0.8,0.4) ); + st->add_vertex(a.linear_interpolate(b,0.8)); + st->add_color( Color(1.0,1.0,0.8,0.8) ); + st->add_vertex(b); + + } + + Ref<FixedMaterial> mat = memnew( FixedMaterial ); + mat->set_flag(Material::FLAG_UNSHADED,true); + mat->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1)); + mat->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA,true); + mat->set_fixed_flag(FixedMaterial::FLAG_USE_COLOR_ARRAY,true); + st->set_material(mat); + selection_box = st->commit(); +} + + +Dictionary SpatialEditor::get_state() const { + + + Dictionary d; + + + int vc=0; + if (view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT) )) + vc=1; + else if (view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS) )) + vc=2; + else if (view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_3_VIEWPORTS) )) + vc=3; + else if (view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_4_VIEWPORTS) )) + vc=4; + + d["viewport_mode"]=vc; + Array vpdata; + for(int i=0;i<4;i++) { + vpdata.push_back( viewports[i]->get_state() ); + } + + d["viewports"]=vpdata; + + d["default_light"]=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_DEFAULT_LIGHT) );; + d["show_grid"]=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_GRID) );; + d["show_origin"]=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_ORIGIN) );; + d["fov"]=get_fov(); + d["znear"]=get_znear(); + d["zfar"]=get_zfar(); + + return d; +} +void SpatialEditor::set_state(const Dictionary& p_state) { + + Dictionary d = p_state; + + ERR_FAIL_COND(!d.has("viewport_mode")); + ERR_FAIL_COND(!d.has("viewports")); + ERR_FAIL_COND(!d.has("default_light")); + ERR_FAIL_COND(!d.has("show_grid")); + ERR_FAIL_COND(!d.has("show_origin")); + ERR_FAIL_COND(!d.has("fov")); + ERR_FAIL_COND(!d.has("znear")); + ERR_FAIL_COND(!d.has("zfar")); + + int vc = d["viewport_mode"]; + + if (vc==1) + _menu_item_pressed(MENU_VIEW_USE_1_VIEWPORT); + else if (vc==2) + _menu_item_pressed(MENU_VIEW_USE_2_VIEWPORTS); + else if (vc==3) + _menu_item_pressed(MENU_VIEW_USE_3_VIEWPORTS); + else if (vc==4) + _menu_item_pressed(MENU_VIEW_USE_4_VIEWPORTS); + + Array vp = d["viewports"]; + ERR_FAIL_COND(vp.size()>4); + + for(int i=0;i<4;i++) { + viewports[i]->set_state(vp[i]); + } + + + if (d.has("zfar")) + settings_zfar->set_text(d["zfar"]); + if (d.has("znear")) + settings_znear->set_text(d["znear"]); + if (d.has("fov")) + settings_fov->set_text(d["fov"]); + if (d.has("default_light")) { + bool use = d["default_light"]; + + bool existing = light_instance.is_valid(); + if (use!=existing) { + if (existing) { + VisualServer::get_singleton()->free(light_instance); + light_instance=RID(); + } else { + light_instance=VisualServer::get_singleton()->instance_create2(light,get_scene()->get_root()->get_world()->get_scenario()); + VisualServer::get_singleton()->instance_set_transform(light_instance,light_transform); + + } + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_DEFAULT_LIGHT), light_instance.is_valid() ); + } + + } + + if (d.has("show_grid")) { + bool use = d["show_grid"]; + + if (use!=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_GRID))) { + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_GRID), use ); + grid_enabled=use; + } + } + + if (d.has("show_origin")) { + bool use = d["show_origin"]; + + if (use!=view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_ORIGIN))) { + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_ORIGIN), use ); + VisualServer::get_singleton()->instance_geometry_set_flag(origin_instance,VS::INSTANCE_FLAG_VISIBLE,use); + } + } + + + +} + + +void SpatialEditor::edit(Spatial *p_spatial) { + + + if (p_spatial) { + //_validate_selection(); + //if (selected.has(p_spatial->get_instance_ID()) && selected.size()==1) + // return; + //_select(p_spatial->get_instance_ID(),false,true); + + // should become the selection + } + + +} + +void SpatialEditor::_xform_dialog_action() { + + Transform t; + //translation + Vector3 scale; + Vector3 rotate; + Vector3 translate; + + for(int i=0;i<3;i++) { + translate[i]=xform_translate[i]->get_text().to_double(); + rotate[i]=Math::deg2rad(xform_rotate[i]->get_text().to_double()); + scale[i]=xform_scale[i]->get_text().to_double(); + } + + t.origin=translate; + for(int i=0;i<3;i++) { + if (!rotate[i]) + continue; + Vector3 axis; + axis[i]=1.0; + t.basis.rotate(axis,rotate[i]); + } + + for(int i=0;i<3;i++) { + if (scale[i]==1) + continue; + t.basis.set_axis(i,t.basis.get_axis(i)*scale[i]); + } + + + undo_redo->create_action("XForm Dialog"); + + List<Node*> &selection = editor_selection->get_selected_node_list(); + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; + + SpatialEditorSelectedItem *se=editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; + + bool post = xform_type->get_selected()>0; + + Transform tr = sp->get_global_transform(); + if (post) + tr = tr * t; + else { + + tr.basis = t.basis * tr.basis; + tr.origin+=t.origin; + } + + undo_redo->add_do_method(sp,"set_global_transform",tr); + undo_redo->add_undo_method(sp,"set_global_transform",sp->get_global_transform()); + } + undo_redo->commit_action(); +} + +void SpatialEditor::_menu_item_pressed(int p_option) { + + switch(p_option) { + + case MENU_TOOL_SELECT: + case MENU_TOOL_MOVE: + case MENU_TOOL_ROTATE: + case MENU_TOOL_SCALE: { + + for(int i=0;i<4;i++) + tool_button[i]->set_pressed(i==p_option); + tool_mode=(ToolMode)p_option; + + static const char *_mode[]={"Selection Mode.","Translation Mode.","Rotation Mode.","Scale Mode."}; +// set_message(_mode[p_option],3); + update_transform_gizmo(); + + } break; + case MENU_TRANSFORM_USE_SNAP: { + + bool is_checked = transform_menu->get_popup()->is_item_checked( transform_menu->get_popup()->get_item_index(p_option) ); + snap_enabled=!is_checked; + transform_menu->get_popup()->set_item_checked( transform_menu->get_popup()->get_item_index(p_option), snap_enabled ); + } break; + case MENU_TRANSFORM_CONFIGURE_SNAP: { + + snap_dialog->popup_centered(Size2(200,160)); + } break; + case MENU_TRANSFORM_LOCAL_COORDS: { + + bool is_checked = transform_menu->get_popup()->is_item_checked( transform_menu->get_popup()->get_item_index(p_option) ); + transform_menu->get_popup()->set_item_checked( transform_menu->get_popup()->get_item_index(p_option), !is_checked ); + update_transform_gizmo(); + + } break; + case MENU_TRANSFORM_DIALOG: { + + for(int i=0;i<3;i++) { + + + xform_translate[i]->set_text("0"); + xform_rotate[i]->set_text("0"); + xform_scale[i]->set_text("1"); + + } + + xform_dialog->popup_centered(Size2(200,200)); + + } break; + case MENU_VIEW_USE_DEFAULT_LIGHT: { + + bool is_checked = view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(p_option) ); + + if (is_checked) { + VisualServer::get_singleton()->free(light_instance); + light_instance=RID(); + } else { + light_instance=VisualServer::get_singleton()->instance_create2(light,get_scene()->get_root()->get_world()->get_scenario()); + VisualServer::get_singleton()->instance_set_transform(light_instance,light_transform); + } + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(p_option), light_instance.is_valid() ); + + } break; + case MENU_VIEW_USE_1_VIEWPORT: { + + for(int i=1;i<4;i++) { + + viewports[i]->hide(); + } + + viewports[0]->set_area_as_parent_rect(); + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), true ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_3_VIEWPORTS), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_4_VIEWPORTS), false ); + + } break; + case MENU_VIEW_USE_2_VIEWPORTS: { + + for(int i=1;i<4;i++) { + + if (i==1 || i==3) + viewports[i]->hide(); + else + viewports[i]->show(); + + + } + viewports[0]->set_area_as_parent_rect(); + viewports[0]->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_RATIO,0.5); + viewports[2]->set_area_as_parent_rect(); + viewports[2]->set_anchor_and_margin(MARGIN_TOP,ANCHOR_RATIO,0.5); + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), true ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_3_VIEWPORTS), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_4_VIEWPORTS), false ); + + } break; + case MENU_VIEW_USE_3_VIEWPORTS: { + + for(int i=1;i<4;i++) { + + if (i==1) + viewports[i]->hide(); + else + viewports[i]->show(); + } + viewports[0]->set_area_as_parent_rect(); + viewports[0]->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_RATIO,0.5); + viewports[2]->set_area_as_parent_rect(); + viewports[2]->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_RATIO,0.5); + viewports[2]->set_anchor_and_margin(MARGIN_TOP,ANCHOR_RATIO,0.5); + viewports[3]->set_area_as_parent_rect(); + viewports[3]->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_RATIO,0.5); + viewports[3]->set_anchor_and_margin(MARGIN_TOP,ANCHOR_RATIO,0.5); + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_3_VIEWPORTS), true ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_4_VIEWPORTS), false ); + + } break; + case MENU_VIEW_USE_4_VIEWPORTS: { + + for(int i=1;i<4;i++) { + + viewports[i]->show(); + } + viewports[0]->set_area_as_parent_rect(); + viewports[0]->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_RATIO,0.5); + viewports[0]->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_RATIO,0.5); + viewports[1]->set_area_as_parent_rect(); + viewports[1]->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_RATIO,0.5); + viewports[1]->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_RATIO,0.5); + viewports[2]->set_area_as_parent_rect(); + viewports[2]->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_RATIO,0.5); + viewports[2]->set_anchor_and_margin(MARGIN_TOP,ANCHOR_RATIO,0.5); + viewports[3]->set_area_as_parent_rect(); + viewports[3]->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_RATIO,0.5); + viewports[3]->set_anchor_and_margin(MARGIN_TOP,ANCHOR_RATIO,0.5); + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_3_VIEWPORTS), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_USE_4_VIEWPORTS), true ); + + } break; + case MENU_VIEW_DISPLAY_NORMAL: { + + + VisualServer::get_singleton()->scenario_set_debug( get_scene()->get_root()->get_world()->get_scenario(), VisualServer::SCENARIO_DEBUG_DISABLED ); + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_NORMAL), true ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_WIREFRAME), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_OVERDRAW), false ); + + } break; + case MENU_VIEW_DISPLAY_WIREFRAME: { + + VisualServer::get_singleton()->scenario_set_debug( get_scene()->get_root()->get_world()->get_scenario(), VisualServer::SCENARIO_DEBUG_WIREFRAME ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_NORMAL), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_WIREFRAME), true ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_OVERDRAW), false ); + + } break; + case MENU_VIEW_DISPLAY_OVERDRAW: { + + VisualServer::get_singleton()->scenario_set_debug( get_scene()->get_root()->get_world()->get_scenario(), VisualServer::SCENARIO_DEBUG_OVERDRAW ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_NORMAL), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_WIREFRAME), false ); + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_OVERDRAW), true ); + + } break; + case MENU_VIEW_ORIGIN: { + + bool is_checked = view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(p_option) ); + + is_checked=!is_checked; + VisualServer::get_singleton()->instance_geometry_set_flag(origin_instance,VS::INSTANCE_FLAG_VISIBLE,is_checked); + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(p_option), is_checked); + } break; + case MENU_VIEW_GRID: { + + bool is_checked = view_menu->get_popup()->is_item_checked( view_menu->get_popup()->get_item_index(p_option) ); + + grid_enabled=!is_checked; + + view_menu->get_popup()->set_item_checked( view_menu->get_popup()->get_item_index(p_option), grid_enabled ); + + + } break; + case MENU_VIEW_CAMERA_SETTINGS: { + + settings_dialog->popup_centered(Size2(200,160)); + } break; + + } +} + + +void SpatialEditor::_init_indicators() { + + //make sure that the camera indicator is not selectable + light=VisualServer::get_singleton()->light_create( VisualServer::LIGHT_DIRECTIONAL ); + //VisualServer::get_singleton()->light_set_shadow( light, true ); + light_instance=VisualServer::get_singleton()->instance_create2(light,get_scene()->get_root()->get_world()->get_scenario()); + + + light_transform.rotate(Vector3(1,0,0),Math_PI/5.0); + VisualServer::get_singleton()->instance_set_transform(light_instance,light_transform); + + + RID mat = VisualServer::get_singleton()->fixed_material_create(); + VisualServer::get_singleton()->fixed_material_set_flag(mat, VisualServer::FIXED_MATERIAL_FLAG_USE_ALPHA,true); + VisualServer::get_singleton()->fixed_material_set_flag(mat, VisualServer::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY,true); + + + { + + RID indicator_mat = VisualServer::get_singleton()->fixed_material_create(); + VisualServer::get_singleton()->material_set_flag( indicator_mat, VisualServer::MATERIAL_FLAG_UNSHADED, true ); + VisualServer::get_singleton()->material_set_flag( indicator_mat, VisualServer::MATERIAL_FLAG_ONTOP, false ); + VisualServer::get_singleton()->fixed_material_set_flag(indicator_mat, VisualServer::FIXED_MATERIAL_FLAG_USE_ALPHA,true); + VisualServer::get_singleton()->fixed_material_set_flag(indicator_mat, VisualServer::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY,true); + + DVector<Color> grid_colors[3]; + DVector<Vector3> grid_points[3]; + Vector<Color> origin_colors; + Vector<Vector3> origin_points; + + for(int i=0;i<3;i++) { + Vector3 axis; + axis[i]=1; + Vector3 axis_n1; + axis_n1[(i+1)%3]=1; + Vector3 axis_n2; + axis_n2[(i+2)%3]=1; + + origin_colors.push_back(Color(axis.x,axis.y,axis.z)); + origin_colors.push_back(Color(axis.x,axis.y,axis.z)); + origin_points.push_back(axis*4096); + origin_points.push_back(axis*-4096); +#define ORIGIN_GRID_SIZE 25 + + for(int j=-ORIGIN_GRID_SIZE;j<=ORIGIN_GRID_SIZE;j++) { + + + grid_colors[i].push_back(Color(axis.x,axis.y,axis.z,0.2)); + grid_colors[i].push_back(Color(axis.x,axis.y,axis.z,0.2)); + grid_colors[i].push_back(Color(axis.x,axis.y,axis.z,0.2)); + grid_colors[i].push_back(Color(axis.x,axis.y,axis.z,0.2)); + grid_points[i].push_back(axis_n1*ORIGIN_GRID_SIZE+axis_n2*j); + grid_points[i].push_back(-axis_n1*ORIGIN_GRID_SIZE+axis_n2*j); + grid_points[i].push_back(axis_n2*ORIGIN_GRID_SIZE+axis_n1*j); + grid_points[i].push_back(-axis_n2*ORIGIN_GRID_SIZE+axis_n1*j); + + } + + grid[i] = VisualServer::get_singleton()->mesh_create(); + Array d; + d.resize(VS::ARRAY_MAX); + d[VisualServer::ARRAY_VERTEX]=grid_points[i]; + d[VisualServer::ARRAY_COLOR]=grid_colors[i]; + VisualServer::get_singleton()->mesh_add_surface(grid[i],VisualServer::PRIMITIVE_LINES,d); + VisualServer::get_singleton()->mesh_surface_set_material(grid[i],0,indicator_mat); + grid_instance[i] = VisualServer::get_singleton()->instance_create2(grid[i],get_scene()->get_root()->get_world()->get_scenario()); + grid_visible[i]=false; + grid_enable[i]=false; + VisualServer::get_singleton()->instance_geometry_set_flag(grid_instance[i],VS::INSTANCE_FLAG_VISIBLE,false); + VisualServer::get_singleton()->instance_geometry_set_flag(grid_instance[i],VS::INSTANCE_FLAG_CAST_SHADOW,false); + + + } + + origin = VisualServer::get_singleton()->mesh_create(); + Array d; + d.resize(VS::ARRAY_MAX); + d[VisualServer::ARRAY_VERTEX]=origin_points; + d[VisualServer::ARRAY_COLOR]=origin_colors; + + VisualServer::get_singleton()->mesh_add_surface(origin,VisualServer::PRIMITIVE_LINES,d); + VisualServer::get_singleton()->mesh_surface_set_material(origin,0,indicator_mat,true); + + +// origin = VisualServer::get_singleton()->poly_create(); +// VisualServer::get_singleton()->poly_add_primitive(origin,origin_points,Vector<Vector3>(),origin_colors,Vector<Vector3>()); +// VisualServer::get_singleton()->poly_set_material(origin,indicator_mat,true); + origin_instance = VisualServer::get_singleton()->instance_create2(origin,get_scene()->get_root()->get_world()->get_scenario()); + VisualServer::get_singleton()->instance_geometry_set_flag(origin_instance,VS::INSTANCE_FLAG_CAST_SHADOW,false); + + + + VisualServer::get_singleton()->instance_geometry_set_flag(grid_instance[1],VS::INSTANCE_FLAG_VISIBLE,true); + grid_enable[1]=true; + grid_visible[1]=true; + grid_enabled=true; + last_grid_snap=1; + + } + + { + cursor_mesh = VisualServer::get_singleton()->mesh_create(); + DVector<Vector3> cursor_points; + float cs = 0.25; + cursor_points.push_back(Vector3(+cs,0,0)); + cursor_points.push_back(Vector3(-cs,0,0)); + cursor_points.push_back(Vector3(0,+cs,0)); + cursor_points.push_back(Vector3(0,-cs,0)); + cursor_points.push_back(Vector3(0,0,+cs)); + cursor_points.push_back(Vector3(0,0,-cs)); + RID cmat=VisualServer::get_singleton()->fixed_material_create(); + VisualServer::get_singleton()->fixed_material_set_param(cmat,VS::FIXED_MATERIAL_PARAM_DIFFUSE,Color(0,1,1)); + VisualServer::get_singleton()->material_set_flag( cmat, VisualServer::MATERIAL_FLAG_UNSHADED, true ); + VisualServer::get_singleton()->fixed_material_set_flag(cmat, VisualServer::FIXED_MATERIAL_FLAG_USE_ALPHA,true); + VisualServer::get_singleton()->fixed_material_set_flag(cmat, VisualServer::FIXED_MATERIAL_FLAG_USE_COLOR_ARRAY,true); + + Array d; + d.resize(VS::ARRAY_MAX); + d[VS::ARRAY_VERTEX]=cursor_points; + VisualServer::get_singleton()->mesh_add_surface(cursor_mesh,VS::PRIMITIVE_LINES,d); + VisualServer::get_singleton()->mesh_surface_set_material(cursor_mesh,0,cmat,true); + + cursor_instance = VisualServer::get_singleton()->instance_create2(cursor_mesh,get_scene()->get_root()->get_world()->get_scenario()); + VisualServer::get_singleton()->instance_geometry_set_flag(cursor_instance,VS::INSTANCE_FLAG_CAST_SHADOW,false); + + + } + + + { + + //move gizmo + + + gizmo_hl = Ref<FixedMaterial>( memnew( FixedMaterial ) ); + gizmo_hl->set_flag(Material::FLAG_UNSHADED, true); + gizmo_hl->set_flag(Material::FLAG_ONTOP, true); + gizmo_hl->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true); + gizmo_hl->set_parameter(FixedMaterial::PARAM_DIFFUSE,Color(1,1,1,0.4)); + + for(int i=0;i<3;i++) { + + move_gizmo[i]=Ref<Mesh>( memnew( Mesh ) ); + move_gizmo_instance[i]=VS::get_singleton()->instance_create(); + VS::get_singleton()->instance_set_base(move_gizmo_instance[i],move_gizmo[i]->get_rid()); + VS::get_singleton()->instance_set_scenario(move_gizmo_instance[i],get_scene()->get_root()->get_world()->get_scenario()); + VS::get_singleton()->instance_geometry_set_flag(move_gizmo_instance[i],VS::INSTANCE_FLAG_VISIBLE,false); + VS::get_singleton()->instance_geometry_set_flag(move_gizmo_instance[i],VS::INSTANCE_FLAG_DEPH_SCALE,true); + VS::get_singleton()->instance_geometry_set_flag(move_gizmo_instance[i],VS::INSTANCE_FLAG_CAST_SHADOW,false); + + + + rotate_gizmo[i]=Ref<Mesh>( memnew( Mesh ) ); + rotate_gizmo_instance[i]=VS::get_singleton()->instance_create(); + VS::get_singleton()->instance_set_base(rotate_gizmo_instance[i],rotate_gizmo[i]->get_rid()); + VS::get_singleton()->instance_set_scenario(rotate_gizmo_instance[i],get_scene()->get_root()->get_world()->get_scenario()); + VS::get_singleton()->instance_geometry_set_flag(rotate_gizmo_instance[i],VS::INSTANCE_FLAG_VISIBLE,false); + VS::get_singleton()->instance_geometry_set_flag(rotate_gizmo_instance[i],VS::INSTANCE_FLAG_DEPH_SCALE,true); + VS::get_singleton()->instance_geometry_set_flag(rotate_gizmo_instance[i],VS::INSTANCE_FLAG_CAST_SHADOW,false); + + + Ref<FixedMaterial> mat = memnew( FixedMaterial ); + mat->set_flag(Material::FLAG_UNSHADED, true); + mat->set_flag(Material::FLAG_ONTOP, true); + mat->set_fixed_flag(FixedMaterial::FLAG_USE_ALPHA, true); + Color col; + col[i]=1.0; + col.a=0.2; + mat->set_parameter(FixedMaterial::PARAM_DIFFUSE,col); + gizmo_color[i]=mat; + + + + + Vector3 ivec; + ivec[i]=1; + Vector3 nivec; + nivec[(i+1)%3]=1; + nivec[(i+2)%3]=1; + Vector3 ivec2; + ivec2[(i+1)%3]=1; + Vector3 ivec3; + ivec3[(i+2)%3]=1; + + + { + + Ref<SurfaceTool> surftool = memnew( SurfaceTool ); + surftool->begin(Mesh::PRIMITIVE_TRIANGLES); + + //translate + + const int arrow_points=5; + Vector3 arrow[5]={ + nivec*0.0+ivec*0.0, + nivec*0.01+ivec*0.0, + nivec*0.01+ivec*1.0, + nivec*0.1+ivec*1.0, + nivec*0.0+ivec*(1+GIZMO_ARROW_SIZE), + }; + + int arrow_sides=6; + + + for(int i = 0; i < 7 ; i++) { + + + Matrix3 ma(ivec,Math_PI*2*float(i)/arrow_sides); + Matrix3 mb(ivec,Math_PI*2*float(i+1)/arrow_sides); + + + for(int j=0;j<arrow_points-1;j++) { + + Vector3 points[4]={ + ma.xform(arrow[j]), + mb.xform(arrow[j]), + mb.xform(arrow[j+1]), + ma.xform(arrow[j+1]), + }; + surftool->add_vertex(points[0]); + surftool->add_vertex(points[1]); + surftool->add_vertex(points[2]); + + surftool->add_vertex(points[0]); + surftool->add_vertex(points[2]); + surftool->add_vertex(points[3]); + } + + } + + surftool->set_material(mat); + surftool->commit(move_gizmo[i]); + } + + { + + + Ref<SurfaceTool> surftool = memnew( SurfaceTool ); + surftool->begin(Mesh::PRIMITIVE_TRIANGLES); + + Vector3 circle[5]={ + ivec*0.02+ivec2*0.02+ivec2*1.0, + ivec*-0.02+ivec2*0.02+ivec2*1.0, + ivec*-0.02+ivec2*-0.02+ivec2*1.0, + ivec*0.02+ivec2*-0.02+ivec2*1.0, + ivec*0.02+ivec2*0.02+ivec2*1.0, + }; + + + for(int k = 0; k < 33 ; k++) { + + + Matrix3 ma(ivec,Math_PI*2*float(k)/32); + Matrix3 mb(ivec,Math_PI*2*float(k+1)/32); + + + for(int j=0;j<4;j++) { + + Vector3 points[4]={ + ma.xform(circle[j]), + mb.xform(circle[j]), + mb.xform(circle[j+1]), + ma.xform(circle[j+1]), + }; + surftool->add_vertex(points[0]); + surftool->add_vertex(points[1]); + surftool->add_vertex(points[2]); + + surftool->add_vertex(points[0]); + surftool->add_vertex(points[2]); + surftool->add_vertex(points[3]); + } + + } + + surftool->set_material(mat); + surftool->commit(rotate_gizmo[i]); + + } + + + } + } + + + _generate_selection_box(); + + + //get_scene()->get_root_node()->cast_to<EditorNode>()->get_scene_root()->add_child(camera); + + //current_camera=camera; + +} + +void SpatialEditor::_finish_indicators() { + + + VisualServer::get_singleton()->free(origin_instance); + VisualServer::get_singleton()->free(origin); + for(int i=0;i<3;i++) { + VisualServer::get_singleton()->free(grid_instance[i]); + VisualServer::get_singleton()->free(grid[i]); + } + VisualServer::get_singleton()->free(light_instance); + VisualServer::get_singleton()->free(light); + //VisualServer::get_singleton()->free(poly); + //VisualServer::get_singleton()->free(indicators_instance); + //VisualServer::get_singleton()->free(indicators); + + VisualServer::get_singleton()->free(cursor_instance); + VisualServer::get_singleton()->free(cursor_mesh); +} + +void SpatialEditor::_instance_scene() { +#if 0 + EditorNode *en = get_scene()->get_root_node()->cast_to<EditorNode>(); + ERR_FAIL_COND(!en); + String path = en->get_scenes_dock()->get_selected_path(); + if (path=="") { + set_message("No scene selected to instance!"); + return; + } + + undo_redo->create_action("Instance at Cursor"); + + Node* scene = en->request_instance_scene(path); + + if (!scene) { + set_message("Could not instance scene!"); + undo_redo->commit_action(); //bleh + return; + } + + Spatial *s = scene->cast_to<Spatial>(); + if (s) { + + undo_redo->add_do_method(s,"set_global_transform",Transform(Matrix3(),cursor.cursor_pos)); + } + + undo_redo->commit_action(); +#endif +} +/* +void SpatialEditor::_update_selection() { + + + +} +*/ +void SpatialEditor::_unhandled_key_input(InputEvent p_event) { + + if (!is_visible()) + return; + + { + + EditorNode *en = editor; + EditorPlugin *over_plugin = en->get_editor_plugin_over(); + + if (over_plugin && over_plugin->forward_input_event(p_event)) { + + return; //ate the over input event + } + + } + + switch(p_event.type) { + + case InputEvent::KEY: { + + + const InputEventKey &k=p_event.key; + + if (!k.pressed) + break; + + switch(k.scancode) { + + case KEY_Q: _menu_item_pressed(MENU_TOOL_SELECT); break; + case KEY_W: _menu_item_pressed(MENU_TOOL_MOVE); break; + case KEY_E: _menu_item_pressed(MENU_TOOL_ROTATE); break; + case KEY_R: _menu_item_pressed(MENU_TOOL_SCALE); break; + +#if 0 +#endif + } + + } break; + } +} +void SpatialEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_READY) { + + tool_button[SpatialEditor::TOOL_MODE_SELECT]->set_icon( get_icon("ToolSelect","EditorIcons") ); + tool_button[SpatialEditor::TOOL_MODE_MOVE]->set_icon( get_icon("ToolMove","EditorIcons") ); + tool_button[SpatialEditor::TOOL_MODE_ROTATE]->set_icon( get_icon("ToolRotate","EditorIcons") ); + tool_button[SpatialEditor::TOOL_MODE_SCALE]->set_icon( get_icon("ToolScale","EditorIcons") ); + instance_button->set_icon( get_icon("SpatialAdd","EditorIcons") ); + + + view_menu->get_popup()->set_item_icon(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT),get_icon("Panels1","EditorIcons")); + view_menu->get_popup()->set_item_icon(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS),get_icon("Panels2","EditorIcons")); + view_menu->get_popup()->set_item_icon(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_3_VIEWPORTS),get_icon("Panels3","EditorIcons")); + view_menu->get_popup()->set_item_icon(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_4_VIEWPORTS),get_icon("Panels4","EditorIcons")); + + _menu_item_pressed(MENU_VIEW_USE_1_VIEWPORT); + + get_scene()->connect("node_removed",this,"_node_removed"); + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + + gizmos = memnew( SpatialEditorGizmos ); + _init_indicators(); + + } + if (p_what==NOTIFICATION_EXIT_SCENE) { + + _finish_indicators(); + memdelete( gizmos ); + + } +} + +void SpatialEditor::add_control_to_menu_panel(Control *p_control) { + + + hbc_menu->add_child(p_control); +} + +void SpatialEditor::set_can_preview(Camera* p_preview) { + + for(int i=0;i<4;i++) { + viewports[i]->set_can_preview(p_preview); + } +} + +VSplitContainer *SpatialEditor::get_shader_split() { + + return shader_split; +} + +HSplitContainer *SpatialEditor::get_palette_split() { + + return palette_split; +} + + +void SpatialEditor::_request_gizmo(Object* p_obj) { + + Spatial *sp=p_obj->cast_to<Spatial>(); + if (!sp) + return; + if (editor->get_edited_scene() && (sp==editor->get_edited_scene() || sp->get_owner()==editor->get_edited_scene())) { + + Ref<SpatialEditorGizmo> seg = gizmos->get_gizmo(sp); + + if (seg.is_valid()) + sp->set_gizmo(seg); + + for (List<EditorPlugin*>::Element *E=gizmo_plugins.front();E;E=E->next()) { + + if (E->get()->create_spatial_gizmo(sp)) + return; + } + } + +} + +void SpatialEditor::_bind_methods() { + +// ObjectTypeDB::bind_method("_input_event",&SpatialEditor::_input_event); + ObjectTypeDB::bind_method("_unhandled_key_input",&SpatialEditor::_unhandled_key_input); + //ObjectTypeDB::bind_method("_node_removed",&SpatialEditor::_node_removed); + ObjectTypeDB::bind_method("_menu_item_pressed",&SpatialEditor::_menu_item_pressed); + ObjectTypeDB::bind_method("_xform_dialog_action",&SpatialEditor::_xform_dialog_action); + ObjectTypeDB::bind_method("_instance_scene",&SpatialEditor::_instance_scene); +// ObjectTypeDB::bind_method("_update_selection",&SpatialEditor::_update_selection); + ObjectTypeDB::bind_method("_get_editor_data",&SpatialEditor::_get_editor_data); + ObjectTypeDB::bind_method("_request_gizmo",&SpatialEditor::_request_gizmo); + + ADD_SIGNAL( MethodInfo("transform_key_request") ); + +} + +SpatialEditor::SpatialEditor(EditorNode *p_editor) { + + + viewport_environment = Ref<Environment>( memnew( Environment ) ); + undo_redo=p_editor->get_undo_redo(); + VBoxContainer *vbc = this; + + custom_camera=NULL; + singleton=this; + editor=p_editor; + editor_selection=editor->get_editor_selection(); + editor_selection->add_editor_plugin(this); + editor_selection->connect("selection_changed",this,"_update_selection"); + + snap_enabled=false; + tool_mode = TOOL_MODE_SELECT; + + //set_focus_mode(FOCUS_ALL); + + hbc_menu = memnew( HBoxContainer ); + vbc->add_child(hbc_menu); + + + Vector<Variant> button_binds; + button_binds.resize(1); + + tool_button[TOOL_MODE_SELECT] = memnew( ToolButton ); + hbc_menu->add_child( tool_button[TOOL_MODE_SELECT] ); + tool_button[TOOL_MODE_SELECT]->set_toggle_mode(true); + tool_button[TOOL_MODE_SELECT]->set_flat(true); + tool_button[TOOL_MODE_SELECT]->set_pressed(true); + button_binds[0]=MENU_TOOL_SELECT; + tool_button[TOOL_MODE_SELECT]->connect("pressed", this,"_menu_item_pressed",button_binds); + tool_button[TOOL_MODE_SELECT]->set_tooltip("Select Mode (Q)"); + + + tool_button[TOOL_MODE_MOVE] = memnew( ToolButton ); + + hbc_menu->add_child( tool_button[TOOL_MODE_MOVE] ); + tool_button[TOOL_MODE_MOVE]->set_toggle_mode(true); + tool_button[TOOL_MODE_MOVE]->set_flat(true); + button_binds[0]=MENU_TOOL_MOVE; + tool_button[TOOL_MODE_MOVE]->connect("pressed", this,"_menu_item_pressed",button_binds); + tool_button[TOOL_MODE_MOVE]->set_tooltip("Move Mode (W)"); + + tool_button[TOOL_MODE_ROTATE] = memnew( ToolButton ); + hbc_menu->add_child( tool_button[TOOL_MODE_ROTATE] ); + tool_button[TOOL_MODE_ROTATE]->set_toggle_mode(true); + tool_button[TOOL_MODE_ROTATE]->set_flat(true); + button_binds[0]=MENU_TOOL_ROTATE; + tool_button[TOOL_MODE_ROTATE]->connect("pressed", this,"_menu_item_pressed",button_binds); + tool_button[TOOL_MODE_ROTATE]->set_tooltip("Rotate Mode (E)"); + + tool_button[TOOL_MODE_SCALE] = memnew( ToolButton ); + hbc_menu->add_child( tool_button[TOOL_MODE_SCALE] ); + tool_button[TOOL_MODE_SCALE]->set_toggle_mode(true); + tool_button[TOOL_MODE_SCALE]->set_flat(true); + button_binds[0]=MENU_TOOL_SCALE; + tool_button[TOOL_MODE_SCALE]->connect("pressed", this,"_menu_item_pressed",button_binds); + tool_button[TOOL_MODE_SCALE]->set_tooltip("Scale Mode (R)"); + + instance_button = memnew( Button ); + hbc_menu->add_child( instance_button ); + instance_button->set_flat(true); + instance_button->connect("pressed",this,"_instance_scene"); + + VSeparator *vs = memnew( VSeparator ); + hbc_menu->add_child(vs); + + + PopupMenu *p; + + transform_menu = memnew( MenuButton ); + transform_menu->set_text("Transform"); + hbc_menu->add_child( transform_menu ); + + p = transform_menu->get_popup(); + p->add_check_item("Use Snap",MENU_TRANSFORM_USE_SNAP); + p->add_item("Configure Snap..",MENU_TRANSFORM_CONFIGURE_SNAP); + p->add_separator(); + p->add_check_item("Local Coords",MENU_TRANSFORM_LOCAL_COORDS); + //p->set_item_checked(p->get_item_count()-1,true); + p->add_separator(); + p->add_item("Transform Dialog..",MENU_TRANSFORM_DIALOG); + + p->connect("item_pressed", this,"_menu_item_pressed"); + + view_menu = memnew( MenuButton ); + view_menu->set_text("View"); + view_menu->set_pos( Point2( 212,0) ); + hbc_menu->add_child( view_menu ); + + p = view_menu->get_popup(); + + p->add_check_item("Use Default Light",MENU_VIEW_USE_DEFAULT_LIGHT); + p->add_separator(); + + p->add_check_item("1 Viewport",MENU_VIEW_USE_1_VIEWPORT); + p->add_check_item("2 Viewports",MENU_VIEW_USE_2_VIEWPORTS); + p->add_check_item("3 Viewports",MENU_VIEW_USE_3_VIEWPORTS); + p->add_check_item("4 Viewports",MENU_VIEW_USE_4_VIEWPORTS); + p->add_separator(); + + p->add_check_item("Display Normal",MENU_VIEW_DISPLAY_NORMAL); + p->add_check_item("Display Wireframe",MENU_VIEW_DISPLAY_WIREFRAME); + p->add_check_item("Display Overdraw",MENU_VIEW_DISPLAY_OVERDRAW); + p->add_separator(); + p->add_check_item("View Origin",MENU_VIEW_ORIGIN); + p->add_check_item("View Grid",MENU_VIEW_GRID); + p->add_separator(); + p->add_check_item("Settings",MENU_VIEW_CAMERA_SETTINGS ); + + + p->set_item_checked( p->get_item_index(MENU_VIEW_USE_DEFAULT_LIGHT), true ); + p->set_item_checked( p->get_item_index(MENU_VIEW_DISPLAY_NORMAL), true ); + p->set_item_checked( p->get_item_index(MENU_VIEW_ORIGIN), true ); + p->set_item_checked( p->get_item_index(MENU_VIEW_GRID), true ); + + + p->connect("item_pressed", this,"_menu_item_pressed"); + + + /* REST OF MENU */ + + palette_split = memnew( HSplitContainer); + palette_split->set_v_size_flags(SIZE_EXPAND_FILL); + vbc->add_child(palette_split); + + shader_split = memnew( VSplitContainer ); + shader_split->set_h_size_flags(SIZE_EXPAND_FILL); + palette_split->add_child(shader_split); + viewport_base = memnew( Control ); + shader_split->add_child(viewport_base); + viewport_base->set_v_size_flags(SIZE_EXPAND_FILL); + for(int i=0;i<4;i++) { + + viewports[i] = memnew( SpatialEditorViewport(this,editor) ); + viewport_base->add_child(viewports[i]); + } + //vbc->add_child(viewport_base); + + + + + /* SNAP DIALOG */ + + snap_dialog = memnew( ConfirmationDialog ); + snap_dialog->set_title("Snap Settings"); + add_child(snap_dialog); + Label *l = memnew(Label); + l->set_text("Translate Snap:"); + l->set_pos(Point2(5,5)); + snap_dialog->add_child(l); + + snap_translate = memnew( LineEdit ); + snap_translate->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + snap_translate->set_begin( Point2(15,22) ); + snap_translate->set_end( Point2(15,35) ); + snap_translate->set_text("1"); + snap_dialog->add_child(snap_translate); + + l = memnew(Label); + l->set_text("Rotate Snap (deg.):"); + l->set_pos(Point2(5,45)); + snap_dialog->add_child(l); + + snap_rotate = memnew( LineEdit ); + snap_rotate->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + snap_rotate->set_begin( Point2(15,62) ); + snap_rotate->set_end( Point2(15,75) ); + snap_rotate->set_text("5"); + snap_dialog->add_child(snap_rotate); + + + l = memnew(Label); + l->set_text("Scale Snap (%):"); + l->set_pos(Point2(5,85)); + snap_dialog->add_child(l); + + snap_scale = memnew( LineEdit ); + snap_scale->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + snap_scale->set_begin( Point2(15,102) ); + snap_scale->set_end( Point2(15,115) ); + snap_scale->set_text("5"); + snap_dialog->add_child(snap_scale); + + //snap_dialog->get_cancel()->hide(); + + /* SNAP DIALOG */ + + settings_dialog = memnew( ConfirmationDialog ); + settings_dialog->set_title("Viewport Settings"); + add_child(settings_dialog); + l = memnew(Label); + l->set_text("Perspective FOV (deg.):"); + l->set_pos(Point2(5,5)); + settings_dialog->add_child(l); + + settings_fov = memnew( LineEdit ); + settings_fov->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + settings_fov->set_begin( Point2(15,22) ); + settings_fov->set_end( Point2(15,35) ); + settings_fov->set_text(EDITOR_DEF("3d_editor/default_fov",60.0)); + settings_dialog->add_child(settings_fov); + + l = memnew(Label); + l->set_text("View Z-Near"); + l->set_pos(Point2(5,45)); + settings_dialog->add_child(l); + + settings_znear = memnew( LineEdit ); + settings_znear->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + settings_znear->set_begin( Point2(15,62) ); + settings_znear->set_end( Point2(15,75) ); + settings_znear->set_text(EDITOR_DEF("3d_editor/default_z_near",0.1)); + settings_dialog->add_child(settings_znear); + + + l = memnew(Label); + l->set_text("View Z-Far"); + l->set_pos(Point2(5,85)); + settings_dialog->add_child(l); + + settings_zfar = memnew( LineEdit ); + settings_zfar->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + settings_zfar->set_begin( Point2(15,102) ); + settings_zfar->set_end( Point2(15,115) ); + settings_zfar->set_text(EDITOR_DEF("3d_editor/default_z_far",500.0)); + settings_dialog->add_child(settings_zfar); + + //settings_dialog->get_cancel()->hide(); + /* XFORM DIALOG */ + + xform_dialog = memnew( ConfirmationDialog ); + xform_dialog->set_title("Transform Change"); + add_child(xform_dialog); + l = memnew(Label); + l->set_text("Translate:"); + l->set_pos(Point2(5,5)); + xform_dialog->add_child(l); + + for(int i=0;i<3;i++) { + + xform_translate[i] = memnew( LineEdit ); + xform_translate[i]->set_pos( Point2(15+i*60,22) ); + xform_translate[i]->set_size( Size2(50,12 ) ); + xform_dialog->add_child( xform_translate[i] ); + } + + l = memnew(Label); + l->set_text("Rotate (deg.):"); + l->set_pos(Point2(5,45)); + xform_dialog->add_child(l); + + for(int i=0;i<3;i++) { + xform_rotate[i] = memnew( LineEdit ); + xform_rotate[i]->set_pos( Point2(15+i*60,62) ); + xform_rotate[i]->set_size( Size2(50,22 ) ); + xform_dialog->add_child(xform_rotate[i]); + } + + l = memnew(Label); + l->set_text("Scale (ratio):"); + l->set_pos(Point2(5,85)); + xform_dialog->add_child(l); + + for(int i=0;i<3;i++) { + xform_scale[i] = memnew( LineEdit ); + xform_scale[i]->set_pos( Point2(15+i*60,102) ); + xform_scale[i]->set_size( Size2(50,22 ) ); + xform_dialog->add_child(xform_scale[i]); + } + + l = memnew(Label); + l->set_text("Transform Type"); + l->set_pos(Point2(5,125)); + xform_dialog->add_child(l); + + xform_type = memnew( OptionButton ); + xform_type->set_anchor( MARGIN_RIGHT, ANCHOR_END ); + xform_type->set_begin( Point2(15,142) ); + xform_type->set_end( Point2(15,75) ); + xform_type->add_item("Pre"); + xform_type->add_item("Post"); + xform_dialog->add_child(xform_type); + + xform_dialog->connect("confirmed", this,"_xform_dialog_action"); + + scenario_debug=VisualServer::SCENARIO_DEBUG_DISABLED; + + + add_to_group("unhandled_key_input"); + add_to_group("_spatial_editor_group"); +} + +SpatialEditor::~SpatialEditor() { + + +} + + + + +void SpatialEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + + + spatial_editor->show(); + spatial_editor->set_process(true); + //VisualServer::get_singleton()->viewport_set_hide_scenario(editor->get_scene_root()->get_viewport(),false); + spatial_editor->grab_focus(); + + } else { + + spatial_editor->hide(); + spatial_editor->set_process(false); + //VisualServer::get_singleton()->viewport_set_hide_scenario(editor->get_scene_root()->get_viewport(),true); + + } + +} +void SpatialEditorPlugin::edit(Object *p_object) { + + spatial_editor->edit(p_object->cast_to<Spatial>()); +} + +bool SpatialEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("Spatial"); +} + +Dictionary SpatialEditorPlugin::get_state() const { + return spatial_editor->get_state(); +} + +void SpatialEditorPlugin::set_state(const Dictionary& p_state) { + + spatial_editor->set_state(p_state); +} + +void SpatialEditor::snap_cursor_to_plane(const Plane& p_plane) { + +// cursor.pos=p_plane.project(cursor.pos); +} + +void SpatialEditorPlugin::_bind_methods() { + + ObjectTypeDB::bind_method("snap_cursor_to_plane",&SpatialEditorPlugin::snap_cursor_to_plane); + +} + +void SpatialEditorPlugin::snap_cursor_to_plane(const Plane& p_plane) { + + + spatial_editor->snap_cursor_to_plane(p_plane); +} + + + + +SpatialEditorPlugin::SpatialEditorPlugin(EditorNode *p_node) { + + editor=p_node; + spatial_editor = memnew( SpatialEditor(p_node) ); + editor->get_viewport()->add_child(spatial_editor); + spatial_editor->set_area_as_parent_rect(); + spatial_editor->hide(); + spatial_editor->connect("transform_key_request",editor,"_transform_keyed"); + + //spatial_editor->set_process(true); +} + + +SpatialEditorPlugin::~SpatialEditorPlugin() { + +} + + + diff --git a/tools/editor/plugins/spatial_editor_plugin.h b/tools/editor/plugins/spatial_editor_plugin.h new file mode 100644 index 000000000..308590ece --- /dev/null +++ b/tools/editor/plugins/spatial_editor_plugin.h @@ -0,0 +1,467 @@ +/*************************************************************************/ +/* spatial_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SPATIAL_EDITOR_PLUGIN_H +#define SPATIAL_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/3d/visual_instance.h" +#include "scene/gui/panel_container.h" +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class Camera; +class SpatialEditor; +class SpatialEditorGizmos; + +class SpatialEditorGizmo : public SpatialGizmo { + + OBJ_TYPE(SpatialEditorGizmo,SpatialGizmo); +public: + + virtual String get_handle_name(int p_idx) const; + virtual Variant get_handle_value(int p_idx) const; + virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point); + virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false); + + virtual bool intersect_frustum(const Camera *p_camera,const Vector<Plane> &p_frustum); + virtual bool intersect_ray(const Camera *p_camera,const Point2& p_point, Vector3& r_pos, Vector3& r_normal,int *r_gizmo_handle=NULL,bool p_sec_first=false); + SpatialEditorGizmo(); +}; + + +class SpatialEditorViewport : public Control { + + OBJ_TYPE( SpatialEditorViewport, Control ); + + enum { + + VIEW_TOP, + VIEW_BOTTOM, + VIEW_LEFT, + VIEW_RIGHT, + VIEW_FRONT, + VIEW_REAR, + VIEW_CENTER_TO_SELECTION, + VIEW_PERSPECTIVE, + VIEW_ENVIRONMENT, + VIEW_ORTHOGONAL + }; + + void _menu_option(int p_option); + + EditorNode *editor; + EditorSelection *editor_selection; + UndoRedo *undo_redo; + + Button *preview_camera; + + MenuButton *view_menu; + + Control *surface; + Viewport *viewport; + Camera *camera; + bool transforming; + bool orthogonal; + + void _compute_edit(const Point2& p_point); + void _clear_selected(); + void _select_clicked(bool p_append,bool p_single); + void _select(Spatial *p_node, bool p_append,bool p_single); + ObjectID _select_ray(const Point2& p_pos, bool p_append,bool &r_includes_current,int *r_gizmo_handle=NULL,bool p_alt_select=false); + Vector3 _get_ray_pos(const Vector2& p_pos) const; + Vector3 _get_ray(const Vector2& p_pos); + Point2 _point_to_screen(const Vector3& p_point); + Transform _get_camera_transform() const; + int get_selected_count() const; + + Vector3 _get_camera_pos() const; + Vector3 _get_camera_normal() const; + Vector3 _get_screen_to_space(const Vector3& p_vector3); + + void _select_region(); + void _update_selection(); + bool _gizmo_select(const Vector2& p_screenpos,bool p_hilite_only=false); + + + float get_znear() const; + float get_zfar() const; + float get_fov() const; + + ObjectID clicked; + bool clicked_includes_current; + bool clicked_wants_append; + + enum TransformMode { + TRANSFORM_NONE, + TRANSFORM_ROTATE, + TRANSFORM_TRANSLATE, + TRANSFORM_SCALE + + }; + enum TransformPlane { + TRANSFORM_VIEW, + TRANSFORM_X_AXIS, + TRANSFORM_Y_AXIS, + TRANSFORM_Z_AXIS, + }; + + struct EditData { + TransformMode mode; + TransformPlane plane; + Transform original; + Vector3 click_ray; + Vector3 click_ray_pos; + Vector3 center; + Vector3 orig_gizmo_pos; + int edited_gizmo; + Point2 mouse_pos; + bool snap; + Ref<SpatialEditorGizmo> gizmo; + int gizmo_handle; + Variant gizmo_initial_value; + Vector3 gizmo_initial_pos; + } _edit; + + struct Cursor { + + Vector3 cursor_pos; + + Vector3 pos; + float x_rot,y_rot,distance; + bool region_select; + Point2 region_begin,region_end; + + Cursor() { x_rot=y_rot=0; distance=4; region_select=false; } + } cursor; + + String last_message; + String message; + float message_time; + + void set_message(String p_message,float p_time=5); + + // + void _update_camera(); + void _draw(); + + void _smouseenter(); + void _sinput(const InputEvent& p_ie); + SpatialEditor *spatial_editor; + + Camera* previewing; + Camera* preview; + + void _preview_exited_scene(); + void _toggle_camera_preview(bool); +protected: + + void _notification(int p_what); + static void _bind_methods(); +public: + + void set_can_preview(Camera* p_preview); + void set_state(const Dictionary& p_state); + Dictionary get_state() const; + + + + SpatialEditorViewport(SpatialEditor *p_spatial_editor,EditorNode *p_editor); +}; + + + +class SpatialEditorSelectedItem : public Object { + + OBJ_TYPE(SpatialEditorSelectedItem,Object); + +public: + + AABB aabb; + Transform original; // original location when moving + Transform last_xform; // last transform + Spatial *sp; + RID sbox_instance; + + SpatialEditorSelectedItem() { sp=NULL; } + ~SpatialEditorSelectedItem(); +}; + +class SpatialEditor : public VBoxContainer { + + OBJ_TYPE(SpatialEditor, VBoxContainer ); +public: + + enum ToolMode { + + TOOL_MODE_SELECT, + TOOL_MODE_MOVE, + TOOL_MODE_ROTATE, + TOOL_MODE_SCALE + + }; + + +private: + EditorNode *editor; + EditorSelection *editor_selection; + + + + Control *viewport_base; + SpatialEditorViewport *viewports[4]; + VSplitContainer *shader_split; + HSplitContainer *palette_split; + + ///// + + ToolMode tool_mode; + bool orthogonal; + + + VisualServer::ScenarioDebugMode scenario_debug; + + RID light; + RID light_instance; + Transform light_transform; + + + RID origin; + RID origin_instance; + RID grid[3]; + RID grid_instance[3]; + bool grid_visible[3]; //currently visible + float last_grid_snap; + bool grid_enable[3]; //should be always visible if true + bool grid_enabled; + + Ref<Mesh> move_gizmo[3], rotate_gizmo[3]; + RID move_gizmo_instance[3], rotate_gizmo_instance[3]; + Ref<FixedMaterial> gizmo_color[3]; + Ref<FixedMaterial> gizmo_hl; + + + + + Ref<Mesh> selection_box; + RID indicators; + RID indicators_instance; + RID cursor_mesh; + RID cursor_instance; + +/* + struct Selected { + AABB aabb; + Transform original; // original location when moving + Transform last_xform; // last transform + Spatial *sp; + RID poly_instance; + }; + + Map<uint32_t,Selected> selected; +*/ + struct Gizmo { + + bool visible; + float scale; + Transform transform; + } gizmo; + + + + + enum MenuOption { + + MENU_TOOL_SELECT, + MENU_TOOL_MOVE, + MENU_TOOL_ROTATE, + MENU_TOOL_SCALE, + MENU_TRANSFORM_USE_SNAP, + MENU_TRANSFORM_CONFIGURE_SNAP, + MENU_TRANSFORM_LOCAL_COORDS, + MENU_TRANSFORM_DIALOG, + MENU_VIEW_USE_1_VIEWPORT, + MENU_VIEW_USE_2_VIEWPORTS, + MENU_VIEW_USE_3_VIEWPORTS, + MENU_VIEW_USE_4_VIEWPORTS, + MENU_VIEW_USE_DEFAULT_LIGHT, + MENU_VIEW_DISPLAY_NORMAL, + MENU_VIEW_DISPLAY_WIREFRAME, + MENU_VIEW_DISPLAY_OVERDRAW, + MENU_VIEW_ORIGIN, + MENU_VIEW_GRID, + MENU_VIEW_CAMERA_SETTINGS, + + }; + + + Button *tool_button[4]; + Button *instance_button; + + + MenuButton* transform_menu; + MenuButton* view_menu; + + ConfirmationDialog *snap_dialog; + ConfirmationDialog *xform_dialog; + ConfirmationDialog *settings_dialog; + + bool snap_enabled; + LineEdit *snap_translate; + LineEdit *snap_rotate; + LineEdit *snap_scale; + PanelContainer* menu_panel; + + LineEdit *xform_translate[3]; + LineEdit *xform_rotate[3]; + LineEdit *xform_scale[3]; + OptionButton *xform_type; + + LineEdit *settings_fov; + LineEdit *settings_znear; + LineEdit *settings_zfar; + + void _xform_dialog_action(); + void _menu_item_pressed(int p_option); + + HBoxContainer *hbc_menu; + + void _update_transform_gizmo_view(); + +// +// + void _generate_selection_box(); + UndoRedo *undo_redo; + + void _instance_scene(); + void _init_indicators(); + void _finish_indicators(); + + Node *custom_camera; + + Object *_get_editor_data(Object *p_what); + + Ref<Environment> viewport_environment; + + List<EditorPlugin*> gizmo_plugins; + + void _request_gizmo(Object* p_obj); + + static SpatialEditor *singleton; + + SpatialEditorGizmos *gizmos; + SpatialEditor(); + +protected: + + + + + void _notification(int p_what); + //void _input_event(InputEvent p_event); + void _unhandled_key_input(InputEvent p_event); + + static void _bind_methods(); +public: + + + static SpatialEditor *get_singleton() { return singleton; } + void snap_cursor_to_plane(const Plane& p_plane); + + float get_znear() const { return settings_znear->get_text().to_double(); } + float get_zfar() const { return settings_zfar->get_text().to_double(); } + float get_fov() const { return settings_fov->get_text().to_double(); } + + Transform get_gizmo_transform() const { return gizmo.transform; } + bool is_gizmo_visible() const { return gizmo.visible; } + + ToolMode get_tool_mode() const { return tool_mode; } + bool is_snap_enabled() const { return snap_enabled; } + float get_translate_snap() const { return snap_translate->get_text().to_double(); } + float get_rotate_snap() const { return snap_rotate->get_text().to_double(); } + float get_scale_snap() const { return snap_scale->get_text().to_double(); } + + void update_transform_gizmo(); + + void select_gizmo_hilight_axis(int p_axis); + void set_custom_camera(Node *p_camera) { custom_camera=p_camera; } + + void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; } + Dictionary get_state() const; + void set_state(const Dictionary& p_state); + + Ref<Environment> get_viewport_environment() { return viewport_environment; } + + UndoRedo *get_undo_redo() { return undo_redo; } + + void add_gizmo_plugin(EditorPlugin* p_plugin) { gizmo_plugins.push_back(p_plugin); } + + void add_control_to_menu_panel(Control *p_control); + + VSplitContainer *get_shader_split(); + HSplitContainer *get_palette_split(); + + void set_can_preview(Camera* p_preview); + + Camera *get_camera() { return NULL; } + void edit(Spatial *p_spatial); + SpatialEditor(EditorNode *p_editor); + ~SpatialEditor(); +}; + +class SpatialEditorPlugin : public EditorPlugin { + + OBJ_TYPE( SpatialEditorPlugin, EditorPlugin ); + + SpatialEditor *spatial_editor; + EditorNode *editor; +protected: + static void _bind_methods(); +public: + + void snap_cursor_to_plane(const Plane& p_plane); + + SpatialEditor *get_spatial_editor() { return spatial_editor; } + virtual String get_name() const { return "3D"; } + bool has_main_screen() const { return true; } + virtual void make_visible(bool p_visible); + virtual void edit(Object *p_object); + virtual bool handles(Object *p_object) const; + + virtual Dictionary get_state() const; + virtual void set_state(const Dictionary& p_state); + + + SpatialEditorPlugin(EditorNode *p_node); + ~SpatialEditorPlugin(); + +}; + +#endif diff --git a/tools/editor/plugins/sprite_frames_editor_plugin.cpp b/tools/editor/plugins/sprite_frames_editor_plugin.cpp new file mode 100644 index 000000000..a26fab0f9 --- /dev/null +++ b/tools/editor/plugins/sprite_frames_editor_plugin.cpp @@ -0,0 +1,483 @@ +/*************************************************************************/ +/* sprite_frames_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "sprite_frames_editor_plugin.h" + +#include "io/resource_loader.h" +#include "globals.h" +#include "tools/editor/editor_settings.h" + + + + +void SpriteFramesEditor::_input_event(InputEvent p_event) { + + +} + +void SpriteFramesEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_FIXED_PROCESS) { + + } + + if (p_what==NOTIFICATION_ENTER_SCENE) { + load->set_icon( get_icon("Folder","EditorIcons") ); + _delete->set_icon( get_icon("Del","EditorIcons") ); + } + + if (p_what==NOTIFICATION_READY) { + +// NodePath("/root")->connect("node_removed", this,"_node_removed",Vector<Variant>(),true); + } + + if (p_what==NOTIFICATION_DRAW) { + + } +} + +void SpriteFramesEditor::_file_load_request(const DVector<String>& p_path) { + + + List< Ref<Texture> > resources; + + for(int i=0;i<p_path.size();i++) { + + Ref<Texture> resource; + resource = ResourceLoader::load(p_path[i]); + + if (resource.is_null()) { + dialog->set_text("ERROR: Couldn't load frame resource!"); + dialog->set_title("Error!"); + //dialog->get_cancel()->set_text("Close"); + dialog->get_ok()->set_text("Close"); + dialog->popup_centered(Size2(300,60)); + return; ///beh should show an error i guess + } + + resources.push_back(resource); + } + + + if (resources.empty()) { + print_line("added frames!"); + return; + } + + undo_redo->create_action("Add Frame"); + int fc=frames->get_frame_count(); + + for(List< Ref<Texture> >::Element *E=resources.front();E;E=E->next() ) { + + undo_redo->add_do_method(frames,"add_frame",E->get()); + undo_redo->add_undo_method(frames,"remove_frame",fc++); + + } + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + + undo_redo->commit_action(); + print_line("added frames!"); +} + +void SpriteFramesEditor::_load_pressed() { + + loading_scene=false; + + file->clear_filters(); + List<String> extensions; + ResourceLoader::get_recognized_extensions_for_type("Texture",&extensions); + for(int i=0;i<extensions.size();i++) + file->add_filter("*."+extensions[i]); + + file->set_mode(FileDialog::MODE_OPEN_FILES); + + file->popup_centered_ratio(); + +} + + +void SpriteFramesEditor::_item_edited() { + +#if 0 + if (!tree->get_selected()) + return; + + TreeItem *s = tree->get_selected(); + + if (tree->get_selected_column()==0) { + // renamed + String old_name=s->get_metadata(0); + String new_name=s->get_text(0); + if (old_name==new_name) + return; + + if (new_name=="" || new_name.find("\\")!=-1 || new_name.find("/")!=-1 || frames->has_resource(new_name)) { + + s->set_text(0,old_name); + return; + } + + RES samp = frames->get_resource(old_name); + undo_redo->create_action("Rename Resource"); + undo_redo->add_do_method(frames,"remove_resource",old_name); + undo_redo->add_do_method(frames,"add_resource",new_name,samp); + undo_redo->add_undo_method(frames,"remove_resource",new_name); + undo_redo->add_undo_method(frames,"add_resource",old_name,samp); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + + } +#endif + +} + +void SpriteFramesEditor::_delete_confirm_pressed() { + + if (!tree->get_selected()) + return; + + sel-=1; + if (sel<0 && frames->get_frame_count()) + sel=0; + + int to_remove = tree->get_selected()->get_metadata(0); + sel=to_remove; + Ref<Texture> r = frames->get_frame(to_remove); + undo_redo->create_action("Delete Resource"); + undo_redo->add_do_method(frames,"remove_frame",to_remove); + undo_redo->add_undo_method(frames,"add_frame",r,to_remove); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + +} + + +void SpriteFramesEditor::_paste_pressed() { + + Ref<Texture> r=EditorSettings::get_singleton()->get_resource_clipboard(); + if (!r.is_valid()) { + dialog->set_text("Resource clipboard is empty or not a texture!"); + dialog->set_title("Error!"); + //dialog->get_cancel()->set_text("Close"); + dialog->get_ok()->set_text("Close"); + dialog->popup_centered(Size2(300,60)); + return; ///beh should show an error i guess + } + + + undo_redo->create_action("Paste Frame"); + undo_redo->add_do_method(frames,"add_frame",r); + undo_redo->add_undo_method(frames,"remove_frame",frames->get_frame_count()); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + +} + +void SpriteFramesEditor::_empty_pressed() { + + + int from=-1; + + if (tree->get_selected()) { + + from = tree->get_selected()->get_metadata(0); + sel=from; + + } else { + from=frames->get_frame_count(); + } + + + + Ref<Texture> r; + + undo_redo->create_action("Add Empty"); + undo_redo->add_do_method(frames,"add_frame",r,from); + undo_redo->add_undo_method(frames,"remove_frame",from); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + +} + +void SpriteFramesEditor::_up_pressed() { + + if (!tree->get_selected()) + return; + int to_move = tree->get_selected()->get_metadata(0); + if (to_move<1) + return; + + sel=to_move; + sel-=1; + + Ref<Texture> r = frames->get_frame(to_move); + undo_redo->create_action("Delete Resource"); + undo_redo->add_do_method(frames,"set_frame",to_move,frames->get_frame(to_move-1)); + undo_redo->add_do_method(frames,"set_frame",to_move-1,frames->get_frame(to_move)); + undo_redo->add_undo_method(frames,"set_frame",to_move,frames->get_frame(to_move)); + undo_redo->add_undo_method(frames,"set_frame",to_move-1,frames->get_frame(to_move-1)); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + +} + +void SpriteFramesEditor::_down_pressed() { + + if (!tree->get_selected()) + return; + int to_move = tree->get_selected()->get_metadata(0); + if (to_move<0 || to_move>=frames->get_frame_count()-1) + return; + + sel=to_move; + sel+=1; + + Ref<Texture> r = frames->get_frame(to_move); + undo_redo->create_action("Delete Resource"); + undo_redo->add_do_method(frames,"set_frame",to_move,frames->get_frame(to_move+1)); + undo_redo->add_do_method(frames,"set_frame",to_move+1,frames->get_frame(to_move)); + undo_redo->add_undo_method(frames,"set_frame",to_move,frames->get_frame(to_move)); + undo_redo->add_undo_method(frames,"set_frame",to_move+1,frames->get_frame(to_move+1)); + undo_redo->add_do_method(this,"_update_library"); + undo_redo->add_undo_method(this,"_update_library"); + undo_redo->commit_action(); + + + +} + + +void SpriteFramesEditor::_delete_pressed() { + + + if (!tree->get_selected()) + return; + + _delete_confirm_pressed(); //it has undo.. why bother with a dialog.. + /* + dialog->set_title("Confirm..."); + dialog->set_text("Remove Resource '"+tree->get_selected()->get_text(0)+"' ?"); + //dialog->get_cancel()->set_text("Cancel"); + //dialog->get_ok()->show(); + dialog->get_ok()->set_text("Remove"); + dialog->popup_centered(Size2(300,60));*/ + +} + + +void SpriteFramesEditor::_update_library() { + + tree->clear(); + tree->set_hide_root(true); + TreeItem *root = tree->create_item(NULL); + + if (sel>=frames->get_frame_count()) + sel=frames->get_frame_count()-1; + else if (sel<0 && frames->get_frame_count()) + sel=0; + + for(int i=0;i<frames->get_frame_count();i++) { + + TreeItem *ti = tree->create_item(root); + ti->set_cell_mode(0,TreeItem::CELL_MODE_STRING); + ti->set_editable(0,true); + ti->set_selectable(0,true); + + if (frames->get_frame(i).is_null()) { + + ti->set_text(0,"Frame "+itos(i)+" (empty)"); + + } else { + ti->set_text(0,"Frame "+itos(i)); + ti->set_icon(0,frames->get_frame(i)); + } + ti->set_metadata(0,i); + ti->set_icon_max_width(0,96); + if (sel==i) + ti->select(0); + } + + //player->add_resource("default",resource); +} + + + +void SpriteFramesEditor::edit(SpriteFrames* p_frames) { + + frames=p_frames; + + + if (p_frames) { + _update_library(); + } else { + + hide(); + //set_fixed_process(false); + } + +} + + + +void SpriteFramesEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_input_event"),&SpriteFramesEditor::_input_event); + ObjectTypeDB::bind_method(_MD("_load_pressed"),&SpriteFramesEditor::_load_pressed); + ObjectTypeDB::bind_method(_MD("_empty_pressed"),&SpriteFramesEditor::_empty_pressed); + ObjectTypeDB::bind_method(_MD("_item_edited"),&SpriteFramesEditor::_item_edited); + ObjectTypeDB::bind_method(_MD("_delete_pressed"),&SpriteFramesEditor::_delete_pressed); + ObjectTypeDB::bind_method(_MD("_paste_pressed"),&SpriteFramesEditor::_paste_pressed); + ObjectTypeDB::bind_method(_MD("_delete_confirm_pressed"),&SpriteFramesEditor::_delete_confirm_pressed); + ObjectTypeDB::bind_method(_MD("_file_load_request"),&SpriteFramesEditor::_file_load_request); + ObjectTypeDB::bind_method(_MD("_update_library"),&SpriteFramesEditor::_update_library); + ObjectTypeDB::bind_method(_MD("_up_pressed"),&SpriteFramesEditor::_up_pressed); + ObjectTypeDB::bind_method(_MD("_down_pressed"),&SpriteFramesEditor::_down_pressed); +} + +SpriteFramesEditor::SpriteFramesEditor() { + + //add_style_override("panel", get_stylebox("panel","Panel")); + + VBoxContainer *vbc = memnew( VBoxContainer ); + add_child(vbc); + + HBoxContainer *hbc = memnew( HBoxContainer ); + vbc->add_child(hbc); + + load = memnew( Button ); + load->set_tooltip("Load Resource"); + hbc->add_child(load); + + + + + paste = memnew( Button ); + paste->set_text("Paste"); + hbc->add_child(paste); + + empty = memnew( Button ); + empty->set_text("Insert Empty"); + hbc->add_child(empty); + + move_up = memnew( Button ); + move_up->set_text("Up"); + hbc->add_child(move_up); + + move_down = memnew( Button ); + move_down->set_text("Down"); + hbc->add_child(move_down); + + _delete = memnew( Button ); + hbc->add_child(_delete); + + file = memnew( FileDialog ); + add_child(file); + + + tree = memnew( Tree ); + tree->set_columns(2); + tree->set_column_min_width(0,3); + tree->set_column_min_width(1,1); + tree->set_column_expand(0,true); + tree->set_column_expand(1,true); + tree->set_v_size_flags(SIZE_EXPAND_FILL); + + vbc->add_child(tree); + + dialog = memnew( AcceptDialog ); + add_child( dialog ); + + load->connect("pressed", this,"_load_pressed"); + _delete->connect("pressed", this,"_delete_pressed"); + paste->connect("pressed", this,"_paste_pressed"); + empty->connect("pressed", this,"_empty_pressed"); + move_up->connect("pressed", this,"_up_pressed"); + move_down->connect("pressed", this,"_down_pressed"); + file->connect("files_selected", this,"_file_load_request"); + //dialog->connect("confirmed", this,"_delete_confirm_pressed"); + tree->connect("item_edited", this,"_item_edited"); + loading_scene=false; + sel=-1; + +} + + +void SpriteFramesEditorPlugin::edit(Object *p_object) { + + frames_editor->set_undo_redo(&get_undo_redo()); + SpriteFrames * s = p_object->cast_to<SpriteFrames>(); + if (!s) + return; + + frames_editor->edit(s); +} + +bool SpriteFramesEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("SpriteFrames"); +} + +void SpriteFramesEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + frames_editor->show(); +// frames_editor->set_process(true); + } else { + + frames_editor->hide(); +// frames_editor->set_process(false); + } + +} + +SpriteFramesEditorPlugin::SpriteFramesEditorPlugin(EditorNode *p_node) { + + editor=p_node; + frames_editor = memnew( SpriteFramesEditor ); + editor->get_viewport()->add_child(frames_editor); + frames_editor->set_area_as_parent_rect(); +// frames_editor->set_anchor( MARGIN_TOP, Control::ANCHOR_END); +// frames_editor->set_margin( MARGIN_TOP, 120 ); + frames_editor->hide(); + + + +} + + +SpriteFramesEditorPlugin::~SpriteFramesEditorPlugin() +{ +} + + diff --git a/tools/editor/plugins/sprite_frames_editor_plugin.h b/tools/editor/plugins/sprite_frames_editor_plugin.h new file mode 100644 index 000000000..99c6ad486 --- /dev/null +++ b/tools/editor/plugins/sprite_frames_editor_plugin.h @@ -0,0 +1,109 @@ +/*************************************************************************/ +/* sprite_frames_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef SPRITE_FRAMES_EDITOR_PLUGIN_H +#define SPRITE_FRAMES_EDITOR_PLUGIN_H + + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/gui/tree.h" +#include "scene/2d/animated_sprite.h" +#include "scene/gui/file_dialog.h" +#include "scene/gui/dialogs.h" + + +class SpriteFramesEditor : public PanelContainer { + + OBJ_TYPE(SpriteFramesEditor, PanelContainer ); + + Button *load; + Button *_delete; + Button *paste; + Button *empty; + Button *move_up; + Button *move_down; + Tree *tree; + bool loading_scene; + int sel; + + + FileDialog *file; + + AcceptDialog *dialog; + + SpriteFrames *frames; + + + void _load_pressed(); + void _load_scene_pressed(); + void _file_load_request(const DVector<String>& p_path); + void _paste_pressed(); + void _empty_pressed(); + void _delete_pressed(); + void _delete_confirm_pressed(); + void _up_pressed(); + void _down_pressed(); + void _update_library(); + void _item_edited(); + + UndoRedo *undo_redo; + +protected: + void _notification(int p_what); + void _input_event(InputEvent p_event); + static void _bind_methods(); +public: + + void set_undo_redo(UndoRedo *p_undo_redo) {undo_redo=p_undo_redo; } + + void edit(SpriteFrames* p_frames); + SpriteFramesEditor(); +}; + +class SpriteFramesEditorPlugin : public EditorPlugin { + + OBJ_TYPE( SpriteFramesEditorPlugin, EditorPlugin ); + + SpriteFramesEditor *frames_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "SpriteFrames"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + SpriteFramesEditorPlugin(EditorNode *p_node); + ~SpriteFramesEditorPlugin(); + +}; + +#endif // SPRITE_FRAMES_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/stream_editor_plugin.cpp b/tools/editor/plugins/stream_editor_plugin.cpp new file mode 100644 index 000000000..4588c694e --- /dev/null +++ b/tools/editor/plugins/stream_editor_plugin.cpp @@ -0,0 +1,148 @@ +/*************************************************************************/ +/* stream_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "stream_editor_plugin.h" + + + +void StreamEditor::_notification(int p_what) { + + if (p_what==NOTIFICATION_ENTER_SCENE) { + play->set_icon( get_icon("Play","EditorIcons") ); + stop->set_icon( get_icon("Stop","EditorIcons") ); + } + +} +void StreamEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} + +void StreamEditor::_play() { + + node->call("play"); +} + +void StreamEditor::_stop() { + + node->call("stop"); +} + +void StreamEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_play"),&StreamEditor::_play); + ObjectTypeDB::bind_method(_MD("_stop"),&StreamEditor::_stop); + +} + +void StreamEditor::edit(Node *p_stream) { + + node=p_stream; + +} +StreamEditor::StreamEditor() { + + play = memnew( Button ); + + + play->set_anchor_and_margin(MARGIN_LEFT,Control::ANCHOR_END,60); + play->set_anchor_and_margin(MARGIN_RIGHT,Control::ANCHOR_END,40); + play->set_anchor_and_margin(MARGIN_TOP,Control::ANCHOR_BEGIN,0); + play->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_BEGIN,0); + + add_child(play); + + stop = memnew( Button ); + + stop->set_pos(Point2( 35, 5 )); + stop->set_anchor_and_margin(MARGIN_LEFT,Control::ANCHOR_END,30); + stop->set_anchor_and_margin(MARGIN_RIGHT,Control::ANCHOR_END,10); + stop->set_anchor_and_margin(MARGIN_TOP,Control::ANCHOR_BEGIN,0); + stop->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_BEGIN,0); + add_child(stop); + + + play->connect("pressed", this,"_play"); + stop->connect("pressed", this,"_stop"); + +} + + +void StreamEditorPlugin::edit(Object *p_object) { + + stream_editor->edit(p_object->cast_to<Node>()); +} + +bool StreamEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("StreamPlayer") || p_object->is_type("SpatialStreamPlayer"); +} + +void StreamEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + stream_editor->show(); + stream_editor->set_fixed_process(true); + } else { + + stream_editor->hide(); + stream_editor->set_fixed_process(false); + stream_editor->edit(NULL); + } + +} + +StreamEditorPlugin::StreamEditorPlugin(EditorNode *p_node) { + + editor=p_node; + stream_editor = memnew( StreamEditor ); + editor->get_viewport()->add_child(stream_editor); + + stream_editor->set_anchor(MARGIN_LEFT,Control::ANCHOR_END); + stream_editor->set_anchor(MARGIN_RIGHT,Control::ANCHOR_END); + stream_editor->set_margin(MARGIN_LEFT,60); + stream_editor->set_margin(MARGIN_RIGHT,0); + stream_editor->set_margin(MARGIN_TOP,0); + stream_editor->set_margin(MARGIN_BOTTOM,10); + + + stream_editor->hide(); + + + +} + + +StreamEditorPlugin::~StreamEditorPlugin() +{ +} + diff --git a/tools/editor/plugins/stream_editor_plugin.h b/tools/editor/plugins/stream_editor_plugin.h new file mode 100644 index 000000000..d49d15b76 --- /dev/null +++ b/tools/editor/plugins/stream_editor_plugin.h @@ -0,0 +1,83 @@ +/*************************************************************************/ +/* stream_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef STREAM_EDITOR_PLUGIN_H +#define STREAM_EDITOR_PLUGIN_H + + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/audio/stream_player.h" + +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class StreamEditor : public Control { + + OBJ_TYPE(StreamEditor, Control ); + + Button * play; + Button * stop; + + Panel *panel; + Node *node; + + void _play(); + void _stop(); +protected: + void _notification(int p_what); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + void edit(Node *p_stream); + StreamEditor(); +}; + +class StreamEditorPlugin : public EditorPlugin { + + OBJ_TYPE( StreamEditorPlugin, EditorPlugin ); + + StreamEditor *stream_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Stream"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + StreamEditorPlugin(EditorNode *p_node); + ~StreamEditorPlugin(); + +}; + +#endif // STREAM_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/style_box_editor_plugin.cpp b/tools/editor/plugins/style_box_editor_plugin.cpp new file mode 100644 index 000000000..3b537fb5c --- /dev/null +++ b/tools/editor/plugins/style_box_editor_plugin.cpp @@ -0,0 +1,109 @@ +/*************************************************************************/ +/* style_box_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "style_box_editor_plugin.h" + + +void StyleBoxEditor::edit(const Ref<StyleBox>& p_stylebox) { + + if (stylebox.is_valid()) + stylebox->disconnect("changed",this,"_sb_changed"); + stylebox=p_stylebox; + if (p_stylebox.is_valid()) { + preview->add_style_override("panel",stylebox); + stylebox->connect("changed",this,"_sb_changed"); + + } +} + +void StyleBoxEditor::_sb_changed() { + + preview->update(); +} + +void StyleBoxEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_sb_changed",&StyleBoxEditor::_sb_changed); +// ObjectTypeDB::bind_method("_import",&StyleBoxEditor::_import); +// ObjectTypeDB::bind_method("_import_accept",&StyleBoxEditor::_import_accept); +// ObjectTypeDB::bind_method("_preview_text_changed",&StyleBoxEditor::_preview_text_changed); +} + +StyleBoxEditor::StyleBoxEditor() { + + panel = memnew( Panel ); + add_child(panel); + panel->set_area_as_parent_rect(); + + Label *l = memnew( Label ); + l->set_text("StyleBox Preview:"); + l->set_pos(Point2(5,5)); + panel->add_child(l); + + + preview = memnew( Panel ); + panel->add_child(preview); + preview->set_pos(Point2(50,50)); + preview->set_size(Size2(200,100)); + + +} + +void StyleBoxEditorPlugin::edit(Object *p_node) { + + if (p_node && p_node->cast_to<StyleBox>()) { + stylebox_editor->edit( p_node->cast_to<StyleBox>() ); + stylebox_editor->show(); + } else + stylebox_editor->hide(); +} + +bool StyleBoxEditorPlugin::handles(Object *p_node) const{ + + return p_node->is_type("StyleBox"); +} + +void StyleBoxEditorPlugin::make_visible(bool p_visible){ + + if (p_visible) + stylebox_editor->show(); + else + stylebox_editor->hide(); +} + +StyleBoxEditorPlugin::StyleBoxEditorPlugin(EditorNode *p_node) { + + stylebox_editor = memnew( StyleBoxEditor ); + + p_node->get_viewport()->add_child(stylebox_editor); + stylebox_editor->set_area_as_parent_rect(); + stylebox_editor->hide(); + + +} + diff --git a/tools/editor/plugins/style_box_editor_plugin.h b/tools/editor/plugins/style_box_editor_plugin.h new file mode 100644 index 000000000..87f72b3cc --- /dev/null +++ b/tools/editor/plugins/style_box_editor_plugin.h @@ -0,0 +1,82 @@ +/*************************************************************************/ +/* style_box_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef STYLE_BOX_EDITOR_PLUGIN_H +#define STYLE_BOX_EDITOR_PLUGIN_H + +#include "scene/resources/style_box.h" +#include "scene/gui/texture_frame.h" +#include "scene/gui/option_button.h" +#include "tools/editor/editor_node.h" + + +class StyleBoxEditor : public Control { + + OBJ_TYPE( StyleBoxEditor, Control ); + + Panel *panel; + Panel *preview; + + Ref<StyleBox> stylebox; + + void _sb_changed(); + +protected: + + + static void _bind_methods(); +public: + + void edit(const Ref<StyleBox>& p_stylebox); + + StyleBoxEditor(); +}; + + + +class StyleBoxEditorPlugin : public EditorPlugin { + + OBJ_TYPE( StyleBoxEditorPlugin, EditorPlugin ); + + StyleBoxEditor *stylebox_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "StyleBox"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + StyleBoxEditorPlugin(EditorNode *p_node); + +}; + + +#endif // STYLE_BOX_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/theme_editor_plugin.cpp b/tools/editor/plugins/theme_editor_plugin.cpp new file mode 100644 index 000000000..f17ab9449 --- /dev/null +++ b/tools/editor/plugins/theme_editor_plugin.cpp @@ -0,0 +1,696 @@ +/*************************************************************************/ +/* theme_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "version.h" +#include "theme_editor_plugin.h" +#include "os/file_access.h" + +void ThemeEditor::edit(const Ref<Theme>& p_theme) { + + theme=p_theme; + panel->set_theme(p_theme); + +} + +void ThemeEditor::_open_file_dialog() { + + test_file_dialog->popup_centered_ratio(); +} + +void ThemeEditor::_type_menu_cbk(int p_option) { + + + type_edit->set_text( type_menu->get_popup()->get_item_text(p_option) ); +} + +void ThemeEditor::_name_menu_about_to_show() { + + String fromtype=type_edit->get_text(); + List<StringName> names; + + if (popup_mode==POPUP_ADD) { + + switch(type_select->get_selected()) { + + case 0: Theme::get_default()->get_icon_list(fromtype,&names); break; + case 1: Theme::get_default()->get_stylebox_list(fromtype,&names); break; + case 2: Theme::get_default()->get_font_list(fromtype,&names); break; + case 3: Theme::get_default()->get_color_list(fromtype,&names); break; + case 4: Theme::get_default()->get_constant_list(fromtype,&names); break; + } + } else if (popup_mode==POPUP_REMOVE) { + + theme->get_icon_list(fromtype,&names); + theme->get_stylebox_list(fromtype,&names); + theme->get_font_list(fromtype,&names); + theme->get_color_list(fromtype,&names); + theme->get_constant_list(fromtype,&names); + } + + + name_menu->get_popup()->clear(); + + for(List<StringName>::Element *E=names.front();E;E=E->next()) { + + name_menu->get_popup()->add_item(E->get()); + } +} + +void ThemeEditor::_name_menu_cbk(int p_option) { + + name_edit->set_text( name_menu->get_popup()->get_item_text(p_option) ); +} + +struct _TECategory { + + template<class T> + struct RefItem { + + Ref<T> item; + StringName name; + bool operator<(const RefItem<T>& p) const { return item->get_instance_ID() < p.item->get_instance_ID(); } + }; + + template<class T> + struct Item { + + T item; + String name; + bool operator<(const Item<T>& p) const { return name < p.name; } + }; + + + Set<RefItem<StyleBox> > stylebox_items; + Set<RefItem<Font> > font_items; + Set<RefItem<Texture> > icon_items; + + Set<Item<Color> > color_items; + Set<Item<int> > constant_items; + +}; + + +void ThemeEditor::_save_template_cbk(String fname) { + + String filename = file_dialog->get_current_path(); + + Map<String,_TECategory> categories; + + //fill types + List<StringName> type_list; + Theme::get_default()->get_type_list(&type_list); + for (List<StringName>::Element *E=type_list.front();E;E=E->next()) { + categories.insert(E->get(),_TECategory()); + } + + //fill default theme + for(Map<String,_TECategory>::Element *E=categories.front();E;E=E->next() ) { + + _TECategory &tc = E->get(); + + List<StringName> stylebox_list; + Theme::get_default()->get_stylebox_list(E->key(),&stylebox_list); + for (List<StringName>::Element *F=stylebox_list.front();F;F=F->next()) { + _TECategory::RefItem<StyleBox> it; + it.name=F->get(); + it.item=Theme::get_default()->get_stylebox(F->get(),E->key()); + tc.stylebox_items.insert(it); + } + + List<StringName> font_list; + Theme::get_default()->get_font_list(E->key(),&font_list); + for (List<StringName>::Element *F=font_list.front();F;F=F->next()) { + _TECategory::RefItem<Font> it; + it.name=F->get(); + it.item=Theme::get_default()->get_font(F->get(),E->key()); + tc.font_items.insert(it); + } + + List<StringName> icon_list; + Theme::get_default()->get_icon_list(E->key(),&icon_list); + for (List<StringName>::Element *F=icon_list.front();F;F=F->next()) { + _TECategory::RefItem<Texture> it; + it.name=F->get(); + it.item=Theme::get_default()->get_icon(F->get(),E->key()); + tc.icon_items.insert(it); + } + + List<StringName> color_list; + Theme::get_default()->get_color_list(E->key(),&color_list); + for (List<StringName>::Element *F=color_list.front();F;F=F->next()) { + _TECategory::Item<Color> it; + it.name=F->get(); + it.item=Theme::get_default()->get_color(F->get(),E->key()); + tc.color_items.insert(it); + } + + List<StringName> constant_list; + Theme::get_default()->get_constant_list(E->key(),&constant_list); + for (List<StringName>::Element *F=constant_list.front();F;F=F->next()) { + _TECategory::Item<int> it; + it.name=F->get(); + it.item=Theme::get_default()->get_constant(F->get(),E->key()); + tc.constant_items.insert(it); + } + + } + + FileAccess *file = FileAccess::open(filename,FileAccess::WRITE); + if (!file) { + + + ERR_EXPLAIN("Can't save theme to file: "+filename); + return; + } + file->store_line("; ******************* "); + file->store_line("; Template Theme File "); + file->store_line("; ******************* "); + file->store_line("; "); + file->store_line("; Theme Syntax: "); + file->store_line("; ------------- "); + file->store_line("; "); + file->store_line("; Must be placed in section [theme]"); + file->store_line("; "); + file->store_line("; Type.item = [value] "); + file->store_line("; "); + file->store_line("; [value] examples:"); + file->store_line("; "); + file->store_line("; Type.item = 6 ; numeric constant. "); + file->store_line("; Type.item = #FF00FF ; HTML color "); + file->store_line("; Type.item = #55FF00FF ; HTML color with alpha 55."); + file->store_line("; Type.item = icon(image.png) ; icon in a png file (relative to theme file)."); + file->store_line("; Type.item = font(font.xres) ; font in a resource (relative to theme file)."); + file->store_line("; Type.item = sbox(stylebox.xres) ; stylebox in a resource (relative to theme file)."); + file->store_line("; Type.item = sboxf(2,#FF00FF) ; flat stylebox with margin 2."); + file->store_line("; Type.item = sboxf(2,#FF00FF,#FFFFFF) ; flat stylebox with margin 2 and border."); + file->store_line("; Type.item = sboxf(2,#FF00FF,#FFFFFF,#000000) ; flat stylebox with margin 2, light & dark borders."); + file->store_line("; Type.item = sboxt(base.png,2,2,2,2) ; textured stylebox with 3x3 stretch and stretch margins."); + file->store_line("; -Additionally, 4 extra integers can be added to sboxf and sboxt to specify custom padding of contents:"); + file->store_line("; Type.item = sboxt(base.png,2,2,2,2,5,4,2,4) ;"); + file->store_line("; -Order for all is always left, top, right, bottom."); + file->store_line("; "); + file->store_line("; Special values:"); + file->store_line("; Type.item = default ; use the value in the default theme (must exist there)."); + file->store_line("; Type.item = @somebutton_color ; reference to a library value previously defined."); + file->store_line("; "); + file->store_line("; Library Syntax: "); + file->store_line("; --------------- "); + file->store_line("; "); + file->store_line("; Must be placed in section [library], but usage is optional."); + file->store_line("; "); + file->store_line("; item = [value] ; same as Theme, but assign to library."); + file->store_line("; "); + file->store_line("; examples:"); + file->store_line("; "); + file->store_line("; [library]"); + file->store_line("; "); + file->store_line("; default_button_color = #FF00FF"); + file->store_line("; "); + file->store_line("; [theme]"); + file->store_line("; "); + file->store_line("; Button.color = @default_button_color ; used reference."); + file->store_line("; "); + file->store_line("; ******************* "); + file->store_line("; "); + file->store_line("; Template Generated Using: "+String(VERSION_MKSTRING)); + file->store_line("; "); + file->store_line("; "); + file->store_line(""); + file->store_line("[library]"); + file->store_line(""); + file->store_line("; place library stuff here"); + file->store_line(""); + file->store_line("[theme]"); + file->store_line(""); + file->store_line(""); + + //write default theme + for(Map<String,_TECategory>::Element *E=categories.front();E;E=E->next() ) { + + _TECategory &tc = E->get(); + + String underline="; "; + for(int i=0;i<E->key().length();i++) + underline+="*"; + + file->store_line(""); + file->store_line(underline); + file->store_line("; "+E->key()); + file->store_line(underline); + + if (tc.stylebox_items.size()) + file->store_line("\n; StyleBox Items:\n"); + + for (Set<_TECategory::RefItem<StyleBox> >::Element *F=tc.stylebox_items.front();F;F=F->next()) { + + file->store_line(E->key()+"."+F->get().name+" = default"); + } + + if (tc.font_items.size()) + file->store_line("\n; Font Items:\n"); + + for (Set<_TECategory::RefItem<Font> >::Element *F=tc.font_items.front();F;F=F->next()) { + + file->store_line(E->key()+"."+F->get().name+" = default"); + } + + if (tc.icon_items.size()) + file->store_line("\n; Icon Items:\n"); + + for (Set<_TECategory::RefItem<Texture> >::Element *F=tc.icon_items.front();F;F=F->next()) { + + file->store_line(E->key()+"."+F->get().name+" = default"); + } + + if (tc.color_items.size()) + file->store_line("\n; Color Items:\n"); + + for (Set<_TECategory::Item<Color> >::Element *F=tc.color_items.front();F;F=F->next()) { + + file->store_line(E->key()+"."+F->get().name+" = default"); + } + + if (tc.constant_items.size()) + file->store_line("\n; Constant Items:\n"); + + for (Set<_TECategory::Item<int> >::Element *F=tc.constant_items.front();F;F=F->next()) { + + file->store_line(E->key()+"."+F->get().name+" = default"); + } + + } + + file->close(); + memdelete(file); +} + +void ThemeEditor::_dialog_cbk() { + + switch(popup_mode) { + case POPUP_ADD: { + + switch(type_select->get_selected()) { + + case 0: theme->set_icon(name_edit->get_text(),type_edit->get_text(),Ref<Texture>()); break; + case 1: theme->set_stylebox(name_edit->get_text(),type_edit->get_text(),Ref<StyleBox>()); break; + case 2: theme->set_font(name_edit->get_text(),type_edit->get_text(),Ref<Font>()); break; + case 3: theme->set_color(name_edit->get_text(),type_edit->get_text(),Color()); break; + case 4: theme->set_constant(name_edit->get_text(),type_edit->get_text(),0); break; + } + + } break; + case POPUP_CLASS_ADD: { + + StringName fromtype = type_edit->get_text(); + List<StringName> names; + + { + names.clear(); + Theme::get_default()->get_icon_list(fromtype,&names); + for(List<StringName>::Element *E=names.front();E;E=E->next()) { + theme->set_icon(E->get(),fromtype,Theme::get_default()->get_icon(E->get(),fromtype)); + + } + + } + { + names.clear(); + Theme::get_default()->get_stylebox_list(fromtype,&names); + for(List<StringName>::Element *E=names.front();E;E=E->next()) { + theme->set_stylebox(E->get(),fromtype,Theme::get_default()->get_stylebox(E->get(),fromtype)); + + } + + } + { + names.clear(); + Theme::get_default()->get_font_list(fromtype,&names); + for(List<StringName>::Element *E=names.front();E;E=E->next()) { + theme->set_font(E->get(),fromtype,Theme::get_default()->get_font(E->get(),fromtype)); + + } + } + { + names.clear(); + Theme::get_default()->get_color_list(fromtype,&names); + for(List<StringName>::Element *E=names.front();E;E=E->next()) { + theme->set_color(E->get(),fromtype,Theme::get_default()->get_color(E->get(),fromtype)); + + } + } + { + names.clear(); + Theme::get_default()->get_constant_list(fromtype,&names); + for(List<StringName>::Element *E=names.front();E;E=E->next()) { + theme->set_constant(E->get(),fromtype,Theme::get_default()->get_constant(E->get(),fromtype)); + + } + } + } break; + case POPUP_REMOVE: { + switch(type_select->get_selected()) { + + case 0: theme->clear_icon(name_edit->get_text(),type_edit->get_text()); break; + case 1: theme->clear_stylebox(name_edit->get_text(),type_edit->get_text()); break; + case 2: theme->clear_font(name_edit->get_text(),type_edit->get_text()); break; + case 3: theme->clear_color(name_edit->get_text(),type_edit->get_text()); break; + case 4: theme->clear_constant(name_edit->get_text(),type_edit->get_text()); break; + } + + + } break; + } + +} + +void ThemeEditor::_theme_menu_cbk(int p_option) { + + + if (p_option==POPUP_CREATE_TEMPLATE) { + + file_dialog->set_mode(FileDialog::MODE_SAVE_FILE); + file_dialog->set_current_path("custom.theme"); + file_dialog->popup_centered_ratio(); + return; + } + + Ref<Theme> base_theme; + + type_select->show(); + type_select_label->show(); + name_select_label->show(); + name_edit->show(); + name_menu->show(); + + + if (p_option==POPUP_ADD) {//add + + add_del_dialog->set_title("Add Item"); + add_del_dialog->get_ok()->set_text("Add"); + add_del_dialog->popup_centered(Size2(490,85)); + + base_theme=Theme::get_default(); + + } else if (p_option==POPUP_CLASS_ADD) {//add + + add_del_dialog->set_title("Add All Items"); + add_del_dialog->get_ok()->set_text("Add All"); + add_del_dialog->popup_centered(Size2(240,85)); + + base_theme=Theme::get_default(); + + type_select->hide(); + name_select_label->hide(); + type_select_label->hide(); + name_edit->hide(); + name_menu->hide(); + + } else if (p_option==POPUP_REMOVE) { + + add_del_dialog->set_title("Remove Item"); + add_del_dialog->get_ok()->set_text("Remove"); + add_del_dialog->popup_centered(Size2(490,85)); + + base_theme=theme; + + } + popup_mode=p_option; + + ERR_FAIL_COND( theme.is_null() ); + + List<StringName> types; + base_theme->get_type_list(&types); + type_menu->get_popup()->clear();; + + if (p_option==0 || p_option==1) {//add + + List<StringName> new_types; + theme->get_type_list(&new_types); + //uh kind of sucks + for(List<StringName>::Element *F=new_types.front();F;F=F->next()) { + + bool found=false; + for(List<StringName>::Element *E=types.front();E;E=E->next()) { + + if (E->get()==F->get()) { + found=true; + break; + } + } + + if (!found) + types.push_back(F->get()); + } + } + + types.sort(); + + for(List<StringName>::Element *E=types.front();E;E=E->next()) { + + type_menu->get_popup()->add_item( E->get() ); + } + +} + +void ThemeEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_type_menu_cbk",&ThemeEditor::_type_menu_cbk); + ObjectTypeDB::bind_method("_name_menu_about_to_show",&ThemeEditor::_name_menu_about_to_show); + ObjectTypeDB::bind_method("_name_menu_cbk",&ThemeEditor::_name_menu_cbk); + ObjectTypeDB::bind_method("_theme_menu_cbk",&ThemeEditor::_theme_menu_cbk); + ObjectTypeDB::bind_method("_dialog_cbk",&ThemeEditor::_dialog_cbk); + ObjectTypeDB::bind_method("_save_template_cbk",&ThemeEditor::_save_template_cbk); +} + +ThemeEditor::ThemeEditor() { + + Panel *main_panel = memnew( Panel ); + add_child(main_panel); + main_panel->set_area_as_parent_rect(); + panel = memnew( Panel ); + + main_panel->add_child(panel); + panel->set_area_as_parent_rect(); + panel->set_margin( MARGIN_TOP,20 ); + + test_button = memnew( Button ); + test_button->set_pos(Point2(25,25)); + test_button->set_text("Button"); + panel->add_child(test_button); + + test_label = memnew( Label ); + test_label->set_pos(Point2(25,75)); + test_label->set_text("Label"); + panel->add_child(test_label); + + test_menu_button = memnew( MenuButton ); + test_menu_button->set_pos(Point2(25,125)); + test_menu_button->set_text("Menu Button"); + test_menu_button->get_popup()->add_item("Item"); + test_menu_button->get_popup()->add_separator(); + test_menu_button->get_popup()->add_check_item("Check Item"); + test_menu_button->get_popup()->add_check_item("Checked Item"); + test_menu_button->get_popup()->set_item_checked(2,true); + panel->add_child(test_menu_button); + + test_option_button = memnew( OptionButton ); + test_option_button->set_pos(Point2(25,175)); + test_option_button->add_item("OptionButton"); + test_option_button->add_separator(); + test_option_button->add_item("Has"); + test_option_button->add_item("Many"); + test_option_button->add_item("Options"); + panel->add_child(test_option_button); + + test_h_scroll = memnew( HScrollBar ); + test_h_scroll->set_pos( Point2( 25, 225 ) ); + test_h_scroll->set_size( Point2( 150, 5 ) ); + panel->add_child(test_h_scroll); + + line_edit = memnew( LineEdit ); + line_edit->set_pos( Point2( 25, 275 ) ); + line_edit->set_size( Point2( 150, 5 ) ); + line_edit->set_text("Line Edit"); + panel->add_child(line_edit); + + test_v_scroll = memnew( VScrollBar ); + test_v_scroll->set_pos( Point2( 200, 25 ) ); + test_v_scroll->set_size( Point2( 5, 150 ) ); + panel->add_child(test_v_scroll); + + test_tree = memnew(Tree); + test_tree->set_pos( Point2( 300, 25 ) ); + test_tree->set_size( Point2( 200, 200 ) ); + panel->add_child(test_tree); + + + TreeItem *item = test_tree->create_item(); + item->set_editable(0,true); + item->set_text(0,"root"); + item = test_tree->create_item( test_tree->get_root() ); + item->set_cell_mode(0, TreeItem::CELL_MODE_CHECK); + item->set_editable(0,true); + item->set_text(0,"check"); + item = test_tree->create_item( test_tree->get_root() ); + item->set_cell_mode(0, TreeItem::CELL_MODE_RANGE); + item->set_editable(0,true); + item->set_range_config(0,0,20,0.1); + item->set_range(0,2); + item = test_tree->create_item( test_tree->get_root() ); + item->set_cell_mode(0, TreeItem::CELL_MODE_RANGE); + item->set_editable(0,true); + item->set_text(0,"Have,Many,Several,Options!"); + item->set_range(0,2); + + Button *fd_button= memnew( Button ); + fd_button->set_pos(Point2(300,275)); + fd_button->set_text("Open File Dialog"); + panel->add_child(fd_button); + + test_file_dialog = memnew( FileDialog ); + panel->add_child(test_file_dialog); + + fd_button->connect("pressed", this,"_open_file_dialog"); + + theme_menu = memnew( MenuButton ); + theme_menu->set_text("Theme.."); + theme_menu->get_popup()->add_item("Add Item",POPUP_ADD); + theme_menu->get_popup()->add_item("Add Class Items",POPUP_CLASS_ADD); + theme_menu->get_popup()->add_item("Remove Item",POPUP_REMOVE); + theme_menu->get_popup()->add_separator(); + theme_menu->get_popup()->add_item("Create Template",POPUP_CREATE_TEMPLATE); + main_panel->add_child(theme_menu); + theme_menu->set_pos(Point2(5,5)); + theme_menu->get_popup()->connect("item_pressed", this,"_theme_menu_cbk"); + + add_del_dialog = memnew(ConfirmationDialog); + add_del_dialog->hide(); + main_panel->add_child(add_del_dialog); + + + Label *l = memnew( Label ); + l->set_pos( Point2(5,5) ); + l->set_text("Type:"); + add_del_dialog->add_child(l); + dtype_select_label=l; + + + type_edit = memnew( LineEdit ); + type_edit->set_pos(Point2(5,25)); + type_edit->set_size(Point2(150,5)); + add_del_dialog->add_child(type_edit); + type_menu = memnew( MenuButton ); + type_menu->set_pos(Point2(160,25)); + type_menu->set_size(Point2(30,5)); + type_menu->set_text(".."); + add_del_dialog->add_child(type_menu); + + type_menu->get_popup()->connect("item_pressed", this,"_type_menu_cbk"); + + l = memnew( Label ); + l->set_pos( Point2(200,5) ); + l->set_text("Name:"); + add_del_dialog->add_child(l); + name_select_label=l; + + name_edit = memnew( LineEdit ); + name_edit->set_pos(Point2(200,25)); + name_edit->set_size(Point2(150,5)); + add_del_dialog->add_child(name_edit); + name_menu = memnew( MenuButton ); + name_menu->set_pos(Point2(360,25)); + name_menu->set_size(Point2(30,5)); + name_menu->set_text(".."); + + add_del_dialog->add_child(name_menu); + + name_menu->get_popup()->connect("about_to_show", this,"_name_menu_about_to_show"); + name_menu->get_popup()->connect("item_pressed", this,"_name_menu_cbk"); + + type_select_label= memnew( Label ); + type_select_label->set_pos( Point2(400,5) ); + type_select_label->set_text("Data Type:"); + add_del_dialog->add_child(type_select_label); + + type_select = memnew( OptionButton ); + type_select->add_item("Icon"); + type_select->add_item("Style"); + type_select->add_item("Font"); + type_select->add_item("Color"); + type_select->add_item("Constant"); + type_select->set_pos( Point2( 400,25 ) ); + type_select->set_size( Point2( 80,5 ) ); + + + add_del_dialog->add_child(type_select); + + add_del_dialog->get_ok()->connect("pressed", this,"_dialog_cbk"); + + + file_dialog = memnew( FileDialog ); + file_dialog->add_filter("*.theme ; Theme File"); + add_child(file_dialog); + file_dialog->connect("file_selected",this,"_save_template_cbk"); + + //MenuButton *name_menu; + //LineEdit *name_edit; + +} + +void ThemeEditorPlugin::edit(Object *p_node) { + + if (p_node && p_node->cast_to<Theme>()) { + theme_editor->edit( p_node->cast_to<Theme>() ); + theme_editor->show(); + } else + theme_editor->hide(); +} + +bool ThemeEditorPlugin::handles(Object *p_node) const{ + + return p_node->is_type("Theme"); +} + +void ThemeEditorPlugin::make_visible(bool p_visible){ + + if (p_visible) + theme_editor->show(); + else + theme_editor->hide(); +} + +ThemeEditorPlugin::ThemeEditorPlugin(EditorNode *p_node) { + + theme_editor = memnew( ThemeEditor ); + + p_node->get_viewport()->add_child(theme_editor); + theme_editor->set_area_as_parent_rect(); + theme_editor->hide(); + +} + diff --git a/tools/editor/plugins/theme_editor_plugin.h b/tools/editor/plugins/theme_editor_plugin.h new file mode 100644 index 000000000..a52173095 --- /dev/null +++ b/tools/editor/plugins/theme_editor_plugin.h @@ -0,0 +1,122 @@ +/*************************************************************************/ +/* theme_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef THEME_EDITOR_PLUGIN_H +#define THEME_EDITOR_PLUGIN_H + +#include "scene/resources/theme.h" +#include "scene/gui/texture_frame.h" +#include "scene/gui/option_button.h" +#include "scene/gui/file_dialog.h" + +#include "tools/editor/editor_node.h" + + + +class ThemeEditor : public Control { + + OBJ_TYPE( ThemeEditor, Control ); + + Panel *panel; + + Ref<Theme> theme; + + FileDialog *file_dialog; + + Button *test_button; + Label *test_label; + MenuButton *test_menu_button; + OptionButton *test_option_button; + HScrollBar *test_h_scroll; + VScrollBar *test_v_scroll; + LineEdit *line_edit; + FileDialog *test_file_dialog; + + + MenuButton *theme_menu; + ConfirmationDialog *add_del_dialog; + MenuButton *type_menu; + LineEdit *type_edit; + MenuButton *name_menu; + LineEdit *name_edit; + OptionButton *type_select; + Label * type_select_label; + Label * name_select_label; + Label * dtype_select_label; + + enum PopupMode { + POPUP_ADD, + POPUP_CLASS_ADD, + POPUP_REMOVE, + POPUP_CREATE_TEMPLATE + }; + + int popup_mode; + + Tree *test_tree; + + void _save_template_cbk(String fname); + void _dialog_cbk(); + void _type_menu_cbk(int p_option); + void _name_menu_about_to_show(); + void _name_menu_cbk(int p_option); + void _theme_menu_cbk(int p_option); + void _open_file_dialog(); + +protected: + static void _bind_methods(); +public: + + void edit(const Ref<Theme>& p_theme); + + ThemeEditor(); +}; + + + +class ThemeEditorPlugin : public EditorPlugin { + + OBJ_TYPE( ThemeEditorPlugin, EditorPlugin ); + + ThemeEditor *theme_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "Theme"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + ThemeEditorPlugin(EditorNode *p_node); + +}; + + +#endif // THEME_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/tile_map_editor_plugin.cpp b/tools/editor/plugins/tile_map_editor_plugin.cpp new file mode 100644 index 000000000..64ba59abb --- /dev/null +++ b/tools/editor/plugins/tile_map_editor_plugin.cpp @@ -0,0 +1,688 @@ +/*************************************************************************/ +/* tile_map_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "tile_map_editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "os/keyboard.h" + +#include "canvas_item_editor_plugin.h" +#include "os/file_access.h" +#include "tools/editor/editor_settings.h" +#include "os/input.h" + + +void TileMapEditor::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_READY: { + + pane_drag->connect("dragged", this,"_pane_drag"); + mirror_x->set_icon( get_icon("MirrorX","EditorIcons")); + mirror_y->set_icon( get_icon("MirrorY","EditorIcons")); + + } break; + } + +} + +void TileMapEditor::_canvas_mouse_enter() { + + mouse_over=true; + canvas_item_editor->update(); + + +} + +void TileMapEditor::_canvas_mouse_exit() { + + mouse_over=false; + canvas_item_editor->update(); + +} + +int TileMapEditor::get_selected_tile() const { + + TreeItem *item = palette->get_selected(); + if (!item) + return TileMap::INVALID_CELL; + return item->get_metadata(0); +} + +void TileMapEditor::_set_cell(const Point2i& p_pos,int p_value,bool p_flip_h, bool p_flip_v) { + + ERR_FAIL_COND(!node); + + bool prev_flip_h=node->is_cell_x_flipped(p_pos.x,p_pos.y); + bool prev_flip_v=node->is_cell_y_flipped(p_pos.x,p_pos.y); + int prev_val=node->get_cell(p_pos.x,p_pos.y); + + if (p_value==prev_val && p_flip_h==prev_flip_h && p_flip_v==prev_flip_v) + return; //check that it's actually different + + node->set_cell(p_pos.x,p_pos.y,p_value,p_flip_h,p_flip_v); + +#if 0 +//not yet + undo_redo->create_action("Set Tile"); + undo_redo->add_do_method(node,"set_cell",p_pos.x,p_pos.y,p_value,p_flip_h,p_flip_v); + undo_redo->add_undo_method(node,"set_cell",p_pos.x,p_pos.y,prev_val,prev_flip_h,prev_flip_v); + undo_redo->commit_action(); +#endif + +} + +void TileMapEditor::_update_palette() { + + if (!node) + return; + + palette->clear();; + + Ref<TileSet> tileset=node->get_tileset(); + if (!tileset.is_valid()) + return; + + + TreeItem *root = palette->create_item(); + palette->set_hide_root(true); + List<int> tiles; + tileset->get_tile_list(&tiles); + + for(List<int>::Element *E=tiles.front();E;E=E->next()) { + + TreeItem *tile = palette->create_item(root); + + tile->set_icon_max_width(0,64); + Ref<Texture> tex = tileset->tile_get_texture(E->get()); + if (tex.is_valid()) { + tile->set_icon(0,tex); + Rect2 region = tileset->tile_get_region(E->get()); + if (region!=Rect2()) + tile->set_icon_region(0,region); + + } else if (tileset->tile_get_name(E->get())!="") + tile->set_text(0,tileset->tile_get_name(E->get())); + else + tile->set_text(0,"#"+itos(E->get())); + + tile->set_metadata(0,E->get()); + + } +} + +void TileMapEditor::_node_removed(Node *p_node) { + + if(p_node==node) { + node=NULL; + hide(); + } + +} +void TileMapEditor::_menu_option(int p_option) { + + switch(p_option) { + + + } +} + +struct _TileMapEditorCopyData { + Point2i pos; + int cell; + bool flip_h; + bool flip_v; +}; + +bool TileMapEditor::forward_input_event(const InputEvent& p_event) { + + if (!node || !node->get_tileset().is_valid()) + return false; + + Matrix32 xform = CanvasItemEditor::get_singleton()->get_canvas_transform() * node->get_global_transform(); + Matrix32 xform_inv = xform.affine_inverse(); + Vector2 snap = Vector2(1,1)*node->get_cell_size(); + + + switch(p_event.type) { + + case InputEvent::MOUSE_BUTTON: { + + const InputEventMouseButton &mb=p_event.mouse_button; + + if (mb.button_index==BUTTON_LEFT) { + + + if (mb.pressed && tool==TOOL_DUPLICATING) { + + + List<_TileMapEditorCopyData> dupdata; + Point2 ofs = over_tile-selection.pos; + + for(int i=selection.pos.y;i<=selection.pos.y+selection.size.y;i++) { + + for(int j=selection.pos.x;j<=selection.pos.x+selection.size.x;j++) { + + _TileMapEditorCopyData tcd; + tcd.pos=Point2i(j,i); + tcd.cell=node->get_cell(j,i); + tcd.flip_h=node->is_cell_x_flipped(j,i); + tcd.flip_v=node->is_cell_y_flipped(j,i); + dupdata.push_back(tcd); + + + } + } + + for (List<_TileMapEditorCopyData>::Element *E=dupdata.front();E;E=E->next()) { + + + _set_cell(E->get().pos+ofs,E->get().cell,E->get().flip_h,E->get().flip_v); + } + + tool=TOOL_NONE; + canvas_item_editor->update(); + selection.pos=over_tile; + + } else if (mb.pressed && tool==TOOL_NONE) { + + if (Input::get_singleton()->is_key_pressed(KEY_SPACE)) + return false; //drag + if (mb.mod.shift) { + + tool=TOOL_SELECTING; + selection_begin =(xform_inv.xform(Point2(mb.x,mb.y))/snap).floor(); + selection.pos=selection_begin; + selection.size=Point2(0,0); + selection_active=true; + canvas_item_editor->update(); + return true; + + } else { + int id = get_selected_tile(); + if (id!=TileMap::INVALID_CELL) { + tool=TOOL_PAINTING; + Point2i local =(xform_inv.xform(Point2(mb.x,mb.y))/snap).floor(); + paint_undo.clear(); + CellOp op; + op.idx = node->get_cell(local.x,local.y); + if (op.idx>=0) { + if (node->is_cell_x_flipped(local.x,local.y)) + op.xf=true; + if (node->is_cell_y_flipped(local.x,local.y)) + op.yf=true; + } + paint_undo[local]=op; + node->set_cell(local.x,local.y,id,mirror_x->is_pressed(),mirror_y->is_pressed()); + return true; + } + } + } else { + + if (tool==TOOL_PAINTING || tool == TOOL_SELECTING) { + + if (tool==TOOL_PAINTING) { + + if (paint_undo.size()) { + undo_redo->create_action("Paint TileMap"); + for(Map<Point2i,CellOp>::Element *E=paint_undo.front();E;E=E->next()) { + + Point2i p=E->key(); + undo_redo->add_do_method(node,"set_cell",p.x,p.y,node->get_cell(p.x,p.y),node->is_cell_x_flipped(p.x,p.y),node->is_cell_y_flipped(p.x,p.y)); + undo_redo->add_undo_method(node,"set_cell",p.x,p.y,E->get().idx,E->get().xf,E->get().yf); + } + + undo_redo->commit_action(); + } + } + tool=TOOL_NONE; + return true; + } + } + } + + if (mb.button_index==BUTTON_RIGHT) { + + if (mb.pressed && tool==TOOL_DUPLICATING) { + + tool=TOOL_NONE; + canvas_item_editor->update(); + } else if (mb.pressed && tool==TOOL_NONE) { + + tool=TOOL_ERASING; + Point2i local =(xform_inv.xform(Point2(mb.x,mb.y))/snap).floor(); + _set_cell(local,TileMap::INVALID_CELL); + return true; + } else { + + if (tool==TOOL_ERASING) { + + tool=TOOL_NONE; + return true; + } + } + } + + } break; + case InputEvent::MOUSE_MOTION: { + + const InputEventMouseMotion &mm=p_event.mouse_motion; + + Point2i new_over_tile = (xform_inv.xform(Point2(mm.x,mm.y))/snap).floor(); + if (new_over_tile!=over_tile) { + + over_tile=new_over_tile; + canvas_item_editor->update(); + } + + + + if (tool==TOOL_PAINTING) { + + int id = get_selected_tile(); + if (id!=TileMap::INVALID_CELL) { + + if (!paint_undo.has(over_tile)) { + + CellOp op; + op.idx = node->get_cell(over_tile.x,over_tile.y); + if (op.idx>=0) { + if (node->is_cell_x_flipped(over_tile.x,over_tile.y)) + op.xf=true; + if (node->is_cell_y_flipped(over_tile.x,over_tile.y)) + op.yf=true; + } + paint_undo[over_tile]=op; + } + node->set_cell(over_tile.x,over_tile.y,id,mirror_x->is_pressed(),mirror_y->is_pressed()); + + return true; + } + } + + if (tool==TOOL_SELECTING) { + + Point2i begin=selection_begin; + Point2i end =over_tile; + + if (begin.x > end.x) { + + SWAP( begin.x, end.x); + } + if (begin.y > end.y) { + + SWAP( begin.y, end.y); + } + + selection.pos=begin; + selection.size=end-begin; + canvas_item_editor->update(); + + return true; + + } + if (tool==TOOL_ERASING) { + Point2i local =over_tile; + _set_cell(local,TileMap::INVALID_CELL); + return true; + } + + + } break; + case InputEvent::KEY: { + + const InputEventKey &k = p_event.key; + if (!node) + break; + + if (k.pressed && k.scancode==KEY_DELETE && selection_active && tool==TOOL_NONE) { + + for(int i=selection.pos.y;i<=selection.pos.y+selection.size.y;i++) { + + for(int j=selection.pos.x;j<=selection.pos.x+selection.size.x;j++) { + + + _set_cell(Point2i(j,i),TileMap::INVALID_CELL); + } + } + + selection_active=false; + canvas_item_editor->update(); + return true; + } + + if (mouse_over && k.pressed && k.scancode==KEY_A && tool==TOOL_NONE) { + + /*int cell = node->get_cell(over_tile.x,over_tile.y); + if (cell!=TileMap::INVALID_CELL) { + bool flip_h = node->is_cell_x_flipped(over_tile.x,over_tile.y); + bool flip_v = node->is_cell_y_flipped(over_tile.x,over_tile.y); + _set_cell(over_tile,cell,!flip_h,flip_v); + }*/ + + mirror_x->set_pressed( ! mirror_x->is_pressed() ); + canvas_item_editor->update(); + return true; + } + if (mouse_over && k.pressed && k.scancode==KEY_S && tool==TOOL_NONE) { + + + /* + int cell = node->get_cell(over_tile.x,over_tile.y); + if (cell!=TileMap::INVALID_CELL) { + + bool flip_h = node->is_cell_x_flipped(over_tile.x,over_tile.y); + bool flip_v = node->is_cell_y_flipped(over_tile.x,over_tile.y); + _set_cell(over_tile,cell,flip_h,!flip_v); + }*/ + + mirror_y->set_pressed( ! mirror_y->is_pressed() ); + canvas_item_editor->update(); + return true; + } + + if (mouse_over && selection_active && k.pressed && k.mod.command && k.scancode==KEY_D && tool==TOOL_NONE) { + + tool=TOOL_DUPLICATING; + canvas_item_editor->update(); + return true; + } + + + + } break; + } + + return false; +} +void TileMapEditor::_canvas_draw() { + + if (!node) + return; + + int cell_size=node->get_cell_size(); + + Matrix32 xform = CanvasItemEditor::get_singleton()->get_canvas_transform() * node->get_global_transform(); + Matrix32 xform_inv = xform.affine_inverse(); + + + Size2 screen_size=canvas_item_editor->get_size(); + Rect2 aabb; + aabb.pos=xform_inv.xform(Vector2()); + aabb.expand_to(xform_inv.xform(Vector2(0,screen_size.height))); + aabb.expand_to(xform_inv.xform(Vector2(screen_size.width,0))); + aabb.expand_to(xform_inv.xform(screen_size)); + Rect2i si=aabb; + + for(int i=(si.pos.x/cell_size)-1;i<=(si.pos.x+si.size.x)/cell_size;i++) { + + int ofs = i*cell_size; + + Color col=i==0?Color(1,0.8,0.2,0.5):Color(1,0.3,0.1,0.2); + canvas_item_editor->draw_line(xform.xform(Point2(ofs,si.pos.y)),xform.xform(Point2(ofs,si.pos.y+si.size.y)),col,1); + + } + + for(int i=(si.pos.y/cell_size)-1;i<=(si.pos.y+si.size.y)/cell_size;i++) { + + int ofs = i*cell_size; + Color col=i==0?Color(1,0.8,0.2,0.5):Color(1,0.3,0.1,0.2); + canvas_item_editor->draw_line(xform.xform(Point2(si.pos.x,ofs)),xform.xform(Point2(si.pos.x+si.size.x,ofs)),col,1); + } + + + if (selection_active) { + + Vector<Vector2> points; + points.push_back( xform.xform( selection.pos * cell_size) ); + points.push_back( xform.xform( (selection.pos+Point2(selection.size.x+1,0)) * cell_size) ); + points.push_back( xform.xform( (selection.pos+Point2(selection.size.x+1,selection.size.y+1)) * cell_size) ); + points.push_back( xform.xform( (selection.pos+Point2(0,selection.size.y+1)) * cell_size) ); + Color col=Color(0.2,0.8,1,0.4); + + canvas_item_editor->draw_colored_polygon(points,col); + } + + + if (mouse_over){ + + const Vector2 endpoints[4]={ + + xform.xform( over_tile * cell_size) , + xform.xform( (over_tile+Point2(1,0)) * cell_size) , + xform.xform( (over_tile+Point2(1,1)) * cell_size) , + xform.xform( (over_tile+Point2(0,1)) * cell_size) , + + + }; + Color col; + if (node->get_cell(over_tile.x,over_tile.y)!=TileMap::INVALID_CELL) + col=Color(0.2,0.8,1.0,0.8); + else + col=Color(1.0,0.4,0.2,0.8); + + for(int i=0;i<4;i++) + canvas_item_editor->draw_line(endpoints[i],endpoints[(i+1)%4],col,2); + + + + if (tool==TOOL_DUPLICATING) { + + Rect2i duplicate=selection; + duplicate.pos=over_tile; + + + Vector<Vector2> points; + points.push_back( xform.xform( duplicate.pos * cell_size) ); + points.push_back( xform.xform( (duplicate.pos+Point2(duplicate.size.x+1,0)) * cell_size) ); + points.push_back( xform.xform( (duplicate.pos+Point2(duplicate.size.x+1,duplicate.size.y+1)) * cell_size) ); + points.push_back( xform.xform( (duplicate.pos+Point2(0,duplicate.size.y+1)) * cell_size) ); + Color col=Color(0.2,1.0,0.8,0.4); + + canvas_item_editor->draw_colored_polygon(points,col); + + } else { + + Ref<TileSet> ts = node->get_tileset(); + + + if (ts.is_valid()) { + + int st = get_selected_tile(); + if (ts->has_tile(st)) { + + Ref<Texture> t = ts->tile_get_texture(st); + if (t.is_valid()) { + Rect2 r = ts->tile_get_region(st); + Size2 sc = (endpoints[2]-endpoints[0])/cell_size; + if (mirror_x->is_pressed()) + sc.x*=-1.0; + if (mirror_y->is_pressed()) + sc.y*=-1.0; + if (r==Rect2()) { + + canvas_item_editor->draw_texture_rect(t,Rect2(endpoints[0],t->get_size()*sc),false,Color(1,1,1,0.5)); + } else { + + canvas_item_editor->draw_texture_rect_region(t,Rect2(endpoints[0],r.get_size()*sc),r,Color(1,1,1,0.5)); + } + } + } + } + + } + } + + + +} + + + +void TileMapEditor::edit(Node *p_tile_map) { + + if (!canvas_item_editor) { + canvas_item_editor=CanvasItemEditor::get_singleton()->get_viewport_control(); + } + + if (p_tile_map) { + + node=p_tile_map->cast_to<TileMap>(); + if (!canvas_item_editor->is_connected("draw",this,"_canvas_draw")) + canvas_item_editor->connect("draw",this,"_canvas_draw"); + if (!canvas_item_editor->is_connected("mouse_enter",this,"_canvas_mouse_enter")) + canvas_item_editor->connect("mouse_enter",this,"_canvas_mouse_enter"); + if (!canvas_item_editor->is_connected("mouse_exit",this,"_canvas_mouse_exit")) + canvas_item_editor->connect("mouse_exit",this,"_canvas_mouse_exit"); + + _update_palette(); + + } else { + node=NULL; + + if (canvas_item_editor->is_connected("draw",this,"_canvas_draw")) + canvas_item_editor->disconnect("draw",this,"_canvas_draw"); + if (canvas_item_editor->is_connected("mouse_enter",this,"_canvas_mouse_enter")) + canvas_item_editor->disconnect("mouse_enter",this,"_canvas_mouse_enter"); + if (canvas_item_editor->is_connected("mouse_exit",this,"_canvas_mouse_exit")) + canvas_item_editor->disconnect("mouse_exit",this,"_canvas_mouse_exit"); + + _update_palette(); + } + + +} + +void TileMapEditor::_pane_drag(const Point2& p_to) { + + int x = theme_panel->get_margin(MARGIN_RIGHT); + + x+=p_to.x; + if (x<10) + x=10; + if (x>300) + x=300; + theme_panel->set_margin(MARGIN_RIGHT,x); +} + +void TileMapEditor::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_menu_option"),&TileMapEditor::_menu_option); + ObjectTypeDB::bind_method(_MD("_canvas_draw"),&TileMapEditor::_canvas_draw); + ObjectTypeDB::bind_method(_MD("_pane_drag"),&TileMapEditor::_pane_drag); + ObjectTypeDB::bind_method(_MD("_canvas_mouse_enter"),&TileMapEditor::_canvas_mouse_enter); + ObjectTypeDB::bind_method(_MD("_canvas_mouse_exit"),&TileMapEditor::_canvas_mouse_exit); + +} + +TileMapEditor::TileMapEditor(EditorNode *p_editor) { + + canvas_item_editor=NULL; + editor=p_editor; + undo_redo = editor->get_undo_redo(); + + theme_panel = memnew( Panel ); + theme_panel->set_anchor(MARGIN_BOTTOM,ANCHOR_END); + theme_panel->set_begin( Point2(0,20)); + theme_panel->set_end( Point2(100,0) ); + p_editor->get_viewport()->add_child(theme_panel); + theme_panel->hide(); + + palette = memnew( Tree ); + palette->set_area_as_parent_rect(4); + palette->set_margin(MARGIN_TOP,25);; + theme_panel->add_child(palette); + + pane_drag = memnew( PaneDrag ) ; + pane_drag->set_anchor(MARGIN_LEFT,ANCHOR_END); + pane_drag->set_begin(Point2(16,4)); + theme_panel->add_child(pane_drag); + + add_child( memnew( VSeparator )); + + mirror_x = memnew( ToolButton ); + mirror_x->set_toggle_mode(true); + mirror_x->set_tooltip("Mirror X (A)"); + mirror_x->set_focus_mode(FOCUS_NONE); + add_child(mirror_x); + mirror_y = memnew( ToolButton ); + mirror_y->set_toggle_mode(true); + mirror_y->set_tooltip("Mirror Y (S)"); + mirror_y->set_focus_mode(FOCUS_NONE); + add_child(mirror_y); + + + tool=TOOL_NONE; + selection_active=false; + mouse_over=false; +} + + +void TileMapEditorPlugin::edit(Object *p_object) { + + tile_map_editor->edit(p_object->cast_to<Node>()); +} + +bool TileMapEditorPlugin::handles(Object *p_object) const { + + return p_object->is_type("TileMap"); +} + +void TileMapEditorPlugin::make_visible(bool p_visible) { + + if (p_visible) { + tile_map_editor->show(); + tile_map_editor->theme_panel->show(); + + } else { + + tile_map_editor->hide(); + tile_map_editor->theme_panel->hide(); + tile_map_editor->edit(NULL); + } + +} + +TileMapEditorPlugin::TileMapEditorPlugin(EditorNode *p_node) { + + editor=p_node; + tile_map_editor = memnew( TileMapEditor(p_node) ); + CanvasItemEditor::get_singleton()->add_control_to_menu_panel(tile_map_editor); + + tile_map_editor->hide(); + + + + +} + + +TileMapEditorPlugin::~TileMapEditorPlugin() +{ +} + diff --git a/tools/editor/plugins/tile_map_editor_plugin.h b/tools/editor/plugins/tile_map_editor_plugin.h new file mode 100644 index 000000000..cd037113b --- /dev/null +++ b/tools/editor/plugins/tile_map_editor_plugin.h @@ -0,0 +1,138 @@ +/*************************************************************************/ +/* tile_map_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef TILE_MAP_EDITOR_PLUGIN_H +#define TILE_MAP_EDITOR_PLUGIN_H + +#include "tools/editor/editor_plugin.h" +#include "tools/editor/editor_node.h" +#include "scene/2d/tile_map.h" +#include "scene/gui/tool_button.h" +#include "scene/gui/button_group.h" +#include "tools/editor/pane_drag.h" +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ +class CanvasItemEditor; + +class TileMapEditor : public HBoxContainer { + + OBJ_TYPE(TileMapEditor, BoxContainer ); + + UndoRedo *undo_redo; + + enum Tool { + + TOOL_NONE, + TOOL_PAINTING, + TOOL_SELECTING, + TOOL_ERASING, + TOOL_DUPLICATING + }; + + Tool tool; + Control *canvas_item_editor; + + Tree *palette; + EditorNode *editor; + Panel *panel; + TileMap *node; + MenuButton *options; + PaneDrag *pane_drag; + + bool selection_active; + Point2i selection_begin; + Rect2i selection; + Point2i over_tile; + bool mouse_over; + + Label *mirror_label; + ToolButton *mirror_x; + ToolButton *mirror_y; + + + struct CellOp { + int idx; + bool xf; + bool yf; + CellOp() { idx=-1; xf=false; yf=false; } + }; + + Map<Point2i,CellOp> paint_undo; + + int get_selected_tile() const; + + void _update_palette(); + void _pane_drag(const Point2& p_to); + void _canvas_draw(); + void _menu_option(int p_option); + + void _set_cell(const Point2i& p_pos,int p_value,bool p_flip_h=false, bool p_flip_v=false); + + void _canvas_mouse_enter(); + void _canvas_mouse_exit(); + + +friend class TileMapEditorPlugin; + Panel *theme_panel; +protected: + void _notification(int p_what); + void _node_removed(Node *p_node); + static void _bind_methods(); +public: + + Vector2 snap_point(const Vector2& p_point) const; + bool forward_input_event(const InputEvent& p_event); + void edit(Node *p_tile_map); + TileMapEditor(EditorNode *p_editor); +}; + +class TileMapEditorPlugin : public EditorPlugin { + + OBJ_TYPE( TileMapEditorPlugin, EditorPlugin ); + + TileMapEditor *tile_map_editor; + EditorNode *editor; + +public: + + virtual bool forward_input_event(const InputEvent& p_event) { return tile_map_editor->forward_input_event(p_event); } + + virtual String get_name() const { return "TileMap"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + TileMapEditorPlugin(EditorNode *p_node); + ~TileMapEditorPlugin(); + +}; + + +#endif // TILE_MAP_EDITOR_PLUGIN_H diff --git a/tools/editor/plugins/tile_set_editor_plugin.cpp b/tools/editor/plugins/tile_set_editor_plugin.cpp new file mode 100644 index 000000000..203233c4a --- /dev/null +++ b/tools/editor/plugins/tile_set_editor_plugin.cpp @@ -0,0 +1,231 @@ +/*************************************************************************/ +/* tile_set_editor_plugin.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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 "tile_set_editor_plugin.h" +#include "scene/2d/sprite.h" +#include "scene/2d/physics_body_2d.h" +void TileSetEditor::edit(const Ref<TileSet>& p_tileset) { + + tileset=p_tileset; +} + +void TileSetEditor::_import_scene(Node *scene, Ref<TileSet> p_library, bool p_merge) { + + if (!p_merge) + p_library->clear(); + + for(int i=0;i<scene->get_child_count();i++) { + + + Node *child = scene->get_child(i); + + if (!child->cast_to<Sprite>()) { + if (child->get_child_count()>0) { + child=child->get_child(0); + if (!child->cast_to<Sprite>()) { + continue; + } + + } else + continue; + + + } + + Sprite *mi = child->cast_to<Sprite>(); + Ref<Texture> texture=mi->get_texture(); + if (texture.is_null()) + continue; + + int id = p_library->find_tile_by_name(mi->get_name()); + if (id<0) { + + id=p_library->get_last_unused_tile_id(); + p_library->create_tile(id); + p_library->tile_set_name(id,mi->get_name()); + } + + + p_library->tile_set_texture(id,texture); + if (mi->is_centered()) { + p_library->tile_set_offset(id,texture->get_size()/2); + } + if (mi->is_region()) { + p_library->tile_set_region(id,mi->get_region_rect()); + } + + Vector<Ref<Shape2D> >collisions; + + for(int j=0;j<mi->get_child_count();j++) { + + Node *child2 = mi->get_child(j); + if (!child2->cast_to<StaticBody2D>()) + continue; + StaticBody2D *sb = child2->cast_to<StaticBody2D>(); + if (sb->get_shape_count()==0) + continue; + Ref<Shape2D> collision=sb->get_shape(0); + if (collision.is_valid()) + collisions.push_back(collision); + } + + if (collisions.size()) { + + p_library->tile_set_shapes(id,collisions); + } + + } +} + +void TileSetEditor::_menu_confirm() { + + switch(option) { + + case MENU_OPTION_REMOVE_ITEM: { + + tileset->remove_tile(to_erase); + } break; + case MENU_OPTION_MERGE_FROM_SCENE: + case MENU_OPTION_CREATE_FROM_SCENE: { + + + EditorNode *en = editor; + Node * scene = en->get_edited_scene(); + if (!scene) + break; + + _import_scene(scene,tileset,option==MENU_OPTION_MERGE_FROM_SCENE); + + + } break; + } +} + +void TileSetEditor::_menu_cbk(int p_option) { + + option=p_option; + switch(p_option) { + + case MENU_OPTION_ADD_ITEM: { + + tileset->create_tile(tileset->get_last_unused_tile_id()); + } break; + case MENU_OPTION_REMOVE_ITEM: { + + String p = editor->get_property_editor()->get_selected_path(); + if (p.begins_with("/TileSet") && p.get_slice_count("/")>=2) { + + to_erase = p.get_slice("/",2).to_int(); + cd->set_text("Remove Item "+itos(to_erase)+"?"); + cd->popup_centered(Size2(300,60)); + } + } break; + case MENU_OPTION_CREATE_FROM_SCENE: { + + cd->set_text("Create from scene?"); + cd->popup_centered(Size2(300,60)); + } break; + case MENU_OPTION_MERGE_FROM_SCENE: { + + cd->set_text("Merge from scene?"); + cd->popup_centered(Size2(300,60)); + } break; + } +} + + + +Error TileSetEditor::update_library_file(Node *p_base_scene, Ref<TileSet> ml,bool p_merge) { + + _import_scene(p_base_scene,ml,p_merge); + return OK; + +} + +void TileSetEditor::_bind_methods() { + + ObjectTypeDB::bind_method("_menu_cbk",&TileSetEditor::_menu_cbk); + ObjectTypeDB::bind_method("_menu_confirm",&TileSetEditor::_menu_confirm); +} + +TileSetEditor::TileSetEditor(EditorNode *p_editor) { + + Panel *panel = memnew( Panel ); + panel->set_area_as_parent_rect(); + add_child(panel); + MenuButton * options = memnew( MenuButton ); + panel->add_child(options); + options->set_pos(Point2(1,1)); + options->set_text("Theme"); + options->get_popup()->add_item("Add Item",MENU_OPTION_ADD_ITEM); + options->get_popup()->add_item("Remove Selected Item",MENU_OPTION_REMOVE_ITEM); + options->get_popup()->add_separator(); + options->get_popup()->add_item("Create from Scene",MENU_OPTION_CREATE_FROM_SCENE); + options->get_popup()->add_item("Merge from Scene",MENU_OPTION_MERGE_FROM_SCENE); + options->get_popup()->connect("item_pressed", this,"_menu_cbk"); + editor=p_editor; + cd = memnew(ConfirmationDialog); + add_child(cd); + cd->get_ok()->connect("pressed", this,"_menu_confirm"); + +} + +void TileSetEditorPlugin::edit(Object *p_node) { + + if (p_node && p_node->cast_to<TileSet>()) { + tileset_editor->edit( p_node->cast_to<TileSet>() ); + tileset_editor->show(); + } else + tileset_editor->hide(); +} + +bool TileSetEditorPlugin::handles(Object *p_node) const{ + + return p_node->is_type("TileSet"); +} + +void TileSetEditorPlugin::make_visible(bool p_visible){ + + if (p_visible) + tileset_editor->show(); + else + tileset_editor->hide(); +} + +TileSetEditorPlugin::TileSetEditorPlugin(EditorNode *p_node) { + + tileset_editor = memnew( TileSetEditor(p_node) ); + + p_node->get_viewport()->add_child(tileset_editor); + tileset_editor->set_area_as_parent_rect(); + tileset_editor->set_anchor( MARGIN_RIGHT, Control::ANCHOR_END ); + tileset_editor->set_anchor( MARGIN_BOTTOM, Control::ANCHOR_BEGIN ); + tileset_editor->set_end( Point2(0,22) ); + tileset_editor->hide(); + +} diff --git a/tools/editor/plugins/tile_set_editor_plugin.h b/tools/editor/plugins/tile_set_editor_plugin.h new file mode 100644 index 000000000..2531ec55b --- /dev/null +++ b/tools/editor/plugins/tile_set_editor_plugin.h @@ -0,0 +1,98 @@ +/*************************************************************************/ +/* tile_set_editor_plugin.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 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. */ +/*************************************************************************/ +#ifndef TILE_SET_EDITOR_PLUGIN_H +#define TILE_SET_EDITOR_PLUGIN_H + + + +#include "scene/resources/tile_set.h" +#include "tools/editor/editor_node.h" + + +class TileSetEditor : public Control { + + OBJ_TYPE( TileSetEditor, Control ); + + Ref<TileSet> tileset; + + EditorNode *editor; + MenuButton *menu; + ConfirmationDialog *cd; + int to_erase; + + enum { + + MENU_OPTION_ADD_ITEM, + MENU_OPTION_REMOVE_ITEM, + MENU_OPTION_CREATE_FROM_SCENE, + MENU_OPTION_MERGE_FROM_SCENE + }; + + int option; + void _menu_cbk(int p_option); + void _menu_confirm(); + + static void _import_scene(Node *p_scene, Ref<TileSet> p_library, bool p_merge); + + +protected: + static void _bind_methods(); +public: + + void edit(const Ref<TileSet>& p_tileset); + static Error update_library_file(Node *p_base_scene, Ref<TileSet> ml,bool p_merge=true); + + TileSetEditor(EditorNode *p_editor); +}; + + + +class TileSetEditorPlugin : public EditorPlugin { + + OBJ_TYPE( TileSetEditorPlugin, EditorPlugin ); + + TileSetEditor *tileset_editor; + EditorNode *editor; + +public: + + virtual String get_name() const { return "TileSet"; } + bool has_main_screen() const { return false; } + virtual void edit(Object *p_node); + virtual bool handles(Object *p_node) const; + virtual void make_visible(bool p_visible); + + + + TileSetEditorPlugin(EditorNode *p_node); + +}; + + +#endif // TILE_SET_EDITOR_PLUGIN_H |