2016-06-18 14:46:12 +02:00
|
|
|
/**************************************************************************/
|
2019-02-12 17:18:13 +01:00
|
|
|
/* resource_format_text.cpp */
|
2016-06-18 14:46:12 +02:00
|
|
|
/**************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* https://godotengine.org */
|
|
|
|
/**************************************************************************/
|
|
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/**************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2019-02-12 17:18:13 +01:00
|
|
|
#include "resource_format_text.h"
|
|
|
|
|
2020-11-07 23:33:38 +01:00
|
|
|
#include "core/config/project_settings.h"
|
2021-06-11 14:51:48 +02:00
|
|
|
#include "core/io/dir_access.h"
|
2022-04-28 22:49:10 +02:00
|
|
|
#include "core/io/missing_resource.h"
|
2023-09-06 21:02:52 +02:00
|
|
|
#include "core/object/script_language.h"
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2024-04-08 16:51:34 +02:00
|
|
|
// Version 2: Changed names for Basis, AABB, Vectors, etc.
|
|
|
|
// Version 3: New string ID for ext/subresources, breaks forward compat.
|
|
|
|
// Version 4: PackedByteArray can be base64 encoded, and PackedVector4Array was added.
|
2024-03-05 17:53:57 +01:00
|
|
|
#define FORMAT_VERSION 4
|
2024-04-08 16:51:34 +02:00
|
|
|
// For compat, save as version 3 if not using PackedVector4Array or no big PackedByteArray.
|
|
|
|
#define FORMAT_VERSION_COMPAT 3
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
#define _printerr() ERR_PRINT(String(res_path + ":" + itos(lines) + " - Parse Error: " + error_text).utf8().get_data());
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
///
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
Ref<Resource> ResourceLoaderText::get_resource() {
|
2015-11-24 14:42:05 +01:00
|
|
|
return resource;
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
Error ResourceLoaderText::_parse_sub_resource_dummy(DummyReadData *p_data, VariantParser::Stream *p_stream, Ref<Resource> &r_res, int &line, String &r_err_str) {
|
2017-12-15 12:38:24 +01:00
|
|
|
VariantParser::Token token;
|
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
2021-07-21 02:36:56 +02:00
|
|
|
if (token.type != VariantParser::TK_NUMBER && token.type != VariantParser::TK_STRING) {
|
|
|
|
r_err_str = "Expected number (old style) or string (sub-resource index)";
|
2017-12-15 12:38:24 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
if (p_data->no_placeholders) {
|
|
|
|
r_res.unref();
|
|
|
|
} else {
|
|
|
|
String unique_id = token.value;
|
2017-12-15 12:38:24 +01:00
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
if (!p_data->resource_map.has(unique_id)) {
|
|
|
|
r_err_str = "Found unique_id reference before mapping, sub-resources stored out of order in resource file";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
2017-12-15 12:38:24 +01:00
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
r_res = p_data->resource_map[unique_id];
|
|
|
|
}
|
2017-12-15 12:38:24 +01:00
|
|
|
|
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
|
|
|
if (token.type != VariantParser::TK_PARENTHESIS_CLOSE) {
|
|
|
|
r_err_str = "Expected ')'";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
Error ResourceLoaderText::_parse_ext_resource_dummy(DummyReadData *p_data, VariantParser::Stream *p_stream, Ref<Resource> &r_res, int &line, String &r_err_str) {
|
2017-12-15 12:38:24 +01:00
|
|
|
VariantParser::Token token;
|
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
2021-07-21 02:36:56 +02:00
|
|
|
if (token.type != VariantParser::TK_NUMBER && token.type != VariantParser::TK_STRING) {
|
|
|
|
r_err_str = "Expected number (old style sub-resource index) or String (ext-resource ID)";
|
2017-12-15 12:38:24 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
if (p_data->no_placeholders) {
|
|
|
|
r_res.unref();
|
|
|
|
} else {
|
|
|
|
String id = token.value;
|
2017-12-15 12:38:24 +01:00
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
ERR_FAIL_COND_V(!p_data->rev_external_resources.has(id), ERR_PARSE_ERROR);
|
2017-12-15 12:38:24 +01:00
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
r_res = p_data->rev_external_resources[id];
|
|
|
|
}
|
2017-12-15 12:38:24 +01:00
|
|
|
|
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
|
|
|
if (token.type != VariantParser::TK_PARENTHESIS_CLOSE) {
|
|
|
|
r_err_str = "Expected ')'";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
Error ResourceLoaderText::_parse_sub_resource(VariantParser::Stream *p_stream, Ref<Resource> &r_res, int &line, String &r_err_str) {
|
2015-11-29 00:56:14 +01:00
|
|
|
VariantParser::Token token;
|
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
2021-07-21 02:36:56 +02:00
|
|
|
if (token.type != VariantParser::TK_NUMBER && token.type != VariantParser::TK_STRING) {
|
|
|
|
r_err_str = "Expected number (old style sub-resource index) or string";
|
2015-11-29 00:56:14 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
String id = token.value;
|
|
|
|
ERR_FAIL_COND_V(!int_resources.has(id), ERR_INVALID_PARAMETER);
|
|
|
|
r_res = int_resources[id];
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
|
|
|
if (token.type != VariantParser::TK_PARENTHESIS_CLOSE) {
|
|
|
|
r_err_str = "Expected ')'";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
Error ResourceLoaderText::_parse_ext_resource(VariantParser::Stream *p_stream, Ref<Resource> &r_res, int &line, String &r_err_str) {
|
2015-11-29 00:56:14 +01:00
|
|
|
VariantParser::Token token;
|
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
2021-07-21 02:36:56 +02:00
|
|
|
if (token.type != VariantParser::TK_NUMBER && token.type != VariantParser::TK_STRING) {
|
|
|
|
r_err_str = "Expected number (old style sub-resource index) or String (ext-resource ID)";
|
2015-11-29 00:56:14 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
String id = token.value;
|
2022-11-28 16:19:15 +01:00
|
|
|
Error err = OK;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2016-06-28 17:35:11 +02:00
|
|
|
if (!ignore_resource_parsing) {
|
|
|
|
if (!ext_resources.has(id)) {
|
2021-07-21 02:36:56 +02:00
|
|
|
r_err_str = "Can't load cached ext-resource id: " + id;
|
2016-06-28 17:35:11 +02:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2016-06-28 17:35:11 +02:00
|
|
|
String path = ext_resources[id].path;
|
|
|
|
String type = ext_resources[id].type;
|
2023-03-05 01:09:18 +01:00
|
|
|
Ref<ResourceLoader::LoadToken> &load_token = ext_resources[id].load_token;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2023-03-05 01:09:18 +01:00
|
|
|
if (load_token.is_valid()) { // If not valid, it's OK since then we know this load accepts broken dependencies.
|
|
|
|
Ref<Resource> res = ResourceLoader::_load_complete(*load_token.ptr(), &err);
|
2020-02-28 12:27:04 +01:00
|
|
|
if (res.is_null()) {
|
2023-03-05 01:09:18 +01:00
|
|
|
if (!ResourceLoader::is_cleaning_tasks()) {
|
|
|
|
if (ResourceLoader::get_abort_on_missing_resources()) {
|
|
|
|
error = ERR_FILE_MISSING_DEPENDENCIES;
|
|
|
|
error_text = "[ext_resource] referenced non-existent resource at: " + path;
|
|
|
|
_printerr();
|
|
|
|
err = error;
|
|
|
|
} else {
|
|
|
|
ResourceLoader::notify_dependency_error(local_path, path, type);
|
|
|
|
}
|
2020-02-28 12:27:04 +01:00
|
|
|
}
|
|
|
|
} else {
|
2023-03-05 01:09:18 +01:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
//remember ID for saving
|
2023-06-01 22:34:49 +02:00
|
|
|
res->set_id_for_path(local_path, id);
|
2023-03-05 01:09:18 +01:00
|
|
|
#endif
|
2020-02-28 12:27:04 +01:00
|
|
|
r_res = res;
|
|
|
|
}
|
|
|
|
} else {
|
2023-03-05 01:09:18 +01:00
|
|
|
r_res = Ref<Resource>();
|
2016-06-28 17:35:11 +02:00
|
|
|
}
|
2024-01-04 14:12:27 +01:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
if (r_res.is_null()) {
|
|
|
|
// Hack to allow checking original path.
|
|
|
|
r_res.instantiate();
|
|
|
|
r_res->set_meta("__load_path__", ext_resources[id].path);
|
|
|
|
}
|
|
|
|
#endif
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
VariantParser::get_token(p_stream, token, line, r_err_str);
|
|
|
|
if (token.type != VariantParser::TK_PARENTHESIS_CLOSE) {
|
|
|
|
r_err_str = "Expected ')'";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2022-11-28 16:19:15 +01:00
|
|
|
return err;
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
Ref<PackedScene> ResourceLoaderText::_parse_node_tag(VariantParser::ResourceParser &parser) {
|
2024-06-25 14:12:40 +02:00
|
|
|
Ref<PackedScene> packed_scene = ResourceLoader::get_resource_ref_override(local_path);
|
|
|
|
if (packed_scene.is_null()) {
|
|
|
|
packed_scene.instantiate();
|
|
|
|
}
|
2017-12-15 12:38:24 +01:00
|
|
|
|
|
|
|
while (true) {
|
|
|
|
if (next_tag.name == "node") {
|
|
|
|
int parent = -1;
|
|
|
|
int owner = -1;
|
|
|
|
int type = -1;
|
|
|
|
int name = -1;
|
|
|
|
int instance = -1;
|
2017-12-08 15:05:15 +01:00
|
|
|
int index = -1;
|
2017-12-15 12:38:24 +01:00
|
|
|
//int base_scene=-1;
|
|
|
|
|
|
|
|
if (next_tag.fields.has("name")) {
|
|
|
|
name = packed_scene->get_state()->add_name(next_tag.fields["name"]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_tag.fields.has("parent")) {
|
|
|
|
NodePath np = next_tag.fields["parent"];
|
|
|
|
np.prepend_period(); //compatible to how it manages paths internally
|
|
|
|
parent = packed_scene->get_state()->add_node_path(np);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_tag.fields.has("type")) {
|
|
|
|
type = packed_scene->get_state()->add_name(next_tag.fields["type"]);
|
|
|
|
} else {
|
2022-11-16 00:13:39 +01:00
|
|
|
type = SceneState::TYPE_INSTANTIATED; //no type? assume this was instantiated
|
2017-12-15 12:38:24 +01:00
|
|
|
}
|
|
|
|
|
2022-06-19 00:42:02 +02:00
|
|
|
HashSet<StringName> path_properties;
|
|
|
|
|
|
|
|
if (next_tag.fields.has("node_paths")) {
|
|
|
|
Vector<String> paths = next_tag.fields["node_paths"];
|
|
|
|
for (int i = 0; i < paths.size(); i++) {
|
|
|
|
path_properties.insert(paths[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-15 12:38:24 +01:00
|
|
|
if (next_tag.fields.has("instance")) {
|
|
|
|
instance = packed_scene->get_state()->add_value(next_tag.fields["instance"]);
|
|
|
|
|
|
|
|
if (packed_scene->get_state()->get_node_count() == 0 && parent == -1) {
|
|
|
|
packed_scene->get_state()->set_base_scene(instance);
|
|
|
|
instance = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_tag.fields.has("instance_placeholder")) {
|
|
|
|
String path = next_tag.fields["instance_placeholder"];
|
|
|
|
|
|
|
|
int path_v = packed_scene->get_state()->add_value(path);
|
|
|
|
|
|
|
|
if (packed_scene->get_state()->get_node_count() == 0) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Instance Placeholder can't be used for inheritance.";
|
|
|
|
_printerr();
|
|
|
|
return Ref<PackedScene>();
|
|
|
|
}
|
|
|
|
|
|
|
|
instance = path_v | SceneState::FLAG_INSTANCE_IS_PLACEHOLDER;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_tag.fields.has("owner")) {
|
|
|
|
owner = packed_scene->get_state()->add_node_path(next_tag.fields["owner"]);
|
|
|
|
} else {
|
2022-11-16 00:13:39 +01:00
|
|
|
if (parent != -1 && !(type == SceneState::TYPE_INSTANTIATED && instance == -1)) {
|
2017-12-15 12:38:24 +01:00
|
|
|
owner = 0; //if no owner, owner is root
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-12-15 12:38:24 +01:00
|
|
|
}
|
|
|
|
|
2017-12-08 15:05:15 +01:00
|
|
|
if (next_tag.fields.has("index")) {
|
|
|
|
index = next_tag.fields["index"];
|
|
|
|
}
|
|
|
|
|
|
|
|
int node_id = packed_scene->get_state()->add_node(parent, owner, type, name, instance, index);
|
2017-12-15 12:38:24 +01:00
|
|
|
|
|
|
|
if (next_tag.fields.has("groups")) {
|
|
|
|
Array groups = next_tag.fields["groups"];
|
2023-12-24 13:44:21 +01:00
|
|
|
for (const Variant &group : groups) {
|
|
|
|
packed_scene->get_state()->add_node_group(node_id, packed_scene->get_state()->add_name(group));
|
2017-12-15 12:38:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
String assign;
|
|
|
|
Variant value;
|
|
|
|
|
|
|
|
error = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, &parser);
|
|
|
|
|
|
|
|
if (error) {
|
2022-02-26 12:02:05 +01:00
|
|
|
if (error == ERR_FILE_MISSING_DEPENDENCIES) {
|
|
|
|
// Resource loading error, just skip it.
|
|
|
|
} else if (error != ERR_FILE_EOF) {
|
2023-12-20 01:17:26 +01:00
|
|
|
ERR_PRINT(vformat("Parse Error: %s. [Resource file %s:%d]", error_names[error], res_path, lines));
|
2017-12-15 12:38:24 +01:00
|
|
|
return Ref<PackedScene>();
|
|
|
|
} else {
|
2020-02-28 21:45:33 +01:00
|
|
|
error = OK;
|
2017-12-15 12:38:24 +01:00
|
|
|
return packed_scene;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-09 10:42:46 +01:00
|
|
|
if (!assign.is_empty()) {
|
2022-06-19 00:42:02 +02:00
|
|
|
StringName assign_name = assign;
|
|
|
|
int nameidx = packed_scene->get_state()->add_name(assign_name);
|
2017-12-15 12:38:24 +01:00
|
|
|
int valueidx = packed_scene->get_state()->add_value(value);
|
2022-06-19 00:42:02 +02:00
|
|
|
packed_scene->get_state()->add_node_property(node_id, nameidx, valueidx, path_properties.has(assign_name));
|
2017-12-15 12:38:24 +01:00
|
|
|
//it's assignment
|
2021-12-09 10:42:46 +01:00
|
|
|
} else if (!next_tag.name.is_empty()) {
|
2017-12-15 12:38:24 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (next_tag.name == "connection") {
|
|
|
|
if (!next_tag.fields.has("from")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2018-09-13 03:38:39 +02:00
|
|
|
error_text = "missing 'from' field from connection tag";
|
2017-12-15 12:38:24 +01:00
|
|
|
return Ref<PackedScene>();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!next_tag.fields.has("to")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2018-09-13 03:38:39 +02:00
|
|
|
error_text = "missing 'to' field from connection tag";
|
2017-12-15 12:38:24 +01:00
|
|
|
return Ref<PackedScene>();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!next_tag.fields.has("signal")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2018-09-13 03:38:39 +02:00
|
|
|
error_text = "missing 'signal' field from connection tag";
|
2017-12-15 12:38:24 +01:00
|
|
|
return Ref<PackedScene>();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!next_tag.fields.has("method")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2018-09-13 03:38:39 +02:00
|
|
|
error_text = "missing 'method' field from connection tag";
|
2017-12-15 12:38:24 +01:00
|
|
|
return Ref<PackedScene>();
|
|
|
|
}
|
|
|
|
|
|
|
|
NodePath from = next_tag.fields["from"];
|
|
|
|
NodePath to = next_tag.fields["to"];
|
|
|
|
StringName method = next_tag.fields["method"];
|
|
|
|
StringName signal = next_tag.fields["signal"];
|
2020-02-28 12:27:04 +01:00
|
|
|
int flags = Object::CONNECT_PERSIST;
|
2021-10-01 02:40:07 +02:00
|
|
|
int unbinds = 0;
|
2017-12-15 12:38:24 +01:00
|
|
|
Array binds;
|
|
|
|
|
|
|
|
if (next_tag.fields.has("flags")) {
|
|
|
|
flags = next_tag.fields["flags"];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_tag.fields.has("binds")) {
|
|
|
|
binds = next_tag.fields["binds"];
|
|
|
|
}
|
|
|
|
|
2021-10-01 02:40:07 +02:00
|
|
|
if (next_tag.fields.has("unbinds")) {
|
|
|
|
unbinds = next_tag.fields["unbinds"];
|
|
|
|
}
|
|
|
|
|
2017-12-15 12:38:24 +01:00
|
|
|
Vector<int> bind_ints;
|
2023-12-24 13:44:21 +01:00
|
|
|
for (const Variant &bind : binds) {
|
|
|
|
bind_ints.push_back(packed_scene->get_state()->add_value(bind));
|
2017-12-15 12:38:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
packed_scene->get_state()->add_connection(
|
|
|
|
packed_scene->get_state()->add_node_path(from.simplified()),
|
|
|
|
packed_scene->get_state()->add_node_path(to.simplified()),
|
|
|
|
packed_scene->get_state()->add_name(signal),
|
|
|
|
packed_scene->get_state()->add_name(method),
|
|
|
|
flags,
|
2021-10-01 02:40:07 +02:00
|
|
|
unbinds,
|
2017-12-15 12:38:24 +01:00
|
|
|
bind_ints);
|
|
|
|
|
|
|
|
error = VariantParser::parse_tag(&stream, lines, error_text, next_tag, &parser);
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
if (error != ERR_FILE_EOF) {
|
|
|
|
_printerr();
|
|
|
|
return Ref<PackedScene>();
|
|
|
|
} else {
|
2020-02-28 21:45:33 +01:00
|
|
|
error = OK;
|
2017-12-15 12:38:24 +01:00
|
|
|
return packed_scene;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (next_tag.name == "editable") {
|
|
|
|
if (!next_tag.fields.has("path")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2021-11-23 12:20:57 +01:00
|
|
|
error_text = "missing 'path' field from editable tag";
|
2017-12-15 12:38:24 +01:00
|
|
|
_printerr();
|
|
|
|
return Ref<PackedScene>();
|
|
|
|
}
|
|
|
|
|
|
|
|
NodePath path = next_tag.fields["path"];
|
|
|
|
|
|
|
|
packed_scene->get_state()->add_editable_instance(path.simplified());
|
|
|
|
|
|
|
|
error = VariantParser::parse_tag(&stream, lines, error_text, next_tag, &parser);
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
if (error != ERR_FILE_EOF) {
|
|
|
|
_printerr();
|
|
|
|
return Ref<PackedScene>();
|
|
|
|
} else {
|
2020-02-28 21:45:33 +01:00
|
|
|
error = OK;
|
2017-12-15 12:38:24 +01:00
|
|
|
return packed_scene;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
_printerr();
|
|
|
|
return Ref<PackedScene>();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
Error ResourceLoaderText::load() {
|
2020-05-14 16:41:43 +02:00
|
|
|
if (error != OK) {
|
2015-11-29 00:56:14 +01:00
|
|
|
return error;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
while (true) {
|
|
|
|
if (next_tag.name != "ext_resource") {
|
|
|
|
break;
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
if (!next_tag.fields.has("path")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Missing 'path' in external resource tag";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!next_tag.fields.has("type")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Missing 'type' in external resource tag";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!next_tag.fields.has("id")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Missing 'id' in external resource tag";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
String path = next_tag.fields["path"];
|
|
|
|
String type = next_tag.fields["type"];
|
2021-07-21 02:36:56 +02:00
|
|
|
String id = next_tag.fields["id"];
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
if (next_tag.fields.has("uid")) {
|
|
|
|
String uidt = next_tag.fields["uid"];
|
|
|
|
ResourceUID::ID uid = ResourceUID::get_singleton()->text_to_id(uidt);
|
|
|
|
if (uid != ResourceUID::INVALID_ID && ResourceUID::get_singleton()->has_id(uid)) {
|
|
|
|
// If a UID is found and the path is valid, it will be used, otherwise, it falls back to the path.
|
|
|
|
path = ResourceUID::get_singleton()->get_id_path(uid);
|
|
|
|
} else {
|
2022-10-09 13:52:04 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
// Silence a warning that can happen during the initial filesystem scan due to cache being regenerated.
|
|
|
|
if (ResourceLoader::get_resource_uid(path) != uid) {
|
2022-12-05 19:01:59 +01:00
|
|
|
WARN_PRINT(String(res_path + ":" + itos(lines) + " - ext_resource, invalid UID: " + uidt + " - using text path instead: " + path).utf8().get_data());
|
2022-10-09 13:52:04 +02:00
|
|
|
}
|
|
|
|
#else
|
2022-12-05 19:01:59 +01:00
|
|
|
WARN_PRINT(String(res_path + ":" + itos(lines) + " - ext_resource, invalid UID: " + uidt + " - using text path instead: " + path).utf8().get_data());
|
2022-10-09 13:52:04 +02:00
|
|
|
#endif
|
2021-07-23 21:01:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-03 17:03:38 +01:00
|
|
|
if (!path.contains("://") && path.is_relative_path()) {
|
2015-11-24 14:42:05 +01:00
|
|
|
// path is relative to file being loaded, so convert to a resource path
|
2022-08-30 02:34:01 +02:00
|
|
|
path = ProjectSettings::get_singleton()->localize_path(local_path.get_base_dir().path_join(path));
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (remaps.has(path)) {
|
|
|
|
path = remaps[path];
|
|
|
|
}
|
|
|
|
|
2023-03-05 01:09:18 +01:00
|
|
|
ext_resources[id].path = path;
|
|
|
|
ext_resources[id].type = type;
|
2024-02-22 12:53:19 +01:00
|
|
|
ext_resources[id].load_token = ResourceLoader::_load_start(path, type, use_sub_threads ? ResourceLoader::LOAD_THREAD_DISTRIBUTE : ResourceLoader::LOAD_THREAD_FROM_CURRENT, cache_mode_for_external);
|
2023-03-05 01:09:18 +01:00
|
|
|
if (!ext_resources[id].load_token.is_valid()) {
|
|
|
|
if (ResourceLoader::get_abort_on_missing_resources()) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "[ext_resource] referenced non-existent resource at: " + path;
|
|
|
|
_printerr();
|
|
|
|
return error;
|
2020-02-28 12:27:04 +01:00
|
|
|
} else {
|
2023-03-05 01:09:18 +01:00
|
|
|
ResourceLoader::notify_dependency_error(local_path, path, type);
|
2020-02-28 12:27:04 +01:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
error = VariantParser::parse_tag(&stream, lines, error_text, next_tag, &rp);
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
_printerr();
|
2022-11-15 09:50:26 +01:00
|
|
|
return error;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2016-01-29 12:41:22 +01:00
|
|
|
resource_current++;
|
2020-02-28 12:27:04 +01:00
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
//these are the ones that count
|
|
|
|
resources_total -= resource_current;
|
|
|
|
resource_current = 0;
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
if (next_tag.name != "sub_resource") {
|
|
|
|
break;
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
if (!next_tag.fields.has("type")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Missing 'type' in external resource tag";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!next_tag.fields.has("id")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2021-07-21 02:36:56 +02:00
|
|
|
error_text = "Missing 'id' in external resource tag";
|
2015-11-29 00:56:14 +01:00
|
|
|
_printerr();
|
2015-11-24 14:42:05 +01:00
|
|
|
return error;
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
String type = next_tag.fields["type"];
|
2021-07-21 02:36:56 +02:00
|
|
|
String id = next_tag.fields["id"];
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
String path = local_path + "::" + id;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
//bool exists=ResourceCache::has(path);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
Ref<Resource> res;
|
2021-02-11 18:18:45 +01:00
|
|
|
bool do_assign = false;
|
|
|
|
|
|
|
|
if (cache_mode == ResourceFormatLoader::CACHE_MODE_REPLACE && ResourceCache::has(path)) {
|
|
|
|
//reuse existing
|
2022-06-22 13:46:46 +02:00
|
|
|
Ref<Resource> cache = ResourceCache::get_ref(path);
|
|
|
|
if (cache.is_valid() && cache->get_class() == type) {
|
|
|
|
res = cache;
|
2021-02-11 18:18:45 +01:00
|
|
|
res->reset_state();
|
|
|
|
do_assign = true;
|
|
|
|
}
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
MissingResource *missing_resource = nullptr;
|
|
|
|
|
2021-02-11 18:18:45 +01:00
|
|
|
if (res.is_null()) { //not reuse
|
2022-06-22 13:46:46 +02:00
|
|
|
Ref<Resource> cache = ResourceCache::get_ref(path);
|
|
|
|
if (cache_mode != ResourceFormatLoader::CACHE_MODE_IGNORE && cache.is_valid()) { //only if it doesn't exist
|
2021-02-11 18:18:45 +01:00
|
|
|
//cached, do not assign
|
2022-06-22 13:46:46 +02:00
|
|
|
res = cache;
|
2021-02-11 18:18:45 +01:00
|
|
|
} else {
|
|
|
|
//create
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-06-18 00:03:09 +02:00
|
|
|
Object *obj = ClassDB::instantiate(type);
|
2021-02-11 18:18:45 +01:00
|
|
|
if (!obj) {
|
2022-04-28 22:49:10 +02:00
|
|
|
if (ResourceLoader::is_creating_missing_resources_if_class_unavailable_enabled()) {
|
|
|
|
missing_resource = memnew(MissingResource);
|
|
|
|
missing_resource->set_original_class(type);
|
|
|
|
missing_resource->set_recording_properties(true);
|
|
|
|
obj = missing_resource;
|
|
|
|
} else {
|
|
|
|
error_text += "Can't create sub resource of type: " + type;
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
return error;
|
|
|
|
}
|
2021-02-11 18:18:45 +01:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-02-11 18:18:45 +01:00
|
|
|
Resource *r = Object::cast_to<Resource>(obj);
|
|
|
|
if (!r) {
|
|
|
|
error_text += "Can't create sub resource of type, because not a resource: " + type;
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
return error;
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2021-02-11 18:18:45 +01:00
|
|
|
res = Ref<Resource>(r);
|
|
|
|
do_assign = true;
|
2020-04-20 04:19:21 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2016-01-29 12:41:22 +01:00
|
|
|
resource_current++;
|
|
|
|
|
2023-01-10 18:48:28 +01:00
|
|
|
if (progress && resources_total > 0) {
|
|
|
|
*progress = resource_current / float(resources_total);
|
|
|
|
}
|
|
|
|
|
2023-01-28 16:20:03 +01:00
|
|
|
int_resources[id] = res; // Always assign int resources.
|
|
|
|
if (do_assign) {
|
|
|
|
if (cache_mode != ResourceFormatLoader::CACHE_MODE_IGNORE) {
|
|
|
|
res->set_path(path, cache_mode == ResourceFormatLoader::CACHE_MODE_REPLACE);
|
2024-02-22 12:53:19 +01:00
|
|
|
} else {
|
2023-08-05 02:07:16 +02:00
|
|
|
res->set_path_cache(path);
|
2023-01-28 16:20:03 +01:00
|
|
|
}
|
2023-01-10 18:48:28 +01:00
|
|
|
res->set_scene_unique_id(id);
|
2021-08-10 06:42:35 +02:00
|
|
|
}
|
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
Dictionary missing_resource_properties;
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
while (true) {
|
|
|
|
String assign;
|
|
|
|
Variant value;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
error = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, &rp);
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2021-12-09 10:42:46 +01:00
|
|
|
if (!assign.is_empty()) {
|
2021-02-11 18:18:45 +01:00
|
|
|
if (do_assign) {
|
2022-04-28 22:49:10 +02:00
|
|
|
bool set_valid = true;
|
|
|
|
|
|
|
|
if (value.get_type() == Variant::OBJECT && missing_resource != nullptr) {
|
|
|
|
// If the property being set is a missing resource (and the parent is not),
|
|
|
|
// then setting it will most likely not work.
|
|
|
|
// Instead, save it as metadata.
|
|
|
|
|
|
|
|
Ref<MissingResource> mr = value;
|
|
|
|
if (mr.is_valid()) {
|
|
|
|
missing_resource_properties[assign] = mr;
|
|
|
|
set_valid = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-27 08:56:53 +01:00
|
|
|
if (value.get_type() == Variant::ARRAY) {
|
|
|
|
Array set_array = value;
|
|
|
|
bool is_get_valid = false;
|
|
|
|
Variant get_value = res->get(assign, &is_get_valid);
|
|
|
|
if (is_get_valid && get_value.get_type() == Variant::ARRAY) {
|
|
|
|
Array get_array = get_value;
|
|
|
|
if (!set_array.is_same_typed(get_array)) {
|
|
|
|
value = Array(set_array, get_array.get_typed_builtin(), get_array.get_typed_class_name(), get_array.get_typed_script());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
if (set_valid) {
|
|
|
|
res->set(assign, value);
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
|
|
|
//it's assignment
|
2021-12-09 10:42:46 +01:00
|
|
|
} else if (!next_tag.name.is_empty()) {
|
2015-11-29 00:56:14 +01:00
|
|
|
error = OK;
|
|
|
|
break;
|
|
|
|
} else {
|
2015-11-24 14:42:05 +01:00
|
|
|
error = ERR_FILE_CORRUPT;
|
2015-11-29 00:56:14 +01:00
|
|
|
error_text = "Premature end of file while parsing [sub_resource]";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
if (missing_resource) {
|
|
|
|
missing_resource->set_recording_properties(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!missing_resource_properties.is_empty()) {
|
|
|
|
res->set_meta(META_MISSING_RESOURCES, missing_resource_properties);
|
|
|
|
}
|
2020-02-28 12:27:04 +01:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
while (true) {
|
|
|
|
if (next_tag.name != "resource") {
|
|
|
|
break;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (is_scene) {
|
|
|
|
error_text += "found the 'resource' tag on a scene file!";
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
return error;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
MissingResource *missing_resource = nullptr;
|
|
|
|
|
2024-06-25 14:12:40 +02:00
|
|
|
resource = ResourceLoader::get_resource_ref_override(local_path);
|
|
|
|
if (resource.is_null()) {
|
|
|
|
Ref<Resource> cache = ResourceCache::get_ref(local_path);
|
|
|
|
if (cache_mode == ResourceFormatLoader::CACHE_MODE_REPLACE && cache.is_valid() && cache->get_class() == res_type) {
|
|
|
|
cache->reset_state();
|
|
|
|
resource = cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!resource.is_valid()) {
|
|
|
|
Object *obj = ClassDB::instantiate(res_type);
|
|
|
|
if (!obj) {
|
|
|
|
if (ResourceLoader::is_creating_missing_resources_if_class_unavailable_enabled()) {
|
|
|
|
missing_resource = memnew(MissingResource);
|
|
|
|
missing_resource->set_original_class(res_type);
|
|
|
|
missing_resource->set_recording_properties(true);
|
|
|
|
obj = missing_resource;
|
|
|
|
} else {
|
|
|
|
error_text += "Can't create sub resource of type: " + res_type;
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Resource *r = Object::cast_to<Resource>(obj);
|
|
|
|
if (!r) {
|
|
|
|
error_text += "Can't create sub resource of type, because not a resource: " + res_type;
|
2022-04-28 22:49:10 +02:00
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
return error;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2024-06-25 14:12:40 +02:00
|
|
|
resource = Ref<Resource>(r);
|
2021-02-11 18:18:45 +01:00
|
|
|
}
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
Dictionary missing_resource_properties;
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
while (true) {
|
|
|
|
String assign;
|
|
|
|
Variant value;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
error = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, &rp);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (error) {
|
|
|
|
if (error != ERR_FILE_EOF) {
|
|
|
|
_printerr();
|
2016-01-14 15:06:20 +01:00
|
|
|
} else {
|
2020-02-28 21:45:33 +01:00
|
|
|
error = OK;
|
2021-02-11 18:18:45 +01:00
|
|
|
if (cache_mode != ResourceFormatLoader::CACHE_MODE_IGNORE) {
|
2020-04-20 04:19:21 +02:00
|
|
|
if (!ResourceCache::has(res_path)) {
|
|
|
|
resource->set_path(res_path);
|
|
|
|
}
|
|
|
|
resource->set_as_translation_remapped(translation_remapped);
|
2024-02-22 12:53:19 +01:00
|
|
|
} else {
|
|
|
|
resource->set_path_cache(res_path);
|
2016-01-14 15:06:20 +01:00
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-12-09 10:42:46 +01:00
|
|
|
if (!assign.is_empty()) {
|
2022-04-28 22:49:10 +02:00
|
|
|
bool set_valid = true;
|
|
|
|
|
|
|
|
if (value.get_type() == Variant::OBJECT && missing_resource != nullptr) {
|
|
|
|
// If the property being set is a missing resource (and the parent is not),
|
|
|
|
// then setting it will most likely not work.
|
|
|
|
// Instead, save it as metadata.
|
|
|
|
|
|
|
|
Ref<MissingResource> mr = value;
|
|
|
|
if (mr.is_valid()) {
|
|
|
|
missing_resource_properties[assign] = mr;
|
|
|
|
set_valid = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-27 08:56:53 +01:00
|
|
|
if (value.get_type() == Variant::ARRAY) {
|
|
|
|
Array set_array = value;
|
|
|
|
bool is_get_valid = false;
|
|
|
|
Variant get_value = resource->get(assign, &is_get_valid);
|
|
|
|
if (is_get_valid && get_value.get_type() == Variant::ARRAY) {
|
|
|
|
Array get_array = get_value;
|
|
|
|
if (!set_array.is_same_typed(get_array)) {
|
|
|
|
value = Array(set_array, get_array.get_typed_builtin(), get_array.get_typed_class_name(), get_array.get_typed_script());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
if (set_valid) {
|
|
|
|
resource->set(assign, value);
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
//it's assignment
|
2021-12-09 10:42:46 +01:00
|
|
|
} else if (!next_tag.name.is_empty()) {
|
2015-11-29 00:56:14 +01:00
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Extra tag found when parsing main resource file";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
} else {
|
2022-04-28 22:49:10 +02:00
|
|
|
break;
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
|
|
|
}
|
2022-04-28 22:49:10 +02:00
|
|
|
|
2023-01-10 18:48:28 +01:00
|
|
|
resource_current++;
|
|
|
|
|
|
|
|
if (progress && resources_total > 0) {
|
|
|
|
*progress = resource_current / float(resources_total);
|
|
|
|
}
|
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
if (missing_resource) {
|
|
|
|
missing_resource->set_recording_properties(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!missing_resource_properties.is_empty()) {
|
|
|
|
resource->set_meta(META_MISSING_RESOURCES, missing_resource_properties);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = OK;
|
|
|
|
|
|
|
|
return error;
|
2020-02-28 12:27:04 +01:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
//for scene files
|
|
|
|
|
|
|
|
if (next_tag.name == "node") {
|
2015-11-29 00:56:14 +01:00
|
|
|
if (!is_scene) {
|
|
|
|
error_text += "found the 'node' tag on a resource file!";
|
|
|
|
_printerr();
|
2015-11-24 14:42:05 +01:00
|
|
|
error = ERR_FILE_CORRUPT;
|
2015-11-29 00:56:14 +01:00
|
|
|
return error;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2017-12-15 12:38:24 +01:00
|
|
|
Ref<PackedScene> packed_scene = _parse_node_tag(rp);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (!packed_scene.is_valid()) {
|
2015-11-29 00:56:14 +01:00
|
|
|
return error;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
error = OK;
|
2017-12-15 12:38:24 +01:00
|
|
|
//get it here
|
|
|
|
resource = packed_scene;
|
2024-02-22 12:53:19 +01:00
|
|
|
if (cache_mode != ResourceFormatLoader::CACHE_MODE_IGNORE) {
|
|
|
|
if (!ResourceCache::has(res_path)) {
|
|
|
|
packed_scene->set_path(res_path);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
packed_scene->get_state()->set_path(res_path);
|
|
|
|
packed_scene->set_path_cache(res_path);
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
resource_current++;
|
|
|
|
|
2020-08-16 07:20:20 +02:00
|
|
|
if (progress && resources_total > 0) {
|
2020-02-28 12:27:04 +01:00
|
|
|
*progress = resource_current / float(resources_total);
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
return error;
|
2015-11-29 00:56:14 +01:00
|
|
|
} else {
|
|
|
|
error_text += "Unknown tag in file: " + next_tag.name;
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
int ResourceLoaderText::get_stage() const {
|
2015-11-29 00:56:14 +01:00
|
|
|
return resource_current;
|
|
|
|
}
|
2020-05-14 14:29:06 +02:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
int ResourceLoaderText::get_stage_count() const {
|
2015-11-29 00:56:14 +01:00
|
|
|
return resources_total; //+ext_resources;
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
void ResourceLoaderText::set_translation_remapped(bool p_remapped) {
|
2017-06-28 22:00:18 +02:00
|
|
|
translation_remapped = p_remapped;
|
|
|
|
}
|
|
|
|
|
2022-12-12 16:14:39 +01:00
|
|
|
ResourceLoaderText::ResourceLoaderText() :
|
2024-04-19 09:55:29 +02:00
|
|
|
stream(false), format_version(FORMAT_VERSION) {}
|
2017-06-28 22:00:18 +02:00
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
void ResourceLoaderText::get_dependencies(Ref<FileAccess> p_f, List<String> *p_dependencies, bool p_add_types) {
|
2017-08-11 21:10:05 +02:00
|
|
|
open(p_f);
|
2016-06-28 17:35:11 +02:00
|
|
|
ignore_resource_parsing = true;
|
2015-11-29 00:56:14 +01:00
|
|
|
ERR_FAIL_COND(error != OK);
|
|
|
|
|
|
|
|
while (next_tag.name == "ext_resource") {
|
2015-11-24 14:42:05 +01:00
|
|
|
if (!next_tag.fields.has("type")) {
|
2015-11-29 00:56:14 +01:00
|
|
|
error = ERR_FILE_CORRUPT;
|
2015-11-24 14:42:05 +01:00
|
|
|
error_text = "Missing 'type' in external resource tag";
|
|
|
|
_printerr();
|
2015-11-29 00:56:14 +01:00
|
|
|
return;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (!next_tag.fields.has("id")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2021-07-21 02:36:56 +02:00
|
|
|
error_text = "Missing 'id' in external resource tag";
|
2015-11-24 14:42:05 +01:00
|
|
|
_printerr();
|
2015-11-29 00:56:14 +01:00
|
|
|
return;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
String path = next_tag.fields["path"];
|
|
|
|
String type = next_tag.fields["type"];
|
2023-02-11 23:47:43 +01:00
|
|
|
String fallback_path;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
bool using_uid = false;
|
|
|
|
if (next_tag.fields.has("uid")) {
|
2023-02-11 23:47:43 +01:00
|
|
|
// If uid exists, return uid in text format, not the path.
|
2021-07-23 21:01:18 +02:00
|
|
|
String uidt = next_tag.fields["uid"];
|
|
|
|
ResourceUID::ID uid = ResourceUID::get_singleton()->text_to_id(uidt);
|
|
|
|
if (uid != ResourceUID::INVALID_ID) {
|
2023-02-11 23:47:43 +01:00
|
|
|
fallback_path = path; // Used by Dependency Editor, in case uid path fails.
|
2021-07-23 21:01:18 +02:00
|
|
|
path = ResourceUID::get_singleton()->id_to_text(uid);
|
|
|
|
using_uid = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-03 17:03:38 +01:00
|
|
|
if (!using_uid && !path.contains("://") && path.is_relative_path()) {
|
2023-02-11 23:47:43 +01:00
|
|
|
// Path is relative to file being loaded, so convert to a resource path.
|
2022-08-30 02:34:01 +02:00
|
|
|
path = ProjectSettings::get_singleton()->localize_path(local_path.get_base_dir().path_join(path));
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (p_add_types) {
|
|
|
|
path += "::" + type;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
2023-02-11 23:47:43 +01:00
|
|
|
if (!fallback_path.is_empty()) {
|
|
|
|
if (!p_add_types) {
|
|
|
|
path += "::"; // Ensure that path comes third, even if there is no type.
|
|
|
|
}
|
|
|
|
path += "::" + fallback_path;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
p_dependencies->push_back(path);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = VariantParser::parse_tag(&stream, lines, error_text, next_tag, &rp);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
if (err) {
|
2016-06-28 17:35:11 +02:00
|
|
|
print_line(error_text + " - " + itos(lines));
|
2015-11-24 14:42:05 +01:00
|
|
|
error_text = "Unexpected end of file";
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
2022-11-15 09:50:26 +01:00
|
|
|
return;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
}
|
2015-11-29 00:56:14 +01:00
|
|
|
}
|
|
|
|
|
2022-05-13 15:04:37 +02:00
|
|
|
Error ResourceLoaderText::rename_dependencies(Ref<FileAccess> p_f, const String &p_path, const HashMap<String, String> &p_map) {
|
2016-01-23 18:09:55 +01:00
|
|
|
open(p_f, true);
|
2015-11-24 14:42:05 +01:00
|
|
|
ERR_FAIL_COND_V(error != OK, error);
|
2016-06-28 17:35:11 +02:00
|
|
|
ignore_resource_parsing = true;
|
2015-11-24 14:42:05 +01:00
|
|
|
//FileAccess
|
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
Ref<FileAccess> fw;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
String base_path = local_path.get_base_dir();
|
2016-01-23 18:09:55 +01:00
|
|
|
|
2017-09-10 15:37:49 +02:00
|
|
|
uint64_t tag_end = f->get_position();
|
2016-01-23 18:09:55 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
while (true) {
|
|
|
|
Error err = VariantParser::parse_tag(&stream, lines, error_text, next_tag, &rp);
|
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
if (err != OK) {
|
2015-11-24 14:42:05 +01:00
|
|
|
error = ERR_FILE_CORRUPT;
|
2016-01-23 18:09:55 +01:00
|
|
|
ERR_FAIL_V(error);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
if (next_tag.name != "ext_resource") {
|
|
|
|
//nothing was done
|
2022-03-23 10:08:58 +01:00
|
|
|
if (fw.is_null()) {
|
2016-01-23 18:09:55 +01:00
|
|
|
return OK;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2016-01-23 18:09:55 +01:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
} else {
|
2022-03-23 10:08:58 +01:00
|
|
|
if (fw.is_null()) {
|
2015-11-24 14:42:05 +01:00
|
|
|
fw = FileAccess::open(p_path + ".depren", FileAccess::WRITE);
|
2022-12-18 01:05:36 +01:00
|
|
|
|
|
|
|
if (res_uid == ResourceUID::INVALID_ID) {
|
|
|
|
res_uid = ResourceSaver::get_resource_id_for_path(p_path);
|
|
|
|
}
|
|
|
|
|
|
|
|
String uid_text = "";
|
|
|
|
if (res_uid != ResourceUID::INVALID_ID) {
|
|
|
|
uid_text = " uid=\"" + ResourceUID::get_singleton()->id_to_text(res_uid) + "\"";
|
|
|
|
}
|
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
if (is_scene) {
|
2024-04-19 09:55:29 +02:00
|
|
|
fw->store_line("[gd_scene load_steps=" + itos(resources_total) + " format=" + itos(format_version) + uid_text + "]\n");
|
2016-01-23 18:09:55 +01:00
|
|
|
} else {
|
2023-01-19 19:12:25 +01:00
|
|
|
String script_res_text;
|
|
|
|
if (!script_class.is_empty()) {
|
|
|
|
script_res_text = "script_class=\"" + script_class + "\" ";
|
|
|
|
}
|
2024-04-19 09:55:29 +02:00
|
|
|
fw->store_line("[gd_resource type=\"" + res_type + "\" " + script_res_text + "load_steps=" + itos(resources_total) + " format=" + itos(format_version) + uid_text + "]\n");
|
2016-01-23 18:09:55 +01:00
|
|
|
}
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
if (!next_tag.fields.has("path") || !next_tag.fields.has("id") || !next_tag.fields.has("type")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
ERR_FAIL_V(error);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
String path = next_tag.fields["path"];
|
2021-07-21 02:36:56 +02:00
|
|
|
String id = next_tag.fields["id"];
|
2016-01-23 18:09:55 +01:00
|
|
|
String type = next_tag.fields["type"];
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
if (next_tag.fields.has("uid")) {
|
|
|
|
String uidt = next_tag.fields["uid"];
|
|
|
|
ResourceUID::ID uid = ResourceUID::get_singleton()->text_to_id(uidt);
|
|
|
|
if (uid != ResourceUID::INVALID_ID && ResourceUID::get_singleton()->has_id(uid)) {
|
|
|
|
// If a UID is found and the path is valid, it will be used, otherwise, it falls back to the path.
|
|
|
|
path = ResourceUID::get_singleton()->get_id_path(uid);
|
|
|
|
}
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
bool relative = false;
|
|
|
|
if (!path.begins_with("res://")) {
|
2022-08-30 02:34:01 +02:00
|
|
|
path = base_path.path_join(path).simplify_path();
|
2015-11-24 14:42:05 +01:00
|
|
|
relative = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p_map.has(path)) {
|
2023-12-13 17:06:14 +01:00
|
|
|
path = p_map[path];
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (relative) {
|
|
|
|
//restore relative
|
|
|
|
path = base_path.path_to_file(path);
|
|
|
|
}
|
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
String s = "[ext_resource type=\"" + type + "\"";
|
|
|
|
|
|
|
|
ResourceUID::ID uid = ResourceSaver::get_resource_id_for_path(path);
|
|
|
|
if (uid != ResourceUID::INVALID_ID) {
|
|
|
|
s += " uid=\"" + ResourceUID::get_singleton()->id_to_text(uid) + "\"";
|
|
|
|
}
|
|
|
|
s += " path=\"" + path + "\" id=\"" + id + "\"]";
|
|
|
|
fw->store_line(s); // Bundled.
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2017-09-10 15:37:49 +02:00
|
|
|
tag_end = f->get_position();
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
f->seek(tag_end);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2022-12-11 02:43:18 +01:00
|
|
|
const uint32_t buffer_size = 2048;
|
|
|
|
uint8_t *buffer = (uint8_t *)alloca(buffer_size);
|
|
|
|
uint32_t num_read;
|
|
|
|
|
|
|
|
num_read = f->get_buffer(buffer, buffer_size);
|
|
|
|
ERR_FAIL_COND_V_MSG(num_read == UINT32_MAX, ERR_CANT_CREATE, "Failed to allocate memory for buffer.");
|
|
|
|
ERR_FAIL_COND_V(num_read == 0, ERR_FILE_CORRUPT);
|
|
|
|
|
|
|
|
if (*buffer == '\n') {
|
|
|
|
// Skip first newline character since we added one.
|
|
|
|
if (num_read > 1) {
|
|
|
|
fw->store_buffer(buffer + 1, num_read - 1);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fw->store_buffer(buffer, num_read);
|
2020-05-25 23:25:34 +02:00
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
while (!f->eof_reached()) {
|
2022-12-11 02:43:18 +01:00
|
|
|
num_read = f->get_buffer(buffer, buffer_size);
|
|
|
|
fw->store_buffer(buffer, num_read);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool all_ok = fw->get_error() == OK;
|
|
|
|
|
|
|
|
if (!all_ok) {
|
|
|
|
return ERR_CANT_CREATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
void ResourceLoaderText::open(Ref<FileAccess> p_f, bool p_skip_first_tag) {
|
2015-11-24 14:42:05 +01:00
|
|
|
error = OK;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
lines = 1;
|
|
|
|
f = p_f;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
stream.f = f;
|
|
|
|
is_scene = false;
|
2016-06-28 17:35:11 +02:00
|
|
|
ignore_resource_parsing = false;
|
2016-01-29 12:41:22 +01:00
|
|
|
resource_current = 0;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
VariantParser::Tag tag;
|
|
|
|
Error err = VariantParser::parse_tag(&stream, lines, error_text, tag);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
error = err;
|
|
|
|
_printerr();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tag.fields.has("format")) {
|
2024-04-19 09:55:29 +02:00
|
|
|
format_version = tag.fields["format"];
|
|
|
|
if (format_version > FORMAT_VERSION) {
|
2015-11-24 14:42:05 +01:00
|
|
|
error_text = "Saved with newer format version";
|
|
|
|
_printerr();
|
2024-04-12 11:42:08 +02:00
|
|
|
error = ERR_FILE_UNRECOGNIZED;
|
2015-11-24 14:42:05 +01:00
|
|
|
return;
|
|
|
|
}
|
2024-04-19 09:55:29 +02:00
|
|
|
} else {
|
|
|
|
format_version = FORMAT_VERSION;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (tag.name == "gd_scene") {
|
|
|
|
is_scene = true;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
} else if (tag.name == "gd_resource") {
|
|
|
|
if (!tag.fields.has("type")) {
|
|
|
|
error_text = "Missing 'type' field in 'gd_resource' tag";
|
|
|
|
_printerr();
|
|
|
|
error = ERR_PARSE_ERROR;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-01-19 19:12:25 +01:00
|
|
|
if (tag.fields.has("script_class")) {
|
|
|
|
script_class = tag.fields["script_class"];
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
res_type = tag.fields["type"];
|
|
|
|
|
|
|
|
} else {
|
|
|
|
error_text = "Unrecognized file type: " + tag.name;
|
|
|
|
_printerr();
|
|
|
|
error = ERR_PARSE_ERROR;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
if (tag.fields.has("uid")) {
|
|
|
|
res_uid = ResourceUID::get_singleton()->text_to_id(tag.fields["uid"]);
|
|
|
|
} else {
|
|
|
|
res_uid = ResourceUID::INVALID_ID;
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
if (tag.fields.has("load_steps")) {
|
|
|
|
resources_total = tag.fields["load_steps"];
|
|
|
|
} else {
|
|
|
|
resources_total = 0;
|
|
|
|
}
|
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
if (!p_skip_first_tag) {
|
|
|
|
err = VariantParser::parse_tag(&stream, lines, error_text, next_tag, &rp);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2016-01-23 18:09:55 +01:00
|
|
|
if (err) {
|
|
|
|
error_text = "Unexpected end of file";
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
rp.ext_func = _parse_ext_resources;
|
|
|
|
rp.sub_func = _parse_sub_resources;
|
|
|
|
rp.userdata = this;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
Error ResourceLoaderText::get_classes_used(HashSet<StringName> *r_classes) {
|
|
|
|
if (error) {
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
ignore_resource_parsing = true;
|
|
|
|
|
|
|
|
DummyReadData dummy_read;
|
|
|
|
dummy_read.no_placeholders = true;
|
2022-09-29 11:53:28 +02:00
|
|
|
VariantParser::ResourceParser rp_new;
|
|
|
|
rp_new.ext_func = _parse_ext_resource_dummys;
|
|
|
|
rp_new.sub_func = _parse_sub_resource_dummys;
|
|
|
|
rp_new.userdata = &dummy_read;
|
2022-07-14 14:18:18 +02:00
|
|
|
|
|
|
|
while (next_tag.name == "ext_resource") {
|
2022-09-29 11:53:28 +02:00
|
|
|
error = VariantParser::parse_tag(&stream, lines, error_text, next_tag, &rp_new);
|
2022-07-14 14:18:18 +02:00
|
|
|
|
|
|
|
if (error) {
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (next_tag.name == "sub_resource" || next_tag.name == "resource") {
|
|
|
|
if (next_tag.name == "sub_resource") {
|
|
|
|
if (!next_tag.fields.has("type")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Missing 'type' in external resource tag";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
r_classes->insert(next_tag.fields["type"]);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
r_classes->insert(next_tag.fields["res_type"]);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
String assign;
|
|
|
|
Variant value;
|
|
|
|
|
2022-09-29 11:53:28 +02:00
|
|
|
error = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, &rp_new);
|
2022-07-14 14:18:18 +02:00
|
|
|
|
|
|
|
if (error) {
|
|
|
|
if (error == ERR_FILE_EOF) {
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!assign.is_empty()) {
|
|
|
|
continue;
|
|
|
|
} else if (!next_tag.name.is_empty()) {
|
|
|
|
error = OK;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Premature end of file while parsing [sub_resource]";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (next_tag.name == "node") {
|
|
|
|
// This is a node, must save one more!
|
|
|
|
|
|
|
|
if (!is_scene) {
|
|
|
|
error_text += "found the 'node' tag on a resource file!";
|
|
|
|
_printerr();
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!next_tag.fields.has("type")) {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Missing 'type' in external resource tag";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
r_classes->insert(next_tag.fields["type"]);
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
String assign;
|
|
|
|
Variant value;
|
|
|
|
|
2022-09-29 11:53:28 +02:00
|
|
|
error = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, &rp_new);
|
2022-07-14 14:18:18 +02:00
|
|
|
|
|
|
|
if (error) {
|
|
|
|
if (error == ERR_FILE_MISSING_DEPENDENCIES) {
|
|
|
|
// Resource loading error, just skip it.
|
|
|
|
} else if (error != ERR_FILE_EOF) {
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
} else {
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!assign.is_empty()) {
|
|
|
|
continue;
|
|
|
|
} else if (!next_tag.name.is_empty()) {
|
|
|
|
error = OK;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
error = ERR_FILE_CORRUPT;
|
|
|
|
error_text = "Premature end of file while parsing [sub_resource]";
|
|
|
|
_printerr();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2023-01-19 19:12:25 +01:00
|
|
|
String ResourceLoaderText::recognize_script_class(Ref<FileAccess> p_f) {
|
|
|
|
error = OK;
|
|
|
|
|
|
|
|
lines = 1;
|
|
|
|
f = p_f;
|
|
|
|
|
|
|
|
stream.f = f;
|
|
|
|
|
|
|
|
ignore_resource_parsing = true;
|
|
|
|
|
|
|
|
VariantParser::Tag tag;
|
|
|
|
Error err = VariantParser::parse_tag(&stream, lines, error_text, tag);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
_printerr();
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tag.fields.has("format")) {
|
|
|
|
int fmt = tag.fields["format"];
|
|
|
|
if (fmt > FORMAT_VERSION) {
|
|
|
|
error_text = "Saved with newer format version";
|
|
|
|
_printerr();
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tag.name != "gd_resource") {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tag.fields.has("script_class")) {
|
|
|
|
return tag.fields["script_class"];
|
|
|
|
}
|
|
|
|
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
String ResourceLoaderText::recognize(Ref<FileAccess> p_f) {
|
2015-11-24 14:42:05 +01:00
|
|
|
error = OK;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
lines = 1;
|
2015-11-24 14:42:05 +01:00
|
|
|
f = p_f;
|
|
|
|
|
2016-06-28 17:35:11 +02:00
|
|
|
stream.f = f;
|
|
|
|
|
|
|
|
ignore_resource_parsing = true;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
VariantParser::Tag tag;
|
|
|
|
Error err = VariantParser::parse_tag(&stream, lines, error_text, tag);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
_printerr();
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tag.fields.has("format")) {
|
|
|
|
int fmt = tag.fields["format"];
|
|
|
|
if (fmt > FORMAT_VERSION) {
|
|
|
|
error_text = "Saved with newer format version";
|
|
|
|
_printerr();
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (tag.name == "gd_scene") {
|
2015-11-24 14:42:05 +01:00
|
|
|
return "PackedScene";
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (tag.name != "gd_resource") {
|
2015-11-24 14:42:05 +01:00
|
|
|
return "";
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
if (!tag.fields.has("type")) {
|
|
|
|
error_text = "Missing 'type' field in 'gd_resource' tag";
|
|
|
|
_printerr();
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
return tag.fields["type"];
|
|
|
|
}
|
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
ResourceUID::ID ResourceLoaderText::get_uid(Ref<FileAccess> p_f) {
|
2021-07-23 21:01:18 +02:00
|
|
|
error = OK;
|
|
|
|
|
|
|
|
lines = 1;
|
|
|
|
f = p_f;
|
|
|
|
|
|
|
|
stream.f = f;
|
|
|
|
|
|
|
|
ignore_resource_parsing = true;
|
|
|
|
|
|
|
|
VariantParser::Tag tag;
|
|
|
|
Error err = VariantParser::parse_tag(&stream, lines, error_text, tag);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
_printerr();
|
|
|
|
return ResourceUID::INVALID_ID;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tag.fields.has("uid")) { //field is optional
|
|
|
|
String uidt = tag.fields["uid"];
|
|
|
|
return ResourceUID::get_singleton()->text_to_id(uidt);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ResourceUID::INVALID_ID;
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
/////////////////////
|
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
Ref<Resource> ResourceFormatLoaderText::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) {
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_error) {
|
2015-11-24 14:42:05 +01:00
|
|
|
*r_error = ERR_CANT_OPEN;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Error err;
|
2020-02-28 12:27:04 +01:00
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ, &err);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot open file '" + p_path + "'.");
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
ResourceLoaderText loader;
|
2021-12-09 10:42:46 +01:00
|
|
|
String path = !p_original_path.is_empty() ? p_original_path : p_path;
|
2024-02-22 12:53:19 +01:00
|
|
|
switch (p_cache_mode) {
|
|
|
|
case CACHE_MODE_IGNORE:
|
|
|
|
case CACHE_MODE_REUSE:
|
|
|
|
case CACHE_MODE_REPLACE:
|
|
|
|
loader.cache_mode = p_cache_mode;
|
|
|
|
loader.cache_mode_for_external = CACHE_MODE_REUSE;
|
|
|
|
break;
|
|
|
|
case CACHE_MODE_IGNORE_DEEP:
|
|
|
|
loader.cache_mode = ResourceFormatLoader::CACHE_MODE_IGNORE;
|
|
|
|
loader.cache_mode_for_external = p_cache_mode;
|
|
|
|
break;
|
|
|
|
case CACHE_MODE_REPLACE_DEEP:
|
|
|
|
loader.cache_mode = ResourceFormatLoader::CACHE_MODE_REPLACE;
|
|
|
|
loader.cache_mode_for_external = p_cache_mode;
|
|
|
|
break;
|
|
|
|
}
|
2020-02-28 12:27:04 +01:00
|
|
|
loader.use_sub_threads = p_use_sub_threads;
|
|
|
|
loader.local_path = ProjectSettings::get_singleton()->localize_path(path);
|
|
|
|
loader.progress = r_progress;
|
|
|
|
loader.res_path = loader.local_path;
|
|
|
|
loader.open(f);
|
|
|
|
err = loader.load();
|
|
|
|
if (r_error) {
|
|
|
|
*r_error = err;
|
|
|
|
}
|
|
|
|
if (err == OK) {
|
|
|
|
return loader.get_resource();
|
|
|
|
} else {
|
2022-05-03 01:43:50 +02:00
|
|
|
return Ref<Resource>();
|
2020-02-28 12:27:04 +01:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void ResourceFormatLoaderText::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
|
2021-12-09 10:42:46 +01:00
|
|
|
if (p_type.is_empty()) {
|
2015-12-09 17:56:14 +01:00
|
|
|
get_recognized_extensions(p_extensions);
|
|
|
|
return;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2022-05-02 23:21:15 +02:00
|
|
|
if (ClassDB::is_parent_class("PackedScene", p_type)) {
|
2015-11-24 14:42:05 +01:00
|
|
|
p_extensions->push_back("tscn");
|
2022-05-02 23:21:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Don't allow .tres for PackedScenes.
|
|
|
|
if (p_type != "PackedScene") {
|
2015-11-24 14:42:05 +01:00
|
|
|
p_extensions->push_back("tres");
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void ResourceFormatLoaderText::get_recognized_extensions(List<String> *p_extensions) const {
|
|
|
|
p_extensions->push_back("tscn");
|
|
|
|
p_extensions->push_back("tres");
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ResourceFormatLoaderText::handles_type(const String &p_type) const {
|
|
|
|
return true;
|
|
|
|
}
|
2020-05-14 14:29:06 +02:00
|
|
|
|
2022-07-14 14:18:18 +02:00
|
|
|
void ResourceFormatLoaderText::get_classes_used(const String &p_path, HashSet<StringName> *r_classes) {
|
|
|
|
String ext = p_path.get_extension().to_lower();
|
|
|
|
if (ext == "tscn") {
|
|
|
|
r_classes->insert("PackedScene");
|
|
|
|
}
|
|
|
|
|
|
|
|
// ...for anything else must test...
|
|
|
|
|
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
|
|
|
if (f.is_null()) {
|
|
|
|
return; // Could not read.
|
|
|
|
}
|
|
|
|
|
|
|
|
ResourceLoaderText loader;
|
|
|
|
loader.local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
|
|
|
loader.res_path = loader.local_path;
|
|
|
|
loader.open(f);
|
|
|
|
loader.get_classes_used(r_classes);
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
String ResourceFormatLoaderText::get_resource_type(const String &p_path) const {
|
2017-01-14 04:51:09 +01:00
|
|
|
String ext = p_path.get_extension().to_lower();
|
2020-05-14 16:41:43 +02:00
|
|
|
if (ext == "tscn") {
|
2015-11-24 14:42:05 +01:00
|
|
|
return "PackedScene";
|
2020-05-14 16:41:43 +02:00
|
|
|
} else if (ext != "tres") {
|
2015-11-29 00:56:14 +01:00
|
|
|
return String();
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
Fix various typos with codespell
Found via `codespell -q 3 -S ./thirdparty,*.po,./DONORS.md -L ackward,ang,ans,ba,beng,cas,childs,childrens,dof,doubleclick,fave,findn,hist,inout,leapyear,lod,nd,numer,ois,ony,paket,seeked,sinc,switchs,te,uint`
2021-07-07 17:17:32 +02:00
|
|
|
// ...for anything else must test...
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
|
|
|
if (f.is_null()) {
|
2021-03-12 14:35:16 +01:00
|
|
|
return ""; //could not read
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
ResourceLoaderText loader;
|
|
|
|
loader.local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
|
|
|
loader.res_path = loader.local_path;
|
|
|
|
String r = loader.recognize(f);
|
2019-10-03 22:39:08 +02:00
|
|
|
return ClassDB::get_compatibility_remapped_class(r);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2023-01-19 19:12:25 +01:00
|
|
|
String ResourceFormatLoaderText::get_resource_script_class(const String &p_path) const {
|
|
|
|
String ext = p_path.get_extension().to_lower();
|
|
|
|
if (ext != "tres") {
|
|
|
|
return String();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ...for anything else must test...
|
|
|
|
|
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
|
|
|
if (f.is_null()) {
|
|
|
|
return ""; //could not read
|
|
|
|
}
|
|
|
|
|
|
|
|
ResourceLoaderText loader;
|
|
|
|
loader.local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
|
|
|
loader.res_path = loader.local_path;
|
|
|
|
return loader.recognize_script_class(f);
|
|
|
|
}
|
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
ResourceUID::ID ResourceFormatLoaderText::get_resource_uid(const String &p_path) const {
|
|
|
|
String ext = p_path.get_extension().to_lower();
|
|
|
|
|
|
|
|
if (ext != "tscn" && ext != "tres") {
|
|
|
|
return ResourceUID::INVALID_ID;
|
|
|
|
}
|
|
|
|
|
2022-03-23 10:08:58 +01:00
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
|
|
|
if (f.is_null()) {
|
2021-07-23 21:01:18 +02:00
|
|
|
return ResourceUID::INVALID_ID; //could not read
|
|
|
|
}
|
|
|
|
|
|
|
|
ResourceLoaderText loader;
|
|
|
|
loader.local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
|
|
|
loader.res_path = loader.local_path;
|
|
|
|
return loader.get_uid(f);
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
void ResourceFormatLoaderText::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
|
2022-03-23 10:08:58 +01:00
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
|
|
|
if (f.is_null()) {
|
2015-11-24 14:42:05 +01:00
|
|
|
ERR_FAIL();
|
|
|
|
}
|
|
|
|
|
2020-02-28 12:27:04 +01:00
|
|
|
ResourceLoaderText loader;
|
|
|
|
loader.local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
|
|
|
loader.res_path = loader.local_path;
|
|
|
|
loader.get_dependencies(f, p_dependencies, p_add_types);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2022-05-13 15:04:37 +02:00
|
|
|
Error ResourceFormatLoaderText::rename_dependencies(const String &p_path, const HashMap<String, String> &p_map) {
|
2022-05-02 15:37:50 +02:00
|
|
|
Error err = OK;
|
|
|
|
{
|
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
|
|
|
|
if (f.is_null()) {
|
|
|
|
ERR_FAIL_V(ERR_CANT_OPEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
ResourceLoaderText loader;
|
|
|
|
loader.local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
|
|
|
loader.res_path = loader.local_path;
|
|
|
|
err = loader.rename_dependencies(f, p_path, p_map);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2023-12-14 22:28:48 +01:00
|
|
|
Ref<DirAccess> da = DirAccess::create(DirAccess::ACCESS_RESOURCES);
|
|
|
|
if (err == OK && da->file_exists(p_path + ".depren")) {
|
2022-05-02 15:37:50 +02:00
|
|
|
da->remove(p_path);
|
|
|
|
da->rename(p_path + ".depren", p_path);
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
ResourceFormatLoaderText *ResourceFormatLoaderText::singleton = nullptr;
|
2018-01-30 15:03:46 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
/*****************************************************************************************************/
|
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
String ResourceFormatSaverTextInstance::_write_resources(void *ud, const Ref<Resource> &p_resource) {
|
2022-04-05 12:40:26 +02:00
|
|
|
ResourceFormatSaverTextInstance *rsi = static_cast<ResourceFormatSaverTextInstance *>(ud);
|
2015-12-31 04:31:00 +01:00
|
|
|
return rsi->_write_resource(p_resource);
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
String ResourceFormatSaverTextInstance::_write_resource(const Ref<Resource> &res) {
|
2023-07-01 01:29:46 +02:00
|
|
|
if (res->get_meta(SNAME("_skip_save_"), false)) {
|
|
|
|
return "null";
|
|
|
|
}
|
|
|
|
|
2015-12-31 04:31:00 +01:00
|
|
|
if (external_resources.has(res)) {
|
2022-06-19 05:54:03 +02:00
|
|
|
return "ExtResource(\"" + external_resources[res] + "\")";
|
2015-12-31 04:31:00 +01:00
|
|
|
} else {
|
|
|
|
if (internal_resources.has(res)) {
|
2022-06-19 05:54:03 +02:00
|
|
|
return "SubResource(\"" + internal_resources[res] + "\")";
|
2021-07-10 21:17:41 +02:00
|
|
|
} else if (!res->is_built_in()) {
|
2019-02-24 14:45:08 +01:00
|
|
|
if (res->get_path() == local_path) { //circular reference attempt
|
|
|
|
return "null";
|
|
|
|
}
|
2015-12-31 04:31:00 +01:00
|
|
|
//external resource
|
|
|
|
String path = relative_paths ? local_path.path_to_file(res->get_path()) : res->get_path();
|
2022-06-19 05:54:03 +02:00
|
|
|
return "Resource(\"" + path + "\")";
|
2015-12-31 04:31:00 +01:00
|
|
|
} else {
|
2019-08-08 22:11:48 +02:00
|
|
|
ERR_FAIL_V_MSG("null", "Resource was not pre cached for the resource section, bug?");
|
2015-12-31 04:31:00 +01:00
|
|
|
//internal resource
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ResourceFormatSaverTextInstance::_find_resources(const Variant &p_variant, bool p_main) {
|
|
|
|
switch (p_variant.get_type()) {
|
|
|
|
case Variant::OBJECT: {
|
2022-05-03 01:43:50 +02:00
|
|
|
Ref<Resource> res = p_variant;
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2023-07-01 01:29:46 +02:00
|
|
|
if (res.is_null() || external_resources.has(res) || res->get_meta(SNAME("_skip_save_"), false)) {
|
2015-10-10 14:09:09 +02:00
|
|
|
return;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2021-07-10 21:17:41 +02:00
|
|
|
if (!p_main && (!bundle_resources) && !res->is_built_in()) {
|
2019-02-24 14:45:08 +01:00
|
|
|
if (res->get_path() == local_path) {
|
2019-11-06 17:03:04 +01:00
|
|
|
ERR_PRINT("Circular reference to resource being saved found: '" + local_path + "' will be null next time it's loaded.");
|
2019-02-24 14:45:08 +01:00
|
|
|
return;
|
|
|
|
}
|
2021-07-21 02:36:56 +02:00
|
|
|
|
|
|
|
// Use a numeric ID as a base, because they are sorted in natural order before saving.
|
|
|
|
// This increases the chances of thread loading to fetch them first.
|
|
|
|
String id = itos(external_resources.size() + 1) + "_" + Resource::generate_scene_unique_id();
|
|
|
|
external_resources[res] = id;
|
2015-10-10 14:09:09 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (resource_set.has(res)) {
|
2015-10-10 14:09:09 +02:00
|
|
|
return;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2023-02-17 11:18:58 +01:00
|
|
|
resource_set.insert(res);
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
List<PropertyInfo> property_list;
|
|
|
|
|
|
|
|
res->get_property_list(&property_list);
|
|
|
|
property_list.sort();
|
|
|
|
|
|
|
|
List<PropertyInfo>::Element *I = property_list.front();
|
|
|
|
|
|
|
|
while (I) {
|
|
|
|
PropertyInfo pi = I->get();
|
|
|
|
|
2017-01-03 04:38:16 +01:00
|
|
|
if (pi.usage & PROPERTY_USAGE_STORAGE) {
|
2015-10-10 14:09:09 +02:00
|
|
|
Variant v = res->get(I->get().name);
|
2019-02-22 00:49:42 +01:00
|
|
|
|
|
|
|
if (pi.usage & PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT) {
|
2022-12-17 22:20:27 +01:00
|
|
|
NonPersistentKey npk;
|
|
|
|
npk.base = res;
|
|
|
|
npk.property = pi.name;
|
|
|
|
non_persistent_map[npk] = v;
|
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
Ref<Resource> sres = v;
|
2019-02-22 00:49:42 +01:00
|
|
|
if (sres.is_valid()) {
|
|
|
|
resource_set.insert(sres);
|
|
|
|
saved_resources.push_back(sres);
|
2022-12-17 22:20:27 +01:00
|
|
|
} else {
|
|
|
|
_find_resources(v);
|
2019-02-22 00:49:42 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
_find_resources(v);
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
I = I->next();
|
|
|
|
}
|
|
|
|
|
2023-02-17 11:18:58 +01:00
|
|
|
saved_resources.push_back(res); // Saved after, so the children it needs are available when loaded
|
2015-10-10 14:09:09 +02:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::ARRAY: {
|
|
|
|
Array varray = p_variant;
|
2023-11-17 18:27:42 +01:00
|
|
|
_find_resources(varray.get_typed_script());
|
2023-12-24 13:44:21 +01:00
|
|
|
for (const Variant &var : varray) {
|
|
|
|
_find_resources(var);
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::DICTIONARY: {
|
|
|
|
Dictionary d = p_variant;
|
|
|
|
List<Variant> keys;
|
|
|
|
d.get_key_list(&keys);
|
2021-07-24 15:46:25 +02:00
|
|
|
for (const Variant &E : keys) {
|
2022-08-24 05:43:22 +02:00
|
|
|
// Of course keys should also be cached, after all we can't prevent users from using resources as keys, right?
|
|
|
|
// See also ResourceFormatSaverBinaryInstance::_find_resources (when p_variant is of type Variant::DICTIONARY)
|
|
|
|
_find_resources(E);
|
2021-07-16 05:45:57 +02:00
|
|
|
Variant v = d[E];
|
2015-10-10 14:09:09 +02:00
|
|
|
_find_resources(v);
|
|
|
|
}
|
|
|
|
} break;
|
2024-04-19 09:55:29 +02:00
|
|
|
case Variant::PACKED_BYTE_ARRAY: {
|
|
|
|
// Balance between compatibility and performance.
|
|
|
|
if (use_compat && p_variant.operator PackedByteArray().size() > 64) {
|
|
|
|
use_compat = false;
|
|
|
|
}
|
|
|
|
} break;
|
2024-04-08 16:51:34 +02:00
|
|
|
case Variant::PACKED_VECTOR4_ARRAY: {
|
|
|
|
use_compat = false;
|
|
|
|
} break;
|
2019-04-09 17:08:36 +02:00
|
|
|
default: {
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
static String _resource_get_class(Ref<Resource> p_resource) {
|
|
|
|
Ref<MissingResource> missing_resource = p_resource;
|
|
|
|
if (missing_resource.is_valid()) {
|
|
|
|
return missing_resource->get_original_class();
|
|
|
|
} else {
|
|
|
|
return p_resource->get_class();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
Error ResourceFormatSaverTextInstance::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
|
2015-10-10 14:09:09 +02:00
|
|
|
if (p_path.ends_with(".tscn")) {
|
|
|
|
packed_scene = p_resource;
|
|
|
|
}
|
|
|
|
|
|
|
|
Error err;
|
2022-03-23 10:08:58 +01:00
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::WRITE, &err);
|
2019-09-25 10:28:50 +02:00
|
|
|
ERR_FAIL_COND_V_MSG(err, ERR_CANT_OPEN, "Cannot save file '" + p_path + "'.");
|
2022-03-23 10:08:58 +01:00
|
|
|
Ref<FileAccess> _fref(f);
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2017-07-19 22:00:46 +02:00
|
|
|
local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
2015-10-10 14:09:09 +02:00
|
|
|
|
|
|
|
relative_paths = p_flags & ResourceSaver::FLAG_RELATIVE_PATHS;
|
|
|
|
skip_editor = p_flags & ResourceSaver::FLAG_OMIT_EDITOR_PROPERTIES;
|
|
|
|
bundle_resources = p_flags & ResourceSaver::FLAG_BUNDLE_RESOURCES;
|
|
|
|
takeover_paths = p_flags & ResourceSaver::FLAG_REPLACE_SUBRESOURCE_PATHS;
|
|
|
|
if (!p_path.begins_with("res://")) {
|
|
|
|
takeover_paths = false;
|
|
|
|
}
|
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
// Save resources.
|
2024-04-19 09:55:29 +02:00
|
|
|
use_compat = true; // _find_resources() changes this.
|
2015-10-10 14:09:09 +02:00
|
|
|
_find_resources(p_resource, true);
|
|
|
|
|
|
|
|
if (packed_scene.is_valid()) {
|
2021-07-21 02:36:56 +02:00
|
|
|
// Add instances to external resources if saving a packed scene.
|
2015-10-10 14:09:09 +02:00
|
|
|
for (int i = 0; i < packed_scene->get_state()->get_node_count(); i++) {
|
2020-05-14 16:41:43 +02:00
|
|
|
if (packed_scene->get_state()->is_node_instance_placeholder(i)) {
|
2016-02-21 15:17:50 +01:00
|
|
|
continue;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2016-02-21 15:17:50 +01:00
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
Ref<PackedScene> instance = packed_scene->get_state()->get_node_instance(i);
|
2015-10-10 14:09:09 +02:00
|
|
|
if (instance.is_valid() && !external_resources.has(instance)) {
|
2021-07-21 02:36:56 +02:00
|
|
|
int index = external_resources.size() + 1;
|
|
|
|
external_resources[instance] = itos(index) + "_" + Resource::generate_scene_unique_id(); // Keep the order for improved thread loading performance.
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
String title = packed_scene.is_valid() ? "[gd_scene " : "[gd_resource ";
|
2020-05-14 16:41:43 +02:00
|
|
|
if (packed_scene.is_null()) {
|
2022-04-28 22:49:10 +02:00
|
|
|
title += "type=\"" + _resource_get_class(p_resource) + "\" ";
|
2023-01-19 19:12:25 +01:00
|
|
|
Ref<Script> script = p_resource->get_script();
|
|
|
|
if (script.is_valid() && script->get_global_name()) {
|
|
|
|
title += "script_class=\"" + String(script->get_global_name()) + "\" ";
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2023-01-19 19:12:25 +01:00
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
int load_steps = saved_resources.size() + external_resources.size();
|
|
|
|
|
|
|
|
if (load_steps > 1) {
|
|
|
|
title += "load_steps=" + itos(load_steps) + " ";
|
|
|
|
}
|
2024-04-19 09:55:29 +02:00
|
|
|
title += "format=" + itos(use_compat ? FORMAT_VERSION_COMPAT : FORMAT_VERSION) + "";
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
ResourceUID::ID uid = ResourceSaver::get_resource_id_for_path(local_path, true);
|
|
|
|
|
|
|
|
if (uid != ResourceUID::INVALID_ID) {
|
|
|
|
title += " uid=\"" + ResourceUID::get_singleton()->id_to_text(uid) + "\"";
|
|
|
|
}
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
f->store_string(title);
|
2021-07-21 02:36:56 +02:00
|
|
|
f->store_line("]\n"); // One empty line.
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2019-04-11 19:35:23 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
2021-07-21 02:36:56 +02:00
|
|
|
// Keep order from cached ids.
|
2022-05-19 17:00:06 +02:00
|
|
|
HashSet<String> cached_ids_found;
|
2022-05-03 01:43:50 +02:00
|
|
|
for (KeyValue<Ref<Resource>, String> &E : external_resources) {
|
2021-08-09 22:13:42 +02:00
|
|
|
String cached_id = E.key->get_id_for_path(local_path);
|
2021-12-09 10:42:46 +01:00
|
|
|
if (cached_id.is_empty() || cached_ids_found.has(cached_id)) {
|
2021-08-09 22:13:42 +02:00
|
|
|
int sep_pos = E.value.find("_");
|
2021-07-21 02:36:56 +02:00
|
|
|
if (sep_pos != -1) {
|
2021-08-09 22:13:42 +02:00
|
|
|
E.value = E.value.substr(0, sep_pos + 1); // Keep the order found, for improved thread loading performance.
|
2021-07-21 02:36:56 +02:00
|
|
|
} else {
|
2021-08-09 22:13:42 +02:00
|
|
|
E.value = "";
|
2021-07-21 02:36:56 +02:00
|
|
|
}
|
|
|
|
|
2019-04-11 19:35:23 +02:00
|
|
|
} else {
|
2021-08-09 22:13:42 +02:00
|
|
|
E.value = cached_id;
|
2019-04-11 19:35:23 +02:00
|
|
|
cached_ids_found.insert(cached_id);
|
|
|
|
}
|
|
|
|
}
|
2021-07-21 02:36:56 +02:00
|
|
|
// Create IDs for non cached resources.
|
2022-05-03 01:43:50 +02:00
|
|
|
for (KeyValue<Ref<Resource>, String> &E : external_resources) {
|
2021-08-09 22:13:42 +02:00
|
|
|
if (cached_ids_found.has(E.value)) { // Already cached, go on.
|
2019-04-11 19:35:23 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
String attempt;
|
|
|
|
while (true) {
|
2021-08-09 22:13:42 +02:00
|
|
|
attempt = E.value + Resource::generate_scene_unique_id();
|
2021-07-21 02:36:56 +02:00
|
|
|
if (!cached_ids_found.has(attempt)) {
|
|
|
|
break;
|
|
|
|
}
|
2019-04-11 19:35:23 +02:00
|
|
|
}
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2019-04-11 19:35:23 +02:00
|
|
|
cached_ids_found.insert(attempt);
|
2021-08-09 22:13:42 +02:00
|
|
|
E.value = attempt;
|
2021-07-21 02:36:56 +02:00
|
|
|
// Update also in resource.
|
2021-08-09 22:13:42 +02:00
|
|
|
Ref<Resource> res = E.key;
|
2019-05-20 13:51:51 +02:00
|
|
|
res->set_id_for_path(local_path, attempt);
|
2019-04-11 19:35:23 +02:00
|
|
|
}
|
|
|
|
#else
|
2021-07-21 02:36:56 +02:00
|
|
|
// Make sure to start from one, as it makes format more readable.
|
|
|
|
int counter = 1;
|
2022-05-03 01:43:50 +02:00
|
|
|
for (KeyValue<Ref<Resource>, String> &E : external_resources) {
|
2021-08-09 22:13:42 +02:00
|
|
|
E.value = itos(counter++);
|
2019-04-11 19:35:23 +02:00
|
|
|
}
|
|
|
|
#endif
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2019-04-11 19:35:23 +02:00
|
|
|
Vector<ResourceSort> sorted_er;
|
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
for (const KeyValue<Ref<Resource>, String> &E : external_resources) {
|
2019-04-11 19:35:23 +02:00
|
|
|
ResourceSort rs;
|
2021-08-09 22:13:42 +02:00
|
|
|
rs.resource = E.key;
|
|
|
|
rs.id = E.value;
|
2019-04-11 19:35:23 +02:00
|
|
|
sorted_er.push_back(rs);
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2019-04-11 19:35:23 +02:00
|
|
|
sorted_er.sort();
|
|
|
|
|
2015-12-31 04:31:00 +01:00
|
|
|
for (int i = 0; i < sorted_er.size(); i++) {
|
2019-04-11 19:35:23 +02:00
|
|
|
String p = sorted_er[i].resource->get_path();
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2021-07-23 21:01:18 +02:00
|
|
|
String s = "[ext_resource type=\"" + sorted_er[i].resource->get_save_class() + "\"";
|
|
|
|
|
|
|
|
ResourceUID::ID uid = ResourceSaver::get_resource_id_for_path(p, false);
|
|
|
|
if (uid != ResourceUID::INVALID_ID) {
|
|
|
|
s += " uid=\"" + ResourceUID::get_singleton()->id_to_text(uid) + "\"";
|
|
|
|
}
|
|
|
|
s += " path=\"" + p + "\" id=\"" + sorted_er[i].id + "\"]\n";
|
|
|
|
f->store_string(s); // Bundled.
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (external_resources.size()) {
|
2021-07-21 02:36:56 +02:00
|
|
|
f->store_line(String()); // Separate.
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2022-05-19 17:00:06 +02:00
|
|
|
HashSet<String> used_unique_ids;
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
for (List<Ref<Resource>>::Element *E = saved_resources.front(); E; E = E->next()) {
|
|
|
|
Ref<Resource> res = E->get();
|
2021-07-10 21:17:41 +02:00
|
|
|
if (E->next() && res->is_built_in()) {
|
2021-12-09 10:42:46 +01:00
|
|
|
if (!res->get_scene_unique_id().is_empty()) {
|
2021-07-21 02:36:56 +02:00
|
|
|
if (used_unique_ids.has(res->get_scene_unique_id())) {
|
|
|
|
res->set_scene_unique_id(""); // Repeated.
|
2015-10-10 14:09:09 +02:00
|
|
|
} else {
|
2021-07-21 02:36:56 +02:00
|
|
|
used_unique_ids.insert(res->get_scene_unique_id());
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
for (List<Ref<Resource>>::Element *E = saved_resources.front(); E; E = E->next()) {
|
|
|
|
Ref<Resource> res = E->get();
|
2015-10-10 14:09:09 +02:00
|
|
|
ERR_CONTINUE(!resource_set.has(res));
|
2020-04-02 01:20:12 +02:00
|
|
|
bool main = (E->next() == nullptr);
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (main && packed_scene.is_valid()) {
|
2021-07-21 02:36:56 +02:00
|
|
|
break; // Save as a scene.
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
|
|
|
if (main) {
|
2019-02-10 16:07:19 +01:00
|
|
|
f->store_line("[resource]");
|
2015-10-10 14:09:09 +02:00
|
|
|
} else {
|
|
|
|
String line = "[sub_resource ";
|
2021-12-09 10:42:46 +01:00
|
|
|
if (res->get_scene_unique_id().is_empty()) {
|
2021-07-21 02:36:56 +02:00
|
|
|
String new_id;
|
|
|
|
while (true) {
|
2022-04-28 22:49:10 +02:00
|
|
|
new_id = _resource_get_class(res) + "_" + Resource::generate_scene_unique_id();
|
2021-07-21 02:36:56 +02:00
|
|
|
|
|
|
|
if (!used_unique_ids.has(new_id)) {
|
|
|
|
break;
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
res->set_scene_unique_id(new_id);
|
|
|
|
used_unique_ids.insert(new_id);
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
String id = res->get_scene_unique_id();
|
2022-04-28 22:49:10 +02:00
|
|
|
line += "type=\"" + _resource_get_class(res) + "\" id=\"" + id;
|
2021-07-21 02:36:56 +02:00
|
|
|
f->store_line(line + "\"]");
|
2015-10-10 14:09:09 +02:00
|
|
|
if (takeover_paths) {
|
2021-07-21 02:36:56 +02:00
|
|
|
res->set_path(p_path + "::" + id, true);
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2021-07-21 02:36:56 +02:00
|
|
|
internal_resources[res] = id;
|
2016-08-31 22:58:51 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
res->set_edited(false);
|
|
|
|
#endif
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2022-04-28 22:49:10 +02:00
|
|
|
Dictionary missing_resource_properties = p_resource->get_meta(META_MISSING_RESOURCES, Dictionary());
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
List<PropertyInfo> property_list;
|
|
|
|
res->get_property_list(&property_list);
|
|
|
|
for (List<PropertyInfo>::Element *PE = property_list.front(); PE; PE = PE->next()) {
|
2020-05-14 16:41:43 +02:00
|
|
|
if (skip_editor && PE->get().name.begins_with("__editor")) {
|
2015-10-10 14:09:09 +02:00
|
|
|
continue;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2022-04-28 22:49:10 +02:00
|
|
|
if (PE->get().name == META_PROPERTY_MISSING_RESOURCES) {
|
|
|
|
continue;
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2017-01-03 04:38:16 +01:00
|
|
|
if (PE->get().usage & PROPERTY_USAGE_STORAGE) {
|
2015-10-10 14:09:09 +02:00
|
|
|
String name = PE->get().name;
|
2019-02-22 00:49:42 +01:00
|
|
|
Variant value;
|
|
|
|
if (PE->get().usage & PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT) {
|
|
|
|
NonPersistentKey npk;
|
|
|
|
npk.base = res;
|
|
|
|
npk.property = name;
|
|
|
|
if (non_persistent_map.has(npk)) {
|
|
|
|
value = non_persistent_map[npk];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
value = res->get(name);
|
|
|
|
}
|
2022-04-28 22:49:10 +02:00
|
|
|
|
|
|
|
if (PE->get().type == Variant::OBJECT && missing_resource_properties.has(PE->get().name)) {
|
2022-05-23 21:32:19 +02:00
|
|
|
// Was this missing resource overridden? If so do not save the old value.
|
2022-04-28 22:49:10 +02:00
|
|
|
Ref<Resource> ures = value;
|
|
|
|
if (ures.is_null()) {
|
|
|
|
value = missing_resource_properties[PE->get().name];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-08 15:30:02 +01:00
|
|
|
Variant default_value = ClassDB::class_get_default_property_value(res->get_class(), name);
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2018-11-08 15:30:02 +01:00
|
|
|
if (default_value.get_type() != Variant::NIL && bool(Variant::evaluate(Variant::OP_EQUAL, value, default_value))) {
|
2015-10-10 14:09:09 +02:00
|
|
|
continue;
|
2018-11-08 15:30:02 +01:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (PE->get().type == Variant::OBJECT && value.is_zero() && !(PE->get().usage & PROPERTY_USAGE_STORE_IF_NULL)) {
|
2015-10-10 14:09:09 +02:00
|
|
|
continue;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2015-12-31 04:31:00 +01:00
|
|
|
String vars;
|
2024-04-19 09:55:29 +02:00
|
|
|
VariantWriter::write_to_string(value, vars, _write_resources, this, use_compat);
|
2019-12-20 03:03:15 +01:00
|
|
|
f->store_string(name.property_name_encode() + " = " + vars + "\n");
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (E->next()) {
|
2019-03-01 22:52:53 +01:00
|
|
|
f->store_line(String());
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (packed_scene.is_valid()) {
|
2021-07-21 02:36:56 +02:00
|
|
|
// If this is a scene, save nodes and connections!
|
2015-10-10 14:09:09 +02:00
|
|
|
Ref<SceneState> state = packed_scene->get_state();
|
|
|
|
for (int i = 0; i < state->get_node_count(); i++) {
|
|
|
|
StringName type = state->get_node_type(i);
|
|
|
|
StringName name = state->get_node_name(i);
|
2017-12-08 15:05:15 +01:00
|
|
|
int index = state->get_node_index(i);
|
2015-10-10 14:09:09 +02:00
|
|
|
NodePath path = state->get_node_path(i, true);
|
|
|
|
NodePath owner = state->get_node_owner_path(i);
|
|
|
|
Ref<PackedScene> instance = state->get_node_instance(i);
|
2016-02-21 15:17:50 +01:00
|
|
|
String instance_placeholder = state->get_node_instance_placeholder(i);
|
2015-10-10 14:09:09 +02:00
|
|
|
Vector<StringName> groups = state->get_node_groups(i);
|
2022-06-19 00:42:02 +02:00
|
|
|
Vector<String> deferred_node_paths = state->get_node_deferred_nodepath_properties(i);
|
2015-10-10 14:09:09 +02:00
|
|
|
|
|
|
|
String header = "[node";
|
2019-06-03 15:54:41 +02:00
|
|
|
header += " name=\"" + String(name).c_escape() + "\"";
|
2015-10-10 14:09:09 +02:00
|
|
|
if (type != StringName()) {
|
|
|
|
header += " type=\"" + String(type) + "\"";
|
|
|
|
}
|
|
|
|
if (path != NodePath()) {
|
2019-06-03 15:54:41 +02:00
|
|
|
header += " parent=\"" + String(path.simplified()).c_escape() + "\"";
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
if (owner != NodePath() && owner != NodePath(".")) {
|
2019-06-03 15:54:41 +02:00
|
|
|
header += " owner=\"" + String(owner.simplified()).c_escape() + "\"";
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
2017-12-08 15:05:15 +01:00
|
|
|
if (index >= 0) {
|
|
|
|
header += " index=\"" + itos(index) + "\"";
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2022-06-19 00:42:02 +02:00
|
|
|
if (deferred_node_paths.size()) {
|
|
|
|
header += " node_paths=" + Variant(deferred_node_paths).get_construct_string();
|
|
|
|
}
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
if (groups.size()) {
|
2021-08-31 17:06:18 +02:00
|
|
|
// Write all groups on the same line as they're part of a section header.
|
|
|
|
// This improves readability while not impacting VCS friendliness too much,
|
|
|
|
// since it's rare to have more than 5 groups assigned to a single node.
|
2019-09-07 15:54:53 +02:00
|
|
|
groups.sort_custom<StringName::AlphCompare>();
|
2021-08-31 17:06:18 +02:00
|
|
|
String sgroups = " groups=[";
|
2015-10-10 14:09:09 +02:00
|
|
|
for (int j = 0; j < groups.size(); j++) {
|
2021-08-31 17:06:18 +02:00
|
|
|
sgroups += "\"" + String(groups[j]).c_escape() + "\"";
|
|
|
|
if (j < groups.size() - 1) {
|
|
|
|
sgroups += ", ";
|
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
2017-01-16 18:03:38 +01:00
|
|
|
sgroups += "]";
|
2015-10-10 14:09:09 +02:00
|
|
|
header += sgroups;
|
|
|
|
}
|
|
|
|
|
|
|
|
f->store_string(header);
|
|
|
|
|
2021-12-09 10:42:46 +01:00
|
|
|
if (!instance_placeholder.is_empty()) {
|
2016-02-21 15:17:50 +01:00
|
|
|
String vars;
|
|
|
|
f->store_string(" instance_placeholder=");
|
2024-04-19 09:55:29 +02:00
|
|
|
VariantWriter::write_to_string(instance_placeholder, vars, _write_resources, this, use_compat);
|
2016-02-21 15:17:50 +01:00
|
|
|
f->store_string(vars);
|
|
|
|
}
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
if (instance.is_valid()) {
|
2015-12-31 04:31:00 +01:00
|
|
|
String vars;
|
2015-10-10 14:09:09 +02:00
|
|
|
f->store_string(" instance=");
|
2024-04-19 09:55:29 +02:00
|
|
|
VariantWriter::write_to_string(instance, vars, _write_resources, this, use_compat);
|
2015-12-31 04:31:00 +01:00
|
|
|
f->store_string(vars);
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2018-03-25 23:09:19 +02:00
|
|
|
f->store_line("]");
|
2015-10-10 14:09:09 +02:00
|
|
|
|
|
|
|
for (int j = 0; j < state->get_node_property_count(i); j++) {
|
2015-12-31 04:31:00 +01:00
|
|
|
String vars;
|
2024-04-19 09:55:29 +02:00
|
|
|
VariantWriter::write_to_string(state->get_node_property_value(i, j), vars, _write_resources, this, use_compat);
|
2015-10-10 14:09:09 +02:00
|
|
|
|
2019-12-20 03:03:15 +01:00
|
|
|
f->store_string(String(state->get_node_property_name(i, j)).property_name_encode() + " = " + vars + "\n");
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (i < state->get_node_count() - 1) {
|
2019-03-01 22:52:53 +01:00
|
|
|
f->store_line(String());
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < state->get_connection_count(); i++) {
|
2020-09-29 13:01:01 +02:00
|
|
|
if (i == 0) {
|
|
|
|
f->store_line("");
|
|
|
|
}
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
String connstr = "[connection";
|
2023-12-22 05:35:24 +01:00
|
|
|
connstr += " signal=\"" + String(state->get_connection_signal(i)).c_escape() + "\"";
|
|
|
|
connstr += " from=\"" + String(state->get_connection_source(i).simplified()).c_escape() + "\"";
|
|
|
|
connstr += " to=\"" + String(state->get_connection_target(i).simplified()).c_escape() + "\"";
|
|
|
|
connstr += " method=\"" + String(state->get_connection_method(i)).c_escape() + "\"";
|
2015-10-10 14:09:09 +02:00
|
|
|
int flags = state->get_connection_flags(i);
|
|
|
|
if (flags != Object::CONNECT_PERSIST) {
|
|
|
|
connstr += " flags=" + itos(flags);
|
|
|
|
}
|
|
|
|
|
2021-10-01 02:40:07 +02:00
|
|
|
int unbinds = state->get_connection_unbinds(i);
|
|
|
|
if (unbinds > 0) {
|
|
|
|
connstr += " unbinds=" + itos(unbinds);
|
|
|
|
}
|
|
|
|
|
2015-10-10 14:09:09 +02:00
|
|
|
Array binds = state->get_connection_binds(i);
|
|
|
|
f->store_string(connstr);
|
2016-01-06 12:56:06 +01:00
|
|
|
if (binds.size()) {
|
2015-12-31 04:31:00 +01:00
|
|
|
String vars;
|
2024-04-19 09:55:29 +02:00
|
|
|
VariantWriter::write_to_string(binds, vars, _write_resources, this, use_compat);
|
2016-01-06 12:56:06 +01:00
|
|
|
f->store_string(" binds= " + vars);
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2018-03-25 23:09:19 +02:00
|
|
|
f->store_line("]");
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Vector<NodePath> editable_instances = state->get_editable_instances();
|
|
|
|
for (int i = 0; i < editable_instances.size(); i++) {
|
2020-09-29 13:01:01 +02:00
|
|
|
if (i == 0) {
|
|
|
|
f->store_line("");
|
|
|
|
}
|
2023-12-22 05:35:24 +01:00
|
|
|
f->store_line("[editable path=\"" + editable_instances[i].operator String().c_escape() + "\"]");
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f->get_error() != OK && f->get_error() != ERR_FILE_EOF) {
|
|
|
|
return ERR_CANT_CREATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2022-12-05 19:01:59 +01:00
|
|
|
Error ResourceLoaderText::set_uid(Ref<FileAccess> p_f, ResourceUID::ID p_uid) {
|
|
|
|
open(p_f, true);
|
|
|
|
ERR_FAIL_COND_V(error != OK, error);
|
|
|
|
ignore_resource_parsing = true;
|
|
|
|
|
|
|
|
Ref<FileAccess> fw;
|
|
|
|
|
|
|
|
fw = FileAccess::open(local_path + ".uidren", FileAccess::WRITE);
|
|
|
|
if (is_scene) {
|
2024-04-19 09:55:29 +02:00
|
|
|
fw->store_string("[gd_scene load_steps=" + itos(resources_total) + " format=" + itos(format_version) + " uid=\"" + ResourceUID::get_singleton()->id_to_text(p_uid) + "\"]");
|
2022-12-05 19:01:59 +01:00
|
|
|
} else {
|
2023-01-19 19:12:25 +01:00
|
|
|
String script_res_text;
|
|
|
|
if (!script_class.is_empty()) {
|
|
|
|
script_res_text = "script_class=\"" + script_class + "\" ";
|
|
|
|
}
|
|
|
|
|
2024-04-19 09:55:29 +02:00
|
|
|
fw->store_string("[gd_resource type=\"" + res_type + "\" " + script_res_text + "load_steps=" + itos(resources_total) + " format=" + itos(format_version) + " uid=\"" + ResourceUID::get_singleton()->id_to_text(p_uid) + "\"]");
|
2022-12-05 19:01:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t c = f->get_8();
|
|
|
|
while (!f->eof_reached()) {
|
|
|
|
fw->store_8(c);
|
|
|
|
c = f->get_8();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool all_ok = fw->get_error() == OK;
|
|
|
|
|
|
|
|
if (!all_ok) {
|
|
|
|
return ERR_CANT_CREATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2022-06-03 01:33:42 +02:00
|
|
|
Error ResourceFormatSaverText::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) {
|
2022-02-06 14:12:19 +01:00
|
|
|
if (p_path.ends_with(".tscn") && !Ref<PackedScene>(p_resource).is_valid()) {
|
2015-10-10 14:09:09 +02:00
|
|
|
return ERR_FILE_UNRECOGNIZED;
|
|
|
|
}
|
|
|
|
|
|
|
|
ResourceFormatSaverTextInstance saver;
|
|
|
|
return saver.save(p_path, p_resource, p_flags);
|
|
|
|
}
|
|
|
|
|
2022-12-05 19:01:59 +01:00
|
|
|
Error ResourceFormatSaverText::set_uid(const String &p_path, ResourceUID::ID p_uid) {
|
|
|
|
String lc = p_path.to_lower();
|
|
|
|
if (!lc.ends_with(".tscn") && !lc.ends_with(".tres")) {
|
|
|
|
return ERR_FILE_UNRECOGNIZED;
|
|
|
|
}
|
|
|
|
|
|
|
|
String local_path = ProjectSettings::get_singleton()->localize_path(p_path);
|
|
|
|
Error err = OK;
|
|
|
|
{
|
2023-02-01 10:49:05 +01:00
|
|
|
Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::READ);
|
|
|
|
if (file.is_null()) {
|
2022-12-05 19:01:59 +01:00
|
|
|
ERR_FAIL_V(ERR_CANT_OPEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
ResourceLoaderText loader;
|
|
|
|
loader.local_path = local_path;
|
|
|
|
loader.res_path = loader.local_path;
|
2023-02-01 10:49:05 +01:00
|
|
|
err = loader.set_uid(file, p_uid);
|
2022-12-05 19:01:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (err == OK) {
|
|
|
|
Ref<DirAccess> da = DirAccess::create(DirAccess::ACCESS_RESOURCES);
|
|
|
|
da->remove(local_path);
|
|
|
|
da->rename(local_path + ".uidren", local_path);
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
bool ResourceFormatSaverText::recognize(const Ref<Resource> &p_resource) const {
|
2022-02-06 14:12:19 +01:00
|
|
|
return true; // All resources recognized!
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
2020-05-14 14:29:06 +02:00
|
|
|
|
2022-05-03 01:43:50 +02:00
|
|
|
void ResourceFormatSaverText::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
|
2022-02-06 14:12:19 +01:00
|
|
|
if (Ref<PackedScene>(p_resource).is_valid()) {
|
|
|
|
p_extensions->push_back("tscn"); // Text scene.
|
2020-05-14 16:41:43 +02:00
|
|
|
} else {
|
2022-02-06 14:12:19 +01:00
|
|
|
p_extensions->push_back("tres"); // Text resource.
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2015-10-10 14:09:09 +02:00
|
|
|
}
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
ResourceFormatSaverText *ResourceFormatSaverText::singleton = nullptr;
|
2015-10-10 14:09:09 +02:00
|
|
|
ResourceFormatSaverText::ResourceFormatSaverText() {
|
|
|
|
singleton = this;
|
|
|
|
}
|