2009-2021, Zoltan Herczeg

License: BSD-3-clause

Files: ./thirdparty/recastnavigation/

Comment: Recast

Copyright: 2009, Mikko Mononen

return abort_on_gpu_errors;

}

bool Engine::is_validation_layers_enabled() const {

return use_validation_layers;

}

double _physics_interpolation_fraction = 0.0f;

bool abort_on_gpu_errors = false;

bool use_validation_layers = false;

uint64_t _process_frames = 0;

bool _in_physics = false;

bool is_abort_on_gpu_errors_enabled() const;

bool is_validation_layers_enabled() const;

Engine();

virtual ~Engine() {}

return ::OS::get_singleton()->shell_open(p_uri);

}

List<String> args;

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

args.push_back(p_arguments[i]);

}

String pipe;

int exitcode = 0;

r_output.push_back(pipe);

if (err != OK) {

return -1;

return pid;

}

List<String> args;

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

args.push_back(p_arguments[i]);

}

::OS::ProcessID pid = 0;

if (err != OK) {

return -1;

}

ClassDB::bind_method(D_METHOD("get_processor_count"), &OS::get_processor_count);

ClassDB::bind_method(D_METHOD("get_executable_path"), &OS::get_executable_path);

ClassDB::bind_method(D_METHOD("create_instance", "arguments"), &OS::create_instance);

ClassDB::bind_method(D_METHOD("kill", "pid"), &OS::kill);

ClassDB::bind_method(D_METHOD("shell_open", "uri"), &OS::shell_open);

void crash(const String &p_message);

String get_executable_path() const;

int create_instance(const Vector<String> &p_arguments);

Error kill(int p_pid);

Error shell_open(String p_uri);

"BPTC_RGBA",

"BPTC_RGBF",

"BPTC_RGBFU",

"ETC", //etc1

"ETC2_R11", //etc2

"ETC2_R11S", //signed", NOT srgb.

return 1; //float /

case FORMAT_BPTC_RGBFU:

return 1; //unsigned float

case FORMAT_ETC:

return 1; //etc1

case FORMAT_ETC2_R11:

r_w = 4;

r_h = 4;

} break;

case FORMAT_ETC: {

r_w = 4;

r_h = 4;

}

int Image::get_format_pixel_rshift(Format p_format) {

return 1;

} else {

return 0;

}

return 4;

}

case FORMAT_ETC: {

return 4;

}

} break;

case FORMAT_DXT3:

case FORMAT_DXT5: {

detected = true;

}

} break;

case FORMAT_DXT3:

case FORMAT_DXT5: {

detected = true;

_image_decompress_bc(this);

} else if (format >= FORMAT_BPTC_RGBA && format <= FORMAT_BPTC_RGBFU && _image_decompress_bptc) {

_image_decompress_bptc(this);

} else if (format == FORMAT_ETC && _image_decompress_etc1) {

_image_decompress_etc1(this);

} else if (format >= FORMAT_ETC2_R11 && format <= FORMAT_ETC2_RA_AS_RG && _image_decompress_etc2) {

ERR_FAIL_COND_V(!_image_compress_bc_func, ERR_UNAVAILABLE);

_image_compress_bc_func(this, p_lossy_quality, p_channels);

} break;

case COMPRESS_ETC: {

ERR_FAIL_COND_V(!_image_compress_etc1_func, ERR_UNAVAILABLE);

_image_compress_etc1_func(this, p_lossy_quality);

void (*Image::_image_compress_bc_func)(Image *, float, Image::UsedChannels) = nullptr;

void (*Image::_image_compress_bptc_func)(Image *, float, Image::UsedChannels) = nullptr;

void (*Image::_image_compress_etc1_func)(Image *, float) = nullptr;

void (*Image::_image_compress_etc2_func)(Image *, float, Image::UsedChannels) = nullptr;

void (*Image::_image_decompress_bc)(Image *) = nullptr;

void (*Image::_image_decompress_bptc)(Image *) = nullptr;

void (*Image::_image_decompress_etc1)(Image *) = nullptr;

BIND_ENUM_CONSTANT(FORMAT_BPTC_RGBA); //btpc bc6h

BIND_ENUM_CONSTANT(FORMAT_BPTC_RGBF); //float /

BIND_ENUM_CONSTANT(FORMAT_BPTC_RGBFU); //unsigned float

BIND_ENUM_CONSTANT(FORMAT_ETC); //etc1

BIND_ENUM_CONSTANT(FORMAT_ETC2_R11); //etc2

BIND_ENUM_CONSTANT(FORMAT_ETC2_R11S); //signed ); NOT srgb.

BIND_ENUM_CONSTANT(ALPHA_BLEND);

BIND_ENUM_CONSTANT(COMPRESS_S3TC);

BIND_ENUM_CONSTANT(COMPRESS_ETC);

BIND_ENUM_CONSTANT(COMPRESS_ETC2);

BIND_ENUM_CONSTANT(COMPRESS_BPTC);

FORMAT_BPTC_RGBA, //btpc bc7

FORMAT_BPTC_RGBF, //float bc6h

FORMAT_BPTC_RGBFU, //unsigned float bc6hu

FORMAT_ETC, //etc1

FORMAT_ETC2_R11, //etc2

FORMAT_ETC2_R11S, //signed, NOT srgb.

static void (*_image_compress_bc_func)(Image *, float, UsedChannels p_channels);

static void (*_image_compress_bptc_func)(Image *, float p_lossy_quality, UsedChannels p_channels);

static void (*_image_compress_etc1_func)(Image *, float);

static void (*_image_compress_etc2_func)(Image *, float, UsedChannels p_channels);

static void (*_image_decompress_bc)(Image *);

static void (*_image_decompress_bptc)(Image *);

static void (*_image_decompress_etc1)(Image *);

enum CompressMode {

COMPRESS_S3TC,

COMPRESS_ETC,

COMPRESS_ETC2,

COMPRESS_BPTC,

virtual int get_low_processor_usage_mode_sleep_usec() const;

virtual String get_executable_path() const;

virtual Error create_instance(const List<String> &p_arguments, ProcessID *r_child_id = nullptr) { return create_process(get_executable_path(), p_arguments, r_child_id); };

virtual Error kill(const ProcessID &p_pid) = 0;

virtual int get_process_id() const;

}

String String::num_real(double p_num, bool p_trailing) {

} else {

}

}

#ifdef REAL_T_IS_DOUBLE

#else

#endif

}

}

String String::num_scientific(double p_num) {

r_valid = true;

}

static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {

_add_arrays(*VariantGetInternalPtr<Array>::get_ptr(r_ret), *VariantGetInternalPtr<Array>::get_ptr(left), *VariantGetInternalPtr<Array>::get_ptr(right));

}

static void ptr_evaluate(const void *left, const void *right, void *r_ret) {

[b]Note:[/b] This method is only implemented on Linux.

</description>

</method>

<method name="create_sub_window">

<return type="int" />

<argument index="0" name="mode" type="int" enum="DisplayServer.WindowMode" />

<description>

</description>

</method>

<method name="keyboard_get_current_layout" qualifiers="const">

<return type="int" />

<description>

</constant>

<constant name="FEATURE_NATIVE_DIALOG" value="9" enum="Feature">

</constant>

</constant>

</constant>

</constant>

</constant>

</constant>

</constant>

</constant>

</constant>

<constant name="MOUSE_MODE_VISIBLE" value="0" enum="MouseMode">

Makes the mouse cursor visible if it is hidden.

Returns [code]true[/code], if font supports given script ([url=https://en.wikipedia.org/wiki/ISO_15924]ISO 15924[/url] code).

</description>

</method>

<method name="remove_cache">

<return type="void" />

<argument index="0" name="cache_index" type="int" />

<return type="int" enum="Error" />

<description>

Decompresses the image if it is VRAM compressed in a supported format. Returns [constant OK] if the format is supported, otherwise [constant ERR_UNAVAILABLE].

</description>

</method>

<method name="detect_alpha" qualifiers="const">

<constant name="FORMAT_BPTC_RGBFU" value="24" enum="Format">

Texture format that uses [url=https://www.khronos.org/opengl/wiki/BPTC_Texture_Compression]BPTC[/url] compression with unsigned floating-point RGB components.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC1]Ericsson Texture Compression format 1[/url], also referred to as "ETC1", and is part of the OpenGL ES graphics standard. This format cannot store an alpha channel.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC]Ericsson Texture Compression format 2[/url] ([code]R11_EAC[/code] variant), which provides one channel of unsigned data.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC]Ericsson Texture Compression format 2[/url] ([code]SIGNED_R11_EAC[/code] variant), which provides one channel of signed data.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC]Ericsson Texture Compression format 2[/url] ([code]RG11_EAC[/code] variant), which provides two channels of unsigned data.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC]Ericsson Texture Compression format 2[/url] ([code]SIGNED_RG11_EAC[/code] variant), which provides two channels of signed data.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC]Ericsson Texture Compression format 2[/url] ([code]RGB8[/code] variant), which is a follow-up of ETC1 and compresses RGB888 data.

[b]Note:[/b] When creating an [ImageTexture], an sRGB to linear color space conversion is performed.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC]Ericsson Texture Compression format 2[/url] ([code]RGBA8[/code]variant), which compresses RGBA8888 data with full alpha support.

[b]Note:[/b] When creating an [ImageTexture], an sRGB to linear color space conversion is performed.

</constant>

[url=https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC]Ericsson Texture Compression format 2[/url] ([code]RGB8_PUNCHTHROUGH_ALPHA1[/code] variant), which compresses RGBA data to make alpha either fully transparent or fully opaque.

[b]Note:[/b] When creating an [ImageTexture], an sRGB to linear color space conversion is performed.

</constant>

</constant>

</constant>

Represents the size of the [enum Format] enum.

</constant>

<constant name="INTERPOLATE_NEAREST" value="0" enum="Interpolation">

<constant name="COMPRESS_S3TC" value="0" enum="CompressMode">

Use S3TC compression.

</constant>

Use ETC compression.

</constant>

Use ETC2 compression.

</constant>

Use BPTC compression.

</constant>

<constant name="USED_CHANNELS_L" value="0" enum="UsedChannels">

<return type="int" />

<argument index="0" name="path" type="String" />

<argument index="1" name="arguments" type="PackedStringArray" />

<description>

Creates a new process that runs independently of Godot. It will not terminate if Godot terminates. The path specified in [code]path[/code] must exist and be executable file or macOS .app bundle. Platform path resolution will be used. The [code]arguments[/code] are used in the given order and separated by a space.

If the process creation succeeds, the method will return the new process ID, which you can use to monitor the process (and potentially terminate it with [method kill]). If the process creation fails, the method will return [code]-1[/code].

For example, running another instance of the project:

[codeblocks]

<argument index="1" name="arguments" type="PackedStringArray" />

<argument index="2" name="output" type="Array" default="[]" />

<argument index="3" name="read_stderr" type="bool" default="false" />

<description>

Executes a command. The file specified in [code]path[/code] must exist and be executable. Platform path resolution will be used. The [code]arguments[/code] are used in the given order and separated by a space. If an [code]output[/code] [Array] is provided, the complete shell output of the process will be appended as a single [String] element in [code]output[/code]. If [code]read_stderr[/code] is [code]true[/code], the output to the standard error stream will be included too.

If the command is successfully executed, the method will return the exit code of the command, or [code]-1[/code] if it fails.

[b]Note:[/b] The Godot thread will pause its execution until the executed command terminates. Use [Thread] to create a separate thread that will not pause the Godot thread, or use [method create_process] to create a completely independent process.

For example, to retrieve a list of the working directory's contents:

int exitCode = OS.Execute("ls", new string[] {"-l", "/tmp"}, output);

[/csharp]

[/codeblocks]

[codeblocks]

[gdscript]

var output = []

[/csharp]

[/codeblocks]

[b]Note:[/b] This method is implemented on Android, iOS, Linux, macOS and Windows.

[b]Note:[/b] On macOS, sandboxed applications are limited to run only embedded helper executables, specified during export.

</description>

</method>

<tutorials>

</tutorials>

<members>

<member name="panorama" type="Texture2D" setter="set_panorama" getter="get_panorama">

[Texture2D] to be applied to the [PanoramaSkyMaterial].

</member>

If [code]true[/code], the texture importer will import VRAM-compressed textures using the Ericsson Texture Compression 2 algorithm. This texture compression algorithm is only supported when using the Vulkan renderer.

[b]Note:[/b] Changing this setting does [i]not[/i] impact textures that were already imported before. To make this setting apply to textures that were already imported, exit the editor, remove the [code].godot/imported/[/code] folder located inside the project folder then restart the editor (see [member application/config/use_hidden_project_data_directory]).

</member>

<member name="rendering/textures/vram_compression/import_s3tc" type="bool" setter="" getter="" default="true">

If [code]true[/code], the texture importer will import VRAM-compressed textures using the S3 Texture Compression algorithm. This algorithm is only supported on desktop platforms and consoles.

[b]Note:[/b] Changing this setting does [i]not[/i] impact textures that were already imported before. To make this setting apply to textures that were already imported, exit the editor, remove the [code].godot/imported/[/code] folder located inside the project folder then restart the editor (see [member application/config/use_hidden_project_data_directory]).

<tutorials>

</tutorials>

<members>

</member>

<member name="swizzle_a" type="int" setter="set_swizzle_a" getter="get_swizzle_a" enum="RenderingDevice.TextureSwizzle" default="6">

</member>

<tutorials>

</tutorials>

<members>

</member>

<member name="frequency" type="int" setter="set_frequency" getter="get_frequency" enum="RenderingDevice.VertexFrequency" default="0">

</member>

</constant>

<constant name="DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM" value="217" enum="DataFormat">

</constant>

</constant>

<constant name="TEXTURE_TYPE_1D" value="0" enum="TextureType">

</constant>

<return type="bool" />

<argument index="0" name="feature" type="String" />

<description>

</description>

</method>

<method name="instance_attach_object_instance_id">

</member>

<member name="text" type="String" setter="set_text" getter="get_text" default="&quot;&quot;">

The label's text in BBCode format. Is not representative of manual modifications to the internal tag stack. Erases changes made by other methods when edited.

</member>

<member name="text_direction" type="int" setter="set_text_direction" getter="get_text_direction" enum="Control.TextDirection" default="0">

Base text writing direction.

<method name="to_float" qualifiers="const">

<return type="float" />

<description>

</description>

</method>

<method name="to_int" qualifiers="const">

<return type="int" />

<description>

</description>

</method>

<method name="to_lower" qualifiers="const">

<argument index="1" name="orientation" type="int" enum="TextServer.Orientation" default="0" />

<description>

Creates new buffer for complex text layout, with the given [code]direction[/code] and [code]orientation[/code]. To free the resulting buffer, use [method free_rid] method.

</description>

</method>

<method name="draw_hex_code_box" qualifiers="const">

<argument index="1" name="direction" type="int" enum="TextServer.Direction" default="0" />

<description>

Sets desired text direction. If set to [code]TEXT_DIRECTION_AUTO[/code], direction will be detected based on the buffer contents and current locale.

</description>

</method>

<method name="shaped_text_set_orientation">

<argument index="1" name="orientation" type="int" enum="TextServer.Orientation" default="0" />

<description>

Sets desired text orientation.

</description>

</method>

<method name="shaped_text_set_preserve_control">

Aligns shaped text to the given tab-stops.

</description>

</method>

<method name="strip_diacritics" qualifiers="const">

<return type="String" />

<argument index="0" name="string" type="String" />

<constant name="FEATURE_FONT_VARIABLE" value="64" enum="Feature">

TextServer supports variable fonts.

</constant>

TextServer require external data file for some features.

</constant>

<constant name="CONTOUR_CURVE_TAG_ON" value="1" enum="ContourPointTag">

Updates justification opportunities (spaces, kashidas, etc.).

</description>

</method>

<method name="_tag_to_name" qualifiers="virtual const">

<return type="String" />

<argument index="0" name="tag" type="int" />

#define _EXT_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE

#define _EXT_ETC1_RGB8_OES 0x8D64

#define _EXT_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C

#define _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D

#define _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E

need_decompress = true;

}

} break;

case Image::FORMAT_ETC: {

if (config.etc_supported) {

r_gl_internal_format = _EXT_ETC1_RGB8_OES;

}

bool RasterizerStorageGLES3::has_os_feature(const String &p_feature) const {

return config.s3tc_supported;

return config.etc_supported;

return config.use_skeleton_software;

return false;

}

#ifdef GLES_OVER_GL

config.float_texture_supported = true;

config.s3tc_supported = true;

config.etc_supported = false;

config.support_npot_repeat_mipmap = true;

config.depth_buffer_internalformat = GL_DEPTH_COMPONENT24;

config.float_texture_supported = config.extensions.has("GL_ARB_texture_float") || config.extensions.has("GL_OES_texture_float");

config.s3tc_supported = config.extensions.has("GL_EXT_texture_compression_s3tc") || config.extensions.has("WEBGL_compressed_texture_s3tc");

config.etc_supported = config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture") || config.extensions.has("WEBGL_compressed_texture_etc1");

config.support_npot_repeat_mipmap = config.extensions.has("GL_OES_texture_npot");

#ifdef JAVASCRIPT_ENABLED

config.etc_supported = config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture");

config.latc_supported = config.extensions.has("GL_EXT_texture_compression_latc");

config.bptc_supported = config.extensions.has("GL_ARB_texture_compression_bptc");

config.rgtc_supported = config.extensions.has("GL_EXT_texture_compression_rgtc") || config.extensions.has("GL_ARB_texture_compression_rgtc") || config.extensions.has("EXT_texture_compression_rgtc");

config.bptc_supported = config.extensions.has("GL_ARB_texture_compression_bptc") || config.extensions.has("EXT_texture_compression_bptc");

config.srgb_decode_supported = config.extensions.has("GL_EXT_texture_sRGB_decode");

bool bptc_supported;

bool etc_supported;

bool etc2_supported;

bool srgb_decode_supported;

bool keep_original_textures;

p_extensions->push_back("png");

p_extensions->push_back("pvr");

p_extensions->push_back("svg");

p_extensions->push_back("tga");

p_extensions->push_back("webp");

}

extension == "png" ||

extension == "pvr" ||

extension == "svg" ||

extension == "tga" ||

extension == "webp") {

return "ImageTexture";

return longtime;

}

#ifdef __EMSCRIPTEN__

// Don't compile this code at all to avoid undefined references.

// Actual virtual call goes to OS_JavaScript.

#endif

}

#ifdef __EMSCRIPTEN__

// Don't compile this code at all to avoid undefined references.

// Actual virtual call goes to OS_JavaScript.

virtual void delay_usec(uint32_t p_usec) const override;

virtual uint64_t get_ticks_usec() const override;

virtual Error kill(const ProcessID &p_pid) override;

virtual int get_process_id() const override;

VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,

VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,

VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,

};

const char *RenderingDeviceVulkan::named_formats[RenderingDevice::DATA_FORMAT_MAX] = {

"G16_B16_R16_3Plane_422_Unorm",

"G16_B16R16_2Plane_422_Unorm",

"G16_B16_R16_3Plane_444_Unorm",

};

int RenderingDeviceVulkan::get_format_vertex_size(DataFormat p_format) {

case DATA_FORMAT_G16_B16R16_2PLANE_422_UNORM:

case DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM:

return 8;

default: {

ERR_PRINT("Format not handled, bug");

}

r_w = 4;

r_h = 4;

return;

default: {

r_w = 1;

r_h = 1;

case DATA_FORMAT_ASTC_12x12_UNORM_BLOCK:

case DATA_FORMAT_ASTC_12x12_SRGB_BLOCK:

return 8; //wrong

default: {

}

}

case DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:

case DATA_FORMAT_EAC_R11_UNORM_BLOCK:

case DATA_FORMAT_EAC_R11_SNORM_BLOCK:

return 1;

default: {

}

}

return OK;

}

/* obtain version */

_obtain_vulkan_version();

inst_info.pNext = &dbg_report_callback_create_info;

}

VkResult err = vkCreateInstance(&inst_info, nullptr, &inst);

ERR_FAIL_COND_V_MSG(err == VK_ERROR_INCOMPATIBLE_DRIVER, ERR_CANT_CREATE,

"Cannot find a compatible Vulkan installable client driver (ICD).\n\n"

volkLoadInstance(inst);

#endif

/* Make initial call to query gpu_count, then second call for gpu info*/

ERR_FAIL_COND_V(err, ERR_CANT_CREATE);

ERR_FAIL_COND_V_MSG(gpu_count == 0, ERR_CANT_CREATE,

"vkEnumeratePhysicalDevices reported zero accessible devices.\n\n"

"Do you have a compatible Vulkan installable client driver (ICD) installed?\n"

ERR_FAIL_V(ERR_CANT_CREATE);

}

// TODO: At least on Linux Laptops integrated GPUs fail with Vulkan in many instances.

// The device should really be a preference, but for now choosing a discrete GPU over the

// integrated one is better than the default.

for (uint32_t i = 0; i < gpu_count; ++i) {

VkPhysicalDeviceProperties props;

vkGetPhysicalDeviceProperties(physical_devices[i], &props);

}

}

gpu = physical_devices[device_index];

free(physical_devices);

/* Get identifier properties */

vkGetPhysicalDeviceProperties(gpu, &gpu_props);

device_name = gpu_props.deviceName;

device_type = gpu_props.deviceType;

pipeline_cache_id = String::hex_encode_buffer(gpu_props.pipelineCacheUUID, VK_UUID_SIZE);

" extension.\n\nDo you have a compatible Vulkan installable client driver (ICD) installed?\n"

"vkCreateInstance Failure");

/* Call with nullptr data to get count */

vkGetPhysicalDeviceQueueFamilyProperties(gpu, &queue_family_count, nullptr);

ERR_FAIL_COND_V(queue_family_count == 0, ERR_CANT_CREATE);

}

}

return OK;

}

Error VulkanContext::_window_create(DisplayServer::WindowID p_window_id, DisplayServer::VSyncMode p_vsync_mode, VkSurfaceKHR p_surface, int p_width, int p_height) {

ERR_FAIL_COND_V(windows.has(p_window_id), ERR_INVALID_PARAMETER);

if (!queues_initialized) {

// We use a single GPU, but we need a surface to initialize the

// queues, so this process must be deferred until a surface

// is created.

Error err = _initialize_queues(p_surface);

ERR_FAIL_COND_V(err != OK, ERR_CANT_CREATE);

}

Window window;

return FAILED;

}

#endif

return err;

}

return OK;

}

const char *pMessage,

void *pUserData);

Error _initialize_queues(VkSurfaceKHR p_surface);

}

void ConnectionsDock::_notification(int p_what) {

}

}

search_box = memnew(LineEdit);

search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL);

search_box->set_placeholder(TTR("Filter signals"));

search_box->set_clear_button_enabled(true);

search_box->connect("text_changed", callable_mp(this, &ConnectionsDock::_filter_changed));

vbc->add_child(search_box);

root->set_text(0, base_type);

root->set_icon(0, search_options->get_theme_icon(icon_fallback, SNAME("EditorIcons")));

search_options_types[base_type] = root;

const String search_text = search_box->get_text();

bool empty_search = search_text.is_empty();

// Build the type tree.

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

}

// Select the best result.

}

}

if (search_options_types.has(p_type)) {

return;

}

String inherits;

inherits = ClassDB::get_parent_class(p_type);

} else {

}

TreeItem *item = search_options->create_item(search_options_types[inherits]);

search_options_types[p_type] = item;

}

bool script_type = ScriptServer::is_global_class(p_type);

r_item->set_text(0, p_type);

} else if (script_type) {

r_item->set_metadata(0, p_type);

r_item->set_text(0, p_type + " (" + ScriptServer::get_global_class_path(p_type).get_file() + ")");

r_item->set_text(0, p_type);

}

if (!can_instantiate) {

r_item->set_custom_color(0, search_options->get_theme_color(SNAME("disabled_font_color"), SNAME("Editor")));

r_item->set_icon(0, EditorNode::get_singleton()->get_class_icon(p_type, "NodeDisabled"));

const String &description = DTR(EditorHelp::get_doc_data()->class_list[p_type].brief_description);

r_item->set_tooltip(0, description);

Ref<Texture2D> icon = EditorNode::get_editor_data().get_custom_types()[custom_type_parents[p_type]][custom_type_indices[p_type]].icon;

if (icon.is_valid()) {

r_item->set_icon(0, icon);

}

}

void CreateDialog::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_ENTER_TREE: {

connect("confirmed", callable_mp(this, &CreateDialog::_confirmed));

} break;

case NOTIFICATION_EXIT_TREE: {

disconnect("confirmed", callable_mp(this, &CreateDialog::_confirmed));

EditorSettings::get_singleton()->get_project_metadata("dialog_bounds", "create_new_node", Rect2(get_position(), get_size()));

}

} break;

}

}

hsc->add_child(vbc);

search_box = memnew(LineEdit);

search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL);

search_box->connect("text_changed", callable_mp(this, &CreateDialog::_text_changed));

search_box->connect("gui_input", callable_mp(this, &CreateDialog::_sbox_input));

class CreateDialog : public ConfirmationDialog {

GDCLASS(CreateDialog, ConfirmationDialog);

LineEdit *search_box;

Tree *search_options;

void _update_search();

bool _should_hide_type(const String &p_type) const;

String _top_result(const Vector<String> p_candidates, const String &p_search_text) const;

float _score_type(const String &p_type, const String &p_search) const;

bool _is_type_preferred(const String &p_type) const;

bool _is_class_disabled_by_feature_profile(const StringName &p_class) const;

void _load_favorites_and_history();

protected:

void _notification(int p_what);

static void _bind_methods();

node->connect("stopped", callable_mp(this, &EditorDebuggerNode::_debugger_stopped), varray(id));

node->connect("stack_frame_selected", callable_mp(this, &EditorDebuggerNode::_stack_frame_selected), varray(id));

node->connect("error_selected", callable_mp(this, &EditorDebuggerNode::_error_selected), varray(id));

node->connect("clear_execution", callable_mp(this, &EditorDebuggerNode::_clear_execution));

node->connect("breaked", callable_mp(this, &EditorDebuggerNode::_breaked), varray(id));

node->connect("remote_tree_updated", callable_mp(this, &EditorDebuggerNode::_remote_tree_updated), varray(id));

le_clear->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_live_edit_clear));

error_tree->connect("item_selected", callable_mp(this, &ScriptEditorDebugger::_error_selected));

error_tree->connect("item_activated", callable_mp(this, &ScriptEditorDebugger::_error_activated));

vmem_refresh->set_icon(get_theme_icon(SNAME("Reload"), SNAME("EditorIcons")));

vmem_export->set_icon(get_theme_icon(SNAME("Save"), SNAME("EditorIcons")));

search->set_right_icon(get_theme_icon(SNAME("Search"), SNAME("EditorIcons")));

emit_signal("clear_breakpoints");

}

void ScriptEditorDebugger::start(Ref<RemoteDebuggerPeer> p_peer) {

_clear_errors_list();

stop();

msg.push_back(p_line);

msg.push_back(p_enabled);

_put_msg("breakpoint", msg);

}

void ScriptEditorDebugger::reload_scripts() {

clear_button->set_disabled(true);

}

// Right click on specific file(s) or folder(s).

void ScriptEditorDebugger::_error_tree_item_rmb_selected(const Vector2 &p_pos) {

item_menu->clear();

line_number));

}

} break;

}

}

ADD_SIGNAL(MethodInfo("stop_requested"));

ADD_SIGNAL(MethodInfo("stack_frame_selected", PropertyInfo(Variant::INT, "frame")));

ADD_SIGNAL(MethodInfo("error_selected", PropertyInfo(Variant::INT, "error")));

ADD_SIGNAL(MethodInfo("set_execution", PropertyInfo("script"), PropertyInfo(Variant::INT, "line")));

ADD_SIGNAL(MethodInfo("clear_execution", PropertyInfo("script")));

ADD_SIGNAL(MethodInfo("breaked", PropertyInfo(Variant::BOOL, "reallydid"), PropertyInfo(Variant::BOOL, "can_debug"), PropertyInfo(Variant::STRING, "reason"), PropertyInfo(Variant::BOOL, "has_stackdump")));

docontinue->set_shortcut(ED_GET_SHORTCUT("debugger/continue"));

docontinue->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_continue));

HSplitContainer *sc = memnew(HSplitContainer);

sc->set_v_size_flags(SIZE_EXPAND_FILL);

stack_dump = memnew(Tree);

stack_dump->set_allow_reselect(true);

sc->add_child(stack_dump);

VBoxContainer *inspector_vbox = memnew(VBoxContainer);

sc->add_child(inspector_vbox);

HBoxContainer *tools_hb = memnew(HBoxContainer);

inspector->register_text_enter(search);

inspector->set_use_filter(true);

inspector_vbox->add_child(inspector);

tabs->add_child(dbg);

}

{ //errors

enum Actions {

ACTION_COPY_ERROR,

ACTION_OPEN_SOURCE,

};

AcceptDialog *msgdialog;

Button *clear_button;

PopupMenu *item_menu;

EditorFileDialog *file_dialog;

enum FileDialogPurpose {

SAVE_MONITORS_CSV,

void _clear_errors_list();

void _error_tree_item_rmb_selected(const Vector2 &p_pos);

void _item_menu_id_pressed(int p_option);

void _tab_changed(int p_tab);

void _set_breakpoint(const String &p_path, const int &p_line, const bool &p_enabled);

void _clear_breakpoints();

protected:

void _notification(int p_what);

static void _bind_methods();

extension_guess["jpeg"] = tree->get_theme_icon(SNAME("ImageTexture"), SNAME("EditorIcons"));

extension_guess["png"] = tree->get_theme_icon(SNAME("ImageTexture"), SNAME("EditorIcons"));

extension_guess["svg"] = tree->get_theme_icon(SNAME("ImageTexture"), SNAME("EditorIcons"));

extension_guess["tga"] = tree->get_theme_icon(SNAME("ImageTexture"), SNAME("EditorIcons"));

extension_guess["webp"] = tree->get_theme_icon(SNAME("ImageTexture"), SNAME("EditorIcons"));

}

String EditorExportPlatform::test_etc2() const {

}

return String();

}

virtual Error run(const Ref<EditorExportPreset> &p_preset, int p_device, int p_debug_flags) { return OK; }

virtual Ref<Texture2D> get_run_icon() const { return get_logo(); }

virtual bool can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const = 0;

virtual List<String> get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const = 0;

copy_button->set_icon(get_theme_icon(SNAME("ActionCopy"), SNAME("EditorIcons")));

collapse_button->set_icon(get_theme_icon(SNAME("CombineLines"), SNAME("EditorIcons")));

show_search_button->set_icon(get_theme_icon(SNAME("Search"), SNAME("EditorIcons")));

}

void EditorLog::_notification(int p_what) {

search_box = memnew(LineEdit);

search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL);

search_box->set_placeholder(TTR("Filter messages"));

search_box->set_clear_button_enabled(true);

search_box->set_visible(true);

search_box->connect("text_changed", callable_mp(this, &EditorLog::_search_changed));

DisplayServer::get_singleton()->window_set_mode(DisplayServer::get_singleton()->window_get_mode() == DisplayServer::WINDOW_MODE_FULLSCREEN ? DisplayServer::WINDOW_MODE_WINDOWED : DisplayServer::WINDOW_MODE_FULLSCREEN);

} break;

case EDITOR_SCREENSHOT: {

screenshot_timer->start();

} break;

ED_SHORTCUT_OVERRIDE("editor/fullscreen_mode", "macos", KeyModifierMask::CMD | KeyModifierMask::CTRL | Key::F);

p->add_shortcut(ED_GET_SHORTCUT("editor/fullscreen_mode"), SETTINGS_TOGGLE_FULLSCREEN);

p->add_separator();

if (OS::get_singleton()->get_data_path() == OS::get_singleton()->get_config_path()) {

SETTINGS_MANAGE_FEATURE_PROFILES,

SETTINGS_INSTALL_ANDROID_BUILD_TEMPLATE,

SETTINGS_PICK_MAIN_SCENE,

SETTINGS_TOGGLE_FULLSCREEN,

SETTINGS_HELP,

SCENE_TAB_CLOSE,

_initial_set("interface/editor/separate_distraction_mode", false);

_initial_set("interface/editor/automatically_open_screenshots", true);

EDITOR_SETTING_USAGE(Variant::BOOL, PROPERTY_HINT_NONE, "interface/editor/single_window_mode", false, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_RESTART_IF_CHANGED)

_initial_set("interface/editor/mouse_extra_buttons_navigate_history", true);

_initial_set("interface/editor/save_each_scene_on_quit", true); // Regression

#ifdef DEV_ENABLED

switch (p_what) {

case NOTIFICATION_TRANSLATION_CHANGED:

case Control::NOTIFICATION_LAYOUT_DIRECTION_CHANGED:

if (is_layout_rtl()) {

add_button->set_icon(groups->get_theme_icon(SNAME("Back"), SNAME("EditorIcons")));

remove_button->set_icon(groups->get_theme_icon(SNAME("Forward"), SNAME("EditorIcons")));

#include "resource_importer_bmfont.h"

#include "core/io/resource_saver.h"

String ResourceImporterBMFont::get_importer_name() const {

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "compress"), true));

}

Error ResourceImporterBMFont::import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files, Variant *r_metadata) {

print_verbose("Importing BMFont font from: " + p_source_file);

Ref<FontData> font;

font.instantiate();

int flg = ResourceSaver::SaverFlags::FLAG_BUNDLE_RESOURCES | ResourceSaver::FLAG_REPLACE_SUBRESOURCE_PATHS;

if ((bool)p_options["compress"]) {

}

print_verbose("Saving to: " + p_save_path + ".fontdata");

ERR_FAIL_COND_V_MSG(err != OK, err, "Cannot save font to file \"" + p_save_path + ".res\".");

print_verbose("Done saving to: " + p_save_path + ".fontdata");

return OK;

formats_imported.push_back("etc2");

}

if (!ok_on_pc) {

EditorNode::add_io_error("Warning, no suitable PC VRAM compression enabled in Project Settings. This texture will not display correctly on PC.");

}

"s3tc",

"etc",

"etc2",

nullptr

};

String ResourceImporterLayeredTexture::get_import_settings_string() const {

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "mipmaps/generate"), (p_preset == PRESET_3D ? true : false)));

r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "mipmaps/limit", PROPERTY_HINT_RANGE, "-1,256"), -1));

r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "roughness/mode", PROPERTY_HINT_ENUM, "Detect,Disabled,Red,Green,Blue,Alpha,Gray"), 0));

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/fix_alpha_border"), p_preset != PRESET_3D));

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/premult_alpha"), false));

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/normal_map_invert_y"), false));

r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "process/HDR_as_SRGB"), false));

r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "process/size_limit", PROPERTY_HINT_RANGE, "0,4096,1"), 0));

r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "detect_3d/compress_to", PROPERTY_HINT_ENUM, "Disabled,VRAM Compressed,Basis Universal"), (p_preset == PRESET_DETECT) ? 1 : 0));

}

void ResourceImporterTexture::save_to_stex_format(FileAccess *f, const Ref<Image> &p_image, CompressMode p_compress_mode, Image::UsedChannels p_channels, Image::CompressMode p_compress_format, float p_lossy_quality) {

int size_limit = p_options["process/size_limit"];

bool hdr_as_srgb = p_options["process/HDR_as_SRGB"];

int normal = p_options["compress/normal_map"];

int hdr_compression = p_options["compress/hdr_compression"];

int bptc_ldr = p_options["compress/bptc_ldr"];

int roughness = p_options["roughness/mode"];

String normal_map = p_options["roughness/src_normal"];

Ref<Image> normal_image;

Image::RoughnessChannel roughness_channel = Image::ROUGHNESS_CHANNEL_R;

formats_imported.push_back("etc");

}

if (!ok_on_pc) {

EditorNode::add_io_error("Warning, no suitable PC VRAM compression enabled in Project Settings. This texture will not display correctly on PC.");

}

"s3tc",

"etc",

"etc2",

nullptr

};

String ResourceImporterTexture::get_import_settings_string() const {

}

void AnimationNodeBlendTreeEditor::_update_graph() {

return;

}

return;

}

String new_name = current;

while (player->has_animation(new_name)) {

new_name = new_name + " (copy)";

}

}

void AnimationPlayerEditor::_seek_value_changed(float p_value, bool p_set, bool p_timeline_only) {

if (updating || !player || player->is_playing()) {

return;

case TOOL_PASTE_ANIM: {

Ref<Animation> anim2 = EditorSettings::get_singleton()->get_resource_clipboard();

if (!anim2.is_valid()) {

error_dialog->popup_centered();

return;

}

}

} break;

case TOOL_EDIT_RESOURCE: {

if (!animation->get_item_count()) {

tool_anim->get_popup()->add_separator();

tool_anim->get_popup()->add_shortcut(ED_SHORTCUT("animation_player_editor/copy_animation", TTR("Copy")), TOOL_COPY_ANIM);

tool_anim->get_popup()->add_shortcut(ED_SHORTCUT("animation_player_editor/paste_animation", TTR("Paste")), TOOL_PASTE_ANIM);

tool_anim->get_popup()->add_separator();

tool_anim->get_popup()->add_shortcut(ED_SHORTCUT("animation_player_editor/duplicate_animation", TTR("Duplicate")), TOOL_DUPLICATE_ANIM);

tool_anim->get_popup()->add_separator();

TOOL_REMOVE_ANIM,

TOOL_COPY_ANIM,

TOOL_PASTE_ANIM,

TOOL_EDIT_RESOURCE

};

void _animation_blend();

void _animation_edit();

void _animation_duplicate();

void _animation_resource_edit();

void _scale_changed(const String &p_scale);

void _save_animation(String p_file);

void EditorAssetLibraryItemDescription::_notification(int p_what) {

switch (p_what) {

previews_bg->add_theme_style_override("panel", previews->get_theme_stylebox(SNAME("normal"), SNAME("TextEdit")));

} break;

}

void EditorAssetLibraryItemDownload::_notification(int p_what) {

switch (p_what) {

dismiss->set_normal_texture(get_theme_icon(SNAME("Close"), SNAME("EditorIcons")));

} break;

case NOTIFICATION_PROCESS: {

}

EditorAssetLibraryItemDownload::EditorAssetLibraryItemDownload() {

HBoxContainer *hb = memnew(HBoxContainer);

icon = memnew(TextureRect);

hb->add_child(icon);

set_custom_minimum_size(Size2(310, 0) * EDSCALE);

download = memnew(HTTPRequest);

download->connect("request_completed", callable_mp(this, &EditorAssetLibraryItemDownload::_http_download_completed));

setup_http_request(download);

download_error = memnew(AcceptDialog);

download_error->set_title(TTR("Download Error"));

asset_installer = memnew(EditorAssetInstaller);

asset_installer->connect("confirmed", callable_mp(this, &EditorAssetLibraryItemDownload::_close));

prev_status = -1;

void EditorAssetLibrary::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_READY: {

error_tr->set_texture(get_theme_icon(SNAME("Error"), SNAME("EditorIcons")));

filter->set_right_icon(get_theme_icon(SNAME("Search"), SNAME("EditorIcons")));

} break;

case NOTIFICATION_VISIBILITY_CHANGED: {

if (is_visible()) {

}

} break;

case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: {

_update_repository_options();

} break;

} else {

filter->set_placeholder(TTR("Search assets (excluding templates, projects, and demos)"));

}

search_hb->add_child(filter);

filter->set_h_size_flags(Control::SIZE_EXPAND_FILL);

filter->connect("text_changed", callable_mp(this, &EditorAssetLibrary::_search_text_changed));

error_hb = memnew(HBoxContainer);

library_main->add_child(error_hb);

error_label = memnew(Label);

error_hb->add_child(error_label);

error_tr = memnew(TextureRect);

error_tr->set_v_size_flags(Control::SIZE_SHRINK_CENTER);

EditorAssetLibraryItemDescription();

};

TextureRect *icon;

Label *title;

ProgressBar *progress;

int fc = frames->get_frame_count(edited_anim);

for (Set<int>::Element *E = frames_selected.front(); E; E = E->next()) {

int idx = E->get();

Point2 frame_coords(idx % frame_count_x, idx / frame_count_x);

Ref<AtlasTexture> at;

at.instantiate();

at->set_atlas(split_sheet_preview->get_texture());

undo_redo->add_do_method(frames, "add_frame", edited_anim, at, -1);

undo_redo->add_undo_method(frames, "remove_frame", edited_anim, fc);

presets.insert("s3tc");

presets.insert("etc");

presets.insert("etc2");

presets.insert("debug");

presets.insert("release");

presets.insert("editor");

action_map->update_action_list(actions);

}

void ProjectSettingsEditor::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_VISIBILITY_CHANGED: {

} break;

case NOTIFICATION_ENTER_TREE: {

inspector->edit(ps);

_update_action_map_editor();

} break;

}

}

search_box = memnew(LineEdit);

search_box->set_placeholder(TTR("Filter Settings"));

search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL);

search_bar->add_child(search_box);

void _action_renamed(const String &p_old_name, const String &p_new_name);

void _action_reordered(const String &p_action_name, const String &p_relative_to, bool p_before);

void _update_action_map_editor();

protected:

void _notification(int p_what);

popup_centered_clamped(Size2(350, 700) * EDSCALE);

}

void SceneTreeDialog::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_VISIBILITY_CHANGED: {

} break;

case NOTIFICATION_ENTER_TREE: {

connect("confirmed", callable_mp(this, &SceneTreeDialog::_select));

} break;

case NOTIFICATION_EXIT_TREE: {

disconnect("confirmed", callable_mp(this, &SceneTreeDialog::_select));

filter = memnew(LineEdit);

filter->set_h_size_flags(Control::SIZE_EXPAND_FILL);

filter->set_placeholder(TTR("Filter nodes"));

filter->add_theme_constant_override("minimum_character_width", 0);

filter->connect("text_changed", callable_mp(this, &SceneTreeDialog::_filter_changed));

vbc->add_child(filter);

void _select();

void _cancel();

void _filter_changed(const String &p_filter);

protected:

void _notification(int p_what);

OS::get_singleton()->print("].\n");

OS::get_singleton()->print(" --rendering-driver <driver> Rendering driver (depends on display driver).\n");

OS::get_singleton()->print(" --text-driver <driver> Text driver (Fonts, BiDi, shaping)\n");

} else if (I->get() == "-w" || I->get() == "--windowed") { // force windowed window

init_windowed = true;

} else if (I->get() == "--vk-layers") {

Engine::singleton->use_validation_layers = true;

#ifdef DEBUG_ENABLED

GLOBAL_DEF("application/config/icon", String());

ProjectSettings::get_singleton()->set_custom_property_info("application/config/icon",

PropertyInfo(Variant::STRING, "application/config/icon",

GLOBAL_DEF("application/config/macos_native_icon", String());

ProjectSettings::get_singleton()->set_custom_property_info("application/config/macos_native_icon",

}

if (project_manager || editor) {

// Load SSL Certificates from Editor Settings (or builtin)

Crypto::load_default_certificates(

EditorSettings::get_singleton()->get_setting("network/ssl/editor_ssl_certificates").operator String());

# Colors are disabled in non-TTY environments such as pipes. This means

# that if output is redirected to a file, it will not contain color codes

if sys.stdout.isatty():

else:

colors["blue"] = ""

)

)

)

)

)

)

)

)

env.Append(CXXCOMSTR=[compile_source_message])

env.vs_incs.append(str(header))

module_configs = ModuleConfigs()

if env.get("module_mono_enabled"):

mono_root = env.get("mono_prefix") or mono_reg.find_mono_root_dir(env["bits"])

if mono_root:

module_configs.add_mode(

bool in_keyword = false;

bool in_word = false;

bool in_function_name = false;

bool in_variable_declaration = false;

bool in_function_args = false;

bool in_member_variable = false;

bool in_node_path = false;

/* color regions */

if (is_a_symbol || in_region != -1) {

int from = j;

}

}

if (from != line_length) {

/* check if it's the whole line */

if (end_key_length == 0 || color_regions[c].line_only || from + end_key_length > line_length) {

prev_color = color_regions[in_region].color;

highlighter_info["color"] = color_regions[c].color;

color_map[j] = highlighter_info;

/* if we are in one find the end key */

if (in_region != -1) {

/* search the line */

int region_end_index = -1;

int end_key_length = color_regions[in_region].end_key.length();

const char32_t *end_key = color_regions[in_region].end_key.get_data();

for (; from < line_length; from++) {

if (line_length - from < end_key_length) {

}

if (!is_symbol(str[from])) {

}

if (str[from] == '\\') {

from++;

continue;

}

}

}

previous_type = REGION;

previous_text = "";

previous_column = j;

}

if (!in_function_name && in_word && !in_keyword) {

}

}

}

in_variable_declaration = false;

in_function_name = false;

in_member_variable = false;

}

} else if (in_member_variable) {

next_type = MEMBER;

color = member_color;

} else if (in_function_name) {

next_type = FUNCTION;

color = function_definition_color;

} else {

color = function_color;

SYMBOL,

NUMBER,

FUNCTION,

KEYWORD,

MEMBER,

IDENTIFIER,

GDScriptParser::DataType result;

result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;

result.kind = GDScriptParser::DataType::ENUM_VALUE;

result.native_type = base.native_type;

result.enum_type = name;

p_identifier->set_datatype(result);

void GDScriptByteCodeGenerator::write_end_ternary() {

patch_jump(ternary_jump_skip_pos.back()->get());

ternary_jump_skip_pos.pop_back();

}

void GDScriptByteCodeGenerator::write_set(const Address &p_target, const Address &p_index, const Address &p_source) {

}

void GDScriptParser::TreePrinter::print_identifier(IdentifierNode *p_identifier) {

}

void GDScriptParser::TreePrinter::print_if(IfNode *p_if, bool p_is_elif) {

}

}

void GridMapEditor::_notification(int p_what) {

switch (p_what) {

case NOTIFICATION_ENTER_TREE: {

_update_selection_transform();

_update_paste_indicator();

} break;

case NOTIFICATION_EXIT_TREE: {

} break;

case NOTIFICATION_THEME_CHANGED: {

} break;

case NOTIFICATION_APPLICATION_FOCUS_OUT: {

mode_thumbnail->set_flat(true);

mode_thumbnail->set_toggle_mode(true);

mode_thumbnail->set_pressed(true);

hb->add_child(mode_thumbnail);

mode_thumbnail->connect("pressed", callable_mp(this, &GridMapEditor::_set_display_mode), varray(DISPLAY_THUMBNAIL));

mode_list->set_flat(true);

mode_list->set_toggle_mode(true);

mode_list->set_pressed(false);

hb->add_child(mode_list);

mode_list->connect("pressed", callable_mp(this, &GridMapEditor::_set_display_mode), varray(DISPLAY_LIST));

void _update_cursor_transform();

void _update_cursor_instance();

void _update_clip();

void _text_changed(const String &p_text);

void _sbox_input(const Ref<InputEvent> &p_ie);

CRASH_COND(p_script->native == nullptr);

p_script->valid = true;

update_script_class_info(p_script);

}

Error CSharpScript::reload(bool p_keep_state) {

}

GD_MONO_SCOPE_THREAD_ATTACH;

void CSharpScript::_clear() {

tool = false;

valid = false;

base = nullptr;

native = nullptr;

bool tool = false;

bool valid = false;

bool builtin;

/*************************************************************************/

String TextServerAdvanced::interface_name = "ICU / HarfBuzz / Graphite";

bool TextServerAdvanced::has_feature(Feature p_feature) const {

return (interface_features & p_feature) == p_feature;

return result;

}

TextServerAdvanced::TextServerAdvanced() {

_insert_num_systems_lang();

_insert_feature_sets();

virtual String strip_diacritics(const String &p_string) const override;

TextServerAdvanced();

~TextServerAdvanced();

};

#include "core/error/error_macros.h"

#include "core/string/print_string.h"

#include "modules/modules_enabled.gen.h" // For freetype, msdfgen.

return sd->uthk;

}

TextServerFallback::TextServerFallback() {

_insert_feature_sets();

};

virtual float shaped_text_get_underline_position(RID p_shaped) const override;

virtual float shaped_text_get_underline_thickness(RID p_shaped) const override;

TextServerFallback();

~TextServerFallback();

};

bool DisplayServerAndroid::has_feature(Feature p_feature) const {

switch (p_feature) {

case FEATURE_CURSOR_SHAPE:

//case FEATURE_CUSTOM_CURSOR_SHAPE:

//case FEATURE_GLOBAL_MENU:

bool DisplayServerIPhone::has_feature(Feature p_feature) const {

switch (p_feature) {

// case FEATURE_CURSOR_SHAPE:

// case FEATURE_CUSTOM_CURSOR_SHAPE:

// case FEATURE_GLOBAL_MENU:

void EditorExportPlatformIOS::get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features) {

String driver = ProjectSettings::get_singleton()->get("rendering/driver/driver_name");

Vector<String> architectures = _get_preset_architectures(p_preset);

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

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "privacy/microphone_usage_description", PROPERTY_HINT_PLACEHOLDER_TEXT, "Provide a message if you need to use the microphone"), ""));

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "privacy/photolibrary_usage_description", PROPERTY_HINT_PLACEHOLDER_TEXT, "Provide a message if you need access to the photo library"), ""));

r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "storyboard/use_launch_screen_storyboard"), false));

r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "storyboard/image_scale_mode", PROPERTY_HINT_ENUM, "Same as Logo,Center,Scale to Fit,Scale to Fill,Scale"), 0));

r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "storyboard/use_custom_bg_color"), false));

r_options->push_back(ExportOption(PropertyInfo(Variant::COLOR, "storyboard/custom_bg_color"), Color()));

for (uint64_t i = 0; i < sizeof(loading_screen_infos) / sizeof(loading_screen_infos[0]); ++i) {

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, loading_screen_infos[i].preset_key, PROPERTY_HINT_FILE, "*.png"), ""));

}

const char *actual_size_side;

const char *scale;

const char *unscaled_size;

};

static const IconInfo icon_infos[] = {

};

Error EditorExportPlatformIOS::_export_icons(const Ref<EditorExportPreset> &p_preset, const String &p_iconset_dir) {

int side_size = String(info.actual_size_side).to_int();

String icon_path = p_preset->get(info.preset_key);

if (icon_path.length() == 0) {

}

} else {

Ref<Image> img = memnew(Image);

Error err = ImageLoader::load_image(icon_path, img);

if (err != OK) {

return ERR_UNCONFIGURED;

}

if (img->get_width() != side_size || img->get_height() != side_size) {

}

if (err) {

memdelete(da);

String err_str = String("Failed to export icon(" + String(info.preset_key) + "): '" + icon_path + "'.");

for (uint64_t i = 0; i < sizeof(loading_screen_infos) / sizeof(loading_screen_infos[0]); ++i) {

LoadingScreenInfo info = loading_screen_infos[i];

String loading_screen_file = p_preset->get(info.preset_key);

if (loading_screen_file.size() > 0) {

Ref<Image> img = memnew(Image);

Error err = ImageLoader::load_image(loading_screen_file, img);

if (err != OK) {

return ERR_UNCONFIGURED;

}

if (img->get_width() != info.width || img->get_height() != info.height) {

}

if (err) {

memdelete(da);

String err_str = String("Failed to export loading screen (") + info.preset_key + ") from path '" + loading_screen_file + "'.";

ERR_PRINT(err_str.utf8().get_data());

return err;

}

// Generate loading screen from the splash screen

Ref<Image> img = memnew(Image);

img->create(info.width, info.height, false, Image::FORMAT_RGBA8);

img->fill(boot_bg_color);

String err_str = String("Failed to export loading screen (") + info.preset_key + ") from splash screen.";

WARN_PRINT(err_str.utf8().get_data());

}

}

}

memdelete(da);

valid = false;

}

if (!etc_error.is_empty()) {

valid = false;

err += etc_error;

bool DisplayServerJavaScript::has_feature(Feature p_feature) const {

switch (p_feature) {

//case FEATURE_GLOBAL_MENU:

//case FEATURE_HIDPI:

//case FEATURE_IME:

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "progressive_web_app/offline_page", PROPERTY_HINT_FILE, "*.html"), ""));

r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "progressive_web_app/display", PROPERTY_HINT_ENUM, "Fullscreen,Standalone,Minimal UI,Browser"), 1));

r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "progressive_web_app/orientation", PROPERTY_HINT_ENUM, "Any,Landscape,Portrait"), 0));

r_options->push_back(ExportOption(PropertyInfo(Variant::COLOR, "progressive_web_app/background_color", PROPERTY_HINT_COLOR_NO_ALPHA), Color()));

}

// Miscellaneous

return create_process(p_path, p_arguments);

}

Array args;

for (const String &E : p_arguments) {

args.push_back(E);

MainLoop *get_main_loop() const override;

bool main_loop_iterate();

Error kill(const ProcessID &p_pid) override;

int get_process_id() const override;

int get_processor_count() const override;

virtual void set_native_icon(const String &p_filename) override;

virtual void set_icon(const Ref<Image> &p_icon) override;

static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error);

static Vector<String> get_rendering_drivers_func();

case FEATURE_CURSOR_SHAPE:

case FEATURE_CUSTOM_CURSOR_SHAPE:

case FEATURE_NATIVE_DIALOG:

case FEATURE_IME:

case FEATURE_WINDOW_TRANSPARENCY:

case FEATURE_HIDPI:

#endif

}

DisplayServerOSX::DisplayServerOSX(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {

Input::get_singleton()->set_event_dispatch_function(_dispatch_input_events);

String get_locale() const override;

virtual String get_executable_path() const override;

virtual Error create_instance(const List<String> &p_arguments, ProcessID *r_child_id = nullptr) override;

virtual String get_unique_id() const override; //++

if (nsappname != nil) {

String path;

path.parse_utf8([[[NSBundle mainBundle] bundlePath] UTF8String]);

} else {

}

}

if (@available(macOS 10.15, *)) {

// Use NSWorkspace if path is an .app bundle.

NSURL *url = [NSURL fileURLWithPath:@(p_path.utf8().get_data())];

return err;

} else {

}

} else {

}

}

// TODO

}

return FAILED;

};

return FAILED;

};

virtual void delay_usec(uint32_t p_usec) const;

virtual uint64_t get_ticks_usec() const;

virtual Error kill(const ProcessID &p_pid);

virtual bool has_environment(const String &p_var) const;

# Vista support dropped after EOL due to GH-10243

("target_win_version", "Targeted Windows version, >= 0x0601 (Windows 7)", "0x0601"),

BoolVariable("debug_symbols", "Add debugging symbols to release/release_debug builds", True),

BoolVariable("separate_debug_symbols", "Create a separate file containing debugging symbols", False),

("msvc_version", "MSVC version to use. Ignored if VCINSTALLDIR is set in shell env.", None),

BoolVariable("use_mingw", "Use the Mingw compiler, even if MSVC is installed.", False),

# Build type

if env["target"] == "release":

if env["optimize"] == "speed": # optimize for speed (default)

env.Append(CCFLAGS=["/O2"])

## Build type

if env["target"] == "release":

env.Append(CCFLAGS=["-msse2"])

case FEATURE_CLIPBOARD:

case FEATURE_CURSOR_SHAPE:

case FEATURE_CUSTOM_CURSOR_SHAPE:

case FEATURE_IME:

case FEATURE_WINDOW_TRANSPARENCY:

case FEATURE_HIDPI:

ImmReleaseContext(wd.hWnd, himc);

}

void DisplayServerWindows::cursor_set_shape(CursorShape p_shape) {

_THREAD_SAFE_METHOD_

shift_mem = false;

control_mem = false;

meta_mem = false;

hInstance = ((OS_Windows *)OS::get_singleton())->get_hinstance();

pressrc = 0;

bool use_raw_input = false;

bool drop_events = false;

bool in_dispatch_input_event = false;

WNDCLASSEXW wc;

virtual void window_attach_instance_id(ObjectID p_instance, WindowID p_window = MAIN_WINDOW_ID) override;

virtual ObjectID window_get_attached_instance_id(WindowID p_window = MAIN_WINDOW_ID) const override;

virtual void window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;

virtual void window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, WindowID p_window = MAIN_WINDOW_ID) override;

virtual DisplayServer::VSyncMode window_get_vsync_mode(WindowID p_vsync_mode) const override;

virtual void cursor_set_shape(CursorShape p_shape) override;

virtual CursorShape cursor_get_shape() const override;

virtual void cursor_set_custom_image(const RES &p_cursor, CursorShape p_shape = CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;

#include <regstr.h>

#include <shlobj.h>

extern "C" {

__declspec(dllexport) DWORD NvOptimusEnablement = 1;

__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;

}

void RedirectIOToConsole() {

}

BOOL WINAPI HandlerRoutine(_In_ DWORD dwCtrlType) {

void OS_Windows::initialize() {

crash_handler.initialize();

FileAccess::make_default<FileAccessWindows>(FileAccess::ACCESS_RESOURCES);

FileAccess::make_default<FileAccessWindows>(FileAccess::ACCESS_USERDATA);

return p_text;

}

String path = p_path.replace("/", "\\");

String command = _quote_command_line_argument(path);

for (const String &E : p_arguments) {

command += " " + _quote_command_line_argument(E);

}

if (r_pipe) {

if (read_stderr) {

}

if (p_pipe_mutex) {

p_pipe_mutex->lock();

}

if (p_pipe_mutex) {

p_pipe_mutex->unlock();

}

}

if (r_exitcode) {

DWORD ret2;

GetExitCodeProcess(pi.pi.hProcess, &ret2);

*r_exitcode = ret2;

}

CloseHandle(pi.pi.hProcess);

CloseHandle(pi.pi.hThread);

return OK;

};