gaming/godot
gaming/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot synced 2024-10-14 10:18:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix referring to ResourceImporterScene static importers via instances

Browse source
This commit is contained in:
Aaron Franke 2023-10-08 00:48:53 -05:00
parent 15a03ed98e
commit 52f1b86ebc
No known key found for this signature in database
GPG key ID: 40A1750B977E56BF
6 changed files with 37 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
editor/editor_node.cpp
View file

@ -6924,15 +6924,15 @@ EditorNode::EditorNode() {
{
Ref<EditorSceneFormatImporterCollada> import_collada;
import_collada.instantiate();
ResourceImporterScene::add_importer(import_collada);
ResourceImporterScene::add_scene_importer(import_collada);
Ref<EditorOBJImporter> import_obj2;
import_obj2.instantiate();
ResourceImporterScene::add_importer(import_obj2);
ResourceImporterScene::add_scene_importer(import_obj2);
Ref<EditorSceneFormatImporterESCN> import_escn;
import_escn.instantiate();
ResourceImporterScene::add_importer(import_escn);
ResourceImporterScene::add_scene_importer(import_escn);
}
Ref<ResourceImporterBitMap> import_bitmap;

4
editor/editor_plugin.cpp
View file

@ -443,12 +443,12 @@ void EditorPlugin::remove_inspector_plugin(const Ref<EditorInspectorPlugin> &p_p
void EditorPlugin::add_scene_format_importer_plugin(const Ref<EditorSceneFormatImporter> &p_importer, bool p_first_priority) {
ERR_FAIL_COND(!p_importer.is_valid());
ResourceImporterScene::add_importer(p_importer, p_first_priority);
ResourceImporterScene::add_scene_importer(p_importer, p_first_priority);
}
void EditorPlugin::remove_scene_format_importer_plugin(const Ref<EditorSceneFormatImporter> &p_importer) {
ERR_FAIL_COND(!p_importer.is_valid());
ResourceImporterScene::remove_importer(p_importer);
ResourceImporterScene::remove_scene_importer(p_importer);
}
void EditorPlugin::add_scene_post_import_plugin(const Ref<EditorScenePostImportPlugin> &p_plugin, bool p_first_priority) {

28
editor/filesystem_dock.cpp
View file

@ -47,7 +47,7 @@
#include "editor/editor_string_names.h"
#include "editor/gui/editor_dir_dialog.h"
#include "editor/gui/editor_scene_tabs.h"
#include "editor/import/resource_importer_scene.h"
#include "editor/import/scene_import_settings.h"
#include "editor/import_dock.h"
#include "editor/plugins/editor_resource_tooltip_plugins.h"
#include "editor/scene_create_dialog.h"
@ -1192,12 +1192,12 @@ void FileSystemDock::_select_file(const String &p_path, bool p_select_in_favorit
String resource_type = ResourceLoader::get_resource_type(fpath);
if (resource_type == "PackedScene") {
if (resource_type == "PackedScene" || resource_type == "AnimationLibrary") {
bool is_imported = false;
{
List<String> importer_exts;
ResourceImporterScene::get_scene_singleton()->get_recognized_extensions(&importer_exts);
ResourceImporterScene::get_scene_importer_extensions(&importer_exts);
String extension = fpath.get_extension();
for (const String &E : importer_exts) {
if (extension.nocasecmp_to(E) == 0) {
@ -1208,27 +1208,7 @@ void FileSystemDock::_select_file(const String &p_path, bool p_select_in_favorit
}
if (is_imported) {
ResourceImporterScene::get_scene_singleton()->show_advanced_options(fpath);
} else {
EditorNode::get_singleton()->open_request(fpath);
}
} else if (resource_type == "AnimationLibrary") {
bool is_imported = false;
{
List<String> importer_exts;
ResourceImporterScene::get_animation_singleton()->get_recognized_extensions(&importer_exts);
String extension = fpath.get_extension();
for (const String &E : importer_exts) {
if (extension.nocasecmp_to(E) == 0) {
is_imported = true;
break;
}
}
}
if (is_imported) {
ResourceImporterScene::get_animation_singleton()->show_advanced_options(fpath);
SceneImportSettingsDialog::get_singleton()->open_settings(p_path, resource_type == "AnimationLibrary");
} else {
EditorNode::get_singleton()->open_request(fpath);
}

35
editor/import/resource_importer_scene.cpp
View file

@ -250,9 +250,7 @@ String ResourceImporterScene::get_visible_name() const {
}
void ResourceImporterScene::get_recognized_extensions(List<String> *p_extensions) const {
for (Ref<EditorSceneFormatImporter> importer_elem : importers) {
importer_elem->get_extensions(p_extensions);
}
get_scene_importer_extensions(p_extensions);
}
String ResourceImporterScene::get_save_extension() const {
@ -294,7 +292,7 @@ bool ResourceImporterScene::get_option_visibility(const String &p_path, const St
}
}
for (Ref<EditorSceneFormatImporter> importer : importers) {
for (Ref<EditorSceneFormatImporter> importer : scene_importers) {
Variant ret = importer->get_option_visibility(p_path, animation_importer, p_option, p_options);
if (ret.get_type() == Variant::BOOL) {
return ret;
@ -1951,13 +1949,13 @@ void ResourceImporterScene::get_import_options(const String &p_path, List<Import
post_importer_plugins.write[i]->get_import_options(p_path, r_options);
}
for (Ref<EditorSceneFormatImporter> importer_elem : importers) {
for (Ref<EditorSceneFormatImporter> importer_elem : scene_importers) {
importer_elem->get_import_options(p_path, r_options);
}
}
void ResourceImporterScene::handle_compatibility_options(HashMap<StringName, Variant> &p_import_params) const {
for (Ref<EditorSceneFormatImporter> importer_elem : importers) {
for (Ref<EditorSceneFormatImporter> importer_elem : scene_importers) {
importer_elem->handle_compatibility_options(p_import_params);
}
}
@ -2360,7 +2358,7 @@ Node *ResourceImporterScene::pre_import(const String &p_source_file, const HashM
EditorProgress progress("pre-import", TTR("Pre-Import Scene"), 0);
progress.step(TTR("Importing Scene..."), 0);
for (Ref<EditorSceneFormatImporter> importer_elem : importers) {
for (Ref<EditorSceneFormatImporter> importer_elem : scene_importers) {
List<String> extensions;
importer_elem->get_extensions(&extensions);
@ -2402,7 +2400,7 @@ Error ResourceImporterScene::import(const String &p_source_file, const String &p
EditorProgress progress("import", TTR("Import Scene"), 104);
progress.step(TTR("Importing Scene..."), 0);
for (Ref<EditorSceneFormatImporter> importer_elem : importers) {
for (Ref<EditorSceneFormatImporter> importer_elem : scene_importers) {
List<String> extensions;
importer_elem->get_extensions(&extensions);
@ -2665,12 +2663,13 @@ Error ResourceImporterScene::import(const String &p_source_file, const String &p
ResourceImporterScene *ResourceImporterScene::scene_singleton = nullptr;
ResourceImporterScene *ResourceImporterScene::animation_singleton = nullptr;
Vector<Ref<EditorSceneFormatImporter>> ResourceImporterScene::importers;
Vector<Ref<EditorSceneFormatImporter>> ResourceImporterScene::scene_importers;
Vector<Ref<EditorScenePostImportPlugin>> ResourceImporterScene::post_importer_plugins;
bool ResourceImporterScene::has_advanced_options() const {
return true;
}
void ResourceImporterScene::show_advanced_options(const String &p_path) {
SceneImportSettingsDialog::get_singleton()->open_settings(p_path, animation_importer);
}
@ -2697,12 +2696,12 @@ ResourceImporterScene::~ResourceImporterScene() {
}
}
void ResourceImporterScene::add_importer(Ref<EditorSceneFormatImporter> p_importer, bool p_first_priority) {
void ResourceImporterScene::add_scene_importer(Ref<EditorSceneFormatImporter> p_importer, bool p_first_priority) {
ERR_FAIL_COND(p_importer.is_null());
if (p_first_priority) {
importers.insert(0, p_importer);
scene_importers.insert(0, p_importer);
} else {
importers.push_back(p_importer);
scene_importers.push_back(p_importer);
}
}
@ -2719,15 +2718,21 @@ void ResourceImporterScene::add_post_importer_plugin(const Ref<EditorScenePostIm
}
}
void ResourceImporterScene::remove_importer(Ref<EditorSceneFormatImporter> p_importer) {
importers.erase(p_importer);
void ResourceImporterScene::remove_scene_importer(Ref<EditorSceneFormatImporter> p_importer) {
scene_importers.erase(p_importer);
}
void ResourceImporterScene::clean_up_importer_plugins() {
importers.clear();
scene_importers.clear();
post_importer_plugins.clear();
}
void ResourceImporterScene::get_scene_importer_extensions(List<String> *p_extensions) {
for (Ref<EditorSceneFormatImporter> importer_elem : scene_importers) {
importer_elem->get_extensions(p_extensions);
}
}
///////////////////////////////////////
uint32_t EditorSceneFormatImporterESCN::get_import_flags() const {

10
editor/import/resource_importer_scene.h
View file

@ -159,7 +159,7 @@ VARIANT_ENUM_CAST(EditorScenePostImportPlugin::InternalImportCategory)
class ResourceImporterScene : public ResourceImporter {
GDCLASS(ResourceImporterScene, ResourceImporter);
static Vector<Ref<EditorSceneFormatImporter>> importers;
static Vector<Ref<EditorSceneFormatImporter>> scene_importers;
static Vector<Ref<EditorScenePostImportPlugin>> post_importer_plugins;
static ResourceImporterScene *scene_singleton;
@ -243,10 +243,10 @@ public:
static void add_post_importer_plugin(const Ref<EditorScenePostImportPlugin> &p_plugin, bool p_first_priority = false);
static void remove_post_importer_plugin(const Ref<EditorScenePostImportPlugin> &p_plugin);
const Vector<Ref<EditorSceneFormatImporter>> &get_importers() const { return importers; }
static void add_importer(Ref<EditorSceneFormatImporter> p_importer, bool p_first_priority = false);
static void remove_importer(Ref<EditorSceneFormatImporter> p_importer);
const Vector<Ref<EditorSceneFormatImporter>> &get_scene_importers() const { return scene_importers; }
static void add_scene_importer(Ref<EditorSceneFormatImporter> p_importer, bool p_first_priority = false);
static void remove_scene_importer(Ref<EditorSceneFormatImporter> p_importer);
static void get_scene_importer_extensions(List<String> *p_extensions);
static void clean_up_importer_plugins();

6
modules/gltf/register_types.cpp
View file

@ -51,7 +51,7 @@
static void _editor_init() {
Ref<EditorSceneFormatImporterGLTF> import_gltf;
import_gltf.instantiate();
ResourceImporterScene::add_importer(import_gltf);
ResourceImporterScene::add_scene_importer(import_gltf);
// Blend to glTF importer.
@ -66,7 +66,7 @@ static void _editor_init() {
} else {
Ref<EditorSceneFormatImporterBlend> importer;
importer.instantiate();
ResourceImporterScene::add_importer(importer);
ResourceImporterScene::add_scene_importer(importer);
Ref<EditorFileSystemImportFormatSupportQueryBlend> blend_import_query;
blend_import_query.instantiate();
@ -82,7 +82,7 @@ static void _editor_init() {
if (fbx_enabled) {
Ref<EditorSceneFormatImporterFBX> importer;
importer.instantiate();
ResourceImporterScene::get_scene_singleton()->add_importer(importer);
ResourceImporterScene::add_scene_importer(importer);
Ref<EditorFileSystemImportFormatSupportQueryFBX> fbx_import_query;
fbx_import_query.instantiate();