godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/ru/class_os.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

1972 lines
173 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_OS:
OS
==
**Наследует:** :ref:`Object<class_Object>`
Предоставляет доступ к общим функциям операционной системы.
.. rst-class:: classref-introduction-group
Описание
----------------
Класс **OS** охватывает наиболее распространенные функции для взаимодействия с операционной системой хоста, такие как видеодрайвер, задержки, переменные среды, выполнение двоичных файлов, командная строка и т. д.
\ **Примечание:** В Godot 4 функции **OS**, связанные с управлением окнами, буфером обмена и TTS, были перемещены в синглтон :ref:`DisplayServer<class_DisplayServer>` (и класс :ref:`Window<class_Window>`). Функции, связанные со временем, были удалены и доступны только в классе :ref:`Time<class_Time>`.
.. rst-class:: classref-introduction-group
Обучающие материалы
--------------------------------------
- `Демонстрация тестирования операционной системы <https://godotengine.org/asset-library/asset/2789>`__
.. rst-class:: classref-reftable-group
Свойства
----------------
.. table::
:widths: auto
+-------------------------+---------------------------------------------------------------------------------------------------+-----------+
| :ref:`bool<class_bool>` | :ref:`delta_smoothing<class_OS_property_delta_smoothing>` | ``true`` |
+-------------------------+---------------------------------------------------------------------------------------------------+-----------+
| :ref:`bool<class_bool>` | :ref:`low_processor_usage_mode<class_OS_property_low_processor_usage_mode>` | ``false`` |
+-------------------------+---------------------------------------------------------------------------------------------------+-----------+
| :ref:`int<class_int>` | :ref:`low_processor_usage_mode_sleep_usec<class_OS_property_low_processor_usage_mode_sleep_usec>` | ``6900`` |
+-------------------------+---------------------------------------------------------------------------------------------------+-----------+
.. rst-class:: classref-reftable-group
Методы
------------
.. table::
:widths: auto
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_logger<class_OS_method_add_logger>`\ (\ logger\: :ref:`Logger<class_Logger>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`alert<class_OS_method_alert>`\ (\ text\: :ref:`String<class_String>`, title\: :ref:`String<class_String>` = "Alert!"\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`close_midi_inputs<class_OS_method_close_midi_inputs>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`crash<class_OS_method_crash>`\ (\ message\: :ref:`String<class_String>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`create_instance<class_OS_method_create_instance>`\ (\ arguments\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`create_process<class_OS_method_create_process>`\ (\ path\: :ref:`String<class_String>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>`, open_console\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`delay_msec<class_OS_method_delay_msec>`\ (\ msec\: :ref:`int<class_int>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`delay_usec<class_OS_method_delay_usec>`\ (\ usec\: :ref:`int<class_int>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`execute<class_OS_method_execute>`\ (\ path\: :ref:`String<class_String>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>`, output\: :ref:`Array<class_Array>` = [], read_stderr\: :ref:`bool<class_bool>` = false, open_console\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Dictionary<class_Dictionary>` | :ref:`execute_with_pipe<class_OS_method_execute_with_pipe>`\ (\ path\: :ref:`String<class_String>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>`, blocking\: :ref:`bool<class_bool>` = true\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Key<enum_@GlobalScope_Key>` | :ref:`find_keycode_from_string<class_OS_method_find_keycode_from_string>`\ (\ string\: :ref:`String<class_String>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_cache_dir<class_OS_method_get_cache_dir>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_cmdline_args<class_OS_method_get_cmdline_args>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_cmdline_user_args<class_OS_method_get_cmdline_user_args>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_config_dir<class_OS_method_get_config_dir>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_connected_midi_inputs<class_OS_method_get_connected_midi_inputs>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_data_dir<class_OS_method_get_data_dir>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_distribution_name<class_OS_method_get_distribution_name>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`get_entropy<class_OS_method_get_entropy>`\ (\ size\: :ref:`int<class_int>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_environment<class_OS_method_get_environment>`\ (\ variable\: :ref:`String<class_String>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_executable_path<class_OS_method_get_executable_path>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_granted_permissions<class_OS_method_get_granted_permissions>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_keycode_string<class_OS_method_get_keycode_string>`\ (\ code\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_locale<class_OS_method_get_locale>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_locale_language<class_OS_method_get_locale_language>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_main_thread_id<class_OS_method_get_main_thread_id>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Dictionary<class_Dictionary>` | :ref:`get_memory_info<class_OS_method_get_memory_info>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_model_name<class_OS_method_get_model_name>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_name<class_OS_method_get_name>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_process_exit_code<class_OS_method_get_process_exit_code>`\ (\ pid\: :ref:`int<class_int>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_process_id<class_OS_method_get_process_id>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_processor_count<class_OS_method_get_processor_count>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_processor_name<class_OS_method_get_processor_name>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_restart_on_exit_arguments<class_OS_method_get_restart_on_exit_arguments>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_static_memory_peak_usage<class_OS_method_get_static_memory_peak_usage>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_static_memory_usage<class_OS_method_get_static_memory_usage>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`StdHandleType<enum_OS_StdHandleType>` | :ref:`get_stderr_type<class_OS_method_get_stderr_type>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`StdHandleType<enum_OS_StdHandleType>` | :ref:`get_stdin_type<class_OS_method_get_stdin_type>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`StdHandleType<enum_OS_StdHandleType>` | :ref:`get_stdout_type<class_OS_method_get_stdout_type>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_system_ca_certificates<class_OS_method_get_system_ca_certificates>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_system_dir<class_OS_method_get_system_dir>`\ (\ dir\: :ref:`SystemDir<enum_OS_SystemDir>`, shared_storage\: :ref:`bool<class_bool>` = true\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_system_font_path<class_OS_method_get_system_font_path>`\ (\ font_name\: :ref:`String<class_String>`, weight\: :ref:`int<class_int>` = 400, stretch\: :ref:`int<class_int>` = 100, italic\: :ref:`bool<class_bool>` = false\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_system_font_path_for_text<class_OS_method_get_system_font_path_for_text>`\ (\ font_name\: :ref:`String<class_String>`, text\: :ref:`String<class_String>`, locale\: :ref:`String<class_String>` = "", script\: :ref:`String<class_String>` = "", weight\: :ref:`int<class_int>` = 400, stretch\: :ref:`int<class_int>` = 100, italic\: :ref:`bool<class_bool>` = false\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_system_fonts<class_OS_method_get_system_fonts>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_temp_dir<class_OS_method_get_temp_dir>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_thread_caller_id<class_OS_method_get_thread_caller_id>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_unique_id<class_OS_method_get_unique_id>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_user_data_dir<class_OS_method_get_user_data_dir>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_version<class_OS_method_get_version>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_version_alias<class_OS_method_get_version_alias>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_video_adapter_driver_info<class_OS_method_get_video_adapter_driver_info>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_environment<class_OS_method_has_environment>`\ (\ variable\: :ref:`String<class_String>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_feature<class_OS_method_has_feature>`\ (\ tag_name\: :ref:`String<class_String>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_debug_build<class_OS_method_is_debug_build>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_keycode_unicode<class_OS_method_is_keycode_unicode>`\ (\ code\: :ref:`int<class_int>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_process_running<class_OS_method_is_process_running>`\ (\ pid\: :ref:`int<class_int>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_restart_on_exit_set<class_OS_method_is_restart_on_exit_set>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_sandboxed<class_OS_method_is_sandboxed>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_stdout_verbose<class_OS_method_is_stdout_verbose>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_userfs_persistent<class_OS_method_is_userfs_persistent>`\ (\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`kill<class_OS_method_kill>`\ (\ pid\: :ref:`int<class_int>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`move_to_trash<class_OS_method_move_to_trash>`\ (\ path\: :ref:`String<class_String>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`open_midi_inputs<class_OS_method_open_midi_inputs>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`open_with_program<class_OS_method_open_with_program>`\ (\ program_path\: :ref:`String<class_String>`, paths\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`read_buffer_from_stdin<class_OS_method_read_buffer_from_stdin>`\ (\ buffer_size\: :ref:`int<class_int>` = 1024\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`read_string_from_stdin<class_OS_method_read_string_from_stdin>`\ (\ buffer_size\: :ref:`int<class_int>` = 1024\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_logger<class_OS_method_remove_logger>`\ (\ logger\: :ref:`Logger<class_Logger>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`request_permission<class_OS_method_request_permission>`\ (\ name\: :ref:`String<class_String>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`request_permissions<class_OS_method_request_permissions>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`revoke_granted_permissions<class_OS_method_revoke_granted_permissions>`\ (\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_environment<class_OS_method_set_environment>`\ (\ variable\: :ref:`String<class_String>`, value\: :ref:`String<class_String>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_restart_on_exit<class_OS_method_set_restart_on_exit>`\ (\ restart\: :ref:`bool<class_bool>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>` = PackedStringArray()\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`set_thread_name<class_OS_method_set_thread_name>`\ (\ name\: :ref:`String<class_String>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_use_file_access_save_and_swap<class_OS_method_set_use_file_access_save_and_swap>`\ (\ enabled\: :ref:`bool<class_bool>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`shell_open<class_OS_method_shell_open>`\ (\ uri\: :ref:`String<class_String>`\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`shell_show_in_file_manager<class_OS_method_shell_show_in_file_manager>`\ (\ file_or_dir_path\: :ref:`String<class_String>`, open_folder\: :ref:`bool<class_bool>` = true\ ) |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`unset_environment<class_OS_method_unset_environment>`\ (\ variable\: :ref:`String<class_String>`\ ) |const| |
+---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Перечисления
------------------------
.. _enum_OS_RenderingDriver:
.. rst-class:: classref-enumeration
enum **RenderingDriver**: :ref:`🔗<enum_OS_RenderingDriver>`
.. _class_OS_constant_RENDERING_DRIVER_VULKAN:
.. rst-class:: classref-enumeration-constant
:ref:`RenderingDriver<enum_OS_RenderingDriver>` **RENDERING_DRIVER_VULKAN** = ``0``
Драйвер рендеринга Vulkan. Он требует поддержки Vulkan 1.0 и автоматически использует функции из Vulkan 1.1 и 1.2, если они доступны.
.. _class_OS_constant_RENDERING_DRIVER_OPENGL3:
.. rst-class:: classref-enumeration-constant
:ref:`RenderingDriver<enum_OS_RenderingDriver>` **RENDERING_DRIVER_OPENGL3** = ``1``
Драйвер рендеринга OpenGL 3. Он использует OpenGL 3.3 Core Profile на настольных платформах, OpenGL ES 3.0 на мобильных устройствах и WebGL 2.0 на веб-устройствах.
.. _class_OS_constant_RENDERING_DRIVER_D3D12:
.. rst-class:: classref-enumeration-constant
:ref:`RenderingDriver<enum_OS_RenderingDriver>` **RENDERING_DRIVER_D3D12** = ``2``
Драйвер рендеринга Direct3D 12.
.. _class_OS_constant_RENDERING_DRIVER_METAL:
.. rst-class:: classref-enumeration-constant
:ref:`RenderingDriver<enum_OS_RenderingDriver>` **RENDERING_DRIVER_METAL** = ``3``
Драйвер рендеринга Metal.
.. rst-class:: classref-item-separator
----
.. _enum_OS_SystemDir:
.. rst-class:: classref-enumeration
enum **SystemDir**: :ref:`🔗<enum_OS_SystemDir>`
.. _class_OS_constant_SYSTEM_DIR_DESKTOP:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_DESKTOP** = ``0``
Относится к пути к каталогу рабочего стола.
.. _class_OS_constant_SYSTEM_DIR_DCIM:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_DCIM** = ``1``
Относится к пути к каталогу DCIM (изображения с цифровой камеры).
.. _class_OS_constant_SYSTEM_DIR_DOCUMENTS:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_DOCUMENTS** = ``2``
Относится к пути к каталогу документов.
.. _class_OS_constant_SYSTEM_DIR_DOWNLOADS:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_DOWNLOADS** = ``3``
Относится к пути к каталогу загрузок.
.. _class_OS_constant_SYSTEM_DIR_MOVIES:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_MOVIES** = ``4``
Относится к пути к каталогу фильмов (или видео).
.. _class_OS_constant_SYSTEM_DIR_MUSIC:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_MUSIC** = ``5``
Относится к пути к каталогу «Музыка».
.. _class_OS_constant_SYSTEM_DIR_PICTURES:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_PICTURES** = ``6``
Относится к пути к каталогу изображений.
.. _class_OS_constant_SYSTEM_DIR_RINGTONES:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_RINGTONES** = ``7``
Относится к пути к каталогу рингтонов.
.. rst-class:: classref-item-separator
----
.. _enum_OS_StdHandleType:
.. rst-class:: classref-enumeration
enum **StdHandleType**: :ref:`🔗<enum_OS_StdHandleType>`
.. _class_OS_constant_STD_HANDLE_INVALID:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_INVALID** = ``0``
Стандартное устройство ввода-вывода (I/O) недействительно. Невозможно получить или отправить данные с этих стандартных устройств ввода-вывода.
.. _class_OS_constant_STD_HANDLE_CONSOLE:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_CONSOLE** = ``1``
Стандартное устройство ввода-вывода — это консоль. Обычно это происходит, когда Godot запускается из терминала без перенаправления. Это также используется для всех стандартных устройств ввода-вывода при запуске Godot из редактора, по крайней мере на настольных платформах.
.. _class_OS_constant_STD_HANDLE_FILE:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_FILE** = ``2``
Стандартное устройство ввода-вывода — это обычный файл. Обычно это происходит при перенаправлении с терминала, например, ``godot > stdout.txt``, ``godot < stdin.txt`` или ``godot > stdout_stderr.txt 2>&1``.
.. _class_OS_constant_STD_HANDLE_PIPE:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_PIPE** = ``3``
Стандартное устройство ввода-вывода — FIFO/pipe. Обычно это происходит при использовании pipe с терминала, например ``echo "Hello" | godot``.
.. _class_OS_constant_STD_HANDLE_UNKNOWN:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_UNKNOWN** = ``4``
Тип стандартного устройства ввода-вывода неизвестен.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания свойств
--------------------------------
.. _class_OS_property_delta_smoothing:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **delta_smoothing** = ``true`` :ref:`🔗<class_OS_property_delta_smoothing>`
.. rst-class:: classref-property-setget
- |void| **set_delta_smoothing**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_delta_smoothing_enabled**\ (\ )
Если ``true``, движок фильтрует временную дельту, измеренную между каждым кадром, и пытается компенсировать случайные отклонения. Это работает только в системах, где активна V-Sync.
\ **Примечание:** При запуске это то же самое, что и :ref:`ProjectSettings.application/run/delta_smoothing<class_ProjectSettings_property_application/run/delta_smoothing>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_property_low_processor_usage_mode:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **low_processor_usage_mode** = ``false`` :ref:`🔗<class_OS_property_low_processor_usage_mode>`
.. rst-class:: classref-property-setget
- |void| **set_low_processor_usage_mode**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_in_low_processor_usage_mode**\ (\ )
Если ``true``, движок оптимизируется для низкого использования процессора, обновляя экран только при необходимости. Может улучшить расход батареи на мобильных устройствах.
\ **Примечание:** При запуске это то же самое, что и :ref:`ProjectSettings.application/run/low_processor_mode<class_ProjectSettings_property_application/run/low_processor_mode>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_property_low_processor_usage_mode_sleep_usec:
.. rst-class:: classref-property
:ref:`int<class_int>` **low_processor_usage_mode_sleep_usec** = ``6900`` :ref:`🔗<class_OS_property_low_processor_usage_mode_sleep_usec>`
.. rst-class:: classref-property-setget
- |void| **set_low_processor_usage_mode_sleep_usec**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_low_processor_usage_mode_sleep_usec**\ (\ )
Количество сна между кадрами при включенном режиме низкой загрузки процессора в микросекундах. Более высокие значения приведут к снижению загрузки ЦП. См. также :ref:`low_processor_usage_mode<class_OS_property_low_processor_usage_mode>`.
\ **Примечание:** При запуске это то же самое, что и :ref:`ProjectSettings.application/run/low_processor_mode_sleep_usec<class_ProjectSettings_property_application/run/low_processor_mode_sleep_usec>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания метода
------------------------------
.. _class_OS_method_add_logger:
.. rst-class:: classref-method
|void| **add_logger**\ (\ logger\: :ref:`Logger<class_Logger>`\ ) :ref:`🔗<class_OS_method_add_logger>`
Добавьте пользовательский регистратор для перехвата внутреннего потока сообщений.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_alert:
.. rst-class:: classref-method
|void| **alert**\ (\ text\: :ref:`String<class_String>`, title\: :ref:`String<class_String>` = "Alert!"\ ) :ref:`🔗<class_OS_method_alert>`
Отображает модальное диалоговое окно, используя реализацию хост-платформы. Выполнение движка блокируется до тех пор, пока диалог не будет закрыт.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_close_midi_inputs:
.. rst-class:: classref-method
|void| **close_midi_inputs**\ (\ ) :ref:`🔗<class_OS_method_close_midi_inputs>`
Отключает системный драйвер MIDI. Godot больше не будет получать :ref:`InputEventMIDI<class_InputEventMIDI>`. См. также :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>` и :ref:`get_connected_midi_inputs()<class_OS_method_get_connected_midi_inputs>`.
\ **Примечание:** Этот метод реализован в Linux, macOS, Windows и Web.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_crash:
.. rst-class:: classref-method
|void| **crash**\ (\ message\: :ref:`String<class_String>`\ ) :ref:`🔗<class_OS_method_crash>`
Вызывает сбой движка (или редактора, если он вызван в скрипте ``@tool``. См. также :ref:`kill()<class_OS_method_kill>`.
\ **Примечание:** Этот метод следует использовать *только* для тестирования обработчика сбоев системы, а не для каких-либо других целей. Для общего сообщения об ошибках используйте (в порядке предпочтения) :ref:`@GDScript.assert()<class_@GDScript_method_assert>`, :ref:`@GlobalScope.push_error()<class_@GlobalScope_method_push_error>` или :ref:`alert()<class_OS_method_alert>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_create_instance:
.. rst-class:: classref-method
:ref:`int<class_int>` **create_instance**\ (\ arguments\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) :ref:`🔗<class_OS_method_create_instance>`
Создает новый экземпляр Godot, который запускается независимо. ``arguments`` используются в указанном порядке и разделяются пробелом.
Если процесс успешно создан, этот метод возвращает идентификатор нового процесса, который можно использовать для мониторинга процесса (и потенциального завершения его с помощью :ref:`kill()<class_OS_method_kill>`). Если процесс не может быть создан, этот метод возвращает ``-1``.
См. :ref:`create_process()<class_OS_method_create_process>`, если вы хотите запустить другой процесс.
\ **Примечание:** Этот метод реализован в Android, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_create_process:
.. rst-class:: classref-method
:ref:`int<class_int>` **create_process**\ (\ path\: :ref:`String<class_String>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>`, open_console\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_OS_method_create_process>`
Создает новый процесс, который выполняется независимо от Godot. Он не будет завершен при завершении Godot. Путь, указанный в ``path``, должен существовать и быть исполняемым файлом или пакетом macOS ``.app``. Путь определяется на основе текущей платформы. ``arguments`` используются в указанном порядке и разделяются пробелом.
В Windows, если ``open_console`` равен ``true`` и процесс является консольным приложением, будет открыто новое окно терминала.
Если процесс успешно создан, этот метод возвращает его идентификатор процесса, который можно использовать для мониторинга процесса (и потенциально завершить его с помощью :ref:`kill()<class_OS_method_kill>`). В противном случае этот метод возвращает ``-1``.
\ **Пример:** Запуск другого экземпляра проекта:
.. tabs::
.. code-tab:: gdscript
var pid = OS.create_process(OS.get_executable_path(), [])
.. code-tab:: csharp
var pid = OS.CreateProcess(OS.GetExecutablePath(), []);
См. :ref:`execute()<class_OS_method_execute>`, если вы хотите запустить внешнюю команду и получить результаты.
\ **Примечание:** Этот метод реализован в Android, Linux, macOS и Windows.
\ **Примечание:** В macOS изолированные приложения ограничены запуском только встроенных вспомогательных исполняемых файлов, указанных во время экспорта или системного пакета .app, системные пакеты .app будут игнорировать аргументы.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_delay_msec:
.. rst-class:: classref-method
|void| **delay_msec**\ (\ msec\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_OS_method_delay_msec>`
Задерживает выполнение текущего потока на ``msec`` миллисекунд. ``msec`` должен быть больше или равен ``0``. В противном случае :ref:`delay_msec()<class_OS_method_delay_msec>` ничего не делает и выводит сообщение об ошибке.
\ **Примечание:** :ref:`delay_msec()<class_OS_method_delay_msec>` — это *блокирующий* способ задержки выполнения кода. Чтобы задержать выполнение кода неблокирующим способом, можно использовать :ref:`SceneTree.create_timer()<class_SceneTree_method_create_timer>`. Ожидание с :ref:`SceneTreeTimer<class_SceneTreeTimer>` задерживает выполнение кода, размещенного под ``await``, не влияя на остальную часть проекта (или редактора для :ref:`EditorPlugin<class_EditorPlugin>` и :ref:`EditorScript<class_EditorScript>`).
\ **Примечание:** Когда :ref:`delay_msec()<class_OS_method_delay_msec>` вызывается в основном потоке, он замораживает проект и не позволяет ему перерисовывать и регистрировать ввод, пока не пройдет задержка. При использовании :ref:`delay_msec()<class_OS_method_delay_msec>` как части :ref:`EditorPlugin<class_EditorPlugin>` или :ref:`EditorScript<class_EditorScript>` редактор будет заморожен, но проект не будет заморожен, если он в данный момент запущен (поскольку проект является независимым дочерним процессом).
.. rst-class:: classref-item-separator
----
.. _class_OS_method_delay_usec:
.. rst-class:: classref-method
|void| **delay_usec**\ (\ usec\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_OS_method_delay_usec>`
Задерживает выполнение текущего потока на ``usec`` микросекунд. ``usec`` должен быть больше или равен ``0``. В противном случае :ref:`delay_usec()<class_OS_method_delay_usec>` ничего не делает и выводит сообщение об ошибке.
\ **Примечание:** :ref:`delay_usec()<class_OS_method_delay_usec>` — это *блокирующий* способ задержки выполнения кода. Чтобы задержать выполнение кода неблокирующим способом, можно использовать :ref:`SceneTree.create_timer()<class_SceneTree_method_create_timer>`. Ожидание с :ref:`SceneTreeTimer<class_SceneTreeTimer>` задерживает выполнение кода, размещенного под ``await``, не влияя на остальную часть проекта (или редактора для :ref:`EditorPlugin<class_EditorPlugin>` и :ref:`EditorScript<class_EditorScript>`).
\ **Примечание:** Когда :ref:`delay_usec()<class_OS_method_delay_usec>` вызывается в основном потоке, он замораживает проект и не позволяет ему перерисовывать и регистрировать ввод, пока не пройдет задержка. При использовании :ref:`delay_usec()<class_OS_method_delay_usec>` как части :ref:`EditorPlugin<class_EditorPlugin>` или :ref:`EditorScript<class_EditorScript>` редактор будет заморожен, но проект не будет заморожен, если он в данный момент запущен (поскольку проект является независимым дочерним процессом).
.. rst-class:: classref-item-separator
----
.. _class_OS_method_execute:
.. rst-class:: classref-method
:ref:`int<class_int>` **execute**\ (\ path\: :ref:`String<class_String>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>`, output\: :ref:`Array<class_Array>` = [], read_stderr\: :ref:`bool<class_bool>` = false, open_console\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_OS_method_execute>`
Выполняет заданный процесс *блокирующим* способом. Файл, указанный в ``path``, должен существовать и быть исполняемым. Будет использоваться системное разрешение пути. ``arguments`` используются в заданном порядке, разделяются пробелами и заключаются в кавычки.
Если указан массив ``output``, полный вывод оболочки процесса добавляется к ``output`` как один элемент :ref:`String<class_String>`. Если ``read_stderr`` равен ``true``, вывод в стандартный поток ошибок также добавляется к массиву.
В Windows, если ``open_console`` равен ``true`` и процесс является консольным приложением, открывается новое окно терминала.
Этот метод возвращает код завершения команды или ``-1``, если процесс не выполняется.
\ **Примечание:** Основной поток будет заблокирован до тех пор, пока не завершится выполненная команда. Используйте :ref:`Thread<class_Thread>`, чтобы создать отдельный поток, который не будет блокировать основной поток, или используйте :ref:`create_process()<class_OS_method_create_process>`, чтобы создать полностью независимый процесс.
Например, чтобы получить список содержимого рабочего каталога:
.. tabs::
.. code-tab:: gdscript
var output = []
var exit_code = OS.execute("ls", ["-l", "/tmp"], output)
.. code-tab:: csharp
Godot.Collections.Array output = [];
int exitCode = OS.Execute("ls", ["-l", "/tmp"], output);
Если вы хотите получить доступ к встроенной оболочке или выполнить составную команду, можно вызвать платформенно-зависимую оболочку. Например:
.. tabs::
.. code-tab:: gdscript
var output = []
OS.execute("CMD.exe", ["/C", "cd %TEMP% && dir"], output)
.. code-tab:: csharp
Godot.Collections.Array output = [];
OS.Execute("CMD.exe", ["/C", "cd %TEMP% && dir"], output);
\ **Примечание:** Этот метод реализован в Android, Linux, macOS и Windows.
\ **Примечание:** Чтобы выполнить встроенную команду интерпретатора команд Windows, укажите ``cmd.exe`` в ``path``, ``/c`` в качестве первого аргумента и нужную команду в качестве второго аргумента.
\ **Примечание:** Чтобы выполнить встроенную команду PowerShell, укажите ``powershell.exe`` в ``path``, ``-Command`` в качестве первого аргумента и нужную команду в качестве второго аргумента.
\ **Примечание:** Чтобы выполнить встроенную команду оболочки Unix, укажите имя исполняемого файла оболочки в ``path``, ``-c`` в качестве первого аргумента и нужную команду в качестве второго аргумента.
\ **Примечание:** В macOS изолированные приложения ограничены запуском только встроенных вспомогательных исполняемых файлов, указанных во время экспорта.
\ **Примечание:** В Android системные команды, такие как ``dumpsys``, могут быть запущены только на устройстве с правами root.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_execute_with_pipe:
.. rst-class:: classref-method
:ref:`Dictionary<class_Dictionary>` **execute_with_pipe**\ (\ path\: :ref:`String<class_String>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>`, blocking\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_OS_method_execute_with_pipe>`
Создает новый процесс, который выполняется независимо от Godot с перенаправленным вводом-выводом. Он не будет завершен при завершении Godot. Путь, указанный в ``path``, должен существовать и быть исполняемым файлом или пакетом macOS ``.app``. Путь определяется на основе текущей платформы. ``arguments`` используются в указанном порядке и разделяются пробелом.
Если ``blocking`` равно ``false``, созданные каналы работают в неблокируемом режиме, т. е. операции чтения и записи будут возвращаться немедленно. Используйте :ref:`FileAccess.get_error()<class_FileAccess_method_get_error>`, чтобы проверить, была ли последняя операция чтения/записи успешной.
Если процесс не может быть создан, этот метод возвращает пустой :ref:`Dictionary<class_Dictionary>`. В противном случае этот метод возвращает :ref:`Dictionary<class_Dictionary>` со следующими ключами:
- ``"stdio"`` - :ref:`FileAccess<class_FileAccess>` для доступа к каналам stdin и stdout процесса (чтение/запись).
- ``"stderr"`` - :ref:`FileAccess<class_FileAccess>` для доступа к каналу stderr процесса (только для чтения).
- ``"pid"`` - идентификатор процесса как :ref:`int<class_int>`, который можно использовать для мониторинга процесса (и потенциального его завершения с помощью :ref:`kill()<class_OS_method_kill>`).
\ **Примечание:** Этот метод реализован в Android, Linux, macOS и Windows.
\ **Примечание:** Чтобы выполнить встроенную команду интерпретатора команд Windows, укажите ``cmd.exe`` в ``path``, ``/c`` в качестве первого аргумента и нужную команду в качестве второго аргумента.
\ **Примечание:** Чтобы выполнить встроенную команду PowerShell, укажите ``powershell.exe`` в ``path``, ``-Command`` в качестве первого аргумента и нужную команду в качестве второго аргумента.
\ **Примечание:** Чтобы выполнить встроенную команду оболочки Unix, укажите имя исполняемого файла оболочки в ``path``, ``-c`` в качестве первого аргумента и нужную команду в качестве второго аргумента.
\ **Примечание:** В macOS изолированные приложения ограничены запуском только встроенных вспомогательных исполняемых файлов, указанных во время экспорта или системного пакета .app, системные пакеты .app будут игнорировать аргументы.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_find_keycode_from_string:
.. rst-class:: classref-method
:ref:`Key<enum_@GlobalScope_Key>` **find_keycode_from_string**\ (\ string\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_OS_method_find_keycode_from_string>`
Находит код клавиши для заданной строки. Возвращаемые значения эквивалентны константам :ref:`Key<enum_@GlobalScope_Key>`.
.. tabs::
.. code-tab:: gdscript
print(OS.find_keycode_from_string("C")) # Выводит 67 (KEY_C)
print(OS.find_keycode_from_string("Escape")) # Выводит 4194305 (KEY_ESCAPE)
print(OS.find_keycode_from_string("Shift+Tab")) # Выводит 37748738 (KEY_MASK_SHIFT | KEY_TAB)
print(OS.find_keycode_from_string("Unknown")) # Выводит 0 (KEY_NONE)
.. code-tab:: csharp
GD.Print(OS.FindKeycodeFromString("C")); // Выводит C (Key.C)
GD.Print(OS.FindKeycodeFromString("Escape")); // Выводит Escape (Key.Escape)
GD.Print(OS.FindKeycodeFromString("Shift+Tab")); // Выводит 37748738 (KeyModifierMask.MaskShift | Key.Tab)
GD.Print(OS.FindKeycodeFromString("Unknown")); // Выводит None (Key.None)
См. также :ref:`get_keycode_string()<class_OS_method_get_keycode_string>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_cache_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_cache_dir**\ (\ ) |const| :ref:`🔗<class_OS_method_get_cache_dir>`
Возвращает *глобальный* каталог данных кэша в соответствии со стандартами операционной системы.
На платформе Linux/BSD этот путь можно переопределить, установив переменную среды ``XDG_CACHE_HOME`` перед запуском проекта. Для получения дополнительной информации см. :doc:`Пути к файлам в проектах Godot <../tutorials/io/data_paths>` в документации. См. также :ref:`get_config_dir()<class_OS_method_get_config_dir>` и :ref:`get_data_dir()<class_OS_method_get_data_dir>`.
Не путать с :ref:`get_user_data_dir()<class_OS_method_get_user_data_dir>`, который возвращает *специфичный для проекта* путь к данным пользователя.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_cmdline_args:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_cmdline_args**\ (\ ) :ref:`🔗<class_OS_method_get_cmdline_args>`
Returns the command-line arguments passed to the engine, excluding arguments processed by the engine, such as ``--headless`` and ``--fullscreen``.
::
# Godot has been executed with the following command:
# godot --headless --verbose --scene my_scene.tscn --custom
OS.get_cmdline_args() # Returns ["--scene", "my_scene.tscn", "--custom"]
Command-line arguments can be written in any form, including both ``--key value`` and ``--key=value`` forms so they can be properly parsed, as long as custom command-line arguments do not conflict with engine arguments.
You can also incorporate environment variables using the :ref:`get_environment()<class_OS_method_get_environment>` method.
You can set :ref:`ProjectSettings.editor/run/main_run_args<class_ProjectSettings_property_editor/run/main_run_args>` to define command-line arguments to be passed by the editor when running the project.
\ **Example:** Parse command-line arguments into a :ref:`Dictionary<class_Dictionary>` using the ``--key=value`` form for arguments:
.. tabs::
.. code-tab:: gdscript
var arguments = {}
for argument in OS.get_cmdline_args():
if argument.contains("="):
var key_value = argument.split("=")
arguments[key_value[0].trim_prefix("--")] = key_value[1]
else:
# Options without an argument will be present in the dictionary,
# with the value set to an empty string.
arguments[argument.trim_prefix("--")] = ""
.. code-tab:: csharp
var arguments = new Dictionary<string, string>();
foreach (var argument in OS.GetCmdlineArgs())
{
if (argument.Contains('='))
{
string[] keyValue = argument.Split("=");
arguments[keyValue[0].TrimPrefix("--")] = keyValue[1];
}
else
{
// Options without an argument will be present in the dictionary,
// with the value set to an empty string.
arguments[argument.TrimPrefix("--")] = "";
}
}
\ **Note:** Passing custom user arguments directly is not recommended, as the engine may discard or modify them. Instead, pass the standard UNIX double dash (``--``) and then the custom arguments, which the engine will ignore by design. These can be read via :ref:`get_cmdline_user_args()<class_OS_method_get_cmdline_user_args>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_cmdline_user_args:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_cmdline_user_args**\ (\ ) :ref:`🔗<class_OS_method_get_cmdline_user_args>`
Returns the command-line user arguments passed to the engine. User arguments are ignored by the engine and reserved for the user. They are passed after the double dash ``--`` argument. ``++`` may be used when ``--`` is intercepted by another program (such as ``startx``).
::
# Godot has been executed with the following command:
# godot --fullscreen --custom -- --level=2 --hardcore
OS.get_cmdline_args() # Returns ["--custom"]
OS.get_cmdline_user_args() # Returns ["--level=2", "--hardcore"]
To get arguments passed before ``--`` or ``++``, use :ref:`get_cmdline_args()<class_OS_method_get_cmdline_args>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_config_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_config_dir**\ (\ ) |const| :ref:`🔗<class_OS_method_get_config_dir>`
Возвращает *глобальный* каталог конфигурации пользователя в соответствии со стандартами операционной системы.
На платформе Linux/BSD этот путь можно переопределить, установив переменную среды ``XDG_CONFIG_HOME`` перед запуском проекта. Для получения дополнительной информации см. :doc:`Пути к файлам в проектах Godot <../tutorials/io/data_paths>` в документации. См. также :ref:`get_cache_dir()<class_OS_method_get_cache_dir>` и :ref:`get_data_dir()<class_OS_method_get_data_dir>`.
Не путать с :ref:`get_user_data_dir()<class_OS_method_get_user_data_dir>`, который возвращает *специфичный для проекта* путь к данным пользователя.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_connected_midi_inputs:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_connected_midi_inputs**\ (\ ) :ref:`🔗<class_OS_method_get_connected_midi_inputs>`
Возвращает массив имен подключенных устройств MIDI, если они существуют. Возвращает пустой массив, если системный драйвер MIDI ранее не был инициализирован с помощью :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>`. См. также :ref:`close_midi_inputs()<class_OS_method_close_midi_inputs>`.
\ **Примечание:** Этот метод реализован в Linux, macOS, Windows и Web.
\ **Примечание:** На веб-платформе веб-MIDI должен поддерживаться браузером. `На данный момент <https://caniuse.com/midi>`__ он поддерживается всеми основными браузерами, кроме Safari.
\ **Примечание:** На веб-платформе использование ввода MIDI требует предварительного предоставления разрешения браузеру. Этот запрос разрешения выполняется при вызове :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>`. Браузер воздержится от обработки ввода MIDI, пока пользователь не примет запрос разрешения.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_data_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_data_dir**\ (\ ) |const| :ref:`🔗<class_OS_method_get_data_dir>`
Возвращает *глобальный* каталог пользовательских данных в соответствии со стандартами операционной системы.
На платформе Linux/BSD этот путь можно переопределить, установив переменную среды ``XDG_DATA_HOME`` перед запуском проекта. Для получения дополнительной информации см. :doc:`Пути к файлам в проектах Godot <../tutorials/io/data_paths>` в документации. См. также :ref:`get_cache_dir()<class_OS_method_get_cache_dir>` и :ref:`get_config_dir()<class_OS_method_get_config_dir>`.
Не путать с :ref:`get_user_data_dir()<class_OS_method_get_user_data_dir>`, который возвращает *специфичный для проекта* путь к пользовательским данным.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_distribution_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_distribution_name**\ (\ ) |const| :ref:`🔗<class_OS_method_get_distribution_name>`
Возвращает имя дистрибутива для платформ Linux и BSD (например, "Ubuntu", "Manjaro", "OpenBSD" и т. д.).
Возвращает то же значение, что и :ref:`get_name()<class_OS_method_get_name>` для стандартных Android ROM, но пытается вернуть пользовательское имя ROM для популярных производных Android, таких как "LineageOS".
Возвращает то же значение, что и :ref:`get_name()<class_OS_method_get_name>` для других платформ.
\ **Примечание:** Этот метод не поддерживается на веб-платформе. Он возвращает пустую строку.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_entropy:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **get_entropy**\ (\ size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_OS_method_get_entropy>`
Генерирует :ref:`PackedByteArray<class_PackedByteArray>` криптографически безопасных случайных байтов с заданным ``size``.
\ **Примечание:** Генерация больших объемов байтов с использованием этого метода может привести к блокировке и энтропии более низкого качества на большинстве платформ. Использование :ref:`Crypto.generate_random_bytes()<class_Crypto_method_generate_random_bytes>` является предпочтительным в большинстве случаев.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_environment:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_environment**\ (\ variable\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_OS_method_get_environment>`
Возвращает значение заданной переменной среды или пустую строку, если ``variable`` не существует.
\ **Примечание:** Дважды проверьте регистр ``variable``. Имена переменных среды чувствительны к регистру на всех платформах, кроме Windows.
\ **Примечание:** В macOS приложения не имеют доступа к переменным среды оболочки.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_executable_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_executable_path**\ (\ ) |const| :ref:`🔗<class_OS_method_get_executable_path>`
Возвращает путь к текущему исполняемому файлу движка.
\ **Примечание:** В macOS, если вы хотите запустить другой экземпляр Godot, всегда используйте :ref:`create_instance()<class_OS_method_create_instance>` вместо того, чтобы полагаться на путь к исполняемому файлу.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_granted_permissions:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_granted_permissions**\ (\ ) |const| :ref:`🔗<class_OS_method_get_granted_permissions>`
На устройствах Android: возвращает список предоставленных опасных разрешений.
На macOS: возвращает список предоставленных разрешений и выбранных пользователем папок, доступных приложению (только для изолированных приложений). Используйте встроенный диалог файлов для запроса разрешения на доступ к папке.
На iOS, visionOS: возвращает список предоставленных разрешений.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_keycode_string:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_keycode_string**\ (\ code\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| :ref:`🔗<class_OS_method_get_keycode_string>`
Возвращает заданный код клавиши как :ref:`String<class_String>`.
.. tabs::
.. code-tab:: gdscript
print(OS.get_keycode_string(KEY_C)) # Выводит "C"
print(OS.get_keycode_string(KEY_ESCAPE)) # Выводит "Escape"
print(OS.get_keycode_string(KEY_MASK_SHIFT | KEY_TAB)) # Выводит "Shift+Tab"
.. code-tab:: csharp
GD.Print(OS.GetKeycodeString(Key.C)); // Выводит "C"
GD.Print(OS.GetKeycodeString(Key.Escape)); // Выводит "Escape"
GD.Print(OS.GetKeycodeString((Key)KeyModifierMask.MaskShift | Key.Tab)); // Выводит "Shift+Tab"
См. также :ref:`find_keycode_from_string()<class_OS_method_find_keycode_from_string>`, :ref:`InputEventKey.keycode<class_InputEventKey_property_keycode>` и :ref:`InputEventKey.get_keycode_with_modifiers()<class_InputEventKey_method_get_keycode_with_modifiers>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_locale:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_locale**\ (\ ) |const| :ref:`🔗<class_OS_method_get_locale>`
Возвращает локаль ОС хоста как :ref:`String<class_String>` в форме ``language_Script_COUNTRY_VARIANT@extra``. Каждая подстрока после ``language`` является необязательной и может отсутствовать.
- ``language`` - 2-х или 3-х буквенный `код языка <https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>`__ в нижнем регистре.
- ``Script`` - 4-х буквенный `код скрипта <https://en.wikipedia.org/wiki/ISO_15924>`__ в верхнем регистре.
- ``COUNTRY`` - 2-х или 3-х буквенный `код страны <https://en.wikipedia.org/wiki/ISO_3166-1>`__ в верхнем регистре.
- ``VARIANT`` - языковой вариант, регион и порядок сортировки. Вариант может иметь любое количество подчеркнутых ключевых слов.
- ``extra`` - список дополнительных ключевых слов, разделенных точкой с запятой. Это может включать информацию о валюте, календаре, порядке сортировки и системе нумерации.
Если вам нужен только код языка, а не полностью указанная локаль из ОС, вы можете использовать :ref:`get_locale_language()<class_OS_method_get_locale_language>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_locale_language:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_locale_language**\ (\ ) |const| :ref:`🔗<class_OS_method_get_locale_language>`
Возвращает 2-х или 3-буквенный `код языка <https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>`__ операционной системы хоста в виде строки, которая должна быть единообразной на всех платформах. Это эквивалентно извлечению части ``language`` строки :ref:`get_locale()<class_OS_method_get_locale>`.
Это можно использовать для сужения полностью указанных строк локали только до «общего» кода языка, когда вам не нужна дополнительная информация о коде страны или вариантах. Например, для франкоканадского пользователя с локалью ``fr_CA`` это вернет ``fr``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_main_thread_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_main_thread_id**\ (\ ) |const| :ref:`🔗<class_OS_method_get_main_thread_id>`
Возвращает идентификатор основного потока. См. :ref:`get_thread_caller_id()<class_OS_method_get_thread_caller_id>`.
\ **Примечание:** Идентификаторы потоков не являются детерминированными и могут повторно использоваться при перезапусках приложения.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_memory_info:
.. rst-class:: classref-method
:ref:`Dictionary<class_Dictionary>` **get_memory_info**\ (\ ) |const| :ref:`🔗<class_OS_method_get_memory_info>`
Возвращает :ref:`Dictionary<class_Dictionary>`, содержащий информацию о текущей памяти со следующими записями:
- ``"physical"`` - общий объем используемой физической памяти в байтах. Это значение может быть немного меньше фактического объема физической памяти, поскольку оно не включает память, зарезервированную ядром и устройствами.
- ``"free"`` - объем физической памяти, который может быть немедленно выделен без доступа к диску или других затратных операций, в байтах. Процесс может выделить больше физической памяти, но это действие потребует перемещения неактивных страниц на диск, что может быть затратно.
- ``"available"`` - объем памяти, который может быть выделен без расширения файла(ов) подкачки, в байтах. Это значение включает как физическую память, так и подкачку.
- ``"stack"`` - размер стека текущего потока в байтах.
\ **Примечание:** Значение каждой записи может быть ``-1``, если оно неизвестно.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_model_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_model_name**\ (\ ) |const| :ref:`🔗<class_OS_method_get_model_name>`
Возвращает название модели текущего устройства.
\ **Примечание:** Этот метод реализован на Android, iOS, macOS и Windows. Возвращает ``"GenericDevice"`` на неподдерживаемых платформах.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_name**\ (\ ) |const| :ref:`🔗<class_OS_method_get_name>`
Возвращает имя хост-платформы.
- В Windows это ``"Windows"``.
- В macOS это ``"macOS"``.
- В операционных системах на базе Linux это ``"Linux"``.
- В операционных системах на базе BSD это ``"FreeBSD"``, ``"NetBSD"``, ``"OpenBSD"`` или ``"BSD"`` в качестве резерва.
- В Android это ``"Android"``.
- В iOS это ``"iOS"``.
- В Web это ``"Web"``.
\ **Примечание:** Пользовательские сборки движка могут поддерживать дополнительные платформы, такие как консоли, возможно, возвращая другие имена.
.. tabs::
.. code-tab:: gdscript
match OS.get_name():
"Windows":
print("Welcome to Windows!")
"macOS":
print("Welcome to macOS!")
"Linux", "FreeBSD", "NetBSD", "OpenBSD", "BSD":
print("Welcome to Linux/BSD!")
"Android":
print("Welcome to Android!")
"iOS":
print("Welcome to iOS!")
"Web":
print("Welcome to the Web!")
.. code-tab:: csharp
switch (OS.GetName())
{
case "Windows":
GD.Print("Welcome to Windows");
break;
case "macOS":
GD.Print("Welcome to macOS!");
break;
case "Linux":
case "FreeBSD":
case "NetBSD":
case "OpenBSD":
case "BSD":
GD.Print("Welcome to Linux/BSD!");
break;
case "Android":
GD.Print("Welcome to Android!");
break;
case "iOS":
GD.Print("Welcome to iOS!");
break;
case "Web":
GD.Print("Welcome to the Web!");
break;
}
\ **Примечание:** На веб-платформах по-прежнему возможно определить ОС хост-платформы с помощью тегов функций. См. :ref:`has_feature()<class_OS_method_has_feature>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_process_exit_code:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_process_exit_code**\ (\ pid\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_OS_method_get_process_exit_code>`
Возвращает код выхода порожденного процесса после завершения его выполнения (см. :ref:`is_process_running()<class_OS_method_is_process_running>`).
Возвращает ``-1``, если ``pid`` не является PID порожденного дочернего процесса, процесс все еще выполняется или метод не реализован для текущей платформы.
\ **Примечание:** Возвращает ``-1``, если ``pid`` является процессом приложения, связанным с macOS.
\ **Примечание:** Этот метод реализован в Android, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_process_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_process_id**\ (\ ) |const| :ref:`🔗<class_OS_method_get_process_id>`
Возвращает номер, используемый хост-машиной для уникальной идентификации этого приложения.
\ **Примечание:** В Интернете этот метод всегда возвращает ``0``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_processor_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_processor_count**\ (\ ) |const| :ref:`🔗<class_OS_method_get_processor_count>`
Возвращает количество *логических* ядер ЦП, доступных на хост-машине. На ЦП с включенной функцией HyperThreading это число будет больше количества *физических* ядер ЦП.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_processor_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_processor_name**\ (\ ) |const| :ref:`🔗<class_OS_method_get_processor_name>`
Возвращает полное имя модели ЦП на хост-компьютере (например, ``"Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz"``).
\ **Примечание:** Этот метод реализован только в Windows, macOS, Linux и iOS. На Android и в Интернете :ref:`get_processor_name()<class_OS_method_get_processor_name>` возвращает пустую строку.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_restart_on_exit_arguments:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_restart_on_exit_arguments**\ (\ ) |const| :ref:`🔗<class_OS_method_get_restart_on_exit_arguments>`
Возвращает список аргументов командной строки, которые будут использоваться при автоматическом перезапуске проекта с использованием :ref:`set_restart_on_exit()<class_OS_method_set_restart_on_exit>`. См. также :ref:`is_restart_on_exit_set()<class_OS_method_is_restart_on_exit_set>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_static_memory_peak_usage:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_static_memory_peak_usage**\ (\ ) |const| :ref:`🔗<class_OS_method_get_static_memory_peak_usage>`
Возвращает максимальный объем используемой статической памяти. Работает только в отладочных сборках.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_static_memory_usage:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_static_memory_usage**\ (\ ) |const| :ref:`🔗<class_OS_method_get_static_memory_usage>`
Возвращает объем статической памяти, используемой программой в байтах. Работает только в отладочных сборках.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_stderr_type:
.. rst-class:: classref-method
:ref:`StdHandleType<enum_OS_StdHandleType>` **get_stderr_type**\ (\ ) |const| :ref:`🔗<class_OS_method_get_stderr_type>`
Возвращает тип стандартного устройства ошибок.
\ **Примечание:** Этот метод реализован в Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_stdin_type:
.. rst-class:: classref-method
:ref:`StdHandleType<enum_OS_StdHandleType>` **get_stdin_type**\ (\ ) |const| :ref:`🔗<class_OS_method_get_stdin_type>`
Возвращает тип стандартного устройства ввода.
\ **Примечание:** Этот метод реализован в Linux, macOS и Windows.
\ **Примечание:** В экспортированных сборках Windows запустите исполняемый файл оболочки консоли для доступа к стандартному вводу. Если вам нужен один исполняемый файл с полной поддержкой консоли, используйте пользовательскую сборку, скомпилированную с флагом ``windows_subsystem=console``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_stdout_type:
.. rst-class:: classref-method
:ref:`StdHandleType<enum_OS_StdHandleType>` **get_stdout_type**\ (\ ) |const| :ref:`🔗<class_OS_method_get_stdout_type>`
Возвращает тип стандартного устройства вывода.
\ **Примечание:** Этот метод реализован в Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_system_ca_certificates:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_system_ca_certificates**\ (\ ) :ref:`🔗<class_OS_method_get_system_ca_certificates>`
Возвращает список центров сертификации, которым доверяет операционная система, в виде строки объединенных сертификатов в формате PEM.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_system_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_system_dir**\ (\ dir\: :ref:`SystemDir<enum_OS_SystemDir>`, shared_storage\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_OS_method_get_system_dir>`
Возвращает путь к часто используемым папкам на разных платформах, как определено ``dir``. См. константы :ref:`SystemDir<enum_OS_SystemDir>` для доступных расположений.
\ **Примечание:** Этот метод реализован в Android, Linux, macOS и Windows.
\ **Примечание:** Общее хранилище реализовано в Android и позволяет различать каталоги, специфичные для приложения, и общие каталоги, если ``shared_storage`` имеет значение ``true``. Общие каталоги имеют дополнительные ограничения в Android.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_system_font_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_system_font_path**\ (\ font_name\: :ref:`String<class_String>`, weight\: :ref:`int<class_int>` = 400, stretch\: :ref:`int<class_int>` = 100, italic\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_OS_method_get_system_font_path>`
Возвращает путь к системному файлу шрифта с ``font_name`` и стилем. Возвращает пустую строку, если соответствующие шрифты не найдены.
Для запроса шрифтов по умолчанию можно использовать следующие псевдонимы: "sans-serif", "serif", "monospace", "cursive" и "fantasy".
\ **Примечание:** Возвращаемый шрифт может иметь другой стиль, если запрошенный стиль недоступен.
\ **Примечание:** Этот метод реализован на Android, iOS, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_system_font_path_for_text:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_system_font_path_for_text**\ (\ font_name\: :ref:`String<class_String>`, text\: :ref:`String<class_String>`, locale\: :ref:`String<class_String>` = "", script\: :ref:`String<class_String>` = "", weight\: :ref:`int<class_int>` = 400, stretch\: :ref:`int<class_int>` = 100, italic\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_OS_method_get_system_font_path_for_text>`
Возвращает массив путей к файлам системных подстановочных шрифтов, которые похожи на шрифт с ``font_name`` и стилем для указанного текста, локали и скрипта. Возвращает пустой массив, если соответствующие шрифты не найдены.
Следующие псевдонимы можно использовать для запроса шрифтов по умолчанию: "sans-serif", "serif", "monospace", "cursive" и "fantasy".
\ **Примечание:** В зависимости от ОС не гарантируется, что какой-либо из возвращенных шрифтов подойдет для рендеринга указанного текста. Шрифты следует загружать и проверять в том порядке, в котором они возвращаются, и использовать первый подходящий.
\ **Примечание:** Возвращенные шрифты могут иметь другой стиль, если запрошенный стиль недоступен или принадлежит к другому семейству шрифтов.
\ **Примечание:** Этот метод реализован на Android, iOS, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_system_fonts:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_system_fonts**\ (\ ) |const| :ref:`🔗<class_OS_method_get_system_fonts>`
Возвращает список доступных имен семейств шрифтов.
\ **Примечание:** Этот метод реализован на Android, iOS, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_temp_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_temp_dir**\ (\ ) |const| :ref:`🔗<class_OS_method_get_temp_dir>`
Возвращает *глобальный* временный каталог данных в соответствии со стандартами операционной системы.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_thread_caller_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_thread_caller_id**\ (\ ) |const| :ref:`🔗<class_OS_method_get_thread_caller_id>`
Возвращает идентификатор текущего потока. Его можно использовать в журналах для упрощения отладки многопоточных приложений.
\ **Примечание:** Идентификаторы потоков не являются детерминированными и могут повторно использоваться при перезапусках приложения.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_unique_id:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_unique_id**\ (\ ) |const| :ref:`🔗<class_OS_method_get_unique_id>`
Возвращает строку, которая уникальна для устройства.
\ **Примечание:** Эта строка может измениться без уведомления, если пользователь переустановит свою операционную систему, обновит ее или изменит свое оборудование. Это означает, что ее, как правило, не следует использовать для шифрования постоянных данных, поскольку данные, сохраненные до неожиданного изменения идентификатора, станут недоступными. Возвращаемая строка также может быть подделана с помощью внешних программ, поэтому не полагайтесь на строку, возвращаемую этим методом, в целях безопасности.
\ **Примечание:** В Интернете возвращает пустую строку и генерирует ошибку, поскольку этот метод не может быть реализован по соображениям безопасности.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_user_data_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_user_data_dir**\ (\ ) |const| :ref:`🔗<class_OS_method_get_user_data_dir>`
Возвращает абсолютный путь к каталогу, в который записываются пользовательские данные (каталог ``user://`` в Godot). Путь зависит от имени проекта и :ref:`ProjectSettings.application/config/use_custom_user_dir<class_ProjectSettings_property_application/config/use_custom_user_dir>`.
- В Windows это ``%AppData%\Godot\app_userdata\[project_name]`` или ``%AppData%\[custom_name]``, если задано ``use_custom_user_dir``. ``%AppData%`` расширяется до ``%UserProfile%\AppData\Roaming``.
- В macOS это ``~/Library/Application Support/Godot/app_userdata/[project_name]`` или ``~/Library/Application Support/[custom_name]``, если задано ``use_custom_user_dir``.
- В Linux и BSD это ``~/.local/share/godot/app_userdata/[project_name]`` или ``~/.local/share/[custom_name]``, если задано ``use_custom_user_dir``.
- В Android и iOS это изолированный каталог во внутреннем или внешнем хранилище в зависимости от конфигурации пользователя.
- В Web это виртуальный каталог, управляемый браузером.
Если имя проекта пустое, ``[project_name]`` возвращается к ``[unnamed project]``.
Не путать с :ref:`get_data_dir()<class_OS_method_get_data_dir>`, который возвращает *глобальный* (не относящийся к проекту) домашний каталог пользователя.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_version:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_version**\ (\ ) |const| :ref:`🔗<class_OS_method_get_version>`
Возвращает точную производственную и сборочную версию операционной системы. Она отличается от фирменной версии, используемой в маркетинге. Это помогает различать разные выпуски операционных систем, включая второстепенные версии, а также внутренние и пользовательские сборки.
- Для Windows возвращаются основная и второстепенная версии, а также номер сборки. Например, возвращаемая строка может выглядеть как ``10.0.9926`` для сборки Windows 10.
- Для скользящих дистрибутивов, таких как Arch Linux, возвращается пустая строка.
- Для macOS и iOS возвращаются основная и второстепенная версии, а также номер патча.
- Для Android возвращаются версия SDK и инкрементный номер сборки. Если это пользовательская прошивка, она пытается вернуть свою версию.
\ **Примечание:** Этот метод не поддерживается на веб-платформе. Он возвращает пустую строку.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_version_alias:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_version_alias**\ (\ ) |const| :ref:`🔗<class_OS_method_get_version_alias>`
Возвращает фирменную версию, используемую в маркетинге, за которой следует номер сборки (в Windows), номер версии (в macOS) или версия SDK и инкрементный номер сборки (в Android). Примеры включают ``11 (build 22000)``, ``Sequoia (15.0.0)`` и ``15 (SDK 35 build abc528-11988f)``.
Затем это значение можно добавить к :ref:`get_name()<class_OS_method_get_name>`, чтобы получить полное, понятное человеку имя операционной системы и комбинацию версии для операционной системы. Обновления функций Windows, такие как 24H2, не содержатся в результирующей строке, но Windows Server распознается как таковой (например, ``2025 (build 26100)`` для Windows Server 2025).
\ **Примечание:** Этот метод поддерживается только в Windows, macOS и Android. В других операционных системах он возвращает то же значение, что и :ref:`get_version()<class_OS_method_get_version>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_get_video_adapter_driver_info:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_video_adapter_driver_info**\ (\ ) |const| :ref:`🔗<class_OS_method_get_video_adapter_driver_info>`
Возвращает имя и версию драйвера видеоадаптера для текущей активной видеокарты пользователя в виде :ref:`PackedStringArray<class_PackedStringArray>`. См. также :ref:`RenderingServer.get_video_adapter_api_version()<class_RenderingServer_method_get_video_adapter_api_version>`.
Первый элемент содержит имя драйвера, например, ``nvidia``, ``amdgpu`` и т. д.
Второй элемент содержит версию драйвера. Например, для драйвера ``nvidia`` на платформе Linux/BSD версия имеет формат ``510.85.02``. Для Windows формат драйвера — ``31.0.15.1659``.
\ **Примечание:** Этот метод поддерживается только в Linux/BSD и Windows, если он не запущен в режиме headless. На других платформах он возвращает пустой массив.
\ **Примечание:** Этот метод будет выполняться медленно при первом вызове в сеансе; его выполнение может занять несколько секунд в зависимости от операционной системы и оборудования. Он блокируется при вызове в основном потоке, поэтому рекомендуется вызывать его в отдельном потоке с помощью :ref:`Thread<class_Thread>`. Это позволяет движку продолжать работу во время получения информации. Однако :ref:`get_video_adapter_driver_info()<class_OS_method_get_video_adapter_driver_info>` *не* потокобезопасен, поэтому его не следует вызывать из нескольких потоков одновременно.
.. tabs::
.. code-tab:: gdscript
var thread = Thread.new()
func _ready():
thread.start(
func():
var driver_info = OS.get_video_adapter_driver_info()
if not driver_info.is_empty():
print("Драйвер: %s %s" % [driver_info[0], driver_info[1]])
else:
print("Драйвер: (неизвестный)")
)
func _exit_tree():
thread.wait_to_finish()
.. rst-class:: classref-item-separator
----
.. _class_OS_method_has_environment:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_environment**\ (\ variable\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_OS_method_has_environment>`
Возвращает ``true``, если переменная среды с именем ``variable`` существует.
\ **Примечание:** Дважды проверьте регистр ``variable``. Имена переменных среды чувствительны к регистру на всех платформах, кроме Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_has_feature:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_feature**\ (\ tag_name\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_OS_method_has_feature>`
Возвращает ``true``, если функция для данного тега функции поддерживается в текущем запущенном экземпляре, в зависимости от платформы, сборки и т. д. Может использоваться для проверки того, запущена ли в данный момент отладочная сборка на определенной платформе или архитектуре и т. д. Более подробную информацию см. в документации :doc:`Теги функций <../tutorials/export/feature_tags>`.
\ **Примечание:** Имена тегов чувствительны к регистру.
\ **Примечание:** На веб-платформе для указания платформы хоста определен один из следующих дополнительных тегов: ``web_android``, ``web_ios``, ``web_linuxbsd``, ``web_macos`` или ``web_windows``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_is_debug_build:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_debug_build**\ (\ ) |const| :ref:`🔗<class_OS_method_is_debug_build>`
Возвращает ``true``, если двоичный файл Godot, используемый для запуска проекта, является шаблоном экспорта *debug*, или при запуске в редакторе.
Возвращает ``false``, если двоичный файл Godot, используемый для запуска проекта, является шаблоном экспорта *release*.
\ **Примечание:** Чтобы проверить, является ли двоичный файл Godot, используемый для запуска проекта, шаблоном экспорта (отладки или выпуска), используйте вместо этого ``OS.has_feature("template")``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_is_keycode_unicode:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_keycode_unicode**\ (\ code\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_OS_method_is_keycode_unicode>`
Возвращает ``true``, если входной keycode соответствует символу Unicode. Список кодов см. в константах :ref:`Key<enum_@GlobalScope_Key>`.
.. tabs::
.. code-tab:: gdscript
print(OS.is_keycode_unicode(KEY_G)) # Выводит true
print(OS.is_keycode_unicode(KEY_KP_4)) # Выводит true
print(OS.is_keycode_unicode(KEY_TAB)) # Выводит false
print(OS.is_keycode_unicode(KEY_ESCAPE)) # Выводит false
.. code-tab:: csharp
GD.Print(OS.IsKeycodeUnicode((long)Key.G)); // Выводит True
GD.Print(OS.IsKeycodeUnicode((long)Key.Kp4)); // Выводит True
GD.Print(OS.IsKeycodeUnicode((long)Key.Tab)); // Выводит False
GD.Print(OS.IsKeycodeUnicode((long)Key.Escape)); // Выводит False
.. rst-class:: classref-item-separator
----
.. _class_OS_method_is_process_running:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_process_running**\ (\ pid\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_OS_method_is_process_running>`
Возвращает ``true``, если идентификатор дочернего процесса (``pid``) все еще выполняется, или ``false``, если он был завершен. ``pid`` должен быть допустимым идентификатором, сгенерированным из :ref:`create_process()<class_OS_method_create_process>`.
\ **Примечание:** Этот метод реализован в Android, iOS, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_is_restart_on_exit_set:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_restart_on_exit_set**\ (\ ) |const| :ref:`🔗<class_OS_method_is_restart_on_exit_set>`
Возвращает ``true``, если проект автоматически перезапустится при выходе из него по любой причине, ``false`` в противном случае. См. также :ref:`set_restart_on_exit()<class_OS_method_set_restart_on_exit>` и :ref:`get_restart_on_exit_arguments()<class_OS_method_get_restart_on_exit_arguments>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_is_sandboxed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_sandboxed**\ (\ ) |const| :ref:`🔗<class_OS_method_is_sandboxed>`
Возвращает ``true``, если приложение запущено в песочнице.
\ **Примечание:** Этот метод реализован только в macOS и Linux.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_is_stdout_verbose:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_stdout_verbose**\ (\ ) |const| :ref:`🔗<class_OS_method_is_stdout_verbose>`
Возвращает ``true``, если движок был запущен с аргументом командной строки ``--verbose`` или ``-v``, или если :ref:`ProjectSettings.debug/settings/stdout/verbose_stdout<class_ProjectSettings_property_debug/settings/stdout/verbose_stdout>` равен ``true``. См. также :ref:`@GlobalScope.print_verbose()<class_@GlobalScope_method_print_verbose>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_is_userfs_persistent:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_userfs_persistent**\ (\ ) |const| :ref:`🔗<class_OS_method_is_userfs_persistent>`
Возвращает ``true``, если файловая система ``user://`` является постоянной, то есть ее состояние остается прежним после того, как игрок выходит из игры и снова ее запускает. Относится к веб-платформе, где эта постоянная возможность может быть недоступна.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_kill:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **kill**\ (\ pid\: :ref:`int<class_int>`\ ) :ref:`🔗<class_OS_method_kill>`
Убить (завершить) процесс, идентифицированный заданным идентификатором процесса (``pid``), например, идентификатором, возвращаемым :ref:`execute()<class_OS_method_execute>` в неблокируемом режиме. См. также :ref:`crash()<class_OS_method_crash>`.
\ **Примечание:** Этот метод также можно использовать для уничтожения процессов, которые не были порождены движком.
\ **Примечание:** Этот метод реализован в Android, iOS, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_move_to_trash:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **move_to_trash**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_OS_method_move_to_trash>`
Перемещает файл или каталог по указанному ``path`` в системную корзину. См. также :ref:`DirAccess.remove()<class_DirAccess_method_remove>`.
Метод принимает только глобальные пути, поэтому вам может потребоваться использовать :ref:`ProjectSettings.globalize_path()<class_ProjectSettings_method_globalize_path>`. Не используйте его для файлов в ``res://``, так как он не будет работать в экспортированных проектах.
Возвращает :ref:`@GlobalScope.FAILED<class_@GlobalScope_constant_FAILED>`, если файл или каталог не могут быть найдены или система не поддерживает этот метод.
.. tabs::
.. code-tab:: gdscript
var file_to_remove = "user://slot1.save"
OS.move_to_trash(ProjectSettings.globalize_path(file_to_remove))
.. code-tab:: csharp
var fileToRemove = "user://slot1.save";
OS.MoveToTrash(ProjectSettings.GlobalizePath(fileToRemove));
\ **Примечание:** Этот метод реализован на Android, Linux, macOS и Windows.
\ **Примечание:** Если пользователь отключил корзину в своей системе, файл будет удален навсегда.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_open_midi_inputs:
.. rst-class:: classref-method
|void| **open_midi_inputs**\ (\ ) :ref:`🔗<class_OS_method_open_midi_inputs>`
Инициализирует синглтон для системного драйвера MIDI, позволяя Godot получать :ref:`InputEventMIDI<class_InputEventMIDI>`. См. также :ref:`get_connected_midi_inputs()<class_OS_method_get_connected_midi_inputs>` и :ref:`close_midi_inputs()<class_OS_method_close_midi_inputs>`.
\ **Примечание:** Этот метод реализован в Linux, macOS, Windows и Web.
\ **Примечание:** На веб-платформе веб-MIDI должен поддерживаться браузером. `На данный момент <https://caniuse.com/midi>`__ он поддерживается всеми основными браузерами, кроме Safari.
\ **Примечание:** На веб-платформе использование ввода MIDI требует предварительного предоставления разрешения браузеру. Этот запрос разрешения выполняется при вызове :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>`. Браузер воздержится от обработки ввода MIDI, пока пользователь не примет запрос разрешения.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_open_with_program:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **open_with_program**\ (\ program_path\: :ref:`String<class_String>`, paths\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) :ref:`🔗<class_OS_method_open_with_program>`
Открывает один или несколько файлов/каталогов с помощью указанного приложения. Параметр ``program_path`` задаёт путь к приложению, используемому для открытия файлов, а ``paths`` содержит массив путей к файлам/каталогам, которые нужно открыть.
\ **Примечание:** Этот метод в основном актуален только для macOS, где открытие файлов с помощью :ref:`create_process()<class_OS_method_create_process>` может завершиться ошибкой. На других платформах используется :ref:`create_process()<class_OS_method_create_process>`.
\ **Примечание:** В macOS параметр ``program_path`` в идеале должен быть путём к пакету ``.app``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_read_buffer_from_stdin:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **read_buffer_from_stdin**\ (\ buffer_size\: :ref:`int<class_int>` = 1024\ ) :ref:`🔗<class_OS_method_read_buffer_from_stdin>`
Считывает пользовательский ввод как необработанные данные из стандартного ввода. Эта операция может быть *блокирующей*, что приводит к замораживанию окна, если :ref:`read_buffer_from_stdin()<class_OS_method_read_buffer_from_stdin>` вызывается в основном потоке.
- Если стандартный ввод — консоль, этот метод будет блокироваться до тех пор, пока программа не получит разрыв строки в стандартном вводе (обычно нажатием пользователем :kbd:`Enter`).
- Если стандартный ввод — канал, этот метод будет блокироваться до тех пор, пока не будет прочитано определенное количество данных или канал не будет закрыт.
- Если стандартный ввод — файл, этот метод прочитает определенное количество данных (или меньше, если достигнут конец файла) и немедленно вернется.
\ **Примечание:** Этот метод реализован в Linux, macOS и Windows.
\ **Примечание:** В экспортированных сборках Windows запустите исполняемый файл оболочки консоли для доступа к терминалу. Если стандартный ввод — консоль, вызов этого метода без оболочки консоли приведет к постоянной заморозке. Если стандартный ввод — это канал или файл, его можно использовать без оболочки консоли. Если вам нужен один исполняемый файл с полной поддержкой консоли, используйте пользовательскую сборку, скомпилированную с флагом ``windows_subsystem=console``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_read_string_from_stdin:
.. rst-class:: classref-method
:ref:`String<class_String>` **read_string_from_stdin**\ (\ buffer_size\: :ref:`int<class_int>` = 1024\ ) :ref:`🔗<class_OS_method_read_string_from_stdin>`
Считывает пользовательский ввод как строку в кодировке UTF-8 из стандартного ввода. Эта операция может быть *блокирующей*, что приводит к замораживанию окна, если :ref:`read_string_from_stdin()<class_OS_method_read_string_from_stdin>` вызывается в основном потоке.
- Если стандартный ввод — консоль, этот метод будет блокироваться до тех пор, пока программа не получит разрыв строки в стандартном вводе (обычно нажатием пользователем :kbd:`Enter`).
- Если стандартный ввод — канал, этот метод будет блокироваться до тех пор, пока не будет прочитано определенное количество данных или канал не будет закрыт.
- Если стандартный ввод — файл, этот метод прочитает определенное количество данных (или меньше, если достигнут конец файла) и немедленно вернет управление.
\ **Примечание:** Этот метод автоматически заменяет разрывы строк ``\r\n`` на ``\n`` и удаляет их из конца строки. Используйте :ref:`read_buffer_from_stdin()<class_OS_method_read_buffer_from_stdin>` для чтения необработанных данных.
\ **Примечание:** Этот метод реализован в Linux, macOS и Windows.
\ **Примечание:** В экспортированных сборках Windows запустите исполняемый файл оболочки консоли, чтобы получить доступ к терминалу. Если стандартный ввод — консоль, вызов этого метода без оболочки консоли зависнет навсегда. Если стандартный ввод — канал или файл, его можно использовать без оболочки консоли. Если вам нужен один исполняемый файл с полной поддержкой консоли, используйте пользовательскую сборку, скомпилированную с флагом ``windows_subsystem=console``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_remove_logger:
.. rst-class:: classref-method
|void| **remove_logger**\ (\ logger\: :ref:`Logger<class_Logger>`\ ) :ref:`🔗<class_OS_method_remove_logger>`
Удалить пользовательский логер, добавленный :ref:`add_logger()<class_OS_method_add_logger>`.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_request_permission:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **request_permission**\ (\ name\: :ref:`String<class_String>`\ ) :ref:`🔗<class_OS_method_request_permission>`
Запрашивает разрешение у ОС для указанного ``name``. Возвращает ``true``, если разрешение уже предоставлено. См. также :ref:`MainLoop.on_request_permissions_result<class_MainLoop_signal_on_request_permissions_result>`.
\ ``name`` должно быть полным именем разрешения. Например:
- ``OS.request_permission("android.permission.READ_EXTERNAL_STORAGE")``\
- ``OS.request_permission("android.permission.POST_NOTIFICATIONS")``\
- ``OS.request_permission("macos.permission.RECORD_SCREEN")``\
- ``OS.request_permission("appleembedded.permission.AUDIO_RECORD")``\
\ **Примечание:** На Android разрешение необходимо проверять во время экспорта.
\ **Примечание:** Этот метод реализован на платформах Android, macOS и visionOS.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_request_permissions:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **request_permissions**\ (\ ) :ref:`🔗<class_OS_method_request_permissions>`
Запрашивает *опасные* разрешения от ОС. Возвращает ``true``, если разрешения уже предоставлены. См. также :ref:`MainLoop.on_request_permissions_result<class_MainLoop_signal_on_request_permissions_result>`.
\ **Примечание:** Разрешения должны быть проверены во время экспорта.
\ **Примечание:** Этот метод реализован только на Android. Обычные разрешения автоматически предоставляются во время установки в приложениях Android.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_revoke_granted_permissions:
.. rst-class:: classref-method
|void| **revoke_granted_permissions**\ (\ ) :ref:`🔗<class_OS_method_revoke_granted_permissions>`
В macOS (только для изолированных приложений) эта функция очищает список выбранных пользователем папок, доступных приложению.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_set_environment:
.. rst-class:: classref-method
|void| **set_environment**\ (\ variable\: :ref:`String<class_String>`, value\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_OS_method_set_environment>`
Устанавливает значение переменной среды ``variable`` на ``value``. Переменная среды будет установлена для процесса Godot и любого процесса, выполняемого с помощью :ref:`execute()<class_OS_method_execute>` после запуска :ref:`set_environment()<class_OS_method_set_environment>`. Переменная среды *не* сохранится в процессах, запущенных после завершения процесса Godot.
\ **Примечание:** Имена переменных среды чувствительны к регистру на всех платформах, кроме Windows. Имя ``variable`` не может быть пустым или включать символ ``=``. В Windows существует ограничение в 32767 символов для общей длины ``variable``, ``value``, а также ``=`` и нулевого терминатора, которые будут зарегистрированы в блоке среды.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_set_restart_on_exit:
.. rst-class:: classref-method
|void| **set_restart_on_exit**\ (\ restart\: :ref:`bool<class_bool>`, arguments\: :ref:`PackedStringArray<class_PackedStringArray>` = PackedStringArray()\ ) :ref:`🔗<class_OS_method_set_restart_on_exit>`
Если ``restart`` равен ``true``, автоматически перезапускает проект при выходе из него с помощью :ref:`SceneTree.quit()<class_SceneTree_method_quit>` или :ref:`Node.NOTIFICATION_WM_CLOSE_REQUEST<class_Node_constant_NOTIFICATION_WM_CLOSE_REQUEST>`. Можно указать ``arguments`` командной строки. Чтобы перезапустить проект с теми же аргументами командной строки, которые изначально использовались для запуска проекта, передайте :ref:`get_cmdline_args()<class_OS_method_get_cmdline_args>` в качестве значения для ``arguments``.
Этот метод можно использовать для применения изменений настроек, требующих перезапуска. См. также :ref:`is_restart_on_exit_set()<class_OS_method_is_restart_on_exit_set>` и :ref:`get_restart_on_exit_arguments()<class_OS_method_get_restart_on_exit_arguments>`.
\ **Примечание:** Этот метод эффективен только на настольных платформах и только когда проект не запущен из редактора. Он не будет иметь никакого эффекта на мобильных и веб-платформах или когда проект запущен из редактора.
\ **Примечание:** Если процесс проекта аварийно завершается или *завершен* пользователем (путем отправки ``SIGKILL`` вместо обычного ``SIGTERM``), проект не будет перезапущен автоматически.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_set_thread_name:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **set_thread_name**\ (\ name\: :ref:`String<class_String>`\ ) :ref:`🔗<class_OS_method_set_thread_name>`
Назначает заданное имя текущему потоку. Возвращает :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>`, если недоступно на текущей платформе.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_set_use_file_access_save_and_swap:
.. rst-class:: classref-method
|void| **set_use_file_access_save_and_swap**\ (\ enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_OS_method_set_use_file_access_save_and_swap>`
Если ``enabled`` имеет значение ``true``, при открытии файла для записи вместо него используется временный файл. При закрытии он автоматически применяется к целевому файлу.
Это может быть полезно, когда файлы могут быть открыты другими приложениями, такими как антивирусы, текстовые редакторы или даже сам редактор Godot.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_shell_open:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **shell_open**\ (\ uri\: :ref:`String<class_String>`\ ) :ref:`🔗<class_OS_method_shell_open>`
Запрашивает у ОС открытие ресурса, указанного ``uri``, с помощью наиболее подходящей программы. Например:
- ``OS.shell_open("C:\\Users\\name\\Downloads")`` в Windows открывает файловый менеджер в папке "Загрузки" пользователя.
- ``OS.shell_open("C:/Users/name/Downloads")`` также работает в Windows и открывает файловый менеджер в папке "Загрузки" пользователя.
- ``OS.shell_open("https://godotengine.org")`` открывает веб-браузер по умолчанию на официальном сайте Godot.
- ``OS.shell_open("mailto:example@example.com")`` открывает почтовый клиент по умолчанию с полем "Кому" в значении ``example@example.com``. См. `RFC 2368 — Схема URL [code]mailto[/code] <https://datatracker.ietf.org/doc/html/rfc2368>`__ для списка полей, которые можно добавить.
Используйте :ref:`ProjectSettings.globalize_path()<class_ProjectSettings_method_globalize_path>` для преобразования пути проекта ``res://`` или ``user://`` в системный путь для использования с этим методом.
\ **Примечание:** Используйте :ref:`String.uri_encode()<class_String_method_uri_encode>` для кодирования символов в URL-адресах безопасным для URL-адресов, переносимым способом. Это особенно необходимо для переносов строк. В противном случае :ref:`shell_open()<class_OS_method_shell_open>` может работать некорректно в проекте, экспортированном на веб-платформу.
\ **Примечание:** Этот метод реализован на Android, iOS, Web, Linux, macOS и Windows.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_shell_show_in_file_manager:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **shell_show_in_file_manager**\ (\ file_or_dir_path\: :ref:`String<class_String>`, open_folder\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_OS_method_shell_show_in_file_manager>`
Запрашивает у ОС открытие файлового менеджера, переход к указанному ``file_or_dir_path`` и выбор целевого файла или папки.
Если ``open_folder`` равно ``true`` и ``file_or_dir_path`` является допустимым путем к каталогу, ОС откроет файловый менеджер и перейдет к целевой папке, ничего не выбирая.
Используйте :ref:`ProjectSettings.globalize_path()<class_ProjectSettings_method_globalize_path>` для преобразования пути проекта ``res://`` или ``user://`` в системный путь для использования с этим методом.
\ **Примечание:** Этот метод в настоящее время реализован только в Windows и macOS. На других платформах он будет возвращаться к :ref:`shell_open()<class_OS_method_shell_open>` с путем к каталогу ``file_or_dir_path`` с префиксом ``file://``.
.. rst-class:: classref-item-separator
----
.. _class_OS_method_unset_environment:
.. rst-class:: classref-method
|void| **unset_environment**\ (\ variable\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_OS_method_unset_environment>`
Удаляет указанную переменную среды из текущей среды, если она существует. Имя ``variable`` не может быть пустым или включать символ ``=``. Переменная среды будет удалена для процесса Godot и любого процесса, выполняемого с :ref:`execute()<class_OS_method_execute>` после запуска :ref:`unset_environment()<class_OS_method_unset_environment>`. Удаление переменной среды *не* сохранится для процессов, запущенных после завершения процесса Godot.
\ **Примечание:** Имена переменных среды чувствительны к регистру на всех платформах, кроме Windows.
.. |virtual| replace:: :abbr:`virtual (Этот метод обычно должен быть переопределен пользователем, чтобы иметь какой-либо эффект.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Этот метод не имеет побочных эффектов. Он не изменяет ни одну из переменных-членов экземпляра.)`
.. |vararg| replace:: :abbr:`vararg (Этот метод принимает любое количество аргументов после описанных здесь.)`
.. |constructor| replace:: :abbr:`constructor (Этот метод используется для создания типа.)`
.. |static| replace:: :abbr:`static (Этот метод не нуждается в вызове экземпляра, поэтому его можно вызвать напрямую, используя имя класса.)`
.. |operator| replace:: :abbr:`operator (Этот метод описывает допустимый оператор для использования с этим типом в качестве левого операнда.)`
.. |bitfield| replace:: :abbr:`BitField (Это значение является целым числом, составленным как битовая маска следующих флагов.)`
.. |void| replace:: :abbr:`void (Нет возвращаемого значения.)`
Reference in New Issue View Git Blame Copy Permalink