Changed import workflow

-Rearrange favorites in fs dock with drag and drop
-Removed import -> sub-scene, moved to scenetree contextual menu
-Removed import -> re-import , moved and integrated to FS dock
-Added ability in FS dock to re-import more than one resource
simultaneously
-Added ability to drag from native filesystem explorer to Godot, only
works on Windows though
-Removed scene reimport merge options, never worked well. Eventually
merging materials should be re-added
-Added ability to set custom root node type when importing scenes
-Re-Import is now automatic, can be configured back to manual in editor
settings
-Added resource previews in property list for many resource types

12 files changed, 533 insertions, 579 deletions

diff --git a/tools/editor/io_plugins/editor_font_import_plugin.cpp b/tools/editor/io_plugins/editor_font_import_plugin.cpp
index 6ac67ab8a..7cc5b579f 100644
--- a/tools/editor/io_plugins/editor_font_import_plugin.cpp
+++ b/tools/editor/io_plugins/editor_font_import_plugin.cpp
@@ -601,6 +601,13 @@ public:
 		}
 	}
 
+
+	void set_source_and_dest(const String& p_font,const String& p_dest) {
+		source->get_line_edit()->set_text(p_font);
+		dest->get_line_edit()->set_text(p_dest);
+		_prop_changed();
+	}
+
 	EditorFontImportDialog(EditorFontImportPlugin *p_plugin) {
 		plugin=p_plugin;
 		VBoxContainer *vbc = memnew( VBoxContainer );
@@ -1629,6 +1636,20 @@ Error EditorFontImportPlugin::import(const String& p_path, const Ref<ResourceImp
 
 }
 
+void EditorFontImportPlugin::import_from_drop(const Vector<String>& p_drop, const String &p_dest_path) {
+
+	for(int i=0;i<p_drop.size();i++) {
+		String ext = p_drop[i].extension().to_lower();
+		String file = p_drop[i].get_file();
+		if (ext=="ttf" || ext=="otf" || ext=="fnt") {
+
+			import_dialog();
+			dialog->set_source_and_dest(p_drop[i],p_dest_path.plus_file(file.basename()+".fnt"));
+			break;
+		}
+	}
+}
+
 
 EditorFontImportPlugin::EditorFontImportPlugin(EditorNode* p_editor) {
 
diff --git a/tools/editor/io_plugins/editor_font_import_plugin.h b/tools/editor/io_plugins/editor_font_import_plugin.h
index ce26ef91e..25914e6f8 100644
--- a/tools/editor/io_plugins/editor_font_import_plugin.h
+++ b/tools/editor/io_plugins/editor_font_import_plugin.h
@@ -48,6 +48,7 @@ public:
 	virtual String get_visible_name() const;
 	virtual void import_dialog(const String& p_from="");
 	virtual Error import(const String& p_path, const Ref<ResourceImportMetadata>& p_from);
+	virtual void import_from_drop(const Vector<String>& p_drop,const String& p_dest_path);
 
 
 	EditorFontImportPlugin(EditorNode* p_editor);
diff --git a/tools/editor/io_plugins/editor_mesh_import_plugin.cpp b/tools/editor/io_plugins/editor_mesh_import_plugin.cpp
index 9af7d8daa..c77256f27 100644
--- a/tools/editor/io_plugins/editor_mesh_import_plugin.cpp
+++ b/tools/editor/io_plugins/editor_mesh_import_plugin.cpp
@@ -331,7 +331,7 @@ String EditorMeshImportPlugin::get_name() const {
 }
 String EditorMeshImportPlugin::get_visible_name() const{
 
-	return "3D Mesh";
+	return "Mesh";
 }
 void EditorMeshImportPlugin::import_dialog(const String& p_from){
 
@@ -536,6 +536,26 @@ Error EditorMeshImportPlugin::import(const String& p_path, const Ref<ResourceImp
 }
 
 
+void EditorMeshImportPlugin::import_from_drop(const Vector<String>& p_drop, const String &p_dest_path) {
+
+
+	Vector<String> files;
+	for(int i=0;i<p_drop.size();i++) {
+		String ext = p_drop[i].extension().to_lower();
+		String file = p_drop[i].get_file();
+		if (ext=="obj") {
+
+			files.push_back(p_drop[i]);
+		}
+	}
+
+	if (files.size()) {
+		import_dialog();
+		dialog->_choose_files(files);
+		dialog->_choose_save_dir(p_dest_path);
+	}
+}
+
 EditorMeshImportPlugin::EditorMeshImportPlugin(EditorNode* p_editor) {
 
 	dialog = memnew( EditorMeshImportDialog(this));
diff --git a/tools/editor/io_plugins/editor_mesh_import_plugin.h b/tools/editor/io_plugins/editor_mesh_import_plugin.h
index 014954685..ed30d69e1 100644
--- a/tools/editor/io_plugins/editor_mesh_import_plugin.h
+++ b/tools/editor/io_plugins/editor_mesh_import_plugin.h
@@ -21,6 +21,7 @@ public:
 	virtual String get_visible_name() const;
 	virtual void import_dialog(const String& p_from="");
 	virtual Error import(const String& p_path, const Ref<ResourceImportMetadata>& p_from);
+	void import_from_drop(const Vector<String>& p_drop, const String &p_dest_path);
 
 
 	EditorMeshImportPlugin(EditorNode* p_editor);
diff --git a/tools/editor/io_plugins/editor_sample_import_plugin.cpp b/tools/editor/io_plugins/editor_sample_import_plugin.cpp
index c608fe906..631273a87 100644
--- a/tools/editor/io_plugins/editor_sample_import_plugin.cpp
+++ b/tools/editor/io_plugins/editor_sample_import_plugin.cpp
@@ -823,6 +823,58 @@ void EditorSampleImportPlugin::_compress_ima_adpcm(const Vector<float>& p_data,D
 EditorSampleImportPlugin* EditorSampleImportPlugin::singleton=NULL;
 
 
+void EditorSampleImportPlugin::import_from_drop(const Vector<String>& p_drop, const String &p_dest_path) {
+
+
+	Vector<String> files;
+	for(int i=0;i<p_drop.size();i++) {
+		String ext = p_drop[i].extension().to_lower();
+
+		if (ext=="wav") {
+
+			files.push_back(p_drop[i]);
+		}
+	}
+
+	if (files.size()) {
+		import_dialog();
+		dialog->_choose_files(files);
+		dialog->_choose_save_dir(p_dest_path);
+	}
+}
+
+void EditorSampleImportPlugin::reimport_multiple_files(const Vector<String>& p_list) {
+
+	if (p_list.size()==0)
+		return;
+
+	Vector<String> sources;
+	for(int i=0;i<p_list.size();i++) {
+		int idx;
+		EditorFileSystemDirectory *efsd = EditorFileSystem::get_singleton()->find_file(p_list[i],&idx);
+		if (efsd) {
+			for(int j=0;j<efsd->get_source_count(idx);j++) {
+				String file = expand_source_path(efsd->get_source_file(idx,j));
+				if (sources.find(file)==-1) {
+					sources.push_back(file);
+				}
+
+			}
+		}
+	}
+
+	if (sources.size()) {
+
+		dialog->popup_import(p_list[0]);
+		dialog->_choose_files(sources);
+		dialog->_choose_save_dir(p_list[0].get_base_dir());
+	}
+}
+
+bool EditorSampleImportPlugin::can_reimport_multiple_files() const {
+
+	return true;
+}
 
 EditorSampleImportPlugin::EditorSampleImportPlugin(EditorNode* p_editor) {
 
@@ -865,6 +917,7 @@ Vector<uint8_t> EditorSampleExportPlugin::custom_export(String& p_path,const Ref
 }
 
 
+
 EditorSampleExportPlugin::EditorSampleExportPlugin() {
 
 }
diff --git a/tools/editor/io_plugins/editor_sample_import_plugin.h b/tools/editor/io_plugins/editor_sample_import_plugin.h
index b31562af7..a2686ebe4 100644
--- a/tools/editor/io_plugins/editor_sample_import_plugin.h
+++ b/tools/editor/io_plugins/editor_sample_import_plugin.h
@@ -49,6 +49,9 @@ public:
 	virtual String get_visible_name() const;
 	virtual void import_dialog(const String& p_from="");
 	virtual Error import(const String& p_path, const Ref<ResourceImportMetadata>& p_from);
+	void import_from_drop(const Vector<String>& p_drop, const String &p_dest_path);
+	virtual void reimport_multiple_files(const Vector<String>& p_list);
+	virtual bool can_reimport_multiple_files() const;
 
 
 	EditorSampleImportPlugin(EditorNode* p_editor);
diff --git a/tools/editor/io_plugins/editor_scene_import_plugin.cpp b/tools/editor/io_plugins/editor_scene_import_plugin.cpp
index 84ef5f197..00bd5413d 100644
--- a/tools/editor/io_plugins/editor_scene_import_plugin.cpp
+++ b/tools/editor/io_plugins/editor_scene_import_plugin.cpp
@@ -41,6 +41,7 @@
 #include "scene/3d/physics_body.h"
 #include "scene/3d/portal.h"
 #include "scene/3d/vehicle_body.h"
+#include "tools/editor/create_dialog.h"
 #include "os/os.h"
 
 
@@ -95,6 +96,7 @@ class EditorImportAnimationOptions : public VBoxContainer {
 	Tree *optimization_tree;
 	Vector<TreeItem*> items;
 
+
 	bool updating;
 	bool validating;
 
@@ -167,6 +169,7 @@ class EditorSceneImportDialog : public ConfirmationDialog  {
 	EditorFileDialog *script_select;
 	EditorDirDialog *save_select;
 	OptionButton *texture_action;
+	CreateDialog *root_type_choose;
 
 	ConfirmationDialog *confirm_open;
 
@@ -178,8 +181,13 @@ class EditorSceneImportDialog : public ConfirmationDialog  {
 	Map<Ref<Mesh>,Ref<Shape> > collision_map;
 	ConfirmationDialog *error_dialog;
 
-	OptionButton *this_import;
-	OptionButton *next_import;
+	Button *root_type;
+	CheckBox *root_default;
+
+
+	void _root_default_pressed();
+	void _root_type_pressed();
+	void _set_root_type();
 
 	void _choose_file(const String& p_path);
 	void _choose_save_file(const String& p_path);
@@ -206,6 +214,11 @@ protected:
 	static void _bind_methods();
 public:
 
+	void setup_popup(const String& p_from,const String& p_to_path) {
+		_choose_file(p_from);
+		_choose_save_file(p_to_path);
+	}
+
 	Error import(const String& p_from, const String& p_to, const String& p_preset);
 	void popup_import(const String& p_from);
 	EditorSceneImportDialog(EditorNode *p_editor,EditorSceneImportPlugin *p_plugin);
@@ -764,9 +777,10 @@ void EditorSceneImportDialog::_import(bool p_and_open) {
 	rim->set_option("animation_filters",animation_options->get_filter());
 	rim->set_option("animation_clips",animation_options->get_clips());
 	rim->set_option("post_import_script",script_path->get_text());
-	rim->set_option("import_this_time",this_import->get_selected());
-	rim->set_option("import_next_time",next_import->get_selected());
 	rim->set_option("reimport",true);
+	if (!root_default->is_pressed()) {
+		rim->set_option("root_type",root_type->get_text());
+	}
 
 	List<String> missing;
 	Error err = plugin->import1(rim,&scene,&missing);
@@ -909,12 +923,24 @@ void EditorSceneImportDialog::popup_import(const String &p_from) {
 		if (rimd->has_option("animation_optimizer_max_angle"))
 			animation_options->set_optimize_max_angle(rimd->get_option("animation_optimizer_max_angle"));
 
+		if (rimd->has_option("root_type")) {
+			root_default->set_pressed(false);
+			String type = rimd->get_option("root_type");
+			root_type->set_text(type);
+			root_type->set_disabled(false);
+
+			if (has_icon(type,"EditorIcons")) {
+				root_type->set_icon(get_icon(type,"EditorIcons"));
+			} else {
+				root_type->set_icon(get_icon("Object","EditorIcons"));
+			}
+
+		} else {
+			root_default->set_pressed(true);
+			root_type->set_disabled(true);
+		}
 
 		script_path->set_text(rimd->get_option("post_import_script"));
-		if (rimd->has_option("import_this_time"))
-			this_import->select(rimd->get_option("import_this_time"));
-		if (rimd->has_option("import_next_time"))
-			next_import->select(rimd->get_option("import_next_time"));
 
 		save_path->set_text(p_from.get_base_dir());
 		import_path->set_text(EditorImportPlugin::expand_source_path(rimd->get_source_path(0)));
@@ -931,6 +957,9 @@ void EditorSceneImportDialog::_notification(int p_what) {
 
 		List<String> extensions;
 		file_select->clear_filters();
+		root_type->set_icon(get_icon("Spatial","EditorIcons"));
+		root_type->set_text("Spatial");
+		root_type->set_disabled(true);
 
 		for(int i=0;i<plugin->get_importers().size();i++) {
 			plugin->get_importers()[i]->get_extensions(&extensions);
@@ -981,7 +1010,30 @@ void EditorSceneImportDialog::_dialog_hid() {
 		wip_rimd=Ref<ResourceImportMetadata>();
 	}
 }
+void EditorSceneImportDialog::_root_default_pressed() {
+
+	root_type->set_disabled(root_default->is_pressed());
+}
+
+void EditorSceneImportDialog::_root_type_pressed() {
+
+
+	root_type_choose->popup(false);
+}
+
+
+void EditorSceneImportDialog::_set_root_type() {
 
+	String type = root_type_choose->get_selected_type();
+	if (type==String())
+		return;
+	root_type->set_text(type);
+	if (has_icon(type,"EditorIcons")) {
+		root_type->set_icon(get_icon(type,"EditorIcons"));
+	} else {
+		root_type->set_icon(get_icon("Object","EditorIcons"));
+	}
+}
 
 void EditorSceneImportDialog::_bind_methods() {
 
@@ -996,13 +1048,16 @@ void EditorSceneImportDialog::_bind_methods() {
 	ObjectTypeDB::bind_method("_dialog_hid",&EditorSceneImportDialog::_dialog_hid);
 	ObjectTypeDB::bind_method("_import_confirm",&EditorSceneImportDialog::_import_confirm);
 	ObjectTypeDB::bind_method("_open_and_import",&EditorSceneImportDialog::_open_and_import);
+	ObjectTypeDB::bind_method("_root_default_pressed",&EditorSceneImportDialog::_root_default_pressed);
+	ObjectTypeDB::bind_method("_root_type_pressed",&EditorSceneImportDialog::_root_type_pressed);
+	ObjectTypeDB::bind_method("_set_root_type",&EditorSceneImportDialog::_set_root_type);
+
 
 	ADD_SIGNAL( MethodInfo("imported",PropertyInfo(Variant::OBJECT,"scene")) );
 }
 
 
 
-
 const EditorSceneImportDialog::FlagInfo EditorSceneImportDialog::scene_flag_names[]={
 
 	{EditorSceneImportPlugin::SCENE_FLAG_REMOVE_NOIMP,("Actions"),"Remove Nodes (-noimp)",true},
@@ -1162,6 +1217,23 @@ EditorSceneImportDialog::EditorSceneImportDialog(EditorNode *p_editor, EditorSce
 	error_dialog->get_ok()->set_text(TTR("Accept"));
 //	error_dialog->get_cancel()->hide();
 
+
+	HBoxContainer *custom_root_hb = memnew( HBoxContainer );
+	vbc->add_margin_child(TTR("Custom Root Node Type:"),custom_root_hb);
+	root_type = memnew(Button);
+	root_type->set_h_size_flags(SIZE_EXPAND_FILL);
+	root_type->set_text_align(Button::ALIGN_LEFT);
+	root_type->connect("pressed",this,"_root_type_pressed");
+	custom_root_hb->add_child(root_type);
+
+	root_default = memnew(CheckBox);
+	root_default->set_text("Auto");
+	root_default->set_pressed(true);
+	root_default->connect("pressed",this,"_root_default_pressed");
+	custom_root_hb->add_child(root_default);
+
+
+	/*
 	this_import = memnew( OptionButton );
 	this_import->add_item(TTR("Overwrite Existing Scene"));
 	this_import->add_item(TTR("Overwrite Existing, Keep Materials"));
@@ -1175,7 +1247,7 @@ EditorSceneImportDialog::EditorSceneImportDialog(EditorNode *p_editor, EditorSce
 	next_import->add_item(TTR("Keep Existing, Merge with New"));
 	next_import->add_item(TTR("Keep Existing, Ignore New"));
 	vbc->add_margin_child(TTR("Next Time:"),next_import);
-
+*/
 	set_hide_on_ok(false);
 
 	GLOBAL_DEF("import/shared_textures","res://");
@@ -1183,6 +1255,7 @@ EditorSceneImportDialog::EditorSceneImportDialog(EditorNode *p_editor, EditorSce
 
 	import_hb->add_constant_override("separation",30);
 
+
 	VBoxContainer *ovb = memnew( VBoxContainer);
 	ovb->set_h_size_flags(SIZE_EXPAND_FILL);
 	import_hb->add_child(ovb);
@@ -1232,6 +1305,10 @@ EditorSceneImportDialog::EditorSceneImportDialog(EditorNode *p_editor, EditorSce
 	wip_open=false;
 	//texture_options->set_format(EditorImport::IMAGE_FORMAT_C);
 
+	root_type_choose = memnew( CreateDialog );
+	add_child(root_type_choose);
+	root_type_choose->set_base_type("Node");
+	root_type_choose->connect("create",this,"_set_root_type");
 }
 
 
@@ -1247,7 +1324,7 @@ String EditorSceneImportPlugin::get_name() const {
 
 String EditorSceneImportPlugin::get_visible_name() const{
 
-	return "3D Scene";
+	return "Scene";
 }
 
 void EditorSceneImportPlugin::import_dialog(const String& p_from){
@@ -1906,398 +1983,8 @@ Node* EditorSceneImportPlugin::_fix_node(Node *p_node,Node *p_root,Map<Ref<Mesh>
 }
 
 
-void EditorSceneImportPlugin::_merge_existing_node(Node *p_node,Node *p_imported_scene,Set<Ref<Resource> >& checked_resources,Set<Node*> &checked_nodes) {
-
-
-	NodePath path = p_node->get_import_path();
-
-	if (!path.is_empty() && p_imported_scene->has_node(path)) {
-
-		Node *imported_node = p_imported_scene->get_node(path);
-
-		if (imported_node->get_type()==p_node->get_type()) {
-			//same thing, check what it is
-
-			if (p_node->get_type()=="MeshInstance") {
-
-				//merge mesh instance, this is a special case!
-				MeshInstance *mi_imported=imported_node->cast_to<MeshInstance>();
-				MeshInstance *mi_node=p_node->cast_to<MeshInstance>();
-
-				Ref<Mesh> mesh_imported = mi_imported->get_mesh();
-				Ref<Mesh> mesh_node = mi_node->get_mesh();
-
-				if (mesh_node.is_null() && mesh_imported.is_valid()) {
-
-					mi_node->set_mesh(mesh_imported);
-
-				} else if (mesh_node.is_valid() && mesh_imported.is_valid()) {
-
-					if (checked_resources.has(mesh_imported)) {
-
-						mi_node->set_mesh(mesh_imported);
-					} else {
-						//mix up meshes
-						//import new geometry but keep materials
-						for(int i=0;i<mesh_imported->get_surface_count();i++) {
-
-							String name = mesh_imported->surface_get_name(i);
-
-							for(int j=0;j<mesh_node->get_surface_count();j++) {
-
-								Ref<Material> mat = mesh_node->surface_get_material(j);
-								if (mat.is_valid() && mesh_node->surface_get_name(j)==name  ) {
-
-									mesh_imported->surface_set_material(i,mat);
-									break;
-								}
-							}
-						}
-						// was imported, do nothing further
-						checked_resources.insert(mesh_imported);
-						mi_node->set_mesh(mesh_imported);
-					}
-
-				}
-			} else if (p_node->get_type()=="Path") {
-				//for paths, overwrite path
-				Path *path_imported =imported_node->cast_to<Path>();
-				Path *path_node =p_node->cast_to<Path>();
-
-				if (path_imported->get_curve().is_valid()) {
-
-					path_node->set_curve(path_imported->get_curve());
-				}
-			} else if (p_node->get_type()=="Portal") {
-				//for paths, overwrite path
-
-				Portal *portal_imported =imported_node->cast_to<Portal>();
-				Portal *portal_node =p_node->cast_to<Portal>();
-
-				portal_node->set_shape( portal_imported->get_shape() );
-
-			} else if (p_node->get_type()=="Room") {
-				//for paths, overwrite path
-
-				Room *room_imported =imported_node->cast_to<Room>();
-				Room *room_node =p_node->cast_to<Room>();
-
-				room_node->set_room( room_imported->get_room() );
-
-			} else if (p_node->get_type()=="Skeleton") {
-				//for paths, overwrite path
-
-				Skeleton *skeleton_imported =imported_node->cast_to<Skeleton>();
-				Skeleton *skeleton_node =p_node->cast_to<Skeleton>();
-
-				//use imported bones, obviously
-				skeleton_node->clear_bones();
-				for(int i=0;i<skeleton_imported->get_bone_count();i++) {
-
-					skeleton_node->add_bone(skeleton_imported->get_bone_name(i));
-					skeleton_node->set_bone_parent(i,skeleton_imported->get_bone_parent(i));
-					skeleton_node->set_bone_rest(i,skeleton_imported->get_bone_rest(i));
-					//skeleton_node->set_bone_pose(i,skeleton_imported->get_bone_pose(i)); // not in a scene, will throw errors
-				}
-			}
-			else if (p_node->get_type() == "AnimationPlayer") {
-				//for paths, overwrite path
-				AnimationPlayer *aplayer_imported = imported_node->cast_to<AnimationPlayer>();
-				AnimationPlayer *aplayer_node = p_node->cast_to<AnimationPlayer>();
-
-				//use imported bones, obviously
-				List<StringName> anims;
-				List<StringName> existing_anims;
-				aplayer_imported->get_animation_list(&anims);
-				aplayer_node->get_animation_list(&existing_anims);
-
-				//use imported animations
-				for (List<StringName>::Element *N = anims.front(); N; N = N->next()) {
-
-					Ref<Animation> candidate = aplayer_imported->get_animation(N->get());
-
-					if (aplayer_node->has_animation(N->get())) {
-
-						Ref<Animation> found = aplayer_node->get_animation(N->get());
-
-						candidate->set_loop(found->has_loop());
-						candidate->set_step(found->get_step());
-
-						//For each track candidate
-						for (int i = 0; i < candidate->get_track_count(); i++) {
-
-							NodePath track_path = candidate->track_get_path(i);
-							// For each track existing
-							for (int x = 0; x < found->get_track_count(); x++) {
-
-								NodePath path_to_compare = found->track_get_path(x);
-
-								if (track_path.hash() == path_to_compare.hash() && candidate->track_get_type(x) == found->track_get_type(i)) {
-
-									//Tracks matches
-									if (candidate->track_get_interpolation_type(i) != found->track_get_interpolation_type(x))
-										candidate->track_set_interpolation_type(i, found->track_get_interpolation_type(x));
-									if (candidate->track_get_type(i) == Animation::TYPE_VALUE && candidate->value_track_is_continuous(i) != found->value_track_is_continuous(x))
-										candidate->value_track_set_continuous(i, found->value_track_is_continuous(x));
-
-									//Key transitions might have changed, but the animation remained unchanged
-									if (candidate->track_get_key_count(i) == found->track_get_key_count(x)) {
-										for (int k = 0; k < candidate->track_get_key_count(i); k++) {
-
-											if (candidate->track_get_key_transition(i, k) != found->track_get_key_transition(x, k))
-												candidate->track_set_key_transition(i, k, found->track_get_key_transition(x, k));
-										}
-									}
-
-								}
-
-							}
-						}
-
-						// Append function callbacks and values
-						for (int x = 0; x < found->get_track_count(); x++) {
-							if (found->track_get_type(x) == Animation::TYPE_METHOD || found->track_get_type(x) == Animation::TYPE_VALUE)
-								candidate->add_track(found->track_get_type(x), candidate->get_track_count());
-
-							for (int k = 0; k < found->track_get_key_count(x); k++)
-								candidate->track_insert_key(x, found->track_get_key_time(x, k), found->track_get_key_value(x, k), found->track_get_key_transition(x, k));
-						}
-					}
-
-					aplayer_node->add_animation(N->get(), candidate);
-				}
-
-			} else if (p_node->get_type()=="CollisionShape") {
-				//for paths, overwrite path
-
-				CollisionShape *collision_imported =imported_node->cast_to<CollisionShape>();
-				CollisionShape *collision_node =p_node->cast_to<CollisionShape>();
-
-				collision_node->set_shape( collision_imported->get_shape() );
-			}
-		}
-
-		if (p_node->cast_to<Spatial>() && imported_node->cast_to<Spatial>()) {
-			//apply transform if changed
-			Spatial *snode = p_node->cast_to<Spatial>();
-			Spatial *simp = imported_node->cast_to<Spatial>();
-
-			if (snode->get_import_transform() == snode->get_transform()) {
-				//not moved, apply new
-				snode->set_import_transform(simp->get_transform());
-				snode->set_transform(simp->get_transform());
-			} else if (snode->get_import_transform() == simp->get_import_transform()) {
-				//do nothing, nothing changed keep local changes
-			} else {
-				//changed both, imported and edited, merge
-				Transform local_xform = snode->get_import_transform().affine_inverse() * snode->get_transform();
-				snode->set_import_transform(simp->get_import_transform());
-				snode->set_transform(simp->get_import_transform() * local_xform);
-			}
-		}
-
-		checked_nodes.insert(imported_node);
-
-	}
-#if 0
-	else {
-
-		if (p_node!=p_root && p_existing->has_node(p_root->get_path_to(p_node->get_parent()))) {
-
-			Node *parent = p_existing->get_node(p_root->get_path_to(p_node->get_parent()));
-			NodePath path = p_root->get_path_to(p_node);
-
-			//add it.. because not existing in existing scene
-			Object *o = ObjectTypeDB::instance(p_existing->get_type());
-			Node *n=NULL;
-			if (o)
-				n=o->cast_to<Node>();
-
-			if (n) {
-
-				List<PropertyInfo> pl;
-				p_existing->get_property_list(&pl);
-				for(List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) {
-					if (!(E->get().usage&PROPERTY_USAGE_STORAGE))
-						continue;
-					n->set( E->get().name, p_existing->get(E->get().name) );
-				}
-
-				parent->add_child(n);
-
-				valid=true;
-			}
-		}
-
-	}
-#endif
-
-	for(int i=0;i<p_node->get_child_count();i++) {
-		_merge_existing_node(p_node->get_child(i),p_imported_scene,checked_resources,checked_nodes);
-	}
-}
-
-
-void EditorSceneImportPlugin::_add_new_nodes(Node *p_node,Node *p_imported,Node *p_imported_scene,Node *p_existing_scene,Set<Node*> &checked_nodes) {
 
 
-	for(int i=0;i<p_imported->get_child_count();i++) {
-
-
-		Node *imported_node = p_imported->get_child(i);
-
-		if (imported_node->get_owner()!=p_imported_scene) {
-		//	print_line("skipping because not imported at "+String(imported_node->get_name()));
-			continue; //end of the road
-		}
-
-		Vector<StringName> nn;
-		nn.push_back(imported_node->get_name());
-		NodePath imported_path(nn,false);
-		//print_line("check for: "+String(imported_path));
-
-		if (!p_node->has_node(imported_path) && !checked_nodes.has(imported_node)) {
-			//not there, re-add it
-			//add it.. because not existing in existing scene
-			Object *o = ObjectTypeDB::instance(imported_node->get_type());
-			Node *n=NULL;
-			if (o)
-				n=o->cast_to<Node>();
-
-			//print_line("creating node of same type..");
-
-			if (n) {
-
-				//print_line("copy props and add");
-				List<PropertyInfo> pl;
-				imported_node->get_property_list(&pl);
-				for(List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) {
-					if (!(E->get().usage&PROPERTY_USAGE_STORAGE))
-						continue;
-					n->set( E->get().name, imported_node->get(E->get().name) );
-				}
-
-				p_node->add_child(n);
-				n->set_owner(p_existing_scene);
-			}
-
-		} else {
-			//print_line("already exists");
-		}
-
-
-		if (p_node->has_node(imported_path)) {
-
-			Node *other_node = p_node->get_node(imported_path);
-
-			_add_new_nodes(other_node,imported_node,p_imported_scene,p_existing_scene,checked_nodes);
-
-		}
-
-	}
-}
-
-
-void EditorSceneImportPlugin::_merge_scenes(Node *p_node,Node *p_imported) {
-
-	Set<Ref<Resource> > checked_resources;
-	Set<Node*> checked_nodes;
-	_merge_existing_node(p_node,p_imported,checked_resources,checked_nodes);
-	_add_new_nodes(p_node,p_imported,p_imported,p_node,checked_nodes);
-	//add existing.. ?
-}
-
-
-void EditorSceneImportPlugin::_scan_materials(Node*p_base,Node *p_node,Map<String,Ref<Material> > &mesh_materials,Map<String,Ref<Material> >& override_materials) {
-
-	if (!p_base && p_node->get_owner()!=p_base)
-		return;
-	MeshInstance *mi=p_node->cast_to<MeshInstance>();
-
-	if (mi) {
-		if (mi->get_material_override().is_valid()) {
-			String path = p_base->get_path_to(p_node);
-			override_materials[path]=mi->get_material_override();
-		}
-		Ref<Mesh> mesh = mi->get_mesh();
-		if (mesh.is_valid()) {
-
-			for(int i=0;i<mesh->get_surface_count();i++) {
-
-				String name = mesh->get_name()+":"+mesh->surface_get_name(i);
-				if (!mesh_materials.has(name)) {
-					mesh_materials[name]=mesh->surface_get_material(i);
-				}
-			}
-		}
-	}
-
-	for(int i=0;i<p_node->get_child_count();i++) {
-		_scan_materials(p_base,p_node->get_child(i),mesh_materials,override_materials);
-	}
-}
-
-
-void EditorSceneImportPlugin::_apply_materials(Node*p_base,Node *p_node,Map<String,Ref<Material> > &mesh_materials,Map<String,Ref<Material> >& override_materials,Set<Ref<Mesh> >& meshes_processed) {
-
-	if (p_node!=p_base && p_node->get_owner()!=p_base)
-		return;
-
-	MeshInstance *mi=p_node->cast_to<MeshInstance>();
-
-	if (mi) {
-
-		print_line("is mesh "+String(p_node->get_name()));
-		String path = p_base->get_path_to(p_node);
-		if (override_materials.has(path)) {
-			print_line("is in material overrides");
-			mi->set_material_override(override_materials[path]);
-		}
-
-		Ref<Mesh> mesh = mi->get_mesh();
-		if (mesh.is_valid() && !meshes_processed.has(mesh)) {
-			print_line("mesh was not processed");
-			meshes_processed.insert(mesh);
-			for(int i=0;i<mesh->get_surface_count();i++) {
-
-				String name = mesh->get_name()+":"+mesh->surface_get_name(i);
-				print_line("name for surface "+itos(i)+": "+name);
-				if (mesh_materials.has(name)) {
-
-					Ref<Material> mat = mesh_materials[name];
-					mesh->surface_set_material(i,mat);
-					print_line("overriding!");
-				}
-			}
-		}
-	}
-
-	for(int i=0;i<p_node->get_child_count();i++) {
-		_apply_materials(p_base,p_node->get_child(i),mesh_materials,override_materials,meshes_processed);
-	}
-}
-
-void EditorSceneImportPlugin::_merge_materials(Node *p_node,Node *p_imported) {
-
-	Map<String,Ref<Material> > mesh_materials;
-	Map<String,Ref<Material> > override_materials;
-
-	_scan_materials(p_node,p_node,mesh_materials,override_materials);
-
-	for (Map<String,Ref<Material> >::Element *E=mesh_materials.front();E;E=E->next()) {
-		print_line("Mats: "+String(E->key()));
-	}
-
-	for (Map<String,Ref<Material> >::Element *E=override_materials.front();E;E=E->next()) {
-		print_line("Overrides: "+String(E->key()));
-	}
-
-	Set<Ref<Mesh> > mp;
-	_apply_materials(p_imported,p_imported,mesh_materials,override_materials,mp);
-
-
-}
-
 #if 0
 
 Error EditorImport::import_scene(const String& p_path,const String& p_dest_path,const String& p_resource_path,uint32_t p_flags,ImageFormat p_image_format,ImageCompression p_image_compression,uint32_t p_image_flags,float p_quality,uint32_t animation_flags,Node **r_scene,Ref<EditorPostImport> p_post_import) {
@@ -2397,6 +2084,21 @@ Error EditorSceneImportPlugin::import1(const Ref<ResourceImportMetadata>& p_from
 		return err;
 	}
 
+	if (from->has_option("root_type")) {
+		String type = from->get_option("root_type");
+		Object *base = ObjectTypeDB::instance(type);
+		Node *base_node = NULL;
+		if (base)
+			base_node=base->cast_to<Node>();
+
+		if (base_node) {
+
+			scene->replace_by(base_node);
+			memdelete(scene);
+			scene=base_node;
+		}
+	}
+
 	_tag_import_paths(scene,scene);
 
 	*r_node=scene;
@@ -2839,66 +2541,12 @@ Error EditorSceneImportPlugin::import2(Node *scene, const String& p_dest_path, c
 				}
 			}
 
-			Error err = EditorTextureImportPlugin::get_singleton(EditorTextureImportPlugin::MODE_TEXTURE_3D)->import(target_path,imd);
+			Error err = EditorTextureImportPlugin::get_singleton()->import(target_path,imd);
 
 		}
 	}
 
 
-	/// BEFORE SAVING - MERGE
-
-
-	if (import_action!=SCENE_UPDATE_REPLACE_WITH_NEW) {
-
-
-		progress.step(TTR("Merging.."),103);
-
-		FileAccess *fa = FileAccess::create(FileAccess::ACCESS_RESOURCES);
-
-		if (fa->file_exists(p_dest_path)) {
-
-
-			//try to merge
-
-			Ref<PackedScene> s = ResourceLoader::load(p_dest_path);
-			if (s.is_valid()) {
-
-				Node *existing = s->instance(true);
-
-				if (existing) {
-
-
-					switch(import_action) {
-
-						case SCENE_UPDATE_REPLACE_WITH_NEW: break;
-						case SCENE_UPDATE_REPLACE_WITH_NEW_KEEP_MATERIALS: {
-
-							_merge_materials(existing,scene);
-							memdelete(existing);
-
-						} break;
-						case SCENE_UPDATE_KEEP_OLD_MERGE_CHANGES: {
-
-							_merge_scenes(existing,scene);
-							memdelete(scene);
-							scene=existing;
-
-						} break;
-						case SCENE_UPDATE_KEEP_OLD: {
-
-							memdelete(scene);
-							scene=existing;
-						} break;
-					}
-
-				}
-			}
-
-		}
-
-		memdelete(fa);
-	}
-
 
 	progress.step(TTR("Saving.."),104);
 
@@ -2957,6 +2605,30 @@ void EditorSceneImportPlugin::add_importer(const Ref<EditorSceneImporter>& p_imp
 	importers.push_back(p_importer);
 }
 
+void EditorSceneImportPlugin::import_from_drop(const Vector<String>& p_drop,const String& p_dest_path) {
+
+	List<String> extensions;
+	for(int i=0;i<importers.size();i++) {
+		importers[i]->get_extensions(&extensions);
+	}
+	//bool warn_compatible=false;
+	for(int i=0;i<p_drop.size();i++) {
+
+		String extension = p_drop[i].extension().to_lower();
+
+		for(List<String>::Element *E=extensions.front();E;E=E->next()) {
+
+			if (E->get()==extension) {
+
+				dialog->popup_import(String());
+				dialog->setup_popup(p_drop[i],p_dest_path);
+				return;
+			}
+		}
+	}
+
+}
+
 
 EditorSceneImportPlugin::EditorSceneImportPlugin(EditorNode* p_editor) {
 
diff --git a/tools/editor/io_plugins/editor_scene_import_plugin.h b/tools/editor/io_plugins/editor_scene_import_plugin.h
index a1a090de7..8a2d30f1f 100644
--- a/tools/editor/io_plugins/editor_scene_import_plugin.h
+++ b/tools/editor/io_plugins/editor_scene_import_plugin.h
@@ -45,6 +45,7 @@
 #include "tools/editor/io_plugins/editor_texture_import_plugin.h"
 #include "scene/resources/animation.h"
 
+
 class EditorNode;
 class EditorSceneImportDialog;
 
@@ -111,16 +112,8 @@ class EditorSceneImportPlugin : public EditorImportPlugin {
 	void _create_clips(Node *scene, const Array& p_clips, bool p_bake_all);
 	void _filter_anim_tracks(Ref<Animation> anim,Set<String> &keep);
 	void _filter_tracks(Node *scene, const String& p_text);
-	void _merge_existing_node(Node *p_node,Node *p_imported_scene,Set<Ref<Resource> >& checked_resources,Set<Node*> &checked_nodes);
-
-	void _add_new_nodes(Node *p_node,Node *p_imported,Node *p_imported_scene,Node *p_existing_scene,Set<Node*> &checked_nodes);
 	void _optimize_animations(Node *scene, float p_max_lin_error,float p_max_ang_error,float p_max_angle);
 
-	void _merge_scenes(Node *p_node, Node *p_imported);
-	void _scan_materials(Node*p_base,Node *p_node,Map<String,Ref<Material> > &mesh_materials,Map<String,Ref<Material> >& override_materials);
-	void _apply_materials(Node*p_base,Node *p_node,Map<String,Ref<Material> > &mesh_materials,Map<String,Ref<Material> >& override_materials,Set<Ref<Mesh> >& meshes_processed);
-	void _merge_materials(Node *p_node,Node *p_imported);
-
 	void _tag_import_paths(Node *p_scene,Node *p_node);
 
 public:
@@ -150,13 +143,6 @@ public:
 		SCENE_FLAG_CONVERT_NORMALMAPS_TO_XY=1<<30,
 	};
 
-	enum SceneUpdate {
-		SCENE_UPDATE_REPLACE_WITH_NEW,
-		SCENE_UPDATE_REPLACE_WITH_NEW_KEEP_MATERIALS,
-		SCENE_UPDATE_KEEP_OLD_MERGE_CHANGES,
-		SCENE_UPDATE_KEEP_OLD,
-	};
-
 
 	virtual String get_name() const;
 	virtual String get_visible_name() const;
@@ -169,6 +155,8 @@ public:
 	void add_importer(const Ref<EditorSceneImporter>& p_importer);
 	const Vector<Ref<EditorSceneImporter> >& get_importers() { return importers; }
 
+	virtual void import_from_drop(const Vector<String>& p_drop,const String& p_dest_path);
+
 	EditorSceneImportPlugin(EditorNode* p_editor=NULL);
 
 
diff --git a/tools/editor/io_plugins/editor_texture_import_plugin.cpp b/tools/editor/io_plugins/editor_texture_import_plugin.cpp
index 0e2d35b9f..c7598466d 100644
--- a/tools/editor/io_plugins/editor_texture_import_plugin.cpp
+++ b/tools/editor/io_plugins/editor_texture_import_plugin.cpp
@@ -35,6 +35,9 @@
 #include "io/md5.h"
 #include "io/marshalls.h"
 #include "globals.h"
+#include "scene/gui/check_button.h"
+#include "scene/gui/button_group.h"
+#include "scene/gui/margin_container.h"
 
 static const char *flag_names[]={
 	("Streaming Format"),
@@ -164,12 +167,13 @@ void EditorImportTextureOptions::_notification(int p_what) {
 
 void EditorImportTextureOptions::show_2d_notice() {
 
-	notice_for_2d->show();
+	//notice_for_2d->show();
 }
 
 EditorImportTextureOptions::EditorImportTextureOptions() {
 
 
+	add_constant_override("separation",3);
 	updating=false;
 	format = memnew( OptionButton );
 
@@ -223,12 +227,6 @@ EditorImportTextureOptions::EditorImportTextureOptions() {
 
 	add_margin_child(TTR("Texture Options"),flags,true);
 
-	notice_for_2d = memnew( Label );
-	notice_for_2d->set_text(TTR("NOTICE: You are not forced to import textures for 2D projects. Just copy your .jpg or .png files to your project, and change export options later. Atlases can be generated on export too."));
-	notice_for_2d->set_custom_minimum_size(Size2(0,50));
-	notice_for_2d->set_autowrap(true);
-	add_child(notice_for_2d);
-	notice_for_2d->hide();
 
 }
 
@@ -242,8 +240,13 @@ class EditorTextureImportDialog : public ConfirmationDialog  {
 	OBJ_TYPE(EditorTextureImportDialog,ConfirmationDialog);
 
 
+
+	HBoxContainer *mode_hb;
+	CheckBox *mode_check[EditorTextureImportPlugin::MODE_MAX];
+
 	EditorImportTextureOptions *texture_options;
 
+	EditorTextureImportPlugin::Mode mode;
 	//EditorNode *editor;
 
 	LineEdit *import_path;
@@ -255,11 +258,16 @@ class EditorTextureImportDialog : public ConfirmationDialog  {
 	ConfirmationDialog *error_dialog;
 	CheckButton *crop_source;
 	SpinBox *size;
-	bool atlas;
-	bool large;
+
+	MarginContainer *size_mc;
+	Label* size_label;
+
+	Label* source_label;
+	Label *notice_for_2d;
 
 	EditorTextureImportPlugin *plugin;
 
+	void _mode_changed(int p_mode);
 	void _choose_files(const Vector<String>& p_path);
 	void _choose_file(const String& p_path);
 	void _choose_save_dir(const String& p_path);
@@ -274,9 +282,23 @@ protected:
 	static void _bind_methods();
 public:
 
+
+	void setup_multiple_import_3d(const Vector<String>& p_path,const String& p_dest) {
+
+		_mode_changed(EditorTextureImportPlugin::MODE_TEXTURE_3D);
+		_choose_files(p_path);
+		_choose_save_dir(p_dest);
+	}
+
+	void add_sources_and_dest(const Vector<String>& p_path,const String& p_dest) {
+
+		_choose_files(p_path);
+		_choose_save_dir(p_dest);
+	}
+
 	Error import(const String& p_from, const String& p_to, const String& p_preset);
 	void popup_import(const String &p_from=String());
-	EditorTextureImportDialog(EditorTextureImportPlugin *p_plugin=NULL,bool p_2d=false,bool p_atlas=false,bool p_large=false);
+	EditorTextureImportDialog(EditorTextureImportPlugin *p_plugin=NULL);
 };
 
 
@@ -349,13 +371,13 @@ void EditorTextureImportDialog::_import() {
 	}
 
 
-	if (!atlas && !large && !DirAccess::exists(save_path->get_text())) {
+	if (mode!=EditorTextureImportPlugin::MODE_ATLAS && mode!=EditorTextureImportPlugin::MODE_LARGE && !DirAccess::exists(save_path->get_text())) {
 		error_dialog->set_text(TTR("Target path must exist."));
 		error_dialog->popup_centered_minsize();
 		return;
 	}
 
-	if (atlas) { //atlas
+	if (mode==EditorTextureImportPlugin::MODE_ATLAS) { //atlas
 
 		if (files.size()==0) {
 
@@ -378,6 +400,7 @@ void EditorTextureImportDialog::_import() {
 		imd->set_option("atlas_size",int(size->get_val()));
 		imd->set_option("large",false);
 		imd->set_option("crop",crop_source->is_pressed());
+		imd->set_option("mode",mode);
 
 		Error err = plugin->import(dst_file,imd);
 		if (err) {
@@ -387,7 +410,7 @@ void EditorTextureImportDialog::_import() {
 			return;
 
 		}
-	} else if (large) { //atlas
+	} else if (mode==EditorTextureImportPlugin::MODE_LARGE) { //large
 
 		if (files.size()!=1) {
 
@@ -410,6 +433,7 @@ void EditorTextureImportDialog::_import() {
 		imd->set_option("large",true);
 		imd->set_option("large_cell_size",int(size->get_val()));
 		imd->set_option("crop",crop_source->is_pressed());
+		imd->set_option("mode",mode);
 
 		Error err = plugin->import(dst_file,imd);
 		if (err) {
@@ -434,6 +458,7 @@ void EditorTextureImportDialog::_import() {
 			imd->set_option("quality",texture_options->get_quality());
 			imd->set_option("atlas",false);
 			imd->set_option("large",false);
+			imd->set_option("mode",mode);
 
 			Error err = plugin->import(dst_file,imd);
 			if (err) {
@@ -456,7 +481,7 @@ void EditorTextureImportDialog::_browse() {
 
 void EditorTextureImportDialog::_browse_target() {
 
-	if (atlas || large) {
+	if (mode==EditorTextureImportPlugin::MODE_ATLAS || mode==EditorTextureImportPlugin::MODE_LARGE) {
 		save_file_select->popup_centered_ratio();
 	} else {
 		save_select->popup_centered_ratio();
@@ -467,12 +492,28 @@ void EditorTextureImportDialog::_browse_target() {
 
 void EditorTextureImportDialog::popup_import(const String& p_from) {
 
-	popup_centered(Size2(400,400));
+	popup_centered(Size2(600,500));
 	if (p_from!="") {
 		Ref<ResourceImportMetadata> rimd = ResourceLoader::load_import_metadata(p_from);
 		ERR_FAIL_COND(!rimd.is_valid());
 
-		if (plugin->get_mode()==EditorTextureImportPlugin::MODE_ATLAS || plugin->get_mode()==EditorTextureImportPlugin::MODE_LARGE)
+		if (rimd->has_option("mode")) {
+			//new imported stuff uses this option
+			_mode_changed(rimd->get_option("mode"));
+		} else {
+			//this one is for compatibility, will have to guess it
+			if (rimd->has_option("atlas") && rimd->get_option("atlas")) {
+				_mode_changed(EditorTextureImportPlugin::MODE_ATLAS);
+			} else if (rimd->has_option("large") && rimd->get_option("large")) {
+				_mode_changed(EditorTextureImportPlugin::MODE_LARGE);
+			} else {
+				//guess by usage of mipmaps..?
+				_mode_changed(EditorTextureImportPlugin::MODE_TEXTURE_2D);
+			}
+
+		}
+
+		if (mode==EditorTextureImportPlugin::MODE_ATLAS || mode==EditorTextureImportPlugin::MODE_LARGE)
 			save_path->set_text(p_from);
 		else
 			save_path->set_text(p_from.get_base_dir());
@@ -518,6 +559,81 @@ Error EditorTextureImportDialog::import(const String& p_from, const String& p_to
 	return OK;
 }
 
+void EditorTextureImportDialog::_mode_changed(int p_mode) {
+
+	mode = EditorTextureImportPlugin::Mode(p_mode);
+
+	for(int i=0;i<EditorTextureImportPlugin::MODE_MAX;i++) {
+		mode_check[i]->set_pressed(i==mode);
+	}
+
+	if (p_mode==EditorTextureImportPlugin::MODE_ATLAS) {
+
+		size_label->set_text(TTR("Max Texture Size:"));
+		size->set_val(2048);
+		crop_source->show();
+		size_label->show();
+		size->show();
+
+		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS|EditorTextureImportPlugin::IMAGE_FLAG_FILTER);
+		texture_options->set_quality(0.7);
+		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_DISK_LOSSY);
+		set_title(TTR("Import Textures for Atlas (2D)"));
+
+	} else {
+		crop_source->hide();
+	}
+
+
+	if (p_mode==EditorTextureImportPlugin::MODE_LARGE) {
+
+		size_label->set_text(TTR("Cell Size:"));
+		size->set_val(256);
+		size_label->show();
+		size->show();
+
+		file_select->set_mode(EditorFileDialog::MODE_OPEN_FILE);
+		save_file_select->add_filter("*.ltex;"+TTR("Large Texture"));
+
+		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS|EditorTextureImportPlugin::IMAGE_FLAG_FILTER);
+		texture_options->set_quality(0.7);
+		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_DISK_LOSSLESS);
+		set_title(TTR("Import Large Textures (2D)"));
+		source_label->set_text(TTR("Source Texture"));
+
+	} else {
+		file_select->set_mode(EditorFileDialog::MODE_OPEN_FILES);
+		save_file_select->add_filter("*.tex;"+TTR("Base Atlas Texture"));
+		source_label->set_text(TTR("Source Texture(s)"));
+	}
+
+	if (p_mode==EditorTextureImportPlugin::MODE_TEXTURE_2D) {
+
+		size_label->hide();
+		size->hide();
+
+		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS|EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_FILTER);
+		texture_options->set_quality(0.7);
+		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_DISK_LOSSY);
+		notice_for_2d->show();
+		set_title(TTR("Import Textures for 2D"));
+
+	} else {
+		notice_for_2d->hide();
+	}
+
+	if (p_mode==EditorTextureImportPlugin::MODE_TEXTURE_3D) {
+
+		size_label->hide();
+		size->hide();
+		//texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_);
+		//texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS);
+		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_FILTER|EditorTextureImportPlugin::IMAGE_FLAG_REPEAT);
+		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_RAM);
+		set_title(TTR("Import Textures for 3D"));
+	}
+}
+
 void EditorTextureImportDialog::_bind_methods() {
 
 
@@ -527,28 +643,64 @@ void EditorTextureImportDialog::_bind_methods() {
 	ObjectTypeDB::bind_method("_import",&EditorTextureImportDialog::_import);
 	ObjectTypeDB::bind_method("_browse",&EditorTextureImportDialog::_browse);
 	ObjectTypeDB::bind_method("_browse_target",&EditorTextureImportDialog::_browse_target);
+	ObjectTypeDB::bind_method("_mode_changed",&EditorTextureImportDialog::_mode_changed);
 //	ADD_SIGNAL( MethodInfo("imported",PropertyInfo(Variant::OBJECT,"scene")) );
 }
 
-EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin* p_plugin, bool p_2d, bool p_atlas,bool p_large) {
+EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin* p_plugin) {
+
+
+
 
 
-	atlas=p_atlas;
-	large=p_large;
 	plugin=p_plugin;
 	set_title(TTR("Import Textures"));
 
+	mode_hb = memnew( HBoxContainer );
+	add_child(mode_hb);
+	set_child_rect(mode_hb);
+
+	VBoxContainer *vbcg = memnew( VBoxContainer);
+
+
+	mode_hb->add_child(vbcg);
+	mode_hb->add_constant_override("separation",15);
+	ButtonGroup *bg = memnew( ButtonGroup );
+	vbcg->add_margin_child("Import Mode",bg);
+
+	for(int i=0;i<EditorTextureImportPlugin::MODE_MAX;i++) {
+		String mode_name[EditorTextureImportPlugin::MODE_MAX]={
+			TTR("2D Texture"),
+			TTR("3D Texture"),
+			TTR("Atlas Texture"),
+			TTR("Large Texture")
+		};
+
+
+		mode_check[i]=memnew(CheckBox);
+		bg->add_child(mode_check[i]);
+		mode_check[i]->set_text(mode_name[i]);
+		mode_check[i]->connect("pressed",this,"_mode_changed",varray(i));
+	}
 
 	VBoxContainer *vbc = memnew(VBoxContainer);
-	add_child(vbc);
-	set_child_rect(vbc);
+	mode_hb->add_child(vbc);
+	vbc->set_h_size_flags(SIZE_EXPAND_FILL);
+	vbc->add_constant_override("separation",4);
 
+	notice_for_2d = memnew( Label );
+	notice_for_2d->set_text(TTR("NOTICE: Importing 2D textures is not mandatory. Just copy png/jpg files to the project."));
+	//notice_for_2d->set_custom_minimum_size(Size2(0,50));
+	notice_for_2d->set_autowrap(true);
+	notice_for_2d->hide();
+	vbcg->add_child(notice_for_2d);
+	notice_for_2d->set_v_size_flags(SIZE_EXPAND_FILL);
+	notice_for_2d->set_valign(Label::VALIGN_BOTTOM);
 
 	VBoxContainer *source_vb=memnew(VBoxContainer);
-	if (large)
-		vbc->add_margin_child(TTR("Source Texture:"),source_vb);
-	else
-		vbc->add_margin_child(TTR("Source Texture(s):"),source_vb);
+	MarginContainer *source_mc = vbc->add_margin_child(TTR("Source Texture(s):"),source_vb);
+
+	source_label = vbc->get_child(source_mc->get_index()-1)->cast_to<Label>();
 
 	HBoxContainer *hbc = memnew( HBoxContainer );
 	source_vb->add_child(hbc);
@@ -560,8 +712,6 @@ EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin*
 	crop_source->set_pressed(true);
 	source_vb->add_child(crop_source);
 	crop_source->set_text(TTR("Crop empty space."));
-	if (!p_atlas)
-		crop_source->hide();
 
 
 	Button * import_choose = memnew( Button );
@@ -577,13 +727,10 @@ EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin*
 	size->set_min(128);
 	size->set_max(16384);
 
-	if (p_atlas) {
-		size->set_val(2048);
-		vbc->add_margin_child(TTR("Max Texture Size:"),size);
-	} else {
-		size->set_val(256);
-		vbc->add_margin_child(TTR("Cell Size:"),size);
-	}
+
+	size->set_val(256);
+	size_mc=vbc->add_margin_child(TTR("Cell Size:"),size);
+	size_label=vbc->get_child(size_mc->get_index()-1)->cast_to<Label>();
 
 
 	save_path = memnew( LineEdit );
@@ -599,10 +746,7 @@ EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin*
 	file_select = memnew(EditorFileDialog);
 	file_select->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
 	add_child(file_select);
-	if (!large)
-		file_select->set_mode(EditorFileDialog::MODE_OPEN_FILES);
-	else
-		file_select->set_mode(EditorFileDialog::MODE_OPEN_FILE);
+
 	file_select->connect("files_selected", this,"_choose_files");
 	file_select->connect("file_selected", this,"_choose_file");
 
@@ -611,10 +755,7 @@ EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin*
 	add_child(save_file_select);
 	save_file_select->set_mode(EditorFileDialog::MODE_SAVE_FILE);
 	save_file_select->clear_filters();
-	if (large)
-		save_file_select->add_filter("*.ltex;"+TTR("Large Texture"));
-	else
-		save_file_select->add_filter("*.tex;"+TTR("Base Atlas Texture"));
+
 	save_file_select->connect("file_selected", this,"_choose_save_dir");
 
 	save_select = memnew(	EditorDirDialog );
@@ -641,36 +782,7 @@ EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin*
 	vbc->add_child(texture_options);
 	texture_options->set_v_size_flags(SIZE_EXPAND_FILL);
 
-	if (atlas) {
-
-		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS|EditorTextureImportPlugin::IMAGE_FLAG_FILTER);
-		texture_options->set_quality(0.7);
-		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_DISK_LOSSY);
-		//texture_options->show_2d_notice();
-		set_title(TTR("Import Textures for Atlas (2D)"));
-	} else if (large) {
-
-		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS|EditorTextureImportPlugin::IMAGE_FLAG_FILTER);
-		texture_options->set_quality(0.7);
-		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_DISK_LOSSLESS);
-		texture_options->show_2d_notice();
-		set_title(TTR("Import Large Textures (2D)"));
-
-	} else if (p_2d) {
-
-		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS|EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_FILTER);
-		texture_options->set_quality(0.7);
-		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_DISK_LOSSY);
-		texture_options->show_2d_notice();
-		set_title(TTR("Import Textures for 2D"));
-	} else {
-
-		//texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_);
-		//texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS);
-		texture_options->set_flags(EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA|EditorTextureImportPlugin::IMAGE_FLAG_FILTER|EditorTextureImportPlugin::IMAGE_FLAG_REPEAT);
-		texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_RAM);
-		set_title(TTR("Import Textures for 3D"));
-	}
+	_mode_changed(EditorTextureImportPlugin::MODE_TEXTURE_3D);
 
 
 //	GLOBAL_DEF("import/shared_textures","res://");
@@ -686,6 +798,8 @@ EditorTextureImportDialog::EditorTextureImportDialog(EditorTextureImportPlugin*
 
 String EditorTextureImportPlugin::get_name() const {
 
+	return "texture";
+#if 0 //old names, kept for compatibility reference
 	switch(mode) {
 		case MODE_TEXTURE_2D: {
 
@@ -707,34 +821,14 @@ String EditorTextureImportPlugin::get_name() const {
 
 	}
 
-	return "";
 
+	return "";
+#endif
 }
 
 String EditorTextureImportPlugin::get_visible_name() const {
 
-	switch(mode) {
-		case MODE_TEXTURE_2D: {
-
-			return "2D Texture";
-		} break;
-		case MODE_TEXTURE_3D: {
-
-			return "3D Texture";
-
-		} break;
-		case MODE_ATLAS: {
-
-			return "2D Atlas Texture";
-		} break;
-		case MODE_LARGE: {
-
-			return "2D Large Texture";
-		} break;
-
-	}
-
-	return "";
+	return "Texture";
 
 }
 void EditorTextureImportPlugin::import_dialog(const String& p_from) {
@@ -1626,15 +1720,93 @@ Vector<uint8_t> EditorTextureImportPlugin::custom_export(const String& p_path, c
 	return ret;
 }
 
+void EditorTextureImportPlugin::import_from_drop(const Vector<String>& p_drop,const String& p_dest_path) {
+
+	Vector<String> valid;
+
+	List<String> valid_extensions;
+	ImageLoader::get_recognized_extensions(&valid_extensions);
+	for(int i=0;i<p_drop.size();i++) {
+
+		String extension=p_drop[i].extension().to_lower();
+
+		for (List<String>::Element *E=valid_extensions.front();E;E=E->next()) {
+
+			if (E->get()==extension) {
+				valid.push_back(p_drop[i]);
+				break;
+			}
+		}
+	}
+
+	if (valid.size()) {
+		dialog->popup_import();
+		dialog->setup_multiple_import_3d(valid,p_dest_path);
+	}
+}
+
+void EditorTextureImportPlugin::reimport_multiple_files(const Vector<String>& p_list) {
+
+	Vector<String> valid;
+
+
+	bool warning=false;
+	for(int i=0;i<p_list.size();i++) {
+
+		Ref<ResourceImportMetadata> rimd = ResourceLoader::load_import_metadata(p_list[i]);
+		String type = rimd->get_editor();
+		if (type=="texture" || type.begins_with("texture_")) {
+
+			if ((rimd->has_option("atlas") && rimd->get_option("atlas")) || (rimd->has_option("large") && rimd->get_option("large"))) {
+				warning=true;
+				continue;
+			}
+
+			valid.push_back(p_list[i]);
+		}
+	}
+
+	if (valid.size()) {
+
+		dialog->popup_import(valid[0]);
+
+		Vector<String> sources;
+		for(int i=0;i<valid.size();i++) {
+			int idx;
+			EditorFileSystemDirectory *efsd = EditorFileSystem::get_singleton()->find_file(valid[i],&idx);
+			if (efsd) {
+				for(int j=0;j<efsd->get_source_count(idx);j++) {
+					String file = expand_source_path(efsd->get_source_file(idx,j));
+					if (sources.find(file)==-1) {
+						sources.push_back(file);
+					}
+
+				}
+			}
+		}
+
+		if (sources.size()) {
+
+			dialog->add_sources_and_dest(sources,valid[0].get_base_dir());
+		}
+	}
+}
+
+bool EditorTextureImportPlugin::can_reimport_multiple_files() const {
+
+	return true;
+
+}
+
+
 
-EditorTextureImportPlugin *EditorTextureImportPlugin::singleton[EditorTextureImportPlugin::MODE_MAX]={NULL,NULL,NULL,NULL};
+EditorTextureImportPlugin *EditorTextureImportPlugin::singleton=NULL;
 
-EditorTextureImportPlugin::EditorTextureImportPlugin(EditorNode *p_editor, Mode p_mode) {
+EditorTextureImportPlugin::EditorTextureImportPlugin(EditorNode *p_editor) {
 
-	singleton[p_mode]=this;
-	editor=p_editor;
-	mode=p_mode;
-	dialog = memnew( EditorTextureImportDialog(this,p_mode==MODE_TEXTURE_2D || p_mode==MODE_ATLAS || p_mode==MODE_LARGE,p_mode==MODE_ATLAS,p_mode==MODE_LARGE) );
+	singleton=this;
+	editor=p_editor;	
+	dialog = memnew( EditorTextureImportDialog(this) );
 	editor->get_gui_base()->add_child(dialog);
 
 }
diff --git a/tools/editor/io_plugins/editor_texture_import_plugin.h b/tools/editor/io_plugins/editor_texture_import_plugin.h
index cb63ba98c..5c8abd10a 100644
--- a/tools/editor/io_plugins/editor_texture_import_plugin.h
+++ b/tools/editor/io_plugins/editor_texture_import_plugin.h
@@ -64,10 +64,10 @@ public:
 
 
 private:
-	Mode mode;
+
 	EditorNode *editor;
 	EditorTextureImportDialog *dialog;
-	static EditorTextureImportPlugin *singleton[MODE_MAX];
+	static EditorTextureImportPlugin *singleton;
 	//used by other importers such as mesh
 
 	Error _process_texture_data(Ref<ImageTexture> &texture, int format, float quality, int flags,EditorExportPlatform::ImageCompression p_compr,int tex_flags,float shrink);
@@ -75,7 +75,7 @@ private:
 public:
 
 
-	static EditorTextureImportPlugin *get_singleton(Mode p_mode) { return singleton[p_mode]; }
+	static EditorTextureImportPlugin *get_singleton() { return singleton; }
 
 	enum ImageFormat {
 
@@ -100,7 +100,6 @@ public:
 		IMAGE_FLAG_USE_ANISOTROPY=1024, //convert image to linear
 	};
 
-	Mode get_mode() const { return mode; }
 	virtual String get_name() const;
 	virtual String get_visible_name() const;
 	virtual void import_dialog(const String& p_from="");
@@ -108,8 +107,11 @@ public:
 	virtual Error import2(const String& p_path, const Ref<ResourceImportMetadata>& p_from,EditorExportPlatform::ImageCompression p_compr, bool p_external=false);
 	virtual Vector<uint8_t> custom_export(const String& p_path,const Ref<EditorExportPlatform> &p_platform);
 
+	virtual void import_from_drop(const Vector<String>& p_drop,const String& p_dest_path);
+	virtual void reimport_multiple_files(const Vector<String>& p_list);
+	virtual bool can_reimport_multiple_files() const;
 
-	EditorTextureImportPlugin(EditorNode* p_editor=NULL,Mode p_mode=MODE_TEXTURE_2D);
+	EditorTextureImportPlugin(EditorNode* p_editor=NULL);
 };
 
 
@@ -134,7 +136,7 @@ class EditorImportTextureOptions : public VBoxContainer {
 	HSlider *quality;
 	Tree *flags;
 	Vector<TreeItem*> items;
-	Label *notice_for_2d;
+
 
 	bool updating;
 
diff --git a/tools/editor/io_plugins/editor_translation_import_plugin.cpp b/tools/editor/io_plugins/editor_translation_import_plugin.cpp
index b57e4cb84..282153fa7 100644
--- a/tools/editor/io_plugins/editor_translation_import_plugin.cpp
+++ b/tools/editor/io_plugins/editor_translation_import_plugin.cpp
@@ -394,6 +394,26 @@ void EditorTranslationImportPlugin::import_dialog(const String& p_from) {
 	dialog->popup_import(p_from);
 }
 
+
+
+void EditorTranslationImportPlugin::import_from_drop(const Vector<String>& p_drop, const String &p_dest_path) {
+
+
+	for(int i=0;i<p_drop.size();i++) {
+		String ext = p_drop[i].extension().to_lower();
+
+		if (ext=="csv") {
+
+			import_dialog();
+			dialog->_choose_file(p_drop[i]);
+			dialog->_choose_save_dir(p_dest_path);
+			break;
+		}
+	}
+
+
+}
+
 Error EditorTranslationImportPlugin::import(const String& p_path, const Ref<ResourceImportMetadata>& p_from) {
 
 	Ref<ResourceImportMetadata> from = p_from;
diff --git a/tools/editor/io_plugins/editor_translation_import_plugin.h b/tools/editor/io_plugins/editor_translation_import_plugin.h
index cadcdc03b..532f2cedc 100644
--- a/tools/editor/io_plugins/editor_translation_import_plugin.h
+++ b/tools/editor/io_plugins/editor_translation_import_plugin.h
@@ -46,6 +46,7 @@ public:
 	virtual String get_visible_name() const;
 	virtual void import_dialog(const String& p_from="");
 	virtual Error import(const String& p_path, const Ref<ResourceImportMetadata>& p_from);
+	void import_from_drop(const Vector<String>& p_drop, const String &p_dest_path);
 
 
 	EditorTranslationImportPlugin(EditorNode* p_editor);