godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/tools/editor/project_export.cpp

1921 lines
59 KiB
C++
Raw Blame History

/*************************************************************************/
/* project_export.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "project_export.h"
#include "os/dir_access.h"
#include "os/file_access.h"
#include "globals.h"
#include "io/resource_loader.h"
#include "io/resource_saver.h"
#include "os/os.h"
#include "scene/gui/box_container.h"
#include "default_saver.h"
#include "scene/gui/tab_container.h"
#include "scene/gui/scroll_container.h"
#include "editor_data.h"
#include "io/image_loader.h"
#include "compressed_translation.h"
#include "editor_node.h"
#include "io_plugins/editor_texture_import_plugin.h"
#include "editor_settings.h"
const char *ProjectExportDialog::da_string[ProjectExportDialog::ACTION_MAX]={
"",
"Copy",
"Bundle"
};
bool ProjectExportDialog::_create_tree(TreeItem *p_parent,EditorFileSystemDirectory *p_dir) {
TreeItem *item = tree->create_item(p_parent);
item->set_text(0,p_dir->get_name()+"/");
item->set_icon(0,get_icon("Folder","EditorIcons"));
bool has_items=false;
for(int i=0;i<p_dir->get_subdir_count();i++) {
if (_create_tree(item,p_dir->get_subdir(i)))
has_items=true;
}
// int cc = p_options.get_slice_count(",");
for (int i=0;i<p_dir->get_file_count();i++) {
TreeItem *fitem = tree->create_item(item);
//fitem->set_cell_mode(0,TreeItem::CELL_MODE_CHECK);
//fitem->set_editable(0,true);
// fitem->set_checked(0,isfave);
fitem->set_text(0,p_dir->get_file(i));
String path = p_dir->get_file_path(i);
fitem->set_tooltip(0,path);
fitem->set_metadata(0,path);
Ref<Texture> icon = get_icon( (has_icon(p_dir->get_file_type(i),ei)?p_dir->get_file_type(i):ot),ei);
fitem->set_icon(0,icon);
fitem->set_cell_mode(1,TreeItem::CELL_MODE_RANGE);
fitem->set_range_config(1,0,2,1);
fitem->set_text(1,expopt);
fitem->set_editable(1,true);
EditorImportExport::FileAction fa = EditorImportExport::get_singleton()->get_export_file_action(path);
fitem->set_range(1,fa);
has_items=true;
}
if (!has_items) {
memdelete(item);
return false;
}
return true;
}
void ProjectExportDialog::_tree_changed() {
TreeItem *t=tree->get_selected();
if (!t)
return;
String selected = t->get_metadata(0);
EditorImportExport::get_singleton()->set_export_file_action(selected,EditorImportExport::FileAction(int(t->get_range(1))));
_save_export_cfg();
//editor->save_import_export(true);
//EditorImportDB::get_singleton()->save_settings();
}
void ProjectExportDialog::popup_export() {
popup_centered_ratio();
if (pending_update_tree) {
_update_tree();
_update_group_tree();
pending_update_tree=false;
}
}
void ProjectExportDialog::_update_tree() {
updating_tree=true;
tree->clear();
EditorFileSystemDirectory *efsd = EditorFileSystem::get_singleton()->get_filesystem();
if (efsd) {
_create_tree(NULL,efsd);
}
updating_tree=false;
}
void ProjectExportDialog::_update_platform() {
_validate_platform();
TreeItem *selected = platforms->get_selected();
if (!selected)
return;
String platform = selected->get_metadata(0);
Ref<EditorExportPlatform> exporter = EditorImportExport::get_singleton()->get_export_platform(platform);
platform_options->edit( exporter.ptr() );
}
void ProjectExportDialog::_platform_selected() {
String p =platforms->get_selected()->get_metadata(0);
_update_platform();
// editor->save_import_export();
// EditorFileSystem::get_singleton()->scan();
}
void ProjectExportDialog::_scan_finished() {
/* print_line("**********SCAN DONEEE********");
print_line("**********SCAN DONEEE********");
print_line("**********SCAN DONEEE********");
print_line("**********SCAN DONEEE********");*/
if (!is_visible()) {
pending_update_tree=true;
return;
}
_update_tree();
_update_group_tree();
}
void ProjectExportDialog::_rescan() {
EditorFileSystem::get_singleton()->scan();
}
void ProjectExportDialog::_update_exporter() {
}
void ProjectExportDialog::_save_export_cfg() {
EditorImportExport::get_singleton()->save_config();
}
void ProjectExportDialog::_prop_edited(String what) {
_save_export_cfg();
_validate_platform();
}
void ProjectExportDialog::_filters_edited(String what) {
EditorImportExport::get_singleton()->set_export_custom_filter(what);
_save_export_cfg();
}
void ProjectExportDialog::_filters_exclude_edited(String what) {
EditorImportExport::get_singleton()->set_export_custom_filter_exclude(what);
_save_export_cfg();
}
void ProjectExportDialog::_quality_edited(float what) {
EditorImportExport::get_singleton()->set_export_image_quality(what);
_save_export_cfg();
}
void ProjectExportDialog::_shrink_edited(float what) {
EditorImportExport::get_singleton()->set_export_image_shrink(what);
_save_export_cfg();
}
void ProjectExportDialog::_image_export_edited(int what) {
EditorImportExport::get_singleton()->set_export_image_action(EditorImportExport::ImageAction(what));
_save_export_cfg();
}
void ProjectExportDialog::_format_toggled() {
EditorImportExport::get_singleton()->get_image_formats().clear();
for(int i=0;i<formats.size();i++) {
if (formats[i]->is_checked(0))
EditorImportExport::get_singleton()->get_image_formats().insert( formats[i]->get_text(0));
}
_save_export_cfg();
}
void ProjectExportDialog::_script_edited(Variant v) {
if (updating_script)
return;
updating_script=true;
EditorNode::get_undo_redo()->create_action(TTR("Edit Script Options"));
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"script_set_action",script_mode->get_selected());
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"script_set_action",EditorImportExport::get_singleton()->script_get_action());
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"script_set_encryption_key",script_key->get_text());
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"script_set_encryption_key",EditorImportExport::get_singleton()->script_get_encryption_key());
EditorNode::get_undo_redo()->add_do_method(this,"_update_script");
EditorNode::get_undo_redo()->add_undo_method(this,"_update_script");
EditorNode::get_undo_redo()->add_do_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->add_undo_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->commit_action();
updating_script=false;
}
void ProjectExportDialog::_sample_convert_edited(int what) {
EditorImportExport::get_singleton()->sample_set_action( EditorImportExport::SampleAction(sample_mode->get_selected()));
EditorImportExport::get_singleton()->sample_set_max_hz( sample_max_hz->get_val() );
EditorImportExport::get_singleton()->sample_set_trim( sample_trim->is_pressed() );
_save_export_cfg();
}
void ProjectExportDialog::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_ENTER_TREE: {
CenterContainer *cc = memnew( CenterContainer );
TextureFrame *tf = memnew( TextureFrame);
tf->set_texture(get_icon("ErrorSign","EditorIcons"));
cc->add_child(tf);
plat_errors->add_child(cc);
platform_error_string->raise();
TreeItem *root = platforms->create_item(NULL);
List<StringName> ep;
EditorImportExport::get_singleton()->get_export_platforms(&ep);
ep.sort_custom<StringName::AlphCompare>();
for(List<StringName>::Element *E=ep.front();E;E=E->next()) {
Ref<EditorExportPlatform> eep = EditorImportExport::get_singleton()->get_export_platform(E->get());
TreeItem *p = platforms->create_item(root);
p->set_text(0,eep->get_name());
p->set_icon(0,eep->get_logo());
p->set_metadata(0,eep->get_name());
if (eep->get_name()==OS::get_singleton()->get_name())
p->select(0);
}
EditorFileSystem::get_singleton()->connect("filesystem_changed",this,"_scan_finished");
// _rescan();
_update_platform();
export_mode->select( EditorImportExport::get_singleton()->get_export_filter() );
convert_text_scenes->set_pressed( EditorImportExport::get_singleton()->get_convert_text_scenes() );
filters->set_text( EditorImportExport::get_singleton()->get_export_custom_filter() );
filters_exclude->set_text( EditorImportExport::get_singleton()->get_export_custom_filter_exclude() );
if (EditorImportExport::get_singleton()->get_export_filter()!=EditorImportExport::EXPORT_SELECTED)
tree_vb->hide();
else
tree_vb->show();
image_action->select(EditorImportExport::get_singleton()->get_export_image_action());
image_quality->set_val(EditorImportExport::get_singleton()->get_export_image_quality());
image_shrink->set_val(EditorImportExport::get_singleton()->get_export_image_shrink());
_update_script();
image_quality->connect("value_changed",this,"_quality_edited");
image_shrink->connect("value_changed",this,"_shrink_edited");
image_action->connect("item_selected",this,"_image_export_edited");
script_mode->connect("item_selected",this,"_script_edited");
script_key->connect("text_changed",this,"_script_edited");
for(int i=0;i<formats.size();i++) {
if (EditorImportExport::get_singleton()->get_image_formats().has(formats[i]->get_text(0)))
formats[i]->set_checked(0,true);
}
image_formats->connect("item_edited",this,"_format_toggled");
group_add->set_icon(get_icon("Add","EditorIcons"));
// group_del->set_icon(get_icon("Del","EditorIcons"));
_update_group_list();
_update_group();
_update_group_tree();
sample_mode->select( EditorImportExport::get_singleton()->sample_get_action() );
sample_max_hz->set_val( EditorImportExport::get_singleton()->sample_get_max_hz() );
sample_trim->set_pressed( EditorImportExport::get_singleton()->sample_get_trim() );
sample_mode->connect("item_selected",this,"_sample_convert_edited");
sample_max_hz->connect("value_changed",this,"_sample_convert_edited");
sample_trim->connect("toggled",this,"_sample_convert_edited");
} break;
case NOTIFICATION_EXIT_TREE: {
} break;
case MainLoop::NOTIFICATION_WM_FOCUS_IN: {
//something may have changed
_validate_platform();
} break;
case NOTIFICATION_VISIBILITY_CHANGED: {
if (is_visible())
_validate_platform();
} break;
case NOTIFICATION_PROCESS: {
} break;
}
}
void ProjectExportDialog::_validate_platform() {
get_ok()->set_disabled(true);
button_export->set_disabled(true);
TreeItem *selected = platforms->get_selected();
plat_errors->hide();
if (!selected) {
return;
}
String platform = selected->get_metadata(0);
Ref<EditorExportPlatform> exporter = EditorImportExport::get_singleton()->get_export_platform(platform);
if (!exporter.is_valid()) {
return;
}
String err;
if (!exporter->can_export(&err)) {
Vector<String> items = err.strip_edges().split("\n");
err="";
for(int i=0;i<items.size();i++) {
if (i!=0)
err+="\n";
err+=" -"+items[i];
}
platform_error_string->set_text(err);
plat_errors->show();
return;
}
List<String> pl;
EditorFileSystem::get_singleton()->get_changed_sources(&pl);
if (false && pl.size()) {
if (pl.size()==1)
platform_error_string->set_text(" -One Resource is pending re-import.");
else
platform_error_string->set_text(" "+itos(pl.size())+" Resources are pending re-import.");
plat_errors->show();
return;
}
get_ok()->set_disabled(false);
button_export->set_disabled(false);
}
void ProjectExportDialog::_export_mode_changed(int p_idx) {
bool do_all = p_idx==0;
if (EditorImportExport::get_singleton()->get_export_filter()==p_idx)
return;
EditorImportExport::get_singleton()->set_export_filter(EditorImportExport::ExportFilter(p_idx));
if (p_idx!=EditorImportExport::EXPORT_SELECTED)
tree_vb->hide();
else
tree_vb->show();
EditorImportExport::get_singleton()->set_convert_text_scenes( convert_text_scenes->is_pressed() );
_save_export_cfg();
}
void ProjectExportDialog::_export_action(const String& p_file) {
String location = Globals::get_singleton()->globalize_path(p_file).get_base_dir().replace("\\","/");
while(true) {
print_line("TESTING: "+location.plus_file("engine.cfg"));
if (FileAccess::exists(location.plus_file("engine.cfg"))) {
error->set_text(TTR("Please export outside the project folder!"));
error->popup_centered_minsize();
return;
}
String nl = (location+"/..").simplify_path();
if (nl.find("/")==location.find_last("/"))
break;
location=nl;
}
/* Checked if the export location is outside the project directory,
* now will check if a file name has been entered */
if (p_file.ends_with("/")) {
error->set_text("Please enter a file name!");
error->popup_centered_minsize();
return;
}
TreeItem *selected = platforms->get_selected();
if (!selected)
return;
String platform = selected->get_metadata(0);
bool debugging_enabled = EditorImportExport::get_singleton()->get_export_platform(platform)->is_debugging_enabled();
Error err = export_platform(platform,p_file,debugging_enabled,file_export_password->get_text(),false);
if (err!=OK) {
error->set_text(TTR("Error exporting project!"));
error->popup_centered_minsize();
}
}
void ProjectExportDialog::_export_action_pck(const String& p_file) {
TreeItem *selected = platforms->get_selected();
if (!selected)
return;
Ref<EditorExportPlatform> exporter = EditorImportExport::get_singleton()->get_export_platform(selected->get_metadata(0));
if (exporter.is_null()) {
ERR_PRINT("Invalid platform for export of PCK");
return;
}
if (p_file.ends_with(".pck")) {
FileAccess *f = FileAccess::open(p_file,FileAccess::WRITE);
if (!f) {
error->set_text(TTR("Error exporting project PCK! Can't write"));
error->popup_centered_minsize();
}
ERR_FAIL_COND(!f);
Error err = exporter->save_pack(f,false);
memdelete(f);
if (err!=OK) {
error->set_text(TTR("Error exporting project!"));
error->popup_centered_minsize();
return;
}
} else if (p_file.ends_with(".zip")) {
Error err = exporter->save_zip(p_file,false);
if (err!=OK) {
error->set_text(TTR("Error exporting project!"));
error->popup_centered_minsize();
return;
}
}
}
Error ProjectExportDialog::export_platform(const String& p_platform, const String& p_path, bool p_debug,const String& p_password, bool p_quit_after) {
Ref<EditorExportPlatform> exporter = EditorImportExport::get_singleton()->get_export_platform(p_platform);
if (exporter.is_null()) {
ERR_PRINT("Invalid platform for export");
List<StringName> platforms;
EditorImportExport::get_singleton()->get_export_platforms(&platforms);
print_line("Valid export plaftorms are:");
for (List<StringName>::Element *E=platforms.front();E;E=E->next())
print_line(" \""+E->get()+"\"");
if (p_quit_after) {
OS::get_singleton()->set_exit_code(255);
get_tree()->quit();
}
return ERR_INVALID_PARAMETER;
}
Error err = exporter->export_project(p_path,p_debug);
if (err!=OK) {
error->set_text(TTR("Error exporting project!"));
error->popup_centered_minsize();
ERR_PRINT("Exporting failed!");
if (p_quit_after) {
OS::get_singleton()->set_exit_code(255);
get_tree()->quit();
}
return ERR_CANT_CREATE;
} else {
if (p_quit_after) {
get_tree()->quit();
}
}
return OK;
}
void ProjectExportDialog::ok_pressed() {
//export pck
pck_export->popup_centered_ratio();
}
void ProjectExportDialog::custom_action(const String&) {
//real export
TreeItem *selected = platforms->get_selected();
if (!selected)
return;
String platform = selected->get_metadata(0);
Ref<EditorExportPlatform> exporter = EditorImportExport::get_singleton()->get_export_platform(platform);
if (exporter.is_null()) {
error->set_text(TTR("No exporter for platform '")+platform+"' yet.");
error->popup_centered_minsize();
return;
}
String extension = exporter->get_binary_extension();
file_export_password->set_editable( exporter->requires_password(exporter->is_debugging_enabled()) );
file_export->clear_filters();
if (extension!="") {
file_export->add_filter("*."+extension);
}
file_export->popup_centered_ratio();
}
void ProjectExportDialog::_group_selected() {
_update_group(); //?
_update_group_tree();
}
String ProjectExportDialog::_get_selected_group() {
TreeItem *sel = groups->get_selected();
if (!sel)
return String();
return sel->get_text(0);
}
void ProjectExportDialog::_update_group_list() {
String current = _get_selected_group();
groups->clear();
List<StringName> grouplist;
EditorImportExport::get_singleton()->image_export_get_groups(&grouplist);
grouplist.sort_custom<StringName::AlphCompare>();
TreeItem *r = groups->create_item();
for (List<StringName>::Element *E=grouplist.front();E;E=E->next()) {
TreeItem *ti = groups->create_item(r);
ti->set_text(0,E->get());
ti->add_button(0,get_icon("Remove","EditorIcons"));
if (E->get()==current) {
ti->select(0);
}
}
_update_group();
}
void ProjectExportDialog::_select_group(const String& p_by_name) {
TreeItem *c = groups->get_root();
if (!c)
return;
c=c->get_children();
if (!c)
return;
while(c) {
if (c->get_text(0)==p_by_name) {
c->select(0);
_update_group();
return;
}
c=c->get_next();
}
}
void ProjectExportDialog::_update_group() {
if (updating)
return;
updating=true;
if (_get_selected_group()=="") {
group_options->hide();
//group_del->set_disabled(true);
} else {
group_options->show();
//group_del->set_disabled(false);
StringName name = _get_selected_group();
group_image_action->select(EditorImportExport::get_singleton()->image_export_group_get_image_action(name));
group_atlas->set_pressed(EditorImportExport::get_singleton()->image_export_group_get_make_atlas(name));
group_shrink->set_val(EditorImportExport::get_singleton()->image_export_group_get_shrink(name));
group_lossy_quality->set_val(EditorImportExport::get_singleton()->image_export_group_get_lossy_quality(name));
if (group_atlas->is_pressed())
atlas_preview->show();
else
atlas_preview->hide();
}
_update_group_tree();
updating=false;
}
bool ProjectExportDialog::_update_group_treef(TreeItem *p_parent,EditorFileSystemDirectory *p_dir,const Set<String>& p_extensions,const String& p_groups,const Map<StringName,int>& p_group_index) {
TreeItem *ti = group_images->create_item(p_parent);
ti->set_text(0,p_dir->get_name()+"/");
bool has_child=false;
for(int i=0;i<p_dir->get_subdir_count();i++) {
if (_update_group_treef(ti,p_dir->get_subdir(i),p_extensions,p_groups,p_group_index)) {
has_child=true;
}
}
String filter=group_images_filter->get_text();
StringName current_group = _get_selected_group();
String check_text=TTR("Include");
for(int i=0;i<p_dir->get_file_count();i++) {
String fname = p_dir->get_file(i);
if (p_extensions.has(fname.to_lower().extension())) {
String path = p_dir->get_file_path(i);
if (filter!=String() && path.find(filter)==-1)
continue;
has_child=true;
TreeItem *file = group_images->create_item(ti);
file->set_text(0,fname);
StringName g = EditorImportExport::get_singleton()->image_get_export_group(path);
if (current_group==g || g==StringName()) {
file->set_cell_mode(1,TreeItem::CELL_MODE_CHECK);
file->set_text(1,check_text);
file->set_editable(1,true);
file->set_checked(1,current_group==g);
} else {
file->set_text(1,g);
file->set_editable(1,false);
file->set_selectable(1,false);
}
file->set_metadata(0,path);
}
}
if (!has_child) {
memdelete(ti);
return false;
}
return true;
}
void ProjectExportDialog::_update_group_tree() {
if (updating)
return;
group_images->clear();
if (_get_selected_group()=="")
return;
updating=true;
print_line("****UGT");
List<String> img_extensions;
ImageLoader::get_recognized_extensions(&img_extensions);
Set<String> extensions;
for(List<String>::Element *E=img_extensions.front();E;E=E->next()) {
extensions.insert(E->get());
}
List<StringName> grouplist;
EditorImportExport::get_singleton()->image_export_get_groups(&grouplist);
grouplist.sort_custom<StringName::AlphCompare>();
Map<StringName,int> group_index;
group_index[StringName()]=0;
int idx=1;
String groupenum="--";
for(List<StringName>::Element *E=grouplist.front();E;E=E->next()) {
group_index[E->get()]=idx++;
groupenum+=","+String(E->get());
}
updating=false;
_update_group_treef(NULL,EditorFileSystem::get_singleton()->get_filesystem(),extensions,groupenum,group_index);
}
void ProjectExportDialog::_group_changed(Variant v) {
if (updating)
return;
if (_get_selected_group()=="")
return;
updating=true;
StringName name = _get_selected_group();
EditorNode::get_undo_redo()->create_action(TTR("Change Image Group"));
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_export_group_set_image_action",name,group_image_action->get_selected());
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_export_group_set_make_atlas",name,group_atlas->is_pressed());
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_export_group_set_shrink",name,group_shrink->get_val());
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_export_group_set_lossy_quality",name,group_lossy_quality->get_val());
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_image_action",name,EditorImportExport::get_singleton()->image_export_group_get_image_action(name));
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_make_atlas",name,EditorImportExport::get_singleton()->image_export_group_get_make_atlas(name));
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_shrink",name,EditorImportExport::get_singleton()->image_export_group_get_shrink(name));
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_lossy_quality",name,EditorImportExport::get_singleton()->image_export_group_get_lossy_quality(name));
EditorNode::get_undo_redo()->add_do_method(this,"_update_group");
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group");
EditorNode::get_undo_redo()->add_do_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->add_undo_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->commit_action();
updating=false;
// update atlas preview button
_update_group();
}
void ProjectExportDialog::_group_item_edited() {
TreeItem *item = group_images->get_edited();
if (!item)
return;
if (_get_selected_group()==String())
return;
StringName path = item->get_metadata(0);
String group;
if (item->is_checked(1)) {
group=_get_selected_group();
} else {
group=String();
}
print_line("changed "+path+" to group: "+group);
EditorNode::get_undo_redo()->create_action(TTR("Change Image Group"));
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_add_to_export_group",path,group);
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_add_to_export_group",path,EditorImportExport::get_singleton()->image_get_export_group(path));
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_do_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_do_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->add_undo_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->commit_action();
}
void ProjectExportDialog::_group_add() {
String name = group_new_name->get_text();
if (name=="") {
group_new_name_error->show();
group_new_name_error->set_text(TTR("Group Name Can't be Empty!"));
return;
}
if (name.find("/")!=-1 || name.find(":")!=-1 || name.find(",")!=-1 || name.find("-")!=-1) {
group_new_name_error->set_text(TTR("Invalid Character in Group Name!"));
group_new_name_error->show();
return;
}
if (EditorImportExport::get_singleton()->image_export_has_group(name)) {
group_new_name_error->set_text(TTR("Group Name Already Exists!"));
group_new_name_error->show();
return;
}
group_new_name_error->hide();
String current=_get_selected_group();
EditorNode::get_undo_redo()->create_action(TTR("Add Image Group"));
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_export_group_create",name);
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_remove",name);
EditorNode::get_undo_redo()->add_do_method(this,"_update_group_list");
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group_list");
EditorNode::get_undo_redo()->add_do_method(this,"_select_group",name);
if (current!="")
EditorNode::get_undo_redo()->add_undo_method(this,"_select_group",current);
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_do_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_do_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->add_undo_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->commit_action();
}
void ProjectExportDialog::_group_del(Object *p_item, int p_column, int p_button){
TreeItem *item = p_item->cast_to<TreeItem>();
if (!item)
return;
String name = item->get_text(0);
EditorNode::get_undo_redo()->create_action(TTR("Delete Image Group"));
List<StringName> images_used;
EditorImportExport::get_singleton()->image_export_get_images_in_group(name,&images_used);
for (List<StringName>::Element*E=images_used.front();E;E=E->next()) {
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_add_to_export_group",E->get(),StringName());
}
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_export_group_remove",name);
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_create",name);
for (List<StringName>::Element*E=images_used.front();E;E=E->next()) {
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_add_to_export_group",E->get(),name);
}
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_image_action",name,EditorImportExport::get_singleton()->image_export_group_get_image_action(name));
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_make_atlas",name,EditorImportExport::get_singleton()->image_export_group_get_make_atlas(name));
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_shrink",name,EditorImportExport::get_singleton()->image_export_group_get_shrink(name));
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_export_group_set_lossy_quality",name,EditorImportExport::get_singleton()->image_export_group_get_lossy_quality(name));
EditorNode::get_undo_redo()->add_do_method(this,"_update_group_list");
EditorNode::get_undo_redo()->add_do_method(this,"_update_group");
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group_list");
EditorNode::get_undo_redo()->add_undo_method(this,"_select_group",name);
EditorNode::get_undo_redo()->add_do_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_do_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->add_undo_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->commit_action();
}
void ProjectExportDialog::_group_select_all() {
String group = _get_selected_group();
if (group=="")
return;
TreeItem *item = group_images->get_root();
if (!item)
return;
List<StringName> items;
while(item) {
if (item->get_cell_mode(1)==TreeItem::CELL_MODE_CHECK && !item->is_checked(1))
items.push_back(item->get_metadata(0));
item=item->get_next_visible();
}
if (items.size()==0)
return;
EditorNode::get_undo_redo()->create_action(TTR("Select All"));
for (List<StringName>::Element *E=items.front();E;E=E->next()) {
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_add_to_export_group",E->get(),group);
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_add_to_export_group",E->get(),String());
}
EditorNode::get_undo_redo()->add_do_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_do_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->add_undo_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->commit_action();
}
void ProjectExportDialog::_group_select_none(){
String group = _get_selected_group();
if (group=="")
return;
TreeItem *item = group_images->get_root();
if (!item)
return;
List<StringName> items;
while(item) {
if (item->get_cell_mode(1)==TreeItem::CELL_MODE_CHECK && item->is_checked(1))
items.push_back(item->get_metadata(0));
item=item->get_next_visible();
}
if (items.size()==0)
return;
EditorNode::get_undo_redo()->create_action(TTR("Select All"));
for (List<StringName>::Element *E=items.front();E;E=E->next()) {
EditorNode::get_undo_redo()->add_do_method(EditorImportExport::get_singleton(),"image_add_to_export_group",E->get(),String());
EditorNode::get_undo_redo()->add_undo_method(EditorImportExport::get_singleton(),"image_add_to_export_group",E->get(),group);
}
EditorNode::get_undo_redo()->add_do_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_undo_method(this,"_update_group_tree");
EditorNode::get_undo_redo()->add_do_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->add_undo_method(this,"_save_export_cfg");
EditorNode::get_undo_redo()->commit_action();
}
void ProjectExportDialog::_group_atlas_preview() {
StringName group = _get_selected_group();
if (!group)
return;
atlas_preview_frame->set_texture(Ref<Texture>()); //clear previous
List<StringName> images;
EditorImportExport::get_singleton()->image_export_get_images_in_group(group,&images);
images.sort_custom<StringName::AlphCompare>();
String dst_file = EditorSettings::get_singleton()->get_settings_path()+"/tmp/atlas-preview.tex";
Ref<ResourceImportMetadata> imd = memnew( ResourceImportMetadata );
//imd->set_editor();
for (List<StringName>::Element *F=images.front();F;F=F->next()) {
imd->add_source(EditorImportPlugin::validate_source_path(F->get()));
}
int flags=0;
if (Globals::get_singleton()->get("image_loader/filter"))
flags|=EditorTextureImportPlugin::IMAGE_FLAG_FILTER;
if (!Globals::get_singleton()->get("image_loader/gen_mipmaps"))
flags|=EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS;
if (!Globals::get_singleton()->get("image_loader/repeat"))
flags|=EditorTextureImportPlugin::IMAGE_FLAG_REPEAT;
flags|=EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA;
imd->set_option("format",EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_DISK_LOSSLESS);
imd->set_option("flags",flags);
imd->set_option("quality",0.7);
imd->set_option("atlas",true);
imd->set_option("crop",true);
Ref<EditorTextureImportPlugin> plugin = EditorImportExport::get_singleton()->get_import_plugin_by_name("texture_atlas");
Error err = plugin->import2(dst_file,imd,EditorExportPlatform::IMAGE_COMPRESSION_NONE,true);
if (err) {
EditorNode::add_io_error(TTR("Error saving atlas! ")+dst_file.get_file());
return;
}
Ref<Texture> tex = ResourceLoader::load(dst_file);
atlas_preview_frame->set_texture(tex); //clear previous
atlas_preview_dialog->set_title(TTR("Atlas Preview (")+itos(tex->get_width())+"x"+itos(tex->get_height())+")");
atlas_preview_dialog->popup_centered_ratio(0.9);
}
void ProjectExportDialog::_update_script() {
if (updating_script)
return;
updating_script=true;
script_mode->select(EditorImportExport::get_singleton()->script_get_action());
script_key->set_text(EditorImportExport::get_singleton()->script_get_encryption_key());
updating_script=false;
}
void ProjectExportDialog::_image_filter_changed(String) {
_update_group_tree();
}
void ProjectExportDialog::_bind_methods() {
ObjectTypeDB::bind_method(_MD("_rescan"),&ProjectExportDialog::_rescan);
ObjectTypeDB::bind_method(_MD("_tree_changed"),&ProjectExportDialog::_tree_changed);
ObjectTypeDB::bind_method(_MD("_scan_finished"),&ProjectExportDialog::_scan_finished);
ObjectTypeDB::bind_method(_MD("_platform_selected"),&ProjectExportDialog::_platform_selected);
ObjectTypeDB::bind_method(_MD("_prop_edited"),&ProjectExportDialog::_prop_edited);
ObjectTypeDB::bind_method(_MD("_export_mode_changed"),&ProjectExportDialog::_export_mode_changed);
ObjectTypeDB::bind_method(_MD("_filters_edited"),&ProjectExportDialog::_filters_edited);
ObjectTypeDB::bind_method(_MD("_filters_exclude_edited"),&ProjectExportDialog::_filters_exclude_edited);
ObjectTypeDB::bind_method(_MD("_export_action"),&ProjectExportDialog::_export_action);
ObjectTypeDB::bind_method(_MD("_export_action_pck"),&ProjectExportDialog::_export_action_pck);
ObjectTypeDB::bind_method(_MD("_quality_edited"),&ProjectExportDialog::_quality_edited);
ObjectTypeDB::bind_method(_MD("_shrink_edited"),&ProjectExportDialog::_shrink_edited);
ObjectTypeDB::bind_method(_MD("_image_export_edited"),&ProjectExportDialog::_image_export_edited);
ObjectTypeDB::bind_method(_MD("_format_toggled"),&ProjectExportDialog::_format_toggled);
ObjectTypeDB::bind_method(_MD("_group_changed"),&ProjectExportDialog::_group_changed);
ObjectTypeDB::bind_method(_MD("_group_add"),&ProjectExportDialog::_group_add);
ObjectTypeDB::bind_method(_MD("_group_del"),&ProjectExportDialog::_group_del);
ObjectTypeDB::bind_method(_MD("_group_selected"),&ProjectExportDialog::_group_selected);
ObjectTypeDB::bind_method(_MD("_update_group"),&ProjectExportDialog::_update_group);
ObjectTypeDB::bind_method(_MD("_update_group_list"),&ProjectExportDialog::_update_group_list);
ObjectTypeDB::bind_method(_MD("_select_group"),&ProjectExportDialog::_select_group);
ObjectTypeDB::bind_method(_MD("_update_group_tree"),&ProjectExportDialog::_update_group_tree);
ObjectTypeDB::bind_method(_MD("_group_item_edited"),&ProjectExportDialog::_group_item_edited);
ObjectTypeDB::bind_method(_MD("_save_export_cfg"),&ProjectExportDialog::_save_export_cfg);
ObjectTypeDB::bind_method(_MD("_image_filter_changed"),&ProjectExportDialog::_image_filter_changed);
ObjectTypeDB::bind_method(_MD("_group_atlas_preview"),&ProjectExportDialog::_group_atlas_preview);
ObjectTypeDB::bind_method(_MD("_group_select_all"),&ProjectExportDialog::_group_select_all);
ObjectTypeDB::bind_method(_MD("_group_select_none"),&ProjectExportDialog::_group_select_none);
ObjectTypeDB::bind_method(_MD("_script_edited"),&ProjectExportDialog::_script_edited);
ObjectTypeDB::bind_method(_MD("_update_script"),&ProjectExportDialog::_update_script);
ObjectTypeDB::bind_method(_MD("_sample_convert_edited"),&ProjectExportDialog::_sample_convert_edited);
ObjectTypeDB::bind_method(_MD("export_platform"),&ProjectExportDialog::export_platform);
// ADD_SIGNAL(MethodInfo("instance"));
// ADD_SIGNAL(MethodInfo("open"));
}
ProjectExportDialog::ProjectExportDialog(EditorNode *p_editor) {
editor=p_editor;
set_title(TTR("Project Export Settings"));
sections = memnew( TabContainer );
add_child(sections);
set_child_rect(sections);
VBoxContainer *pvbox = memnew( VBoxContainer );
sections->add_child(pvbox);
pvbox->set_name(TTR("Target"));
HBoxContainer *phbox = memnew( HBoxContainer );
pvbox->add_child(phbox);
phbox->set_v_size_flags(SIZE_EXPAND_FILL);
plat_errors = memnew( HBoxContainer );
pvbox->add_child(plat_errors);
platform_error_string = memnew( Label );
platform_error_string->set_h_size_flags(SIZE_EXPAND_FILL);
plat_errors->add_child(platform_error_string);
VBoxContainer *vb = memnew( VBoxContainer );
vb->set_h_size_flags(SIZE_EXPAND_FILL);
vb->set_v_size_flags(SIZE_EXPAND_FILL);
phbox->add_child(vb);
platforms = memnew( Tree );
platforms->set_hide_root(true);
vb->add_margin_child(TTR("Export to Platform"),platforms,true);
platforms->connect("cell_selected",this,"_platform_selected");
vb = memnew(VBoxContainer );
phbox->add_child(vb);
vb->set_h_size_flags(SIZE_EXPAND_FILL);
vb->set_v_size_flags(SIZE_EXPAND_FILL);
platform_options = memnew( PropertyEditor() );
platform_options->hide_top_label();
vb->add_margin_child(TTR("Options"),platform_options,true);
platform_options->connect("property_edited",this,"_prop_edited");
//////////////////
vb = memnew( VBoxContainer );
vb->set_name(TTR("Resources"));
sections->add_child(vb);
export_mode = memnew( OptionButton );
export_mode->add_item(TTR("Export selected resources (including dependencies)."));
export_mode->add_item(TTR("Export all resources in the project."));
export_mode->add_item(TTR("Export all files in the project directory."));
export_mode->connect("item_selected",this,"_export_mode_changed");
vb->add_margin_child(TTR("Export Mode:"),export_mode);
tree_vb = memnew( VBoxContainer );
vb->add_child(tree_vb);
tree_vb->set_v_size_flags(SIZE_EXPAND_FILL);
tree = memnew( Tree );
tree_vb->add_margin_child(TTR("Resources to Export:"),tree,true);
tree->set_v_size_flags(SIZE_EXPAND_FILL);
tree->connect("item_edited",this,"_tree_changed");
tree->set_columns(2);
tree->set_column_titles_visible(true);
tree->set_column_title(0,TTR("File"));
tree->set_column_title(1,TTR("Action"));
tree->set_column_expand(1,false);
tree->set_column_min_width(1,90);
filters = memnew( LineEdit );
vb->add_margin_child(TTR("Filters to export non-resource files (Comma Separated, eg: *.json, *.txt):"),filters);
filters->connect("text_changed",this,"_filters_edited");
filters_exclude = memnew( LineEdit );
vb->add_margin_child(TTR("Filters to exclude from export (Comma Separated, eg: *.json, *.txt):"),filters_exclude);
filters_exclude->connect("text_changed",this,"_filters_exclude_edited");
convert_text_scenes = memnew( CheckButton );
convert_text_scenes->set_text(TTR("Convert text scenes to binary on export"));
vb->add_child(convert_text_scenes);
convert_text_scenes->connect("toggled",this,"_export_mode_changed");
image_vb = memnew( VBoxContainer );
image_vb->set_name(TTR("Images"));
image_action = memnew( OptionButton );
image_action->add_item(TTR("Keep Original"));
image_action->add_item(TTR("Compress for Disk (Lossy, WebP)"));
image_action->add_item(TTR("Compress for RAM (BC/PVRTC/ETC)"));
image_vb->add_margin_child(TTR("Convert Images (*.png):"),image_action);
HBoxContainer *qhb = memnew( HBoxContainer );
image_quality = memnew( HSlider );
qhb->add_child(image_quality);
image_quality->set_h_size_flags(SIZE_EXPAND_FILL);
SpinBox *qspin = memnew( SpinBox );
image_quality->share(qspin);
qhb->add_child(qspin);
image_quality->set_min(0);
image_quality->set_max(1);
image_quality->set_step(0.01);
image_vb->add_margin_child(TTR("Compress for Disk (Lossy) Quality:"),qhb);
image_shrink = memnew( SpinBox );
image_shrink->set_min(1);
image_shrink->set_max(8);
image_shrink->set_step(0.1);
image_vb->add_margin_child(TTR("Shrink All Images:"),image_shrink);
sections->add_child(image_vb);
image_formats=memnew(Tree);
image_formats->set_hide_root(true);
TreeItem *root = image_formats->create_item(NULL);
List<String> fmts;
ImageLoader::get_recognized_extensions(&fmts);
for(List<String>::Element *E=fmts.front();E;E=E->next()) {
TreeItem *fmt = image_formats->create_item(root);
fmt->set_cell_mode(0,TreeItem::CELL_MODE_CHECK);
fmt->set_text(0,E->get());
fmt->set_editable(0,true);
formats.push_back(fmt);
}
image_vb->add_margin_child(TTR("Compress Formats: "),image_formats,true);
/// groups
HBoxContainer *group_hb = memnew( HBoxContainer );
group_hb->set_name(TTR("Image Groups"));
sections->add_child(group_hb);
VBoxContainer *group_vb_left = memnew( VBoxContainer);
group_hb->add_child(group_vb_left);
VBoxContainer *gvb = memnew(VBoxContainer);
HBoxContainer *ghb = memnew(HBoxContainer);
gvb->add_child(ghb);
group_new_name = memnew( LineEdit );
group_new_name->set_h_size_flags(SIZE_EXPAND_FILL);
ghb->add_child(group_new_name);
group_add = memnew(ToolButton);
group_add->connect("pressed",this,"_group_add");
ghb->add_child(group_add);
group_new_name_error = memnew( Label );
group_new_name_error->add_color_override("font_color",Color(1,0.4,0.4));
gvb->add_child(group_new_name_error);
group_new_name_error->hide();
groups=memnew(Tree);
groups->set_v_size_flags(SIZE_EXPAND_FILL);
groups->connect("cell_selected",this,"_group_selected",varray(),CONNECT_DEFERRED);
groups->connect("button_pressed",this,"_group_del",varray(),CONNECT_DEFERRED);
groups->set_hide_root(true);
gvb->add_child(groups);
group_vb_left->add_margin_child(TTR("Groups:"),gvb,true);
//group_vb_left->add_child( memnew( HSeparator));
group_options = memnew(VBoxContainer);
group_vb_left->add_child(group_options);
group_image_action = memnew(OptionButton);
group_image_action->add_item(TTR("Default"));
group_image_action->add_item(TTR("Compress Disk"));
group_image_action->add_item(TTR("Compress RAM"));
group_image_action->add_item(TTR("Keep Original"));
group_options->add_margin_child(TTR("Compress Mode:"),group_image_action);
group_image_action->connect("item_selected",this,"_group_changed");
group_lossy_quality = memnew( HSlider );
group_lossy_quality->set_min(0.1);
group_lossy_quality->set_max(1.0);
group_lossy_quality->set_step(0.01);
group_lossy_quality->set_val(0.7);
group_lossy_quality->connect("value_changed",this,"_quality_edited");
HBoxContainer *gqhb = memnew( HBoxContainer );
SpinBox *gqspin = memnew( SpinBox );
group_lossy_quality->share(gqspin);
group_lossy_quality->set_h_size_flags(SIZE_EXPAND_FILL);
gqhb->add_child(group_lossy_quality);
gqhb->add_child(gqspin);
group_options->add_margin_child(TTR("Lossy Quality:"),gqhb);
group_atlas = memnew(CheckButton);
group_atlas->set_pressed(true);
group_options->add_margin_child(TTR("Atlas:"),group_atlas);
group_atlas->connect("toggled",this,"_group_changed");
group_shrink = memnew(SpinBox);
group_shrink->set_min(1);
group_shrink->set_max(8);
group_shrink->set_val(1);
group_shrink->set_step(0.001);
group_options->add_margin_child(TTR("Shrink By:"),group_shrink);
group_shrink->connect("value_changed",this,"_group_changed");
atlas_preview = memnew( Button );
atlas_preview->set_text(TTR("Preview Atlas"));
group_options->add_child(atlas_preview);
atlas_preview->show();
atlas_preview->connect("pressed",this,"_group_atlas_preview");
Control *ec = memnew(Control );
ec->set_custom_minimum_size(Size2(150,1));
gvb->add_child(ec);
VBoxContainer *group_vb_right = memnew( VBoxContainer );
group_hb->add_child(group_vb_right);
group_vb_right->set_h_size_flags(SIZE_EXPAND_FILL);
HBoxContainer *filter_hb = memnew (HBoxContainer);
group_images_filter = memnew( LineEdit );
group_vb_right->add_margin_child(TTR("Image Filter:"),filter_hb);
filter_hb->add_child(group_images_filter);
group_images_filter->set_h_size_flags(SIZE_EXPAND_FILL);
group_images_filter->connect("text_changed",this,"_image_filter_changed");
group_images = memnew( Tree );
group_images->set_v_size_flags(SIZE_EXPAND_FILL);
group_vb_right->add_margin_child(TTR("Images:"),group_images,true);
Button *filt_select_all = memnew( Button );
filt_select_all->set_text(TTR("Select All"));
filter_hb->add_child(filt_select_all);
filt_select_all->connect("pressed",this,"_group_select_all");
Button *filt_select_none = memnew( Button );
filt_select_none->set_text(TTR("Select None"));
filter_hb->add_child(filt_select_none);
filt_select_none->connect("pressed",this,"_group_select_none");
atlas_preview_dialog = memnew( AcceptDialog );
ScrollContainer *scroll = memnew( ScrollContainer );
atlas_preview_dialog->add_child(scroll);
atlas_preview_dialog->set_child_rect(scroll);
atlas_preview_frame = memnew( TextureFrame );
scroll->add_child(atlas_preview_frame);
add_child(atlas_preview_dialog);
group_images->set_hide_root(true);
group_images->set_columns(2);
group_images->set_column_expand(0,true);
group_images->set_column_expand(1,false);
group_images->set_column_min_width(1,100);
group_images->set_column_titles_visible(true);
group_images->set_column_title(0,"Image");
group_images->set_column_title(1,TTR("Group"));
group_images->connect("item_edited",this,"_group_item_edited",varray(),CONNECT_DEFERRED);
/* SpinBox *group_shrink;
CheckButton *group_atlas;
OptionButton *group_image_action;*/
/* progress = memnew( Label );
add_child(progress);
progress->set_area_as_parent_rect();
progress->set_anchor_and_margin(MARGIN_TOP,Control::ANCHOR_BEGIN,25);
progress->hide();
progress->set_align(Label::ALIGN_CENTER);*/
/*
button_reload = memnew( Button );
button_reload->set_pos(Point2(3,2));
button_reload->set_size(Point2(20,5));
button_reload->set_flat(true);
//add_child(button_reload);
button_reload->connect("pressed",this,"_rescan");
hbc->add_child(button_reload);
*/
sample_vbox = memnew( VBoxContainer );
sample_vbox->set_name(TTR("Samples"));
sections->add_child(sample_vbox);
sample_mode = memnew( OptionButton );
sample_vbox->add_margin_child(TTR("Sample Conversion Mode: (.wav files):"),sample_mode);
sample_mode->add_item(TTR("Keep"));
sample_mode->add_item(TTR("Compress (RAM - IMA-ADPCM)"));
sample_max_hz = memnew( SpinBox );
sample_max_hz->set_max(192000);
sample_max_hz->set_min(8000);
sample_vbox->add_margin_child(TTR("Sampling Rate Limit: (hz)"),sample_max_hz);
sample_trim = memnew( CheckButton );
sample_trim->set_text(TTR("Trim"));
sample_vbox->add_margin_child(TTR("Trailing Silence:"),sample_trim);
script_vbox = memnew( VBoxContainer );
script_vbox->set_name("Script");
sections->add_child(script_vbox);
script_mode = memnew( OptionButton );
script_vbox->add_margin_child(TTR("Script Export Mode:"),script_mode);
script_mode->add_item(TTR("Text"));
script_mode->add_item(TTR("Compiled"));
script_mode->add_item(TTR("Encrypted (Provide Key Below)"));
script_key = memnew( LineEdit );
script_vbox->add_margin_child(TTR("Script Encryption Key (256-bits as hex):"),script_key);
updating=false;
error = memnew( AcceptDialog );
add_child(error);
confirm = memnew( ConfirmationDialog );
add_child(confirm);
confirm->connect("confirmed",this,"_confirmed");
get_ok()->set_text(TTR("Export PCK/Zip"));
expopt="--,Export,Bundle";
file_export = memnew( EditorFileDialog );
add_child(file_export);
file_export->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
file_export->set_current_dir( EditorSettings::get_singleton()->get("global/default_project_export_path") );
file_export->set_title(TTR("Export Project"));
file_export->connect("file_selected", this,"_export_action");
file_export_password = memnew( LineEdit );
file_export_password->set_secret(true);
file_export_password->set_editable(false);
file_export->get_vbox()->add_margin_child(TTR("Password:"),file_export_password);
pck_export = memnew( EditorFileDialog );
pck_export->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
pck_export->set_current_dir( EditorSettings::get_singleton()->get("global/default_project_export_path") );
pck_export->set_title(TTR("Export Project PCK"));
pck_export->connect("file_selected", this,"_export_action_pck");
pck_export->add_filter("*.pck ; Data Pack");
pck_export->add_filter("*.zip ; Zip");
add_child(pck_export);
button_export = add_button(TTR("Export.."),!OS::get_singleton()->get_swap_ok_cancel(),"export_pck");
updating_script=false;
ei="EditorIcons";
ot="Object";
pending_update_tree=true;
}
ProjectExportDialog::~ProjectExportDialog() {
}
void ProjectExport::popup_export() {
Set<String> presets;
presets.insert("default");
List<PropertyInfo> pi;
Globals::get_singleton()->get_property_list(&pi);
export_preset->clear();
for (List<PropertyInfo>::Element *E=pi.front();E;E=E->next()) {
if (!E->get().name.begins_with("export_presets/"))
continue;
presets.insert(E->get().name.get_slice("/",1));
}
for(Set<String>::Element *E=presets.front();E;E=E->next()) {
export_preset->add_item(E->get());
}
popup_centered(Size2(300,100));
}
Error ProjectExport::export_project(const String& p_preset) {
return OK;
#if 0
String selected=p_preset;
DVector<String> preset_settings = Globals::get_singleton()->get("export_presets/"+selected);
String preset_path=Globals::get_singleton()->get("export_presets_path/"+selected);
if (preset_path=="") {
error->set_text(TTR("Export path empty, see export options"));
error->popup_centered_minsize(Size2(300,100));
ERR_FAIL_V(ERR_INVALID_DATA);
}
int pc=preset_settings.size();
DirAccess *d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
if (d->change_dir(preset_path)!=OK) {
memdelete(d);
error->set_text("Can't access to export path:\n "+preset_path);
error->popup_centered_minsize(Size2(300,100));
ERR_FAIL_V(ERR_INVALID_DATA);
}
if (pc==0) {
memdelete(d);
return OK;
}
if (pc%3 != 0 ) {
memdelete(d);
error->set_text(TTR("Corrupted export data.."));
error->popup_centered_minsize(Size2(300,100));
ERR_EXPLAIN(TTR("Corrupted export data..."));
ERR_FAIL_V(ERR_INVALID_DATA);
}
Map<String,ProjectExportSettings::ItemData> export_action;
Map<String,Map<String,String> > remapped_paths;
Set<String> scene_extensions;
Set<String> resource_extensions;
{
List<String> l;
// SceneLoader::get_recognized_extensions(&l);
// for(List<String>::Element *E=l.front();E;E=E->next()) {
//
// scene_extensions.insert(E->get());
// }
ResourceLoader::get_recognized_extensions_for_type("",&l);
for(List<String>::Element *E=l.front();E;E=E->next()) {
resource_extensions.insert(E->get());
}
}
Vector<String> names = Globals::get_singleton()->get_optimizer_presets();
//prepare base paths
for(int i=0;i<pc;i+=3) {
String name = preset_settings[i+0];
String pname=preset_settings[i+1];
String deps=preset_settings[i+2];
int idx=1;
if (pname=="") {
pname="copy";
} else {
for(int j=0;j<names.size();j++) {
if (pname==names[j]) {
idx=j+2;
break;
}
}
}
int dep_idx=0;
for(int j=0;j<ProjectExportSettings::DA_MAX;j++) {
if (ProjectExportSettings::da_string[j]==deps) {
dep_idx=j;
break;
}
}
if (idx>=0) {
export_action[name].action=idx;
export_action[name].depaction=dep_idx;
}
}
Set<String> bundle_exceptions;
for (Map<String,ProjectExportSettings::ItemData>::Element *E=export_action.front();E;E=E->next()) {
bundle_exceptions.insert(E->key());
}
{
// find dependencies and add them to export
Map<String,ProjectExportSettings::ItemData> dependencies;
for (Map<String,ProjectExportSettings::ItemData>::Element *E=export_action.front();E;E=E->next()) {
ProjectExportSettings::ItemData &id=E->get();
if (id.depaction!=ProjectExportSettings::DA_COPY && id.depaction!=ProjectExportSettings::DA_OPTIMIZE)
continue; //no copy or optimize, go on
List<String> deplist;
ResourceLoader::get_dependencies(E->key(),&deplist);
while (deplist.size()) {
String dependency = deplist.front()->get();
deplist.pop_front();
if (export_action.has(dependency))
continue; //taged to export, will not override
if (dependencies.has(dependency)) {
if (id.action <= dependencies[dependency].action )
continue;
}
ProjectExportSettings::ItemData depid;
if (id.depaction==ProjectExportSettings::DA_COPY || id.action==ProjectExportSettings::DA_COPY)
depid.action=ProjectExportSettings::DA_COPY;
else if (id.depaction==ProjectExportSettings::DA_OPTIMIZE)
depid.action=id.action;
depid.depaction=0;
dependencies[dependency]=depid;
ResourceLoader::get_dependencies(dependency,&deplist);
}
}
for (Map<String,ProjectExportSettings::ItemData>::Element *E=dependencies.front();E;E=E->next()) {
export_action[E->key()]=E->get();
}
}
int idx=0;
for (Map<String,ProjectExportSettings::ItemData>::Element *E=export_action.front();E;E=E->next(),idx++) {
String path=E->key();
if (E->get().action==0)
continue; //nothing to do here
String preset;
if (E->get().action==1)
preset="";
else
preset=names[E->get().action-2];
print_line("Exporting "+itos(idx)+"/"+itos(export_action.size())+": "+path);
String base_dir = Globals::get_singleton()->localize_path(path.get_base_dir()).replace("\\","/").replace("res://","");
DirAccess *da=DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
String cwd = d->get_current_dir();
da->change_dir(cwd);
print_line("base dir: "+base_dir);
String remap_platform="all";
for(int j=0;j<base_dir.get_slice_count("/");j++) {
String p = base_dir.get_slice("/",j);
if (da->change_dir(p)!=OK) {
Error err = da->make_dir(p);
if (err!=OK) {
memdelete(da);
memdelete(d);
ERR_EXPLAIN(TTR("Cannot make dir: ")+cwd+"/"+p);
ERR_FAIL_V(ERR_CANT_CREATE);
}
if (da->change_dir(p)!=OK) {
memdelete(da);
memdelete(d);
ERR_EXPLAIN(TTR("Cannot change to dir: ")+cwd+"/"+p);
ERR_FAIL_V(ERR_CANT_CREATE);
}
}
cwd=da->get_current_dir();
}
memdelete(da);
//cwd is the target dir
String source_file;
print_line("Exporting: "+source_file);
bool delete_source=false;
if (preset=="") {
//just copy!
source_file=path;
delete_source=false;
} else {
delete_source=true;
//create an optimized source file
if (!Globals::get_singleton()->has("optimizer_presets/"+preset)) {
memdelete(d);
ERR_EXPLAIN(TTR("Unknown optimizer preset: ")+preset);
ERR_FAIL_V(ERR_INVALID_DATA);
}
Dictionary dc = Globals::get_singleton()->get("optimizer_presets/"+preset);
ERR_FAIL_COND_V(!dc.has("__type__"),ERR_INVALID_DATA);
String type=dc["__type__"];
Ref<EditorOptimizedSaver> saver;
for(int i=0;i<editor_data->get_optimized_saver_count();i++) {
if (editor_data->get_optimized_saver(i)->get_target_name()==type) {
saver=editor_data->get_optimized_saver(i);
}
}
if (saver.is_null()) {
memdelete(d);
ERR_EXPLAIN(TTR("Preset '")+preset+"' references nonexistent saver: "+type);
ERR_FAIL_COND_V(saver.is_null(),ERR_INVALID_DATA);
}
List<Variant> keys;
dc.get_key_list(&keys);
saver->clear();
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
saver->set(E->get(),dc[E->get()]);
}
remap_platform=saver->get_target_platform();
if (remap_platform=="")
remap_platform="all";
if (resource_extensions.has(path.extension().to_lower())) {
uint32_t flags=0;
// if (saver->is_bundle_scenes_enabled())
// flags|=Reso::FLAG_BUNDLE_INSTANCED_SCENES;
saver->set_bundle_exceptions(NULL);
if (E->get().depaction>=ProjectExportSettings::DA_BUNDLE) {
flags|=ResourceSaver::FLAG_BUNDLE_RESOURCES;
if (E->get().depaction==ProjectExportSettings::DA_BUNDLE)
saver->set_bundle_exceptions(&bundle_exceptions);
}
if (saver->is_remove_editor_data_enabled())
flags|=ResourceSaver::FLAG_OMIT_EDITOR_PROPERTIES;
if (saver->is_big_endian_data_enabled())
flags|=ResourceSaver::FLAG_SAVE_BIG_ENDIAN;
RES res = ResourceLoader::load(path);
if (res.is_null()) {
memdelete(d);
ERR_EXPLAIN(TTR("Errr loading resource to optimize: ")+path);
ERR_FAIL_V(ERR_INVALID_DATA);
}
if (saver->is_compress_translations_enabled() && res->get_type()=="Translation") {
Ref<PHashTranslation> ct = Ref<PHashTranslation>( memnew( PHashTranslation ) );
ct->generate(res);
res=ct;
}
//dst_file=path.get_file();
//dst_file = cwd+"/"+dst_file.substr(0,dst_file.length()-dst_file.extension().length())+"opt.scn";
//String write_file = path.substr(0,path.length()-path.extension().length())+"optimized.res";
String write_file = path+".opt.res";
print_line("DST RES FILE: "+write_file);
Error err = ResourceSaver::save(write_file,res,flags,saver);
if (err) {
memdelete(d);
ERR_EXPLAIN(TTR("Errr saving optimized resource: ")+write_file);
ERR_FAIL_COND_V(err,ERR_CANT_OPEN);
}
source_file=write_file;
// project_settings->add_remapped_path(src_scene,path,platform);
}
}
String dst_file;
dst_file=cwd+"/"+source_file.get_file();
print_line("copying from: "+source_file);
print_line("copying to: "+dst_file);
Error err = d->copy(source_file,dst_file);
if (delete_source)
d->remove(source_file);
if (err) {
ERR_EXPLAIN(TTR("Error copying from: ")+source_file+" to "+dst_file+".");
ERR_FAIL_COND_V(err,err);
}
String src_remap=path;
String dst_remap=source_file;
print_line("remap from: "+src_remap);
print_line("remap to: "+dst_remap);
if (src_remap!=dst_remap) {
remapped_paths[remap_platform][src_remap]=dst_remap;
}
//do the copy man...
}
Map<String,Variant> added_settings;
for (Map<String,Map<String,String> >::Element *E=remapped_paths.front();E;E=E->next()) {
String platform=E->key();
DVector<String> remaps;
for(Map<String,String>::Element *F=E->get().front();F;F=F->next() ) {
remaps.push_back(F->key());
remaps.push_back(F->get());
}
// added_settings["remap/"+platform]=remaps;`
added_settings["remap/"+platform]=Variant(remaps).operator Array();
}
String engine_cfg_path=d->get_current_dir()+"/engine.cfg";
print_line("enginecfg: "+engine_cfg_path);
Globals::get_singleton()->save_custom(engine_cfg_path,added_settings);
memdelete(d);
return OK;
#endif
}
ProjectExport::ProjectExport(EditorData* p_data) {
editor_data=p_data;
VBoxContainer *vbc = memnew( VBoxContainer );
add_child(vbc);
set_child_rect(vbc);
set_title(TTR("Project Export"));
label = memnew( Label );
label->set_text(TTR("Export Preset:"));
vbc->add_child(label);
export_preset = memnew (OptionButton);
vbc->add_child(export_preset);
get_ok()->set_text(TTR("Export"));
set_hide_on_ok(false);
error = memnew( AcceptDialog );
add_child(error);
}
Reference in New Issue View Git Blame Copy Permalink