+ r_img->convert_rgba8_to_bgra8(); // It's badly documented but ETCPAK seems to be expected BGRA8 for ETC.

+ r_img->convert_rgba8_to_bgra8(); // It's badly documented but ETCPAK seems to be expected BGRA8 for ETC.

+ r_img->convert_rgba8_to_bgra8(); // It's badly documented but ETCPAK seems to be expected BGRA8 for ETC.

+ Add a custom icon to the current script. The script must be registered as a global class using the [code]class_name[/code] keyword for this to have a visible effect. The icon specified at [param icon_path] is displayed in the Scene dock for every node of that class, as well as in various editor dialogs.

+ doc.script_path = vformat(R"("%s")", get_script_path().get_slice("://", 1));

+ return vformat("%s(%s)", get_name(), get_script_path());

+ return get_script_path();

+ EngineDebugger::get_script_debugger()->send_error("", get_script_path(), warning.start_line, warning.get_name(), warning.get_message(), false, ERR_HANDLER_WARNING, si);

+String GDScript::get_script_path() const {

+ return path;

+}

+

+ if (_call_stack) {

+ memdelete_arr(_call_stack);

+ _call_stack = nullptr;

+ }

+

+ // Clear the cache before parsing the script_list

+ GDScriptCache::clear();

+

+ // Clear dependencies between scripts, to ensure cyclic references are broken

+ // (to avoid leaks at exit).

+ SelfList<GDScript> *s = script_list.first();

+ while (s) {

+ // This ensures the current script is not released before we can check

+ // what's the next one in the list (we can't get the next upfront because we

+ // don't know if the reference breaking will cause it -or any other after

+ // it, for that matter- to be released so the next one is not the same as

+ // before).

+ Ref<GDScript> scr = s->self();

+ if (scr.is_valid()) {

+ for (KeyValue<StringName, GDScriptFunction *> &E : scr->member_functions) {

+ GDScriptFunction *func = E.value;

+ for (int i = 0; i < func->argument_types.size(); i++) {

+ func->argument_types.write[i].script_type_ref = Ref<Script>();

+ }

+ func->return_type.script_type_ref = Ref<Script>();

+ }

+ for (KeyValue<StringName, GDScript::MemberInfo> &E : scr->member_indices) {

+ E.value.data_type.script_type_ref = Ref<Script>();

+ }

+

+ // Clear backup for scripts that could slip out of the cyclic reference

+ // check

+ scr->clear();

+ }

+ s = s->next();

+ }

+ // Scripts will reload all subclasses, so only reload root scripts.

+ if (elem->self()->is_root_script() && elem->self()->get_path().is_resource_file()) {

+ // Scripts will reload all subclasses, so only reload root scripts.

+ if (elem->self()->is_root_script() && elem->self()->get_path().is_resource_file()) {

+ String get_script_path() const;

+ csi.write[_debug_call_stack_pos - i - 1].file = _call_stack[i].function->get_script()->get_script_path();

+ String parent_class_name = current_class_node->fqcn;

+ if (current_class_node->identifier != nullptr) {

+ parent_class_name = current_class_node->identifier->name;

+ }

+ push_error(vformat(R"(The member "%s" already exists in parent class %s.)", p_member_name, parent_class_name), p_member_node);

+void GDScriptAnalyzer::get_class_node_current_scope_classes(GDScriptParser::ClassNode *p_node, List<GDScriptParser::ClassNode *> *p_list) {

+ if (p_list->find(p_node) != nullptr) {

+ return;

+ }

+ p_list->push_back(p_node);

+

+ // Prioritize node base type over its outer class

+ if (p_node->base_type.class_type != nullptr) {

+ get_class_node_current_scope_classes(p_node->base_type.class_type, p_list);

+ }

+

+ if (p_node->outer != nullptr) {

+ get_class_node_current_scope_classes(p_node->outer, p_list);

+ }

+}

+

+ List<GDScriptParser::ClassNode *> script_classes;

+ get_class_node_current_scope_classes(p_class, &script_classes);

+ for (GDScriptParser::ClassNode *look_class : script_classes) {

+ result.native_type = result.script_type->get_instance_base_type();

+ List<GDScriptParser::ClassNode *> script_classes;

+ get_class_node_current_scope_classes(parser->current_class, &script_classes);

+ for (GDScriptParser::ClassNode *script_class : script_classes) {

+ Ref<GDScriptParserRef> ref = get_parser_for(gdscript->get_script_path());

+ push_error(vformat(R"(Could not parse script from "%s".)", gdscript->get_script_path()), p_type);

+ } else {

+ p_function->default_arg_values.push_back(Variant()); // Prevent shift.

+ String parent_signature = p_function->identifier->name.operator String() + "(";

+ parent_signature += ") -> ";

+

+ const String return_type = parent_return_type.is_hard_type() ? parent_return_type.to_string() : "Variant";

+ if (return_type == "null") {

+ parent_signature += "void";

+ } else {

+ parent_signature += return_type;

+ }

+

+ result.is_constant = false;

+ if (is_static && !base_type.is_meta_type && !(is_self && parser->current_function != nullptr && parser->current_function->is_static)) {

+ String caller_type = String(base_type.native_type);

+

+ if (caller_type.is_empty()) {

+ caller_type = base_type.to_string();

+ }

+

+ parser->push_warning(p_call, GDScriptWarning::STATIC_CALLED_ON_INSTANCE, p_call->function_name, caller_type);

+ HashMap<Variant, GDScriptParser::ExpressionNode *, VariantHasher, StringLikeVariantComparator> elements;

+ return ref->get_parser()->head->get_datatype();

+ type.native_type = type.script_type->get_instance_base_type();

+ if (base_class->outer != nullptr) {

+ List<GDScriptParser::ClassNode *> script_classes;

+ get_class_node_current_scope_classes(parser->current_class, &script_classes);

+ for (GDScriptParser::ClassNode *script_class : script_classes) {

+ if (script_class->has_member(name)) {

+ const GDScriptParser::ClassNode::Member &member = script_class->get_member(name);

+ switch (member.type) {

+ case GDScriptParser::ClassNode::Member::CONSTANT: {

+ // TODO: Make sure loops won't cause problem. And make special error message for those.

+ // For out-of-order resolution:

+ reduce_expression(member.constant->initializer);

+ p_identifier->set_datatype(member.get_datatype());

+ p_identifier->is_constant = true;

+ p_identifier->reduced_value = member.constant->initializer->reduced_value;

+ return;

+ } break;

+ case GDScriptParser::ClassNode::Member::ENUM_VALUE: {

+ p_identifier->set_datatype(member.get_datatype());

+ p_identifier->is_constant = true;

+ p_identifier->reduced_value = member.enum_value.value;

+ return;

+ } break;

+ case GDScriptParser::ClassNode::Member::ENUM: {

+ p_identifier->set_datatype(member.get_datatype());

+ p_identifier->is_constant = false;

+ return;

+ } break;

+ case GDScriptParser::ClassNode::Member::CLASS: {

+ resolve_class_interface(member.m_class);

+ p_identifier->set_datatype(member.m_class->get_datatype());

+ return;

+ } break;

+ default:

+ break;

+ }

+ if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(name)) {

+ Variant constant = GDScriptLanguage::get_singleton()->get_named_globals_map()[name];

+ Node *node = Object::cast_to<Node>(constant);

+ if (node != nullptr) {

+ Ref<GDScript> scr = node->get_script();

+ if (scr.is_valid()) {

+ Ref<GDScriptParserRef> singl_parser = get_parser_for(scr->get_script_path());

+ if (singl_parser.is_valid()) {

+ Error err = singl_parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);

+ if (err == OK) {

+ result = type_from_metatype(singl_parser->get_parser()->head->get_datatype());

+ }

+ }

+ GDScriptCache::get_full_script(gdscr->get_script_path(), err);

+ error = index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;

+ index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;

+ error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::STRING && index_type.builtin_type != Variant::STRING_NAME;

+ if (p_value.get_type() == Variant::NIL) {

+ // A null value is a variant, not void.

+ result.kind = GDScriptParser::DataType::VARIANT;

+ } else if (p_value.get_type() == Variant::OBJECT) {

+ // Object is treated as a native type, not a builtin type.

+ result.kind = GDScriptParser::DataType::NATIVE;

+

+ valid |= p_source.builtin_type == Variant::STRING && p_target.builtin_type == Variant::STRING_NAME;

+ valid |= p_source.builtin_type == Variant::STRING_NAME && p_target.builtin_type == Variant::STRING;

+ void get_class_node_current_scope_classes(GDScriptParser::ClassNode *p_node, List<GDScriptParser::ClassNode *> *p_list);

+

+ function->source = p_script->get_script_path();

+ if (singleton->cleared) {

+ return;

+ }

+

+ if (singleton->cleared) {

+ return;

+ }

+

+ script = singleton->full_gdscript_cache[p_path];

+ if (singleton->cleared) {

+ return;

+ }

+

+void GDScriptCache::clear() {

+ if (singleton == nullptr) {

+ return;

+ }

+ MutexLock lock(singleton->mutex);

+

+ if (singleton->cleared) {

+ return;

+ }

+ singleton->cleared = true;

+ for (KeyValue<String, GDScriptParserRef *> &E : singleton->parser_map) {

+ singleton->packed_scene_dependencies.clear();

+ singleton->packed_scene_cache.clear();

+

+ singleton->parser_map.clear();

+ singleton->shallow_gdscript_cache.clear();

+ singleton->full_gdscript_cache.clear();

+

+ singleton->packed_scene_cache.clear();

+ singleton->packed_scene_dependencies.clear();

+}

+GDScriptCache::GDScriptCache() {

+ singleton = this;

+}

+GDScriptCache::~GDScriptCache() {

+ if (!cleared) {

+ clear();

+ }

+ bool cleared = false;

+ static void clear();

+ if (_is_local_or_parameter(codegen, p_name)) {

+bool GDScriptCompiler::_is_local_or_parameter(CodeGen &codegen, const StringName &p_name) {

+ return codegen.parameters.has(p_name) || codegen.locals.has(p_name);

+}

+

+ } else if (!_is_local_or_parameter(codegen, var_name) && codegen.script->member_indices.has(var_name)) {

+ if (!_is_local_or_parameter(codegen, var_name) && codegen.script->member_indices.has(var_name)) {

+ GDScriptCodeGenerator::Address type_string_addr = codegen.add_constant(Variant::STRING);

+ GDScriptCodeGenerator::Address type_string_name_addr = codegen.add_constant(Variant::STRING_NAME);

+

+

+ // Check if StringName <-> String comparison is possible.

+ GDScriptCodeGenerator::Address type_comp_addr_1 = codegen.add_temporary(equality_type);

+ GDScriptCodeGenerator::Address type_comp_addr_2 = codegen.add_temporary(equality_type);

+

+ codegen.generator->write_binary_operator(type_comp_addr_1, Variant::OP_EQUAL, p_type_addr, type_string_addr);

+ codegen.generator->write_binary_operator(type_comp_addr_2, Variant::OP_EQUAL, literal_type_addr, type_string_name_addr);

+ codegen.generator->write_binary_operator(type_comp_addr_1, Variant::OP_AND, type_comp_addr_1, type_comp_addr_2);

+ codegen.generator->write_binary_operator(type_equality_addr, Variant::OP_OR, type_equality_addr, type_comp_addr_1);

+

+ codegen.generator->write_binary_operator(type_comp_addr_1, Variant::OP_EQUAL, p_type_addr, type_string_name_addr);

+ codegen.generator->write_binary_operator(type_comp_addr_2, Variant::OP_EQUAL, literal_type_addr, type_string_addr);

+ codegen.generator->write_binary_operator(type_comp_addr_1, Variant::OP_AND, type_comp_addr_1, type_comp_addr_2);

+ codegen.generator->write_binary_operator(type_equality_addr, Variant::OP_OR, type_equality_addr, type_comp_addr_1);

+

+ codegen.generator->pop_temporary(); // Remove type_comp_addr_2 from stack.

+ codegen.generator->pop_temporary(); // Remove type_comp_addr_1 from stack.

+

+ bool initialized = false;

+ initialized = true;

+ initialized = true;

+ initialized = true;

+

+ // Assigns a null for the unassigned variables in loops.

+ if (!initialized && p_block->is_loop) {

+ codegen.generator->write_construct(local, Variant::NIL, Vector<GDScriptCodeGenerator::Address>());

+ }

+ if (!p_script->get_script_path().is_empty()) {

+ signature += p_script->get_script_path();

+ ERR_FAIL_COND_V(!base->is_valid() && !base->reloading, ERR_BUG);

+ bool _is_local_or_parameter(CodeGen &codegen, const StringName &p_name);

+ if (!found && base.value.get_type() != Variant::NIL) {

+ if (p_context.base == nullptr) {

+ return false;

+ }

+ const GDScriptParser::GetNodeNode *get_node = nullptr;

+

+ switch (p_subscript->base->type) {

+ case GDScriptParser::Node::GET_NODE: {

+ get_node = static_cast<GDScriptParser::GetNodeNode *>(p_subscript->base);

+ } break;

+

+ case GDScriptParser::Node::IDENTIFIER: {

+ const GDScriptParser::IdentifierNode *identifier_node = static_cast<GDScriptParser::IdentifierNode *>(p_subscript->base);

+ switch (identifier_node->source) {

+ case GDScriptParser::IdentifierNode::Source::MEMBER_VARIABLE: {

+ if (p_context.current_class != nullptr) {

+ const StringName &member_name = identifier_node->name;

+ const GDScriptParser::ClassNode *current_class = p_context.current_class;

+ if (current_class->has_member(member_name)) {

+ const GDScriptParser::ClassNode::Member &member = current_class->get_member(member_name);

+ if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {

+ const GDScriptParser::VariableNode *variable = static_cast<GDScriptParser::VariableNode *>(member.variable);

+ if (variable->initializer && variable->initializer->type == GDScriptParser::Node::GET_NODE) {

+ get_node = static_cast<GDScriptParser::GetNodeNode *>(variable->initializer);

+ }

+ } break;

+ case GDScriptParser::IdentifierNode::Source::LOCAL_VARIABLE: {

+ if (identifier_node->next != nullptr && identifier_node->next->type == GDScriptParser::ClassNode::Node::GET_NODE) {

+ get_node = static_cast<GDScriptParser::GetNodeNode *>(identifier_node->next);

+ }

+ } break;

+ default: {

+ } break;

+ }

+ } break;

+ default: {

+ } break;

+ }

+ if (get_node != nullptr) {

+ const Object *node = p_context.base->call("get_node_or_null", NodePath(get_node->full_path));

+ if (node != nullptr) {

+ if (r_base != nullptr) {

+ *r_base = node;

+ r_base_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;

+ r_base_type.kind = GDScriptParser::DataType::NATIVE;

+ r_base_type.native_type = node->get_class_name();

+ r_base_type.builtin_type = Variant::OBJECT;

+ return true;

+ if (subscript->is_attribute) {

+ context.base = p_owner;

+

+ // Allows class functions with the names like built-ins to be handled properly.

+ if (context.type != GDScriptParser::COMPLETION_ATTRIBUTE) {

+ // Need special checks for assert and preload as they are technically

+ // keywords, so are not registered in GDScriptUtilityFunctions.

+ if (GDScriptUtilityFunctions::function_exists(p_symbol) || "assert" == p_symbol || "preload" == p_symbol) {

+ r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;

+ r_result.class_name = "@GDScript";

+ r_result.class_member = p_symbol;

+ return OK;

+ }

+ }

+

+ GDScriptAnalyzer analyzer(&parser);

+ analyzer.analyze();

+

+ bool found_type = _get_subscript_type(context, subscript, base.type);

+ if (!found_type && !_guess_expression_type(context, subscript->base, base)) {

+#ifdef DEBUG_ENABLED

+#endif

+ n_for->loop->is_loop = true;

+ n_while->loop->is_loop = true;

+ if (p_annotation->name == SNAME("@export_range")) {

+ if (export_type.builtin_type == Variant::INT) {

+ variable->export_info.type = Variant::INT;

+ }

+ }

+

+ variable->export_info.hint_string = export_type.to_string();

+ variable->export_info.hint_string = export_type.to_string();

+ StringName native_base;

+ if (export_type.script_type.is_valid()) {

+ native_base = export_type.script_type->get_instance_base_type();

+ native_base = script->get_instance_base_type();

+ if (class_name != StringName() && native_base != StringName() && ClassDB::is_parent_class(native_base, SNAME("Resource"))) {

+ bool is_loop = false;

+

+ bool is_ignoring_warnings = false;

+ String path = p->get_script_path();

+ if (!path.is_resource_file()) {

+ d["@path"] = path;

+ gdfs->state.script_path = _script->get_script_path();

+ GDScriptAnalyzer analyzer(this);

+

+#include "editor/editor_help.h"

+ if (ResourceLoader::get_resource_type(info.path) == "PackedScene") {

+ // Cache the scene reference before loading it (for cyclic references)

+ Ref<PackedScene> scn;

+ scn.instantiate();

+ scn->set_path(info.path);

+ scn->reload_from_file();

+ ERR_CONTINUE_MSG(!scn.is_valid(), vformat("Can't autoload: %s.", info.path));

+

+ if (scn.is_valid()) {

+ n = scn->instantiate();

+ }

+ } else {

+ Ref<Resource> res = ResourceLoader::load(info.path);

+ ERR_CONTINUE_MSG(res.is_null(), vformat("Can't autoload: %s.", info.path));

+ Ref<Script> scr = res;

+ if (scr.is_valid()) {

+ StringName ibt = scr->get_instance_base_type();

+ bool valid_type = ClassDB::is_parent_class(ibt, "Node");

+ ERR_CONTINUE_MSG(!valid_type, vformat("Script does not inherit from Node: %s.", info.path));

+ Object *obj = ClassDB::instantiate(ibt);

+ ERR_CONTINUE_MSG(!obj, vformat("Cannot instance script for Autoload, expected 'Node' inheritance, got: %s.", ibt));

+

+ n = Object::cast_to<Node>(obj);

+ n->set_script(scr);

+ }

+ ERR_CONTINUE_MSG(!n, vformat("Path in autoload not a node or script: %s.", info.path));

+# https://github.com/godotengine/godot/issues/62957

+

+func test():

+ var dict = {

+ &"key": "StringName",

+ "key": "String"

+ }

+

+ print("Invalid dictionary: %s" % dict)

+GDTEST_ANALYZER_ERROR

+Key "key" was already used in this dictionary (at line 5).

+The function signature doesn't match the parent. Parent signature is "my_function(int) -> int".

+The function signature doesn't match the parent. Parent signature is "my_function(int) -> int".

+The function signature doesn't match the parent. Parent signature is "my_function(int = default) -> int".

+The function signature doesn't match the parent. Parent signature is "my_function(int) -> int".

+The function signature doesn't match the parent. Parent signature is "my_function() -> int".

+func test():

+ # Converted to String when initialized

+ var string_array: Array[String] = [&"abc"]

+ print(string_array)

+

+ # Converted to StringName when initialized

+ var stringname_array: Array[StringName] = ["abc"]

+ print(stringname_array)

+GDTEST_OK

+["abc"]

+[&"abc"]

+const A: = preload("base_outer_resolution_a.notest.gd")

+const B: = preload("base_outer_resolution_b.notest.gd")

+const C: = preload("base_outer_resolution_c.notest.gd")

+

+const Extend: = preload("base_outer_resolution_extend.notest.gd")

+

+func test() -> void:

+ Extend.test_a(A.new())

+ Extend.test_b(B.new())

+ Extend.InnerClass.test_c(C.new())

+ Extend.InnerClass.InnerInnerClass.test_a_b_c(A.new(), B.new(), C.new())

+ Extend.InnerClass.InnerInnerClass.test_enum(C.TestEnum.HELLO_WORLD)

+ Extend.InnerClass.InnerInnerClass.test_a_prime(A.APrime.new())

+

+GDTEST_OK

+true

+true

+true

+true

+true

+true

+class APrime:

+ pass

+const A: = preload("base_outer_resolution_a.notest.gd")

+

+class InnerClassInBase:

+ const C: = preload("base_outer_resolution_c.notest.gd")

+enum TestEnum {

+ HELLO_WORLD

+}

+extends "base_outer_resolution_base.notest.gd"

+

+const B: = preload("base_outer_resolution_b.notest.gd")

+

+static func test_a(a: A) -> void:

+ print(a is A)

+

+static func test_b(b: B) -> void:

+ print(b is B)

+

+class InnerClass extends InnerClassInBase:

+ static func test_c(c: C) -> void:

+ print(c is C)

+

+ class InnerInnerClass:

+ static func test_a_b_c(a: A, b: B, c: C) -> void:

+ print(a is A and b is B and c is C)

+

+ static func test_enum(test_enum: C.TestEnum) -> void:

+ print(test_enum == C.TestEnum.HELLO_WORLD)

+

+ static func test_a_prime(a_prime: A.APrime) -> void:

+ print(a_prime is A.APrime)

+# https://github.com/godotengine/godot/issues/63965

+

+func test():

+ var array_str: Array = []

+ array_str.push_back("godot")

+ print("StringName in Array: ", &"godot" in array_str)

+

+ var array_sname: Array = []

+ array_sname.push_back(&"godot")

+ print("String in Array: ", "godot" in array_sname)

+

+ # Not equal because the values are different types.

+ print("Arrays not equal: ", array_str != array_sname)

+

+ var string_array: Array[String] = []

+ var stringname_array: Array[StringName] = []

+

+ assert(!string_array.push_back(&"abc"))

+ print("Array[String] insert converted: ", typeof(string_array[0]) == TYPE_STRING)

+

+ assert(!stringname_array.push_back("abc"))

+ print("Array[StringName] insert converted: ", typeof(stringname_array[0]) == TYPE_STRING_NAME)

+

+ print("StringName in Array[String]: ", &"abc" in string_array)

+ print("String in Array[StringName]: ", "abc" in stringname_array)

+

+ var packed_string_array: PackedStringArray = []

+ assert(!packed_string_array.push_back("abc"))

+ print("StringName in PackedStringArray: ", &"abc" in packed_string_array)

+

+ assert(!string_array.push_back("abc"))

+ print("StringName finds String in Array: ", string_array.find(&"abc"))

+

+ assert(!stringname_array.push_back(&"abc"))

+ print("String finds StringName in Array: ", stringname_array.find("abc"))

+GDTEST_OK

+StringName in Array: true

+String in Array: true

+Arrays not equal: true

+Array[String] insert converted: true

+Array[StringName] insert converted: true

+StringName in Array[String]: true

+String in Array[StringName]: true

+StringName in PackedStringArray: true

+StringName finds String in Array: 0

+String finds StringName in Array: 0

+# https://github.com/godotengine/godot/issues/62957

+

+func test():

+ var string_dict = {}

+ string_dict["abc"] = 42

+ var stringname_dict = {}

+ stringname_dict[&"abc"] = 24

+

+ print("String key is TYPE_STRING: ", typeof(string_dict.keys()[0]) == TYPE_STRING)

+ print("StringName key is TYPE_STRING: ", typeof(stringname_dict.keys()[0]) == TYPE_STRING)

+

+ print("StringName gets String: ", string_dict.get(&"abc"))

+ print("String gets StringName: ", stringname_dict.get("abc"))

+

+ stringname_dict[&"abc"] = 42

+ # They compare equal because StringName keys are converted to String.

+ print("String Dictionary == StringName Dictionary: ", string_dict == stringname_dict)

+GDTEST_OK

+String key is TYPE_STRING: true

+StringName key is TYPE_STRING: true

+StringName gets String: 42

+String gets StringName: 24

+String Dictionary == StringName Dictionary: true

+# https://github.com/godotengine/godot/issues/60145

+

+func test():

+ match "abc":

+ &"abc":

+ print("String matched StringName")

+ _:

+ print("no match")

+

+ match &"abc":

+ "abc":

+ print("StringName matched String")

+ _:

+ print("no match")

+GDTEST_OK

+String matched StringName

+StringName matched String

+# https://github.com/godotengine/godot/pull/69620

+

+var a: int = 1

+

+func shadow_regular_assignment(a: Variant, b: Variant) -> void:

+ print(a)

+ print(self.a)

+ a = b

+ print(a)

+ print(self.a)

+

+

+var v := Vector2(0.0, 0.0)

+

+func shadow_subscript_assignment(v: Vector2, x: float) -> void:

+ print(v)

+ print(self.v)

+ v.x += x

+ print(v)

+ print(self.v)

+

+

+func test():

+ shadow_regular_assignment('a', 'b')

+ shadow_subscript_assignment(Vector2(1.0, 1.0), 5.0)

+GDTEST_OK

+>> WARNING

+>> Line: 5

+>> SHADOWED_VARIABLE

+>> The local function parameter "a" is shadowing an already-declared variable at line 3.

+>> WARNING

+>> Line: 15

+>> SHADOWED_VARIABLE

+>> The local function parameter "v" is shadowing an already-declared variable at line 13.

+a

+1

+b

+1

+(1, 1)

+(0, 0)

+(6, 1)

+(0, 0)

+# https://github.com/godotengine/godot/issues/64171

+

+func test():

+ print("Compare ==: ", "abc" == &"abc")

+ print("Compare ==: ", &"abc" == "abc")

+ print("Compare !=: ", "abc" != &"abc")

+ print("Compare !=: ", &"abc" != "abc")

+

+ print("Concat: ", "abc" + &"def")

+ print("Concat: ", &"abc" + "def")

+ print("Concat: ", &"abc" + &"def")

+GDTEST_OK

+Compare ==: true

+Compare ==: true

+Compare !=: false

+Compare !=: false

+Concat: abcdef

+Concat: abcdef

+Concat: abcdef

+ <param index="3" name="base_path" type="String" default="&quot;&quot;" />

+ <param index="1" name="bake_fps" type="float" default="30" />

+ <param index="2" name="trimming" type="bool" default="false" />

+ The return value is used to determine if this [GLTFDocumentExtension] instance should be used for exporting a given GLTF file. If [constant OK], the export will use this [GLTFDocumentExtension] instance. If not overridden, [constant OK] is returned.

+ The return value is used to determine if this [GLTFDocumentExtension] instance should be used for importing a given GLTF file. If [constant OK], the import will use this [GLTFDocumentExtension] instance. If not overridden, [constant OK] is returned.

+ Runs when parsing the node extensions of a GLTFNode. This method can be used to process the extension JSON data into a format that can be used by [method _generate_scene_node]. The return value should be a member of the [enum Error] enum.

+ <return type="Material[]" />

+ <param index="0" name="materials" type="Material[]" />

+ Error err = doc->append_from_scene(root, state, flags);

+#include "scene/gui/line_edit.h"

+ const HashMap<StringName, Variant> &p_options,

+ Error err = gltf->append_from_file(sink.get_basename() + ".gltf", state, p_flags, base_dir);

+ return gltf->generate_scene(state, (float)p_options["animation/fps"], (bool)p_options["animation/trimming"]);

+ const HashMap<StringName, Variant> &p_options,

+ const HashMap<StringName, Variant> &p_options,

+ Error err = gltf->append_from_file(sink, state, p_flags);

+ return gltf->generate_scene(state, (float)p_options["animation/fps"], (bool)p_options["animation/trimming"]);

+ const HashMap<StringName, Variant> &p_options,

+ const HashMap<StringName, Variant> &p_options,

+ Error err = doc->append_from_file(p_path, state, p_flags);

+

+ if (p_options.has("animation/trimming")) {

+ return doc->generate_scene(state, (float)p_options["animation/fps"], (bool)p_options["animation/trimming"]);

+ } else {

+ return doc->generate_scene(state, (float)p_options["animation/fps"], false);

+ }

+ const HashMap<StringName, Variant> &p_options,

+#include "scene/3d/importer_mesh_instance_3d.h"

+#include "scene/3d/light_3d.h"

+

+

+class Light3D;

+#include "core/io/image.h"

+

+class Image;

+

+class ImporterMeshInstance3D;

+class MeshInstance3D;

+#include "scene/3d/bone_attachment_3d.h"

+#include "scene/3d/camera_3d.h"

+#include "scene/3d/importer_mesh_instance_3d.h"

+#include "scene/3d/light_3d.h"

+#include "scene/resources/skin.h"

+Error GLTFDocument::_serialize(Ref<GLTFState> p_state, const String &p_path) {

+ if (!p_state->buffers.size()) {

+ p_state->buffers.push_back(Vector<uint8_t>());

+ _convert_mesh_instances(p_state);

+ Error err = _serialize_cameras(p_state);

+ err = _serialize_skins(p_state);

+ err = _serialize_meshes(p_state);

+ err = _serialize_materials(p_state);

+ err = _serialize_texture_samplers(p_state);

+ err = _serialize_animations(p_state);

+ err = _encode_accessors(p_state);

+ err = _serialize_images(p_state, p_path);

+ err = _serialize_textures(p_state);

+ for (GLTFBufferViewIndex i = 0; i < p_state->buffer_views.size(); i++) {

+ p_state->buffer_views.write[i]->buffer = 0;

+ err = _encode_buffer_views(p_state);

+ err = _serialize_nodes(p_state);

+ err = _serialize_scenes(p_state);

+ err = _serialize_lights(p_state);

+ err = _serialize_gltf_extensions(p_state);

+ err = _serialize_version(p_state);

+ err = ext->export_post(p_state);

+Error GLTFDocument::_serialize_gltf_extensions(Ref<GLTFState> p_state) const {

+ Vector<String> extensions_used = p_state->extensions_used;

+ Vector<String> extensions_required = p_state->extensions_required;

+ if (!p_state->lights.is_empty()) {

+ if (p_state->use_khr_texture_transform) {

+ p_state->json["extensionsUsed"] = extensions_used;

+ p_state->json["extensionsRequired"] = extensions_required;

+Error GLTFDocument::_serialize_scenes(Ref<GLTFState> p_state) {

+ p_state->json["scene"] = loaded_scene;

+ if (p_state->nodes.size()) {

+ if (!p_state->scene_name.is_empty()) {

+ s["name"] = p_state->scene_name;

+ p_state->json["scenes"] = scenes;

+Error GLTFDocument::_parse_json(const String &p_path, Ref<GLTFState> p_state) {

+ Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::READ, &err);

+ if (file.is_null()) {

+ array.resize(file->get_length());

+ file->get_buffer(array.ptrw(), array.size());

+ p_state->json = json.get_data();

+Error GLTFDocument::_parse_glb(Ref<FileAccess> p_file, Ref<GLTFState> p_state) {

+ ERR_FAIL_NULL_V(p_file, ERR_INVALID_PARAMETER);

+ ERR_FAIL_NULL_V(p_state, ERR_INVALID_PARAMETER);

+ ERR_FAIL_COND_V(p_file->get_position() != 0, ERR_FILE_CANT_READ);

+ uint32_t magic = p_file->get_32();

+ p_file->get_32(); // version

+ p_file->get_32(); // length

+ uint32_t chunk_length = p_file->get_32();

+ uint32_t chunk_type = p_file->get_32();

+ uint32_t len = p_file->get_buffer(json_data.ptrw(), chunk_length);

+ p_state->json = json.get_data();

+ chunk_length = p_file->get_32();

+ chunk_type = p_file->get_32();

+ if (p_file->eof_reached()) {

+ p_state->glb_data.resize(chunk_length);

+ len = p_file->get_buffer(p_state->glb_data.ptrw(), chunk_length);

+Error GLTFDocument::_serialize_nodes(Ref<GLTFState> p_state) {

+ for (int i = 0; i < p_state->nodes.size(); i++) {

+ Ref<GLTFNode> gltf_node = p_state->nodes[i];

+ ERR_CONTINUE(!p_state->scene_nodes.find(i));

+ Error err = ext->export_node(p_state, gltf_node, node, p_state->scene_nodes[i]);

+ p_state->json["nodes"] = nodes;

+String GLTFDocument::_gen_unique_name(Ref<GLTFState> p_state, const String &p_name) {

+ if (!p_state->unique_names.has(u_name)) {

+ p_state->unique_names.insert(u_name);

+String GLTFDocument::_gen_unique_animation_name(Ref<GLTFState> p_state, const String &p_name) {

+ if (!p_state->unique_animation_names.has(u_name)) {

+ p_state->unique_animation_names.insert(u_name);

+String GLTFDocument::_gen_unique_bone_name(Ref<GLTFState> p_state, const GLTFSkeletonIndex p_skel_i, const String &p_name) {

+ if (!p_state->skeletons[p_skel_i]->unique_names.has(u_name)) {

+ p_state->skeletons.write[p_skel_i]->unique_names.insert(u_name);

+Error GLTFDocument::_parse_scenes(Ref<GLTFState> p_state) {

+ ERR_FAIL_COND_V(!p_state->json.has("scenes"), ERR_FILE_CORRUPT);

+ const Array &scenes = p_state->json["scenes"];

+ if (p_state->json.has("scene")) {

+ loaded_scene = p_state->json["scene"];

+ p_state->root_nodes.push_back(nodes[j]);

+ p_state->scene_name = _gen_unique_name(p_state, s["name"]);

+ p_state->scene_name = _gen_unique_name(p_state, p_state->filename);

+Error GLTFDocument::_parse_nodes(Ref<GLTFState> p_state) {

+ ERR_FAIL_COND_V(!p_state->json.has("nodes"), ERR_FILE_CORRUPT);

+ const Array &nodes = p_state->json["nodes"];

+ Error err = ext->parse_node_extensions(p_state, node, extensions);

+ ERR_CONTINUE_MSG(err != OK, "GLTF: Encountered error " + itos(err) + " when parsing node extensions for node " + node->get_name() + " in file " + p_state->filename + ". Continuing.");

+ p_state->nodes.push_back(node);

+ for (GLTFNodeIndex node_i = 0; node_i < p_state->nodes.size(); node_i++) {

+ for (int j = 0; j < p_state->nodes[node_i]->children.size(); j++) {

+ GLTFNodeIndex child_i = p_state->nodes[node_i]->children[j];

+ ERR_FAIL_INDEX_V(child_i, p_state->nodes.size(), ERR_FILE_CORRUPT);

+ ERR_CONTINUE(p_state->nodes[child_i]->parent != -1); //node already has a parent, wtf.

+ p_state->nodes.write[child_i]->parent = node_i;

+ _compute_node_heights(p_state);

+void GLTFDocument::_compute_node_heights(Ref<GLTFState> p_state) {

+ p_state->root_nodes.clear();

+ for (GLTFNodeIndex node_i = 0; node_i < p_state->nodes.size(); ++node_i) {

+ Ref<GLTFNode> node = p_state->nodes[node_i];

+ const GLTFNodeIndex parent_i = p_state->nodes[current_i]->parent;

+ p_state->root_nodes.push_back(node_i);

+Error GLTFDocument::_encode_buffer_glb(Ref<GLTFState> p_state, const String &p_path) {

+ print_verbose("glTF: Total buffers: " + itos(p_state->buffers.size()));

+ if (!p_state->buffers.size()) {

+ if (p_state->buffers.size()) {

+ Vector<uint8_t> buffer_data = p_state->buffers[0];

+ for (GLTFBufferIndex i = 1; i < p_state->buffers.size() - 1; i++) {

+ Vector<uint8_t> buffer_data = p_state->buffers[i];

+ Ref<FileAccess> file = FileAccess::open(path, FileAccess::WRITE, &err);

+ if (file.is_null()) {

+ file->create(FileAccess::ACCESS_RESOURCES);

+ file->store_buffer(buffer_data.ptr(), buffer_data.size());

+ p_state->json["buffers"] = buffers;

+Error GLTFDocument::_encode_buffer_bins(Ref<GLTFState> p_state, const String &p_path) {

+ print_verbose("glTF: Total buffers: " + itos(p_state->buffers.size()));

+ if (!p_state->buffers.size()) {

+ for (GLTFBufferIndex i = 0; i < p_state->buffers.size(); i++) {

+ Vector<uint8_t> buffer_data = p_state->buffers[i];

+ Ref<FileAccess> file = FileAccess::open(path, FileAccess::WRITE, &err);

+ if (file.is_null()) {

+ file->create(FileAccess::ACCESS_RESOURCES);

+ file->store_buffer(buffer_data.ptr(), buffer_data.size());

+ p_state->json["buffers"] = buffers;

+Error GLTFDocument::_parse_buffers(Ref<GLTFState> p_state, const String &p_base_path) {

+ if (!p_state->json.has("buffers")) {

+ const Array &buffers = p_state->json["buffers"];

+ if (i == 0 && p_state->glb_data.size()) {

+ p_state->buffers.push_back(p_state->glb_data);

+ buffer_data = FileAccess::get_file_as_bytes(uri);

+ p_state->buffers.push_back(buffer_data);

+ print_verbose("glTF: Total buffers: " + itos(p_state->buffers.size()));

+Error GLTFDocument::_encode_buffer_views(Ref<GLTFState> p_state) {

+ for (GLTFBufferViewIndex i = 0; i < p_state->buffer_views.size(); i++) {

+ Ref<GLTFBufferView> buffer_view = p_state->buffer_views[i];

+ print_verbose("glTF: Total buffer views: " + itos(p_state->buffer_views.size()));

+ p_state->json["bufferViews"] = buffers;

+Error GLTFDocument::_parse_buffer_views(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("bufferViews")) {

+ const Array &buffers = p_state->json["bufferViews"];

+ p_state->buffer_views.push_back(buffer_view);

+ print_verbose("glTF: Total buffer views: " + itos(p_state->buffer_views.size()));

+Error GLTFDocument::_encode_accessors(Ref<GLTFState> p_state) {

+ for (GLTFAccessorIndex i = 0; i < p_state->accessors.size(); i++) {

+ Ref<GLTFAccessor> accessor = p_state->accessors[i];

+ p_state->json["accessors"] = accessors;

+ ERR_FAIL_COND_V(!p_state->json.has("accessors"), ERR_FILE_CORRUPT);

+ print_verbose("glTF: Total accessors: " + itos(p_state->accessors.size()));

+Error GLTFDocument::_parse_accessors(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("accessors")) {

+ const Array &accessors = p_state->json["accessors"];

+ p_state->accessors.push_back(accessor);

+ print_verbose("glTF: Total accessors: " + itos(p_state->accessors.size()));

+Error GLTFDocument::_encode_buffer_view(Ref<GLTFState> p_state, const double *p_src, const int p_count, const GLTFType p_type, const int p_component_type, const bool p_normalized, const int p_byte_offset, const bool p_for_vertex, GLTFBufferViewIndex &r_accessor) {

+ const int component_count = component_count_for_type[p_type];

+ const int component_size = _get_component_type_size(p_component_type);

+ switch (p_component_type) {

+ if (p_type == TYPE_MAT2) {

+ if (p_type == TYPE_MAT3) {

+ if (p_type == TYPE_MAT3) {

+ const uint32_t offset = bv->byte_offset = p_byte_offset;

+ Vector<uint8_t> &gltf_buffer = p_state->buffers.write[0];

+ int stride = _get_component_type_size(p_component_type);

+ if (p_for_vertex && stride % 4) {

+ print_verbose("glTF: encoding type " + _get_type_name(p_type) + " component type: " + _get_component_type_name(p_component_type) + " stride: " + itos(stride) + " amount " + itos(p_count));

+ print_verbose("glTF: encoding accessor offset " + itos(p_byte_offset) + " view offset: " + itos(bv->byte_offset) + " total buffer len: " + itos(gltf_buffer.size()) + " view len " + itos(bv->byte_length));

+ const int buffer_end = (stride * (p_count - 1)) + _get_component_type_size(p_component_type);

+ switch (p_component_type) {

+ buffer.resize(p_count * component_count);

+ for (int i = 0; i < p_count; i++) {

+ double d = *p_src;

+ if (p_normalized) {

+ p_src++;

+ buffer.resize(p_count * component_count);

+ for (int i = 0; i < p_count; i++) {

+ double d = *p_src;

+ if (p_normalized) {

+ p_src++;

+ buffer.resize(p_count * component_count);

+ for (int i = 0; i < p_count; i++) {

+ double d = *p_src;

+ if (p_normalized) {

+ p_src++;

+ buffer.resize(p_count * component_count);

+ for (int i = 0; i < p_count; i++) {

+ double d = *p_src;

+ if (p_normalized) {

+ p_src++;

+ buffer.resize(p_count * component_count);

+ for (int i = 0; i < p_count; i++) {

+ double d = *p_src;

+ p_src++;

+ buffer.resize(p_count * component_count);

+ for (int i = 0; i < p_count; i++) {

+ double d = *p_src;

+ p_src++;

+ r_accessor = bv->buffer = p_state->buffer_views.size();

+ p_state->buffer_views.push_back(bv);

+Error GLTFDocument::_decode_buffer_view(Ref<GLTFState> p_state, double *p_dst, const GLTFBufferViewIndex p_buffer_view, const int p_skip_every, const int p_skip_bytes, const int p_element_size, const int p_count, const GLTFType p_type, const int p_component_count, const int p_component_type, const int p_component_size, const bool p_normalized, const int p_byte_offset, const bool p_for_vertex) {

+ const Ref<GLTFBufferView> bv = p_state->buffer_views[p_buffer_view];

+ int stride = p_element_size;

+ if (p_for_vertex && stride % 4) {

+ ERR_FAIL_INDEX_V(bv->buffer, p_state->buffers.size(), ERR_PARSE_ERROR);

+ const uint32_t offset = bv->byte_offset + p_byte_offset;

+ Vector<uint8_t> buffer = p_state->buffers[bv->buffer]; //copy on write, so no performance hit

+ print_verbose("glTF: type " + _get_type_name(p_type) + " component type: " + _get_component_type_name(p_component_type) + " stride: " + itos(stride) + " amount " + itos(p_count));

+ print_verbose("glTF: accessor offset " + itos(p_byte_offset) + " view offset: " + itos(bv->byte_offset) + " total buffer len: " + itos(buffer.size()) + " view len " + itos(bv->byte_length));

+ const int buffer_end = (stride * (p_count - 1)) + p_element_size;

+ for (int i = 0; i < p_count; i++) {

+ for (int j = 0; j < p_component_count; j++) {

+ if (p_skip_every && j > 0 && (j % p_skip_every) == 0) {

+ src += p_skip_bytes;

+ switch (p_component_type) {

+ if (p_normalized) {

+ if (p_normalized) {

+ if (p_normalized) {

+ if (p_normalized) {

+ *p_dst++ = d;

+ src += p_component_size;

+int GLTFDocument::_get_component_type_size(const int p_component_type) {

+ switch (p_component_type) {

+Vector<double> GLTFDocument::_decode_accessor(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ ERR_FAIL_INDEX_V(p_accessor, p_state->accessors.size(), Vector<double>());

+ const Ref<GLTFAccessor> a = p_state->accessors[p_accessor];

+ ERR_FAIL_INDEX_V(a->buffer_view, p_state->buffer_views.size(), Vector<double>());

+ const Error err = _decode_buffer_view(p_state, dst, a->buffer_view, skip_every, skip_bytes, element_size, a->count, a->type, component_count, a->component_type, component_size, a->normalized, a->byte_offset, p_for_vertex);

+ Error err = _decode_buffer_view(p_state, indices.ptrw(), a->sparse_indices_buffer_view, 0, 0, indices_component_size, a->sparse_count, TYPE_SCALAR, 1, a->sparse_indices_component_type, indices_component_size, false, a->sparse_indices_byte_offset, false);

+ err = _decode_buffer_view(p_state, data.ptrw(), a->sparse_values_buffer_view, skip_every, skip_bytes, element_size, a->sparse_count, a->type, component_count, a->component_type, component_size, a->normalized, a->sparse_values_byte_offset, p_for_vertex);

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_ints(Ref<GLTFState> p_state, const Vector<int32_t> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+Vector<int> GLTFDocument::_decode_accessor_as_ints(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+Vector<float> GLTFDocument::_decode_accessor_as_floats(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_vec2(Ref<GLTFState> p_state, const Vector<Vector2> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), p_attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_color(Ref<GLTFState> p_state, const Vector<Color> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), p_attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+void GLTFDocument::_calc_accessor_min_max(int p_i, const int p_element_count, Vector<double> &p_type_max, Vector<double> p_attribs, Vector<double> &p_type_min) {

+ if (p_i == 0) {

+ for (int32_t type_i = 0; type_i < p_element_count; type_i++) {

+ p_type_max.write[type_i] = p_attribs[(p_i * p_element_count) + type_i];

+ p_type_min.write[type_i] = p_attribs[(p_i * p_element_count) + type_i];

+ for (int32_t type_i = 0; type_i < p_element_count; type_i++) {

+ p_type_max.write[type_i] = MAX(p_attribs[(p_i * p_element_count) + type_i], p_type_max[type_i]);

+ p_type_min.write[type_i] = MIN(p_attribs[(p_i * p_element_count) + type_i], p_type_min[type_i]);

+ p_type_max.write[type_i] = _filter_number(p_type_max.write[type_i]);

+ p_type_min.write[type_i] = _filter_number(p_type_min.write[type_i]);

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_weights(Ref<GLTFState> p_state, const Vector<Color> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), p_attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_joints(Ref<GLTFState> p_state, const Vector<Color> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), p_attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_quaternions(Ref<GLTFState> p_state, const Vector<Quaternion> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), p_attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+Vector<Vector2> GLTFDocument::_decode_accessor_as_vec2(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_floats(Ref<GLTFState> p_state, const Vector<real_t> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_vec3(Ref<GLTFState> p_state, const Vector<Vector3> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), p_attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_xform(Ref<GLTFState> p_state, const Vector<Transform3D> p_attribs, const bool p_for_vertex) {

+ int64_t size = p_state->buffers[0].size();

+ Error err = _encode_buffer_view(p_state, attribs.ptr(), p_attribs.size(), type, component_type, accessor->normalized, size, p_for_vertex, buffer_view_i);

+ p_state->accessors.push_back(accessor);

+ return p_state->accessors.size() - 1;

+Vector<Vector3> GLTFDocument::_decode_accessor_as_vec3(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+Vector<Color> GLTFDocument::_decode_accessor_as_color(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+ const int type = p_state->accessors[p_accessor]->type;

+Vector<Quaternion> GLTFDocument::_decode_accessor_as_quaternion(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+Vector<Transform2D> GLTFDocument::_decode_accessor_as_xform2d(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+Vector<Basis> GLTFDocument::_decode_accessor_as_basis(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+Vector<Transform3D> GLTFDocument::_decode_accessor_as_xform(Ref<GLTFState> p_state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {

+ const Vector<double> attribs = _decode_accessor(p_state, p_accessor, p_for_vertex);

+Error GLTFDocument::_serialize_meshes(Ref<GLTFState> p_state) {

+ for (GLTFMeshIndex gltf_mesh_i = 0; gltf_mesh_i < p_state->meshes.size(); gltf_mesh_i++) {

+ Ref<ImporterMesh> import_mesh = p_state->meshes.write[gltf_mesh_i]->get_mesh();

+ Array instance_materials = p_state->meshes.write[gltf_mesh_i]->get_instance_materials();

+ attributes["POSITION"] = _encode_accessor_as_vec3(p_state, a, true);

+ attributes["TANGENT"] = _encode_accessor_as_color(p_state, attribs, true);

+ attributes["NORMAL"] = _encode_accessor_as_vec3(p_state, attribs, true);

+ attributes["TEXCOORD_0"] = _encode_accessor_as_vec2(p_state, a, true);

+ attributes["TEXCOORD_1"] = _encode_accessor_as_vec2(p_state, a, true);

+ attributes[gltf_texcoord_key] = _encode_accessor_as_vec2(p_state, empty, true);

+ attributes[gltf_texcoord_key] = _encode_accessor_as_vec2(p_state, first_channel, true);

+ attributes[gltf_texcoord_key] = _encode_accessor_as_vec2(p_state, second_channel, true);

+ attributes["COLOR_0"] = _encode_accessor_as_color(p_state, a, true);

+ for (GLTFNodeIndex node_i = 0; node_i < p_state->nodes.size(); node_i++) {

+ if (p_state->nodes[node_i]->mesh == gltf_mesh_i) {

+ skin_i = p_state->nodes[node_i]->skin;

+ joint_i_to_bone_i = p_state->skins[skin_i]->joint_i_to_bone_i;

+ attributes["JOINTS_0"] = _encode_accessor_as_joints(p_state, attribs, true);

+ attributes["JOINTS_0"] = _encode_accessor_as_joints(p_state, joints_0, true);

+ attributes["JOINTS_1"] = _encode_accessor_as_joints(p_state, joints_1, true);

+ attributes["WEIGHTS_0"] = _encode_accessor_as_weights(p_state, attribs, true);

+ attributes["WEIGHTS_0"] = _encode_accessor_as_weights(p_state, weights_0, true);

+ attributes["WEIGHTS_1"] = _encode_accessor_as_weights(p_state, weights_1, true);

+ primitive["indices"] = _encode_accessor_as_ints(p_state, mesh_indices, true);

+ primitive["indices"] = _encode_accessor_as_ints(p_state, generated_indices, true);

+ t["POSITION"] = _encode_accessor_as_vec3(p_state, varr, true);

+ t["NORMAL"] = _encode_accessor_as_vec3(p_state, narr, true);

+ t["TANGENT"] = _encode_accessor_as_vec3(p_state, attribs, true);

+ Ref<Material> mat = v;

+ HashMap<Ref<Material>, GLTFMaterialIndex>::Iterator material_cache_i = p_state->material_cache.find(mat);

+ GLTFMaterialIndex mat_i = p_state->materials.size();

+ p_state->materials.push_back(mat);

+ p_state->material_cache.insert(mat, mat_i);

+ if (name_i < p_state->meshes.write[gltf_mesh_i]->get_blend_weights().size()) {

+ weight = p_state->meshes.write[gltf_mesh_i]->get_blend_weights()[name_i];

+ p_state->json["meshes"] = meshes;

+Error GLTFDocument::_parse_meshes(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("meshes")) {

+ Array meshes = p_state->json["meshes"];

+ import_mesh->set_name(_gen_unique_name(p_state, vformat("%s_%s", p_state->scene_name, mesh_name)));

+ PackedVector3Array vertices = _decode_accessor_as_vec3(p_state, a["POSITION"], true);

+ array[Mesh::ARRAY_NORMAL] = _decode_accessor_as_vec3(p_state, a["NORMAL"], true);

+ array[Mesh::ARRAY_TANGENT] = _decode_accessor_as_floats(p_state, a["TANGENT"], true);

+ array[Mesh::ARRAY_TEX_UV] = _decode_accessor_as_vec2(p_state, a["TEXCOORD_0"], true);

+ array[Mesh::ARRAY_TEX_UV2] = _decode_accessor_as_vec2(p_state, a["TEXCOORD_1"], true);

+ texcoord_first = _decode_accessor_as_vec2(p_state, a[gltf_texcoord_key], true);

+ texcoord_second = _decode_accessor_as_vec2(p_state, a[gltf_texcoord_key], true);

+ array[Mesh::ARRAY_COLOR] = _decode_accessor_as_color(p_state, a["COLOR_0"], true);

+ array[Mesh::ARRAY_BONES] = _decode_accessor_as_ints(p_state, a["JOINTS_0"], true);

+ PackedInt32Array joints_0 = _decode_accessor_as_ints(p_state, a["JOINTS_0"], true);

+ PackedInt32Array joints_1 = _decode_accessor_as_ints(p_state, a["JOINTS_1"], true);

+ Vector<float> weights = _decode_accessor_as_floats(p_state, a["WEIGHTS_0"], true);

+ Vector<float> weights_0 = _decode_accessor_as_floats(p_state, a["WEIGHTS_0"], true);

+ Vector<float> weights_1 = _decode_accessor_as_floats(p_state, a["WEIGHTS_1"], true);

+ Vector<int> indices = _decode_accessor_as_ints(p_state, p["indices"], false);

+ Vector<Vector3> varr = _decode_accessor_as_vec3(p_state, t["POSITION"], true);

+ Vector<Vector3> narr = _decode_accessor_as_vec3(p_state, t["NORMAL"], true);

+ const Vector<Vector3> tangents_v3 = _decode_accessor_as_vec3(p_state, t["TANGENT"], true);

+ Ref<Material> mat;

+ if (!p_state->discard_meshes_and_materials) {

+ ERR_FAIL_INDEX_V(material, p_state->materials.size(), ERR_FILE_CORRUPT);

+ Ref<Material> mat3d = p_state->materials[material];

+

+ Ref<BaseMaterial3D> base_material = mat3d;

+ if (has_vertex_color && base_material.is_valid()) {

+ base_material->set_flag(BaseMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);

+ mat3d->set_flag(StandardMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);

+ p_state->meshes.push_back(mesh);

+ print_verbose("glTF: Total meshes: " + itos(p_state->meshes.size()));

+Error GLTFDocument::_serialize_images(Ref<GLTFState> p_state, const String &p_path) {

+ for (int i = 0; i < p_state->images.size(); i++) {

+ ERR_CONTINUE(p_state->images[i].is_null());

+ Ref<Image> image = p_state->images[i]->get_image();

+ bv->byte_offset = p_state->buffers[bi].size();

+ ERR_FAIL_INDEX_V(bi, p_state->buffers.size(), ERR_PARAMETER_RANGE_ERROR);

+ p_state->buffers.write[bi].resize(p_state->buffers[bi].size() + bv->byte_length);

+ memcpy(&p_state->buffers.write[bi].write[bv->byte_offset], buffer.ptr(), buffer.size());

+ ERR_FAIL_COND_V(bv->byte_offset + bv->byte_length > p_state->buffers[bi].size(), ERR_FILE_CORRUPT);

+ p_state->buffer_views.push_back(bv);

+ bvi = p_state->buffer_views.size() - 1;

+ String img_name = p_state->images[i]->get_name();

+ img_name = _gen_unique_name(p_state, img_name);

+ print_verbose("Total images: " + itos(p_state->images.size()));

+ p_state->json["images"] = images;

+Error GLTFDocument::_parse_images(Ref<GLTFState> p_state, const String &p_base_path) {

+ ERR_FAIL_NULL_V(p_state, ERR_INVALID_PARAMETER);

+ if (!p_state->json.has("images")) {

+ const Array &images = p_state->json["images"];

+ p_state->images.push_back(Ref<Texture2D>()); // Placeholder to keep count.

+ p_state->images.push_back(texture);

+ data = FileAccess::get_file_as_bytes(uri);

+ p_state->images.push_back(Ref<Texture2D>()); // Placeholder to keep count.

+ p_state->images.push_back(Ref<Texture2D>()); // Placeholder to keep count.

+ ERR_FAIL_INDEX_V(bvi, p_state->buffer_views.size(), ERR_PARAMETER_RANGE_ERROR);

+ Ref<GLTFBufferView> bv = p_state->buffer_views[bvi];

+ ERR_FAIL_INDEX_V(bi, p_state->buffers.size(), ERR_PARAMETER_RANGE_ERROR);

+ ERR_FAIL_COND_V(bv->byte_offset + bv->byte_length > p_state->buffers[bi].size(), ERR_FILE_CORRUPT);

+ data_ptr = &p_state->buffers[bi][bv->byte_offset];

+ p_state->images.push_back(Ref<Texture2D>());

+ p_state->images.push_back(ImageTexture::create_from_image(img));

+ print_verbose("glTF: Total images: " + itos(p_state->images.size()));

+Error GLTFDocument::_serialize_textures(Ref<GLTFState> p_state) {

+ if (!p_state->textures.size()) {

+ for (int32_t i = 0; i < p_state->textures.size(); i++) {

+ Ref<GLTFTexture> t = p_state->textures[i];

+ p_state->json["textures"] = textures;

+Error GLTFDocument::_parse_textures(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("textures")) {

+ const Array &textures = p_state->json["textures"];

+ p_state->textures.push_back(t);

+GLTFTextureIndex GLTFDocument::_set_texture(Ref<GLTFState> p_state, Ref<Texture2D> p_texture, StandardMaterial3D::TextureFilter p_filter_mode, bool p_repeats) {

+ GLTFImageIndex gltf_src_image_i = p_state->images.size();

+ p_state->images.push_back(p_texture);

+ gltf_texture->set_sampler(_set_sampler_for_mode(p_state, p_filter_mode, p_repeats));

+ GLTFTextureIndex gltf_texture_i = p_state->textures.size();

+ p_state->textures.push_back(gltf_texture);

+Ref<Texture2D> GLTFDocument::_get_texture(Ref<GLTFState> p_state, const GLTFTextureIndex p_texture) {

+ ERR_FAIL_INDEX_V(p_texture, p_state->textures.size(), Ref<Texture2D>());

+ const GLTFImageIndex image = p_state->textures[p_texture]->get_src_image();

+ ERR_FAIL_INDEX_V(image, p_state->images.size(), Ref<Texture2D>());

+ return p_state->images[image];

+GLTFTextureSamplerIndex GLTFDocument::_set_sampler_for_mode(Ref<GLTFState> p_state, StandardMaterial3D::TextureFilter p_filter_mode, bool p_repeats) {

+ for (int i = 0; i < p_state->texture_samplers.size(); ++i) {

+ if (p_state->texture_samplers[i]->get_filter_mode() == p_filter_mode) {

+ GLTFTextureSamplerIndex gltf_sampler_i = p_state->texture_samplers.size();

+ p_state->texture_samplers.push_back(gltf_sampler);

+Ref<GLTFTextureSampler> GLTFDocument::_get_sampler_for_texture(Ref<GLTFState> p_state, const GLTFTextureIndex p_texture) {

+ ERR_FAIL_INDEX_V(p_texture, p_state->textures.size(), Ref<Texture2D>());

+ const GLTFTextureSamplerIndex sampler = p_state->textures[p_texture]->get_sampler();

+ return p_state->default_texture_sampler;

+ ERR_FAIL_INDEX_V(sampler, p_state->texture_samplers.size(), Ref<GLTFTextureSampler>());

+ return p_state->texture_samplers[sampler];

+Error GLTFDocument::_serialize_texture_samplers(Ref<GLTFState> p_state) {

+ if (!p_state->texture_samplers.size()) {

+ for (int32_t i = 0; i < p_state->texture_samplers.size(); ++i) {

+ Ref<GLTFTextureSampler> s = p_state->texture_samplers[i];

+ p_state->json["samplers"] = samplers;

+Error GLTFDocument::_parse_texture_samplers(Ref<GLTFState> p_state) {

+ p_state->default_texture_sampler.instantiate();

+ p_state->default_texture_sampler->set_min_filter(GLTFTextureSampler::FilterMode::LINEAR_MIPMAP_LINEAR);

+ p_state->default_texture_sampler->set_mag_filter(GLTFTextureSampler::FilterMode::LINEAR);

+ p_state->default_texture_sampler->set_wrap_s(GLTFTextureSampler::WrapMode::REPEAT);

+ p_state->default_texture_sampler->set_wrap_t(GLTFTextureSampler::WrapMode::REPEAT);

+ if (!p_state->json.has("samplers")) {

+ const Array &samplers = p_state->json["samplers"];

+ p_state->texture_samplers.push_back(sampler);

+Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {

+ for (int32_t i = 0; i < p_state->materials.size(); i++) {

+ Ref<Material> material = p_state->materials[i];

+ d["name"] = _gen_unique_name(p_state, material->get_name());

+ Ref<BaseMaterial3D> base_material = material;

+ if (base_material.is_valid()) {

+ const Color c = base_material->get_albedo().srgb_to_linear();

+ if (base_material.is_valid()) {

+ Ref<Texture2D> albedo_texture = base_material->get_texture(BaseMaterial3D::TEXTURE_ALBEDO);

+ GLTFTextureIndex gltf_texture_index = -1;

+ if (albedo_texture.is_valid() && albedo_texture->get_image().is_valid()) {

+ albedo_texture->set_name(material->get_name() + "_albedo");

+ gltf_texture_index = _set_texture(p_state, albedo_texture, base_material->get_texture_filter(), base_material->get_flag(BaseMaterial3D::FLAG_USE_TEXTURE_REPEAT));

+ }

+ if (gltf_texture_index != -1) {

+ bct["index"] = gltf_texture_index;

+ Dictionary extensions = _serialize_texture_transform_uv1(material);

+ if (!extensions.is_empty()) {

+ bct["extensions"] = extensions;

+ p_state->use_khr_texture_transform = true;

+ }

+ mr["baseColorTexture"] = bct;

+ if (base_material.is_valid()) {

+ mr["metallicFactor"] = base_material->get_metallic();

+ mr["roughnessFactor"] = base_material->get_roughness();

+ bool has_roughness = base_material->get_texture(BaseMaterial3D::TEXTURE_ROUGHNESS).is_valid() && base_material->get_texture(BaseMaterial3D::TEXTURE_ROUGHNESS)->get_image().is_valid();

+ bool has_ao = base_material->get_feature(BaseMaterial3D::FEATURE_AMBIENT_OCCLUSION) && base_material->get_texture(BaseMaterial3D::TEXTURE_AMBIENT_OCCLUSION).is_valid();

+ bool has_metalness = base_material->get_texture(BaseMaterial3D::TEXTURE_METALLIC).is_valid() && base_material->get_texture(BaseMaterial3D::TEXTURE_METALLIC)->get_image().is_valid();

+ if (has_ao || has_roughness || has_metalness) {

+ Dictionary mrt;

+ Ref<Texture2D> roughness_texture = base_material->get_texture(BaseMaterial3D::TEXTURE_ROUGHNESS);

+ BaseMaterial3D::TextureChannel roughness_channel = base_material->get_roughness_texture_channel();

+ Ref<Texture2D> metallic_texture = base_material->get_texture(BaseMaterial3D::TEXTURE_METALLIC);

+ BaseMaterial3D::TextureChannel metalness_channel = base_material->get_metallic_texture_channel();

+ Ref<Texture2D> ao_texture = base_material->get_texture(BaseMaterial3D::TEXTURE_AMBIENT_OCCLUSION);

+ BaseMaterial3D::TextureChannel ao_channel = base_material->get_ao_texture_channel();

+ Ref<ImageTexture> orm_texture;

+ orm_texture.instantiate();

+ Ref<Image> orm_image;

+ orm_image.instantiate();

+ int32_t height = 0;

+ int32_t width = 0;

+ Ref<Image> ao_image;

+ if (has_ao) {

+ height = ao_texture->get_height();

+ width = ao_texture->get_width();

+ ao_image = ao_texture->get_image();

+ Ref<ImageTexture> img_tex = ao_image;

+ if (img_tex.is_valid()) {

+ ao_image = img_tex->get_image();

+ }

+ if (ao_image->is_compressed()) {

+ ao_image->decompress();

+ }

+ Ref<Image> roughness_image;

+ if (has_roughness) {

+ height = roughness_texture->get_height();

+ width = roughness_texture->get_width();

+ roughness_image = roughness_texture->get_image();

+ Ref<ImageTexture> img_tex = roughness_image;

+ if (img_tex.is_valid()) {

+ roughness_image = img_tex->get_image();

+ }

+ if (roughness_image->is_compressed()) {

+ roughness_image->decompress();

+ }

+ Ref<Image> metallness_image;

+ if (has_metalness) {

+ height = metallic_texture->get_height();

+ width = metallic_texture->get_width();

+ metallness_image = metallic_texture->get_image();

+ Ref<ImageTexture> img_tex = metallness_image;

+ if (img_tex.is_valid()) {

+ metallness_image = img_tex->get_image();

+ }

+ if (metallness_image->is_compressed()) {

+ metallness_image->decompress();

+ }

+ Ref<Texture2D> albedo_texture = base_material->get_texture(BaseMaterial3D::TEXTURE_ALBEDO);

+ if (albedo_texture.is_valid() && albedo_texture->get_image().is_valid()) {

+ height = albedo_texture->get_height();

+ width = albedo_texture->get_width();

+ orm_image->initialize_data(width, height, false, Image::FORMAT_RGBA8);

+ if (ao_image.is_valid() && ao_image->get_size() != Vector2(width, height)) {

+ ao_image->resize(width, height, Image::INTERPOLATE_LANCZOS);

+ if (roughness_image.is_valid() && roughness_image->get_size() != Vector2(width, height)) {

+ roughness_image->resize(width, height, Image::INTERPOLATE_LANCZOS);

+ if (metallness_image.is_valid() && metallness_image->get_size() != Vector2(width, height)) {

+ metallness_image->resize(width, height, Image::INTERPOLATE_LANCZOS);

+ }

+ for (int32_t h = 0; h < height; h++) {

+ for (int32_t w = 0; w < width; w++) {

+ Color c = Color(1.0f, 1.0f, 1.0f);

+ if (has_ao) {

+ if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_RED == ao_channel) {

+ c.r = ao_image->get_pixel(w, h).r;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_GREEN == ao_channel) {

+ c.r = ao_image->get_pixel(w, h).g;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_BLUE == ao_channel) {

+ c.r = ao_image->get_pixel(w, h).b;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_ALPHA == ao_channel) {

+ c.r = ao_image->get_pixel(w, h).a;

+ }

+ if (has_roughness) {

+ if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_RED == roughness_channel) {

+ c.g = roughness_image->get_pixel(w, h).r;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_GREEN == roughness_channel) {

+ c.g = roughness_image->get_pixel(w, h).g;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_BLUE == roughness_channel) {

+ c.g = roughness_image->get_pixel(w, h).b;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_ALPHA == roughness_channel) {

+ c.g = roughness_image->get_pixel(w, h).a;

+ }

+ if (has_metalness) {

+ if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_RED == metalness_channel) {

+ c.b = metallness_image->get_pixel(w, h).r;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_GREEN == metalness_channel) {

+ c.b = metallness_image->get_pixel(w, h).g;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_BLUE == metalness_channel) {

+ c.b = metallness_image->get_pixel(w, h).b;

+ } else if (BaseMaterial3D::TextureChannel::TEXTURE_CHANNEL_ALPHA == metalness_channel) {

+ c.b = metallness_image->get_pixel(w, h).a;

+ }

+ orm_image->set_pixel(w, h, c);

+ orm_image->generate_mipmaps();

+ orm_texture->set_image(orm_image);

+ GLTFTextureIndex orm_texture_index = -1;

+ if (has_ao || has_roughness || has_metalness) {

+ orm_texture->set_name(material->get_name() + "_orm");

+ orm_texture_index = _set_texture(p_state, orm_texture, base_material->get_texture_filter(), base_material->get_flag(BaseMaterial3D::FLAG_USE_TEXTURE_REPEAT));

+ }

+ if (has_ao) {

+ Dictionary occt;

+ occt["index"] = orm_texture_index;

+ d["occlusionTexture"] = occt;

+ }

+ if (has_roughness || has_metalness) {

+ mrt["index"] = orm_texture_index;

+ Dictionary extensions = _serialize_texture_transform_uv1(material);

+ if (!extensions.is_empty()) {

+ mrt["extensions"] = extensions;

+ p_state->use_khr_texture_transform = true;

+ }

+ mr["metallicRoughnessTexture"] = mrt;

+ if (base_material->get_feature(BaseMaterial3D::FEATURE_NORMAL_MAPPING)) {

+ Ref<Texture2D> normal_texture = base_material->get_texture(BaseMaterial3D::TEXTURE_NORMAL);

+ gltf_texture_index = _set_texture(p_state, tex, base_material->get_texture_filter(), base_material->get_flag(BaseMaterial3D::FLAG_USE_TEXTURE_REPEAT));

+ nt["scale"] = base_material->get_normal_scale();

+ if (base_material->get_feature(BaseMaterial3D::FEATURE_EMISSION)) {

+ const Color c = base_material->get_emission().linear_to_srgb();

+ if (base_material->get_feature(BaseMaterial3D::FEATURE_EMISSION)) {

+ Ref<Texture2D> emission_texture = base_material->get_texture(BaseMaterial3D::TEXTURE_EMISSION);

+ gltf_texture_index = _set_texture(p_state, emission_texture, base_material->get_texture_filter(), base_material->get_flag(BaseMaterial3D::FLAG_USE_TEXTURE_REPEAT));

+ const bool ds = base_material->get_cull_mode() == BaseMaterial3D::CULL_DISABLED;

+ if (base_material->get_transparency() == BaseMaterial3D::TRANSPARENCY_ALPHA_SCISSOR) {

+ d["alphaCutoff"] = base_material->get_alpha_scissor_threshold();

+ } else if (base_material->get_transparency() != BaseMaterial3D::TRANSPARENCY_DISABLED) {

+ p_state->json["materials"] = materials;

+ print_verbose("Total materials: " + itos(p_state->materials.size()));

+Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("materials")) {

+ const Array &materials = p_state->json["materials"];

+ Ref<GLTFTextureSampler> diffuse_sampler = _get_sampler_for_texture(p_state, diffuse_texture_dict["index"]);

+ Ref<Texture2D> diffuse_texture = _get_texture(p_state, diffuse_texture_dict["index"]);

+ const Ref<Texture2D> orig_texture = _get_texture(p_state, spec_gloss_texture["index"]);

+ Ref<GLTFTextureSampler> bct_sampler = _get_sampler_for_texture(p_state, bct["index"]);

+ material->set_texture(BaseMaterial3D::TEXTURE_ALBEDO, _get_texture(p_state, bct["index"]));

+ const Ref<Texture2D> t = _get_texture(p_state, bct["index"]);

+ material->set_texture(BaseMaterial3D::TEXTURE_NORMAL, _get_texture(p_state, bct["index"]));

+ material->set_texture(BaseMaterial3D::TEXTURE_AMBIENT_OCCLUSION, _get_texture(p_state, bct["index"]));

+ material->set_texture(BaseMaterial3D::TEXTURE_EMISSION, _get_texture(p_state, bct["index"]));

+ p_state->materials.push_back(material);

+ print_verbose("Total materials: " + itos(p_state->materials.size()));

+void GLTFDocument::_set_texture_transform_uv1(const Dictionary &p_dict, Ref<BaseMaterial3D> p_material) {

+ if (p_dict.has("extensions")) {

+ const Dictionary &extensions = p_dict["extensions"];

+ if (p_material.is_valid()) {

+ const Dictionary &texture_transform = extensions["KHR_texture_transform"];

+ const Array &offset_arr = texture_transform["offset"];

+ if (offset_arr.size() == 2) {

+ const Vector3 offset_vector3 = Vector3(offset_arr[0], offset_arr[1], 0.0f);

+ p_material->set_uv1_offset(offset_vector3);

+ }

+ const Array &scale_arr = texture_transform["scale"];

+ if (scale_arr.size() == 2) {

+ const Vector3 scale_vector3 = Vector3(scale_arr[0], scale_arr[1], 1.0f);

+ p_material->set_uv1_scale(scale_vector3);

+ }

+ if (r_spec_gloss.is_null()) {

+ return;

+ }

+ if (p_material.is_null()) {

+ return;

+ }

+GLTFNodeIndex GLTFDocument::_find_highest_node(Ref<GLTFState> p_state, const Vector<GLTFNodeIndex> &p_subset) {

+ for (int i = 0; i < p_subset.size(); ++i) {

+ const GLTFNodeIndex node_i = p_subset[i];

+ const Ref<GLTFNode> node = p_state->nodes[node_i];

+bool GLTFDocument::_capture_nodes_in_skin(Ref<GLTFState> p_state, Ref<GLTFSkin> p_skin, const GLTFNodeIndex p_node_index) {

+ for (int i = 0; i < p_state->nodes[p_node_index]->children.size(); ++i) {

+ found_joint |= _capture_nodes_in_skin(p_state, p_skin, p_state->nodes[p_node_index]->children[i]);

+ if (p_state->nodes[p_node_index]->joint && p_skin->joints.find(p_node_index) < 0) {

+ p_skin->joints.push_back(p_node_index);

+ } else if (p_skin->non_joints.find(p_node_index) < 0) {

+ p_skin->non_joints.push_back(p_node_index);

+ if (p_skin->joints.find(p_node_index) > 0) {

+void GLTFDocument::_capture_nodes_for_multirooted_skin(Ref<GLTFState> p_state, Ref<GLTFSkin> p_skin) {

+ for (int i = 0; i < p_skin->joints.size(); ++i) {

+ const GLTFNodeIndex node_index = p_skin->joints[i];

+ const GLTFNodeIndex parent = p_state->nodes[node_index]->parent;

+ if (p_skin->joints.find(parent) >= 0) {

+ if (maxHeight == -1 || p_state->nodes[root]->height < maxHeight) {

+ maxHeight = p_state->nodes[root]->height;

+ while (p_state->nodes[current_node]->height > maxHeight) {

+ GLTFNodeIndex parent = p_state->nodes[current_node]->parent;

+ if (p_state->nodes[parent]->joint && p_skin->joints.find(parent) < 0) {

+ p_skin->joints.push_back(parent);

+ } else if (p_skin->non_joints.find(parent) < 0) {

+ p_skin->non_joints.push_back(parent);

+ const GLTFNodeIndex first_parent = p_state->nodes[roots[0]]->parent;

+ all_same &= (first_parent == p_state->nodes[roots[i]]->parent);

+ const GLTFNodeIndex parent = p_state->nodes[current_node]->parent;

+ if (p_state->nodes[parent]->joint && p_skin->joints.find(parent) < 0) {

+ p_skin->joints.push_back(parent);

+ } else if (p_skin->non_joints.find(parent) < 0) {

+ p_skin->non_joints.push_back(parent);

+Error GLTFDocument::_expand_skin(Ref<GLTFState> p_state, Ref<GLTFSkin> p_skin) {

+ _capture_nodes_for_multirooted_skin(p_state, p_skin);

+ all_skin_nodes.append_array(p_skin->joints);

+ all_skin_nodes.append_array(p_skin->non_joints);

+ const GLTFNodeIndex parent = p_state->nodes[node_index]->parent;

+ const GLTFNodeIndex root = _find_highest_node(p_state, set);

+ _capture_nodes_in_skin(p_state, p_skin, out_roots[i]);

+ p_skin->roots = out_roots;

+Error GLTFDocument::_verify_skin(Ref<GLTFState> p_state, Ref<GLTFSkin> p_skin) {

+ all_skin_nodes.append_array(p_skin->joints);

+ all_skin_nodes.append_array(p_skin->non_joints);

+ const GLTFNodeIndex parent = p_state->nodes[node_index]->parent;

+ const GLTFNodeIndex root = _find_highest_node(p_state, set);

+ ERR_FAIL_COND_V(out_roots.size() != p_skin->roots.size(), FAILED);

+ ERR_FAIL_COND_V(out_roots[i] != p_skin->roots[i], FAILED);

+ const GLTFNodeIndex parent = p_state->nodes[out_roots[0]]->parent;

+ if (p_state->nodes[out_roots[i]]->parent != parent) {

+Error GLTFDocument::_parse_skins(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("skins")) {

+ const Array &skins = p_state->json["skins"];

+ skin->inverse_binds = _decode_accessor_as_xform(p_state, d["inverseBindMatrices"], false);

+ ERR_FAIL_INDEX_V(node, p_state->nodes.size(), ERR_PARSE_ERROR);

+ p_state->nodes.write[node]->joint = true;

+ p_state->skins.push_back(skin);

+ for (GLTFSkinIndex i = 0; i < p_state->skins.size(); ++i) {

+ Ref<GLTFSkin> skin = p_state->skins.write[i];

+ ERR_FAIL_COND_V(_expand_skin(p_state, skin), ERR_PARSE_ERROR);

+ ERR_FAIL_COND_V(_verify_skin(p_state, skin), ERR_PARSE_ERROR);

+ print_verbose("glTF: Total skins: " + itos(p_state->skins.size()));

+Error GLTFDocument::_determine_skeletons(Ref<GLTFState> p_state) {

+ for (GLTFSkinIndex skin_i = 0; skin_i < p_state->skins.size(); ++skin_i) {

+ const Ref<GLTFSkin> skin = p_state->skins[skin_i];

+ const GLTFNodeIndex parent = p_state->nodes[node_index]->parent;

+ highest_group_members.push_back(_find_highest_node(p_state, group));

+ if (p_state->nodes[node_i]->parent == p_state->nodes[node_j]->parent) {

+ const GLTFNodeIndex node_i_parent = p_state->nodes[node_i]->parent;

+ for (GLTFSkinIndex skin_i = 0; skin_i < p_state->skins.size(); ++skin_i) {

+ Ref<GLTFSkin> skin = p_state->skins.write[skin_i];

+ if (p_state->nodes[node_i]->joint) {

+ p_state->skeletons.push_back(skeleton);

+ _reparent_non_joint_skeleton_subtrees(p_state, p_state->skeletons.write[skel_i], non_joints);

+ for (GLTFSkeletonIndex skel_i = 0; skel_i < p_state->skeletons.size(); ++skel_i) {

+ Ref<GLTFSkeleton> skeleton = p_state->skeletons.write[skel_i];

+ Ref<GLTFNode> node = p_state->nodes[node_i];

+ ERR_FAIL_COND_V(_determine_skeleton_roots(p_state, skel_i), ERR_PARSE_ERROR);

+Error GLTFDocument::_reparent_non_joint_skeleton_subtrees(Ref<GLTFState> p_state, Ref<GLTFSkeleton> p_skeleton, const Vector<GLTFNodeIndex> &p_non_joints) {

+ for (int i = 0; i < p_non_joints.size(); ++i) {

+ const GLTFNodeIndex node_i = p_non_joints[i];

+ const GLTFNodeIndex parent_i = p_state->nodes[node_i]->parent;

+ if (parent_i >= 0 && p_non_joints.find(parent_i) >= 0 && !p_state->nodes[parent_i]->joint) {

+ Ref<GLTFNode> node = p_state->nodes[subtree_nodes[subtree_i]];

+ p_skeleton->joints.push_back(subtree_nodes[subtree_i]);

+Error GLTFDocument::_determine_skeleton_roots(Ref<GLTFState> p_state, const GLTFSkeletonIndex p_skel_i) {

+ for (GLTFNodeIndex i = 0; i < p_state->nodes.size(); ++i) {

+ const Ref<GLTFNode> node = p_state->nodes[i];

+ if (node->skeleton != p_skel_i) {

+ if (node->parent >= 0 && p_state->nodes[node->parent]->skeleton == p_skel_i) {

+ Ref<GLTFSkeleton> skeleton = p_state->skeletons.write[p_skel_i];

+ const GLTFNodeIndex root = _find_highest_node(p_state, set);

+ const GLTFNodeIndex parent = p_state->nodes[roots[0]]->parent;

+ if (p_state->nodes[roots[i]]->parent != parent) {

+Error GLTFDocument::_create_skeletons(Ref<GLTFState> p_state) {

+ for (GLTFSkeletonIndex skel_i = 0; skel_i < p_state->skeletons.size(); ++skel_i) {

+ Ref<GLTFSkeleton> gltf_skeleton = p_state->skeletons.write[skel_i];

+ p_state->skeleton3d_to_gltf_skeleton[skeleton->get_instance_id()] = skel_i;

+ skeleton->set_name(_gen_unique_name(p_state, "Skeleton3D"));

+ Ref<GLTFNode> node = p_state->nodes[node_i];

+ if (p_state->nodes[child_i]->skeleton == skel_i) {

+ node->set_name(_gen_unique_bone_name(p_state, skel_i, node->get_name()));

+ if (node->parent >= 0 && p_state->nodes[node->parent]->skeleton == skel_i) {

+ const int bone_parent = skeleton->find_bone(p_state->nodes[node->parent]->get_name());

+ skeleton->set_bone_parent(bone_index, skeleton->find_bone(p_state->nodes[node->parent]->get_name()));

+ p_state->scene_nodes.insert(node_i, skeleton);

+ ERR_FAIL_COND_V(_map_skin_joints_indices_to_skeleton_bone_indices(p_state), ERR_PARSE_ERROR);

+Error GLTFDocument::_map_skin_joints_indices_to_skeleton_bone_indices(Ref<GLTFState> p_state) {

+ for (GLTFSkinIndex skin_i = 0; skin_i < p_state->skins.size(); ++skin_i) {

+ Ref<GLTFSkin> skin = p_state->skins.write[skin_i];

+ Ref<GLTFSkeleton> skeleton = p_state->skeletons[skin->skeleton];

+ const Ref<GLTFNode> node = p_state->nodes[node_i];

+Error GLTFDocument::_serialize_skins(Ref<GLTFState> p_state) {

+ _remove_duplicate_skins(p_state);

+ for (int skin_i = 0; skin_i < p_state->skins.size(); skin_i++) {

+ Ref<GLTFSkin> gltf_skin = p_state->skins[skin_i];

+ json_skin["inverseBindMatrices"] = _encode_accessor_as_xform(p_state, gltf_skin->inverse_binds, false);

+ if (!p_state->skins.size()) {

+ p_state->json["skins"] = json_skins;

+Error GLTFDocument::_create_skins(Ref<GLTFState> p_state) {

+ for (GLTFSkinIndex skin_i = 0; skin_i < p_state->skins.size(); ++skin_i) {

+ Ref<GLTFSkin> gltf_skin = p_state->skins.write[skin_i];

+ String bone_name = p_state->nodes[node]->get_name();

+ if (p_state->use_named_skin_binds) {

+ _remove_duplicate_skins(p_state);

+ for (GLTFSkinIndex skin_i = 0; skin_i < p_state->skins.size(); ++skin_i) {

+ Ref<Skin> skin = p_state->skins.write[skin_i]->godot_skin;

+ skin->set_name(_gen_unique_name(p_state, "Skin"));

+bool GLTFDocument::_skins_are_same(const Ref<Skin> p_skin_a, const Ref<Skin> p_skin_b) {

+ if (p_skin_a->get_bind_count() != p_skin_b->get_bind_count()) {

+ for (int i = 0; i < p_skin_a->get_bind_count(); ++i) {

+ if (p_skin_a->get_bind_bone(i) != p_skin_b->get_bind_bone(i)) {

+ if (p_skin_a->get_bind_name(i) != p_skin_b->get_bind_name(i)) {

+ Transform3D a_xform = p_skin_a->get_bind_pose(i);

+ Transform3D b_xform = p_skin_b->get_bind_pose(i);

+void GLTFDocument::_remove_duplicate_skins(Ref<GLTFState> p_state) {

+ for (int i = 0; i < p_state->skins.size(); ++i) {

+ for (int j = i + 1; j < p_state->skins.size(); ++j) {

+ const Ref<Skin> skin_i = p_state->skins[i]->godot_skin;

+ const Ref<Skin> skin_j = p_state->skins[j]->godot_skin;

+ p_state->skins.write[j]->godot_skin = skin_i;

+Error GLTFDocument::_serialize_lights(Ref<GLTFState> p_state) {

+ if (p_state->lights.is_empty()) {

+ for (GLTFLightIndex i = 0; i < p_state->lights.size(); i++) {

+ lights.push_back(p_state->lights[i]->to_dictionary());

+ if (p_state->json.has("extensions")) {

+ extensions = p_state->json["extensions"];

+ p_state->json["extensions"] = extensions;

+ print_verbose("glTF: Total lights: " + itos(p_state->lights.size()));

+Error GLTFDocument::_serialize_cameras(Ref<GLTFState> p_state) {

+ cameras.resize(p_state->cameras.size());

+ for (GLTFCameraIndex i = 0; i < p_state->cameras.size(); i++) {

+ cameras[i] = p_state->cameras[i]->to_dictionary();

+ if (!p_state->cameras.size()) {

+ p_state->json["cameras"] = cameras;

+ print_verbose("glTF: Total cameras: " + itos(p_state->cameras.size()));

+Error GLTFDocument::_parse_lights(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("extensions")) {

+ Dictionary extensions = p_state->json["extensions"];

+ p_state->lights.push_back(light);

+ print_verbose("glTF: Total lights: " + itos(p_state->lights.size()));

+Error GLTFDocument::_parse_cameras(Ref<GLTFState> p_state) {

+ if (!p_state->json.has("cameras")) {

+ const Array cameras = p_state->json["cameras"];

+ p_state->cameras.push_back(GLTFCamera::from_dictionary(cameras[i]));

+ print_verbose("glTF: Total cameras: " + itos(p_state->cameras.size()));

+Error GLTFDocument::_serialize_animations(Ref<GLTFState> p_state) {

+ if (!p_state->animation_players.size()) {

+ for (int32_t player_i = 0; player_i < p_state->animation_players.size(); player_i++) {

+ AnimationPlayer *animation_player = p_state->animation_players[player_i];

+ _convert_animation(p_state, animation_player, animation_names[animation_name_i]);

+ for (GLTFAnimationIndex animation_i = 0; animation_i < p_state->animations.size(); animation_i++) {

+ Ref<GLTFAnimation> gltf_animation = p_state->animations[animation_i];

+ s["input"] = _encode_accessor_as_floats(p_state, times, false);

+ s["output"] = _encode_accessor_as_vec3(p_state, values, false);

+ s["input"] = _encode_accessor_as_floats(p_state, times, false);

+ s["output"] = _encode_accessor_as_quaternions(p_state, values, false);

+ s["input"] = _encode_accessor_as_floats(p_state, times, false);

+ s["output"] = _encode_accessor_as_vec3(p_state, values, false);