godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/it/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
147 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_OS:
OS
==
**Eredita:** :ref:`Object<class_Object>`
Fornisce l'accesso alle funzionalità comuni del sistema operativo.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
La classe **OS** racchiude le funzionalità più comuni per comunicare con il sistema operativo host, come il driver video, i ritardi, le variabili di ambiente, l'esecuzione di binari, la riga di comando, ecc.
\ **Nota:** In Godot 4, le funzioni **OS** riguardo la gestione delle finestre, agli appunti e al TTS sono state spostate nel singleton :ref:`DisplayServer<class_DisplayServer>` (e nella classe :ref:`Window<class_Window>`). Le funzioni riguardo il tempo sono state rimosse e sono disponibili solo nella classe :ref:`Time<class_Time>`.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- `Demo di test di sistema operativo <https://godotengine.org/asset-library/asset/2789>`__
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. 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
Metodi
------------
.. 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
Enumerazioni
------------------------
.. _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``
Il driver di rendering Vulkan. Richiede il supporto per Vulkan 1.0 e utilizza automaticamente le funzionalità di Vulkan 1.1 e 1.2, se disponibili.
.. _class_OS_constant_RENDERING_DRIVER_OPENGL3:
.. rst-class:: classref-enumeration-constant
:ref:`RenderingDriver<enum_OS_RenderingDriver>` **RENDERING_DRIVER_OPENGL3** = ``1``
Il driver di rendering OpenGL 3. Utilizza OpenGL 3.3 Core Profile su piattaforme desktop, OpenGL ES 3.0 su dispositivi mobili e WebGL 2.0 su Web.
.. _class_OS_constant_RENDERING_DRIVER_D3D12:
.. rst-class:: classref-enumeration-constant
:ref:`RenderingDriver<enum_OS_RenderingDriver>` **RENDERING_DRIVER_D3D12** = ``2``
Il driver di rendering Direct3D 12.
.. _class_OS_constant_RENDERING_DRIVER_METAL:
.. rst-class:: classref-enumeration-constant
:ref:`RenderingDriver<enum_OS_RenderingDriver>` **RENDERING_DRIVER_METAL** = ``3``
Il driver di rendering 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``
Fa riferimento al percorso della cartella Desktop.
.. _class_OS_constant_SYSTEM_DIR_DCIM:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_DCIM** = ``1``
Fa riferimento al percorso della cartella DCIM (immagini della fotocamera digitale).
.. _class_OS_constant_SYSTEM_DIR_DOCUMENTS:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_DOCUMENTS** = ``2``
Fa riferimento al percorso della cartella Documenti.
.. _class_OS_constant_SYSTEM_DIR_DOWNLOADS:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_DOWNLOADS** = ``3``
Fa riferimento al percorso della cartella Download.
.. _class_OS_constant_SYSTEM_DIR_MOVIES:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_MOVIES** = ``4``
Fa riferimento al percorso della cartella Film (o Video).
.. _class_OS_constant_SYSTEM_DIR_MUSIC:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_MUSIC** = ``5``
Fa riferimento al percorso della cartella Musica.
.. _class_OS_constant_SYSTEM_DIR_PICTURES:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_PICTURES** = ``6``
Fa riferimento al percorso della cartella Immagini.
.. _class_OS_constant_SYSTEM_DIR_RINGTONES:
.. rst-class:: classref-enumeration-constant
:ref:`SystemDir<enum_OS_SystemDir>` **SYSTEM_DIR_RINGTONES** = ``7``
Fa riferimento al percorso della cartella Suonerie.
.. 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``
Il dispositivo I/O standard non è valido. Non è possibile ricevere o inviare dati da questi dispositivi I/O standard.
.. _class_OS_constant_STD_HANDLE_CONSOLE:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_CONSOLE** = ``1``
Il dispositivo I/O standard è una console. Ciò avviene generalmente quando Godot è eseguito da un terminale senza reindirizzamento. È utilizzato anche per tutti i dispositivi I/O standard quando Godot è eseguito dall'editor, almeno sulle piattaforme desktop.
.. _class_OS_constant_STD_HANDLE_FILE:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_FILE** = ``2``
Il dispositivo I/O standard è un file normale. Ciò avviene generalmente con il reindirizzamento da un terminale, ad esempio ``godot > stdout.txt``, ``godot < stdin.txt`` o ``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``
Il dispositivo I/O standard è un FIFO/pipe. Ciò avviene generalmente con l'utilizzo di pipe da un terminale, ad esempio ``echo "Hello" | godot``.
.. _class_OS_constant_STD_HANDLE_UNKNOWN:
.. rst-class:: classref-enumeration-constant
:ref:`StdHandleType<enum_OS_StdHandleType>` **STD_HANDLE_UNKNOWN** = ``4``
Il tipo di dispositivo I/O standard è sconosciuto.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _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**\ (\ )
Se ``true``, il motore filtra il delta temporale misurato tra ogni frame e tenta di compensare la variazione casuale. Funziona solo su sistemi in cui il V-Sync è attivo.
\ **Nota:** All'avvio, è uguale a :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**\ (\ )
Se ``true``, il motore ottimizza l'utilizzo ridotto del processore aggiornando lo schermo solo se necessario. Può migliorare il consumo della batteria sui dispositivi mobili.
\ **Nota:** All'avvio, è uguale a :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**\ (\ )
La quantità di sospensione tra i frame quando è abilitata la modalità di utilizzo a basso processore, in microsecondi. Valori più alti comporteranno un utilizzo inferiore della CPU. Vedi anche :ref:`low_processor_usage_mode<class_OS_property_low_processor_usage_mode>`.
\ **Nota:** All'avvio, è uguale a :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
Descrizioni dei metodi
--------------------------------------------
.. _class_OS_method_add_logger:
.. rst-class:: classref-method
|void| **add_logger**\ (\ logger\: :ref:`Logger<class_Logger>`\ ) :ref:`🔗<class_OS_method_add_logger>`
Aggiunge un logger personalizzato per intercettare il flusso interno di messaggi.
.. 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>`
Visualizza una finestra di dialogo modale utilizzando l'implementazione della piattaforma host. L'esecuzione del motore è bloccata finché la finestra di dialogo non viene chiusa.
.. 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>`
Spegne il driver MIDI del sistema. Godot non riceverà più :ref:`InputEventMIDI<class_InputEventMIDI>`. Vedi anche :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>` e :ref:`get_connected_midi_inputs()<class_OS_method_get_connected_midi_inputs>`.
\ **Nota:** Questo metodo è implementato su Linux, macOS, Windows e 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>`
Arresta il motore (o l'editor se richiamato all'interno di uno script ``@tool``). Vedi anche :ref:`kill()<class_OS_method_kill>`.
\ **Nota:** Questo metodo dovrebbe essere *solo* utilizzato per testare il gestore dei crash del sistema, non per altri scopi. Per la segnalazione di errori generali, usa (in ordine di preferenza) :ref:`@GDScript.assert()<class_@GDScript_method_assert>`, :ref:`@GlobalScope.push_error()<class_@GlobalScope_method_push_error>` o :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>`
Crea una nuova istanza di Godot che viene eseguita in modo indipendente. Gli argomenti ``arguments`` sono utilizzati nell'ordine specificato e separati da uno spazio.
Se il processo viene creato correttamente, questo metodo restituisce l'ID del nuovo processo, che puoi utilizzare per monitorare il processo (e potenzialmente terminarlo con :ref:`kill()<class_OS_method_kill>`). Se il processo non può essere creato, questo metodo restituisce ``-1``.
Consulta :ref:`create_process()<class_OS_method_create_process>` se desideri eseguire un processo diverso.
\ **Nota:** Questo metodo è implementato su Android, Linux, macOS e 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>`
Crea un nuovo processo che viene eseguito indipendentemente da Godot. Non terminerà quando Godot termina. Il percorso specificato in ``path`` deve esistere ed essere un file eseguibile o un bundle ``.app`` per macOS. Il percorso è risolto in base alla piattaforma attuale. Gli argomenti ``arguments`` sono utilizzati nell'ordine specificato e separati da uno spazio.
Su Windows, se ``open_console`` è ``true`` e il processo è un'applicazione da console, verrà aperta una nuova finestra del terminale.
Se il processo viene creato correttamente, questo metodo restituisce il suo ID di processo, che puoi utilizzare per monitorare il processo (e potenzialmente terminarlo con :ref:`kill()<class_OS_method_kill>`). Altrimenti, questo metodo restituisce ``-1``.
\ **Esempio:** Esegui un'altra istanza del progetto:
.. tabs::
.. code-tab:: gdscript
var pid = OS.create_process(OS.get_executable_path(), [])
.. code-tab:: csharp
var pid = OS.CreateProcess(OS.GetExecutablePath(), new string[] {});
Vedi :ref:`execute()<class_OS_method_execute>` se desideri eseguire un comando esterno e recuperare i risultati.
\ **Nota:** Questo metodo è implementato su Android, Linux, macOS e Windows.
\ **Nota:** Su macOS, le applicazioni in sandbox sono limitate all'esecuzione di soli eseguibili di supporto incorporati, specificati durante l'esportazione o il bundle .app di sistema, i bundle .app di sistema ignoreranno gli argomenti.
.. 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>`
Ritarda l'esecuzione del thread corrente di ``msec`` millisecondi. ``msec`` deve essere maggiore o uguale a ``0``. Altrimenti, :ref:`delay_msec()<class_OS_method_delay_msec>` non fa nulla e stampa un messaggio di errore.
\ **Nota:** :ref:`delay_msec()<class_OS_method_delay_msec>` è un modo *bloccante* per ritardare l'esecuzione del codice. Per ritardare l'esecuzione del codice in modo non bloccante, puoi usare :ref:`SceneTree.create_timer()<class_SceneTree_method_create_timer>`. L'attesa con :ref:`SceneTreeTimer<class_SceneTreeTimer>` ritarda l'esecuzione del codice sotto la dichiarazione di ``await`` senza influenzare il resto del progetto (o editor, per :ref:`EditorPlugin<class_EditorPlugin>` e :ref:`EditorScript<class_EditorScript>`).
\ **Nota:** Quando :ref:`delay_msec()<class_OS_method_delay_msec>` viene chiamato sul thread principale, bloccherà il progetto e gli impedirà di ridisegnare e registrare gli input finché il ritardo non sarà trascorso. Quando si utilizza :ref:`delay_msec()<class_OS_method_delay_msec>` come parte di un :ref:`EditorPlugin<class_EditorPlugin>` o :ref:`EditorScript<class_EditorScript>`, l'editor verrà bloccato ma non il progetto se è in esecuzione (poiché il progetto è un processo figlio indipendente).
.. 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>`
Ritarda l'esecuzione del thread corrente di ``usec`` microsecondi. ``usec`` deve essere maggiore o uguale a ``0``. Altrimenti, :ref:`delay_usec()<class_OS_method_delay_usec>` non fa nulla e stampa un messaggio di errore.
\ **Nota:** :ref:`delay_usec()<class_OS_method_delay_usec>` è un modo *bloccante* per ritardare l'esecuzione del codice. Per ritardare l'esecuzione del codice in modo non bloccante, puoi usare :ref:`SceneTree.create_timer()<class_SceneTree_method_create_timer>`. L'attesa con :ref:`SceneTreeTimer<class_SceneTreeTimer>` ritarda l'esecuzione del codice sotto la dichiarazione di ``await`` senza influenzare il resto del progetto (o editor, per :ref:`EditorPlugin<class_EditorPlugin>` e :ref:`EditorScript<class_EditorScript>`).
\ **Nota:** Quando :ref:`delay_usec()<class_OS_method_delay_usec>` viene chiamato sul thread principale, bloccherà il progetto e gli impedirà di ridisegnare e registrare gli input finché il ritardo non sarà trascorso. Quando si utilizza :ref:`delay_usec()<class_OS_method_delay_usec>` come parte di un :ref:`EditorPlugin<class_EditorPlugin>` o :ref:`EditorScript<class_EditorScript>`, l'editor verrà bloccato ma non il progetto se è in esecuzione (poiché il progetto è un processo figlio indipendente).
.. 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>`
Esegue il processo specificato in modo *bloccante*. Il file specificato in ``path`` deve esistere ed essere eseguibile. Sarà usata la risoluzione del percorso di sistema. Gli argomenti ``arguments`` sono usati nell'ordine specificato, separati da spazi e racchiusi tra virgolette.
Se viene fornito un array ``output``, l'output completo della shell del processo è aggiunto a ``output`` come un singolo elemento :ref:`String<class_String>`. Se ``read_stderr`` è ``true``, anche l'output nel canale di error standard è aggiunto all'array.
Su Windows, se ``open_console`` è ``true`` e il processo è un'app console, è aperta una nuova finestra del terminale.
Questo metodo restituisce il codice di uscita del comando o ``-1`` se il processo non riesce a essere eseguito.
\ **Nota:** Il thread principale sarà bloccato fino al termine del comando eseguito. Usa :ref:`Thread<class_Thread>` per creare un thread separato che non bloccherà il thread principale, oppure usa :ref:`create_process()<class_OS_method_create_process>` per creare un processo completamente indipendente.
Ad esempio, per recuperare una lista del contenuto della cartella di lavoro:
.. 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);
Se si desidera accedere a una shell integrata o eseguire un comando composito, è possibile richiamare una shell specifica della piattaforma. Ad esempio:
.. 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);
\ **Nota:** Questo metodo è implementato su Android, Linux, macOS e Windows.
\ **Nota:** Per eseguire un comando integrato dell'interprete dei comandi in Windows, specifica ``cmd.exe`` in ``path``, ``/c`` come primo argomento e il comando desiderato come secondo argomento.
\ **Nota:** Per eseguire un comando integrato in PowerShell, specificare ``powershell.exe`` in ``path``, ``-Command`` come primo argomento e il comando desiderato come secondo argomento.
\ **Nota:** Per eseguire un comando integrato della shell in Unix, specificare il nome dell'eseguibile della shell in ``path``, ``-c`` come primo argomento e il comando desiderato come secondo argomento.
\ **Nota:** Su macOS, le applicazioni in sandbox possono soltanto eseguire gli eseguibili incorporati ausiliari, specificati durante l'esportazione.
\ **Nota:** Su Android, i comandi di sistema come ``dumpsys`` possono essere eseguiti solo su un dispositivo radicato.
.. 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>`
Crea un nuovo processo che è eseguito indipendentemente da Godot con IO reindirizzato. Non terminerà quando Godot termina. Il percorso specificato in ``path`` deve esistere ed essere un file eseguibile o un bundle macOS ``.app``. Il percorso è risolto in base alla piattaforma attuale. Gli argomenti ``arguments`` sono usati nell'ordine specificato e separati da uno spazio.
Se ``blocking`` è ``false``, le pipe create funzionano in modalità non bloccante, ovvero le operazioni di lettura e scrittura verranno restituite immediatamente. Usa :ref:`FileAccess.get_error()<class_FileAccess_method_get_error>` per verificare se l'ultima operazione di lettura o di scrittura ha avuto successo.
Se il processo non può essere creato, questo metodo restituisce un :ref:`Dictionary<class_Dictionary>` vuoto. Altrimenti, questo metodo restituisce un :ref:`Dictionary<class_Dictionary>` con le seguenti chiavi:
- ``"stdio"`` - :ref:`FileAccess<class_FileAccess>` per accedere ai canali stdin e stdout del processo (lettura/scrittura).
- ``"stderr"`` - :ref:`FileAccess<class_FileAccess>` per accedere al canale stderr del processo (sola lettura).
- ``"pid"`` - ID processo come :ref:`int<class_int>`, che si può utilizzare per monitorare il processo (e potenzialmente terminarlo con :ref:`kill()<class_OS_method_kill>`).
\ **Nota:** Questo metodo è implementato su Android, Linux, macOS e Windows.
\ **Nota:** Per eseguire un comando integrato dell'interprete dei comandi in Windows, specifica ``cmd.exe`` in ``path``, ``/c`` come primo argomento e il comando desiderato come secondo argomento.
\ **Nota:** Per eseguire un comando integrato in PowerShell, specificare ``powershell.exe`` in ``path``, ``-Command`` come primo argomento e il comando desiderato come secondo argomento.
\ **Nota:** Per eseguire un comando integrato della shell in Unix, specificare il nome dell'eseguibile della shell in ``path``, ``-c`` come primo argomento e il comando desiderato come secondo argomento.
\ **Nota:** Su macOS, le applicazioni in sandbox possono soltanto eseguire gli eseguibili incorporati ausiliari, specificati durante l'esportazione o il bundle .app di sistema; i bundle .app di sistema ignoreranno gli argomenti.
.. 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>`
Trova il codice tasto per la stringa specificata. I valori restituiti sono equivalenti alle costanti di :ref:`Key<enum_@GlobalScope_Key>`.
.. tabs::
.. code-tab:: gdscript
print(OS.find_keycode_from_string("C")) # Stampa 67 (KEY_C)
print(OS.find_keycode_from_string("Escape")) # Stampa 4194305 (KEY_ESCAPE)
print(OS.find_keycode_from_string("Shift+Tab")) # Stampa 37748738 (KEY_MASK_SHIFT | KEY_TAB)
print(OS.find_keycode_from_string("Unknown")) # Stampa 0 (KEY_NONE)
.. code-tab:: csharp
GD.Print(OS.FindKeycodeFromString("C")); // Stampa C (Key.C)
GD.Print(OS.FindKeycodeFromString("Escape")); // Stampa Escape (Key.Escape)
GD.Print(OS.FindKeycodeFromString("Shift+Tab")); // Stampa 37748738 (KeyModifierMask.MaskShift | Key.Tab)
GD.Print(OS.FindKeycodeFromString("Unknown")); // Stampa None (Key.None)
Vedi anche :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>`
Restituisce la cartella dei dati della cache *globale* in base agli standard del sistema operativo.
Sulla piattaforma Linux/BSD, questo percorso può essere sovrascritto impostando la variabile d'ambiente ``XDG_CACHE_HOME`` prima di avviare il progetto. Consulta :doc:`Percorsi dei file nei progetti Godot <../tutorials/io/data_paths>` nella documentazione per maggiori informazioni. Vedi anche :ref:`get_config_dir()<class_OS_method_get_config_dir>` e :ref:`get_data_dir()<class_OS_method_get_data_dir>`.
Da non confondere con :ref:`get_user_data_dir()<class_OS_method_get_user_data_dir>`, che restituisce il percorso dei dati utente *specifico per il progetto*.
.. 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>`
Restituisce la cartella di configurazione utente *globale* in base agli standard del sistema operativo.
Sulla piattaforma Linux/BSD, questo percorso può essere sovrascritto impostando la variabile d'ambiente ``XDG_CONFIG_HOME`` prima di avviare il progetto. Consulta :doc:`Percorsi dei file nei progetti Godot <../tutorials/io/data_paths>` nella documentazione per maggiori informazioni. Vedi anche :ref:`get_cache_dir()<class_OS_method_get_cache_dir>` e :ref:`get_data_dir()<class_OS_method_get_data_dir>`.
Da non confondere con :ref:`get_user_data_dir()<class_OS_method_get_user_data_dir>`, che restituisce il percorso dei dati utente *specifico per il progetto*.
.. 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>`
Restituisce un array di nomi dei dispositivi MIDI connessi, se esistono. Restituisce un array vuoto se il driver MIDI del sistema non è stato inizializzato in precedenza con :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>`. Vedi anche :ref:`close_midi_inputs()<class_OS_method_close_midi_inputs>`.
\ **Nota:** Questo metodo è implementato su Linux, macOS, Windows e Web.
\ **Nota:** Sulla piattaforma Web, il browser deve supportare Web MIDI. `Per il momento <https://caniuse.com/midi>`__, è supportato da tutti i principali browser, tranne Safari.
\ **Nota:** Sulla piattaforma Web, l'utilizzo dell'input MIDI richiede prima l'autorizzazione del browser. Questa richiesta di autorizzazione viene eseguita quando viene chiamato :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>`. L'input MIDI non funzionerà finché l'utente non accetta la richiesta di autorizzazione.
.. 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>`
Restituisce la cartella di dati utente *globale* in base agli standard del sistema operativo.
Sulla piattaforma Linux/BSD, questo percorso può essere sovrascritto impostando la variabile d'ambiente ``XDG_DATA_HOME`` prima di avviare il progetto. Consulta :doc:`Percorsi dei file nei progetti Godot <../tutorials/io/data_paths>` nella documentazione per maggiori informazioni. Vedi anche :ref:`get_cache_dir()<class_OS_method_get_cache_dir>` e :ref:`get_config_dir()<class_OS_method_get_config_dir>`.
Da non confondere con :ref:`get_user_data_dir()<class_OS_method_get_user_data_dir>`, che restituisce il percorso dei dati utente *specifico per il progetto*.
.. 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>`
Restituisce il nome della distribuzione per le piattaforme Linux e BSD (ad esempio "Ubuntu", "Manjaro", "OpenBSD", ecc.).
Restituisce lo stesso valore di :ref:`get_name()<class_OS_method_get_name>` per le ROM Android di serie, ma tenta di restituire il nome ROM personalizzato per i derivati Android più diffusi come "LineageOS".
Restituisce lo stesso valore di :ref:`get_name()<class_OS_method_get_name>` per altre piattaforme.
\ **Nota:** Questo metodo non è supportato sulla piattaforma Web. Restituisce una stringa vuota.
.. 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>`
Genera un :ref:`PackedByteArray<class_PackedByteArray>` di byte casuali crittograficamente sicuri di dimensione ``size``.
\ **Nota:** La generazione di grandi quantità di byte utilizzando questo metodo può causare il blocco e l'entropia di qualità inferiore sulla maggior parte delle piattaforme. L'utilizzo di :ref:`Crypto.generate_random_bytes()<class_Crypto_method_generate_random_bytes>` è preferibile nella maggior parte dei casi.
.. 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>`
Restituisce il valore della variabile d'ambiente specificata o una stringa vuota se ``variable`` non esiste.
\ **Nota:** Controlla attentamente le maiuscole e le minuscole di ``variable``. I nomi delle variabili d'ambiente sono sensibili alle maiuscole e alle minuscole su tutte le piattaforme, eccetto Windows.
\ **Nota:** Su macOS, le applicazioni non hanno accesso alle variabili d'ambiente della shell.
.. 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>`
Restituisce il percorso del file eseguibile attuale del motore.
\ **Nota:** Su macOS, se vuoi avviare un'altra istanza di Godot, usa sempre :ref:`create_instance()<class_OS_method_create_instance>` invece di basarti sul percorso dell'eseguibile.
.. 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>`
Sui dispositivi Android: Restituisce la lista delle autorizzazioni pericolose concesse.
Su macOS: Restituisce la lista delle cartelle selezionate dall'utente accessibili all'applicazione (solo applicazioni in sandbox). Usa la finestra di dialogo nativa dei file per richiedere l'autorizzazione di accesso alle cartelle.
Su iOS, visionOS: restituisce la lista di autorizzazioni concesse.
.. 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>`
Restituisce il codice tasto specificato sotto forma di :ref:`String<class_String>`.
.. tabs::
.. code-tab:: gdscript
print(OS.get_keycode_string(KEY_C)) # Stampa "C"
print(OS.get_keycode_string(KEY_ESCAPE)) # Stampa "Escape"
print(OS.get_keycode_string(KEY_MASK_SHIFT | KEY_TAB)) # Stampa "Shift+Tab"
.. code-tab:: csharp
GD.Print(OS.GetKeycodeString(Key.C)); // Stampa "C"
GD.Print(OS.GetKeycodeString(Key.Escape)); // Stampa "Escape"
GD.Print(OS.GetKeycodeString((Key)KeyModifierMask.MaskShift | Key.Tab)); // Stampa "Shift+Tab"
Vedi anche :ref:`find_keycode_from_string()<class_OS_method_find_keycode_from_string>`, :ref:`InputEventKey.keycode<class_InputEventKey_property_keycode>` e :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>`
Restituisce le impostazioni locali del sistema operativo host sotto forma di :ref:`String<class_String>` nel formato ``language_Script_COUNTRY_VARIANT@extra``. Ogni sottostringa dopo ``language`` è facoltativa e potrebbe non esistere.
- ``language`` - `codice lingua <https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>`__ di 2 o 3 lettere, in minuscolo.
- ``Script`` - `codice alfabeto <https://en.wikipedia.org/wiki/ISO_15924>`__ di 4 lettere, in maiuscolo.
- ``COUNTRY`` - `codice paese <https://en.wikipedia.org/wiki/ISO_3166-1>`__ di 2 o 3 lettere, in maiuscolo.
- ``VARIANT`` - variante di lingua, regione e ordinamento. La variante può avere un numero qualsiasi di parole chiave con trattini bassi in mezzo.
- ``extra`` - elenco separato da punto e virgola di parole chiave aggiuntive. Questo può includere informazioni su valuta, calendario, ordinamento e sistema di numerazione.
Se vuoi solo il codice della lingua e non le impostazioni locali completamente specificate dal sistema operativo, puoi usare :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>`
Restituisce il `codice lingua <https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>`__ a 2 o 3 lettere delle impostazioni locali del sistema operativo host come stringa che dovrebbe essere coerente su tutte le piattaforme. Ciò equivale a estrarre la parte ``language`` della stringa da :ref:`get_locale()<class_OS_method_get_locale>`.
Questo è utile per limitare le stringhe delle impostazioni locali a solo il codice della lingua "comune", quando non sono necessarie informazioni aggiuntive sul codice paese o sulle varianti. Ad esempio, per un utente franco-canadese con locale ``fr_CA``, questo restituirebbe ``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>`
Restituisce l'ID del thread principale. Vedi :ref:`get_thread_caller_id()<class_OS_method_get_thread_caller_id>`.
\ **Nota:** gli ID dei thread non sono deterministici e potrebbero essere riutilizzati al riavvio dell'applicazione.
.. 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>`
Restituisce un :ref:`Dictionary<class_Dictionary>` contenente informazioni sulla memoria attuale con le seguenti voci:
- ``"physical"`` - quantità totale di memoria fisica utilizzabile in byte. Questo valore può essere leggermente inferiore alla quantità effettiva di memoria fisica, poiché non include la memoria riservata dal kernel e dai dispositivi.
- ``"free"`` - quantità di memoria fisica, che può essere immediatamente allocata senza accesso al disco o altre operazioni costose, in byte. Il processo potrebbe essere in grado di allocare più memoria fisica, ma questa azione richiederà lo spostamento delle pagine inattive su disco, il che può essere costoso.
- ``"available"`` - quantità di memoria che può essere allocata senza estendere i file di swap, in byte. Questo valore include sia la memoria fisica sia lo swap.
- ``"stack"`` - dimensione dello stack del thread attuale in byte.
\ **Nota:** Il valore di ogni voce può essere ``-1`` se è sconosciuto.
.. 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>`
Restituisce il nome del modello del dispositivo attuale.
\ **Nota:** Questo metodo è implementato su Android, iOS, macOS e Windows. Restituisce ``"GenericDevice"`` su piattaforme non supportate.
.. 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>`
Restituisce il nome della piattaforma host.
- Su Windows, è ``"Windows"``.
- Su macOS, è ``"macOS"``.
- Su sistemi operativi basati su Linux, è ``"Linux"``.
- Su sistemi operativi basati su BSD, è ``"FreeBSD"``, ``"NetBSD"``, ``"OpenBSD"`` o ``"BSD"`` come fallback.
- Su Android, è ``"Android"``.
- Su iOS, è ``"iOS"``.
- Su Web, è ``"Web"``.
\ **Nota:** Le build personalizzate del motore potrebbero supportare piattaforme aggiuntive, come le console, restituendo eventualmente altri nomi.
.. 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;
}
\ **Nota:** Sulle piattaforme Web, è comunque possibile determinare il sistema operativo della piattaforma host con i tag delle funzionalità. Vedi :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>`
Restituisce il codice di uscita di un processo generato, una volta che ha terminato l'esecuzione (vedi :ref:`is_process_running()<class_OS_method_is_process_running>`).
Restituisce ``-1`` se il ``pid`` non è un PID di un processo figlio generato, il processo è ancora in esecuzione, o il metodo non è implementato per la piattaforma attuale.
\ **Nota:** Restituisce ``-1`` se il ``pid`` è un processo di un app in bundle di macOS.
\ **Nota:** Questo metodo è implementato su Android, Linux, macOS e 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>`
Restituisce il numero usato dalla machina ospite per identificare unicamente questa applicazione.
\ **Nota:** Su Web, questo metodo restituisce sempre ``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>`
Restituisce il numero di core CPU *logici* disponibili sulla macchina host. Sulle CPU con HyperThreading abilitato, questo numero sarà maggiore del numero di core CPU *fisici*.
.. 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>`
Restituisce il nome completo del modello di CPU sulla macchina host (ad esempio ``"Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz"``).
\ **Nota:** Questo metodo è implementato solo su Windows, macOS, Linux e iOS. Su Android e Web, :ref:`get_processor_name()<class_OS_method_get_processor_name>` restituisce una stringa vuota.
.. 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>`
Restituisce la lista degli argomenti della riga di comando che saranno utilizzati quando il progetto si riavvia automaticamente tramite :ref:`set_restart_on_exit()<class_OS_method_set_restart_on_exit>`. Vedi anche :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>`
Restituisce la quantità massima di memoria statica utilizzata. Funziona solo nelle build di debug.
.. 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>`
Restituisce la quantità di memoria statica utilizzata dal programma in byte. Funziona solo nelle build di debug.
.. 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>`
Restituisce il tipo del dispositivo di errore standard.
\ **Nota:** Questo metodo è implementato su Linux, macOS e 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>`
Restituisce il tipo del dispositivo di input standard.
\ **Nota:** Questo metodo è implementato su Linux, macOS e Windows.
\ **Nota:** Nelle build esportate di Windows, bisogna eseguire l'eseguibile wrapper della console per accedere all'input standard. Se è necessario un singolo eseguibile con supporto completo per la console, utilizzare una build personalizzata compilata con il flag ``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>`
Restituisce il tipo del dispositivo di output standard.
\ **Nota:** Questo metodo è implementato su Linux, macOS e 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>`
Restituisce l'elenco delle autorità di certificazione considerate attendibili dal sistema operativo come stringa di certificati concatenati in formato 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>`
Restituisce il percorso alle cartelle comunemente utilizzate su diverse piattaforme, come definito da ``dir``. Vedi le costanti di :ref:`SystemDir<enum_OS_SystemDir>` per i percorsi disponibili.
\ **Nota:** Questo metodo è implementato su Android, Linux, macOS e Windows.
\ **Nota:** L'archiviazione condivisa è implementata su Android e consente di distinguere tra cartelle specifiche all'app e condivise, se ``shared_storage`` è ``true``. Le cartelle condivise hanno restrizioni aggiuntive su 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>`
Restituisce il percorso al file font di sistema con ``font_name`` e stile. Restituisce una stringa vuota se non vengono trovati font corrispondenti.
I seguenti alias possono essere utilizzati per richiedere font predefiniti: "sans-serif", "serif", "monospace", "cursive" e "fantasy".
\ **Nota:** Il font restituito potrebbe avere uno stile diverso se lo stile richiesto non è disponibile.
\ **Nota:** Questo metodo è implementato su Android, iOS, Linux, macOS e 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>`
Restituisce un array dei percorsi dei file dei font sostitutivi di sistema, che sono simili al font con ``font_name`` e stile per il testo, le impostazioni locali e l'alfabeto specificati. Restituisce un array vuoto se non vengono trovati font corrispondenti.
I seguenti alias possono essere utilizzati per richiedere i font predefiniti: "sans-serif", "serif", "monospace", "cursive" e "fantasy".
\ **Nota:** A seconda del sistema operativo, non è garantito che alcuno dei font restituiti sia adatto per il rendering del testo specificato. I font devono essere caricati e controllati nell'ordine in cui sono restituiti e deve essere utilizzato il primo adatto.
\ **Nota:** I font restituiti potrebbero avere uno stile diverso se lo stile richiesto non è disponibile o appartiene a una famiglia di font diversa.
\ **Nota:** Questo metodo è implementato su Android, iOS, Linux, macOS e 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>`
Restituisce la lista di nomi di famiglie di font disponibili.
\ **Nota:** Questo metodo è implementato su Android, iOS, Linux, macOS e 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>`
Restituisce la cartella dei dati temporanei *globali* secondo gli standard del sistema operativo.
.. 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>`
Restituisce l'ID del thread attuale. Può essere utilizzato nei log per facilitare il debug delle applicazioni con più thread.
\ **Nota:** gli ID dei thread non sono deterministici e potrebbero essere riutilizzati al riavvio dell'applicazione.
.. 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>`
Restituisce una stringa univoca per il dispositivo.
\ **Nota:** Questa stringa potrebbe cambiare senza preavviso se l'utente reinstalla il sistema operativo, lo aggiorna o modifica il proprio hardware. Ciò significa che in genere non dovrebbe essere utilizzata per crittografare dati persistenti, poiché i dati salvati prima di una modifica imprevista dell'ID diventerebbero inaccessibili. La stringa restituita potrebbe anche essere falsificata tramite programmi esterni, quindi non fare affidamento sulla stringa restituita da questo metodo per motivi di sicurezza.
\ **Nota:** Sul Web, restituisce una stringa vuota e genera un errore, poiché questo metodo non può essere implementato per motivi di sicurezza.
.. 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>`
Restituisce il percorso assoluto della cartella in cui sono scritti i dati utente (la cartella ``user://`` in Godot). Il percorso dipende dal nome del progetto e da :ref:`ProjectSettings.application/config/use_custom_user_dir<class_ProjectSettings_property_application/config/use_custom_user_dir>`.
- Su Windows, questo è ``%AppData%\Godot\app_userdata\[project_name]``, o ``%AppData%\[custom_name]`` se ``use_custom_user_dir`` è impostato. ``%AppData%`` si espande in ``%UserProfile%\AppData\Roaming``.
- Su macOS, questo è ``~/Library/Application Support/Godot/app_userdata/[project_name]``, o ``~/Library/Application Support/[custom_name]`` se ``use_custom_user_dir`` è impostato.
- Su Linux e BSD, questo è ``~/.local/share/godot/app_userdata/[project_name]``, o ``~/.local/share/[custom_name]`` se ``use_custom_user_dir`` è impostato.
- Su Android e iOS, questa è una cartella in sandbox in una memoria interna o esterna, a seconda della configurazione dell'utente.
- Sul Web, questa è una cartella virtuale gestita dal browser.
Se il nome del progetto è vuoto, ``[project_name]`` ricorre a ``[unnamed project]``.
Da non confondere con :ref:`get_data_dir()<class_OS_method_get_data_dir>`, che restituisce la cartella home dell'utente *globale* (non specifica del progetto).
.. 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>`
Restituisce la versione esatta di produzione e build del sistema operativo. Questa è diversa dalla versione di marca utilizzata nella vendita. Ciò aiuta a distinguere tra diverse versioni di sistemi operativi, comprese le versioni minori e build privilegiate e personalizzate.
- Per Windows, sono restituite la versione principale e minore, così come il numero di build. Ad esempio, la stringa restituita potrebbe essere simile a ``10.0.9926`` per una build di Windows 10.
- Per le distribuzioni rolling, come Arch Linux, è restituita una stringa vuota.
- Per macOS e iOS, sono restituite la versione principale e minore, così come il numero di patch.
- Per Android, sono restituiti la versione SDK e il numero di build incrementale. Se si tratta di una ROM personalizzata, tenta di restituire la sua versione.
\ **Nota:** Questo metodo non è supportato sulla piattaforma Web. Restituisce una stringa vuota.
.. 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>`
Restituisce la versione brandizzata utilizzata nel marketing, seguita dal numero di build (su Windows), dal numero di versione (su macOS), o dalla versione dell'SDK e dal numero incrementale di build (su Android). Esempi includono ``11 (build 22000)``, ``Sequoia (15.0.0)`` e ``15 (SDK 35 build abc528-11988f)``.
Questo valore può quindi essere aggiunto a :ref:`get_name()<class_OS_method_get_name>` per ottenere una combinazione completa e leggibile in chiaro del nome e della versione del sistema operativo. Gli aggiornamenti delle funzionalità di Windows come 24H2 non sono contenuti nella stringa risultante, ma Windows Server è riconosciuto come tale (ad esempio ``2025 (build 26100)`` per Windows Server 2025).
\ **Nota:** Questo metodo è supportato solo su Windows, macOS e Android. Su altri sistemi operativi, restituisce lo stesso valore di :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>`
Restituisce il nome e la versione del driver della scheda video per la scheda grafica attualmente attiva dell'utente, come :ref:`PackedStringArray<class_PackedStringArray>`. Vedi anche :ref:`RenderingServer.get_video_adapter_api_version()<class_RenderingServer_method_get_video_adapter_api_version>`.
Il primo elemento contiene il nome del driver, come ``nvidia``, ``amdgpu``, ecc.
Il secondo elemento contiene la versione del driver. Ad esempio, sul driver ``nvidia`` su una piattaforma Linux/BSD, la versione è nel formato ``510.85.02``. Per Windows, il formato del driver è ``31.0.15.1659``.
\ **Nota:** Questo metodo è supportato solo su Linux/BSD e Windows quando non è in esecuzione in modalità headless. Su altre piattaforme, restituisce un array vuoto.
\ **Nota:** Questo metodo sarà eseguito lentamente la prima volta che viene chiamato in una sessione; potrebbe richiedere diversi secondi a seconda del sistema operativo e dell'hardware. È bloccante se chiamato sul thread principale, quindi si consiglia di chiamarlo su un thread separato tramite :ref:`Thread<class_Thread>`. Ciò consente al motore di continuare a funzionare mentre le informazioni vengono recuperate. Tuttavia, :ref:`get_video_adapter_driver_info()<class_OS_method_get_video_adapter_driver_info>` *non* è thread-safe, quindi non si dovrebbe chiamare da più thread allo stesso tempo.
.. 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("Driver: %s %s" % [driver_info[0], driver_info[1]])
else:
print("Driver: (sconosciuto)")
)
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>`
Restituisce ``true`` se esiste la variabile d'ambiente con il nome ``variable``.
\ **Nota:** Controlla attentamente le maiuscole e le minuscole di ``variable``. I nomi delle variabili d'ambiente sono sensibili alle maiuscole e alle minuscole su tutte le piattaforme, eccetto 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>`
Restituisce ``true`` se la funzionalità per il tag di funzionalità specificato è supportata nell'istanza attualmente in esecuzione, a seconda della piattaforma, della build, ecc. Può essere utilizzato per verificare se si sta attualmente eseguendo una build di debug, su una determinata piattaforma o architettura, ecc. Consulta la documentazione sui :doc:`Tag di funzionalità <../tutorials/export/feature_tags>` per ulteriori dettagli.
\ **Nota:** I nomi dei tag sono sensibili alle maiuscole/minuscole.
\ **Nota:** Sulla piattaforma Web, uno dei seguenti tag aggiuntivi è definito per indicare la piattaforma host: ``web_android``, ``web_ios``, ``web_linuxbsd``, ``web_macos`` o ``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>`
Restituisce ``true`` se l'eseguibile Godot utilizzato per eseguire il progetto è un modello di esportazione di *debug* o quando viene eseguito nell'editor.
Restituisce ``false`` se l'eseguibile Godot utilizzato per eseguire il progetto è un modello di esportazione di *release*.
\ **Nota:** Per verificare se l'eseguibile Godot utilizzato per eseguire il progetto è un modello di esportazione (debug o release), utilizza invece ``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>`
Restituisce ``true`` se il codice tasto di input corrisponde a un carattere Unicode. Per un elenco di codici, vedi le costanti di :ref:`Key<enum_@GlobalScope_Key>`.
.. tabs::
.. code-tab:: gdscript
print(OS.is_keycode_unicode(KEY_G)) # Stampa true
print(OS.is_keycode_unicode(KEY_KP_4)) # Stampa true
print(OS.is_keycode_unicode(KEY_TAB)) # Stampa false
print(OS.is_keycode_unicode(KEY_ESCAPE)) # Stampa false
.. code-tab:: csharp
GD.Print(OS.IsKeycodeUnicode((long)Key.G)); // Prints True
GD.Print(OS.IsKeycodeUnicode((long)Key.Kp4)); // Prints True
GD.Print(OS.IsKeycodeUnicode((long)Key.Tab)); // Prints False
GD.Print(OS.IsKeycodeUnicode((long)Key.Escape)); // Prints 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>`
Restituisce ``true`` se ID del processo figlio (``pid``) è ancora in esecuzione o ``false`` è ha terminato. ``pid`` deve essere un ID valido generato da :ref:`create_process()<class_OS_method_create_process>`.
\ **Nota:** Questo metodo è implementato su Android, iOS, Linux, macOS e 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>`
Restituisce ``true`` se il progetto sarà riavviato automaticamente quando esce per qualsiasi motivo, altrimenti ``false``. Vedi anche :ref:`set_restart_on_exit()<class_OS_method_set_restart_on_exit>` e :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>`
Restituisce ``true`` se l'applicazione è in esecuzione nella sandbox.
\ **Nota:** Questo metodo è implementato solo su macOS e 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>`
Restituisce ``true`` se il motore è stato eseguito con l'argomento della riga di comando ``--verbose`` o ``-v``, oppure se :ref:`ProjectSettings.debug/settings/stdout/verbose_stdout<class_ProjectSettings_property_debug/settings/stdout/verbose_stdout>` è ``true``. Vedi anche :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>`
Restituisce ``true`` se il file system ``user://`` è persistente, ovvero il suo stato è lo stesso dopo che un giocatore esce e riavvia il gioco. Rilevante per la piattaforma Web, dove questa persistenza potrebbe non essere disponibile.
.. 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>`
Termina il processo identificato dall'ID di processo specificato (``pid``), come l'ID restituito da :ref:`execute()<class_OS_method_execute>` in modalità non bloccante. Vedi anche :ref:`crash()<class_OS_method_crash>`.
\ **Nota:** Questo metodo può essere utilizzato anche per terminare processi che non sono stati generati dal motore.
\ **Nota:** Questo metodo è implementato su Android, iOS, Linux, macOS e 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>`
Sposta il file o la cartella nel percorso ``path`` specificato nel cestino del sistema. Vedi anche :ref:`DirAccess.remove()<class_DirAccess_method_remove>`.
Il metodo accetta solo percorsi globali, quindi potrebbe essere necessario usare :ref:`ProjectSettings.globalize_path()<class_ProjectSettings_method_globalize_path>`. Non usarlo per i file in ``res://`` poiché non funzionerà nei progetti esportati.
Restituisce :ref:`@GlobalScope.FAILED<class_@GlobalScope_constant_FAILED>` se il file o la cartella non possono essere trovati o il sistema non supporta questo metodo.
.. 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));
\ **Nota:** Questo metodo è implementato su Android, Linux, macOS e Windows.
\ **Nota:** Se l'utente ha disabilitato il cestino sul proprio sistema, il file sarà invece eliminato definitivamente.
.. 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>`
Inizializza il singleton per il driver MIDI del sistema, consentendo a Godot di ricevere :ref:`InputEventMIDI<class_InputEventMIDI>`. vedi anche :ref:`get_connected_midi_inputs()<class_OS_method_get_connected_midi_inputs>` e :ref:`close_midi_inputs()<class_OS_method_close_midi_inputs>`.
\ **Nota:** Questo metodo è implementato su Linux, macOS, Windows e Web.
\ **Nota:** Sulla piattaforma Web, il browser deve supportare Web MIDI. `Per il momento <https://caniuse.com/midi>`__, è supportato da tutti i principali browser, tranne Safari.
\ **Nota:** Sulla piattaforma Web, l'utilizzo dell'input MIDI richiede prima l'autorizzazione del browser. Questa richiesta di autorizzazione viene eseguita quando viene chiamato :ref:`open_midi_inputs()<class_OS_method_open_midi_inputs>`. L'input MIDI non funzionerà finché l'utente non accetta la richiesta di autorizzazione.
.. 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>`
Apre uno o più file/cartelle con l'applicazione specificata. Il parametro ``program_path`` specifica il percorso dell'applicazione da utilizzare per aprire i file, mentre ``paths`` contiene un array di percorsi di file/cartelle da aprire.
\ **Nota:** Questo metodo è rilevante principalmente solo per macOS, dove l'apertura dei file tramite :ref:`create_process()<class_OS_method_create_process>` potrebbe non riuscire. Su altre piattaforme, si ricorre all'utilizzo di :ref:`create_process()<class_OS_method_create_process>`.
\ **Nota:** Su macOS, ``program_path`` dovrebbe idealmente essere il percorso di un pacchetto ``.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>`
Reads a user input as raw data from the standard input. This operation can be *blocking*, which causes the window to freeze if :ref:`read_buffer_from_stdin()<class_OS_method_read_buffer_from_stdin>` is called on the main thread.
- If standard input is console, this method will block until the program receives a line break in standard input (usually by the user pressing :kbd:`Enter`).
- If standard input is pipe, this method will block until a specific amount of data is read or pipe is closed.
- If standard input is a file, this method will read a specific amount of data (or less if end-of-file is reached) and return immediately.
\ **Note:** This method is implemented on Linux, macOS, and Windows.
\ **Note:** On exported Windows builds, run the console wrapper executable to access the terminal. If standard input is console, calling this method without console wrapped will freeze permanently. If standard input is pipe or file, it can be used without console wrapper. If you need a single executable with full console support, use a custom build compiled with the ``windows_subsystem=console`` flag.
.. 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>`
Legge l'input dell'utente dall'input standard come stringa codificata in UTF-8. Questa operazione può è *bloccante*, il che causa il blocco della finestra se :ref:`read_string_from_stdin()<class_OS_method_read_string_from_stdin>` viene chiamato sul thread principale.
- Se l'input standard è una console, questo metodo si bloccherà finché il programma non riceverà un'interruzione di riga nell'input standard (solitamente quando l'utente preme :kbd:`Invio`).
- Se l'input standard è una pipe, questo metodo si bloccherà finché non verrà letta una quantità specifica di dati o la pipe verrà chiusa.
- Se l'input standard è un file, questo metodo leggerà una quantità specifica di dati (o meno se viene raggiunta la fine del file) e restituirà immediatamente.
\ **Nota:** Questo metodo sostituisce automaticamente le interruzioni di riga ``\r\n`` con ``\n`` e le rimuove dalla fine della stringa. Usa :ref:`read_buffer_from_stdin()<class_OS_method_read_buffer_from_stdin>` per leggere i dati non elaborati.
\ **Nota:** Questo metodo è implementato su Linux, macOS e Windows.
\ **Nota:** Nelle build Windows esportate, esegui l'eseguibile wrapper della console per accedere al terminale. Altrimenti, l'input standard non funzionerà correttamente. Se hai bisogno di un singolo eseguibile con supporto per la console, usa una build personalizzata compilata con il flag ``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>`
Rimuove un logger personalizzato aggiunto da :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>`
Richiede l'autorizzazione dal sistema operativo per il nome ``name``. Restituisce ``true`` se l'autorizzazione è già stata concessa. Vedi anche :ref:`MainLoop.on_request_permissions_result<class_MainLoop_signal_on_request_permissions_result>`.
\ ``name`` deve essere il nome completo di un'autorizzazione. Ad esempio:
- ``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")``\
\ **Nota:** Su Android, l'autorizzazione deve essere spuntata durante l'esportazione.
\ **Nota:** Questo metodo è implementato su Android, macOS e piattaforme 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>`
Richiede autorizzazioni *pericolose* dal sistema operativo. Restituisce ``true`` se le autorizzazioni sono state già concesse. Vedi anche :ref:`MainLoop.on_request_permissions_result<class_MainLoop_signal_on_request_permissions_result>`.
\ **Nota:** Le autorizzazioni devono essere selezionate durante l'esportazione.
\ **Nota:** Questo metodo è implementato solo su Android. Le autorizzazioni normali sono concesse automaticamente al momento dell'installazione nelle applicazioni 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>`
Su macOS (solo applicazioni in sandbox), questa funzione svuota la lista delle cartelle selezionate dall'utente accessibili all'applicazione.
.. 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>`
Imposta il valore della variabile di ambiente ``variable`` su ``value``. La variabile di ambiente sarà impostata per il processo Godot e per qualsiasi processo eseguito con :ref:`execute()<class_OS_method_execute>` dopo l'esecuzione di :ref:`set_environment()<class_OS_method_set_environment>`. La variabile di ambiente *non* persisterà nei processi eseguiti dopo la terminazione del processo Godot.
\ **Nota:** I nomi delle variabili di ambiente sono sensibili alle maiuscole/minuscole su tutte le piattaforme, eccetto Windows. Il nome di ``variable`` non può essere vuoto o includere il carattere ``=``. Su Windows, c'è un limite di 32767 caratteri per la lunghezza combinata di ``variable``, ``value`` e i caratteri di terminazione ``=`` e null che saranno registrati nel blocco di ambiente.
.. 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>`
Se ``restart`` è ``true``, riavvia automaticamente il progetto quando si esce con :ref:`SceneTree.quit()<class_SceneTree_method_quit>` o :ref:`Node.NOTIFICATION_WM_CLOSE_REQUEST<class_Node_constant_NOTIFICATION_WM_CLOSE_REQUEST>`. È possibile fornire argomenti (``arguments``) di riga di comando. Per riavviare il progetto con gli stessi argomenti della riga di comando utilizzati in origine per eseguire il progetto, passa :ref:`get_cmdline_args()<class_OS_method_get_cmdline_args>` come valore per ``arguments``.
Questo metodo può essere utilizzato per applicare modifiche alle impostazioni che richiedono un riavvio. Vedi anche :ref:`is_restart_on_exit_set()<class_OS_method_is_restart_on_exit_set>` e :ref:`get_restart_on_exit_arguments()<class_OS_method_get_restart_on_exit_arguments>`.
\ **Nota:** Questo metodo è efficace solo sulle piattaforme desktop e solo quando il progetto non è avviato dall'editor. Non avrà alcun effetto sulle piattaforme mobili e Web o quando il progetto è avviato dall'editor.
\ **Nota:** Se il processo del progetto si blocca o viene *terminato* dall'utente (inviando ``SIGKILL`` invece del solito ``SIGTERM``), il progetto non verrà riavviato automaticamente.
.. 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>`
Assegna il nome specificato al thread attuale. Restituisce :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` se non disponibile sulla piattaforma attuale.
.. 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>`
Se ``enabled`` è ``true``, quando si apre un file per la scrittura, al suo posto è utilizzato un file temporaneo. Quando è chiuso, è automaticamente applicato al file di destinazione.
Questo può essere utile quando i file possono essere aperti da altre applicazioni, come antivirus, editor di testo o persino dall'editor di Godot stesso.
.. 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>`
Richiede al sistema operativo di aprire una risorsa identificata da ``uri`` con il programma più appropriato. Ad esempio:
- ``OS.shell_open("C:\\Users\\name\\Downloads")`` su Windows apre l'esploratore file nella cartella Download dell'utente.
- ``OS.shell_open("C:/Users/name/Downloads")`` funziona inoltre su Windows e apre l'esploratore file nella cartella Download dell'utente.
- ``OS.shell_open("https://godotengine.org")`` apre il browser Web predefinito sul sito Web ufficiale di Godot.
- ``OS.shell_open("mailto:example@example.com")`` apre il client di posta elettronica predefinito con il campo "Destinatario" impostato su ``example@example.com``. Consulta `RFC 2368 - Lo schema URL [code]mailto[/code] <https://datatracker.ietf.org/doc/html/rfc2368>`__ per un elenco di campi che è possibile aggiungere.
Usa :ref:`ProjectSettings.globalize_path()<class_ProjectSettings_method_globalize_path>` per convertire un percorso di progetto ``res://`` o ``user://`` in un percorso di sistema da usare con questo metodo.
\ **Nota:** Usa :ref:`String.uri_encode()<class_String_method_uri_encode>` per codificare i caratteri all'interno degli URL in un modo URL-safe e portabile. Ciò è particolarmente necessario per le interruzioni di riga. Altrimenti, :ref:`shell_open()<class_OS_method_shell_open>` potrebbe non funzionare correttamente in un progetto esportato sulla piattaforma Web.
\ **Nota:** Questo metodo è implementato su Android, iOS, Web, Linux, macOS e 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>`
Richiede al sistema operativo di aprire il gestore dei file, di andare al ``file_or_dir_path`` specificato e di selezionare il file o la cartella di destinazione.
Se ``open_folder`` è ``true`` e ``file_or_dir_path`` è un percorso di cartella valido, il sistema operativo aprirà il gestore dei file e andrà alla cartella di destinazione senza selezionare nulla.
Utilizza :ref:`ProjectSettings.globalize_path()<class_ProjectSettings_method_globalize_path>` per convertire un percorso di progetto ``res://`` o ``user://`` in un percorso di sistema da utilizzare con questo metodo.
\ **Nota:** Questo metodo è attualmente implementato solo su Windows e macOS. Su altre piattaforme, ricadrà a :ref:`shell_open()<class_OS_method_shell_open>` con un percorso di cartella di ``file_or_dir_path`` prefissato con ``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>`
Rimuove la variabile di ambiente specificata dall'ambiente corrente, se esiste. Il nome ``variable`` non può essere vuoto o includere il carattere ``=``. La variabile di ambiente sarà rimossa per il processo Godot e per qualsiasi processo eseguito con :ref:`execute()<class_OS_method_execute>` dopo l'esecuzione di :ref:`unset_environment()<class_OS_method_unset_environment>`. La rimozione della variabile di ambiente *non* persisterà nei processi eseguiti dopo la terminazione del processo Godot.
\ **Nota:** i nomi delle variabili di ambiente sono sensibili alle maiuscole/minuscole su tutte le piattaforme, eccetto Windows.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink