+ if (load_paths_stack) {

+ memdelete(load_paths_stack);

+ load_paths_stack = nullptr;

+ }

+thread_local Vector<String> *ResourceLoader::load_paths_stack = nullptr;

+ [b]Note:[/b] If the [member Animation.loop_mode] isn't set to looping, the [method Animation.track_set_interpolation_loop_wrap] option will not be respected. If you cannot get the expected behavior, consider duplicating the [Animation] resource and changing the loop settings.

+ To use this node, [member stream] needs to be set to a valid [AudioStream] resource. Playing more than one sound at the same time is also supported, see [member max_polyphony].

+ overlay.draw_circle(overlay.get_local_mouse_position(), 64, Color.WHITE)

+ If [code]true[/code], embed modal windows such as docks inside the main editor window. When single-window mode is enabled, tooltips will also be embedded inside the main editor window, which means they can't be displayed outside of the editor window. Single-window mode can be faster as it does not need to create a separate window for every popup and tooltip, which can be a slow operation depending on the operating system and rendering method in use.

+ This is equivalent to [member ProjectSettings.display/window/subwindows/embed_subwindows] in the running project, except the setting's value is inverted.

+ The [JSON] class enables all data types to be converted to and from a JSON string. This is useful for serializing data, e.g. to save to a file or send over the network.

+ Alternatively, you can parse strings using the static [method parse_string] method, but it doesn't handle errors.

+ Return the text parsed by [method parse] (requires passing [code]keep_text[/code] to [method parse]).

+ Returns an [enum Error]. If the parse was successful, it returns [constant OK] and the result can be retrieved using [member data]. If unsuccessful, use [method get_error_line] and [method get_error_message] to identify the source of the failure.

+ The [param indent] parameter controls if and how something is indented; its contents will be used where there should be an indent in the output. Even spaces like [code]" "[/code] will work. [code]\t[/code] and [code]\n[/code] can also be used for a tab indent, or to make a newline for each indent respectively.

+ [b]Note:[/b] Each component is stored in 32 bits in the Forward+ and Mobile rendering methods, but is packed into 16 bits in the Compatibility rendering method.

+ [b]Note:[/b] Each number is stored in 32 bits in the Forward+ and Mobile rendering methods, but is packed into 16 bits in the Compatibility rendering method.

+ If [code]true[/code], subwindows are embedded in the main window (this is also called single-window mode). Single-window mode can be faster as it does not need to create a separate window for every popup and tooltip, which can be a slow operation depending on the operating system and rendering method in use.

+ If [code]false[/code], subwindows are created as separate windows (this is also called multi-window mode). This allows them to be moved outside the main window and use native operating system window decorations.

+ This is equivalent to [member EditorSettings.interface/editor/single_window_mode] in the editor, except the setting's value is inverted.

+ - In 2D, a [CanvasItemMaterial] will need to be created and configured to use the [constant CanvasItemMaterial.BLEND_MODE_PREMULT_ALPHA] blend mode on [CanvasItem]s that use this texture. In custom [code]@canvas_item[/code] shaders, [code]render_mode blend_premul_alpha;[/code] should be used.

+ - In 3D, a [BaseMaterial3D] will need to be created and configured to use the [constant BaseMaterial3D.BLEND_MODE_PREMULT_ALPHA] blend mode on materials that use this texture. In custom [code]spatial[/code] shaders, [code]render_mode blend_premul_alpha;[/code] should be used.

+ This node should be used to implement custom IK solvers, constraints, or skeleton physics.

+<class name="TileMap" inherits="Node2D" deprecated="Use multiple [TileMapLayer] nodes instead. To convert a TileMap to a set of TileMapLayer nodes, open the TileMap bottom panel with the node selected, click the toolbox icon in the top-right corner and choose &apos;Extract TileMap layers as individual TileMapLayer nodes&apos;." keywords="gridmap" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">

+ If [member ProjectSettings.display/window/subwindows/embed_subwindows] is [code]true[/code] (single-window mode), [param rect]'s coordinates are global and relative to the main window's top-left corner (excluding window decorations). If [param rect]'s position coordinates are negative, the window will be located outside the main window and may not be visible as a result.

+ If [member ProjectSettings.display/window/subwindows/embed_subwindows] is [code]false[/code] (multi-window mode), [param rect]'s coordinates are global and relative to the top-left corner of the leftmost screen. If [param rect]'s position coordinates are negative, the window will be placed at the top-left corner of the screen.

+ [b]Note:[/b] [param rect] must be in global coordinates if specified.

+ <method name="popup_centered_clamped" keywords="minsize">

+ <method name="popup_exclusive_centered_clamped" keywords="minsize">

+ tex_info->pending_clear.remove_from_list();

+void EditorSelectionHistory::replace_object(ObjectID p_old_object, ObjectID p_new_object) {

+ for (HistoryElement &element : history) {

+ for (int index = 0; index < element.path.size(); index++) {

+ if (element.path[index].object == p_old_object) {

+ element.path.write[index].object = p_new_object;

+ }

+ }

+ }

+}

+

+ void replace_object(ObjectID p_old_object, ObjectID p_new_object);

+void EditorNode::replace_history_reimported_nodes(Node *p_original_root_node, Node *p_new_root_node, Node *p_node) {

+ NodePath scene_path_to_node = p_original_root_node->get_path_to(p_node);

+ Node *new_node = p_new_root_node->get_node_or_null(scene_path_to_node);

+ if (new_node) {

+ editor_history.replace_object(p_node->get_instance_id(), new_node->get_instance_id());

+ } else {

+ editor_history.replace_object(p_node->get_instance_id(), ObjectID());

+ }

+

+ for (int i = 0; i < p_node->get_child_count(); i++) {

+ Node *child = p_node->get_child(i);

+ replace_history_reimported_nodes(p_original_root_node, p_new_root_node, child);

+ }

+}

+

+ // Replace the old nodes in the history with the new ones.

+ // Otherwise, the history will contain old nodes, and some could still be

+ // instantiated if used elsewhere, causing the "current edited item" to be

+ // linked to a node that will be destroyed later. This caused the editor to

+ // crash when reimporting scenes with animations when "Editable children" was enabled.

+ replace_history_reimported_nodes(original_node, instantiated_node, original_node);

+

+ void replace_history_reimported_nodes(Node *p_original_root_node, Node *p_new_root_node, Node *p_node);

+

+ Button *default_input_btn = memnew(Button);

+ hb->add_child(default_input_btn);

+ register_default_input_button(p_id, j, default_input_btn);

+ default_input_btn->connect(SceneStringName(pressed), callable_mp(editor, &VisualShaderEditor::_edit_port_default_input).bind(default_input_btn, p_id, j));

+ default_input_btn->hide();

+ label->add_theme_style_override(CoreStringName(normal), editor->get_theme_stylebox(SNAME("label_style"), SNAME("VShaderEditor")));

+ String path = project_path->get_text();

+ if (path.is_empty()) {

+ path = EDITOR_GET("filesystem/directories/default_project_path");

+ }

+ fdialog_project->set_current_path(path);

+ fdialog_project->set_current_dir(path.get_base_dir());

+ fdialog_project->set_current_dir(path);

+

+ hide();

+ show_dialog(false);

+void ProjectDialog::_reset_name() {

+ project_name->set_text(TTR("New Game Project"));

+}

+

+ _reset_name();

+void ProjectDialog::show_dialog(bool p_reset_name) {

+ if (p_reset_name) {

+ _reset_name();

+ }

+ fdialog_project->connect("canceled", callable_mp(this, &ProjectDialog::show_dialog).bind(false), CONNECT_DEFERRED);

+ void _reset_name();

+ void show_dialog(bool p_reset_name = true);

+#ifndef ANDROID_ENABLED

+#endif

+#ifndef ANDROID_ENABLED

+#endif

+#ifndef ANDROID_ENABLED

+#endif

+#ifndef ANDROID_ENABLED

+#endif

+#ifndef ANDROID_ENABLED

+#endif

+#ifndef ANDROID_ENABLED

+#endif

+#ifndef ANDROID_ENABLED

+#endif

+#ifndef ANDROID_ENABLED

+ // The language selection dropdown doesn't work on Android (as the setting isn't saved), see GH-60353.

+ // Also, the dropdown it spawns is very tall and can't be scrolled without a hardware mouse.

+#endif

+#ifndef ANDROID_ENABLED

+#endif

+ const bool is_dropping_scene = ClassDB::is_parent_class(res_type, "PackedScene");

+ // Dropping as property.

+ if (p_type == 0 && p_files.size() == 1 && !is_dropping_scene) {

+ if (is_dropping_scene) {

+ p_theme->set_stylebox("label_style", "VShaderEditor", make_empty_stylebox(4, 6, 4, 6));

+ // TODO: 'ensure_cached_external_parser_for_class()' is only necessary because 'resolve_class_inheritance()' is not getting called here.

+ ensure_cached_external_parser_for_class(p_node->base_type.class_type, p_node, "Trying to fetch classes in the current scope", p_source);

+ // TODO: 'ensure_cached_external_parser_for_class()' is only necessary because 'resolve_class_inheritance()' is not getting called here.

+ ensure_cached_external_parser_for_class(p_node->outer, p_node, "Trying to fetch classes in the current scope", p_source);

+ Ref<GDScriptParserRef> parser_ref = ensure_cached_external_parser_for_class(p_class, nullptr, "Trying to resolve class inheritance", p_source);

+ ensure_cached_external_parser_for_class(look_class->base_type.class_type, look_class, "Trying to resolve class inheritance", p_source);

+ Ref<GDScriptParserRef> parser_ref = ensure_cached_external_parser_for_class(p_class, nullptr, "Trying to resolve class member", p_source);

+ ensure_cached_external_parser_for_class(member.get_datatype().class_type, p_class, "Trying to resolve datatype of class member", p_source);

+ ensure_cached_external_parser_for_class(member_type.get_container_element_type(0).class_type, p_class, "Trying to resolve datatype of class member", p_source);

+ Ref<GDScriptParserRef> parser_ref = ensure_cached_external_parser_for_class(p_class, nullptr, "Trying to resolve class interface", p_source);

+ Ref<GDScriptParserRef> parser_ref = ensure_cached_external_parser_for_class(p_class, nullptr, "Trying to resolve class body", p_source);

+Ref<GDScriptParserRef> GDScriptAnalyzer::ensure_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const GDScriptParser::ClassNode *p_from_class, const char *p_context, const GDScriptParser::Node *p_source) {

+ if (parser->has_class(p_class)) {

+ return nullptr;

+ }

+

+ parser_ref = find_cached_external_parser_for_class(p_class, parser);

+ parser_ref = find_cached_external_parser_for_class(p_class, E->value);

+ parser_ref = find_cached_external_parser_for_class(p_class, E->value);

+ push_error(vformat(R"(Parser bug (please report): Could not find external parser for class "%s". (%s))", p_class->fqcn, p_context), p_source);

+ // A null parser will be inserted into the cache, so this error won't spam for the same class.

+Ref<GDScriptParserRef> GDScriptAnalyzer::find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const Ref<GDScriptParserRef> &p_dependant_parser) {

+ return find_cached_external_parser_for_class(p_class, p_dependant_parser->get_parser());

+Ref<GDScriptParserRef> GDScriptAnalyzer::find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, GDScriptParser *p_dependant_parser) {

+

+ // TODO: Not sure if this is necessary anymore.

+ // 'type_from_variant()' should call 'resolve_class_inheritance()' which would call 'ensure_cached_external_parser_for_class()'

+ // Better safe than sorry.

+ ensure_cached_external_parser_for_class(p_preload->get_datatype().class_type, nullptr, "Trying to resolve preload", p_preload);

+ Ref<GDScriptParserRef> ensure_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const GDScriptParser::ClassNode *p_from_class, const char *p_context, const GDScriptParser::Node *p_source);

+ Ref<GDScriptParserRef> find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, const Ref<GDScriptParserRef> &p_dependant_parser);

+ Ref<GDScriptParserRef> find_cached_external_parser_for_class(const GDScriptParser::ClassNode *p_class, GDScriptParser *p_dependant_parser);

+

+ MutexLock lock(GDScriptCache::singleton->mutex);

+ GDScriptCache::singleton->parser_map.erase(path);

+ Maximum amount of streams that can be synchronized.

+ undo_redo->add_undo_method(this, "_update_value", prop, column, value ? 0 : 1);

+ // The requested target might have disconnected while the packet was in transit.

+ if (unlikely(peer > 0 && !connected_peers.has(peer))) {

+ return;

+ }

+ [b]Note:[/b] Only emitted if XR runtime supports the refresh rate extension.

+ // On Windows, setting TCP_NODELAY may fail if the socket is still connecting.

+ p_tcp->set_no_delay(true);

+ if (resolver.has_more_candidates() || tcp->get_status() == StreamPeerTCP::STATUS_CONNECTING) {

+ Indicates whether your app collects audio data.

+ Indicates whether your app links audio data to the user's identity.

+ Indicates whether your app uses audio data for tracking.

+ BitField<MouseButtonMask> last_button_state = 0;

+ if (event.xmotion.state & Button1Mask) {

+ last_button_state.set_flag(MouseButtonMask::LEFT);

+ }

+ if (event.xmotion.state & Button2Mask) {

+ last_button_state.set_flag(MouseButtonMask::MIDDLE);

+ }

+ if (event.xmotion.state & Button3Mask) {

+ last_button_state.set_flag(MouseButtonMask::RIGHT);

+ }

+ if (event.xmotion.state & Button4Mask) {

+ last_button_state.set_flag(MouseButtonMask::MB_XBUTTON1);

+ }

+ if (event.xmotion.state & Button5Mask) {

+ last_button_state.set_flag(MouseButtonMask::MB_XBUTTON2);

+ }

+

+ mm->set_pressure(bool(last_button_state.has_flag(MouseButtonMask::LEFT)) ? 1.0f : 0.0f);

+ mm->set_button_mask(last_button_state);

+ target_bin = lipo(bin_dir + "/" + prefix, env.extra_suffix + env.module_version_string)

+ app_dir = Dir("#bin/" + (prefix + env.extra_suffix + env.module_version_string).replace(".", "_") + ".app").abspath

+ if "mono" in env.module_version_string:

+ shutil.copytree(Dir("#bin/GodotSharp").abspath, app_dir + "/Contents/Resources/GodotSharp")

+ rel_target_bin = lipo(bin_dir + "/" + rel_prefix, env.extra_suffix + env.module_version_string)

+ dbg_target_bin = lipo(bin_dir + "/" + dbg_prefix, env.extra_suffix + env.module_version_string)

+ zip_dir = Dir("#bin/" + (app_prefix + env.extra_suffix + env.module_version_string).replace(".", "_")).abspath

+ Indicates whether your app collects audio data.

+ Indicates whether your app links audio data to the user's identity.

+ Indicates whether your app uses audio data for tracking.

+ bool framework_loaded = false;

+#include <dlfcn.h>

+ return framework_loaded ? OK : ERR_CANT_CREATE;

+ NSBundle *framework = [NSBundle bundleWithPath:@"/System/Library/Frameworks/OpenGL.framework"];

+ if (framework) {

+ void *library_handle = dlopen([framework.executablePath UTF8String], RTLD_NOW);

+ if (library_handle) {

+ CGLEnable = (CGLEnablePtr)dlsym(library_handle, "CGLEnable");

+ CGLSetParameter = (CGLSetParameterPtr)dlsym(library_handle, "CGLSetParameter");

+ CGLGetCurrentContext = (CGLGetCurrentContextPtr)dlsym(library_handle, "CGLGetCurrentContext");

+

+ framework_loaded = CGLEnable && CGLSetParameter && CGLGetCurrentContext;

+ }

+ }

+ bool terminated = [app terminate];

+ if (!terminated) {

+ terminated = [app forceTerminate];

+ }

+ return terminated ? OK : ERR_INVALID_PARAMETER;

+ if (OS::get_singleton()->is_layered_allowed()) {

+ DWM_BLURBEHIND bb;

+ ZeroMemory(&bb, sizeof(bb));

+ HRGN hRgn = CreateRectRgn(0, 0, -1, -1);

+ bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;

+ bb.hRgnBlur = hRgn;

+ bb.fEnable = TRUE;

+ DwmEnableBlurBehindWindow(wd.hWnd, &bb);

+ }

+ // Enable per-pixel alpha.

+ if (OS::get_singleton()->is_layered_allowed()) {

+ DWM_BLURBEHIND bb;

+ ZeroMemory(&bb, sizeof(bb));

+ HRGN hRgn = CreateRectRgn(0, 0, -1, -1);

+ bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;

+ bb.hRgnBlur = hRgn;

+ bb.fEnable = TRUE;

+ DwmEnableBlurBehindWindow(wd.hWnd, &bb);

+ }

+ // Disable per-pixel alpha.

+ if (OS::get_singleton()->is_layered_allowed()) {

+ DWM_BLURBEHIND bb;

+ ZeroMemory(&bb, sizeof(bb));

+ HRGN hRgn = CreateRectRgn(0, 0, -1, -1);

+ bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;

+ bb.hRgnBlur = hRgn;

+ bb.fEnable = FALSE;

+ DwmEnableBlurBehindWindow(wd.hWnd, &bb);

+ }

+ uint32_t pointer_id = LOWORD(wParam);

+ POINTER_INPUT_TYPE pointer_type = PT_POINTER;

+ if (!win8p_GetPointerType(pointer_id, &pointer_type)) {

+ break;

+ }

+

+ if (pointer_type != PT_PEN) {

+ break;

+ }

+

+ warnings.push_back(RTR("The TileMap node is deprecated as it is superseded by the use of multiple TileMapLayer nodes.\nTo convert a TileMap to a set of TileMapLayer nodes, open the TileMap bottom panel with this node selected, click the toolbox icon in the top-right corner and choose \"Extract TileMap layers as individual TileMapLayer nodes\"."));

+

+ add_child(simulator, false, INTERNAL_MODE_BACK);

+ cur_playback_time = anim_size;

+ next_pos = len; // Snap to the edge.

+ next_pos = 0; // Snap to the edge.

+ cd.pos = next_pos;

+

+ if (graph_node_rect.has_point(p_point)) {

+

+ // This prevents interactions with a port hotzone that is behind another node.

+ Rect2 graph_node_rect = Rect2(graph_node->get_position(), graph_node->get_size() * zoom);

+ if (graph_node_rect.has_point(mm->get_position())) {

+ break;

+ }

+ if (was_during_grabbed_click && OS::get_singleton()->get_ticks_msec() - popup_time_msec < 400) {

+ popup_time_msec = OS::get_singleton()->get_ticks_msec();

+ } else {

+ tabs.write[p_index].cb_rect = Rect2();

+bool Font::_is_base_cyclic(const Ref<Font> &p_f, int p_depth) const {

+ ERR_FAIL_COND_V(p_depth > MAX_FALLBACK_DEPTH, true);

+ if (p_f.is_null()) {

+ return false;

+ }

+ if (p_f == this) {

+ return true;

+ }

+ Ref<FontVariation> fv = p_f;

+ if (fv.is_valid()) {

+ return _is_base_cyclic(fv->get_base_font(), p_depth + 1);

+ }

+ Ref<SystemFont> fs = p_f;

+ if (fs.is_valid()) {

+ return _is_base_cyclic(fs->get_base_font(), p_depth + 1);

+ }

+ return false;

+}

+

+ if (_is_base_cyclic(f, 0)) {

+ if (!_is_base_cyclic(f, 0)) {

+ if (_is_base_cyclic(f, 0)) {

+ if (!_is_base_cyclic(f, 0)) {

+ virtual bool _is_cyclic(const Ref<Font> &p_f, int p_depth) const;

+ virtual bool _is_base_cyclic(const Ref<Font> &p_f, int p_depth) const;

+ virtual Ref<Font> get_base_font() const { return base_font; }

+/**************************************************************************/

+/* light_storage.cpp */

+/**************************************************************************/

+/* 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. */

+/**************************************************************************/

+

+#include "light_storage.h"

+

+using namespace RendererDummy;

+

+LightStorage *LightStorage::singleton = nullptr;

+

+LightStorage *LightStorage::get_singleton() {

+ return singleton;

+}

+

+LightStorage::LightStorage() {

+ singleton = this;

+}

+

+LightStorage::~LightStorage() {

+ singleton = nullptr;

+}

+

+bool LightStorage::free(RID p_rid) {

+ if (owns_lightmap(p_rid)) {

+ lightmap_free(p_rid);

+ return true;

+ } else if (owns_lightmap_instance(p_rid)) {

+ lightmap_instance_free(p_rid);

+ return true;

+ }

+

+ return false;

+}

+

+/* LIGHTMAP API */

+

+RID LightStorage::lightmap_allocate() {

+ return lightmap_owner.allocate_rid();

+}

+

+void LightStorage::lightmap_initialize(RID p_lightmap) {

+ lightmap_owner.initialize_rid(p_lightmap, Lightmap());

+}

+

+void LightStorage::lightmap_free(RID p_rid) {

+ lightmap_set_textures(p_rid, RID(), false);

+ lightmap_owner.free(p_rid);

+}

+

+/* LIGHTMAP INSTANCE */

+

+RID LightStorage::lightmap_instance_create(RID p_lightmap) {

+ LightmapInstance li;

+ li.lightmap = p_lightmap;

+ return lightmap_instance_owner.make_rid(li);

+}

+

+void LightStorage::lightmap_instance_free(RID p_lightmap) {

+ lightmap_instance_owner.free(p_lightmap);

+}

+private:

+ static LightStorage *singleton;

+ /* LIGHTMAP */

+ struct Lightmap {

+ // dummy lightmap, no data

+ };

+

+ mutable RID_Owner<Lightmap, true> lightmap_owner;

+ /* LIGHTMAP INSTANCE */

+

+ struct LightmapInstance {

+ RID lightmap;

+ };

+

+ mutable RID_Owner<LightmapInstance> lightmap_instance_owner;

+

+ static LightStorage *get_singleton();

+

+ LightStorage();

+ virtual ~LightStorage();

+

+ bool free(RID p_rid);

+ bool owns_lightmap(RID p_rid) { return lightmap_owner.owns(p_rid); }

+

+ virtual RID lightmap_allocate() override;

+ virtual void lightmap_initialize(RID p_rid) override;

+ virtual void lightmap_free(RID p_rid) override;

+ bool owns_lightmap_instance(RID p_rid) { return lightmap_instance_owner.owns(p_rid); }

+

+ RID lightmap_instance_create(RID p_lightmap) override;

+ void lightmap_instance_free(RID p_lightmap) override;

+#include "light_storage.h"

+ } else if (RendererDummy::LightStorage::get_singleton()->owns_lightmap(p_rid)) {

+ return RS::INSTANCE_LIGHTMAP;

+ if (RendererDummy::LightStorage::get_singleton()->free(p_rid)) {

+ return true;

+ } else if (RendererDummy::TextureStorage::get_singleton()->owns_texture(p_rid)) {

+ if (unlikely(!peers.has(key))) {

+ // The peer might have been disconnected due to a DTLS error.

+ // We need to wait for it to time out, just mark the packet as sent.

+ r_sent = p_len;

+ return OK;

+ }

+ // The peer might have been disconnected due to a DTLS error.

+ // We need to wait for it to time out, just mark the packet as sent.

+ r_sent = p_len;

+ return OK;

+ for (KeyValue<String, Ref<PacketPeerDTLS>> &E : peers) {

+ err = ERR_BUSY;

+ r_read = 0;

+int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {