virtualx-engine/core/io/resource_loader.cpp

353 lines
10 KiB
C++
Raw Normal View History

2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* resource_loader.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "resource_loader.h"
#include "global_config.h"
2014-02-10 02:10:30 +01:00
#include "os/file_access.h"
#include "os/os.h"
#include "path_remap.h"
#include "print_string.h"
2014-02-10 02:10:30 +01:00
ResourceFormatLoader *ResourceLoader::loader[MAX_LOADERS];
int ResourceLoader::loader_count = 0;
2014-02-10 02:10:30 +01:00
Error ResourceInteractiveLoader::wait() {
Error err = poll();
while (err == OK) {
err = poll();
2014-02-10 02:10:30 +01:00
}
return err;
}
bool ResourceFormatLoader::recognize_path(const String &p_path, const String &p_for_type) const {
2016-03-09 00:00:52 +01:00
String extension = p_path.get_extension();
2016-03-09 00:00:52 +01:00
2014-02-10 02:10:30 +01:00
List<String> extensions;
if (p_for_type == String()) {
get_recognized_extensions(&extensions);
} else {
get_recognized_extensions_for_type(p_for_type, &extensions);
}
for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
if (E->get().nocasecmp_to(extension) == 0)
2014-02-10 02:10:30 +01:00
return true;
}
2016-03-09 00:00:52 +01:00
2014-02-10 02:10:30 +01:00
return false;
}
void ResourceFormatLoader::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
if (p_type == "" || handles_type(p_type))
2014-02-10 02:10:30 +01:00
get_recognized_extensions(p_extensions);
}
void ResourceLoader::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) {
2014-02-10 02:10:30 +01:00
for (int i = 0; i < loader_count; i++) {
loader[i]->get_recognized_extensions_for_type(p_type, p_extensions);
2014-02-10 02:10:30 +01:00
}
}
void ResourceInteractiveLoader::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_resource"), &ResourceInteractiveLoader::get_resource);
ClassDB::bind_method(D_METHOD("poll"), &ResourceInteractiveLoader::poll);
ClassDB::bind_method(D_METHOD("wait"), &ResourceInteractiveLoader::wait);
ClassDB::bind_method(D_METHOD("get_stage"), &ResourceInteractiveLoader::get_stage);
ClassDB::bind_method(D_METHOD("get_stage_count"), &ResourceInteractiveLoader::get_stage_count);
2014-02-10 02:10:30 +01:00
}
class ResourceInteractiveLoaderDefault : public ResourceInteractiveLoader {
GDCLASS(ResourceInteractiveLoaderDefault, ResourceInteractiveLoader);
2014-02-10 02:10:30 +01:00
public:
2014-02-10 02:10:30 +01:00
Ref<Resource> resource;
virtual void set_local_path(const String &p_local_path) { /*scene->set_filename(p_local_path);*/
}
2014-02-10 02:10:30 +01:00
virtual Ref<Resource> get_resource() { return resource; }
virtual Error poll() { return ERR_FILE_EOF; }
virtual int get_stage() const { return 1; }
virtual int get_stage_count() const { return 1; }
ResourceInteractiveLoaderDefault() {}
};
Ref<ResourceInteractiveLoader> ResourceFormatLoader::load_interactive(const String &p_path, Error *r_error) {
2014-02-10 02:10:30 +01:00
//either this
Ref<Resource> res = load(p_path, p_path, r_error);
2014-02-10 02:10:30 +01:00
if (res.is_null())
return Ref<ResourceInteractiveLoader>();
Ref<ResourceInteractiveLoaderDefault> ril = Ref<ResourceInteractiveLoaderDefault>(memnew(ResourceInteractiveLoaderDefault));
ril->resource = res;
2014-02-10 02:10:30 +01:00
return ril;
}
RES ResourceFormatLoader::load(const String &p_path, const String &p_original_path, Error *r_error) {
String path = p_path;
2014-02-10 02:10:30 +01:00
//or this must be implemented
Ref<ResourceInteractiveLoader> ril = load_interactive(p_path, r_error);
2014-02-10 02:10:30 +01:00
if (!ril.is_valid())
return RES();
ril->set_local_path(p_original_path);
while (true) {
2014-02-10 02:10:30 +01:00
Error err = ril->poll();
if (err == ERR_FILE_EOF) {
if (r_error)
*r_error = OK;
2014-02-10 02:10:30 +01:00
return ril->get_resource();
}
if (r_error)
*r_error = err;
ERR_FAIL_COND_V(err != OK, RES());
2014-02-10 02:10:30 +01:00
}
return RES();
}
void ResourceFormatLoader::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
2014-02-10 02:10:30 +01:00
//do nothing by default
}
///////////////////////////////////
RES ResourceLoader::load(const String &p_path, const String &p_type_hint, bool p_no_cache, Error *r_error) {
if (r_error)
*r_error = ERR_CANT_OPEN;
2014-02-10 02:10:30 +01:00
String local_path;
if (p_path.is_rel_path())
local_path = "res://" + p_path;
else
local_path = GlobalConfig::get_singleton()->localize_path(p_path);
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND_V(local_path == "", RES());
2014-02-10 02:10:30 +01:00
if (!p_no_cache && ResourceCache::has(local_path)) {
if (OS::get_singleton()->is_stdout_verbose())
print_line("load resource: " + local_path + " (cached)");
2014-02-10 02:10:30 +01:00
return RES(ResourceCache::get(local_path));
2014-02-10 02:10:30 +01:00
}
if (OS::get_singleton()->is_stdout_verbose())
print_line("load resource: " + local_path);
bool found = false;
2016-03-09 00:00:52 +01:00
// Try all loaders and pick the first match for the type hint
for (int i = 0; i < loader_count; i++) {
2016-03-09 00:00:52 +01:00
if (!loader[i]->recognize_path(local_path, p_type_hint)) {
2014-02-10 02:10:30 +01:00
continue;
}
found = true;
RES res = loader[i]->load(local_path, local_path, r_error);
if (res.is_null()) {
2014-02-10 02:10:30 +01:00
continue;
}
2014-02-10 02:10:30 +01:00
if (!p_no_cache)
res->set_path(local_path);
#ifdef TOOLS_ENABLED
res->set_edited(false);
if (timestamp_on_load) {
uint64_t mt = FileAccess::get_modified_time(local_path);
2014-02-10 02:10:30 +01:00
//printf("mt %s: %lli\n",remapped_path.utf8().get_data(),mt);
res->set_last_modified_time(mt);
}
#endif
2014-02-10 02:10:30 +01:00
return res;
}
if (found) {
ERR_EXPLAIN("Failed loading resource: " + p_path);
2014-02-10 02:10:30 +01:00
} else {
ERR_EXPLAIN("No loader found for resource: " + p_path);
2014-02-10 02:10:30 +01:00
}
ERR_FAIL_V(RES());
return RES();
}
Ref<ResourceInteractiveLoader> ResourceLoader::load_interactive(const String &p_path, const String &p_type_hint, bool p_no_cache, Error *r_error) {
2014-02-10 02:10:30 +01:00
if (r_error)
*r_error = ERR_CANT_OPEN;
2014-02-10 02:10:30 +01:00
String local_path;
if (p_path.is_rel_path())
local_path = "res://" + p_path;
else
local_path = GlobalConfig::get_singleton()->localize_path(p_path);
2014-02-10 02:10:30 +01:00
ERR_FAIL_COND_V(local_path == "", Ref<ResourceInteractiveLoader>());
2014-02-10 02:10:30 +01:00
if (!p_no_cache && ResourceCache::has(local_path)) {
if (OS::get_singleton()->is_stdout_verbose())
print_line("load resource: " + local_path + " (cached)");
2014-02-10 02:10:30 +01:00
Ref<Resource> res_cached = ResourceCache::get(local_path);
Ref<ResourceInteractiveLoaderDefault> ril = Ref<ResourceInteractiveLoaderDefault>(memnew(ResourceInteractiveLoaderDefault));
ril->resource = res_cached;
return ril;
2014-02-10 02:10:30 +01:00
}
if (OS::get_singleton()->is_stdout_verbose())
print_line("load resource: ");
bool found = false;
2014-02-10 02:10:30 +01:00
for (int i = 0; i < loader_count; i++) {
2014-02-10 02:10:30 +01:00
if (!loader[i]->recognize_path(local_path, p_type_hint))
2014-02-10 02:10:30 +01:00
continue;
found = true;
Ref<ResourceInteractiveLoader> ril = loader[i]->load_interactive(local_path, r_error);
2014-02-10 02:10:30 +01:00
if (ril.is_null())
continue;
if (!p_no_cache)
ril->set_local_path(local_path);
return ril;
}
if (found) {
ERR_EXPLAIN("Failed loading resource: " + p_path);
2014-02-10 02:10:30 +01:00
} else {
ERR_EXPLAIN("No loader found for resource: " + p_path);
2014-02-10 02:10:30 +01:00
}
ERR_FAIL_V(Ref<ResourceInteractiveLoader>());
return Ref<ResourceInteractiveLoader>();
}
void ResourceLoader::add_resource_format_loader(ResourceFormatLoader *p_format_loader, bool p_at_front) {
2016-03-09 00:00:52 +01:00
ERR_FAIL_COND(loader_count >= MAX_LOADERS);
if (p_at_front) {
for (int i = loader_count; i > 0; i--) {
loader[i] = loader[i - 1];
}
loader[0] = p_format_loader;
loader_count++;
} else {
loader[loader_count++] = p_format_loader;
}
2014-02-10 02:10:30 +01:00
}
void ResourceLoader::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
String local_path;
if (p_path.is_rel_path())
local_path = "res://" + p_path;
else
local_path = GlobalConfig::get_singleton()->localize_path(p_path);
for (int i = 0; i < loader_count; i++) {
if (!loader[i]->recognize_path(local_path))
continue;
/*
if (p_type_hint!="" && !loader[i]->handles_type(p_type_hint))
continue;
*/
loader[i]->get_dependencies(local_path, p_dependencies, p_add_types);
}
}
Error ResourceLoader::rename_dependencies(const String &p_path, const Map<String, String> &p_map) {
String local_path;
if (p_path.is_rel_path())
local_path = "res://" + p_path;
else
local_path = GlobalConfig::get_singleton()->localize_path(p_path);
for (int i = 0; i < loader_count; i++) {
2014-02-10 02:10:30 +01:00
if (!loader[i]->recognize_path(local_path))
2014-02-10 02:10:30 +01:00
continue;
/*
if (p_type_hint!="" && !loader[i]->handles_type(p_type_hint))
continue;
*/
2014-02-10 02:10:30 +01:00
return loader[i]->rename_dependencies(local_path, p_map);
2014-02-10 02:10:30 +01:00
}
return OK; // ??
2014-02-10 02:10:30 +01:00
}
String ResourceLoader::get_resource_type(const String &p_path) {
String local_path;
if (p_path.is_rel_path())
local_path = "res://" + p_path;
else
local_path = GlobalConfig::get_singleton()->localize_path(p_path);
for (int i = 0; i < loader_count; i++) {
2014-02-10 02:10:30 +01:00
String result = loader[i]->get_resource_type(local_path);
if (result != "")
2014-02-10 02:10:30 +01:00
return result;
}
return "";
}
ResourceLoadErrorNotify ResourceLoader::err_notify = NULL;
void *ResourceLoader::err_notify_ud = NULL;
DependencyErrorNotify ResourceLoader::dep_err_notify = NULL;
void *ResourceLoader::dep_err_notify_ud = NULL;
2014-02-10 02:10:30 +01:00
bool ResourceLoader::abort_on_missing_resource = true;
bool ResourceLoader::timestamp_on_load = false;