mirror of
https://github.com/godotengine/godot.git
synced 2025-12-08 06:09:55 +00:00
Remove RES and REF typedefs in favor of spelled out Ref<>
These typedefs don't save much typing compared to the full `Ref<Resource>` and `Ref<RefCounted>`, yet they sometimes introduce confusion among new contributors.
This commit is contained in:
Hugo Locurcio
parent
8762286110
commit
180e5d3028
147 changed files with 607 additions and 611 deletions
|
|
@ -58,15 +58,15 @@ ResourceLoader::ThreadLoadStatus ResourceLoader::load_threaded_get_status(const
|
|||
return (ThreadLoadStatus)tls;
|
||||
}
|
||||
|
||||
RES ResourceLoader::load_threaded_get(const String &p_path) {
|
||||
Ref<Resource> ResourceLoader::load_threaded_get(const String &p_path) {
|
||||
Error error;
|
||||
RES res = ::ResourceLoader::load_threaded_get(p_path, &error);
|
||||
Ref<Resource> res = ::ResourceLoader::load_threaded_get(p_path, &error);
|
||||
return res;
|
||||
}
|
||||
|
||||
RES ResourceLoader::load(const String &p_path, const String &p_type_hint, CacheMode p_cache_mode) {
|
||||
Ref<Resource> ResourceLoader::load(const String &p_path, const String &p_type_hint, CacheMode p_cache_mode) {
|
||||
Error err = OK;
|
||||
RES ret = ::ResourceLoader::load(p_path, p_type_hint, ResourceFormatLoader::CacheMode(p_cache_mode), &err);
|
||||
Ref<Resource> ret = ::ResourceLoader::load(p_path, p_type_hint, ResourceFormatLoader::CacheMode(p_cache_mode), &err);
|
||||
|
||||
ERR_FAIL_COND_V_MSG(err != OK, ret, "Error loading resource: '" + p_path + "'.");
|
||||
return ret;
|
||||
|
|
@ -137,12 +137,12 @@ void ResourceLoader::_bind_methods() {
|
|||
|
||||
////// ResourceSaver //////
|
||||
|
||||
Error ResourceSaver::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
|
||||
Error ResourceSaver::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
|
||||
ERR_FAIL_COND_V_MSG(p_resource.is_null(), ERR_INVALID_PARAMETER, "Can't save empty resource to path '" + String(p_path) + "'.");
|
||||
return ::ResourceSaver::save(p_path, p_resource, p_flags);
|
||||
}
|
||||
|
||||
Vector<String> ResourceSaver::get_recognized_extensions(const RES &p_resource) {
|
||||
Vector<String> ResourceSaver::get_recognized_extensions(const Ref<Resource> &p_resource) {
|
||||
ERR_FAIL_COND_V_MSG(p_resource.is_null(), Vector<String>(), "It's not a reference to a valid Resource object.");
|
||||
List<String> exts;
|
||||
::ResourceSaver::get_recognized_extensions(p_resource, &exts);
|
||||
|
|
@ -1970,7 +1970,7 @@ Variant ClassDB::instantiate(const StringName &p_class) const {
|
|||
|
||||
RefCounted *r = Object::cast_to<RefCounted>(obj);
|
||||
if (r) {
|
||||
return REF(r);
|
||||
return Ref<RefCounted>(r);
|
||||
} else {
|
||||
return obj;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -73,9 +73,9 @@ public:
|
|||
|
||||
Error load_threaded_request(const String &p_path, const String &p_type_hint = "", bool p_use_sub_threads = false);
|
||||
ThreadLoadStatus load_threaded_get_status(const String &p_path, Array r_progress = Array());
|
||||
RES load_threaded_get(const String &p_path);
|
||||
Ref<Resource> load_threaded_get(const String &p_path);
|
||||
|
||||
RES load(const String &p_path, const String &p_type_hint = "", CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
Ref<Resource> load(const String &p_path, const String &p_type_hint = "", CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
Vector<String> get_recognized_extensions_for_type(const String &p_type);
|
||||
void set_abort_on_missing_resources(bool p_abort);
|
||||
PackedStringArray get_dependencies(const String &p_path);
|
||||
|
|
@ -107,8 +107,8 @@ public:
|
|||
|
||||
static ResourceSaver *get_singleton() { return singleton; }
|
||||
|
||||
Error save(const String &p_path, const RES &p_resource, uint32_t p_flags);
|
||||
Vector<String> get_recognized_extensions(const RES &p_resource);
|
||||
Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags);
|
||||
Vector<String> get_recognized_extensions(const Ref<Resource> &p_resource);
|
||||
|
||||
ResourceSaver() { singleton = this; }
|
||||
};
|
||||
|
|
|
|||
|
|
@ -141,7 +141,7 @@ void Crypto::_bind_methods() {
|
|||
|
||||
/// Resource loader/saver
|
||||
|
||||
RES ResourceFormatLoaderCrypto::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<Resource> ResourceFormatLoaderCrypto::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
String el = p_path.get_extension().to_lower();
|
||||
if (el == "crt") {
|
||||
X509Certificate *cert = X509Certificate::create();
|
||||
|
|
@ -185,7 +185,7 @@ String ResourceFormatLoaderCrypto::get_resource_type(const String &p_path) const
|
|||
return "";
|
||||
}
|
||||
|
||||
Error ResourceFormatSaverCrypto::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
|
||||
Error ResourceFormatSaverCrypto::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
|
||||
Error err;
|
||||
Ref<X509Certificate> cert = p_resource;
|
||||
Ref<CryptoKey> key = p_resource;
|
||||
|
|
@ -201,7 +201,7 @@ Error ResourceFormatSaverCrypto::save(const String &p_path, const RES &p_resourc
|
|||
return OK;
|
||||
}
|
||||
|
||||
void ResourceFormatSaverCrypto::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
|
||||
void ResourceFormatSaverCrypto::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
|
||||
const X509Certificate *cert = Object::cast_to<X509Certificate>(*p_resource);
|
||||
const CryptoKey *key = Object::cast_to<CryptoKey>(*p_resource);
|
||||
if (cert) {
|
||||
|
|
@ -215,6 +215,6 @@ void ResourceFormatSaverCrypto::get_recognized_extensions(const RES &p_resource,
|
|||
}
|
||||
}
|
||||
|
||||
bool ResourceFormatSaverCrypto::recognize(const RES &p_resource) const {
|
||||
bool ResourceFormatSaverCrypto::recognize(const Ref<Resource> &p_resource) const {
|
||||
return Object::cast_to<X509Certificate>(*p_resource) || Object::cast_to<CryptoKey>(*p_resource);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ public:
|
|||
|
||||
class ResourceFormatLoaderCrypto : public ResourceFormatLoader {
|
||||
public:
|
||||
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual void get_recognized_extensions(List<String> *p_extensions) const;
|
||||
virtual bool handles_type(const String &p_type) const;
|
||||
virtual String get_resource_type(const String &p_path) const;
|
||||
|
|
@ -125,9 +125,9 @@ public:
|
|||
|
||||
class ResourceFormatSaverCrypto : public ResourceFormatSaver {
|
||||
public:
|
||||
virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
|
||||
virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
|
||||
virtual bool recognize(const RES &p_resource) const;
|
||||
virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
|
||||
virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const;
|
||||
virtual bool recognize(const Ref<Resource> &p_resource) const;
|
||||
};
|
||||
|
||||
#endif // CRYPTO_H
|
||||
|
|
|
|||
|
|
@ -356,7 +356,7 @@ void NativeExtension::initialize_native_extensions() {
|
|||
gdnative_interface.classdb_unregister_extension_class = _unregister_extension_class;
|
||||
}
|
||||
|
||||
RES NativeExtensionResourceLoader::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<Resource> NativeExtensionResourceLoader::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<ConfigFile> config;
|
||||
config.instantiate();
|
||||
|
||||
|
|
@ -367,14 +367,14 @@ RES NativeExtensionResourceLoader::load(const String &p_path, const String &p_or
|
|||
}
|
||||
|
||||
if (err != OK) {
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
if (!config->has_section_key("configuration", "entry_symbol")) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_INVALID_DATA;
|
||||
}
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
String entry_symbol = config->get_value("configuration", "entry_symbol");
|
||||
|
|
@ -406,7 +406,7 @@ RES NativeExtensionResourceLoader::load(const String &p_path, const String &p_or
|
|||
if (r_error) {
|
||||
*r_error = ERR_FILE_NOT_FOUND;
|
||||
}
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
if (!library_path.is_resource_file()) {
|
||||
|
|
@ -423,7 +423,7 @@ RES NativeExtensionResourceLoader::load(const String &p_path, const String &p_or
|
|||
}
|
||||
|
||||
if (err != OK) {
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
return lib;
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ VARIANT_ENUM_CAST(NativeExtension::InitializationLevel)
|
|||
|
||||
class NativeExtensionResourceLoader : public ResourceFormatLoader {
|
||||
public:
|
||||
virtual RES load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual Ref<Resource> load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual void get_recognized_extensions(List<String> *p_extensions) const;
|
||||
virtual bool handles_type(const String &p_type) const;
|
||||
virtual String get_resource_type(const String &p_path) const;
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ void (*Input::set_mouse_mode_func)(Input::MouseMode) = nullptr;
|
|||
Input::MouseMode (*Input::get_mouse_mode_func)() = nullptr;
|
||||
void (*Input::warp_mouse_func)(const Vector2 &p_position) = nullptr;
|
||||
Input::CursorShape (*Input::get_current_cursor_shape_func)() = nullptr;
|
||||
void (*Input::set_custom_mouse_cursor_func)(const RES &, Input::CursorShape, const Vector2 &) = nullptr;
|
||||
void (*Input::set_custom_mouse_cursor_func)(const Ref<Resource> &, Input::CursorShape, const Vector2 &) = nullptr;
|
||||
|
||||
Input *Input::get_singleton() {
|
||||
return singleton;
|
||||
|
|
@ -850,7 +850,7 @@ Input::CursorShape Input::get_current_cursor_shape() const {
|
|||
return get_current_cursor_shape_func();
|
||||
}
|
||||
|
||||
void Input::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
|
||||
void Input::set_custom_mouse_cursor(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
|
||||
if (Engine::get_singleton()->is_editor_hint()) {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -219,7 +219,7 @@ private:
|
|||
static void (*warp_mouse_func)(const Vector2 &p_position);
|
||||
|
||||
static CursorShape (*get_current_cursor_shape_func)();
|
||||
static void (*set_custom_mouse_cursor_func)(const RES &, CursorShape, const Vector2 &);
|
||||
static void (*set_custom_mouse_cursor_func)(const Ref<Resource> &, CursorShape, const Vector2 &);
|
||||
|
||||
EventDispatchFunc event_dispatch_function = nullptr;
|
||||
|
||||
|
|
@ -305,7 +305,7 @@ public:
|
|||
CursorShape get_default_cursor_shape() const;
|
||||
void set_default_cursor_shape(CursorShape p_shape);
|
||||
CursorShape get_current_cursor_shape() const;
|
||||
void set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape = Input::CURSOR_ARROW, const Vector2 &p_hotspot = Vector2());
|
||||
void set_custom_mouse_cursor(const Ref<Resource> &p_cursor, CursorShape p_shape = Input::CURSOR_ARROW, const Vector2 &p_hotspot = Vector2());
|
||||
|
||||
void parse_mapping(String p_mapping);
|
||||
void joy_button(int p_device, JoyButton p_button, bool p_pressed);
|
||||
|
|
|
|||
|
|
@ -111,13 +111,13 @@ void ImageLoader::cleanup() {
|
|||
|
||||
/////////////////
|
||||
|
||||
RES ResourceFormatLoaderImage::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<Resource> ResourceFormatLoaderImage::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
||||
if (f.is_null()) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_CANT_OPEN;
|
||||
}
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
uint8_t header[4] = { 0, 0, 0, 0 };
|
||||
|
|
@ -128,7 +128,7 @@ RES ResourceFormatLoaderImage::load(const String &p_path, const String &p_origin
|
|||
if (r_error) {
|
||||
*r_error = ERR_FILE_UNRECOGNIZED;
|
||||
}
|
||||
ERR_FAIL_V(RES());
|
||||
ERR_FAIL_V(Ref<Resource>());
|
||||
}
|
||||
|
||||
String extension = f->get_pascal_string();
|
||||
|
|
@ -146,7 +146,7 @@ RES ResourceFormatLoaderImage::load(const String &p_path, const String &p_origin
|
|||
if (r_error) {
|
||||
*r_error = ERR_FILE_UNRECOGNIZED;
|
||||
}
|
||||
ERR_FAIL_V(RES());
|
||||
ERR_FAIL_V(Ref<Resource>());
|
||||
}
|
||||
|
||||
Ref<Image> image;
|
||||
|
|
@ -158,7 +158,7 @@ RES ResourceFormatLoaderImage::load(const String &p_path, const String &p_origin
|
|||
if (r_error) {
|
||||
*r_error = err;
|
||||
}
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
if (r_error) {
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ public:
|
|||
|
||||
class ResourceFormatLoaderImage : public ResourceFormatLoader {
|
||||
public:
|
||||
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual void get_recognized_extensions(List<String> *p_extensions) const;
|
||||
virtual bool handles_type(const String &p_type) const;
|
||||
virtual String get_resource_type(const String &p_path) const;
|
||||
|
|
|
|||
|
|
@ -601,7 +601,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
|
|||
}
|
||||
|
||||
if (Object::cast_to<RefCounted>(obj)) {
|
||||
REF ref = REF(Object::cast_to<RefCounted>(obj));
|
||||
Ref<RefCounted> ref = Ref<RefCounted>(Object::cast_to<RefCounted>(obj));
|
||||
r_variant = ref;
|
||||
} else {
|
||||
r_variant = obj;
|
||||
|
|
|
|||
|
|
@ -208,13 +208,13 @@ Ref<Resource> Resource::duplicate_for_local_scene(Node *p_for_scene, Map<Ref<Res
|
|||
}
|
||||
Variant p = get(E.name);
|
||||
if (p.get_type() == Variant::OBJECT) {
|
||||
RES sr = p;
|
||||
Ref<Resource> sr = p;
|
||||
if (sr.is_valid()) {
|
||||
if (sr->is_local_to_scene()) {
|
||||
if (remap_cache.has(sr)) {
|
||||
p = remap_cache[sr];
|
||||
} else {
|
||||
RES dupe = sr->duplicate_for_local_scene(p_for_scene, remap_cache);
|
||||
Ref<Resource> dupe = sr->duplicate_for_local_scene(p_for_scene, remap_cache);
|
||||
p = dupe;
|
||||
remap_cache[sr] = dupe;
|
||||
}
|
||||
|
|
@ -240,7 +240,7 @@ void Resource::configure_for_local_scene(Node *p_for_scene, Map<Ref<Resource>, R
|
|||
}
|
||||
Variant p = get(E.name);
|
||||
if (p.get_type() == Variant::OBJECT) {
|
||||
RES sr = p;
|
||||
Ref<Resource> sr = p;
|
||||
if (sr.is_valid()) {
|
||||
if (sr->is_local_to_scene()) {
|
||||
if (!remap_cache.has(sr)) {
|
||||
|
|
@ -269,7 +269,7 @@ Ref<Resource> Resource::duplicate(bool p_subresources) const {
|
|||
if ((p.get_type() == Variant::DICTIONARY || p.get_type() == Variant::ARRAY)) {
|
||||
r->set(E.name, p.duplicate(p_subresources));
|
||||
} else if (p.get_type() == Variant::OBJECT && (p_subresources || (E.usage & PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE))) {
|
||||
RES sr = p;
|
||||
Ref<Resource> sr = p;
|
||||
if (sr.is_valid()) {
|
||||
r->set(E.name, sr->duplicate(p_subresources));
|
||||
}
|
||||
|
|
@ -321,7 +321,7 @@ void Resource::notify_change_to_owners() {
|
|||
Object *obj = ObjectDB::get_instance(E->get());
|
||||
ERR_CONTINUE_MSG(!obj, "Object was deleted, while still owning a resource."); //wtf
|
||||
//TODO store string
|
||||
obj->call("resource_changed", RES(this));
|
||||
obj->call("resource_changed", Ref<Resource>(this));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -335,7 +335,7 @@ uint32_t Resource::hash_edited_version() const {
|
|||
|
||||
for (const PropertyInfo &E : plist) {
|
||||
if (E.usage & PROPERTY_USAGE_STORAGE && E.type == Variant::OBJECT && E.hint == PROPERTY_HINT_RESOURCE_TYPE) {
|
||||
RES res = get(E.name);
|
||||
Ref<Resource> res = get(E.name);
|
||||
if (res.is_valid()) {
|
||||
hash = hash_djb2_one_32(res->hash_edited_version(), hash);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -150,8 +150,6 @@ public:
|
|||
~Resource();
|
||||
};
|
||||
|
||||
typedef Ref<Resource> RES;
|
||||
|
||||
class ResourceCache {
|
||||
friend class Resource;
|
||||
friend class ResourceLoader; //need the lock
|
||||
|
|
|
|||
|
|
@ -388,7 +388,7 @@ Error ResourceLoaderBinary::parse_variant(Variant &r_v) {
|
|||
path = remaps[path];
|
||||
}
|
||||
|
||||
RES res = ResourceLoader::load(path, exttype);
|
||||
Ref<Resource> res = ResourceLoader::load(path, exttype);
|
||||
|
||||
if (res.is_null()) {
|
||||
WARN_PRINT(String("Couldn't load resource: " + path).utf8().get_data());
|
||||
|
|
@ -696,7 +696,7 @@ Error ResourceLoaderBinary::load() {
|
|||
}
|
||||
|
||||
if (cache_mode == ResourceFormatLoader::CACHE_MODE_REUSE && ResourceCache::has(path)) {
|
||||
RES cached = ResourceCache::get(path);
|
||||
Ref<Resource> cached = ResourceCache::get(path);
|
||||
if (cached.is_valid()) {
|
||||
//already loaded, don't do anything
|
||||
stage++;
|
||||
|
|
@ -717,7 +717,7 @@ Error ResourceLoaderBinary::load() {
|
|||
|
||||
String t = get_unicode_string();
|
||||
|
||||
RES res;
|
||||
Ref<Resource> res;
|
||||
|
||||
if (cache_mode == ResourceFormatLoader::CACHE_MODE_REPLACE && ResourceCache::has(path)) {
|
||||
//use the existing one
|
||||
|
|
@ -745,7 +745,7 @@ Error ResourceLoaderBinary::load() {
|
|||
ERR_FAIL_V_MSG(ERR_FILE_CORRUPT, local_path + ":Resource type in resource field not a resource, type is: " + obj_class + ".");
|
||||
}
|
||||
|
||||
res = RES(r);
|
||||
res = Ref<Resource>(r);
|
||||
if (!path.is_empty() && cache_mode != ResourceFormatLoader::CACHE_MODE_IGNORE) {
|
||||
r->set_path(path, cache_mode == ResourceFormatLoader::CACHE_MODE_REPLACE); //if got here because the resource with same path has different type, replace it
|
||||
}
|
||||
|
|
@ -1026,7 +1026,7 @@ String ResourceLoaderBinary::recognize(Ref<FileAccess> p_f) {
|
|||
return type;
|
||||
}
|
||||
|
||||
RES ResourceFormatLoaderBinary::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<Resource> ResourceFormatLoaderBinary::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_FILE_CANT_OPEN;
|
||||
}
|
||||
|
|
@ -1034,7 +1034,7 @@ RES ResourceFormatLoaderBinary::load(const String &p_path, const String &p_origi
|
|||
Error err;
|
||||
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ, &err);
|
||||
|
||||
ERR_FAIL_COND_V_MSG(err != OK, RES(), "Cannot open file '" + p_path + "'.");
|
||||
ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot open file '" + p_path + "'.");
|
||||
|
||||
ResourceLoaderBinary loader;
|
||||
loader.cache_mode = p_cache_mode;
|
||||
|
|
@ -1052,7 +1052,7 @@ RES ResourceFormatLoaderBinary::load(const String &p_path, const String &p_origi
|
|||
}
|
||||
|
||||
if (err) {
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
return loader.resource;
|
||||
}
|
||||
|
|
@ -1178,7 +1178,7 @@ Error ResourceFormatLoaderBinary::rename_dependencies(const String &p_path, cons
|
|||
err = loader.load();
|
||||
|
||||
ERR_FAIL_COND_V(err != ERR_FILE_EOF, ERR_FILE_CORRUPT);
|
||||
RES res = loader.get_resource();
|
||||
Ref<Resource> res = loader.get_resource();
|
||||
ERR_FAIL_COND_V(!res.is_valid(), ERR_FILE_CORRUPT);
|
||||
|
||||
return ResourceFormatSaverBinary::singleton->save(p_path, res);
|
||||
|
|
@ -1353,7 +1353,7 @@ void ResourceFormatSaverBinaryInstance::_pad_buffer(Ref<FileAccess> f, int p_byt
|
|||
}
|
||||
}
|
||||
|
||||
void ResourceFormatSaverBinaryInstance::write_variant(Ref<FileAccess> f, const Variant &p_property, Map<RES, int> &resource_map, Map<RES, int> &external_resources, Map<StringName, int> &string_map, const PropertyInfo &p_hint) {
|
||||
void ResourceFormatSaverBinaryInstance::write_variant(Ref<FileAccess> f, const Variant &p_property, Map<Ref<Resource>, int> &resource_map, Map<Ref<Resource>, int> &external_resources, Map<StringName, int> &string_map, const PropertyInfo &p_hint) {
|
||||
switch (p_property.get_type()) {
|
||||
case Variant::NIL: {
|
||||
f->store_32(VARIANT_NIL);
|
||||
|
|
@ -1562,7 +1562,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(Ref<FileAccess> f, const V
|
|||
} break;
|
||||
case Variant::OBJECT: {
|
||||
f->store_32(VARIANT_OBJECT);
|
||||
RES res = p_property;
|
||||
Ref<Resource> res = p_property;
|
||||
if (res.is_null()) {
|
||||
f->store_32(OBJECT_EMPTY);
|
||||
return; // don't save it
|
||||
|
|
@ -1728,7 +1728,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(Ref<FileAccess> f, const V
|
|||
void ResourceFormatSaverBinaryInstance::_find_resources(const Variant &p_variant, bool p_main) {
|
||||
switch (p_variant.get_type()) {
|
||||
case Variant::OBJECT: {
|
||||
RES res = p_variant;
|
||||
Ref<Resource> res = p_variant;
|
||||
|
||||
if (res.is_null() || external_resources.has(res)) {
|
||||
return;
|
||||
|
|
@ -1756,7 +1756,7 @@ void ResourceFormatSaverBinaryInstance::_find_resources(const Variant &p_variant
|
|||
if (E.usage & PROPERTY_USAGE_STORAGE) {
|
||||
Variant value = res->get(E.name);
|
||||
if (E.usage & PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT) {
|
||||
RES sres = value;
|
||||
Ref<Resource> sres = value;
|
||||
if (sres.is_valid()) {
|
||||
NonPersistentKey npk;
|
||||
npk.base = res;
|
||||
|
|
@ -1833,7 +1833,7 @@ int ResourceFormatSaverBinaryInstance::get_string_index(const String &p_string)
|
|||
return strings.size() - 1;
|
||||
}
|
||||
|
||||
Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
|
||||
Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
|
||||
Error err;
|
||||
Ref<FileAccess> f;
|
||||
if (p_flags & ResourceSaver::FLAG_COMPRESS) {
|
||||
|
|
@ -1903,7 +1903,7 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const RES &p
|
|||
List<ResourceData> resources;
|
||||
|
||||
{
|
||||
for (const RES &E : saved_resources) {
|
||||
for (const Ref<Resource> &E : saved_resources) {
|
||||
ResourceData &rd = resources.push_back(ResourceData())->get();
|
||||
rd.type = E->get_class();
|
||||
|
||||
|
|
@ -1950,10 +1950,10 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const RES &p
|
|||
|
||||
// save external resource table
|
||||
f->store_32(external_resources.size()); //amount of external resources
|
||||
Vector<RES> save_order;
|
||||
Vector<Ref<Resource>> save_order;
|
||||
save_order.resize(external_resources.size());
|
||||
|
||||
for (const KeyValue<RES, int> &E : external_resources) {
|
||||
for (const KeyValue<Ref<Resource>, int> &E : external_resources) {
|
||||
save_order.write[E.value] = E.key;
|
||||
}
|
||||
|
||||
|
|
@ -1970,7 +1970,7 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const RES &p
|
|||
Vector<uint64_t> ofs_pos;
|
||||
Set<String> used_unique_ids;
|
||||
|
||||
for (RES &r : saved_resources) {
|
||||
for (Ref<Resource> &r : saved_resources) {
|
||||
if (r->is_built_in()) {
|
||||
if (!r->get_scene_unique_id().is_empty()) {
|
||||
if (used_unique_ids.has(r->get_scene_unique_id())) {
|
||||
|
|
@ -1982,9 +1982,9 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const RES &p
|
|||
}
|
||||
}
|
||||
|
||||
Map<RES, int> resource_map;
|
||||
Map<Ref<Resource>, int> resource_map;
|
||||
int res_index = 0;
|
||||
for (RES &r : saved_resources) {
|
||||
for (Ref<Resource> &r : saved_resources) {
|
||||
if (r->is_built_in()) {
|
||||
if (r->get_scene_unique_id().is_empty()) {
|
||||
String new_id;
|
||||
|
|
@ -2045,17 +2045,17 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const RES &p
|
|||
return OK;
|
||||
}
|
||||
|
||||
Error ResourceFormatSaverBinary::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
|
||||
Error ResourceFormatSaverBinary::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
|
||||
String local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
||||
ResourceFormatSaverBinaryInstance saver;
|
||||
return saver.save(local_path, p_resource, p_flags);
|
||||
}
|
||||
|
||||
bool ResourceFormatSaverBinary::recognize(const RES &p_resource) const {
|
||||
bool ResourceFormatSaverBinary::recognize(const Ref<Resource> &p_resource) const {
|
||||
return true; //all recognized
|
||||
}
|
||||
|
||||
void ResourceFormatSaverBinary::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
|
||||
void ResourceFormatSaverBinary::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
|
||||
String base = p_resource->get_base_extension().to_lower();
|
||||
p_extensions->push_back(base);
|
||||
if (base != "res") {
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ class ResourceLoaderBinary {
|
|||
ResourceUID::ID uid = ResourceUID::INVALID_ID;
|
||||
|
||||
Vector<char> str_buf;
|
||||
List<RES> resource_cache;
|
||||
List<Ref<Resource>> resource_cache;
|
||||
|
||||
Vector<StringName> string_map;
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ class ResourceLoaderBinary {
|
|||
String path;
|
||||
String type;
|
||||
ResourceUID::ID uid = ResourceUID::INVALID_ID;
|
||||
RES cache;
|
||||
Ref<Resource> cache;
|
||||
};
|
||||
|
||||
bool using_named_scene_ids = false;
|
||||
|
|
@ -75,7 +75,7 @@ class ResourceLoaderBinary {
|
|||
};
|
||||
|
||||
Vector<IntResource> internal_resources;
|
||||
Map<String, RES> internal_index_cache;
|
||||
Map<String, Ref<Resource>> internal_index_cache;
|
||||
|
||||
String get_unicode_string();
|
||||
void _advance_padding(uint32_t p_len);
|
||||
|
|
@ -89,7 +89,7 @@ class ResourceLoaderBinary {
|
|||
|
||||
Error parse_variant(Variant &r_v);
|
||||
|
||||
Map<String, RES> dependency_cache;
|
||||
Map<String, Ref<Resource>> dependency_cache;
|
||||
|
||||
public:
|
||||
void set_local_path(const String &p_local_path);
|
||||
|
|
@ -107,7 +107,7 @@ public:
|
|||
|
||||
class ResourceFormatLoaderBinary : public ResourceFormatLoader {
|
||||
public:
|
||||
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
|
||||
virtual void get_recognized_extensions(List<String> *p_extensions) const;
|
||||
virtual bool handles_type(const String &p_type) const;
|
||||
|
|
@ -127,20 +127,20 @@ class ResourceFormatSaverBinaryInstance {
|
|||
bool big_endian;
|
||||
bool takeover_paths;
|
||||
String magic;
|
||||
Set<RES> resource_set;
|
||||
Set<Ref<Resource>> resource_set;
|
||||
|
||||
struct NonPersistentKey { //for resource properties generated on the fly
|
||||
RES base;
|
||||
Ref<Resource> base;
|
||||
StringName property;
|
||||
bool operator<(const NonPersistentKey &p_key) const { return base == p_key.base ? property < p_key.property : base < p_key.base; }
|
||||
};
|
||||
|
||||
Map<NonPersistentKey, RES> non_persistent_map;
|
||||
Map<NonPersistentKey, Ref<Resource>> non_persistent_map;
|
||||
Map<StringName, int> string_map;
|
||||
Vector<StringName> strings;
|
||||
|
||||
Map<RES, int> external_resources;
|
||||
List<RES> saved_resources;
|
||||
Map<Ref<Resource>, int> external_resources;
|
||||
List<Ref<Resource>> saved_resources;
|
||||
|
||||
struct Property {
|
||||
int name_idx;
|
||||
|
|
@ -167,16 +167,16 @@ public:
|
|||
// Amount of reserved 32-bit fields in resource header
|
||||
RESERVED_FIELDS = 11
|
||||
};
|
||||
Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
|
||||
static void write_variant(Ref<FileAccess> f, const Variant &p_property, Map<RES, int> &resource_map, Map<RES, int> &external_resources, Map<StringName, int> &string_map, const PropertyInfo &p_hint = PropertyInfo());
|
||||
Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
|
||||
static void write_variant(Ref<FileAccess> f, const Variant &p_property, Map<Ref<Resource>, int> &resource_map, Map<Ref<Resource>, int> &external_resources, Map<StringName, int> &string_map, const PropertyInfo &p_hint = PropertyInfo());
|
||||
};
|
||||
|
||||
class ResourceFormatSaverBinary : public ResourceFormatSaver {
|
||||
public:
|
||||
static ResourceFormatSaverBinary *singleton;
|
||||
virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
|
||||
virtual bool recognize(const RES &p_resource) const;
|
||||
virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
|
||||
virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
|
||||
virtual bool recognize(const Ref<Resource> &p_resource) const;
|
||||
virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const;
|
||||
|
||||
ResourceFormatSaverBinary();
|
||||
};
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ Error ResourceFormatImporter::_get_path_and_type(const String &p_path, PathAndTy
|
|||
return OK;
|
||||
}
|
||||
|
||||
RES ResourceFormatImporter::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<Resource> ResourceFormatImporter::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
PathAndType pat;
|
||||
Error err = _get_path_and_type(p_path, pat);
|
||||
|
||||
|
|
@ -123,10 +123,10 @@ RES ResourceFormatImporter::load(const String &p_path, const String &p_original_
|
|||
*r_error = err;
|
||||
}
|
||||
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
RES res = ResourceLoader::_load(pat.path, p_path, pat.type, p_cache_mode, r_error, p_use_sub_threads, r_progress);
|
||||
Ref<Resource> res = ResourceLoader::_load(pat.path, p_path, pat.type, p_cache_mode, r_error, p_use_sub_threads, r_progress);
|
||||
|
||||
#ifdef TOOLS_ENABLED
|
||||
if (res.is_valid()) {
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ class ResourceFormatImporter : public ResourceFormatLoader {
|
|||
|
||||
public:
|
||||
static ResourceFormatImporter *get_singleton() { return singleton; }
|
||||
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual void get_recognized_extensions(List<String> *p_extensions) const;
|
||||
virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
|
||||
virtual bool recognize_path(const String &p_path, const String &p_for_type = String()) const;
|
||||
|
|
|
|||
|
|
@ -125,14 +125,14 @@ void ResourceFormatLoader::get_recognized_extensions(List<String> *p_extensions)
|
|||
}
|
||||
}
|
||||
|
||||
RES ResourceFormatLoader::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<Resource> ResourceFormatLoader::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Variant res;
|
||||
if (GDVIRTUAL_CALL(_load, p_path, p_original_path, p_use_sub_threads, p_cache_mode, res)) {
|
||||
if (res.get_type() == Variant::INT) { // Error code, abort.
|
||||
if (r_error) {
|
||||
*r_error = (Error)res.operator int64_t();
|
||||
}
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
} else { // Success, pass on result.
|
||||
if (r_error) {
|
||||
*r_error = OK;
|
||||
|
|
@ -141,7 +141,7 @@ RES ResourceFormatLoader::load(const String &p_path, const String &p_original_pa
|
|||
}
|
||||
}
|
||||
|
||||
ERR_FAIL_V_MSG(RES(), "Failed to load resource '" + p_path + "'. ResourceFormatLoader::load was not implemented for this resource type.");
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), "Failed to load resource '" + p_path + "'. ResourceFormatLoader::load was not implemented for this resource type.");
|
||||
}
|
||||
|
||||
void ResourceFormatLoader::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
|
||||
|
|
@ -185,7 +185,7 @@ void ResourceFormatLoader::_bind_methods() {
|
|||
|
||||
///////////////////////////////////
|
||||
|
||||
RES ResourceLoader::_load(const String &p_path, const String &p_original_path, const String &p_type_hint, ResourceFormatLoader::CacheMode p_cache_mode, Error *r_error, bool p_use_sub_threads, float *r_progress) {
|
||||
Ref<Resource> ResourceLoader::_load(const String &p_path, const String &p_original_path, const String &p_type_hint, ResourceFormatLoader::CacheMode p_cache_mode, Error *r_error, bool p_use_sub_threads, float *r_progress) {
|
||||
bool found = false;
|
||||
|
||||
// Try all loaders and pick the first match for the type hint
|
||||
|
|
@ -194,7 +194,7 @@ RES ResourceLoader::_load(const String &p_path, const String &p_original_path, c
|
|||
continue;
|
||||
}
|
||||
found = true;
|
||||
RES res = loader[i]->load(p_path, !p_original_path.is_empty() ? p_original_path : p_path, r_error, p_use_sub_threads, r_progress, p_cache_mode);
|
||||
Ref<Resource> res = loader[i]->load(p_path, !p_original_path.is_empty() ? p_original_path : p_path, r_error, p_use_sub_threads, r_progress, p_cache_mode);
|
||||
if (res.is_null()) {
|
||||
continue;
|
||||
}
|
||||
|
|
@ -202,15 +202,15 @@ RES ResourceLoader::_load(const String &p_path, const String &p_original_path, c
|
|||
return res;
|
||||
}
|
||||
|
||||
ERR_FAIL_COND_V_MSG(found, RES(),
|
||||
ERR_FAIL_COND_V_MSG(found, Ref<Resource>(),
|
||||
vformat("Failed loading resource: %s. Make sure resources have been imported by opening the project in the editor at least once.", p_path));
|
||||
|
||||
#ifdef TOOLS_ENABLED
|
||||
Ref<FileAccess> file_check = FileAccess::create(FileAccess::ACCESS_RESOURCES);
|
||||
ERR_FAIL_COND_V_MSG(!file_check->file_exists(p_path), RES(), "Resource file not found: " + p_path + ".");
|
||||
ERR_FAIL_COND_V_MSG(!file_check->file_exists(p_path), Ref<Resource>(), "Resource file not found: " + p_path + ".");
|
||||
#endif
|
||||
|
||||
ERR_FAIL_V_MSG(RES(), "No loader found for resource: " + p_path + ".");
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), "No loader found for resource: " + p_path + ".");
|
||||
}
|
||||
|
||||
void ResourceLoader::_thread_load_function(void *p_userdata) {
|
||||
|
|
@ -342,7 +342,7 @@ Error ResourceLoader::load_threaded_request(const String &p_path, const String &
|
|||
Resource **rptr = ResourceCache::resources.getptr(local_path);
|
||||
|
||||
if (rptr) {
|
||||
RES res(*rptr);
|
||||
Ref<Resource> res(*rptr);
|
||||
//it is possible this resource was just freed in a thread. If so, this referencing will not work and resource is considered not cached
|
||||
if (res.is_valid()) {
|
||||
//referencing is fine
|
||||
|
|
@ -427,7 +427,7 @@ ResourceLoader::ThreadLoadStatus ResourceLoader::load_threaded_get_status(const
|
|||
return status;
|
||||
}
|
||||
|
||||
RES ResourceLoader::load_threaded_get(const String &p_path, Error *r_error) {
|
||||
Ref<Resource> ResourceLoader::load_threaded_get(const String &p_path, Error *r_error) {
|
||||
String local_path = _validate_local_path(p_path);
|
||||
|
||||
thread_load_mutex->lock();
|
||||
|
|
@ -436,7 +436,7 @@ RES ResourceLoader::load_threaded_get(const String &p_path, Error *r_error) {
|
|||
if (r_error) {
|
||||
*r_error = ERR_INVALID_PARAMETER;
|
||||
}
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
ThreadLoadTask &load_task = thread_load_tasks[local_path];
|
||||
|
|
@ -480,11 +480,11 @@ RES ResourceLoader::load_threaded_get(const String &p_path, Error *r_error) {
|
|||
if (r_error) {
|
||||
*r_error = ERR_INVALID_PARAMETER;
|
||||
}
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
}
|
||||
|
||||
RES resource = load_task.resource;
|
||||
Ref<Resource> resource = load_task.resource;
|
||||
if (r_error) {
|
||||
*r_error = load_task.error;
|
||||
}
|
||||
|
|
@ -504,7 +504,7 @@ RES ResourceLoader::load_threaded_get(const String &p_path, Error *r_error) {
|
|||
return resource;
|
||||
}
|
||||
|
||||
RES ResourceLoader::load(const String &p_path, const String &p_type_hint, ResourceFormatLoader::CacheMode p_cache_mode, Error *r_error) {
|
||||
Ref<Resource> ResourceLoader::load(const String &p_path, const String &p_type_hint, ResourceFormatLoader::CacheMode p_cache_mode, Error *r_error) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_CANT_OPEN;
|
||||
}
|
||||
|
|
@ -522,7 +522,7 @@ RES ResourceLoader::load(const String &p_path, const String &p_type_hint, Resour
|
|||
*r_error = err;
|
||||
}
|
||||
thread_load_mutex->unlock();
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
thread_load_mutex->unlock();
|
||||
|
||||
|
|
@ -535,7 +535,7 @@ RES ResourceLoader::load(const String &p_path, const String &p_type_hint, Resour
|
|||
Resource **rptr = ResourceCache::resources.getptr(local_path);
|
||||
|
||||
if (rptr) {
|
||||
RES res(*rptr);
|
||||
Ref<Resource> res(*rptr);
|
||||
|
||||
//it is possible this resource was just freed in a thread. If so, this referencing will not work and resource is considered not cached
|
||||
if (res.is_valid()) {
|
||||
|
|
@ -575,16 +575,16 @@ RES ResourceLoader::load(const String &p_path, const String &p_type_hint, Resour
|
|||
String path = _path_remap(local_path, &xl_remapped);
|
||||
|
||||
if (path.is_empty()) {
|
||||
ERR_FAIL_V_MSG(RES(), "Remapping '" + local_path + "' failed.");
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), "Remapping '" + local_path + "' failed.");
|
||||
}
|
||||
|
||||
print_verbose("Loading resource: " + path);
|
||||
float p;
|
||||
RES res = _load(path, local_path, p_type_hint, p_cache_mode, r_error, false, &p);
|
||||
Ref<Resource> res = _load(path, local_path, p_type_hint, p_cache_mode, r_error, false, &p);
|
||||
|
||||
if (res.is_null()) {
|
||||
print_verbose("Failed loading resource: " + path);
|
||||
return RES();
|
||||
return Ref<Resource>();
|
||||
}
|
||||
|
||||
if (xl_remapped) {
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ protected:
|
|||
GDVIRTUAL4RC(Variant, _load, String, String, bool, int)
|
||||
|
||||
public:
|
||||
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual bool exists(const String &p_path) const;
|
||||
virtual void get_recognized_extensions(List<String> *p_extensions) const;
|
||||
virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
|
||||
|
|
@ -85,7 +85,7 @@ typedef void (*ResourceLoadErrorNotify)(void *p_ud, const String &p_text);
|
|||
typedef void (*DependencyErrorNotify)(void *p_ud, const String &p_loading, const String &p_which, const String &p_type);
|
||||
|
||||
typedef Error (*ResourceLoaderImport)(const String &p_path);
|
||||
typedef void (*ResourceLoadedCallback)(RES p_resource, const String &p_path);
|
||||
typedef void (*ResourceLoadedCallback)(Ref<Resource> p_resource, const String &p_path);
|
||||
|
||||
class ResourceLoader {
|
||||
enum {
|
||||
|
|
@ -121,7 +121,7 @@ private:
|
|||
friend class ResourceFormatImporter;
|
||||
friend class ResourceInteractiveLoader;
|
||||
// Internal load function.
|
||||
static RES _load(const String &p_path, const String &p_original_path, const String &p_type_hint, ResourceFormatLoader::CacheMode p_cache_mode, Error *r_error, bool p_use_sub_threads, float *r_progress);
|
||||
static Ref<Resource> _load(const String &p_path, const String &p_original_path, const String &p_type_hint, ResourceFormatLoader::CacheMode p_cache_mode, Error *r_error, bool p_use_sub_threads, float *r_progress);
|
||||
|
||||
static ResourceLoadedCallback _loaded_callback;
|
||||
|
||||
|
|
@ -138,7 +138,7 @@ private:
|
|||
ThreadLoadStatus status = THREAD_LOAD_IN_PROGRESS;
|
||||
ResourceFormatLoader::CacheMode cache_mode = ResourceFormatLoader::CACHE_MODE_REUSE;
|
||||
Error error = OK;
|
||||
RES resource;
|
||||
Ref<Resource> resource;
|
||||
bool xl_remapped = false;
|
||||
bool use_sub_threads = false;
|
||||
bool start_next = true;
|
||||
|
|
@ -161,9 +161,9 @@ private:
|
|||
public:
|
||||
static Error load_threaded_request(const String &p_path, const String &p_type_hint = "", bool p_use_sub_threads = false, ResourceFormatLoader::CacheMode p_cache_mode = ResourceFormatLoader::CACHE_MODE_REUSE, const String &p_source_resource = String());
|
||||
static ThreadLoadStatus load_threaded_get_status(const String &p_path, float *r_progress = nullptr);
|
||||
static RES load_threaded_get(const String &p_path, Error *r_error = nullptr);
|
||||
static Ref<Resource> load_threaded_get(const String &p_path, Error *r_error = nullptr);
|
||||
|
||||
static RES load(const String &p_path, const String &p_type_hint = "", ResourceFormatLoader::CacheMode p_cache_mode = ResourceFormatLoader::CACHE_MODE_REUSE, Error *r_error = nullptr);
|
||||
static Ref<Resource> load(const String &p_path, const String &p_type_hint = "", ResourceFormatLoader::CacheMode p_cache_mode = ResourceFormatLoader::CACHE_MODE_REUSE, Error *r_error = nullptr);
|
||||
static bool exists(const String &p_path, const String &p_type_hint = "");
|
||||
|
||||
static void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions);
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ bool ResourceSaver::timestamp_on_save = false;
|
|||
ResourceSavedCallback ResourceSaver::save_callback = nullptr;
|
||||
ResourceSaverGetResourceIDForPath ResourceSaver::save_get_id_for_path = nullptr;
|
||||
|
||||
Error ResourceFormatSaver::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
|
||||
Error ResourceFormatSaver::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
|
||||
int64_t res;
|
||||
if (GDVIRTUAL_CALL(_save, p_path, p_resource, p_flags, res)) {
|
||||
return (Error)res;
|
||||
|
|
@ -50,7 +50,7 @@ Error ResourceFormatSaver::save(const String &p_path, const RES &p_resource, uin
|
|||
return ERR_METHOD_NOT_FOUND;
|
||||
}
|
||||
|
||||
bool ResourceFormatSaver::recognize(const RES &p_resource) const {
|
||||
bool ResourceFormatSaver::recognize(const Ref<Resource> &p_resource) const {
|
||||
bool success;
|
||||
if (GDVIRTUAL_CALL(_recognize, p_resource, success)) {
|
||||
return success;
|
||||
|
|
@ -59,7 +59,7 @@ bool ResourceFormatSaver::recognize(const RES &p_resource) const {
|
|||
return false;
|
||||
}
|
||||
|
||||
void ResourceFormatSaver::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
|
||||
void ResourceFormatSaver::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
|
||||
PackedStringArray exts;
|
||||
if (GDVIRTUAL_CALL(_get_recognized_extensions, p_resource, exts)) {
|
||||
const String *r = exts.ptr();
|
||||
|
|
@ -75,7 +75,7 @@ void ResourceFormatSaver::_bind_methods() {
|
|||
GDVIRTUAL_BIND(_get_recognized_extensions, "resource");
|
||||
}
|
||||
|
||||
Error ResourceSaver::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
|
||||
Error ResourceSaver::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
|
||||
String extension = p_path.get_extension();
|
||||
Error err = ERR_FILE_UNRECOGNIZED;
|
||||
|
||||
|
|
@ -102,7 +102,7 @@ Error ResourceSaver::save(const String &p_path, const RES &p_resource, uint32_t
|
|||
|
||||
String local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
||||
|
||||
RES rwcopy = p_resource;
|
||||
Ref<Resource> rwcopy = p_resource;
|
||||
if (p_flags & FLAG_CHANGE_PATH) {
|
||||
rwcopy->set_path(local_path);
|
||||
}
|
||||
|
|
@ -139,7 +139,7 @@ void ResourceSaver::set_save_callback(ResourceSavedCallback p_callback) {
|
|||
save_callback = p_callback;
|
||||
}
|
||||
|
||||
void ResourceSaver::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) {
|
||||
void ResourceSaver::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) {
|
||||
for (int i = 0; i < saver_count; i++) {
|
||||
saver[i]->get_recognized_extensions(p_resource, p_extensions);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,14 +41,14 @@ class ResourceFormatSaver : public RefCounted {
|
|||
protected:
|
||||
static void _bind_methods();
|
||||
|
||||
GDVIRTUAL3R(int64_t, _save, String, RES, uint32_t)
|
||||
GDVIRTUAL1RC(bool, _recognize, RES)
|
||||
GDVIRTUAL1RC(Vector<String>, _get_recognized_extensions, RES)
|
||||
GDVIRTUAL3R(int64_t, _save, String, Ref<Resource>, uint32_t)
|
||||
GDVIRTUAL1RC(bool, _recognize, Ref<Resource>)
|
||||
GDVIRTUAL1RC(Vector<String>, _get_recognized_extensions, Ref<Resource>)
|
||||
|
||||
public:
|
||||
virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
|
||||
virtual bool recognize(const RES &p_resource) const;
|
||||
virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
|
||||
virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
|
||||
virtual bool recognize(const Ref<Resource> &p_resource) const;
|
||||
virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const;
|
||||
|
||||
virtual ~ResourceFormatSaver() {}
|
||||
};
|
||||
|
|
@ -81,8 +81,8 @@ public:
|
|||
FLAG_REPLACE_SUBRESOURCE_PATHS = 64,
|
||||
};
|
||||
|
||||
static Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = (uint32_t)FLAG_NONE);
|
||||
static void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions);
|
||||
static Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = (uint32_t)FLAG_NONE);
|
||||
static void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions);
|
||||
static void add_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver, bool p_at_front = false);
|
||||
static void remove_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver);
|
||||
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@
|
|||
#include "core/string/translation.h"
|
||||
#include "core/string/translation_po.h"
|
||||
|
||||
RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
||||
Ref<Resource> TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_FILE_CORRUPT;
|
||||
}
|
||||
|
|
@ -49,7 +49,7 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
|
||||
uint16_t version_maj = f->get_16();
|
||||
uint16_t version_min = f->get_16();
|
||||
ERR_FAIL_COND_V_MSG(version_maj > 1, RES(), vformat("Unsupported MO file %s, version %d.%d.", path, version_maj, version_min));
|
||||
ERR_FAIL_COND_V_MSG(version_maj > 1, Ref<Resource>(), vformat("Unsupported MO file %s, version %d.%d.", path, version_maj, version_min));
|
||||
|
||||
uint32_t num_strings = f->get_32();
|
||||
uint32_t id_table_offset = f->get_32();
|
||||
|
|
@ -170,14 +170,14 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
// If we reached last line and it's not a content line, break, otherwise let processing that last loop
|
||||
if (is_eof && l.is_empty()) {
|
||||
if (status == STATUS_READING_ID || status == STATUS_READING_CONTEXT || (status == STATUS_READING_PLURAL && plural_index != plural_forms - 1)) {
|
||||
ERR_FAIL_V_MSG(RES(), "Unexpected EOF while reading PO file at: " + path + ":" + itos(line));
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), "Unexpected EOF while reading PO file at: " + path + ":" + itos(line));
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (l.begins_with("msgctxt")) {
|
||||
ERR_FAIL_COND_V_MSG(status != STATUS_READING_STRING && status != STATUS_READING_PLURAL, RES(), "Unexpected 'msgctxt', was expecting 'msgid_plural' or 'msgstr' before 'msgctxt' while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(status != STATUS_READING_STRING && status != STATUS_READING_PLURAL, Ref<Resource>(), "Unexpected 'msgctxt', was expecting 'msgid_plural' or 'msgstr' before 'msgctxt' while parsing: " + path + ":" + itos(line));
|
||||
|
||||
// In PO file, "msgctxt" appears before "msgid". If we encounter a "msgctxt", we add what we have read
|
||||
// and set "entered_context" to true to prevent adding twice.
|
||||
|
|
@ -185,7 +185,7 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
if (status == STATUS_READING_STRING) {
|
||||
translation->add_message(msg_id, msg_str, msg_context);
|
||||
} else if (status == STATUS_READING_PLURAL) {
|
||||
ERR_FAIL_COND_V_MSG(plural_index != plural_forms - 1, RES(), "Number of 'msgstr[]' doesn't match with number of plural forms: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(plural_index != plural_forms - 1, Ref<Resource>(), "Number of 'msgstr[]' doesn't match with number of plural forms: " + path + ":" + itos(line));
|
||||
translation->add_plural_message(msg_id, msgs_plural, msg_context);
|
||||
}
|
||||
}
|
||||
|
|
@ -197,9 +197,9 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
|
||||
if (l.begins_with("msgid_plural")) {
|
||||
if (plural_forms == 0) {
|
||||
ERR_FAIL_V_MSG(RES(), "PO file uses 'msgid_plural' but 'Plural-Forms' is invalid or missing in header: " + path + ":" + itos(line));
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), "PO file uses 'msgid_plural' but 'Plural-Forms' is invalid or missing in header: " + path + ":" + itos(line));
|
||||
} else if (status != STATUS_READING_ID) {
|
||||
ERR_FAIL_V_MSG(RES(), "Unexpected 'msgid_plural', was expecting 'msgid' before 'msgid_plural' while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_V_MSG(Ref<Resource>(), "Unexpected 'msgid_plural', was expecting 'msgid' before 'msgid_plural' while parsing: " + path + ":" + itos(line));
|
||||
}
|
||||
// We don't record the message in "msgid_plural" itself as tr_n(), TTRN(), RTRN() interfaces provide the plural string already.
|
||||
// We just have to reset variables related to plurals for "msgstr[]" later on.
|
||||
|
|
@ -209,14 +209,14 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
msgs_plural.resize(plural_forms);
|
||||
status = STATUS_READING_PLURAL;
|
||||
} else if (l.begins_with("msgid")) {
|
||||
ERR_FAIL_COND_V_MSG(status == STATUS_READING_ID, RES(), "Unexpected 'msgid', was expecting 'msgstr' while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(status == STATUS_READING_ID, Ref<Resource>(), "Unexpected 'msgid', was expecting 'msgstr' while parsing: " + path + ":" + itos(line));
|
||||
|
||||
if (!msg_id.is_empty()) {
|
||||
if (!skip_this && !entered_context) {
|
||||
if (status == STATUS_READING_STRING) {
|
||||
translation->add_message(msg_id, msg_str, msg_context);
|
||||
} else if (status == STATUS_READING_PLURAL) {
|
||||
ERR_FAIL_COND_V_MSG(plural_index != plural_forms - 1, RES(), "Number of 'msgstr[]' doesn't match with number of plural forms: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(plural_index != plural_forms - 1, Ref<Resource>(), "Number of 'msgstr[]' doesn't match with number of plural forms: " + path + ":" + itos(line));
|
||||
translation->add_plural_message(msg_id, msgs_plural, msg_context);
|
||||
}
|
||||
}
|
||||
|
|
@ -245,11 +245,11 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
}
|
||||
|
||||
if (l.begins_with("msgstr[")) {
|
||||
ERR_FAIL_COND_V_MSG(status != STATUS_READING_PLURAL, RES(), "Unexpected 'msgstr[]', was expecting 'msgid_plural' before 'msgstr[]' while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(status != STATUS_READING_PLURAL, Ref<Resource>(), "Unexpected 'msgstr[]', was expecting 'msgid_plural' before 'msgstr[]' while parsing: " + path + ":" + itos(line));
|
||||
plural_index++; // Increment to add to the next slot in vector msgs_plural.
|
||||
l = l.substr(9, l.length()).strip_edges();
|
||||
} else if (l.begins_with("msgstr")) {
|
||||
ERR_FAIL_COND_V_MSG(status != STATUS_READING_ID, RES(), "Unexpected 'msgstr', was expecting 'msgid' before 'msgstr' while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(status != STATUS_READING_ID, Ref<Resource>(), "Unexpected 'msgstr', was expecting 'msgid' before 'msgstr' while parsing: " + path + ":" + itos(line));
|
||||
l = l.substr(6, l.length()).strip_edges();
|
||||
status = STATUS_READING_STRING;
|
||||
}
|
||||
|
|
@ -262,7 +262,7 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
continue; // Nothing to read or comment.
|
||||
}
|
||||
|
||||
ERR_FAIL_COND_V_MSG(!l.begins_with("\"") || status == STATUS_NONE, RES(), "Invalid line '" + l + "' while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(!l.begins_with("\"") || status == STATUS_NONE, Ref<Resource>(), "Invalid line '" + l + "' while parsing: " + path + ":" + itos(line));
|
||||
|
||||
l = l.substr(1, l.length());
|
||||
// Find final quote, ignoring escaped ones (\").
|
||||
|
|
@ -284,7 +284,7 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
escape_next = false;
|
||||
}
|
||||
|
||||
ERR_FAIL_COND_V_MSG(end_pos == -1, RES(), "Expected '\"' at end of message while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(end_pos == -1, Ref<Resource>(), "Expected '\"' at end of message while parsing: " + path + ":" + itos(line));
|
||||
|
||||
l = l.substr(0, end_pos);
|
||||
l = l.c_unescape();
|
||||
|
|
@ -296,7 +296,7 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
} else if (status == STATUS_READING_CONTEXT) {
|
||||
msg_context += l;
|
||||
} else if (status == STATUS_READING_PLURAL && plural_index >= 0) {
|
||||
ERR_FAIL_COND_V_MSG(plural_index >= plural_forms, RES(), "Unexpected plural form while parsing: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(plural_index >= plural_forms, Ref<Resource>(), "Unexpected plural form while parsing: " + path + ":" + itos(line));
|
||||
msgs_plural.write[plural_index] = msgs_plural[plural_index] + l;
|
||||
}
|
||||
|
||||
|
|
@ -314,13 +314,13 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
}
|
||||
} else if (status == STATUS_READING_PLURAL) {
|
||||
if (!skip_this && !msg_id.is_empty()) {
|
||||
ERR_FAIL_COND_V_MSG(plural_index != plural_forms - 1, RES(), "Number of 'msgstr[]' doesn't match with number of plural forms: " + path + ":" + itos(line));
|
||||
ERR_FAIL_COND_V_MSG(plural_index != plural_forms - 1, Ref<Resource>(), "Number of 'msgstr[]' doesn't match with number of plural forms: " + path + ":" + itos(line));
|
||||
translation->add_plural_message(msg_id, msgs_plural, msg_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ERR_FAIL_COND_V_MSG(config.is_empty(), RES(), "No config found in file: " + path + ".");
|
||||
ERR_FAIL_COND_V_MSG(config.is_empty(), Ref<Resource>(), "No config found in file: " + path + ".");
|
||||
|
||||
Vector<String> configs = config.split("\n");
|
||||
for (int i = 0; i < configs.size(); i++) {
|
||||
|
|
@ -344,13 +344,13 @@ RES TranslationLoaderPO::load_translation(Ref<FileAccess> f, Error *r_error) {
|
|||
return translation;
|
||||
}
|
||||
|
||||
RES TranslationLoaderPO::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
Ref<Resource> TranslationLoaderPO::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
|
||||
if (r_error) {
|
||||
*r_error = ERR_CANT_OPEN;
|
||||
}
|
||||
|
||||
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
||||
ERR_FAIL_COND_V_MSG(f.is_null(), RES(), "Cannot open file '" + p_path + "'.");
|
||||
ERR_FAIL_COND_V_MSG(f.is_null(), Ref<Resource>(), "Cannot open file '" + p_path + "'.");
|
||||
|
||||
return load_translation(f, r_error);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,8 +37,8 @@
|
|||
|
||||
class TranslationLoaderPO : public ResourceFormatLoader {
|
||||
public:
|
||||
static RES load_translation(Ref<FileAccess> f, Error *r_error = nullptr);
|
||||
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
static Ref<Resource> load_translation(Ref<FileAccess> f, Error *r_error = nullptr);
|
||||
virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
|
||||
virtual void get_recognized_extensions(List<String> *p_extensions) const;
|
||||
virtual bool handles_type(const String &p_type) const;
|
||||
virtual String get_resource_type(const String &p_path) const;
|
||||
|
|
|
|||
|
|
@ -1476,7 +1476,7 @@ String Object::tr_n(const StringName &p_message, const StringName &p_message_plu
|
|||
void Object::_clear_internal_resource_paths(const Variant &p_var) {
|
||||
switch (p_var.get_type()) {
|
||||
case Variant::OBJECT: {
|
||||
RES r = p_var;
|
||||
Ref<Resource> r = p_var;
|
||||
if (!r.is_valid()) {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ Variant WeakRef::get_ref() const {
|
|||
}
|
||||
RefCounted *r = cast_to<RefCounted>(obj);
|
||||
if (r) {
|
||||
return REF(r);
|
||||
return Ref<RefCounted>(r);
|
||||
}
|
||||
|
||||
return obj;
|
||||
|
|
@ -118,7 +118,7 @@ void WeakRef::set_obj(Object *p_object) {
|
|||
ref = p_object ? p_object->get_instance_id() : ObjectID();
|
||||
}
|
||||
|
||||
void WeakRef::set_ref(const REF &p_ref) {
|
||||
void WeakRef::set_ref(const Ref<RefCounted> &p_ref) {
|
||||
ref = p_ref.is_valid() ? p_ref->get_instance_id() : ObjectID();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -234,8 +234,6 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
typedef Ref<RefCounted> REF;
|
||||
|
||||
class WeakRef : public RefCounted {
|
||||
GDCLASS(WeakRef, RefCounted);
|
||||
|
||||
|
|
@ -247,7 +245,7 @@ protected:
|
|||
public:
|
||||
Variant get_ref() const;
|
||||
void set_obj(Object *p_object);
|
||||
void set_ref(const REF &p_ref);
|
||||
void set_ref(const Ref<RefCounted> &p_ref);
|
||||
|
||||
WeakRef() {}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ public:
|
|||
String display;
|
||||
String insert_text;
|
||||
Color font_color;
|
||||
RES icon;
|
||||
Ref<Resource> icon;
|
||||
Variant default_value;
|
||||
Vector<Pair<int, int>> matches;
|
||||
int location = LOCATION_OTHER;
|
||||
|
|
|
|||
|
|
@ -806,7 +806,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
|
|||
return ERR_PARSE_ERROR;
|
||||
}
|
||||
|
||||
REF ref = REF(Object::cast_to<RefCounted>(obj));
|
||||
Ref<RefCounted> ref = Ref<RefCounted>(Object::cast_to<RefCounted>(obj));
|
||||
|
||||
get_token(p_stream, token, line, r_err_str);
|
||||
if (token.type != TK_COMMA) {
|
||||
|
|
@ -887,7 +887,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
|
|||
}
|
||||
|
||||
if (p_res_parser && id == "Resource" && p_res_parser->func) {
|
||||
RES res;
|
||||
Ref<Resource> res;
|
||||
Error err = p_res_parser->func(p_res_parser->userdata, p_stream, res, line, r_err_str);
|
||||
if (err) {
|
||||
return err;
|
||||
|
|
@ -895,7 +895,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
|
|||
|
||||
value = res;
|
||||
} else if (p_res_parser && id == "ExtResource" && p_res_parser->ext_func) {
|
||||
RES res;
|
||||
Ref<Resource> res;
|
||||
Error err = p_res_parser->ext_func(p_res_parser->userdata, p_stream, res, line, r_err_str);
|
||||
if (err) {
|
||||
return err;
|
||||
|
|
@ -903,7 +903,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
|
|||
|
||||
value = res;
|
||||
} else if (p_res_parser && id == "SubResource" && p_res_parser->sub_func) {
|
||||
RES res;
|
||||
Ref<Resource> res;
|
||||
Error err = p_res_parser->sub_func(p_res_parser->userdata, p_stream, res, line, r_err_str);
|
||||
if (err) {
|
||||
return err;
|
||||
|
|
@ -914,7 +914,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
|
|||
get_token(p_stream, token, line, r_err_str);
|
||||
if (token.type == TK_STRING) {
|
||||
String path = token.value;
|
||||
RES res = ResourceLoader::load(path);
|
||||
Ref<Resource> res = ResourceLoader::load(path);
|
||||
if (res.is_null()) {
|
||||
r_err_str = "Can't load resource at path: '" + path + "'.";
|
||||
return ERR_PARSE_ERROR;
|
||||
|
|
@ -1624,7 +1624,7 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
|
|||
break; // don't save it
|
||||
}
|
||||
|
||||
RES res = p_variant;
|
||||
Ref<Resource> res = p_variant;
|
||||
if (res.is_valid()) {
|
||||
//is resource
|
||||
String res_text;
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ public:
|
|||
class VariantWriter {
|
||||
public:
|
||||
typedef Error (*StoreStringFunc)(void *ud, const String &p_string);
|
||||
typedef String (*EncodeResourceFunc)(void *ud, const RES &p_resource);
|
||||
typedef String (*EncodeResourceFunc)(void *ud, const Ref<Resource> &p_resource);
|
||||
|
||||
static Error write(const Variant &p_variant, StoreStringFunc p_store_string_func, void *p_store_string_ud, EncodeResourceFunc p_encode_res_func, void *p_encode_res_ud, int recursion_count = 0);
|
||||
static Error write_to_string(const Variant &p_variant, String &r_string, EncodeResourceFunc p_encode_res_func = nullptr, void *p_encode_res_ud = nullptr);
|
||||
|
|
|
|||
|
|
@ -435,7 +435,7 @@ struct VariantUtilityFunctions {
|
|||
r_error.error = Callable::CallError::CALL_OK;
|
||||
if (obj.is_ref_counted()) {
|
||||
Ref<WeakRef> wref = memnew(WeakRef);
|
||||
REF r = obj;
|
||||
Ref<RefCounted> r = obj;
|
||||
if (r.is_valid()) {
|
||||
wref->set_ref(r);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue