/*************************************************************************/ /* asset_library_editor_plugin.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */ /* */ /* 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 "asset_library_editor_plugin.h" #include "core/io/json.h" #include "core/os/input.h" #include "core/os/keyboard.h" #include "core/version.h" #include "editor/editor_node.h" #include "editor/editor_scale.h" #include "editor/editor_settings.h" #include "editor/project_settings_editor.h" void EditorAssetLibraryItem::configure(const String &p_title, int p_asset_id, const String &p_category, int p_category_id, const String &p_author, int p_author_id, const String &p_cost) { title->set_text(p_title); asset_id = p_asset_id; category->set_text(p_category); category_id = p_category_id; author->set_text(p_author); author_id = p_author_id; price->set_text(p_cost); } void EditorAssetLibraryItem::set_image(int p_type, int p_index, const Ref &p_image) { ERR_FAIL_COND(p_type != EditorAssetLibrary::IMAGE_QUEUE_ICON); ERR_FAIL_COND(p_index != 0); icon->set_normal_texture(p_image); } void EditorAssetLibraryItem::_notification(int p_what) { if (p_what == NOTIFICATION_ENTER_TREE) { icon->set_normal_texture(get_icon("ProjectIconLoading", "EditorIcons")); category->add_color_override("font_color", Color(0.5, 0.5, 0.5)); author->add_color_override("font_color", Color(0.5, 0.5, 0.5)); price->add_color_override("font_color", Color(0.5, 0.5, 0.5)); } } void EditorAssetLibraryItem::_asset_clicked() { emit_signal("asset_selected", asset_id); } void EditorAssetLibraryItem::_category_clicked() { emit_signal("category_selected", category_id); } void EditorAssetLibraryItem::_author_clicked() { emit_signal("author_selected", author_id); } void EditorAssetLibraryItem::_bind_methods() { ClassDB::bind_method("set_image", &EditorAssetLibraryItem::set_image); ADD_SIGNAL(MethodInfo("asset_selected")); ADD_SIGNAL(MethodInfo("category_selected")); ADD_SIGNAL(MethodInfo("author_selected")); } EditorAssetLibraryItem::EditorAssetLibraryItem() { Ref border; border.instance(); border->set_default_margin(MARGIN_LEFT, 5 * EDSCALE); border->set_default_margin(MARGIN_RIGHT, 5 * EDSCALE); border->set_default_margin(MARGIN_BOTTOM, 5 * EDSCALE); border->set_default_margin(MARGIN_TOP, 5 * EDSCALE); add_style_override("panel", border); HBoxContainer *hb = memnew(HBoxContainer); // Add some spacing to visually separate the icon from the asset details. hb->add_constant_override("separation", 15 * EDSCALE); add_child(hb); icon = memnew(TextureButton); icon->set_custom_minimum_size(Size2(64, 64) * EDSCALE); icon->set_default_cursor_shape(CURSOR_POINTING_HAND); icon->connect("pressed", callable_mp(this, &EditorAssetLibraryItem::_asset_clicked)); hb->add_child(icon); VBoxContainer *vb = memnew(VBoxContainer); hb->add_child(vb); vb->set_h_size_flags(SIZE_EXPAND_FILL); title = memnew(LinkButton); title->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); title->connect("pressed", callable_mp(this, &EditorAssetLibraryItem::_asset_clicked)); vb->add_child(title); category = memnew(LinkButton); category->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); category->connect("pressed", callable_mp(this, &EditorAssetLibraryItem::_category_clicked)); vb->add_child(category); author = memnew(LinkButton); author->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); author->connect("pressed", callable_mp(this, &EditorAssetLibraryItem::_author_clicked)); vb->add_child(author); price = memnew(Label); vb->add_child(price); set_custom_minimum_size(Size2(250, 100) * EDSCALE); set_h_size_flags(SIZE_EXPAND_FILL); } ////////////////////////////////////////////////////////////////////////////// void EditorAssetLibraryItemDescription::set_image(int p_type, int p_index, const Ref &p_image) { switch (p_type) { case EditorAssetLibrary::IMAGE_QUEUE_ICON: { item->call("set_image", p_type, p_index, p_image); icon = p_image; } break; case EditorAssetLibrary::IMAGE_QUEUE_THUMBNAIL: { for (int i = 0; i < preview_images.size(); i++) { if (preview_images[i].id == p_index) { if (preview_images[i].is_video) { Ref overlay = get_icon("PlayOverlay", "EditorIcons")->get_data(); Ref thumbnail = p_image->get_data(); thumbnail = thumbnail->duplicate(); Point2 overlay_pos = Point2((thumbnail->get_width() - overlay->get_width()) / 2, (thumbnail->get_height() - overlay->get_height()) / 2); // Overlay and thumbnail need the same format for `blend_rect` to work. thumbnail->convert(Image::FORMAT_RGBA8); thumbnail->blend_rect(overlay, overlay->get_used_rect(), overlay_pos); Ref tex; tex.instance(); tex->create_from_image(thumbnail); preview_images[i].button->set_icon(tex); // Make it clearer that clicking it will open an external link preview_images[i].button->set_default_cursor_shape(CURSOR_POINTING_HAND); } else { preview_images[i].button->set_icon(p_image); } break; } } } break; case EditorAssetLibrary::IMAGE_QUEUE_SCREENSHOT: { for (int i = 0; i < preview_images.size(); i++) { if (preview_images[i].id == p_index) { preview_images.write[i].image = p_image; if (preview_images[i].button->is_pressed()) { _preview_click(p_index); } break; } } } break; } } void EditorAssetLibraryItemDescription::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { previews_bg->add_style_override("panel", get_stylebox("normal", "TextEdit")); } break; } } void EditorAssetLibraryItemDescription::_bind_methods() { ClassDB::bind_method(D_METHOD("set_image"), &EditorAssetLibraryItemDescription::set_image); } void EditorAssetLibraryItemDescription::_link_click(const String &p_url) { ERR_FAIL_COND(!p_url.begins_with("http")); OS::get_singleton()->shell_open(p_url); } void EditorAssetLibraryItemDescription::_preview_click(int p_id) { for (int i = 0; i < preview_images.size(); i++) { if (preview_images[i].id == p_id) { preview_images[i].button->set_pressed(true); if (!preview_images[i].is_video) { if (preview_images[i].image.is_valid()) { preview->set_texture(preview_images[i].image); minimum_size_changed(); } } else { _link_click(preview_images[i].video_link); } } else { preview_images[i].button->set_pressed(false); } } } void EditorAssetLibraryItemDescription::configure(const String &p_title, int p_asset_id, const String &p_category, int p_category_id, const String &p_author, int p_author_id, const String &p_cost, int p_version, const String &p_version_string, const String &p_description, const String &p_download_url, const String &p_browse_url, const String &p_sha256_hash) { asset_id = p_asset_id; title = p_title; download_url = p_download_url; sha256 = p_sha256_hash; item->configure(p_title, p_asset_id, p_category, p_category_id, p_author, p_author_id, p_cost); description->clear(); description->add_text(TTR("Version:") + " " + p_version_string + "\n"); description->add_text(TTR("Contents:") + " "); description->push_meta(p_browse_url); description->add_text(TTR("View Files")); description->pop(); description->add_text("\n" + TTR("Description:") + "\n\n"); description->append_bbcode(p_description); set_title(p_title); } void EditorAssetLibraryItemDescription::add_preview(int p_id, bool p_video, const String &p_url) { Preview preview; preview.id = p_id; preview.video_link = p_url; preview.is_video = p_video; preview.button = memnew(Button); preview.button->set_flat(true); preview.button->set_icon(get_icon("ThumbnailWait", "EditorIcons")); preview.button->set_toggle_mode(true); preview.button->connect("pressed", callable_mp(this, &EditorAssetLibraryItemDescription::_preview_click), varray(p_id)); preview_hb->add_child(preview.button); if (!p_video) { preview.image = get_icon("ThumbnailWait", "EditorIcons"); } preview_images.push_back(preview); if (preview_images.size() == 1 && !p_video) { _preview_click(p_id); } } EditorAssetLibraryItemDescription::EditorAssetLibraryItemDescription() { HBoxContainer *hbox = memnew(HBoxContainer); add_child(hbox); VBoxContainer *desc_vbox = memnew(VBoxContainer); hbox->add_child(desc_vbox); hbox->add_constant_override("separation", 15 * EDSCALE); item = memnew(EditorAssetLibraryItem); desc_vbox->add_child(item); desc_vbox->set_custom_minimum_size(Size2(440 * EDSCALE, 0)); description = memnew(RichTextLabel); desc_vbox->add_child(description); description->set_v_size_flags(SIZE_EXPAND_FILL); description->connect("meta_clicked", callable_mp(this, &EditorAssetLibraryItemDescription::_link_click)); description->add_constant_override("line_separation", Math::round(5 * EDSCALE)); VBoxContainer *previews_vbox = memnew(VBoxContainer); hbox->add_child(previews_vbox); previews_vbox->add_constant_override("separation", 15 * EDSCALE); previews_vbox->set_v_size_flags(SIZE_EXPAND_FILL); preview = memnew(TextureRect); previews_vbox->add_child(preview); preview->set_expand(true); preview->set_stretch_mode(TextureRect::STRETCH_KEEP_ASPECT_CENTERED); preview->set_custom_minimum_size(Size2(640 * EDSCALE, 345 * EDSCALE)); previews_bg = memnew(PanelContainer); previews_vbox->add_child(previews_bg); previews_bg->set_custom_minimum_size(Size2(640 * EDSCALE, 101 * EDSCALE)); previews = memnew(ScrollContainer); previews_bg->add_child(previews); previews->set_enable_v_scroll(false); previews->set_enable_h_scroll(true); preview_hb = memnew(HBoxContainer); preview_hb->set_v_size_flags(SIZE_EXPAND_FILL); previews->add_child(preview_hb); get_ok()->set_text(TTR("Download")); get_cancel()->set_text(TTR("Close")); } /////////////////////////////////////////////////////////////////////////////////// void EditorAssetLibraryItemDownload::_http_download_completed(int p_status, int p_code, const PackedStringArray &headers, const PackedByteArray &p_data) { String error_text; switch (p_status) { case HTTPRequest::RESULT_CHUNKED_BODY_SIZE_MISMATCH: case HTTPRequest::RESULT_CONNECTION_ERROR: case HTTPRequest::RESULT_BODY_SIZE_LIMIT_EXCEEDED: { error_text = TTR("Connection error, please try again."); status->set_text(TTR("Can't connect.")); } break; case HTTPRequest::RESULT_CANT_CONNECT: case HTTPRequest::RESULT_SSL_HANDSHAKE_ERROR: { error_text = TTR("Can't connect to host:") + " " + host; status->set_text(TTR("Can't connect.")); } break; case HTTPRequest::RESULT_NO_RESPONSE: { error_text = TTR("No response from host:") + " " + host; status->set_text(TTR("No response.")); } break; case HTTPRequest::RESULT_CANT_RESOLVE: { error_text = TTR("Can't resolve hostname:") + " " + host; status->set_text(TTR("Can't resolve.")); } break; case HTTPRequest::RESULT_REQUEST_FAILED: { error_text = TTR("Request failed, return code:") + " " + itos(p_code); status->set_text(TTR("Request failed.")); } break; case HTTPRequest::RESULT_DOWNLOAD_FILE_CANT_OPEN: case HTTPRequest::RESULT_DOWNLOAD_FILE_WRITE_ERROR: { error_text = TTR("Cannot save response to:") + " " + download->get_download_file(); status->set_text(TTR("Write error.")); } break; case HTTPRequest::RESULT_REDIRECT_LIMIT_REACHED: { error_text = TTR("Request failed, too many redirects"); status->set_text(TTR("Redirect loop.")); } break; case HTTPRequest::RESULT_TIMEOUT: { error_text = TTR("Request failed, timeout"); status->set_text(TTR("Timeout.")); } break; default: { if (p_code != 200) { error_text = TTR("Request failed, return code:") + " " + itos(p_code); status->set_text(TTR("Failed:") + " " + itos(p_code)); } else if (sha256 != "") { String download_sha256 = FileAccess::get_sha256(download->get_download_file()); if (sha256 != download_sha256) { error_text = TTR("Bad download hash, assuming file has been tampered with.") + "\n"; error_text += TTR("Expected:") + " " + sha256 + "\n" + TTR("Got:") + " " + download_sha256; status->set_text(TTR("Failed sha256 hash check")); } } } break; } if (error_text != String()) { download_error->set_text(TTR("Asset Download Error:") + "\n" + error_text); download_error->popup_centered_minsize(); return; } install->set_disabled(false); status->set_text(TTR("Success!")); // Make the progress bar invisible but don't reflow other Controls around it. progress->set_modulate(Color(0, 0, 0, 0)); set_process(false); } void EditorAssetLibraryItemDownload::configure(const String &p_title, int p_asset_id, const Ref &p_preview, const String &p_download_url, const String &p_sha256_hash) { title->set_text(p_title); icon->set_texture(p_preview); asset_id = p_asset_id; if (!p_preview.is_valid()) icon->set_texture(get_icon("FileBrokenBigThumb", "EditorIcons")); host = p_download_url; sha256 = p_sha256_hash; _make_request(); } void EditorAssetLibraryItemDownload::_notification(int p_what) { switch (p_what) { // FIXME: The editor crashes if 'NOTICATION_THEME_CHANGED' is used. case NOTIFICATION_ENTER_TREE: { add_style_override("panel", get_stylebox("panel", "TabContainer")); dismiss->set_normal_texture(get_icon("Close", "EditorIcons")); } break; case NOTIFICATION_PROCESS: { // Make the progress bar visible again when retrying the download. progress->set_modulate(Color(1, 1, 1, 1)); if (download->get_downloaded_bytes() > 0) { progress->set_max(download->get_body_size()); progress->set_value(download->get_downloaded_bytes()); } int cstatus = download->get_http_client_status(); if (cstatus == HTTPClient::STATUS_BODY) { if (download->get_body_size() > 0) { status->set_text(vformat( TTR("Downloading (%s / %s)..."), String::humanize_size(download->get_downloaded_bytes()), String::humanize_size(download->get_body_size()))); } else { // Total file size is unknown, so it cannot be displayed. progress->set_modulate(Color(0, 0, 0, 0)); status->set_text(vformat( TTR("Downloading...") + " (%s)", String::humanize_size(download->get_downloaded_bytes()))); } } if (cstatus != prev_status) { switch (cstatus) { case HTTPClient::STATUS_RESOLVING: { status->set_text(TTR("Resolving...")); progress->set_max(1); progress->set_value(0); } break; case HTTPClient::STATUS_CONNECTING: { status->set_text(TTR("Connecting...")); progress->set_max(1); progress->set_value(0); } break; case HTTPClient::STATUS_REQUESTING: { status->set_text(TTR("Requesting...")); progress->set_max(1); progress->set_value(0); } break; default: { } } prev_status = cstatus; } } break; } } void EditorAssetLibraryItemDownload::_close() { // Clean up downloaded file. DirAccess::remove_file_or_error(download->get_download_file()); queue_delete(); } void EditorAssetLibraryItemDownload::_install() { String file = download->get_download_file(); if (external_install) { emit_signal("install_asset", file, title->get_text()); return; } asset_installer->open(file, 1); } void EditorAssetLibraryItemDownload::_make_request() { download->cancel_request(); download->set_download_file(EditorSettings::get_singleton()->get_cache_dir().plus_file("tmp_asset_" + itos(asset_id)) + ".zip"); Error err = download->request(host); if (err != OK) { status->set_text(TTR("Error making request")); } else { set_process(true); } } void EditorAssetLibraryItemDownload::_bind_methods() { ADD_SIGNAL(MethodInfo("install_asset", PropertyInfo(Variant::STRING, "zip_path"), PropertyInfo(Variant::STRING, "name"))); } EditorAssetLibraryItemDownload::EditorAssetLibraryItemDownload() { HBoxContainer *hb = memnew(HBoxContainer); add_child(hb); icon = memnew(TextureRect); hb->add_child(icon); VBoxContainer *vb = memnew(VBoxContainer); hb->add_child(vb); vb->set_h_size_flags(SIZE_EXPAND_FILL); HBoxContainer *title_hb = memnew(HBoxContainer); vb->add_child(title_hb); title = memnew(Label); title_hb->add_child(title); title->set_h_size_flags(SIZE_EXPAND_FILL); dismiss = memnew(TextureButton); dismiss->connect("pressed", callable_mp(this, &EditorAssetLibraryItemDownload::_close)); title_hb->add_child(dismiss); title->set_clip_text(true); vb->add_spacer(); status = memnew(Label(TTR("Idle"))); vb->add_child(status); status->add_color_override("font_color", Color(0.5, 0.5, 0.5)); progress = memnew(ProgressBar); vb->add_child(progress); HBoxContainer *hb2 = memnew(HBoxContainer); vb->add_child(hb2); hb2->add_spacer(); install = memnew(Button); install->set_text(TTR("Install...")); install->set_disabled(true); install->connect("pressed", callable_mp(this, &EditorAssetLibraryItemDownload::_install)); retry = memnew(Button); retry->set_text(TTR("Retry")); retry->connect("pressed", callable_mp(this, &EditorAssetLibraryItemDownload::_make_request)); hb2->add_child(retry); hb2->add_child(install); set_custom_minimum_size(Size2(310, 0) * EDSCALE); download = memnew(HTTPRequest); add_child(download); download->connect("request_completed", callable_mp(this, &EditorAssetLibraryItemDownload::_http_download_completed)); download->set_use_threads(EDITOR_DEF("asset_library/use_threads", true)); download_error = memnew(AcceptDialog); add_child(download_error); download_error->set_title(TTR("Download Error")); asset_installer = memnew(EditorAssetInstaller); add_child(asset_installer); asset_installer->connect("confirmed", callable_mp(this, &EditorAssetLibraryItemDownload::_close)); prev_status = -1; external_install = false; } //////////////////////////////////////////////////////////////////////////////// void EditorAssetLibrary::_notification(int p_what) { switch (p_what) { case NOTIFICATION_READY: { error_tr->set_texture(get_icon("Error", "EditorIcons")); filter->set_right_icon(get_icon("Search", "EditorIcons")); filter->set_clear_button_enabled(true); error_label->raise(); } break; case NOTIFICATION_VISIBILITY_CHANGED: { if (is_visible() && initial_loading) { _repository_changed(0); // Update when shown for the first time. } } break; case NOTIFICATION_PROCESS: { HTTPClient::Status s = request->get_http_client_status(); const bool loading = s != HTTPClient::STATUS_DISCONNECTED; if (loading) { library_scroll->set_modulate(Color(1, 1, 1, 0.5)); } else { library_scroll->set_modulate(Color(1, 1, 1, 1)); } const bool no_downloads = downloads_hb->get_child_count() == 0; if (no_downloads == downloads_scroll->is_visible()) { downloads_scroll->set_visible(!no_downloads); } } break; case NOTIFICATION_THEME_CHANGED: { library_scroll_bg->add_style_override("panel", get_stylebox("bg", "Tree")); downloads_scroll->add_style_override("bg", get_stylebox("bg", "Tree")); error_tr->set_texture(get_icon("Error", "EditorIcons")); filter->set_right_icon(get_icon("Search", "EditorIcons")); filter->set_clear_button_enabled(true); } break; } } void EditorAssetLibrary::_unhandled_input(const Ref &p_event) { const Ref key = p_event; if (key.is_valid() && key->is_pressed()) { if (key->get_scancode_with_modifiers() == (KEY_MASK_CMD | KEY_F) && is_visible_in_tree()) { filter->grab_focus(); filter->select_all(); accept_event(); } } } void EditorAssetLibrary::_install_asset() { ERR_FAIL_COND(!description); for (int i = 0; i < downloads_hb->get_child_count(); i++) { EditorAssetLibraryItemDownload *d = Object::cast_to(downloads_hb->get_child(i)); if (d && d->get_asset_id() == description->get_asset_id()) { if (EditorNode::get_singleton() != NULL) EditorNode::get_singleton()->show_warning(TTR("Download for this asset is already in progress!")); return; } } EditorAssetLibraryItemDownload *download = memnew(EditorAssetLibraryItemDownload); downloads_hb->add_child(download); download->configure(description->get_title(), description->get_asset_id(), description->get_preview_icon(), description->get_download_url(), description->get_sha256()); if (templates_only) { download->set_external_install(true); download->connect("install_asset", callable_mp(this, &EditorAssetLibrary::_install_external_asset)); } } const char *EditorAssetLibrary::sort_key[SORT_MAX] = { "updated", "updated", "name", "name", "cost", "cost", }; const char *EditorAssetLibrary::sort_text[SORT_MAX] = { TTRC("Recently Updated"), TTRC("Least Recently Updated"), TTRC("Name (A-Z)"), TTRC("Name (Z-A)"), TTRC("License (A-Z)"), // "cost" stores the SPDX license name in the Godot Asset Library. TTRC("License (Z-A)"), // "cost" stores the SPDX license name in the Godot Asset Library. }; const char *EditorAssetLibrary::support_key[SUPPORT_MAX] = { "official", "community", "testing", }; void EditorAssetLibrary::_select_author(int p_id) { // Open author window. } void EditorAssetLibrary::_select_category(int p_id) { for (int i = 0; i < categories->get_item_count(); i++) { if (i == 0) continue; int id = categories->get_item_metadata(i); if (id == p_id) { categories->select(i); _search(); break; } } } void EditorAssetLibrary::_select_asset(int p_id) { _api_request("asset/" + itos(p_id), REQUESTING_ASSET); } void EditorAssetLibrary::_image_update(bool use_cache, bool final, const PackedByteArray &p_data, int p_queue_id) { Object *obj = ObjectDB::get_instance(image_queue[p_queue_id].target); if (obj) { bool image_set = false; PackedByteArray image_data = p_data; if (use_cache) { String cache_filename_base = EditorSettings::get_singleton()->get_cache_dir().plus_file("assetimage_" + image_queue[p_queue_id].image_url.md5_text()); FileAccess *file = FileAccess::open(cache_filename_base + ".data", FileAccess::READ); if (file) { PackedByteArray cached_data; int len = file->get_32(); cached_data.resize(len); uint8_t *w = cached_data.ptrw(); file->get_buffer(w, len); image_data = cached_data; file->close(); memdelete(file); } } int len = image_data.size(); const uint8_t *r = image_data.ptr(); Ref image = Ref(memnew(Image)); uint8_t png_signature[8] = { 137, 80, 78, 71, 13, 10, 26, 10 }; uint8_t jpg_signature[3] = { 255, 216, 255 }; if (r) { if ((memcmp(&r[0], &png_signature[0], 8) == 0) && Image::_png_mem_loader_func) { image->copy_internals_from(Image::_png_mem_loader_func(r, len)); } else if ((memcmp(&r[0], &jpg_signature[0], 3) == 0) && Image::_jpg_mem_loader_func) { image->copy_internals_from(Image::_jpg_mem_loader_func(r, len)); } } if (!image->empty()) { switch (image_queue[p_queue_id].image_type) { case IMAGE_QUEUE_ICON: image->resize(64 * EDSCALE, 64 * EDSCALE, Image::INTERPOLATE_LANCZOS); break; case IMAGE_QUEUE_THUMBNAIL: { float max_height = 85 * EDSCALE; float scale_ratio = max_height / (image->get_height() * EDSCALE); if (scale_ratio < 1) { image->resize(image->get_width() * EDSCALE * scale_ratio, image->get_height() * EDSCALE * scale_ratio, Image::INTERPOLATE_LANCZOS); } } break; case IMAGE_QUEUE_SCREENSHOT: { float max_height = 397 * EDSCALE; float scale_ratio = max_height / (image->get_height() * EDSCALE); if (scale_ratio < 1) { image->resize(image->get_width() * EDSCALE * scale_ratio, image->get_height() * EDSCALE * scale_ratio, Image::INTERPOLATE_LANCZOS); } } break; } Ref tex; tex.instance(); tex->create_from_image(image); obj->call("set_image", image_queue[p_queue_id].image_type, image_queue[p_queue_id].image_index, tex); image_set = true; } if (!image_set && final) { obj->call("set_image", image_queue[p_queue_id].image_type, image_queue[p_queue_id].image_index, get_icon("FileBrokenBigThumb", "EditorIcons")); } } } void EditorAssetLibrary::_image_request_completed(int p_status, int p_code, const PackedStringArray &headers, const PackedByteArray &p_data, int p_queue_id) { ERR_FAIL_COND(!image_queue.has(p_queue_id)); if (p_status == HTTPRequest::RESULT_SUCCESS && p_code < HTTPClient::RESPONSE_BAD_REQUEST) { if (p_code != HTTPClient::RESPONSE_NOT_MODIFIED) { for (int i = 0; i < headers.size(); i++) { if (headers[i].findn("ETag:") == 0) { // Save etag String cache_filename_base = EditorSettings::get_singleton()->get_cache_dir().plus_file("assetimage_" + image_queue[p_queue_id].image_url.md5_text()); String new_etag = headers[i].substr(headers[i].find(":") + 1, headers[i].length()).strip_edges(); FileAccess *file; file = FileAccess::open(cache_filename_base + ".etag", FileAccess::WRITE); if (file) { file->store_line(new_etag); file->close(); memdelete(file); } int len = p_data.size(); const uint8_t *r = p_data.ptr(); file = FileAccess::open(cache_filename_base + ".data", FileAccess::WRITE); if (file) { file->store_32(len); file->store_buffer(r, len); file->close(); memdelete(file); } break; } } } _image_update(p_code == HTTPClient::RESPONSE_NOT_MODIFIED, true, p_data, p_queue_id); } else { WARN_PRINT("Error getting image file from URL: " + image_queue[p_queue_id].image_url); Object *obj = ObjectDB::get_instance(image_queue[p_queue_id].target); if (obj) { obj->call("set_image", image_queue[p_queue_id].image_type, image_queue[p_queue_id].image_index, get_icon("FileBrokenBigThumb", "EditorIcons")); } } image_queue[p_queue_id].request->queue_delete(); image_queue.erase(p_queue_id); _update_image_queue(); } void EditorAssetLibrary::_update_image_queue() { const int max_images = 6; int current_images = 0; List to_delete; for (Map::Element *E = image_queue.front(); E; E = E->next()) { if (!E->get().active && current_images < max_images) { String cache_filename_base = EditorSettings::get_singleton()->get_cache_dir().plus_file("assetimage_" + E->get().image_url.md5_text()); Vector headers; if (FileAccess::exists(cache_filename_base + ".etag") && FileAccess::exists(cache_filename_base + ".data")) { FileAccess *file = FileAccess::open(cache_filename_base + ".etag", FileAccess::READ); if (file) { headers.push_back("If-None-Match: " + file->get_line()); file->close(); memdelete(file); } } Error err = E->get().request->request(E->get().image_url, headers); if (err != OK) { to_delete.push_back(E->key()); } else { E->get().active = true; } current_images++; } else if (E->get().active) { current_images++; } } while (to_delete.size()) { image_queue[to_delete.front()->get()].request->queue_delete(); image_queue.erase(to_delete.front()->get()); to_delete.pop_front(); } } void EditorAssetLibrary::_request_image(ObjectID p_for, String p_image_url, ImageType p_type, int p_image_index) { ImageQueue iq; iq.image_url = p_image_url; iq.image_index = p_image_index; iq.image_type = p_type; iq.request = memnew(HTTPRequest); iq.request->set_use_threads(EDITOR_DEF("asset_library/use_threads", true)); iq.target = p_for; iq.queue_id = ++last_queue_id; iq.active = false; iq.request->connect("request_completed", callable_mp(this, &EditorAssetLibrary::_image_request_completed), varray(iq.queue_id)); image_queue[iq.queue_id] = iq; add_child(iq.request); _image_update(true, false, PackedByteArray(), iq.queue_id); _update_image_queue(); } void EditorAssetLibrary::_repository_changed(int p_repository_id) { host = repository->get_item_metadata(p_repository_id); if (templates_only) { _api_request("configure", REQUESTING_CONFIG, "?type=project"); } else { _api_request("configure", REQUESTING_CONFIG); } } void EditorAssetLibrary::_support_toggled(int p_support) { support->get_popup()->set_item_checked(p_support, !support->get_popup()->is_item_checked(p_support)); _search(); } void EditorAssetLibrary::_rerun_search(int p_ignore) { _search(); } void EditorAssetLibrary::_search(int p_page) { String args; if (templates_only) { args += "?type=project&"; } else { args += "?"; } args += String() + "sort=" + sort_key[sort->get_selected()]; // We use the "branch" version, i.e. major.minor, as patch releases should be compatible args += "&godot_version=" + String(VERSION_BRANCH); String support_list; for (int i = 0; i < SUPPORT_MAX; i++) { if (support->get_popup()->is_item_checked(i)) { support_list += String(support_key[i]) + "+"; } } if (support_list != String()) { args += "&support=" + support_list.substr(0, support_list.length() - 1); } if (categories->get_selected() > 0) { args += "&category=" + itos(categories->get_item_metadata(categories->get_selected())); } // Sorting options with an odd index are always the reverse of the previous one if (sort->get_selected() % 2 == 1) { args += "&reverse=true"; } if (filter->get_text() != String()) { args += "&filter=" + filter->get_text().http_escape(); } if (p_page > 0) { args += "&page=" + itos(p_page); } _api_request("asset", REQUESTING_SEARCH, args); } void EditorAssetLibrary::_search_text_entered(const String &p_text) { _search(); } HBoxContainer *EditorAssetLibrary::_make_pages(int p_page, int p_page_count, int p_page_len, int p_total_items, int p_current_items) { HBoxContainer *hbc = memnew(HBoxContainer); if (p_page_count < 2) return hbc; //do the mario int from = p_page - 5; if (from < 0) from = 0; int to = from + 10; if (to > p_page_count) to = p_page_count; hbc->add_spacer(); hbc->add_constant_override("separation", 5 * EDSCALE); Button *first = memnew(Button); first->set_text(TTR("First")); if (p_page != 0) { first->connect("pressed", callable_mp(this, &EditorAssetLibrary::_search), varray(0)); } else { first->set_disabled(true); first->set_focus_mode(Control::FOCUS_NONE); } hbc->add_child(first); Button *prev = memnew(Button); prev->set_text(TTR("Previous")); if (p_page > 0) { prev->connect("pressed", callable_mp(this, &EditorAssetLibrary::_search), varray(p_page - 1)); } else { prev->set_disabled(true); prev->set_focus_mode(Control::FOCUS_NONE); } hbc->add_child(prev); hbc->add_child(memnew(VSeparator)); for (int i = from; i < to; i++) { if (i == p_page) { Button *current = memnew(Button); current->set_text(itos(i + 1)); current->set_disabled(true); current->set_focus_mode(Control::FOCUS_NONE); hbc->add_child(current); } else { Button *current = memnew(Button); current->set_text(itos(i + 1)); current->connect("pressed", callable_mp(this, &EditorAssetLibrary::_search), varray(i)); hbc->add_child(current); } } Button *next = memnew(Button); next->set_text(TTR("Next")); if (p_page < p_page_count - 1) { next->connect("pressed", callable_mp(this, &EditorAssetLibrary::_search), varray(p_page + 1)); } else { next->set_disabled(true); next->set_focus_mode(Control::FOCUS_NONE); } hbc->add_child(memnew(VSeparator)); hbc->add_child(next); Button *last = memnew(Button); last->set_text(TTR("Last")); if (p_page != p_page_count - 1) { last->connect("pressed", callable_mp(this, &EditorAssetLibrary::_search), varray(p_page_count - 1)); } else { last->set_disabled(true); last->set_focus_mode(Control::FOCUS_NONE); } hbc->add_child(last); hbc->add_spacer(); return hbc; } void EditorAssetLibrary::_api_request(const String &p_request, RequestType p_request_type, const String &p_arguments) { if (requesting != REQUESTING_NONE) { request->cancel_request(); } requesting = p_request_type; error_hb->hide(); request->request(host + "/" + p_request + p_arguments); } void EditorAssetLibrary::_http_request_completed(int p_status, int p_code, const PackedStringArray &headers, const PackedByteArray &p_data) { String str; { int datalen = p_data.size(); const uint8_t *r = p_data.ptr(); str.parse_utf8((const char *)r, datalen); } bool error_abort = true; switch (p_status) { case HTTPRequest::RESULT_CANT_RESOLVE: { error_label->set_text(TTR("Can't resolve hostname:") + " " + host); } break; case HTTPRequest::RESULT_BODY_SIZE_LIMIT_EXCEEDED: case HTTPRequest::RESULT_CONNECTION_ERROR: case HTTPRequest::RESULT_CHUNKED_BODY_SIZE_MISMATCH: { error_label->set_text(TTR("Connection error, please try again.")); } break; case HTTPRequest::RESULT_SSL_HANDSHAKE_ERROR: case HTTPRequest::RESULT_CANT_CONNECT: { error_label->set_text(TTR("Can't connect to host:") + " " + host); } break; case HTTPRequest::RESULT_NO_RESPONSE: { error_label->set_text(TTR("No response from host:") + " " + host); } break; case HTTPRequest::RESULT_REQUEST_FAILED: { error_label->set_text(TTR("Request failed, return code:") + " " + itos(p_code)); } break; case HTTPRequest::RESULT_REDIRECT_LIMIT_REACHED: { error_label->set_text(TTR("Request failed, too many redirects")); } break; default: { if (p_code != 200) { error_label->set_text(TTR("Request failed, return code:") + " " + itos(p_code)); } else { error_abort = false; } } break; } if (error_abort) { error_hb->show(); return; } Dictionary d; { Variant js; String errs; int errl; JSON::parse(str, js, errs, errl); d = js; } RequestType requested = requesting; requesting = REQUESTING_NONE; switch (requested) { case REQUESTING_CONFIG: { categories->clear(); categories->add_item(TTR("All")); categories->set_item_metadata(0, 0); if (d.has("categories")) { Array clist = d["categories"]; for (int i = 0; i < clist.size(); i++) { Dictionary cat = clist[i]; if (!cat.has("name") || !cat.has("id")) continue; String name = cat["name"]; int id = cat["id"]; categories->add_item(name); categories->set_item_metadata(categories->get_item_count() - 1, id); category_map[cat["id"]] = name; } } _search(); } break; case REQUESTING_SEARCH: { initial_loading = false; // The loading text only needs to be displayed before the first page is loaded. // Therefore, we don't need to show it again. library_loading->hide(); library_error->hide(); if (asset_items) { memdelete(asset_items); } if (asset_top_page) { memdelete(asset_top_page); } if (asset_bottom_page) { memdelete(asset_bottom_page); } int page = 0; int pages = 1; int page_len = 10; int total_items = 1; Array result; if (d.has("page")) { page = d["page"]; } if (d.has("pages")) { pages = d["pages"]; } if (d.has("page_length")) { page_len = d["page_length"]; } if (d.has("total")) { total_items = d["total"]; } if (d.has("result")) { result = d["result"]; } asset_top_page = _make_pages(page, pages, page_len, total_items, result.size()); library_vb->add_child(asset_top_page); asset_items = memnew(GridContainer); asset_items->set_columns(2); asset_items->add_constant_override("hseparation", 10 * EDSCALE); asset_items->add_constant_override("vseparation", 10 * EDSCALE); library_vb->add_child(asset_items); asset_bottom_page = _make_pages(page, pages, page_len, total_items, result.size()); library_vb->add_child(asset_bottom_page); if (result.empty()) { if (filter->get_text() != String()) { library_error->set_text( vformat(TTR("No results for \"%s\"."), filter->get_text())); } else { // No results, even though the user didn't search for anything specific. // This is typically because the version number changed recently // and no assets compatible with the new version have been published yet. library_error->set_text( vformat(TTR("No results compatible with %s %s."), String(VERSION_SHORT_NAME).capitalize(), String(VERSION_BRANCH))); } library_error->show(); } for (int i = 0; i < result.size(); i++) { Dictionary r = result[i]; ERR_CONTINUE(!r.has("title")); ERR_CONTINUE(!r.has("asset_id")); ERR_CONTINUE(!r.has("author")); ERR_CONTINUE(!r.has("author_id")); ERR_CONTINUE(!r.has("category_id")); ERR_FAIL_COND(!category_map.has(r["category_id"])); ERR_CONTINUE(!r.has("cost")); EditorAssetLibraryItem *item = memnew(EditorAssetLibraryItem); asset_items->add_child(item); item->configure(r["title"], r["asset_id"], category_map[r["category_id"]], r["category_id"], r["author"], r["author_id"], r["cost"]); item->connect("asset_selected", callable_mp(this, &EditorAssetLibrary::_select_asset)); item->connect("author_selected", callable_mp(this, &EditorAssetLibrary::_select_author)); item->connect("category_selected", callable_mp(this, &EditorAssetLibrary::_select_category)); if (r.has("icon_url") && r["icon_url"] != "") { _request_image(item->get_instance_id(), r["icon_url"], IMAGE_QUEUE_ICON, 0); } } } break; case REQUESTING_ASSET: { Dictionary r = d; ERR_FAIL_COND(!r.has("title")); ERR_FAIL_COND(!r.has("asset_id")); ERR_FAIL_COND(!r.has("author")); ERR_FAIL_COND(!r.has("author_id")); ERR_FAIL_COND(!r.has("version")); ERR_FAIL_COND(!r.has("version_string")); ERR_FAIL_COND(!r.has("category_id")); ERR_FAIL_COND(!category_map.has(r["category_id"])); ERR_FAIL_COND(!r.has("cost")); ERR_FAIL_COND(!r.has("description")); ERR_FAIL_COND(!r.has("download_url")); ERR_FAIL_COND(!r.has("download_hash")); ERR_FAIL_COND(!r.has("browse_url")); if (description) { memdelete(description); } description = memnew(EditorAssetLibraryItemDescription); add_child(description); description->popup_centered_minsize(); description->connect("confirmed", callable_mp(this, &EditorAssetLibrary::_install_asset)); description->configure(r["title"], r["asset_id"], category_map[r["category_id"]], r["category_id"], r["author"], r["author_id"], r["cost"], r["version"], r["version_string"], r["description"], r["download_url"], r["browse_url"], r["download_hash"]); if (r.has("icon_url") && r["icon_url"] != "") { _request_image(description->get_instance_id(), r["icon_url"], IMAGE_QUEUE_ICON, 0); } if (d.has("previews")) { Array previews = d["previews"]; for (int i = 0; i < previews.size(); i++) { Dictionary p = previews[i]; ERR_CONTINUE(!p.has("type")); ERR_CONTINUE(!p.has("link")); bool is_video = p.has("type") && String(p["type"]) == "video"; String video_url; if (is_video && p.has("link")) { video_url = p["link"]; } description->add_preview(i, is_video, video_url); if (p.has("thumbnail")) { _request_image(description->get_instance_id(), p["thumbnail"], IMAGE_QUEUE_THUMBNAIL, i); } if (!is_video) { _request_image(description->get_instance_id(), p["link"], IMAGE_QUEUE_SCREENSHOT, i); } } } } break; default: break; } } void EditorAssetLibrary::_asset_file_selected(const String &p_file) { if (asset_installer) { memdelete(asset_installer); asset_installer = NULL; } asset_installer = memnew(EditorAssetInstaller); add_child(asset_installer); asset_installer->open(p_file); } void EditorAssetLibrary::_asset_open() { asset_open->popup_centered_ratio(); } void EditorAssetLibrary::_manage_plugins() { ProjectSettingsEditor::get_singleton()->popup_project_settings(); ProjectSettingsEditor::get_singleton()->set_plugins_page(); } void EditorAssetLibrary::_install_external_asset(String p_zip_path, String p_title) { emit_signal("install_asset", p_zip_path, p_title); } void EditorAssetLibrary::disable_community_support() { support->get_popup()->set_item_checked(SUPPORT_COMMUNITY, false); } void EditorAssetLibrary::_bind_methods() { ClassDB::bind_method("_unhandled_input", &EditorAssetLibrary::_unhandled_input); ADD_SIGNAL(MethodInfo("install_asset", PropertyInfo(Variant::STRING, "zip_path"), PropertyInfo(Variant::STRING, "name"))); } EditorAssetLibrary::EditorAssetLibrary(bool p_templates_only) { requesting = REQUESTING_NONE; templates_only = p_templates_only; initial_loading = true; VBoxContainer *library_main = memnew(VBoxContainer); add_child(library_main); HBoxContainer *search_hb = memnew(HBoxContainer); library_main->add_child(search_hb); library_main->add_constant_override("separation", 10 * EDSCALE); filter = memnew(LineEdit); search_hb->add_child(filter); filter->set_h_size_flags(SIZE_EXPAND_FILL); filter->connect("text_entered", callable_mp(this, &EditorAssetLibrary::_search_text_entered)); search = memnew(Button(TTR("Search"))); search->connect("pressed", callable_mp(this, &EditorAssetLibrary::_search)); search_hb->add_child(search); if (!p_templates_only) search_hb->add_child(memnew(VSeparator)); Button *open_asset = memnew(Button); open_asset->set_text(TTR("Import...")); search_hb->add_child(open_asset); open_asset->connect("pressed", callable_mp(this, &EditorAssetLibrary::_asset_open)); Button *plugins = memnew(Button); plugins->set_text(TTR("Plugins...")); search_hb->add_child(plugins); plugins->connect("pressed", callable_mp(this, &EditorAssetLibrary::_manage_plugins)); if (p_templates_only) { open_asset->hide(); plugins->hide(); } HBoxContainer *search_hb2 = memnew(HBoxContainer); library_main->add_child(search_hb2); search_hb2->add_child(memnew(Label(TTR("Sort:") + " "))); sort = memnew(OptionButton); for (int i = 0; i < SORT_MAX; i++) { sort->add_item(TTRGET(sort_text[i])); } search_hb2->add_child(sort); sort->set_h_size_flags(SIZE_EXPAND_FILL); sort->connect("item_selected", callable_mp(this, &EditorAssetLibrary::_rerun_search)); search_hb2->add_child(memnew(VSeparator)); search_hb2->add_child(memnew(Label(TTR("Category:") + " "))); categories = memnew(OptionButton); categories->add_item(TTR("All")); search_hb2->add_child(categories); categories->set_h_size_flags(SIZE_EXPAND_FILL); categories->connect("item_selected", callable_mp(this, &EditorAssetLibrary::_rerun_search)); search_hb2->add_child(memnew(VSeparator)); search_hb2->add_child(memnew(Label(TTR("Site:") + " "))); repository = memnew(OptionButton); repository->add_item("godotengine.org"); repository->set_item_metadata(0, "https://godotengine.org/asset-library/api"); repository->add_item("localhost"); repository->set_item_metadata(1, "http://127.0.0.1/asset-library/api"); repository->connect("item_selected", callable_mp(this, &EditorAssetLibrary::_repository_changed)); search_hb2->add_child(repository); repository->set_h_size_flags(SIZE_EXPAND_FILL); search_hb2->add_child(memnew(VSeparator)); support = memnew(MenuButton); search_hb2->add_child(support); support->set_text(TTR("Support")); support->get_popup()->add_check_item(TTR("Official"), SUPPORT_OFFICIAL); support->get_popup()->add_check_item(TTR("Community"), SUPPORT_COMMUNITY); support->get_popup()->add_check_item(TTR("Testing"), SUPPORT_TESTING); support->get_popup()->set_item_checked(SUPPORT_OFFICIAL, true); support->get_popup()->set_item_checked(SUPPORT_COMMUNITY, true); support->get_popup()->connect("id_pressed", callable_mp(this, &EditorAssetLibrary::_support_toggled)); ///////// library_scroll_bg = memnew(PanelContainer); library_main->add_child(library_scroll_bg); library_scroll_bg->set_v_size_flags(SIZE_EXPAND_FILL); library_scroll = memnew(ScrollContainer); library_scroll->set_enable_v_scroll(true); library_scroll->set_enable_h_scroll(false); library_scroll_bg->add_child(library_scroll); Ref border2; border2.instance(); border2->set_default_margin(MARGIN_LEFT, 15 * EDSCALE); border2->set_default_margin(MARGIN_RIGHT, 35 * EDSCALE); border2->set_default_margin(MARGIN_BOTTOM, 15 * EDSCALE); border2->set_default_margin(MARGIN_TOP, 15 * EDSCALE); PanelContainer *library_vb_border = memnew(PanelContainer); library_scroll->add_child(library_vb_border); library_vb_border->add_style_override("panel", border2); library_vb_border->set_h_size_flags(SIZE_EXPAND_FILL); library_vb = memnew(VBoxContainer); library_vb->set_h_size_flags(SIZE_EXPAND_FILL); library_vb_border->add_child(library_vb); library_loading = memnew(Label(TTR("Loading..."))); library_loading->set_align(Label::ALIGN_CENTER); library_vb->add_child(library_loading); library_error = memnew(Label); library_error->set_align(Label::ALIGN_CENTER); library_error->hide(); library_vb->add_child(library_error); asset_top_page = memnew(HBoxContainer); library_vb->add_child(asset_top_page); asset_items = memnew(GridContainer); asset_items->set_columns(2); asset_items->add_constant_override("hseparation", 10 * EDSCALE); asset_items->add_constant_override("vseparation", 10 * EDSCALE); library_vb->add_child(asset_items); asset_bottom_page = memnew(HBoxContainer); library_vb->add_child(asset_bottom_page); request = memnew(HTTPRequest); add_child(request); request->set_use_threads(EDITOR_DEF("asset_library/use_threads", true)); request->connect("request_completed", callable_mp(this, &EditorAssetLibrary::_http_request_completed)); last_queue_id = 0; library_vb->add_constant_override("separation", 20 * EDSCALE); error_hb = memnew(HBoxContainer); library_main->add_child(error_hb); error_label = memnew(Label); error_label->add_color_override("color", get_color("error_color", "Editor")); error_hb->add_child(error_label); error_tr = memnew(TextureRect); error_tr->set_v_size_flags(Control::SIZE_SHRINK_CENTER); error_hb->add_child(error_tr); description = NULL; set_process(true); set_process_unhandled_input(true); downloads_scroll = memnew(ScrollContainer); downloads_scroll->set_enable_h_scroll(true); downloads_scroll->set_enable_v_scroll(false); library_main->add_child(downloads_scroll); downloads_hb = memnew(HBoxContainer); downloads_scroll->add_child(downloads_hb); asset_open = memnew(EditorFileDialog); asset_open->set_access(EditorFileDialog::ACCESS_FILESYSTEM); asset_open->add_filter("*.zip ; " + TTR("Assets ZIP File")); asset_open->set_mode(EditorFileDialog::MODE_OPEN_FILE); add_child(asset_open); asset_open->connect("file_selected", callable_mp(this, &EditorAssetLibrary::_asset_file_selected)); asset_installer = NULL; } /////// void AssetLibraryEditorPlugin::make_visible(bool p_visible) { if (p_visible) { addon_library->show(); } else { addon_library->hide(); } } AssetLibraryEditorPlugin::AssetLibraryEditorPlugin(EditorNode *p_node) { editor = p_node; addon_library = memnew(EditorAssetLibrary); addon_library->set_v_size_flags(Control::SIZE_EXPAND_FILL); editor->get_viewport()->add_child(addon_library); addon_library->set_anchors_and_margins_preset(Control::PRESET_WIDE); addon_library->hide(); } AssetLibraryEditorPlugin::~AssetLibraryEditorPlugin() { }