:github_url: hide

.. _class_@GlobalScope:

@GlobalScope
============

Константы и функции глобальной области видимости.

.. rst-class:: classref-introduction-group

Описание
----------------

Список глобальных областей видимости, перечисленных констант и встроенных функций. Это все, что находится в глобальных, константах, касающихся кодов ошибок, кодов клавиш, подсказок свойств и т. д.

Здесь также документируются синглтоны, поскольку к ним можно получить доступ из любой точки мира.

Информацию о записях, доступ к которым возможен только из скриптов, написанных на GDScript, см. в :ref:`@GDScript<class_@GDScript>`.

.. note::

	Существуют заметные различия при использовании данного API с C#. Подробнее см. :ref:`doc_c_sharp_differences`.

.. rst-class:: classref-introduction-group

Обучающие материалы
--------------------------------------

- :doc:`Генерация случайных чисел <../tutorials/math/random_number_generation>`

.. rst-class:: classref-reftable-group

Свойства
----------------

.. table::
   :widths: auto

   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`AudioServer<class_AudioServer>`                             | :ref:`AudioServer<class_@GlobalScope_property_AudioServer>`                             |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`CameraServer<class_CameraServer>`                           | :ref:`CameraServer<class_@GlobalScope_property_CameraServer>`                           |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`ClassDB<class_ClassDB>`                                     | :ref:`ClassDB<class_@GlobalScope_property_ClassDB>`                                     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`DisplayServer<class_DisplayServer>`                         | :ref:`DisplayServer<class_@GlobalScope_property_DisplayServer>`                         |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`EditorInterface<class_EditorInterface>`                     | :ref:`EditorInterface<class_@GlobalScope_property_EditorInterface>`                     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`Engine<class_Engine>`                                       | :ref:`Engine<class_@GlobalScope_property_Engine>`                                       |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`EngineDebugger<class_EngineDebugger>`                       | :ref:`EngineDebugger<class_@GlobalScope_property_EngineDebugger>`                       |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`GDExtensionManager<class_GDExtensionManager>`               | :ref:`GDExtensionManager<class_@GlobalScope_property_GDExtensionManager>`               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`Geometry2D<class_Geometry2D>`                               | :ref:`Geometry2D<class_@GlobalScope_property_Geometry2D>`                               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`Geometry3D<class_Geometry3D>`                               | :ref:`Geometry3D<class_@GlobalScope_property_Geometry3D>`                               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`IP<class_IP>`                                               | :ref:`IP<class_@GlobalScope_property_IP>`                                               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`Input<class_Input>`                                         | :ref:`Input<class_@GlobalScope_property_Input>`                                         |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`InputMap<class_InputMap>`                                   | :ref:`InputMap<class_@GlobalScope_property_InputMap>`                                   |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`JavaClassWrapper<class_JavaClassWrapper>`                   | :ref:`JavaClassWrapper<class_@GlobalScope_property_JavaClassWrapper>`                   |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`JavaScriptBridge<class_JavaScriptBridge>`                   | :ref:`JavaScriptBridge<class_@GlobalScope_property_JavaScriptBridge>`                   |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`Marshalls<class_Marshalls>`                                 | :ref:`Marshalls<class_@GlobalScope_property_Marshalls>`                                 |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`NativeMenu<class_NativeMenu>`                               | :ref:`NativeMenu<class_@GlobalScope_property_NativeMenu>`                               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`NavigationMeshGenerator<class_NavigationMeshGenerator>`     | :ref:`NavigationMeshGenerator<class_@GlobalScope_property_NavigationMeshGenerator>`     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`NavigationServer2D<class_NavigationServer2D>`               | :ref:`NavigationServer2D<class_@GlobalScope_property_NavigationServer2D>`               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`NavigationServer2DManager<class_NavigationServer2DManager>` | :ref:`NavigationServer2DManager<class_@GlobalScope_property_NavigationServer2DManager>` |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`NavigationServer3D<class_NavigationServer3D>`               | :ref:`NavigationServer3D<class_@GlobalScope_property_NavigationServer3D>`               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`NavigationServer3DManager<class_NavigationServer3DManager>` | :ref:`NavigationServer3DManager<class_@GlobalScope_property_NavigationServer3DManager>` |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`OS<class_OS>`                                               | :ref:`OS<class_@GlobalScope_property_OS>`                                               |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`Performance<class_Performance>`                             | :ref:`Performance<class_@GlobalScope_property_Performance>`                             |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`PhysicsServer2D<class_PhysicsServer2D>`                     | :ref:`PhysicsServer2D<class_@GlobalScope_property_PhysicsServer2D>`                     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`PhysicsServer2DManager<class_PhysicsServer2DManager>`       | :ref:`PhysicsServer2DManager<class_@GlobalScope_property_PhysicsServer2DManager>`       |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`PhysicsServer3D<class_PhysicsServer3D>`                     | :ref:`PhysicsServer3D<class_@GlobalScope_property_PhysicsServer3D>`                     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`PhysicsServer3DManager<class_PhysicsServer3DManager>`       | :ref:`PhysicsServer3DManager<class_@GlobalScope_property_PhysicsServer3DManager>`       |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`ProjectSettings<class_ProjectSettings>`                     | :ref:`ProjectSettings<class_@GlobalScope_property_ProjectSettings>`                     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`RenderingServer<class_RenderingServer>`                     | :ref:`RenderingServer<class_@GlobalScope_property_RenderingServer>`                     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`ResourceLoader<class_ResourceLoader>`                       | :ref:`ResourceLoader<class_@GlobalScope_property_ResourceLoader>`                       |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`ResourceSaver<class_ResourceSaver>`                         | :ref:`ResourceSaver<class_@GlobalScope_property_ResourceSaver>`                         |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`ResourceUID<class_ResourceUID>`                             | :ref:`ResourceUID<class_@GlobalScope_property_ResourceUID>`                             |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`TextServerManager<class_TextServerManager>`                 | :ref:`TextServerManager<class_@GlobalScope_property_TextServerManager>`                 |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`ThemeDB<class_ThemeDB>`                                     | :ref:`ThemeDB<class_@GlobalScope_property_ThemeDB>`                                     |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`Time<class_Time>`                                           | :ref:`Time<class_@GlobalScope_property_Time>`                                           |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`TranslationServer<class_TranslationServer>`                 | :ref:`TranslationServer<class_@GlobalScope_property_TranslationServer>`                 |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`WorkerThreadPool<class_WorkerThreadPool>`                   | :ref:`WorkerThreadPool<class_@GlobalScope_property_WorkerThreadPool>`                   |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
   | :ref:`XRServer<class_XRServer>`                                   | :ref:`XRServer<class_@GlobalScope_property_XRServer>`                                   |
   +-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+

.. rst-class:: classref-reftable-group

Методы
------------

.. table::
   :widths: auto

   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`abs<class_@GlobalScope_method_abs>`\ (\ x\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`absf<class_@GlobalScope_method_absf>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`absi<class_@GlobalScope_method_absi>`\ (\ x\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                                              |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`acos<class_@GlobalScope_method_acos>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`acosh<class_@GlobalScope_method_acosh>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`angle_difference<class_@GlobalScope_method_angle_difference>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                               |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`asin<class_@GlobalScope_method_asin>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`asinh<class_@GlobalScope_method_asinh>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`atan<class_@GlobalScope_method_atan>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`atan2<class_@GlobalScope_method_atan2>`\ (\ y\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                         |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`atanh<class_@GlobalScope_method_atanh>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`bezier_derivative<class_@GlobalScope_method_bezier_derivative>`\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ )                                                                                                                              |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`bezier_interpolate<class_@GlobalScope_method_bezier_interpolate>`\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ )                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`bytes_to_var<class_@GlobalScope_method_bytes_to_var>`\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ )                                                                                                                                                                                                                                                                  |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`bytes_to_var_with_objects<class_@GlobalScope_method_bytes_to_var_with_objects>`\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ )                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`ceil<class_@GlobalScope_method_ceil>`\ (\ x\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`ceilf<class_@GlobalScope_method_ceilf>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`ceili<class_@GlobalScope_method_ceili>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`clamp<class_@GlobalScope_method_clamp>`\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`clampf<class_@GlobalScope_method_clampf>`\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`clampi<class_@GlobalScope_method_clampi>`\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`cos<class_@GlobalScope_method_cos>`\ (\ angle_rad\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                    |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`cosh<class_@GlobalScope_method_cosh>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`cubic_interpolate<class_@GlobalScope_method_cubic_interpolate>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ )                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`cubic_interpolate_angle<class_@GlobalScope_method_cubic_interpolate_angle>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ )                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`cubic_interpolate_angle_in_time<class_@GlobalScope_method_cubic_interpolate_angle_in_time>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ ) |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`cubic_interpolate_in_time<class_@GlobalScope_method_cubic_interpolate_in_time>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ )             |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`db_to_linear<class_@GlobalScope_method_db_to_linear>`\ (\ db\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                         |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`deg_to_rad<class_@GlobalScope_method_deg_to_rad>`\ (\ deg\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`ease<class_@GlobalScope_method_ease>`\ (\ x\: :ref:`float<class_float>`, curve\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                     | :ref:`error_string<class_@GlobalScope_method_error_string>`\ (\ error\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`exp<class_@GlobalScope_method_exp>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`floor<class_@GlobalScope_method_floor>`\ (\ x\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                                    |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`floorf<class_@GlobalScope_method_floorf>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`floori<class_@GlobalScope_method_floori>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`fmod<class_@GlobalScope_method_fmod>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                           |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`fposmod<class_@GlobalScope_method_fposmod>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                     |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`hash<class_@GlobalScope_method_hash>`\ (\ variable\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                               |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Object<class_Object>`                     | :ref:`instance_from_id<class_@GlobalScope_method_instance_from_id>`\ (\ instance_id\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`inverse_lerp<class_@GlobalScope_method_inverse_lerp>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                   |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_equal_approx<class_@GlobalScope_method_is_equal_approx>`\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                     |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_finite<class_@GlobalScope_method_is_finite>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_inf<class_@GlobalScope_method_is_inf>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_instance_id_valid<class_@GlobalScope_method_is_instance_id_valid>`\ (\ id\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                             |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_instance_valid<class_@GlobalScope_method_is_instance_valid>`\ (\ instance\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                     |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_nan<class_@GlobalScope_method_is_nan>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_same<class_@GlobalScope_method_is_same>`\ (\ a\: :ref:`Variant<class_Variant>`, b\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                             |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                         | :ref:`is_zero_approx<class_@GlobalScope_method_is_zero_approx>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`lerp<class_@GlobalScope_method_lerp>`\ (\ from\: :ref:`Variant<class_Variant>`, to\: :ref:`Variant<class_Variant>`, weight\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`lerp_angle<class_@GlobalScope_method_lerp_angle>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`lerpf<class_@GlobalScope_method_lerpf>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                 |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`linear_to_db<class_@GlobalScope_method_linear_to_db>`\ (\ lin\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`log<class_@GlobalScope_method_log>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`max<class_@GlobalScope_method_max>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                             |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`maxf<class_@GlobalScope_method_maxf>`\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                           |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`maxi<class_@GlobalScope_method_maxi>`\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                   |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`min<class_@GlobalScope_method_min>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                             |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`minf<class_@GlobalScope_method_minf>`\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                           |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`mini<class_@GlobalScope_method_mini>`\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                   |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`move_toward<class_@GlobalScope_method_move_toward>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`nearest_po2<class_@GlobalScope_method_nearest_po2>`\ (\ value\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`pingpong<class_@GlobalScope_method_pingpong>`\ (\ value\: :ref:`float<class_float>`, length\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`posmod<class_@GlobalScope_method_posmod>`\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                               |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`pow<class_@GlobalScope_method_pow>`\ (\ base\: :ref:`float<class_float>`, exp\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`print<class_@GlobalScope_method_print>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                         |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`print_rich<class_@GlobalScope_method_print_rich>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                               |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`print_verbose<class_@GlobalScope_method_print_verbose>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                         |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`printerr<class_@GlobalScope_method_printerr>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                   |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`printraw<class_@GlobalScope_method_printraw>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                   |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`prints<class_@GlobalScope_method_prints>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`printt<class_@GlobalScope_method_printt>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`push_error<class_@GlobalScope_method_push_error>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                               |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`push_warning<class_@GlobalScope_method_push_warning>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                           |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`rad_to_deg<class_@GlobalScope_method_rad_to_deg>`\ (\ rad\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`rand_from_seed<class_@GlobalScope_method_rand_from_seed>`\ (\ seed\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`randf<class_@GlobalScope_method_randf>`\ (\ )                                                                                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`randf_range<class_@GlobalScope_method_randf_range>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                         |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`randfn<class_@GlobalScope_method_randfn>`\ (\ mean\: :ref:`float<class_float>`, deviation\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`randi<class_@GlobalScope_method_randi>`\ (\ )                                                                                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`randi_range<class_@GlobalScope_method_randi_range>`\ (\ from\: :ref:`int<class_int>`, to\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                 |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`randomize<class_@GlobalScope_method_randomize>`\ (\ )                                                                                                                                                                                                                                                                                                                               |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`remap<class_@GlobalScope_method_remap>`\ (\ value\: :ref:`float<class_float>`, istart\: :ref:`float<class_float>`, istop\: :ref:`float<class_float>`, ostart\: :ref:`float<class_float>`, ostop\: :ref:`float<class_float>`\ )                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`rid_allocate_id<class_@GlobalScope_method_rid_allocate_id>`\ (\ )                                                                                                                                                                                                                                                                                                                   |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`RID<class_RID>`                           | :ref:`rid_from_int64<class_@GlobalScope_method_rid_from_int64>`\ (\ base\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`rotate_toward<class_@GlobalScope_method_rotate_toward>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                  |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`round<class_@GlobalScope_method_round>`\ (\ x\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                                    |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`roundf<class_@GlobalScope_method_roundf>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`roundi<class_@GlobalScope_method_roundi>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                                          | :ref:`seed<class_@GlobalScope_method_seed>`\ (\ base\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                                           |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`sign<class_@GlobalScope_method_sign>`\ (\ x\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                                      |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`signf<class_@GlobalScope_method_signf>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`signi<class_@GlobalScope_method_signi>`\ (\ x\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`sin<class_@GlobalScope_method_sin>`\ (\ angle_rad\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                    |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`sinh<class_@GlobalScope_method_sinh>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`smoothstep<class_@GlobalScope_method_smoothstep>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                            |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`snapped<class_@GlobalScope_method_snapped>`\ (\ x\: :ref:`Variant<class_Variant>`, step\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`snappedf<class_@GlobalScope_method_snappedf>`\ (\ x\: :ref:`float<class_float>`, step\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`snappedi<class_@GlobalScope_method_snappedi>`\ (\ x\: :ref:`float<class_float>`, step\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                    |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`sqrt<class_@GlobalScope_method_sqrt>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`step_decimals<class_@GlobalScope_method_step_decimals>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                     | :ref:`str<class_@GlobalScope_method_str>`\ (\ ...\ ) |vararg|                                                                                                                                                                                                                                                                                                                             |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`str_to_var<class_@GlobalScope_method_str_to_var>`\ (\ string\: :ref:`String<class_String>`\ )                                                                                                                                                                                                                                                                                       |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`tan<class_@GlobalScope_method_tan>`\ (\ angle_rad\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                    |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`tanh<class_@GlobalScope_method_tanh>`\ (\ x\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                                                                                          |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`type_convert<class_@GlobalScope_method_type_convert>`\ (\ variant\: :ref:`Variant<class_Variant>`, type\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                  |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                     | :ref:`type_string<class_@GlobalScope_method_type_string>`\ (\ type\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                                                                             |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`typeof<class_@GlobalScope_method_typeof>`\ (\ variable\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                           |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`   | :ref:`var_to_bytes<class_@GlobalScope_method_var_to_bytes>`\ (\ variable\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                               |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`   | :ref:`var_to_bytes_with_objects<class_@GlobalScope_method_var_to_bytes_with_objects>`\ (\ variable\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                     |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                     | :ref:`var_to_str<class_@GlobalScope_method_var_to_str>`\ (\ variable\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                   |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`weakref<class_@GlobalScope_method_weakref>`\ (\ obj\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                                                                                              |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`                   | :ref:`wrap<class_@GlobalScope_method_wrap>`\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ )                                                                                                                                                                                                                        |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                       | :ref:`wrapf<class_@GlobalScope_method_wrapf>`\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ )                                                                                                                                                                                                                                  |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                           | :ref:`wrapi<class_@GlobalScope_method_wrapi>`\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ )                                                                                                                                                                                                                                              |
   +-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Перечисления
------------------------

.. _enum_@GlobalScope_Side:

.. rst-class:: classref-enumeration

enum **Side**: :ref:`🔗<enum_@GlobalScope_Side>`

.. _class_@GlobalScope_constant_SIDE_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Side<enum_@GlobalScope_Side>` **SIDE_LEFT** = ``0``

Левая сторона, обычно используется для классов, производных от :ref:`Control<class_Control>` или :ref:`StyleBox<class_StyleBox>`.

.. _class_@GlobalScope_constant_SIDE_TOP:

.. rst-class:: classref-enumeration-constant

:ref:`Side<enum_@GlobalScope_Side>` **SIDE_TOP** = ``1``

Верхняя сторона, обычно используется для классов, производных от :ref:`Control<class_Control>` или :ref:`StyleBox<class_StyleBox>`.

.. _class_@GlobalScope_constant_SIDE_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Side<enum_@GlobalScope_Side>` **SIDE_RIGHT** = ``2``

Правая сторона, обычно используется для классов, производных от :ref:`Control<class_Control>` или :ref:`StyleBox<class_StyleBox>`.

.. _class_@GlobalScope_constant_SIDE_BOTTOM:

.. rst-class:: classref-enumeration-constant

:ref:`Side<enum_@GlobalScope_Side>` **SIDE_BOTTOM** = ``3``

Нижняя сторона, обычно используется для классов, производных от :ref:`Control<class_Control>` или :ref:`StyleBox<class_StyleBox>`.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_Corner:

.. rst-class:: classref-enumeration

enum **Corner**: :ref:`🔗<enum_@GlobalScope_Corner>`

.. _class_@GlobalScope_constant_CORNER_TOP_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_TOP_LEFT** = ``0``

Верхний левый угол.

.. _class_@GlobalScope_constant_CORNER_TOP_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_TOP_RIGHT** = ``1``

Верхний правый угол.

.. _class_@GlobalScope_constant_CORNER_BOTTOM_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_BOTTOM_RIGHT** = ``2``

Нижний правый угол.

.. _class_@GlobalScope_constant_CORNER_BOTTOM_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_BOTTOM_LEFT** = ``3``

Нижний левый угол.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_Orientation:

.. rst-class:: classref-enumeration

enum **Orientation**: :ref:`🔗<enum_@GlobalScope_Orientation>`

.. _class_@GlobalScope_constant_VERTICAL:

.. rst-class:: classref-enumeration-constant

:ref:`Orientation<enum_@GlobalScope_Orientation>` **VERTICAL** = ``1``

Общее вертикальное выравнивание, обычно используется для :ref:`Separator<class_Separator>`, :ref:`ScrollBar<class_ScrollBar>`, :ref:`Slider<class_Slider>` и т.д.

.. _class_@GlobalScope_constant_HORIZONTAL:

.. rst-class:: classref-enumeration-constant

:ref:`Orientation<enum_@GlobalScope_Orientation>` **HORIZONTAL** = ``0``

Общее горизонтальное выравнивание, обычно используется для :ref:`Separator<class_Separator>`, :ref:`ScrollBar<class_ScrollBar>`, :ref:`Slider<class_Slider>` и т.д.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_ClockDirection:

.. rst-class:: classref-enumeration

enum **ClockDirection**: :ref:`🔗<enum_@GlobalScope_ClockDirection>`

.. _class_@GlobalScope_constant_CLOCKWISE:

.. rst-class:: classref-enumeration-constant

:ref:`ClockDirection<enum_@GlobalScope_ClockDirection>` **CLOCKWISE** = ``0``

Вращение по часовой стрелке. Используется некоторыми методами (например :ref:`Image.rotate_90()<class_Image_method_rotate_90>`).

.. _class_@GlobalScope_constant_COUNTERCLOCKWISE:

.. rst-class:: classref-enumeration-constant

:ref:`ClockDirection<enum_@GlobalScope_ClockDirection>` **COUNTERCLOCKWISE** = ``1``

Вращение против часовой стрелки. Используется некоторыми методами (например, :ref:`Image.rotate_90()<class_Image_method_rotate_90>`).

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_HorizontalAlignment:

.. rst-class:: classref-enumeration

enum **HorizontalAlignment**: :ref:`🔗<enum_@GlobalScope_HorizontalAlignment>`

.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_LEFT** = ``0``

Горизонтальное выравнивание по левому краю, обычно для классов, содержащих текст.

.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_CENTER:

.. rst-class:: classref-enumeration-constant

:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_CENTER** = ``1``

Горизонтальное выравнивание по центру, обычно для классов, содержащих текст.

.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_RIGHT** = ``2``

Горизонтальное выравнивание по правому краю, обычно для классов, содержащих текст.

.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_FILL:

.. rst-class:: classref-enumeration-constant

:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_FILL** = ``3``

Расширить строку по ширине, обычно для текстовых классов.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_VerticalAlignment:

.. rst-class:: classref-enumeration

enum **VerticalAlignment**: :ref:`🔗<enum_@GlobalScope_VerticalAlignment>`

.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_TOP:

.. rst-class:: classref-enumeration-constant

:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_TOP** = ``0``

Вертикальное выравнивание сверху, обычно для классов, содержащих текст.

.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_CENTER:

.. rst-class:: classref-enumeration-constant

:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_CENTER** = ``1``

Вертикальное выравнивание по центру, обычно для классов, содержащих текст.

.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_BOTTOM:

.. rst-class:: classref-enumeration-constant

:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_BOTTOM** = ``2``

Вертикальное выравнивание снизу, обычно для классов, содержащих текст.

.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_FILL:

.. rst-class:: classref-enumeration-constant

:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_FILL** = ``3``

Расширить строки по высоте, обычно для текстовых классов.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_InlineAlignment:

.. rst-class:: classref-enumeration

enum **InlineAlignment**: :ref:`🔗<enum_@GlobalScope_InlineAlignment>`

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TOP_TO:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TOP_TO** = ``0``

Выравнивает верх встроенного объекта (например, изображения, таблицы) к позиции текста, определённой константой ``INLINE_ALIGNMENT_TO_*``.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_CENTER_TO:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_CENTER_TO** = ``1``

Выравнивает центр встроенного объекта (например, изображения, таблицы) к позиции текста, определённой константой ``INLINE_ALIGNMENT_TO_*``.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_BASELINE_TO:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_BASELINE_TO** = ``3``

Выравнивает базовую линию (определенную пользователем) встроенного объекта (например, изображение, таблица), относительно положения текста, указанного константой ``INLINE_ALIGNMENT_TO_*`` .

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_BOTTOM_TO:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_BOTTOM_TO** = ``2``

Выравнивает низ встроенного объекта (например, изображения, таблицы) к позиции текста, определённой константой ``INLINE_ALIGNMENT_TO_*``.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_TOP:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_TOP** = ``0``

Выравнивает позицию встроенного объекта (например, изображения, таблицы), определённой константой ``INLINE_ALIGNMENT_*_TO`` к верху текста.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_CENTER:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_CENTER** = ``4``

Выравнивает позицию встроенного объекта (например, изображения, таблицы), определённой константой ``INLINE_ALIGNMENT_*_TO`` к центру текста.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_BASELINE:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_BASELINE** = ``8``

Выравнивает положение встроенного объекта (например, изображение, таблица) указанного константой ``INLINE_ALIGNMENT_*_TO``, относительно базовой линии текста.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_BOTTOM:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_BOTTOM** = ``12``

Выравнивает встроенный объект (например, изображение, таблица) по нижней части текста.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TOP:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TOP** = ``0``

Выравнивает верхнюю часть встроенного объекта (например, изображение, таблица) относительно верхней части текста. Аналогично ``INLINE_ALIGNMENT_TOP_TO | INLINE_ALIGNMENT_TO_TOP``.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_CENTER:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_CENTER** = ``5``

Выравнивает центр встроенного объекта (например, изображение, таблица) по центру текста. Аналогично ``INLINE_ALIGNMENT_CENTER_TO | INLINE_ALIGNMENT_TO_CENTER``.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_BOTTOM:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_BOTTOM** = ``14``

Выравнивает нижнюю часть встроенного объекта (например, изображение, таблица) по нижней части текста. Аналогично ``INLINE_ALIGNMENT_BOTTOM_TO | INLINE_ALIGNMENT_TO_BOTTOM``.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_IMAGE_MASK:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_IMAGE_MASK** = ``3``

Битовая маска для констант выравнивания ``INLINE_ALIGNMENT_*_TO``.

.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TEXT_MASK:

.. rst-class:: classref-enumeration-constant

:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TEXT_MASK** = ``12``

Битовая маска для констант выравнивания ``INLINE_ALIGNMENT_*_TO``.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_EulerOrder:

.. rst-class:: classref-enumeration

enum **EulerOrder**: :ref:`🔗<enum_@GlobalScope_EulerOrder>`

.. _class_@GlobalScope_constant_EULER_ORDER_XYZ:

.. rst-class:: classref-enumeration-constant

:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_XYZ** = ``0``

Указывает что углы Эйлера должны быть в порядке XYZ. При составлении порядок X, Y, Z. А при разложении порядок меняется на противоположный, сначала Z, потом Y, а в конце X.

.. _class_@GlobalScope_constant_EULER_ORDER_XZY:

.. rst-class:: classref-enumeration-constant

:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_XZY** = ``1``

Указывает что углы Эйлера должны быть в порядке XZY. При составлении порядок X, Z, Y. А при разложении порядок меняется на противоположный, сначала Y, потом Z, а в конце X.

.. _class_@GlobalScope_constant_EULER_ORDER_YXZ:

.. rst-class:: classref-enumeration-constant

:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_YXZ** = ``2``

Указывает что углы Эйлера должны быть в порядке YXZ. При составлении порядок Y,X,Z. А при разложении порядок меняется на противоположный, сначала Z, потом X, а в конце Y.

.. _class_@GlobalScope_constant_EULER_ORDER_YZX:

.. rst-class:: classref-enumeration-constant

:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_YZX** = ``3``

Указывает что углы Эйлера должны быть в порядке YZX. При составлении порядок Y, Z, X. А при разложении порядок меняется на противоположный, сначала X, потом Z, а в конце X.

.. _class_@GlobalScope_constant_EULER_ORDER_ZXY:

.. rst-class:: classref-enumeration-constant

:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_ZXY** = ``4``

Указывает что углы Эйлера должны быть в порядке ZXY. При составлении порядок Z, X, Y. А при разложении порядок меняется на противоположный, сначала Y, потом X, а в конце Z.

.. _class_@GlobalScope_constant_EULER_ORDER_ZYX:

.. rst-class:: classref-enumeration-constant

:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_ZYX** = ``5``

Указывает что углы Эйлера должны быть в порядке ZYX. При составлении порядок Z, Y, X. А при разложении порядок меняется на противоположный, сначала X, потом Y, а в конце Z.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_Key:

.. rst-class:: classref-enumeration

enum **Key**: :ref:`🔗<enum_@GlobalScope_Key>`

.. _class_@GlobalScope_constant_KEY_NONE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_NONE** = ``0``

Значение перечисления, которые не соответствует ни одному ключу. Это используется для инициализации свойств :ref:`Key<enum_@GlobalScope_Key>` с общим состоянием.

.. _class_@GlobalScope_constant_KEY_SPECIAL:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SPECIAL** = ``4194304``

Коды клавиш с этим битом не подлежат печати.

.. _class_@GlobalScope_constant_KEY_ESCAPE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_ESCAPE** = ``4194305``

Клавиша Escape.

.. _class_@GlobalScope_constant_KEY_TAB:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_TAB** = ``4194306``

Клавиша Tab.

.. _class_@GlobalScope_constant_KEY_BACKTAB:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACKTAB** = ``4194307``

Клавиша Shift + Tab.

.. _class_@GlobalScope_constant_KEY_BACKSPACE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACKSPACE** = ``4194308``

Клавиша Backspace.

.. _class_@GlobalScope_constant_KEY_ENTER:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_ENTER** = ``4194309``

Клавиша возврата (на основной клавиатуре).

.. _class_@GlobalScope_constant_KEY_KP_ENTER:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_ENTER** = ``4194310``

Клавиша ввода на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_INSERT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_INSERT** = ``4194311``

Клавиша Insert.

.. _class_@GlobalScope_constant_KEY_DELETE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_DELETE** = ``4194312``

Клавиша Delete.

.. _class_@GlobalScope_constant_KEY_PAUSE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PAUSE** = ``4194313``

Клавиша Pause.

.. _class_@GlobalScope_constant_KEY_PRINT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PRINT** = ``4194314``

Клавиша Print Screen.

.. _class_@GlobalScope_constant_KEY_SYSREQ:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SYSREQ** = ``4194315``

Клавиша System Request.

.. _class_@GlobalScope_constant_KEY_CLEAR:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_CLEAR** = ``4194316``

Клавиша очистки.

.. _class_@GlobalScope_constant_KEY_HOME:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_HOME** = ``4194317``

Клавиша Home.

.. _class_@GlobalScope_constant_KEY_END:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_END** = ``4194318``

Клавиша End.

.. _class_@GlobalScope_constant_KEY_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LEFT** = ``4194319``

Клавиша со стрелкой влево.

.. _class_@GlobalScope_constant_KEY_UP:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_UP** = ``4194320``

Клавиша со стрелкой вверх.

.. _class_@GlobalScope_constant_KEY_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_RIGHT** = ``4194321``

Клавиша со стрелкой вправо.

.. _class_@GlobalScope_constant_KEY_DOWN:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_DOWN** = ``4194322``

Клавиша со стрелкой вниз.

.. _class_@GlobalScope_constant_KEY_PAGEUP:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PAGEUP** = ``4194323``

Клавиша Page Up.

.. _class_@GlobalScope_constant_KEY_PAGEDOWN:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PAGEDOWN** = ``4194324``

Клавиша Page Down.

.. _class_@GlobalScope_constant_KEY_SHIFT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SHIFT** = ``4194325``

Клавиша Shift.

.. _class_@GlobalScope_constant_KEY_CTRL:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_CTRL** = ``4194326``

Клавиша Control.

.. _class_@GlobalScope_constant_KEY_META:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_META** = ``4194327``

Клавиша Meta.

.. _class_@GlobalScope_constant_KEY_ALT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_ALT** = ``4194328``

Клавиша Alt.

.. _class_@GlobalScope_constant_KEY_CAPSLOCK:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_CAPSLOCK** = ``4194329``

Клавиша Caps Lock.

.. _class_@GlobalScope_constant_KEY_NUMLOCK:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_NUMLOCK** = ``4194330``

Клавиша Num Lock.

.. _class_@GlobalScope_constant_KEY_SCROLLLOCK:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SCROLLLOCK** = ``4194331``

Клавиша Scroll Lock.

.. _class_@GlobalScope_constant_KEY_F1:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F1** = ``4194332``

Клавиша F1.

.. _class_@GlobalScope_constant_KEY_F2:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F2** = ``4194333``

Клавиша F2.

.. _class_@GlobalScope_constant_KEY_F3:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F3** = ``4194334``

Клавиша F3.

.. _class_@GlobalScope_constant_KEY_F4:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F4** = ``4194335``

Клавиша F4.

.. _class_@GlobalScope_constant_KEY_F5:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F5** = ``4194336``

Клавиша F5.

.. _class_@GlobalScope_constant_KEY_F6:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F6** = ``4194337``

Клавиша F6.

.. _class_@GlobalScope_constant_KEY_F7:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F7** = ``4194338``

Клавиша F7.

.. _class_@GlobalScope_constant_KEY_F8:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F8** = ``4194339``

Клавиша F8.

.. _class_@GlobalScope_constant_KEY_F9:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F9** = ``4194340``

Клавиша F9.

.. _class_@GlobalScope_constant_KEY_F10:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F10** = ``4194341``

Клавиша F10.

.. _class_@GlobalScope_constant_KEY_F11:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F11** = ``4194342``

Клавиша F11.

.. _class_@GlobalScope_constant_KEY_F12:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F12** = ``4194343``

Клавиша F12.

.. _class_@GlobalScope_constant_KEY_F13:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F13** = ``4194344``

Клавиша F13.

.. _class_@GlobalScope_constant_KEY_F14:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F14** = ``4194345``

Клавиша F14.

.. _class_@GlobalScope_constant_KEY_F15:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F15** = ``4194346``

Клавиша F15.

.. _class_@GlobalScope_constant_KEY_F16:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F16** = ``4194347``

Клавиша F16.

.. _class_@GlobalScope_constant_KEY_F17:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F17** = ``4194348``

Клавиша F17.

.. _class_@GlobalScope_constant_KEY_F18:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F18** = ``4194349``

Клавиша F18.

.. _class_@GlobalScope_constant_KEY_F19:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F19** = ``4194350``

Клавиша F19.

.. _class_@GlobalScope_constant_KEY_F20:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F20** = ``4194351``

Клавиша F20.

.. _class_@GlobalScope_constant_KEY_F21:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F21** = ``4194352``

Клавиша F21.

.. _class_@GlobalScope_constant_KEY_F22:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F22** = ``4194353``

Клавиша F22.

.. _class_@GlobalScope_constant_KEY_F23:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F23** = ``4194354``

Клавиша F23.

.. _class_@GlobalScope_constant_KEY_F24:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F24** = ``4194355``

Клавиша F24.

.. _class_@GlobalScope_constant_KEY_F25:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F25** = ``4194356``

Клавиша F25. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F26:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F26** = ``4194357``

Клавиша F26. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F27:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F27** = ``4194358``

Клавиша F27. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F28:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F28** = ``4194359``

Клавиша F28. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F29:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F29** = ``4194360``

Клавиша F29. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F30:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F30** = ``4194361``

Клавиша F30. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F31:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F31** = ``4194362``

Клавиша F31. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F32:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F32** = ``4194363``

Клавиша F32. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F33:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F33** = ``4194364``

Клавиша F33. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F34:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F34** = ``4194365``

Клавиша F34. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_F35:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F35** = ``4194366``

Клавиша F35. Поддерживается только в macOS и Linux, из-за ограничений Windows.

.. _class_@GlobalScope_constant_KEY_KP_MULTIPLY:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_MULTIPLY** = ``4194433``

Клавиша умножения (\*) на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_DIVIDE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_DIVIDE** = ``4194434``

Клавиша деления (/) на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_SUBTRACT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_SUBTRACT** = ``4194435``

Клавиша вычитания (-) на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_PERIOD:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_PERIOD** = ``4194436``

Клавиша точки (.) на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_ADD:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_ADD** = ``4194437``

Клавиша сложения (+) на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_0:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_0** = ``4194438``

Цифра 0 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_1:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_1** = ``4194439``

Цифра 1 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_2:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_2** = ``4194440``

Цифра 2 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_3:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_3** = ``4194441``

Цифра 3 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_4:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_4** = ``4194442``

Цифра 4 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_5:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_5** = ``4194443``

Цифра 5 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_6:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_6** = ``4194444``

Цифра 6 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_7:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_7** = ``4194445``

Цифра 7 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_8:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_8** = ``4194446``

Цифра 8 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_KP_9:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_9** = ``4194447``

Цифра 9 на цифровой клавиатуре.

.. _class_@GlobalScope_constant_KEY_MENU:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_MENU** = ``4194370``

Клавиша контекстного меню.

.. _class_@GlobalScope_constant_KEY_HYPER:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_HYPER** = ``4194371``

Гипер ключ. (Только в Linux/X11).

.. _class_@GlobalScope_constant_KEY_HELP:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_HELP** = ``4194373``

Клавиша помощи.

.. _class_@GlobalScope_constant_KEY_BACK:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACK** = ``4194376``

Клавиша «Назад».

.. _class_@GlobalScope_constant_KEY_FORWARD:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_FORWARD** = ``4194377``

Клавиша «Вперед».

.. _class_@GlobalScope_constant_KEY_STOP:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_STOP** = ``4194378``

Клавиша остановки мультимедиа.

.. _class_@GlobalScope_constant_KEY_REFRESH:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_REFRESH** = ``4194379``

Клавиша «Обновить».

.. _class_@GlobalScope_constant_KEY_VOLUMEDOWN:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_VOLUMEDOWN** = ``4194380``

Клавиша уменьшения громкости.

.. _class_@GlobalScope_constant_KEY_VOLUMEMUTE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_VOLUMEMUTE** = ``4194381``

Клавиша отключения звука.

.. _class_@GlobalScope_constant_KEY_VOLUMEUP:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_VOLUMEUP** = ``4194382``

Клавиша увеличения громкости.

.. _class_@GlobalScope_constant_KEY_MEDIAPLAY:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIAPLAY** = ``4194388``

Клавиша воспроизведения мультимедиа.

.. _class_@GlobalScope_constant_KEY_MEDIASTOP:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIASTOP** = ``4194389``

Клавиша остановки мультимедиа.

.. _class_@GlobalScope_constant_KEY_MEDIAPREVIOUS:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIAPREVIOUS** = ``4194390``

Клавиша «Предыдущая песня».

.. _class_@GlobalScope_constant_KEY_MEDIANEXT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIANEXT** = ``4194391``

Клавиша «Следующая песня».

.. _class_@GlobalScope_constant_KEY_MEDIARECORD:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIARECORD** = ``4194392``

Клавиша «Медиа-запись».

.. _class_@GlobalScope_constant_KEY_HOMEPAGE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_HOMEPAGE** = ``4194393``

Клавиша «Домашняя страница».

.. _class_@GlobalScope_constant_KEY_FAVORITES:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_FAVORITES** = ``4194394``

Клавиша "Избранное".

.. _class_@GlobalScope_constant_KEY_SEARCH:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SEARCH** = ``4194395``

Клавиша поиска.

.. _class_@GlobalScope_constant_KEY_STANDBY:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_STANDBY** = ``4194396``

Клавиша выключения.

.. _class_@GlobalScope_constant_KEY_OPENURL:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_OPENURL** = ``4194397``

Клавиша «Открыть URL / Запустить браузер».

.. _class_@GlobalScope_constant_KEY_LAUNCHMAIL:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHMAIL** = ``4194398``

Клавиша «Запустить почту».

.. _class_@GlobalScope_constant_KEY_LAUNCHMEDIA:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHMEDIA** = ``4194399``

Клавиша «Запуск Медиа».

.. _class_@GlobalScope_constant_KEY_LAUNCH0:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH0** = ``4194400``

Клавиша запуска 0.

.. _class_@GlobalScope_constant_KEY_LAUNCH1:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH1** = ``4194401``

Клавиша запуска 1.

.. _class_@GlobalScope_constant_KEY_LAUNCH2:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH2** = ``4194402``

Клавиша запуска 2.

.. _class_@GlobalScope_constant_KEY_LAUNCH3:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH3** = ``4194403``

Клавиша запуска 3.

.. _class_@GlobalScope_constant_KEY_LAUNCH4:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH4** = ``4194404``

Клавиша запуска 4.

.. _class_@GlobalScope_constant_KEY_LAUNCH5:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH5** = ``4194405``

Клавиша запуска 5.

.. _class_@GlobalScope_constant_KEY_LAUNCH6:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH6** = ``4194406``

Клавиша запуска 6.

.. _class_@GlobalScope_constant_KEY_LAUNCH7:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH7** = ``4194407``

Клавиша запуска 7.

.. _class_@GlobalScope_constant_KEY_LAUNCH8:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH8** = ``4194408``

Клавиша запуска 8.

.. _class_@GlobalScope_constant_KEY_LAUNCH9:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH9** = ``4194409``

Клавиша запуска 9.

.. _class_@GlobalScope_constant_KEY_LAUNCHA:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHA** = ``4194410``

Клавиша запуска A.

.. _class_@GlobalScope_constant_KEY_LAUNCHB:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHB** = ``4194411``

Клавиша запуска B.

.. _class_@GlobalScope_constant_KEY_LAUNCHC:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHC** = ``4194412``

Клавиша запуска C.

.. _class_@GlobalScope_constant_KEY_LAUNCHD:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHD** = ``4194413``

Клавиша запуска D.

.. _class_@GlobalScope_constant_KEY_LAUNCHE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHE** = ``4194414``

Клавиша запуска E.

.. _class_@GlobalScope_constant_KEY_LAUNCHF:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHF** = ``4194415``

Клавиша запуска F.

.. _class_@GlobalScope_constant_KEY_GLOBE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_GLOBE** = ``4194416``

Клавиша «Глобус» на клавиатуре Mac/iPad.

.. _class_@GlobalScope_constant_KEY_KEYBOARD:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_KEYBOARD** = ``4194417``

Клавиша «Экранная клавиатура» на клавиатуре iPad.

.. _class_@GlobalScope_constant_KEY_JIS_EISU:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_JIS_EISU** = ``4194418``

Клавиша 英数 (Буквенно-цифровая) на клавиатуре Mac.

.. _class_@GlobalScope_constant_KEY_JIS_KANA:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_JIS_KANA** = ``4194419``

Клавиша かな (Кана) на клавиатуре Mac.

.. _class_@GlobalScope_constant_KEY_UNKNOWN:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_UNKNOWN** = ``8388607``

Неизвестная клавиша.

.. _class_@GlobalScope_constant_KEY_SPACE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SPACE** = ``32``

Клавиша пробела.

.. _class_@GlobalScope_constant_KEY_EXCLAM:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_EXCLAM** = ``33``

Клавиша восклицательного знака (``!``).

.. _class_@GlobalScope_constant_KEY_QUOTEDBL:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_QUOTEDBL** = ``34``

Двойная кавычка (``"``).

.. _class_@GlobalScope_constant_KEY_NUMBERSIGN:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_NUMBERSIGN** = ``35``

Знак числа или клавиша *решетки* (``#``).

.. _class_@GlobalScope_constant_KEY_DOLLAR:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_DOLLAR** = ``36``

Клавиша со знаком доллара (``$``).

.. _class_@GlobalScope_constant_KEY_PERCENT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PERCENT** = ``37``

Клавиша знака процента (``%``).

.. _class_@GlobalScope_constant_KEY_AMPERSAND:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_AMPERSAND** = ``38``

Клавиша амперсанда (``&``).

.. _class_@GlobalScope_constant_KEY_APOSTROPHE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_APOSTROPHE** = ``39``

Клавиша апострофа (``'``).

.. _class_@GlobalScope_constant_KEY_PARENLEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PARENLEFT** = ``40``

Клавиша левой скобки (``(``).

.. _class_@GlobalScope_constant_KEY_PARENRIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PARENRIGHT** = ``41``

Клавиша правой скобки (``(``).

.. _class_@GlobalScope_constant_KEY_ASTERISK:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_ASTERISK** = ``42``

Клавиша звездочки (знак сноски, умножения) (``*``).

.. _class_@GlobalScope_constant_KEY_PLUS:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PLUS** = ``43``

Клавиша плюс (``+``).

.. _class_@GlobalScope_constant_KEY_COMMA:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_COMMA** = ``44``

Клавиша запятая (``,``).

.. _class_@GlobalScope_constant_KEY_MINUS:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_MINUS** = ``45``

Клавиша минус (``-``).

.. _class_@GlobalScope_constant_KEY_PERIOD:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_PERIOD** = ``46``

Клавиша точки (``.``).

.. _class_@GlobalScope_constant_KEY_SLASH:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SLASH** = ``47``

Клавиша слэш (деления) (``/``).

.. _class_@GlobalScope_constant_KEY_0:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_0** = ``48``

Клавиша 0.

.. _class_@GlobalScope_constant_KEY_1:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_1** = ``49``

Клавиша 1.

.. _class_@GlobalScope_constant_KEY_2:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_2** = ``50``

Клавиша 2.

.. _class_@GlobalScope_constant_KEY_3:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_3** = ``51``

Клавиша 3.

.. _class_@GlobalScope_constant_KEY_4:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_4** = ``52``

Клавиша 4.

.. _class_@GlobalScope_constant_KEY_5:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_5** = ``53``

Клавиша 5.

.. _class_@GlobalScope_constant_KEY_6:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_6** = ``54``

Клавиша 6.

.. _class_@GlobalScope_constant_KEY_7:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_7** = ``55``

Клавиша 7.

.. _class_@GlobalScope_constant_KEY_8:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_8** = ``56``

Клавиша 8.

.. _class_@GlobalScope_constant_KEY_9:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_9** = ``57``

Клавиша 9.

.. _class_@GlobalScope_constant_KEY_COLON:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_COLON** = ``58``

Клавиша двоеточия (``:``).

.. _class_@GlobalScope_constant_KEY_SEMICOLON:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SEMICOLON** = ``59``

Клавиша точки с запятой (``;``).

.. _class_@GlobalScope_constant_KEY_LESS:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_LESS** = ``60``

Клавиша знака «меньше» (``<``).

.. _class_@GlobalScope_constant_KEY_EQUAL:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_EQUAL** = ``61``

Клавиша знака равенства (``=``).

.. _class_@GlobalScope_constant_KEY_GREATER:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_GREATER** = ``62``

Клавиша знака «больше» (``>``).

.. _class_@GlobalScope_constant_KEY_QUESTION:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_QUESTION** = ``63``

Клавиша со знаком вопроса (``?``).

.. _class_@GlobalScope_constant_KEY_AT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_AT** = ``64``

Клавиша at (``@``).

.. _class_@GlobalScope_constant_KEY_A:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_A** = ``65``

Клавиша A.

.. _class_@GlobalScope_constant_KEY_B:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_B** = ``66``

Клавиша B.

.. _class_@GlobalScope_constant_KEY_C:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_C** = ``67``

Клавиша C.

.. _class_@GlobalScope_constant_KEY_D:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_D** = ``68``

Клавиша D.

.. _class_@GlobalScope_constant_KEY_E:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_E** = ``69``

Клавиша E.

.. _class_@GlobalScope_constant_KEY_F:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_F** = ``70``

Клавиша F.

.. _class_@GlobalScope_constant_KEY_G:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_G** = ``71``

Клавиша G.

.. _class_@GlobalScope_constant_KEY_H:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_H** = ``72``

Клавиша H.

.. _class_@GlobalScope_constant_KEY_I:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_I** = ``73``

Клавиша I.

.. _class_@GlobalScope_constant_KEY_J:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_J** = ``74``

Клавиша J.

.. _class_@GlobalScope_constant_KEY_K:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_K** = ``75``

Клавиша K.

.. _class_@GlobalScope_constant_KEY_L:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_L** = ``76``

Клавиша L.

.. _class_@GlobalScope_constant_KEY_M:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_M** = ``77``

Клавиша M.

.. _class_@GlobalScope_constant_KEY_N:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_N** = ``78``

Клавиша N.

.. _class_@GlobalScope_constant_KEY_O:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_O** = ``79``

Клавиша O.

.. _class_@GlobalScope_constant_KEY_P:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_P** = ``80``

Клавиша P.

.. _class_@GlobalScope_constant_KEY_Q:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_Q** = ``81``

Клавиша Q.

.. _class_@GlobalScope_constant_KEY_R:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_R** = ``82``

Клавиша R.

.. _class_@GlobalScope_constant_KEY_S:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_S** = ``83``

Клавиша S.

.. _class_@GlobalScope_constant_KEY_T:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_T** = ``84``

Клавиша T.

.. _class_@GlobalScope_constant_KEY_U:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_U** = ``85``

Клавиша U.

.. _class_@GlobalScope_constant_KEY_V:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_V** = ``86``

Клавиша V.

.. _class_@GlobalScope_constant_KEY_W:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_W** = ``87``

Клавиша W.

.. _class_@GlobalScope_constant_KEY_X:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_X** = ``88``

Клавиша X.

.. _class_@GlobalScope_constant_KEY_Y:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_Y** = ``89``

Клавиша Y.

.. _class_@GlobalScope_constant_KEY_Z:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_Z** = ``90``

Клавиша Z.

.. _class_@GlobalScope_constant_KEY_BRACKETLEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACKETLEFT** = ``91``

Клавиша левой скобки (``[lb]``).

.. _class_@GlobalScope_constant_KEY_BACKSLASH:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACKSLASH** = ``92``

Клавиша обратной косой черты (Backslash key) (``\``).

.. _class_@GlobalScope_constant_KEY_BRACKETRIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACKETRIGHT** = ``93``

Клавиша правой скобки (``[rb]``).

.. _class_@GlobalScope_constant_KEY_ASCIICIRCUM:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_ASCIICIRCUM** = ``94``

Клавиша курсора (``^``).

.. _class_@GlobalScope_constant_KEY_UNDERSCORE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_UNDERSCORE** = ``95``

Клавиша подчеркивания (``_``).

.. _class_@GlobalScope_constant_KEY_QUOTELEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_QUOTELEFT** = ``96``

Клавиша обратного апострофа (`````).

.. _class_@GlobalScope_constant_KEY_BRACELEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACELEFT** = ``123``

Клавиша левой фигурной скобки (``{``).

.. _class_@GlobalScope_constant_KEY_BAR:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BAR** = ``124``

Вертикальная черта или *pipe* (``|``).

.. _class_@GlobalScope_constant_KEY_BRACERIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACERIGHT** = ``125``

Клавиша правой фигурной скобки (``}``).

.. _class_@GlobalScope_constant_KEY_ASCIITILDE:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_ASCIITILDE** = ``126``

Клавиша тильда (``~``).

.. _class_@GlobalScope_constant_KEY_YEN:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_YEN** = ``165``

Клавиша символа йены (``¥``).

.. _class_@GlobalScope_constant_KEY_SECTION:

.. rst-class:: classref-enumeration-constant

:ref:`Key<enum_@GlobalScope_Key>` **KEY_SECTION** = ``167``

Клавиша знака раздела (``§``).

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_KeyModifierMask:

.. rst-class:: classref-enumeration

flags **KeyModifierMask**: :ref:`🔗<enum_@GlobalScope_KeyModifierMask>`

.. _class_@GlobalScope_constant_KEY_CODE_MASK:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_CODE_MASK** = ``8388607``

Клавиша Маска Кода.

.. _class_@GlobalScope_constant_KEY_MODIFIER_MASK:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MODIFIER_MASK** = ``2130706432``

Маска клавиши-модификатора.

.. _class_@GlobalScope_constant_KEY_MASK_CMD_OR_CTRL:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_CMD_OR_CTRL** = ``16777216``

Автоматически переназначается на :ref:`KEY_META<class_@GlobalScope_constant_KEY_META>` на macOS и на :ref:`KEY_CTRL<class_@GlobalScope_constant_KEY_CTRL>` на других платформах, эта маска никогда не устанавливается в реальных событиях и должна использоваться только для сопоставления ключей.

.. _class_@GlobalScope_constant_KEY_MASK_SHIFT:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_SHIFT** = ``33554432``

Маска клавиши Shift.

.. _class_@GlobalScope_constant_KEY_MASK_ALT:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_ALT** = ``67108864``

Маска клавиш Alr или Option (на macOS).

.. _class_@GlobalScope_constant_KEY_MASK_META:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_META** = ``134217728``

Маска клавиш Command (на macOS) или Meta/Windows.

.. _class_@GlobalScope_constant_KEY_MASK_CTRL:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_CTRL** = ``268435456``

Маска управляющей клавиши.

.. _class_@GlobalScope_constant_KEY_MASK_KPAD:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_KPAD** = ``536870912``

Маска клавиш цифровой клавиатуры.

.. _class_@GlobalScope_constant_KEY_MASK_GROUP_SWITCH:

.. rst-class:: classref-enumeration-constant

:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_GROUP_SWITCH** = ``1073741824``

Маска клавиш группового переключатель.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_KeyLocation:

.. rst-class:: classref-enumeration

enum **KeyLocation**: :ref:`🔗<enum_@GlobalScope_KeyLocation>`

.. _class_@GlobalScope_constant_KEY_LOCATION_UNSPECIFIED:

.. rst-class:: classref-enumeration-constant

:ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **KEY_LOCATION_UNSPECIFIED** = ``0``

Используется для клавиш, которые появляются только один раз, или когда при сравнении не требуется различать `` LEFT`` и ``RIGHT `` версий.

Например, при использовании :ref:`InputEvent.is_match()<class_InputEvent_method_is_match>`, событие которые, имеет :ref:`KEY_LOCATION_UNSPECIFIED<class_@GlobalScope_constant_KEY_LOCATION_UNSPECIFIED>` будет соответствовать любому :ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` в переданном событии.

.. _class_@GlobalScope_constant_KEY_LOCATION_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **KEY_LOCATION_LEFT** = ``1``

Клавиша, которая находится слева от своего двойника.

.. _class_@GlobalScope_constant_KEY_LOCATION_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **KEY_LOCATION_RIGHT** = ``2``

Клавиша, которая находится справа от своего двойника.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_MouseButton:

.. rst-class:: classref-enumeration

enum **MouseButton**: :ref:`🔗<enum_@GlobalScope_MouseButton>`

.. _class_@GlobalScope_constant_MOUSE_BUTTON_NONE:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_NONE** = ``0``

Значение перечисления, которое не соответствует ни одной кнопке мыши. Это используется для инициализации свойств :ref:`MouseButton<enum_@GlobalScope_MouseButton>` с помощью общего состояния.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_LEFT** = ``1``

Основная кнопка мыши, обычно назначаемая левой кнопке.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_RIGHT** = ``2``

Дополнительная кнопка мыши, обычно назначаемая правой.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_MIDDLE:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_MIDDLE** = ``3``

Средняя кнопка мыши.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_UP:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_UP** = ``4``

Прокрутка колеса мыши вверх.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_DOWN:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_DOWN** = ``5``

Прокрутка колесика мыши вниз.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_LEFT** = ``6``

Левая кнопка колесика мыши (имеется только на некоторых мышах).

.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_RIGHT** = ``7``

Правая кнопка колесика мыши (есть только на некоторых мышах).

.. _class_@GlobalScope_constant_MOUSE_BUTTON_XBUTTON1:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_XBUTTON1** = ``8``

Дополнительная кнопка мыши 1. Иногда присутствует, обычно по бокам мыши.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_XBUTTON2:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_XBUTTON2** = ``9``

Дополнительная кнопка мыши 2. Иногда присутствует, обычно по бокам мыши.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_MouseButtonMask:

.. rst-class:: classref-enumeration

flags **MouseButtonMask**: :ref:`🔗<enum_@GlobalScope_MouseButtonMask>`

.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_LEFT** = ``1``

Маска основной кнопки мыши, обычно для левой кнопки.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_RIGHT** = ``2``

Маска дополнительной кнопки мыши, обычно для правой кнопки.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_MIDDLE:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_MIDDLE** = ``4``

Маска средней кнопки мыши.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_MB_XBUTTON1:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_MB_XBUTTON1** = ``128``

Маска дополнительной кнопки мыши 1.

.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_MB_XBUTTON2:

.. rst-class:: classref-enumeration-constant

:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_MB_XBUTTON2** = ``256``

Маска дополнительной кнопки мыши 2.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_JoyButton:

.. rst-class:: classref-enumeration

enum **JoyButton**: :ref:`🔗<enum_@GlobalScope_JoyButton>`

.. _class_@GlobalScope_constant_JOY_BUTTON_INVALID:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_INVALID** = ``-1``

Недопустимая кнопка игрового контроллера.

.. _class_@GlobalScope_constant_JOY_BUTTON_A:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_A** = ``0``

Кнопка А игрового контроллера SDL. Соответствует нижней кнопке действия: Крестик на контроллерах Sony, А на контроллерах Xbox, B на контроллерах Nintendo.

.. _class_@GlobalScope_constant_JOY_BUTTON_B:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_B** = ``1``

Кнопка B игрового контроллера SDL. Соответствует правой кнопке действия: Кружок на контроллерах Sony, B на контроллерах Xbox, A на контроллерах Nintendo.

.. _class_@GlobalScope_constant_JOY_BUTTON_X:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_X** = ``2``

Кнопка X игрового контроллера SDL. Соответствует левой кнопке действия: Квадрат на контроллерах Sony, X на контроллерах Xbox, Y на контроллерах Nintendo.

.. _class_@GlobalScope_constant_JOY_BUTTON_Y:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_Y** = ``3``

Кнопка Y игрового контроллера SDL. Соответствует верхней кнопке действия: Треугольник на контроллерах Sony, Y на контроллерах Xbox, X на контроллерах Nintendo.

.. _class_@GlobalScope_constant_JOY_BUTTON_BACK:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_BACK** = ``4``

Кнопка возврата игрового контроллера SDL. Соответствует кнопкам: Выбор на контроллерах Sony, Возврат на Xbox, "-" на контроллерах Nintendo.

.. _class_@GlobalScope_constant_JOY_BUTTON_GUIDE:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_GUIDE** = ``5``

Кнопка управления игрового контроллера SDL. Соответствует кнопкам Sony PS и Xbox Home.

.. _class_@GlobalScope_constant_JOY_BUTTON_START:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_START** = ``6``

Кнопка запуска игрового контроллера SDL. Соответствует кнопкам: Настройки на контроллерах Sony, Меню на контроллерах Xbox, "+" на контроллерах Nintendo.

.. _class_@GlobalScope_constant_JOY_BUTTON_LEFT_STICK:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_LEFT_STICK** = ``7``

Левый стик игрового контроллера SDL. Соответствует кнопкам: L3 на Sony, L/LS на Xbox.

.. _class_@GlobalScope_constant_JOY_BUTTON_RIGHT_STICK:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_RIGHT_STICK** = ``8``

Правый стик игрового контроллера SDL. Соответствует кнопкам: R3 на Sony, R/RS на Xbox.

.. _class_@GlobalScope_constant_JOY_BUTTON_LEFT_SHOULDER:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_LEFT_SHOULDER** = ``9``

Левая плечевая кнопка игрового контроллера SDL. Соответствует кнопкам: L1 на Sony и LB на Xbox.

.. _class_@GlobalScope_constant_JOY_BUTTON_RIGHT_SHOULDER:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_RIGHT_SHOULDER** = ``10``

Правая плечевая кнопка игрового контроллера SDL. Соответствует кнопкам: R1 на Sony и RB на Xbox.

.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_UP:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_UP** = ``11``

Кнопка вверх на крестовине игрового контроллера.

.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_DOWN:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_DOWN** = ``12``

Кнопка вниз на крестовине игрового контроллера.

.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_LEFT** = ``13``

Кнопка влево на крестовине игрового контроллера.

.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_RIGHT** = ``14``

Кнопка вправо на крестовине игрового контроллера.

.. _class_@GlobalScope_constant_JOY_BUTTON_MISC1:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_MISC1** = ``15``

Кнопка разное на игровом контроллере SDL. Соответствует кнопкам: поделиться на Xbox, микрофон на PS5, захват на Nintendo Switch.

.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE1:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE1** = ``16``

Игровой контроллер SDL paddle кнопка 1.

.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE2:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE2** = ``17``

Игровой контроллер SDL paddle кнопка 2.

.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE3:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE3** = ``18``

Игровой контроллер SDL paddle кнопка 3.

.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE4:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE4** = ``19``

Игровой контроллер SDL paddle кнопка 4.

.. _class_@GlobalScope_constant_JOY_BUTTON_TOUCHPAD:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_TOUCHPAD** = ``20``

Кнопка сенсорной панели игрового контроллера SDL.

.. _class_@GlobalScope_constant_JOY_BUTTON_SDL_MAX:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_SDL_MAX** = ``21``

Количество кнопок игрового контроллера SDL.

.. _class_@GlobalScope_constant_JOY_BUTTON_MAX:

.. rst-class:: classref-enumeration-constant

:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_MAX** = ``128``

Максимальное количество кнопок игрового контроллера, поддерживаемое движком. Фактический предел может быть ниже на определенных платформах:

- **Android:** До 36 кнопок.

- **Linux:** До 80 кнопок.

- **Windows** и **macOS:** До 128 кнопок.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_JoyAxis:

.. rst-class:: classref-enumeration

enum **JoyAxis**: :ref:`🔗<enum_@GlobalScope_JoyAxis>`

.. _class_@GlobalScope_constant_JOY_AXIS_INVALID:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_INVALID** = ``-1``

Недопустимая ось игрового контроллера.

.. _class_@GlobalScope_constant_JOY_AXIS_LEFT_X:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_LEFT_X** = ``0``

Игровой контроллер, левый джойстик, ось X.

.. _class_@GlobalScope_constant_JOY_AXIS_LEFT_Y:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_LEFT_Y** = ``1``

Игровой контроллер, левый джойстик, ось Y.

.. _class_@GlobalScope_constant_JOY_AXIS_RIGHT_X:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_RIGHT_X** = ``2``

Игровой контроллер, правый джойстик, ось X.

.. _class_@GlobalScope_constant_JOY_AXIS_RIGHT_Y:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_RIGHT_Y** = ``3``

Игровой контроллер, правый джойстик, ось Y.

.. _class_@GlobalScope_constant_JOY_AXIS_TRIGGER_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_TRIGGER_LEFT** = ``4``

Левая ось триггера игрового контроллера.

.. _class_@GlobalScope_constant_JOY_AXIS_TRIGGER_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_TRIGGER_RIGHT** = ``5``

Правая ось триггера игрового контроллера.

.. _class_@GlobalScope_constant_JOY_AXIS_SDL_MAX:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_SDL_MAX** = ``6``

Количество осей игрового контроллера SDL.

.. _class_@GlobalScope_constant_JOY_AXIS_MAX:

.. rst-class:: classref-enumeration-constant

:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_MAX** = ``10``

Максимальное количество игрового котроллера: OpenVR поддерживает до 5 Джойстиков, что в итоге дает 10 осей.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_MIDIMessage:

.. rst-class:: classref-enumeration

enum **MIDIMessage**: :ref:`🔗<enum_@GlobalScope_MIDIMessage>`

.. _class_@GlobalScope_constant_MIDI_MESSAGE_NONE:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_NONE** = ``0``

Не соответствует ни одному MIDI-сообщению. Это значение по умолчанию для :ref:`InputEventMIDI.message<class_InputEventMIDI_property_message>`.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_NOTE_OFF:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_NOTE_OFF** = ``8``

MIDI-сообщение отправляется при отпускании ноты.

\ **Примечание:** Не все MIDI-устройства отправляют это сообщение; некоторые могут отправлять :ref:`MIDI_MESSAGE_NOTE_ON<class_@GlobalScope_constant_MIDI_MESSAGE_NOTE_ON>` с :ref:`InputEventMIDI.velocity<class_InputEventMIDI_property_velocity>`, установленным на ``0``.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_NOTE_ON:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_NOTE_ON** = ``9``

MIDI-сообщение, отправляемое при нажатии на ноту.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_AFTERTOUCH:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_AFTERTOUCH** = ``10``

MIDI-сообщение, отправляемое для указания изменения давления при нажатии ноты, также называемое aftertouch.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_CONTROL_CHANGE:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_CONTROL_CHANGE** = ``11``

MIDI-сообщение, отправляемое после изменения значения контроллера. В MIDI устройстве, контроллер — любое устройство, которое не проигрывает ноты. К ним могут относиться ползунки для регулировки громкости звука, регулировки баланса и панорамирования, а также переключатели и педали. Подробнее о них смотрите по ссылке: `General MIDI specification <https://en.wikipedia.org/wiki/General_MIDI#Controller_events>`__.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_PROGRAM_CHANGE:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_PROGRAM_CHANGE** = ``12``

MIDI-сообщение, отправляемое после изменения MIDI-устройством своего инструмента (также называется *программой* или *предустановкой*).

.. _class_@GlobalScope_constant_MIDI_MESSAGE_CHANNEL_PRESSURE:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_CHANNEL_PRESSURE** = ``13``

MIDI-сообщение, отправляемое для указания изменения давления для всего канала. Некоторые MIDI-устройства могут отправлять его вместо :ref:`MIDI_MESSAGE_AFTERTOUCH<class_@GlobalScope_constant_MIDI_MESSAGE_AFTERTOUCH>`.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_PITCH_BEND:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_PITCH_BEND** = ``14``

MIDI-сообщение, отправляемое после изменения значения питч-бендера, обычно колесиком, расположенным на MIDI-устройстве.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_SYSTEM_EXCLUSIVE:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SYSTEM_EXCLUSIVE** = ``240``

Системное эксклюзивное сообщение MIDI (SysEx). Этот тип сообщения не является стандартным и во многом зависит от отправляющего его MIDI-устройства.

\ **Примечание:** Получение данных этого сообщения через :ref:`InputEventMIDI<class_InputEventMIDI>` не реализовано.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_QUARTER_FRAME:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_QUARTER_FRAME** = ``241``

MIDI-сообщение, отправляемое каждую четверть кадра для синхронизации подключенных MIDI-устройств. Связано с :ref:`MIDI_MESSAGE_TIMING_CLOCK<class_@GlobalScope_constant_MIDI_MESSAGE_TIMING_CLOCK>`.

\ **Примечание:** Получение данных этого сообщения через :ref:`InputEventMIDI<class_InputEventMIDI>` не реализовано.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_SONG_POSITION_POINTER:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SONG_POSITION_POINTER** = ``242``

MIDI-сообщение, отправляемое для перехода на новую позицию в текущей секвенции или песне.

\ **Примечание:** Получение данных этого сообщения через :ref:`InputEventMIDI<class_InputEventMIDI>` не реализовано.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_SONG_SELECT:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SONG_SELECT** = ``243``

MIDI-сообщение отправлено для выбора последовательности или песни для воспроизведения.

\ **Примечание:** Получение данных этого сообщения из :ref:`InputEventMIDI<class_InputEventMIDI>` не реализовано.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_TUNE_REQUEST:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_TUNE_REQUEST** = ``246``

MIDI-сообщение, отправляемое для запроса калибровки настройки. Используется в аналоговых синтезаторах. Большинству современных MIDI-устройств это сообщение не требуется.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_TIMING_CLOCK:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_TIMING_CLOCK** = ``248``

MIDI-сообщение, отправляемое 24 раза после :ref:`MIDI_MESSAGE_QUARTER_FRAME<class_@GlobalScope_constant_MIDI_MESSAGE_QUARTER_FRAME>`, для синхронизации подключенных MIDI-устройств.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_START:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_START** = ``250``

MIDI сообщение, отправляемое для запуска текущей последовательности или песни с начала.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_CONTINUE:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_CONTINUE** = ``251``

MIDI-сообщение, отправляемое для возобновления воспроизведения с того момента, когда текущая секвенция или песня была приостановлена.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_STOP:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_STOP** = ``252``

MIDI-сообщение отправляется для приостановки текущей последовательности или песни.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_ACTIVE_SENSING:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_ACTIVE_SENSING** = ``254``

MIDI-сообщение, многократно отправляемое во время бездействия MIDI-устройства для того, чтобы сообщить приемнику, что связь поддерживается. Большинство MIDI-устройств это сообщение не отправляется.

.. _class_@GlobalScope_constant_MIDI_MESSAGE_SYSTEM_RESET:

.. rst-class:: classref-enumeration-constant

:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SYSTEM_RESET** = ``255``

MIDI-сообщение, отправляемое для возврата MIDI-устройства в состояние по умолчанию, как если бы оно было только что включено. Его нельзя отправлять, когда MIDI-устройство включено.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_Error:

.. rst-class:: classref-enumeration

enum **Error**: :ref:`🔗<enum_@GlobalScope_Error>`

.. _class_@GlobalScope_constant_OK:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **OK** = ``0``

Методы, возвращающие :ref:`Error<enum_@GlobalScope_Error>`, возвращают :ref:`OK<class_@GlobalScope_constant_OK>`, когда ошибок не произошло.

Поскольку :ref:`OK<class_@GlobalScope_constant_OK>` имеет значение ``0``, а все остальные константы ошибок являются положительными целыми числами, его также можно использовать в булевых проверках.

::

    var error = method_that_returns_error()
    if error != OK:
        printerr("Failure!")

    #Или, в качестве альтернативы:
    if error:
        printerr("Still failing!")

\ **Примечание:** Многие функции не возвращают код ошибки, но выводят сообщения об ошибках на стандартный вывод.

.. _class_@GlobalScope_constant_FAILED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **FAILED** = ``1``

Общая ошибка.

.. _class_@GlobalScope_constant_ERR_UNAVAILABLE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_UNAVAILABLE** = ``2``

Ошибка "Недоступно".

.. _class_@GlobalScope_constant_ERR_UNCONFIGURED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_UNCONFIGURED** = ``3``

Ошибка "Не настроено".

.. _class_@GlobalScope_constant_ERR_UNAUTHORIZED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_UNAUTHORIZED** = ``4``

Ошибка "Не авторизовано".

.. _class_@GlobalScope_constant_ERR_PARAMETER_RANGE_ERROR:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_PARAMETER_RANGE_ERROR** = ``5``

Ошибка диапазона параметров.

.. _class_@GlobalScope_constant_ERR_OUT_OF_MEMORY:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_OUT_OF_MEMORY** = ``6``

Ошибка нехватки памяти (OOM).

.. _class_@GlobalScope_constant_ERR_FILE_NOT_FOUND:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_NOT_FOUND** = ``7``

Ошибка "Файл: Не найден".

.. _class_@GlobalScope_constant_ERR_FILE_BAD_DRIVE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_BAD_DRIVE** = ``8``

Ошибка "Файл: Недопустимый диск".

.. _class_@GlobalScope_constant_ERR_FILE_BAD_PATH:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_BAD_PATH** = ``9``

Ошибка "Файл: Неверный путь".

.. _class_@GlobalScope_constant_ERR_FILE_NO_PERMISSION:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_NO_PERMISSION** = ``10``

Ошибка "Файл: Нет разрешения".

.. _class_@GlobalScope_constant_ERR_FILE_ALREADY_IN_USE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_ALREADY_IN_USE** = ``11``

Ошибка "Файл: Уже используется".

.. _class_@GlobalScope_constant_ERR_FILE_CANT_OPEN:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CANT_OPEN** = ``12``

Ошибка "Файл: Невозможно открыть".

.. _class_@GlobalScope_constant_ERR_FILE_CANT_WRITE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CANT_WRITE** = ``13``

Ошибка "Файл: Невозможно записать".

.. _class_@GlobalScope_constant_ERR_FILE_CANT_READ:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CANT_READ** = ``14``

Ошибка "Файл: Невозможно прочитать".

.. _class_@GlobalScope_constant_ERR_FILE_UNRECOGNIZED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_UNRECOGNIZED** = ``15``

Ошибка "Файл: Не распознан".

.. _class_@GlobalScope_constant_ERR_FILE_CORRUPT:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CORRUPT** = ``16``

Ошибка "Файл: Повреждён".

.. _class_@GlobalScope_constant_ERR_FILE_MISSING_DEPENDENCIES:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_MISSING_DEPENDENCIES** = ``17``

Ошибка "Файл: Отсутствуют зависимости".

.. _class_@GlobalScope_constant_ERR_FILE_EOF:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_EOF** = ``18``

Ошибка "Файл: Конец файла (EOF)".

.. _class_@GlobalScope_constant_ERR_CANT_OPEN:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_OPEN** = ``19``

Ошибка "Невозможно открыть".

.. _class_@GlobalScope_constant_ERR_CANT_CREATE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_CREATE** = ``20``

Ошибка "Невозможно создать".

.. _class_@GlobalScope_constant_ERR_QUERY_FAILED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_QUERY_FAILED** = ``21``

Ошибка "Не удалось выполнить запрос".

.. _class_@GlobalScope_constant_ERR_ALREADY_IN_USE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_ALREADY_IN_USE** = ``22``

Ошибка "Уже используется".

.. _class_@GlobalScope_constant_ERR_LOCKED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_LOCKED** = ``23``

Ошибка "Заблокировано".

.. _class_@GlobalScope_constant_ERR_TIMEOUT:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_TIMEOUT** = ``24``

Ошибка "Время ожидания истекло".

.. _class_@GlobalScope_constant_ERR_CANT_CONNECT:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_CONNECT** = ``25``

Ошибка "Невозможно подключиться".

.. _class_@GlobalScope_constant_ERR_CANT_RESOLVE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_RESOLVE** = ``26``

Ошибка "Невозможно разрешить".

.. _class_@GlobalScope_constant_ERR_CONNECTION_ERROR:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CONNECTION_ERROR** = ``27``

Ошибка подключения.

.. _class_@GlobalScope_constant_ERR_CANT_ACQUIRE_RESOURCE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_ACQUIRE_RESOURCE** = ``28``

Ошибка "Невозможно получить ресурс".

.. _class_@GlobalScope_constant_ERR_CANT_FORK:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_FORK** = ``29``

Ошибка «Невозможно разветвить процесс».

.. _class_@GlobalScope_constant_ERR_INVALID_DATA:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_INVALID_DATA** = ``30``

Ошибка неверных данных.

.. _class_@GlobalScope_constant_ERR_INVALID_PARAMETER:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_INVALID_PARAMETER** = ``31``

Ошибка неверного параметра.

.. _class_@GlobalScope_constant_ERR_ALREADY_EXISTS:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_ALREADY_EXISTS** = ``32``

Ошибка "Уже существует".

.. _class_@GlobalScope_constant_ERR_DOES_NOT_EXIST:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_DOES_NOT_EXIST** = ``33``

Ошибка "Не существует".

.. _class_@GlobalScope_constant_ERR_DATABASE_CANT_READ:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_DATABASE_CANT_READ** = ``34``

База данных: Ошибка чтения.

.. _class_@GlobalScope_constant_ERR_DATABASE_CANT_WRITE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_DATABASE_CANT_WRITE** = ``35``

База данных: Ошибка записи.

.. _class_@GlobalScope_constant_ERR_COMPILATION_FAILED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_COMPILATION_FAILED** = ``36``

Ошибка компиляции.

.. _class_@GlobalScope_constant_ERR_METHOD_NOT_FOUND:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_METHOD_NOT_FOUND** = ``37``

Ошибка "Метод не найден".

.. _class_@GlobalScope_constant_ERR_LINK_FAILED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_LINK_FAILED** = ``38``

Ошибка линковки.

.. _class_@GlobalScope_constant_ERR_SCRIPT_FAILED:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_SCRIPT_FAILED** = ``39``

Ошибка при выполнении скрипта.

.. _class_@GlobalScope_constant_ERR_CYCLIC_LINK:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_CYCLIC_LINK** = ``40``

Ошибка циклической ссылки (цикл импорта).

.. _class_@GlobalScope_constant_ERR_INVALID_DECLARATION:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_INVALID_DECLARATION** = ``41``

Ошибка "Недопустимое определение".

.. _class_@GlobalScope_constant_ERR_DUPLICATE_SYMBOL:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_DUPLICATE_SYMBOL** = ``42``

Ошибка "Повторяющийся символ".

.. _class_@GlobalScope_constant_ERR_PARSE_ERROR:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_PARSE_ERROR** = ``43``

Ошибка синтаксического разбора.

.. _class_@GlobalScope_constant_ERR_BUSY:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_BUSY** = ``44``

Ошибка "Занято".

.. _class_@GlobalScope_constant_ERR_SKIP:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_SKIP** = ``45``

Ошибка "Пропущено".

.. _class_@GlobalScope_constant_ERR_HELP:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_HELP** = ``46``

Ошибка при получении справки. Служит для внутреннего использования при передаче ``--version`` или ``--help`` в качестве опций исполняемого файла.

.. _class_@GlobalScope_constant_ERR_BUG:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_BUG** = ``47``

Ошибка, вызванная проблемой реализации метода.

\ **Примечание:** Если встроенный метод возвращает этот код, пожалуйста, откройте проблему на `трекере проблем GitHub <https://github.com/godotengine/godot/issues>`__.

.. _class_@GlobalScope_constant_ERR_PRINTER_ON_FIRE:

.. rst-class:: classref-enumeration-constant

:ref:`Error<enum_@GlobalScope_Error>` **ERR_PRINTER_ON_FIRE** = ``48``

Ошибка «Принтер в огне» (это пасхальное яйцо, ни один встроенный метод не возвращает этот код ошибки).

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_PropertyHint:

.. rst-class:: classref-enumeration

enum **PropertyHint**: :ref:`🔗<enum_@GlobalScope_PropertyHint>`

.. _class_@GlobalScope_constant_PROPERTY_HINT_NONE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NONE** = ``0``

Свойство не имеет подсказку в редакторе.

.. _class_@GlobalScope_constant_PROPERTY_HINT_RANGE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_RANGE** = ``1``

Hints that an :ref:`int<class_int>` or :ref:`float<class_float>` property should be within a range specified via the hint string ``"min,max"`` or ``"min,max,step"``. The hint string can optionally include ``"or_greater"`` and/or ``"or_less"`` to allow manual input going respectively above the max or below the min values.

\ **Example:** ``"-360,360,1,or_greater,or_less"``.

Additionally, other keywords can be included: ``"exp"`` for exponential range editing, ``"radians_as_degrees"`` for editing radian angles in degrees (the range values are also in degrees), ``"degrees"`` to hint at an angle, ``"prefer_slider"`` to show the slider for integers, ``"hide_control"`` to hide the slider or up-down arrows, and ``"suffix:px/s"`` to display a suffix indicating the value's unit (e.g. ``px/s`` for pixels per second).

.. _class_@GlobalScope_constant_PROPERTY_HINT_ENUM:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ENUM** = ``2``

Hints that an :ref:`int<class_int>`, :ref:`String<class_String>`, or :ref:`StringName<class_StringName>` property is an enumerated value to pick in a list specified via a hint string.

The hint string is a comma separated list of names such as ``"Hello,Something,Else"``. Whitespace is **not** removed from either end of a name. For integer properties, the first name in the list has value 0, the next 1, and so on. Explicit values can also be specified by appending ``:integer`` to the name, e.g. ``"Zero,One,Three:3,Four,Six:6"``.

.. _class_@GlobalScope_constant_PROPERTY_HINT_ENUM_SUGGESTION:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ENUM_SUGGESTION** = ``3``

Hints that a :ref:`String<class_String>` or :ref:`StringName<class_StringName>` property can be an enumerated value to pick in a list specified via a hint string such as ``"Hello,Something,Else"``. See :ref:`PROPERTY_HINT_ENUM<class_@GlobalScope_constant_PROPERTY_HINT_ENUM>` for details.

Unlike :ref:`PROPERTY_HINT_ENUM<class_@GlobalScope_constant_PROPERTY_HINT_ENUM>`, a property with this hint still accepts arbitrary values and can be empty. The list of values serves to suggest possible values.

.. _class_@GlobalScope_constant_PROPERTY_HINT_EXP_EASING:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_EXP_EASING** = ``4``

Подсказки, что свойство :ref:`float<class_float>` должно быть отредактировано с помощью функции экспоненциального смягчения. Строка подсказки может включать ``"attenuation"`` для переворота кривой по горизонтали и/или ``"positive_only"`` для исключения смягчения внутрь/наружу и ограничения значений до значений, которые должны быть больше или равны нулю.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LINK:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LINK** = ``5``

Указывает, что векторное свойство позволяет связать его компоненты. Например, это позволяет редактировать :ref:`Vector2.x<class_Vector2_property_x>` и :ref:`Vector2.y<class_Vector2_property_y>` вместе.

.. _class_@GlobalScope_constant_PROPERTY_HINT_FLAGS:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_FLAGS** = ``6``

Hints that an :ref:`int<class_int>` property is a bitmask with named bit flags.

The hint string is a comma separated list of names such as ``"Bit0,Bit1,Bit2,Bit3"``. Whitespace is **not** removed from either end of a name. The first name in the list has value 1, the next 2, then 4, 8, 16 and so on. Explicit values can also be specified by appending ``:integer`` to the name, e.g. ``"A:4,B:8,C:16"``. You can also combine several flags (``"A:4,B:8,AB:12,C:16"``).

\ **Note:** A flag value must be at least ``1`` and at most ``2 ** 32 - 1``.

\ **Note:** Unlike :ref:`PROPERTY_HINT_ENUM<class_@GlobalScope_constant_PROPERTY_HINT_ENUM>`, the previous explicit value is not taken into account. For the hint ``"A:16,B,C"``, A is 16, B is 2, C is 4.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_2D_RENDER:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_2D_RENDER** = ``7``

Указывает, что свойство :ref:`int<class_int>` является битовой маской, использующей необязательно именованные слои 2D-рендеринга.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_2D_PHYSICS:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_2D_PHYSICS** = ``8``

Указывает, что свойство :ref:`int<class_int>` является битовой маской, использующей необязательно именованные 2D-физические слои.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_2D_NAVIGATION:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_2D_NAVIGATION** = ``9``

Указывает, что свойство :ref:`int<class_int>` является битовой маской, использующей необязательно именованные слои 2D-навигации.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_3D_RENDER:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_3D_RENDER** = ``10``

Указывает, что свойство :ref:`int<class_int>` является битовой маской, использующей необязательно именованные слои 3D-рендеринга.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_3D_PHYSICS:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_3D_PHYSICS** = ``11``

Указывает, что свойство :ref:`int<class_int>` является битовой маской, использующей необязательно именованные слои 3D-физики.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_3D_NAVIGATION:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_3D_NAVIGATION** = ``12``

Указывает, что свойство :ref:`int<class_int>` является битовой маской, использующей необязательно именованные слои 3D-навигации.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_AVOIDANCE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_AVOIDANCE** = ``37``

Указывает, что целочисленное свойство является битовой маской, используя необязательно именованные слои избегания в навигации.

.. _class_@GlobalScope_constant_PROPERTY_HINT_FILE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_FILE** = ``13``

Подсказка, что свойство :ref:`String<class_String>` представляет собой путь к файлу. При его редактировании откроется диалоговое окно для выбора пути. Строка подсказки может представлять собой набор фильтров с подстановочными знаками, например, ``"*.png,*.jpg"``. По умолчанию файл будет сохранён как UID (если он доступен). Вы можете использовать методы :ref:`ResourceUID<class_ResourceUID>`, чтобы преобразовать его обратно в путь. Для сохранения необработанного пути используйте :ref:`PROPERTY_HINT_FILE_PATH<class_@GlobalScope_constant_PROPERTY_HINT_FILE_PATH>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_DIR:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_DIR** = ``14``

Указывает, что свойство :ref:`String<class_String>` — это путь к каталогу. При его редактировании откроется диалоговое окно файла для выбора пути.

.. _class_@GlobalScope_constant_PROPERTY_HINT_GLOBAL_FILE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GLOBAL_FILE** = ``15``

Указывает, что свойство :ref:`String<class_String>` является абсолютным путем к файлу вне папки проекта. При его редактировании откроется диалоговое окно для выбора пути. Подсказка может быть набором фильтров с подстановочными знаками, например ``"*.png,*.jpg"``.

.. _class_@GlobalScope_constant_PROPERTY_HINT_GLOBAL_DIR:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GLOBAL_DIR** = ``16``

Указывает, что свойство :ref:`String<class_String>` — это абсолютный путь к каталогу вне папки проекта. При его редактировании откроется диалоговое окно файла для выбора пути.

.. _class_@GlobalScope_constant_PROPERTY_HINT_RESOURCE_TYPE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_RESOURCE_TYPE** = ``17``

Указывает, что свойство является экземпляром типа, производного от :ref:`Resource<class_Resource>`, опционально указываемого через строку подсказки (например, ``"Texture2D"``). При его редактировании отобразится всплывающее меню допустимых типов ресурсов для создания экземпляра.

.. _class_@GlobalScope_constant_PROPERTY_HINT_MULTILINE_TEXT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_MULTILINE_TEXT** = ``18``

Hints that a :ref:`String<class_String>` property is text with line breaks. Editing it will show a text input field where line breaks can be typed.

The hint string can be set to ``"monospace"`` to force the input field to use a monospaced font.

If the hint string ``"no_wrap"`` is set, the input field will not wrap lines at boundaries, instead resorting to making the area scrollable.

.. _class_@GlobalScope_constant_PROPERTY_HINT_EXPRESSION:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_EXPRESSION** = ``19``

Указывает, что свойство :ref:`String<class_String>` является :ref:`Expression<class_Expression>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_PLACEHOLDER_TEXT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_PLACEHOLDER_TEXT** = ``20``

Указывает, что свойство :ref:`String<class_String>` должно отображать текст-заполнитель в своем поле ввода, если оно пустое. Строка подсказки — это текст-заполнитель для использования.

.. _class_@GlobalScope_constant_PROPERTY_HINT_COLOR_NO_ALPHA:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_COLOR_NO_ALPHA** = ``21``

Подсказка о том, что свойство :ref:`Color<class_Color>` следует редактировать, не влияя на его прозрачность (:ref:`Color.a<class_Color_property_a>` не подлежит редактированию).

.. _class_@GlobalScope_constant_PROPERTY_HINT_OBJECT_ID:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_OBJECT_ID** = ``22``

Указывает, что значение свойства - это объект, представленный как ID объекта, тип которого указан в строке подсказки. Используется отладчиком.

.. _class_@GlobalScope_constant_PROPERTY_HINT_TYPE_STRING:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_TYPE_STRING** = ``23``

Если свойство - :ref:`String<class_String>`, то это намекает, что свойство представляет определенный тип (класс). Это позволяет выбрать тип из диалогового окна создания. Свойство сохранит выбранный тип как строку.

Если свойство - :ref:`Array<class_Array>`, то оно подсказывает редактору, как отображать элементы. ``hint_string`` должен кодировать вложенные типы с помощью ``":"`` и ``"/"``.

Если свойство - :ref:`Dictionary<class_Dictionary>`, то оно подсказывает редактору, как отображать элементы. ``hint_string`` работает также, как и с :ref:`Array<class_Array>`, с ``";"``, разделяющий ключ и значение.


.. tabs::

 .. code-tab:: gdscript

    # Массив с elem_type.
    hint_string = "%d:" % [elem_type]
    hint_string = "%d/%d:%s" % [elem_type, elem_hint, elem_hint_string]
    # Двумерный массив с elem_type (массив массивов с elem_type).
    hint_string = "%d:%d:" % [TYPE_ARRAY, elem_type]
    hint_string = "%d:%d/%d:%s" % [TYPE_ARRAY, elem_type, elem_hint, elem_hint_string]
    #Трехмерный массив с elem_type (массив массивов внутри массивов с elem_type).
    hint_string = "%d:%d:%d:" % [TYPE_ARRAY, TYPE_ARRAY, elem_type]
    hint_string = "%d:%d:%d/%d:%s" % [TYPE_ARRAY, TYPE_ARRAY, elem_type, elem_hint, elem_hint_string]

 .. code-tab:: csharp

    // Массив с elemType.
    hintString = $"{elemType:D}:";
    hintString = $"{elemType:}/{elemHint:D}:{elemHintString}";
    // Двумерный массив с elemType (массив массивов с elemType).
    hintString = $"{Variant.Type.Array:D}:{elemType:D}:";
    hintString = $"{Variant.Type.Array:D}:{elemType:D}/{elemHint:D}:{elemHintString}";
    // Трехмерный массив elemType (массив массивов внутри массивов с elemType).
    hintString = $"{Variant.Type.Array:D}:{Variant.Type.Array:D}:{elemType:D}:";
    hintString = $"{Variant.Type.Array:D}:{Variant.Type.Array:D}:{elemType:D}/{elemHint:D}:{elemHintString}";



\ **Примеры:**\ 


.. tabs::

 .. code-tab:: gdscript

    hint_string = "%d:" % [TYPE_INT] # Массив с целыми числами.
    hint_string = "%d/%d:1,10,1" % [TYPE_INT, PROPERTY_HINT_RANGE] # Массив с целыми числами (в диапазоне от 1 до 10).
    hint_string = "%d/%d:Zero,One,Two" % [TYPE_INT, PROPERTY_HINT_ENUM] # Массив с целыми числами (enum).
    hint_string = "%d/%d:Zero,One,Three:3,Six:6" % [TYPE_INT, PROPERTY_HINT_ENUM] # Массив с целыми числами (enum).
    hint_string = "%d/%d:*.png" % [TYPE_STRING, PROPERTY_HINT_FILE] # Массив со строками (пути к файлам).
    hint_string = "%d/%d:Texture2D" % [TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Массив с текстурами.

    hint_string = "%d:%d:" % [TYPE_ARRAY, TYPE_FLOAT] # Двумерный массив чисел с плавающей точкой (тип float)
    hint_string = "%d:%d/%d:" % [TYPE_ARRAY, TYPE_STRING, PROPERTY_HINT_MULTILINE_TEXT] # Двумерный массив с многострочными строками.
    hint_string = "%d:%d/%d:-1,1,0.1" % [TYPE_ARRAY, TYPE_FLOAT, PROPERTY_HINT_RANGE] # Двумерный массив чисел с плавающей точкой (в диапазоне от -1 до 1).
    hint_string = "%d:%d/%d:Texture2D" % [TYPE_ARRAY, TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Двумерный масив с текстурами.

 .. code-tab:: csharp

    hintString = $"{Variant.Type.Int:D}/{PropertyHint.Range:D}:1,10,1"; // Массив с целыми числами (в диапазоне от 1 до 10).
    hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Two"; // Массив с целыми числами (enum).
    hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Three:3,Six:6"; // Массив с целыми числами (enum).
    hintString = $"{Variant.Type.String:D}/{PropertyHint.File:D}:*.png"; // Массив со строками (пути к файлам).
    hintString = $"{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Массив с текстурами.

    hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}:"; // Двумерный массив чисел с плавающей точкой .
    hintString = $"{Variant.Type.Array:D}:{Variant.Type.String:D}/{PropertyHint.MultilineText:D}:"; // Двумерный массив с многострочными строками.
    hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}/{PropertyHint.Range:D}:-1,1,0.1"; // Двумерный массив чисел с плавающей точкой (в диапазоне от -1 до 1).
    hintString = $"{Variant.Type.Array:D}:{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Двумерный масив с текстурами.



\ **Примечание:** Завершающее двоеточие необходимо для правильного определения встроенных типов.

.. _class_@GlobalScope_constant_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE** = ``24``

**Устарело:** This hint is not used by the engine.



.. _class_@GlobalScope_constant_PROPERTY_HINT_OBJECT_TOO_BIG:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_OBJECT_TOO_BIG** = ``25``

Указывает, что обьект слишком большой для отправки через отладчик.

.. _class_@GlobalScope_constant_PROPERTY_HINT_NODE_PATH_VALID_TYPES:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NODE_PATH_VALID_TYPES** = ``26``

Подсказка о том, что строка подсказки указывает допустимые типы узлов для свойства типа :ref:`NodePath<class_NodePath>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_SAVE_FILE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_SAVE_FILE** = ``27``

Подсказка, что свойство :ref:`String<class_String>` является путем к файлу. При его редактировании откроется диалоговое окно для выбора пути сохранения файла. Диалоговое окно имеет доступ к каталогу проекта. Строка подсказки может быть набором фильтров с подстановочными знаками, например ``"*.png,*.jpg"``. См. также :ref:`FileDialog.filters<class_FileDialog_property_filters>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_GLOBAL_SAVE_FILE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GLOBAL_SAVE_FILE** = ``28``

Подсказка, что свойство :ref:`String<class_String>` является путем к файлу. При его редактировании откроется диалоговое окно для выбора пути сохранения файла. Диалоговое окно имеет доступ ко всей файловой системе. Строка подсказки может быть набором фильтров с подстановочными знаками, например ``"*.png,*.jpg"``. См. также :ref:`FileDialog.filters<class_FileDialog_property_filters>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_INT_IS_OBJECTID:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_INT_IS_OBJECTID** = ``29``

**Устарело:** This hint is not used by the engine.



.. _class_@GlobalScope_constant_PROPERTY_HINT_INT_IS_POINTER:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_INT_IS_POINTER** = ``30``

Подсказывает, что свойство :ref:`int<class_int>` является указателем. Используется GDExtension.

.. _class_@GlobalScope_constant_PROPERTY_HINT_ARRAY_TYPE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ARRAY_TYPE** = ``31``

Указывает, что свойство представляет собой :ref:`Array<class_Array>` с сохраненным типом, указанным в строке подсказки. Строка подсказки содержит тип массива (например, ``"String"``).

Используйте формат строки подсказки из :ref:`PROPERTY_HINT_TYPE_STRING<class_@GlobalScope_constant_PROPERTY_HINT_TYPE_STRING>` для большего контроля над сохраненным типом.

.. _class_@GlobalScope_constant_PROPERTY_HINT_DICTIONARY_TYPE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_DICTIONARY_TYPE** = ``38``

Указывает, что свойство представляет собой :ref:`Dictionary<class_Dictionary>` с сохраненными типами, указанными в строке подсказки. Строка подсказки содержит типы ключа и значения, разделенные точкой с запятой (например, ``"int;String"``).

Используйте формат строки подсказки из :ref:`PROPERTY_HINT_TYPE_STRING<class_@GlobalScope_constant_PROPERTY_HINT_TYPE_STRING>` для большего контроля над сохраненными типами.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LOCALE_ID:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LOCALE_ID** = ``32``

Подсказки, что строковое свойство — это код локали. При его редактировании откроется диалоговое окно локали для выбора языка и страны.

.. _class_@GlobalScope_constant_PROPERTY_HINT_LOCALIZABLE_STRING:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LOCALIZABLE_STRING** = ``33``

Подсказки, что свойство словаря — это карта перевода строк. Ключи словаря — это коды локалей, а значения — это переведенные строки.

.. _class_@GlobalScope_constant_PROPERTY_HINT_NODE_TYPE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NODE_TYPE** = ``34``

Подсказки, что свойство является экземпляром типа, производного от :ref:`Node<class_Node>`, опционально указываемого через строку подсказки (например, ``"Node2D"``). При его редактировании отобразится диалоговое окно для выбора узла из сцены.

.. _class_@GlobalScope_constant_PROPERTY_HINT_HIDE_QUATERNION_EDIT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_HIDE_QUATERNION_EDIT** = ``35``

Подсказка о том, что свойство кватерниона должно отключать временный редактор Эйлера.

.. _class_@GlobalScope_constant_PROPERTY_HINT_PASSWORD:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_PASSWORD** = ``36``

Указывает, что строковое свойство является паролем и каждый символ заменяется секретным символом.

.. _class_@GlobalScope_constant_PROPERTY_HINT_TOOL_BUTTON:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_TOOL_BUTTON** = ``39``

Подсказки, что свойство :ref:`Callable<class_Callable>` должно отображаться как кнопка, на которую можно нажать. При нажатии кнопки вызывается вызываемый объект. Строка подсказки указывает текст кнопки и, при необходимости, значок из типа темы ``"EditorIcons"``.

.. code:: text

    "Click me!" - A button with the text "Click me!" and the default "Callable" icon.
    "Click me!,ColorRect" - A button with the text "Click me!" and the "ColorRect" icon.

\ **Примечание:** :ref:`Callable<class_Callable>` не может быть правильно сериализован (serialized) и сохранен в файле, поэтому рекомендуется использовать :ref:`PROPERTY_USAGE_EDITOR<class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR>` вместо :ref:`PROPERTY_USAGE_DEFAULT<class_@GlobalScope_constant_PROPERTY_USAGE_DEFAULT>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_ONESHOT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ONESHOT** = ``40``

Подсказки о том, что свойство будет изменено само по себе после настройки, например :ref:`AudioStreamPlayer.playing<class_AudioStreamPlayer_property_playing>` или :ref:`GPUParticles3D.emitting<class_GPUParticles3D_property_emitting>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_GROUP_ENABLE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GROUP_ENABLE** = ``42``

Указывает, что логическое свойство включит функцию, связанную с группой, в которой оно встречается. Свойство будет отображаться в виде флажка в заголовке группы. Работает только внутри группы или подгруппы.

По умолчанию отключение свойства скрывает все свойства в группе. Используйте необязательную строку подсказки ``"checkbox_only"``, чтобы отключить это поведение.

.. _class_@GlobalScope_constant_PROPERTY_HINT_INPUT_NAME:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_INPUT_NAME** = ``43``

Указывает, что свойство :ref:`String<class_String>` или :ref:`StringName<class_StringName>` является названием действия. Это позволяет выбрать любое название действия из списка действий в настройках проекта. Подсказка может содержать два варианта, разделённых запятой:

- Если они содержат ``"show_builtin"``, в выборку включаются встроенные действия.

- Если они содержат ``"loose_mode"``, включается свободный режим. Это позволяет выбрать название любого действия, даже если оно не представлено в списке действий.

.. _class_@GlobalScope_constant_PROPERTY_HINT_FILE_PATH:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_FILE_PATH** = ``44``

Аналогично :ref:`PROPERTY_HINT_FILE<class_@GlobalScope_constant_PROPERTY_HINT_FILE>`, но свойство хранится как необработанный путь, а не UID. Это означает, что ссылка будет повреждена при перемещении файла. По возможности используйте :ref:`PROPERTY_HINT_FILE<class_@GlobalScope_constant_PROPERTY_HINT_FILE>`.

.. _class_@GlobalScope_constant_PROPERTY_HINT_MAX:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_MAX** = ``45``

Представляет размер перечисления :ref:`PropertyHint<enum_@GlobalScope_PropertyHint>`.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_PropertyUsageFlags:

.. rst-class:: classref-enumeration

flags **PropertyUsageFlags**: :ref:`🔗<enum_@GlobalScope_PropertyUsageFlags>`

.. _class_@GlobalScope_constant_PROPERTY_USAGE_NONE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NONE** = ``0``

Свойство не сохраняется и не отображается в редакторе. Это значение по умолчанию для неэкспортируемых свойств.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_STORAGE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_STORAGE** = ``2``

Свойство сериализуется и сохраняется в файле сцены (по умолчанию для экспортируемых свойств).

.. _class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_EDITOR** = ``4``

Свойство отображается в :ref:`EditorInspector<class_EditorInspector>` (по умолчанию для экспортированных свойств).

.. _class_@GlobalScope_constant_PROPERTY_USAGE_INTERNAL:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_INTERNAL** = ``8``

Свойство исключено из ссылки на класс.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_CHECKABLE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CHECKABLE** = ``16``

Свойство можно проверить в :ref:`EditorInspector<class_EditorInspector>`.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_CHECKED:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CHECKED** = ``32``

Свойство проверяется в :ref:`EditorInspector<class_EditorInspector>`.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_GROUP:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_GROUP** = ``64``

Используется для группировки свойств в редакторе. См. :ref:`EditorInspector<class_EditorInspector>`.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_CATEGORY:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CATEGORY** = ``128``

Используется для категоризации свойств в редакторе.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_SUBGROUP:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SUBGROUP** = ``256``

Используется для группировки свойств в редакторе в подгруппу (в группе). См. :ref:`EditorInspector<class_EditorInspector>`.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_CLASS_IS_BITFIELD:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CLASS_IS_BITFIELD** = ``512``

Свойство является битовым полем, т.е. оно содержит несколько флагов, представленных в виде битов.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_NO_INSTANCE_STATE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NO_INSTANCE_STATE** = ``1024``

Свойство не сохраняет свое состояние в :ref:`PackedScene<class_PackedScene>`.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_RESTART_IF_CHANGED:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_RESTART_IF_CHANGED** = ``2048``

При редактировании свойства пользователю предлагается перезапустить редактор.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_VARIABLE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SCRIPT_VARIABLE** = ``4096``

Свойство является переменной скрипта. :ref:`PROPERTY_USAGE_SCRIPT_VARIABLE<class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_VARIABLE>` может использоваться для различения экспортированных переменных скрипта от встроенных переменных (которые не имеют этого флага использования). По умолчанию :ref:`PROPERTY_USAGE_SCRIPT_VARIABLE<class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_VARIABLE>` **не** применяется к переменным, которые создаются путем переопределения :ref:`Object._get_property_list()<class_Object_private_method__get_property_list>` в скрипте.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_STORE_IF_NULL:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_STORE_IF_NULL** = ``8192``

Значение свойства типа :ref:`Object<class_Object>` будет сохранено, даже если его значение равно ``null``.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED** = ``16384``

Если это свойство изменено, все поля инспектора будут обновлены.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE** = ``32768``

**Устарело:** This flag is not used by the engine.



.. _class_@GlobalScope_constant_PROPERTY_USAGE_CLASS_IS_ENUM:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CLASS_IS_ENUM** = ``65536``

Свойство является переменной типа enum, т.е. оно принимает только именованные целочисленные константы из соответствующего перечисления.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_NIL_IS_VARIANT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NIL_IS_VARIANT** = ``131072``

Если свойство имеет значение по умолчанию ``nil``, его тип будет :ref:`Variant<class_Variant>`.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_ARRAY** = ``262144``

The property is the element count of a property array, i.e. a list of groups of related properties. Properties defined with this usage also need a specific ``class_name`` field in the form of ``label,prefix``. The field may also include additional comma-separated options:

- ``page_size=N``: Overrides :ref:`EditorSettings.interface/inspector/max_array_dictionary_items_per_page<class_EditorSettings_property_interface/inspector/max_array_dictionary_items_per_page>` for this array.

- ``add_button_text=text``: The text displayed by the "Add Element" button.

- ``static``: The elements can't be re-arranged.

- ``const``: New elements can't be added.

- ``numbered``: An index will appear next to each element.

- ``unfoldable``: The array can't be folded.

- ``swap_method=method_name``: The method that will be called when two elements switch places. The method should take 2 :ref:`int<class_int>` parameters, which will be indices of the elements being swapped.

Note that making a full-fledged property array requires boilerplate code involving :ref:`Object._get_property_list()<class_Object_private_method__get_property_list>`.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_ALWAYS_DUPLICATE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_ALWAYS_DUPLICATE** = ``524288``

При дублировании ресурса с помощью :ref:`Resource.duplicate()<class_Resource_method_duplicate>` и установке этого флага для свойства этого ресурса свойство всегда должно дублироваться, независимо от параметра ``subresources`` bool.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_NEVER_DUPLICATE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NEVER_DUPLICATE** = ``1048576``

При дублировании ресурса с помощью :ref:`Resource.duplicate()<class_Resource_method_duplicate>` и установке этого флага для свойства этого ресурса свойство никогда не должно дублироваться, независимо от параметра ``subresources`` bool.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_HIGH_END_GFX:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_HIGH_END_GFX** = ``2097152``

Свойство отображается в редакторе только если поддерживаются современные методы отрисовки (метод отрисовки Совместимость исключен).

.. _class_@GlobalScope_constant_PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT** = ``4194304``

Свойство :ref:`NodePath<class_NodePath>` всегда будет относительным к корню сцены. В основном полезно для локальных ресурсов.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT** = ``8388608``

Используйте, когда ресурс создается «на лету», т. е. геттер всегда будет возвращать другой экземпляр. :ref:`ResourceSaver<class_ResourceSaver>` нуждается в этой информации для правильного сохранения таких ресурсов.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_KEYING_INCREMENTS:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_KEYING_INCREMENTS** = ``16777216``

Вставка ключевого кадра анимации этого свойства автоматически увеличит значение, что позволит легко создавать ключевые кадры для нескольких значений подряд.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_DEFERRED_SET_RESOURCE:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_DEFERRED_SET_RESOURCE** = ``33554432``

**Устарело:** This flag is not used by the engine.



.. _class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT** = ``67108864``

Если это свойство — :ref:`Resource<class_Resource>`, а базовый объект — :ref:`Node<class_Node>`, экземпляр ресурса будет автоматически создаваться всякий раз, когда узел создается в редакторе.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR_BASIC_SETTING:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_EDITOR_BASIC_SETTING** = ``134217728``

Свойство считается базовой настройкой и будет отображаться даже при отключенном расширенном режиме. Используется для настроек проекта.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_READ_ONLY:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_READ_ONLY** = ``268435456``

Свойство доступно только для чтения в инспекторе редактора.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_SECRET:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SECRET** = ``536870912``

Свойство предустановки экспорта с этим флагом содержит конфиденциальную информацию и хранится отдельно от остальной конфигурации предустановки экспорта.

.. _class_@GlobalScope_constant_PROPERTY_USAGE_DEFAULT:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_DEFAULT** = ``6``

Использование по умолчанию (хранение и редактор).

.. _class_@GlobalScope_constant_PROPERTY_USAGE_NO_EDITOR:

.. rst-class:: classref-enumeration-constant

:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NO_EDITOR** = ``2``

Использование по умолчанию, но без отображения свойства в редакторе (хранение).

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_MethodFlags:

.. rst-class:: classref-enumeration

flags **MethodFlags**: :ref:`🔗<enum_@GlobalScope_MethodFlags>`

.. _class_@GlobalScope_constant_METHOD_FLAG_NORMAL:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_NORMAL** = ``1``

Флаг для обычного метода.

.. _class_@GlobalScope_constant_METHOD_FLAG_EDITOR:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_EDITOR** = ``2``

Флаг для метода редактора.

.. _class_@GlobalScope_constant_METHOD_FLAG_CONST:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_CONST** = ``4``

Флаг для константного метода.

.. _class_@GlobalScope_constant_METHOD_FLAG_VIRTUAL:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_VIRTUAL** = ``8``

Флаг для виртуального метода.

.. _class_@GlobalScope_constant_METHOD_FLAG_VARARG:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_VARARG** = ``16``

Флаг для метода с переменным числом аргументов.

.. _class_@GlobalScope_constant_METHOD_FLAG_STATIC:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_STATIC** = ``32``

Флаг для статического метода.

.. _class_@GlobalScope_constant_METHOD_FLAG_OBJECT_CORE:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_OBJECT_CORE** = ``64``

Используется внутри. Позволяет не выгружать основные виртуальные методы (такие как :ref:`Object._notification()<class_Object_private_method__notification>`) в JSON API.

.. _class_@GlobalScope_constant_METHOD_FLAG_VIRTUAL_REQUIRED:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_VIRTUAL_REQUIRED** = ``128``

Флаг обязательного виртуального метода. В GDScript этот флаг устанавливается для абстрактных функций.

.. _class_@GlobalScope_constant_METHOD_FLAGS_DEFAULT:

.. rst-class:: classref-enumeration-constant

:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAGS_DEFAULT** = ``1``

Флаги метода по умолчанию (нормальные).

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_Variant.Type:

.. rst-class:: classref-enumeration

enum **Variant.Type**: :ref:`🔗<enum_@GlobalScope_Variant.Type>`

.. _class_@GlobalScope_constant_TYPE_NIL:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_NIL** = ``0``

Переменная равна ``null``.

.. _class_@GlobalScope_constant_TYPE_BOOL:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_BOOL** = ``1``

Переменная типа :ref:`bool<class_bool>`.

.. _class_@GlobalScope_constant_TYPE_INT:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_INT** = ``2``

Переменная типа :ref:`int<class_int>`.

.. _class_@GlobalScope_constant_TYPE_FLOAT:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_FLOAT** = ``3``

Переменная имеет тип :ref:`float<class_float>`.

.. _class_@GlobalScope_constant_TYPE_STRING:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_STRING** = ``4``

Переменная типа :ref:`String<class_String>`.

.. _class_@GlobalScope_constant_TYPE_VECTOR2:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR2** = ``5``

Переменная типа :ref:`Vector2<class_Vector2>`.

.. _class_@GlobalScope_constant_TYPE_VECTOR2I:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR2I** = ``6``

Переменная имеет тип :ref:`Vector2i<class_Vector2i>`.

.. _class_@GlobalScope_constant_TYPE_RECT2:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_RECT2** = ``7``

Переменная типа :ref:`Rect2<class_Rect2>`.

.. _class_@GlobalScope_constant_TYPE_RECT2I:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_RECT2I** = ``8``

Переменная имеет тип :ref:`Rect2i<class_Rect2i>`.

.. _class_@GlobalScope_constant_TYPE_VECTOR3:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR3** = ``9``

Переменная типа :ref:`Vector3<class_Vector3>`.

.. _class_@GlobalScope_constant_TYPE_VECTOR3I:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR3I** = ``10``

Переменная имеет тип :ref:`Vector3i<class_Vector3i>`.

.. _class_@GlobalScope_constant_TYPE_TRANSFORM2D:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_TRANSFORM2D** = ``11``

Переменная типа :ref:`Transform2D<class_Transform2D>`.

.. _class_@GlobalScope_constant_TYPE_VECTOR4:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR4** = ``12``

Переменная имеет тип :ref:`Vector4<class_Vector4>`.

.. _class_@GlobalScope_constant_TYPE_VECTOR4I:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR4I** = ``13``

Переменная имеет тип :ref:`Vector4i<class_Vector4i>`.

.. _class_@GlobalScope_constant_TYPE_PLANE:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PLANE** = ``14``

Переменная типа :ref:`Plane<class_Plane>`.

.. _class_@GlobalScope_constant_TYPE_QUATERNION:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_QUATERNION** = ``15``

Переменная имеет тип :ref:`Quaternion<class_Quaternion>`.

.. _class_@GlobalScope_constant_TYPE_AABB:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_AABB** = ``16``

Переменная типа :ref:`AABB<class_AABB>`.

.. _class_@GlobalScope_constant_TYPE_BASIS:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_BASIS** = ``17``

Переменная типа :ref:`Basis<class_Basis>`.

.. _class_@GlobalScope_constant_TYPE_TRANSFORM3D:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_TRANSFORM3D** = ``18``

Переменная имеет тип :ref:`Transform3D<class_Transform3D>`.

.. _class_@GlobalScope_constant_TYPE_PROJECTION:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PROJECTION** = ``19``

Переменная имеет тип ``Проекция``.

.. _class_@GlobalScope_constant_TYPE_COLOR:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_COLOR** = ``20``

Переменная типа :ref:`Color<class_Color>`.

.. _class_@GlobalScope_constant_TYPE_STRING_NAME:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_STRING_NAME** = ``21``

Переменная имеет тип :ref:`StringName<class_StringName>`.

.. _class_@GlobalScope_constant_TYPE_NODE_PATH:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_NODE_PATH** = ``22``

Переменная типа :ref:`NodePath<class_NodePath>`.

.. _class_@GlobalScope_constant_TYPE_RID:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_RID** = ``23``

Переменная типа :ref:`RID<class_RID>`.

.. _class_@GlobalScope_constant_TYPE_OBJECT:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_OBJECT** = ``24``

Переменная типа :ref:`Object<class_Object>`.

.. _class_@GlobalScope_constant_TYPE_CALLABLE:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_CALLABLE** = ``25``

Переменная имеет тип :ref:`Callable<class_Callable>`.

.. _class_@GlobalScope_constant_TYPE_SIGNAL:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_SIGNAL** = ``26``

Переменная имеет тип :ref:`Signal<class_Signal>`.

.. _class_@GlobalScope_constant_TYPE_DICTIONARY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_DICTIONARY** = ``27``

Переменная типа :ref:`Dictionary<class_Dictionary>`.

.. _class_@GlobalScope_constant_TYPE_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_ARRAY** = ``28``

Переменная типа :ref:`Array<class_Array>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_BYTE_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_BYTE_ARRAY** = ``29``

Переменная имеет тип :ref:`PackedByteArray<class_PackedByteArray>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_INT32_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_INT32_ARRAY** = ``30``

Переменная имеет тип :ref:`PackedInt32Array<class_PackedInt32Array>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_INT64_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_INT64_ARRAY** = ``31``

Переменная имеет тип :ref:`PackedInt64Array<class_PackedInt64Array>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_FLOAT32_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_FLOAT32_ARRAY** = ``32``

Переменная имеет тип :ref:`PackedFloat32Array<class_PackedFloat32Array>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_FLOAT64_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_FLOAT64_ARRAY** = ``33``

Переменная имеет тип :ref:`PackedFloat64Array<class_PackedFloat64Array>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_STRING_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_STRING_ARRAY** = ``34``

Переменная имеет тип :ref:`PackedStringArray<class_PackedStringArray>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_VECTOR2_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_VECTOR2_ARRAY** = ``35``

Переменная имеет тип :ref:`PackedVector2Array<class_PackedVector2Array>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_VECTOR3_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_VECTOR3_ARRAY** = ``36``

Переменная имеет тип :ref:`PackedVector3Array<class_PackedVector3Array>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_COLOR_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_COLOR_ARRAY** = ``37``

Переменная имеет тип :ref:`PackedColorArray<class_PackedColorArray>`.

.. _class_@GlobalScope_constant_TYPE_PACKED_VECTOR4_ARRAY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_VECTOR4_ARRAY** = ``38``

Переменная имеет тип :ref:`PackedVector4Array<class_PackedVector4Array>`.

.. _class_@GlobalScope_constant_TYPE_MAX:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_MAX** = ``39``

Представляет размер перечисления :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.

.. rst-class:: classref-item-separator

----

.. _enum_@GlobalScope_Variant.Operator:

.. rst-class:: classref-enumeration

enum **Variant.Operator**: :ref:`🔗<enum_@GlobalScope_Variant.Operator>`

.. _class_@GlobalScope_constant_OP_EQUAL:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_EQUAL** = ``0``

Оператор "Равно" (``==``).

.. _class_@GlobalScope_constant_OP_NOT_EQUAL:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_NOT_EQUAL** = ``1``

Оператор "Не равно" (``!=``).

.. _class_@GlobalScope_constant_OP_LESS:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_LESS** = ``2``

Оператор "Меньше чем" (``<``).

.. _class_@GlobalScope_constant_OP_LESS_EQUAL:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_LESS_EQUAL** = ``3``

Оператор "Меньше чем или равно" (``<=``).

.. _class_@GlobalScope_constant_OP_GREATER:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_GREATER** = ``4``

Оператор "Больше чем" (``>``).

.. _class_@GlobalScope_constant_OP_GREATER_EQUAL:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_GREATER_EQUAL** = ``5``

Оператор "Больше чем или равно" (``>=``).

.. _class_@GlobalScope_constant_OP_ADD:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_ADD** = ``6``

Оператор сложения (``+``).

.. _class_@GlobalScope_constant_OP_SUBTRACT:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_SUBTRACT** = ``7``

Оператор вычитания (``-``).

.. _class_@GlobalScope_constant_OP_MULTIPLY:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_MULTIPLY** = ``8``

Оператор умножения (``*``).

.. _class_@GlobalScope_constant_OP_DIVIDE:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_DIVIDE** = ``9``

Оператор деления (``/``).

.. _class_@GlobalScope_constant_OP_NEGATE:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_NEGATE** = ``10``

Унарный оператор отрицания (``-``).

.. _class_@GlobalScope_constant_OP_POSITIVE:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_POSITIVE** = ``11``

Унарный оператор "Плюс" (``+``).

.. _class_@GlobalScope_constant_OP_MODULE:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_MODULE** = ``12``

Оператор остатка/модуля (``%``).

.. _class_@GlobalScope_constant_OP_POWER:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_POWER** = ``13``

Оператор power (``**``).

.. _class_@GlobalScope_constant_OP_SHIFT_LEFT:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_SHIFT_LEFT** = ``14``

Оператор сдвига влево (``<<``).

.. _class_@GlobalScope_constant_OP_SHIFT_RIGHT:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_SHIFT_RIGHT** = ``15``

Оператор сдвига вправо (``>>``).

.. _class_@GlobalScope_constant_OP_BIT_AND:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_AND** = ``16``

Побитовый оператор И (``&``).

.. _class_@GlobalScope_constant_OP_BIT_OR:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_OR** = ``17``

Побитовый оператор ИЛИ (``|``).

.. _class_@GlobalScope_constant_OP_BIT_XOR:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_XOR** = ``18``

Побитовый оператор Исключающее ИЛИ (``^``).

.. _class_@GlobalScope_constant_OP_BIT_NEGATE:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_NEGATE** = ``19``

Побитовый оператор НЕ (``~``).

.. _class_@GlobalScope_constant_OP_AND:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_AND** = ``20``

Оператор "Логическое И" (``and`` или ``&&``).

.. _class_@GlobalScope_constant_OP_OR:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_OR** = ``21``

Логический оператор ИЛИ (``or`` или ``||``).

.. _class_@GlobalScope_constant_OP_XOR:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_XOR** = ``22``

Логический оператор Исключающее ИЛИ (не реализован в GDScript).

.. _class_@GlobalScope_constant_OP_NOT:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_NOT** = ``23``

Логический оператор НЕ (``not`` или ``!``).

.. _class_@GlobalScope_constant_OP_IN:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_IN** = ``24``

Логический оператор В (``in``).

.. _class_@GlobalScope_constant_OP_MAX:

.. rst-class:: classref-enumeration-constant

:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_MAX** = ``25``

Представляет размер перечисления :ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>`.

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Описания свойств
--------------------------------

.. _class_@GlobalScope_property_AudioServer:

.. rst-class:: classref-property

:ref:`AudioServer<class_AudioServer>` **AudioServer** :ref:`🔗<class_@GlobalScope_property_AudioServer>`

Синглтон :ref:`AudioServer<class_AudioServer>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_CameraServer:

.. rst-class:: classref-property

:ref:`CameraServer<class_CameraServer>` **CameraServer** :ref:`🔗<class_@GlobalScope_property_CameraServer>`

Синглтон :ref:`CameraServer<class_CameraServer>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_ClassDB:

.. rst-class:: classref-property

:ref:`ClassDB<class_ClassDB>` **ClassDB** :ref:`🔗<class_@GlobalScope_property_ClassDB>`

Синглтон :ref:`ClassDB<class_ClassDB>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_DisplayServer:

.. rst-class:: classref-property

:ref:`DisplayServer<class_DisplayServer>` **DisplayServer** :ref:`🔗<class_@GlobalScope_property_DisplayServer>`

Синглтон :ref:`DisplayServer<class_DisplayServer>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_EditorInterface:

.. rst-class:: classref-property

:ref:`EditorInterface<class_EditorInterface>` **EditorInterface** :ref:`🔗<class_@GlobalScope_property_EditorInterface>`

Синглтон :ref:`EditorInterface<class_EditorInterface>`.

\ **Примечание:** Доступно только в сборках редактора.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_Engine:

.. rst-class:: classref-property

:ref:`Engine<class_Engine>` **Engine** :ref:`🔗<class_@GlobalScope_property_Engine>`

Синглтон :ref:`Engine<class_Engine>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_EngineDebugger:

.. rst-class:: classref-property

:ref:`EngineDebugger<class_EngineDebugger>` **EngineDebugger** :ref:`🔗<class_@GlobalScope_property_EngineDebugger>`

Синглтон :ref:`EngineDebugger<class_EngineDebugger>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_GDExtensionManager:

.. rst-class:: classref-property

:ref:`GDExtensionManager<class_GDExtensionManager>` **GDExtensionManager** :ref:`🔗<class_@GlobalScope_property_GDExtensionManager>`

Синглтон :ref:`GDExtensionManager<class_GDExtensionManager>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_Geometry2D:

.. rst-class:: classref-property

:ref:`Geometry2D<class_Geometry2D>` **Geometry2D** :ref:`🔗<class_@GlobalScope_property_Geometry2D>`

Синглтон :ref:`Geometry2D<class_Geometry2D>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_Geometry3D:

.. rst-class:: classref-property

:ref:`Geometry3D<class_Geometry3D>` **Geometry3D** :ref:`🔗<class_@GlobalScope_property_Geometry3D>`

Синглтон :ref:`Geometry3D<class_Geometry3D>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_IP:

.. rst-class:: classref-property

:ref:`IP<class_IP>` **IP** :ref:`🔗<class_@GlobalScope_property_IP>`

Синглтон :ref:`IP<class_IP>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_Input:

.. rst-class:: classref-property

:ref:`Input<class_Input>` **Input** :ref:`🔗<class_@GlobalScope_property_Input>`

Синглтон :ref:`Input<class_Input>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_InputMap:

.. rst-class:: classref-property

:ref:`InputMap<class_InputMap>` **InputMap** :ref:`🔗<class_@GlobalScope_property_InputMap>`

Синглтон :ref:`InputMap<class_InputMap>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_JavaClassWrapper:

.. rst-class:: classref-property

:ref:`JavaClassWrapper<class_JavaClassWrapper>` **JavaClassWrapper** :ref:`🔗<class_@GlobalScope_property_JavaClassWrapper>`

Синглтон :ref:`JavaClassWrapper<class_JavaClassWrapper>`.

\ **Примечание:** Реализовано только на Android.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_JavaScriptBridge:

.. rst-class:: classref-property

:ref:`JavaScriptBridge<class_JavaScriptBridge>` **JavaScriptBridge** :ref:`🔗<class_@GlobalScope_property_JavaScriptBridge>`

Синглтон :ref:`JavaScriptBridge<class_JavaScriptBridge>`.

\ **Примечание:** Реализовано только на веб-платформе.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_Marshalls:

.. rst-class:: classref-property

:ref:`Marshalls<class_Marshalls>` **Marshalls** :ref:`🔗<class_@GlobalScope_property_Marshalls>`

Синглтон :ref:`Marshalls<class_Marshalls>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_NativeMenu:

.. rst-class:: classref-property

:ref:`NativeMenu<class_NativeMenu>` **NativeMenu** :ref:`🔗<class_@GlobalScope_property_NativeMenu>`

Синглтон :ref:`NativeMenu<class_NativeMenu>`.

\ **Примечание:** Реализовано только на macOS.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_NavigationMeshGenerator:

.. rst-class:: classref-property

:ref:`NavigationMeshGenerator<class_NavigationMeshGenerator>` **NavigationMeshGenerator** :ref:`🔗<class_@GlobalScope_property_NavigationMeshGenerator>`

Синглтон :ref:`NavigationMeshGenerator<class_NavigationMeshGenerator>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_NavigationServer2D:

.. rst-class:: classref-property

:ref:`NavigationServer2D<class_NavigationServer2D>` **NavigationServer2D** :ref:`🔗<class_@GlobalScope_property_NavigationServer2D>`

Синглтон :ref:`NavigationServer2D<class_NavigationServer2D>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_NavigationServer2DManager:

.. rst-class:: classref-property

:ref:`NavigationServer2DManager<class_NavigationServer2DManager>` **NavigationServer2DManager** :ref:`🔗<class_@GlobalScope_property_NavigationServer2DManager>`

The :ref:`NavigationServer2DManager<class_NavigationServer2DManager>` singleton.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_NavigationServer3D:

.. rst-class:: classref-property

:ref:`NavigationServer3D<class_NavigationServer3D>` **NavigationServer3D** :ref:`🔗<class_@GlobalScope_property_NavigationServer3D>`

Синглтон :ref:`NavigationServer3D<class_NavigationServer3D>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_NavigationServer3DManager:

.. rst-class:: classref-property

:ref:`NavigationServer3DManager<class_NavigationServer3DManager>` **NavigationServer3DManager** :ref:`🔗<class_@GlobalScope_property_NavigationServer3DManager>`

The :ref:`NavigationServer3DManager<class_NavigationServer3DManager>` singleton.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_OS:

.. rst-class:: classref-property

:ref:`OS<class_OS>` **OS** :ref:`🔗<class_@GlobalScope_property_OS>`

Синглтон :ref:`OS<class_OS>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_Performance:

.. rst-class:: classref-property

:ref:`Performance<class_Performance>` **Performance** :ref:`🔗<class_@GlobalScope_property_Performance>`

Синглтон :ref:`Performance<class_Performance>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_PhysicsServer2D:

.. rst-class:: classref-property

:ref:`PhysicsServer2D<class_PhysicsServer2D>` **PhysicsServer2D** :ref:`🔗<class_@GlobalScope_property_PhysicsServer2D>`

Синглтон :ref:`PhysicsServer2D<class_PhysicsServer2D>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_PhysicsServer2DManager:

.. rst-class:: classref-property

:ref:`PhysicsServer2DManager<class_PhysicsServer2DManager>` **PhysicsServer2DManager** :ref:`🔗<class_@GlobalScope_property_PhysicsServer2DManager>`

Синглтон :ref:`PhysicsServer2DManager<class_PhysicsServer2DManager>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_PhysicsServer3D:

.. rst-class:: classref-property

:ref:`PhysicsServer3D<class_PhysicsServer3D>` **PhysicsServer3D** :ref:`🔗<class_@GlobalScope_property_PhysicsServer3D>`

Синглтон :ref:`PhysicsServer3D<class_PhysicsServer3D>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_PhysicsServer3DManager:

.. rst-class:: classref-property

:ref:`PhysicsServer3DManager<class_PhysicsServer3DManager>` **PhysicsServer3DManager** :ref:`🔗<class_@GlobalScope_property_PhysicsServer3DManager>`

Синглтон :ref:`PhysicsServer3DManager<class_PhysicsServer3DManager>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_ProjectSettings:

.. rst-class:: classref-property

:ref:`ProjectSettings<class_ProjectSettings>` **ProjectSettings** :ref:`🔗<class_@GlobalScope_property_ProjectSettings>`

Синглтон :ref:`ProjectSettings<class_ProjectSettings>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_RenderingServer:

.. rst-class:: classref-property

:ref:`RenderingServer<class_RenderingServer>` **RenderingServer** :ref:`🔗<class_@GlobalScope_property_RenderingServer>`

Синглтон :ref:`RenderingServer<class_RenderingServer>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_ResourceLoader:

.. rst-class:: classref-property

:ref:`ResourceLoader<class_ResourceLoader>` **ResourceLoader** :ref:`🔗<class_@GlobalScope_property_ResourceLoader>`

Синглтон :ref:`ResourceLoader<class_ResourceLoader>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_ResourceSaver:

.. rst-class:: classref-property

:ref:`ResourceSaver<class_ResourceSaver>` **ResourceSaver** :ref:`🔗<class_@GlobalScope_property_ResourceSaver>`

Синглтон :ref:`ResourceSaver<class_ResourceSaver>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_ResourceUID:

.. rst-class:: classref-property

:ref:`ResourceUID<class_ResourceUID>` **ResourceUID** :ref:`🔗<class_@GlobalScope_property_ResourceUID>`

Синглтон :ref:`ResourceUID<class_ResourceUID>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_TextServerManager:

.. rst-class:: classref-property

:ref:`TextServerManager<class_TextServerManager>` **TextServerManager** :ref:`🔗<class_@GlobalScope_property_TextServerManager>`

Синглтон :ref:`TextServerManager<class_TextServerManager>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_ThemeDB:

.. rst-class:: classref-property

:ref:`ThemeDB<class_ThemeDB>` **ThemeDB** :ref:`🔗<class_@GlobalScope_property_ThemeDB>`

Синглтон :ref:`ThemeDB<class_ThemeDB>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_Time:

.. rst-class:: classref-property

:ref:`Time<class_Time>` **Time** :ref:`🔗<class_@GlobalScope_property_Time>`

Синглтон :ref:`Time<class_Time>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_TranslationServer:

.. rst-class:: classref-property

:ref:`TranslationServer<class_TranslationServer>` **TranslationServer** :ref:`🔗<class_@GlobalScope_property_TranslationServer>`

Синглтон :ref:`TranslationServer<class_TranslationServer>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_WorkerThreadPool:

.. rst-class:: classref-property

:ref:`WorkerThreadPool<class_WorkerThreadPool>` **WorkerThreadPool** :ref:`🔗<class_@GlobalScope_property_WorkerThreadPool>`

Синглтон :ref:`WorkerThreadPool<class_WorkerThreadPool>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_property_XRServer:

.. rst-class:: classref-property

:ref:`XRServer<class_XRServer>` **XRServer** :ref:`🔗<class_@GlobalScope_property_XRServer>`

Синглтон :ref:`XRServer<class_XRServer>`.

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Описания метода
------------------------------

.. _class_@GlobalScope_method_abs:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **abs**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_abs>`

Возвращает абсолютное значение :ref:`Variant<class_Variant>` параметра ``x`` (т.е положительное значение). Поддерживаемые типы данных: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.

::

    var a = abs(-1)
    # a это 1

    var b = abs(-1.2)
    # b это 1.2

    var c = abs(Vector2(-3.5, -4))
    # c это (3.5, 4)

    var d = abs(Vector2i(-5, -6))
    # d это (5, 6)

    var e = abs(Vector3(-7, 8.5, -3.8))
    # e это (7, 8.5, 3.8)

    var f = abs(Vector3i(-7, -8, -9))
    # f это (7, 8, 9)

\ **Примечание:** Для лучшей безопасности типов, используйте методы :ref:`absf()<class_@GlobalScope_method_absf>`, :ref:`absi()<class_@GlobalScope_method_absi>`, :ref:`Vector2.abs()<class_Vector2_method_abs>`, :ref:`Vector2i.abs()<class_Vector2i_method_abs>`, :ref:`Vector3.abs()<class_Vector3_method_abs>`, :ref:`Vector3i.abs()<class_Vector3i_method_abs>`, :ref:`Vector4.abs()<class_Vector4_method_abs>`, или :ref:`Vector4i.abs()<class_Vector4i_method_abs>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_absf:

.. rst-class:: classref-method

:ref:`float<class_float>` **absf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_absf>`

Возвращает абсолютное значение параметра float ``x`` (т.е. положительное значение).

::

    # a is 1.2
    var a = absf(-1.2)

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_absi:

.. rst-class:: classref-method

:ref:`int<class_int>` **absi**\ (\ x\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_absi>`

Возвращает абсолютное значение параметра int ``x`` (т.е. положительное значение).

::

    # a is 1
    var a = absi(-1)

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_acos:

.. rst-class:: classref-method

:ref:`float<class_float>` **acos**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_acos>`

Возвращает арккосинус ``x`` в радианах. Используйте для получения угла косинуса ``x``. ``x`` будет ограничено между ``-1.0`` и ``1.0`` (включительно), чтобы предотвратить возврат :ref:`acos()<class_@GlobalScope_method_acos>` :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.

::

    # c равен 0,523599 или 30 градусов, если преобразовано с помощью rad_to_deg(c)
    var c = acos(0.866025)

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_acosh:

.. rst-class:: classref-method

:ref:`float<class_float>` **acosh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_acosh>`

Возвращает гиперболический дуговой (также называемый обратным) косинус ``x``, возвращая значение в радианах. Используйте его для получения угла из косинуса угла в гиперболическом пространстве, если ``x`` больше или равен 1. Для значений ``x`` меньше 1 он вернет 0, чтобы предотвратить возврат :ref:`acosh()<class_@GlobalScope_method_acosh>` :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.

::

    var a = acosh(2) # Returns 1.31695789692482
    cosh(a) # Returns 2

    var b = acosh(-1) # Returns 0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_angle_difference:

.. rst-class:: classref-method

:ref:`float<class_float>` **angle_difference**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_angle_difference>`

Возвращает разницу между двумя углами (в радианах) в диапазоне ``[-PI, +PI[/code]. Когда [param from] и [param to] противоположны, возвращает [code]-PI``, если ``from`` меньше, чем ``to``, или ``PI`` в противном случае.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_asin:

.. rst-class:: classref-method

:ref:`float<class_float>` **asin**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_asin>`

Возвращает арксинус ``x`` в радианах. Используйте для получения угла синуса ``x``. ``x`` будет ограничено между ``-1.0`` и ``1.0`` (включительно), чтобы предотвратить возврат :ref:`asin()<class_@GlobalScope_method_asin>` :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.

::

    # s равен 0,523599 или 30 градусам, если преобразовано с помощью rad_to_deg(s)
    var s = asin(0.5)

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_asinh:

.. rst-class:: classref-method

:ref:`float<class_float>` **asinh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_asinh>`

Возвращает гиперболический дуговой (также называемый обратным) синус ``x``, возвращая значение в радианах. Используйте его, чтобы получить угол из синуса угла в гиперболическом пространстве.

::

    var a = asinh(0.9) # Returns 0.8088669356527824
    sinh(a) # Returns 0.9

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_atan:

.. rst-class:: classref-method

:ref:`float<class_float>` **atan**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_atan>`

Возвращает арктангенс ``x`` в радианах. Используйте его для получения угла из тангенса угла в тригонометрии.

Метод не может знать, в какой квадрант должен попасть угол. Смотрите :ref:`atan2()<class_@GlobalScope_method_atan2>`, если у вас есть и ``y``, и ``x``.

::

    var a = atan(0.5) # a is 0.463648

Если ``x`` находится между ``-PI / 2`` и ``PI / 2`` (включительно), ``atan(tan(x))`` равен ``x``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_atan2:

.. rst-class:: classref-method

:ref:`float<class_float>` **atan2**\ (\ y\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_atan2>`

Возвращает арктангенс ``y/x`` в радианах. Используйте для получения угла тангенса ``y/x``. Для вычисления значения метод учитывает знак обоих аргументов, чтобы определить квадрант.

Важное примечание: по соглашению координата Y идет первой.

::

    var a = atan2(0, -1) # a is 3.141593

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_atanh:

.. rst-class:: classref-method

:ref:`float<class_float>` **atanh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_atanh>`

Возвращает тангенс гиперболической дуги (также называемой обратной) к ``x``, возвращая значение в радианах. Используется для получения угла из тангенса угла в гиперболическом пространстве, если ``x`` находится в диапазоне от -1 до 1 (не включительно).

В математике обратный гиперболический тангенс определен только для -1 < ``x`` < 1 в вещественном множестве, поэтому значения, равные или меньшие -1 для ``x``, возвращают отрицательные :ref:`@GDScript.INF<class_@GDScript_constant_INF>`, а значения, равные или большие 1, возвращают положительные :ref:`@GDScript.INF()<class_@GDScript_method_INF>`, чтобы :ref:`atanh()<class_@GlobalScope_method_atanh>` не возвращал :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.

::
.
    var a = atanh(0.9) # Возвращает 1.47221948958322
    tanh(a) # Возвращает 0.9

    var b = atanh(-2) # Возвращает -inf
    tanh(b) # Возвращает -1

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_bezier_derivative:

.. rst-class:: classref-method

:ref:`float<class_float>` **bezier_derivative**\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_bezier_derivative>`

Возвращает производную при заданной ``t`` на одномерной `кривой Безье <https://ru.wikipedia.org/wiki/Кривая_Безье>`__, заданной точками ``control_1``, ``control_2`` и ``end``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_bezier_interpolate:

.. rst-class:: classref-method

:ref:`float<class_float>` **bezier_interpolate**\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_bezier_interpolate>`

Возвращает точку в заданной точке ``t`` на одномерной `кривой Безье <https://ru.wikipedia.org/wiki/Кривая_Безье>`__, определяемой заданными точками ``control_1``, ``control_2`` и ``end``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_bytes_to_var:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **bytes_to_var**\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_@GlobalScope_method_bytes_to_var>`

Декодирует байтовый массив обратно в значение :ref:`Variant<class_Variant>`, без декодирования объектов.

\ **Примечание:** Если вам нужна десериализация объектов, смотрите :ref:`bytes_to_var_with_objects()<class_@GlobalScope_method_bytes_to_var_with_objects>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_bytes_to_var_with_objects:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **bytes_to_var_with_objects**\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_@GlobalScope_method_bytes_to_var_with_objects>`

Декодирует массив байтов обратно в значение :ref:`Variant<class_Variant>`. Декодирование объектов разрешено.

\ **Предупреждение:** Десериализованный объект может содержать код, который будет выполнен. Не используйте эту опцию, если сериализованный объект получен из ненадежных источников, чтобы избежать потенциальных угроз безопасности (удаленное выполнение кода).

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_ceil:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **ceil**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_ceil>`

Округляет ``x`` в большую сторону (в сторону положительной бесконечности), возвращая наименьшее целое число, которое не меньше ``x``. Поддерживаемые типы: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.

::

    var i = ceil(1.45) # i is 2.0
    i = ceil(1.001)    # i is 2.0

См. также :ref:`floor()<class_@GlobalScope_method_floor>`, :ref:`round()<class_@GlobalScope_method_round>`, и :ref:`snapped()<class_@GlobalScope_method_snapped>`.

\ **Примечание:** Для лучшей безопасности типов используйте :ref:`ceilf()<class_@GlobalScope_method_ceilf>`, :ref:`ceili()<class_@GlobalScope_method_ceili>`, :ref:`Vector2.ceil()<class_Vector2_method_ceil>`, :ref:`Vector3.ceil()<class_Vector3_method_ceil>`, или :ref:`Vector4.ceil()<class_Vector4_method_ceil>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_ceilf:

.. rst-class:: classref-method

:ref:`float<class_float>` **ceilf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_ceilf>`

Округляет ``x`` в большую сторону (в сторону положительной бесконечности), возвращая наименьшее целое число, которое не меньше ``x``.

Типобезопасная версия :ref:`ceil()<class_@GlobalScope_method_ceil>`, возвращающая :ref:`float<class_float>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_ceili:

.. rst-class:: classref-method

:ref:`int<class_int>` **ceili**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_ceili>`

Округляет ``x`` в большую сторону (в сторону положительной бесконечности), возвращая наименьшее целое число, которое не меньше ``x``.

Типобезопасная версия :ref:`ceil()<class_@GlobalScope_method_ceil>`, возвращающая :ref:`int<class_int>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_clamp:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **clamp**\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_clamp>`

Фиксирует ``value``, возвращая :ref:`Variant<class_Variant>` не меньше ``min`` и не больше ``max``. Будут работать любые значения, которые можно сравнить с операторами «меньше» и «больше».

::

    var a = clamp(-10, -1, 5)
    # a is -1

    var b = clamp(8.1, 0.9, 5.5)
    # b is 5.5

\ **Примечание:** Для лучшей безопасности типов используйте :ref:`clampf()<class_@GlobalScope_method_clampf>`, :ref:`clampi()<class_@GlobalScope_method_clampi>`, :ref:`Vector2.clamp()<class_Vector2_method_clamp>`, :ref:`Vector2i.clamp()<class_Vector2i_method_clamp>`, :ref:`Vector3.clamp()<class_Vector3_method_clamp>`, :ref:`Vector3i.clamp()<class_Vector3i_method_clamp>`, :ref:`Vector4.clamp()<class_Vector4_method_clamp>`, :ref:`Vector4i.clamp()<class_Vector4i_method_clamp>` или :ref:`Color.clamp()<class_Color_method_clamp>` (в настоящее время не поддерживается этим методом).

\ **Примечание:** При использовании этого на векторах он *не* будет выполнять покомпонентное ограничение, а выберет ``min``, если ``value < min`` или ``max``, если ``value > max``. Для выполнения покомпонентного ограничения используйте методы, перечисленные выше.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_clampf:

.. rst-class:: classref-method

:ref:`float<class_float>` **clampf**\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_clampf>`

Ограничивает ``value``, возвращая :ref:`float<class_float>` не меньше ``min`` и не больше ``max``.

::
.
    var speed = 42.1
    var a = clampf(speed, 1.0, 20.5) # a равен 20.5

    speed = -10.0
    var b = clampf(speed, -1.0, 1.0) # b равен -1.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_clampi:

.. rst-class:: classref-method

:ref:`int<class_int>` **clampi**\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_clampi>`

Зажимает ``value``, возвращая :ref:`int<class_int>` не меньше ``min`` и не больше ``max``.

::
.
    var speed = 42
    var a = clampi(speed, 1, 20) # a равно 20

    speed = -10
    var b = clampi(speed, -1, 1) # b равно -1

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_cos:

.. rst-class:: classref-method

:ref:`float<class_float>` **cos**\ (\ angle_rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cos>`

Возвращает косинус угла ``angle_rad`` в радианах.

::
.
    cos(PI * 2)         # Возвращает 1.0
    cos(PI)             # Возвращает -1.0
    cos(deg_to_rad(90)) # Возвращает 0.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_cosh:

.. rst-class:: classref-method

:ref:`float<class_float>` **cosh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cosh>`

Возвращает гиперболический косинус ``x`` в радианах.

::

    print(cosh(1)) # Выводит 1.543081

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_cubic_interpolate:

.. rst-class:: classref-method

:ref:`float<class_float>` **cubic_interpolate**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate>`

Кубическая интерполяция между двумя значениями по коэффициенту, определенному в ``weight``, и значениями ``pre`` и ``post``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_cubic_interpolate_angle:

.. rst-class:: classref-method

:ref:`float<class_float>` **cubic_interpolate_angle**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate_angle>`

Кубическая интерполяция между двумя значениями вращения с кратчайшим путем по коэффициенту, определенному в ``weight`` со значениями ``pre`` и ``post``. См. также :ref:`lerp_angle()<class_@GlobalScope_method_lerp_angle>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_cubic_interpolate_angle_in_time:

.. rst-class:: classref-method

:ref:`float<class_float>` **cubic_interpolate_angle_in_time**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate_angle_in_time>`

Кубическая интерполяция между двумя значениями вращения с кратчайшим путем по коэффициенту, определенному в ``weight`` со значениями ``pre`` и ``post``. См. также :ref:`lerp_angle()<class_@GlobalScope_method_lerp_angle>`.

Он может выполнять более плавную интерполяцию, чем :ref:`cubic_interpolate()<class_@GlobalScope_method_cubic_interpolate>` по значениям времени.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_cubic_interpolate_in_time:

.. rst-class:: classref-method

:ref:`float<class_float>` **cubic_interpolate_in_time**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate_in_time>`

Кубическая интерполяция между двумя значениями с помощью коэффициента, определенного в ``weight`` со значениями ``pre`` и ``post``.

Он может выполнять более плавную интерполяцию, чем :ref:`cubic_interpolate()<class_@GlobalScope_method_cubic_interpolate>` по значениям времени.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_db_to_linear:

.. rst-class:: classref-method

:ref:`float<class_float>` **db_to_linear**\ (\ db\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_db_to_linear>`

Преобразует децибелы в линейную энергию (аудио).

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_deg_to_rad:

.. rst-class:: classref-method

:ref:`float<class_float>` **deg_to_rad**\ (\ deg\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_deg_to_rad>`

Преобразует угол, выраженный в градусах, в радианы.

::

    r = deg2rad(180) # r = 3.141593

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_ease:

.. rst-class:: classref-method

:ref:`float<class_float>` **ease**\ (\ x\: :ref:`float<class_float>`, curve\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_ease>`

Возвращает "облегченное" значение ``x`` на основе функции облегчения, определенной с помощью ``curve``. Эта функция облегчения основана на экспоненте. ``curve`` может быть любым числом с плавающей точкой, с определенными значениями, приводящими к следующим поведениям:

.. code:: text

    - Lower than -1.0 (exclusive): Ease in-out
    - -1.0: Linear
    - Between -1.0 and 0.0 (exclusive): Ease out-in
    - 0.0: Constant
    - Between 0.0 to 1.0 (exclusive): Ease out
    - 1.0: Linear
    - Greater than 1.0 (exclusive): Ease in

\ `ease() шпаргалка по значениям кривых <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/ease_cheatsheet.png>`__\ 

См. также :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`. Если вам нужно выполнить более сложные переходы, используйте :ref:`Tween.interpolate_value()<class_Tween_method_interpolate_value>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_error_string:

.. rst-class:: classref-method

:ref:`String<class_String>` **error_string**\ (\ error\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_error_string>`

Возвращает понятное человеку имя для указанного кода :ref:`Error<enum_@GlobalScope_Error>`.

::

    print(OK)                              # Выводит 0
    print(error_string(OK))                # Выводит "OK"
    print(error_string(ERR_BUSY))          # Выводит "Busy"
    print(error_string(ERR_OUT_OF_MEMORY)) # Выводит "Out of memory"

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_exp:

.. rst-class:: classref-method

:ref:`float<class_float>` **exp**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_exp>`

Естественная показательная функция. Возводит математическую константу *e* в степень ``x`` и возвращает ее.

\ *e* имеет приблизительное значение 2,71828 и может быть получено с помощью ``exp(1)``.

Для возведения в степень с другими основаниями используйте method :ref:`pow()<class_@GlobalScope_method_pow>`.

::

    var a = exp(2) # Примерно 7.39

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_floor:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **floor**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_floor>`

Округляет ``x`` в меньшую сторону (в сторону отрицательной бесконечности), возвращая наибольшее целое число, которое не больше ``x``. Поддерживаемые типы: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.

::

    var a = floor(2.99) # a is 2.0
    a = floor(-2.99)    # a is -3.0

См. также :ref:`ceil()<class_@GlobalScope_method_ceil>`, :ref:`round()<class_@GlobalScope_method_round>` и :ref:`snapped()<class_@GlobalScope_method_snapped>`.

\ **Примечание:** Для лучшей безопасности типов используйте :ref:`floorf()<class_@GlobalScope_method_floorf>`, :ref:`floori()<class_@GlobalScope_method_floori>`, :ref:`Vector2.floor()<class_Vector2_method_floor>`, :ref:`Vector3.floor()<class_Vector3_method_floor>` или :ref:`Vector4.floor()<class_Vector4_method_floor>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_floorf:

.. rst-class:: classref-method

:ref:`float<class_float>` **floorf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_floorf>`

Округляет ``x`` в сторону уменьшения (к отрицательной бесконечности), возвращая наибольшее целое число, которое не больше, чем ``x``.

Безопасная для типов версия :ref:`floor()<class_@GlobalScope_method_floor>`, возвращающая :ref:`float<class_float>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_floori:

.. rst-class:: classref-method

:ref:`int<class_int>` **floori**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_floori>`

Округляет ``x`` вниз (в сторону отрицательной бесконечности), возвращая наибольшее целое число, которое не больше, чем ``x``.

Типобезопасная версия :ref:`floor()<class_@GlobalScope_method_floor>`, возвращающая :ref:`int<class_int>`.

\ **Примечание:** Эта функция *не* то же самое, что ``int(x)``, которая округляет до 0.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_fmod:

.. rst-class:: classref-method

:ref:`float<class_float>` **fmod**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_fmod>`

Возвращает остаток с плавающей точкой от деления ``x`` на ``y``, сохраняя знак ``x``.

::

    var remainder = fmod(7, 5.5) # остаток равен 1.5

Для операции целочисленного остатка используйте оператор ``%``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_fposmod:

.. rst-class:: classref-method

:ref:`float<class_float>` **fposmod**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_fposmod>`

Возвращает модуль с плавающей точкой ``x``, деленный на ``y``, с одинаковой оберткой в положительных и отрицательных значениях.

::

    print(" (x)  (fmod(x, 1.5))   (fposmod(x, 1.5))")
    for i in 7:
        var x = i * 0.5 - 1.5
        print("%4.1f           %4.1f  | %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])

Prints:

.. code:: text

     (x)  (fmod(x, 1.5))   (fposmod(x, 1.5))
    -1.5           -0.0  |  0.0
    -1.0           -1.0  |  0.5
    -0.5           -0.5  |  1.0
     0.0            0.0  |  0.0
     0.5            0.5  |  0.5
     1.0            1.0  |  1.0
     1.5            0.0  |  0.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_hash:

.. rst-class:: classref-method

:ref:`int<class_int>` **hash**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_hash>`

Возвращает целочисленный хэш переданной ``variable``.


.. tabs::

 .. code-tab:: gdscript

    print(hash("a")) # Выводит 177670

 .. code-tab:: csharp

    GD.Print(GD.Hash("a")); // Выводит 177670



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_instance_from_id:

.. rst-class:: classref-method

:ref:`Object<class_Object>` **instance_from_id**\ (\ instance_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_instance_from_id>`

Returns the :ref:`Object<class_Object>` that corresponds to ``instance_id``. All Objects have a unique instance ID. See also :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>`.


.. tabs::

 .. code-tab:: gdscript

    var drink = "water"

    func _ready():
        var id = get_instance_id()
        var instance = instance_from_id(id)
        print(instance.drink) # Prints "water"

 .. code-tab:: csharp

    public partial class MyNode : Node
    {
        public string Drink { get; set; } = "water";

        public override void _Ready()
        {
            ulong id = GetInstanceId();
            var instance = (MyNode)InstanceFromId(Id);
            GD.Print(instance.Drink); // Prints "water"
        }
    }



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_inverse_lerp:

.. rst-class:: classref-method

:ref:`float<class_float>` **inverse_lerp**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_inverse_lerp>`

Возвращает коэффициент интерполяции или экстраполяции с учетом диапазона, указанного в ``from`` и ``to``, и интерполированного значения, указанного в ``weight``. Возвращаемое значение будет находиться между ``0.0`` и ``1.0``, если ``weight`` находится между ``from`` и ``to`` (включительно). Если ``weight`` находится за пределами этого диапазона, то будет возвращен коэффициент экстраполяции (возвращаемое значение меньше ``0.0`` или больше ``1.0``). Используйте :ref:`clamp()<class_@GlobalScope_method_clamp>` для результата :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>`, если это нежелательно.

::

    # Коэффициент интерполяции в вызове `lerp()` ниже составляет 0,75.
    var middle = lerp(20, 30, 0.75)
    # средний показатель сейчас составляет 27,5.

    # Теперь мы делаем вид, что забыли исходное соотношение и хотим его восстановить.
    var ratio = inverse_lerp(20, 30, 27.5)
    # Сейчас коэффициент составляет 0,75.

См. также :ref:`lerp()<class_@GlobalScope_method_lerp>`, который выполняет обратную операцию, и :ref:`remap()<class_@GlobalScope_method_remap>` для преобразования одной непрерывной серии значений в другую.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_equal_approx:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_equal_approx**\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_equal_approx>`

Возвращает ``true``, если ``a`` и ``b`` приблизительно равны друг другу.

Здесь «приблизительно равны» означает, что ``a`` и ``b`` находятся в пределах небольшого внутреннего эпсилона друг от друга, который масштабируется с величиной чисел.

Значения бесконечности одного знака считаются равными.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_finite:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_finite**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_finite>`

Проверяет, является ли ``x`` конечным значением, т. е. не является ли он :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`, положительной бесконечностью или отрицательной бесконечностью.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_inf:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_inf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_inf>`

Возвращает ``true``, если ``x`` равен либо положительной бесконечности, либо отрицательной бесконечности. См. также :ref:`is_finite()<class_@GlobalScope_method_is_finite>` и :ref:`is_nan()<class_@GlobalScope_method_is_nan>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_instance_id_valid:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_instance_id_valid**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_is_instance_id_valid>`

Возвращает ``true``, если объект, соответствующий ``id``, является допустимым объектом (например, не был удален из памяти). Все объекты имеют уникальный идентификатор экземпляра.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_instance_valid:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_instance_valid**\ (\ instance\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_is_instance_valid>`

Возвращает ``true``, если ``instance`` является допустимым объектом (например, не был удален из памяти).

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_nan:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_nan**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_nan>`

Возвращает ``true``, если ``x`` является NaN ("Not a Number") или является некорректным значением. Этот метод необходим, поскольку :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` не равен самому себе, что означает, что ``x == NAN`` нельзя использовать для проверки на NaN.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_same:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_same**\ (\ a\: :ref:`Variant<class_Variant>`, b\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_is_same>`

Возвращает ``true`` для типов значений, если ``a`` и ``b`` имеют одно и то же значение. Возвращает ``true`` для ссылочных типов, если ссылки ``a`` и ``b`` совпадают.

::

    # Vector2  это тип значения
    var vec2_a = Vector2(0, 0)
    var vec2_b = Vector2(0, 0)
    var vec2_c = Vector2(1, 1)
    is_same(vec2_a, vec2_a)  # true
    is_same(vec2_a, vec2_b)  # true
    is_same(vec2_a, vec2_c)  # false

    # Array это ссылочный тип
    var arr_a = []
    var arr_b = []
    is_same(arr_a, arr_a)  # true
    is_same(arr_a, arr_b)  # false

Это :ref:`Variant<class_Variant>` типы значений: ``null``, :ref:`bool<class_bool>`, :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`String<class_String>`, :ref:`StringName<class_StringName>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`, :ref:`Rect2<class_Rect2>`, :ref:`Rect2i<class_Rect2i>`, :ref:`Transform2D<class_Transform2D>`, :ref:`Transform3D<class_Transform3D>`, :ref:`Plane<class_Plane>`, :ref:`Quaternion<class_Quaternion>`, :ref:`AABB<class_AABB>`, :ref:`Basis<class_Basis>`, :ref:`Projection<class_Projection>`, :ref:`Color<class_Color>`, :ref:`NodePath<class_NodePath>`, :ref:`RID<class_RID>`, :ref:`Callable<class_Callable>` и :ref:`Signal<class_Signal>`.

Это :ref:`Variant<class_Variant>` ссылочный тип: :ref:`Object<class_Object>`, :ref:`Dictionary<class_Dictionary>`, :ref:`Array<class_Array>`, :ref:`PackedByteArray<class_PackedByteArray>`, :ref:`PackedInt32Array<class_PackedInt32Array>`, :ref:`PackedInt64Array<class_PackedInt64Array>`, :ref:`PackedFloat32Array<class_PackedFloat32Array>`, :ref:`PackedFloat64Array<class_PackedFloat64Array>`, :ref:`PackedStringArray<class_PackedStringArray>`, :ref:`PackedVector2Array<class_PackedVector2Array>`, :ref:`PackedVector3Array<class_PackedVector3Array>` и :ref:`PackedColorArray<class_PackedColorArray>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_is_zero_approx:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_zero_approx**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_zero_approx>`

Возвращает ``true``, если ``x`` равен или приблизительно равен нулю. Сравнивается используя расчет допуска с небольшим внутренним эпсилон.

Эта функция работает быстрее, чем использование :ref:`is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` с одним значением, равным нулю.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_lerp:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **lerp**\ (\ from\: :ref:`Variant<class_Variant>`, to\: :ref:`Variant<class_Variant>`, weight\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_lerp>`

Линейно интерполирует между двумя значениями с коэффициентом, определенным в ``weight``. Для выполнения интерполяции ``weight`` должен быть между ``0.0`` и ``1.0`` (включительно). Однако значения за пределами этого диапазона допускаются и могут использоваться для выполнения *экстраполяции*. Если это нежелательно, используйте :ref:`clampf()<class_@GlobalScope_method_clampf>` для ограничения ``weight``.

Оба ``from`` и ``to`` должны быть одного типа. Поддерживаемые типы: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector4<class_Vector4>`, :ref:`Color<class_Color>`, :ref:`Quaternion<class_Quaternion>`, :ref:`Basis<class_Basis>`, :ref:`Transform2D<class_Transform2D>`, :ref:`Transform3D<class_Transform3D>`.

::

    lerp(0, 4, 0.75) # Returns 3.0

См. также :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>`, который выполняет обратную операцию. Чтобы выполнить упрощенную интерполяцию с помощью :ref:`lerp()<class_@GlobalScope_method_lerp>`, объедините его с :ref:`ease()<class_@GlobalScope_method_ease>` или :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`. См. также :ref:`remap()<class_@GlobalScope_method_remap>`, чтобы сопоставить непрерывный ряд значений с другим.

\ **Примечание:** Для лучшей безопасности типов используйте :ref:`lerpf()<class_@GlobalScope_method_lerpf>`, :ref:`Vector2.lerp()<class_Vector2_method_lerp>`, :ref:`Vector3.lerp()<class_Vector3_method_lerp>`, :ref:`Vector4.lerp()<class_Vector4_method_lerp>`, :ref:`Color.lerp()<class_Color_method_lerp>`, :ref:`Quaternion.slerp()<class_Quaternion_method_slerp>`, :ref:`Basis.slerp()<class_Basis_method_slerp>`, :ref:`Transform2D.interpolate_with()<class_Transform2D_method_interpolate_with>` или :ref:`Transform3D.interpolate_with()<class_Transform3D_method_interpolate_with>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_lerp_angle:

.. rst-class:: classref-method

:ref:`float<class_float>` **lerp_angle**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_lerp_angle>`

Линейно интерполирует между двумя углами (в радианах) по значению ``weight`` между 0,0 и 1,0.

Аналогично :ref:`lerp()<class_@GlobalScope_method_lerp>`, но интерполирует правильно, когда углы огибают :ref:`@GDScript.TAU<class_@GDScript_constant_TAU>`. Чтобы выполнить упрощенную интерполяцию с :ref:`lerp_angle()<class_@GlobalScope_method_lerp_angle>`, объедините его с :ref:`ease()<class_@GlobalScope_method_ease>` или :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`.

::

    extends Sprite
    var elapsed = 0.0
    func _process(delta):
        var min_angle = deg_to_rad(0.0)
        var max_angle = deg_to_rad(90.0)
        rotation = lerp_angle(min_angle, max_angle, elapsed)
        elapsed += delta

\ **Примечание:** Эта функция выполняет линейную интерполяцию по кратчайшему пути между ``from`` и ``to``. Однако, когда эти два угла приблизительно ``PI + k * TAU`` друг от друга для любого целого числа ``k``, неочевидно, в какую сторону они выполняют линейную интерполяцию из-за ошибок точности с плавающей точкой. Например, ``lerp_angle(0, PI, weight)`` выполняет линейную интерполяцию против часовой стрелки, тогда как ``lerp_angle(0, PI + 5 * TAU, weight)`` выполняет линейную интерполяцию по часовой стрелке.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_lerpf:

.. rst-class:: classref-method

:ref:`float<class_float>` **lerpf**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_lerpf>`

Линейно интерполирует между двумя значениями с коэффициентом, определенным в ``weight``. Для выполнения интерполяции ``weight`` должен быть между ``0.0`` и ``1.0`` (включительно). Однако значения за пределами этого диапазона допускаются и могут использоваться для выполнения *экстраполяции*. Если это нежелательно, используйте :ref:`clampf()<class_@GlobalScope_method_clampf>` для результата этой функции.

::

    lerpf(0, 4, 0.75) # Returns 3.0

См. также :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>`, который выполняет обратную операцию. Чтобы выполнить облегченную интерполяцию с помощью :ref:`lerp()<class_@GlobalScope_method_lerp>`, объедините его с :ref:`ease()<class_@GlobalScope_method_ease>` или :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_linear_to_db:

.. rst-class:: classref-method

:ref:`float<class_float>` **linear_to_db**\ (\ lin\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_linear_to_db>`

Преобразует линейную энергию в децибелы (аудио). Поскольку громкость обычно нелинейна, это можно использовать для реализации ползунков громкости, которые ведут себя ожидаемым образом.

\ **Пример:** Измените громкость главной шины с помощью узла :ref:`Slider<class_Slider>`, который находится в диапазоне от ``0.0`` до ``1.0``:

::

    AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear_to_db($Slider.value))

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_log:

.. rst-class:: classref-method

:ref:`float<class_float>` **log**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_log>`

Возвращает `натуральный логарифм <https://en.wikipedia.org/wiki/Natural_logarithm>`__ ``x`` (основание `[i]e[/i] <https://en.wikipedia.org/wiki/E_(mathematical_constant)>`__, где *e* приблизительно равно 2,71828). Это количество времени, необходимое для достижения определенного уровня непрерывного роста.

\ **Примечание:** Это не то же самое, что функция "log" на большинстве калькуляторов, которая использует логарифм по основанию 10. Чтобы использовать логарифм по основанию 10, используйте ``log(x) / log(10)``.

::

    log(10) # Returns 2.302585

\ **Примечание:** Логарифм ``0`` возвращает ``-inf``, тогда как отрицательные значения возвращают ``-nan``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_max:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **max**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_max>`

Возвращает наибольшее из указанных числовых значений. Эта функция может принимать любое количество аргументов.

::

    max(1, 7, 3, -6, 5) # Возвращает 7

\ **Примечание:** При использовании этой функции для векторов она *не* вернет максимальный из компонентов, а выберет наибольшее значение, путем сравнения ``x < y ``. Чтобы найти максимальный из компонентов используйте :ref:`Vector2.max()<class_Vector2_method_max>`, :ref:`Vector2i.max()<class_Vector2i_method_max>`, :ref:`Vector3.max()<class_Vector3_method_max>`, :ref:`Vector3i.max()<class_Vector3i_method_max>`, :ref:`Vector4.max()<class_Vector4_method_max>`, and :ref:`Vector4i.max()<class_Vector4i_method_max>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_maxf:

.. rst-class:: classref-method

:ref:`float<class_float>` **maxf**\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_maxf>`

Возвращает максимальное из двух значений :ref:`float<class_float>`.

::

    maxf(3.6, 24) # Возвращает 24.0
    maxf(-3.99, -4) # Возвращает -3.99

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_maxi:

.. rst-class:: classref-method

:ref:`int<class_int>` **maxi**\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_maxi>`

Возвращает максимальное из двух значений :ref:`int<class_int>`.

::

    maxi(1, 2) # Возвращает 2
    maxi(-3, -4) # Возвращает -3

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_min:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **min**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_min>`

Возвращает наименьшее из указанных числовых значений. Эта функция может принимать любое количество аргументов.

::

    min(1, 7, 3, -6, 5) # Возвращает -6

\ **Примечание:** При использовании этой функции для векторов она *не* вернет минимальный из компонентов, а выберет наименьшее значение, путем сравнения ``x < y ``. Чтобы найти минимальный из компонентов используйте :ref:`Vector2.min()<class_Vector2_method_min>`, :ref:`Vector2i.min()<class_Vector2i_method_min>`, :ref:`Vector3.min()<class_Vector3_method_min>`, :ref:`Vector3i.min()<class_Vector3i_method_min>`, :ref:`Vector4.min()<class_Vector4_method_min>`, and :ref:`Vector4i.min()<class_Vector4i_method_min>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_minf:

.. rst-class:: classref-method

:ref:`float<class_float>` **minf**\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_minf>`

Возвращает минимум из двух значений :ref:`float<class_float>`.

::

    minf(3.6, 24) # Возвращает 3.6
    minf(-3.99, -4) # Возвращает -4.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_mini:

.. rst-class:: classref-method

:ref:`int<class_int>` **mini**\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_mini>`

Возвращает минимальное из двух значений :ref:`int<class_int>`.

::

    mini(1, 2) # Возвращает 1
    mini(-3, -4) # Возвращает -4

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_move_toward:

.. rst-class:: classref-method

:ref:`float<class_float>` **move_toward**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_move_toward>`

Перемещает ``from`` в направлении ``to`` на величину ``delta``. Не выйдет за пределы ``to``.

Используйте отрицательное значение ``delta``, чтобы переместиться.

::

    move_toward(5, 10, 4) # Возвращает 9
    move_toward(10, 5, 4) # Возвращает 6
    move_toward(5, 10, 9) # Возвращает 10
    move_toward(10, 5, -1.5) # Возвращает 11.5

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_nearest_po2:

.. rst-class:: classref-method

:ref:`int<class_int>` **nearest_po2**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_nearest_po2>`

Возвращает наименьшую целую степень числа 2, которая больше или равна ``value``.

::

    nearest_po2(3) # Возвращает 4
    nearest_po2(4) # Возвращает 4
    nearest_po2(5) # Возвращает 8

    nearest_po2(0) # Возвращает 0 (может быть неожиданным)
    nearest_po2(-1) # Возвращает 0 (может быть неожиданным)

\ **Предупреждение:** Из-за своей реализации этот метод возвращает ``0`` вместо ``1`` для значений, меньших или равных ``0``, за исключением ``value``, являющегося наименьшим отрицательным 64-битным целым числом (``-9223372036854775808``), в этом случае ``value`` возвращается без изменений.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_pingpong:

.. rst-class:: classref-method

:ref:`float<class_float>` **pingpong**\ (\ value\: :ref:`float<class_float>`, length\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_pingpong>`

Оборачивает ``value`` между ``0`` и ``length``. Если предел достигнут, следующее возвращаемое функцией значение уменьшается до стороны ``0`` или увеличивается до стороны ``length`` (как треугольная волна). Если ``length`` меньше нуля, оно становится положительным.

::

    pingpong(-3.0, 3.0) # Возвращает 3.0
    pingpong(-2.0, 3.0) # Возвращает 2.0
    pingpong(-1.0, 3.0) # Возвращает 1.0
    pingpong(0.0, 3.0) # Возвращает 0.0
    pingpong(1.0, 3.0) # Возвращает 1.0
    pingpong(2.0, 3.0) # Возвращает 2.0
    pingpong(3.0, 3.0) # Возвращает 3.0
    pingpong(4.0, 3.0) # Возвращает 2.0
    pingpong(5.0, 3.0) # Возвращает 1.0
    pingpong(6.0, 3.0) # Возвращает 0.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_posmod:

.. rst-class:: classref-method

:ref:`int<class_int>` **posmod**\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_posmod>`

Возвращает целочисленный модуль ``x``, деленный на ``y``, который одинаково охватывает положительные и отрицательные числа.

::

    print("#(i)  (i % 3)   (posmod(i, 3))")
    for i in range(-3, 4):
        print("%2d       %2d  | %2d" % [i, i % 3, posmod(i, 3)])

Выводит:

.. code:: text

    (i)  (i % 3)   (posmod(i, 3))
    -3        0  |  0
    -2       -2  |  1
    -1       -1  |  2
     0        0  |  0
     1        1  |  1
     2        2  |  2
     3        0  |  0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_pow:

.. rst-class:: classref-method

:ref:`float<class_float>` **pow**\ (\ base\: :ref:`float<class_float>`, exp\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_pow>`

Возвращает результат ``base``, возведенный в степень ``exp``.

В GDScript это эквивалент оператора ``**``.

::

    pow(2, 5) # Возвращает 32.0
    pow(4, 1.5) # Возвращает 8.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_print:

.. rst-class:: classref-method

|void| **print**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_print>`

Преобразует один или несколько аргументов любого типа в строку наилучшим возможным способом и выводит их на консоль.


.. tabs::

 .. code-tab:: gdscript

    var a = [1, 2, 3]
    print("a", "b", a) # Выводит "ab[1, 2, 3]"

 .. code-tab:: csharp

    Godot.Collections.Array a = [1, 2, 3];
    GD.Print("a", "b", a); // Выводит "ab[1, 2, 3]"



\ **Примечание:** Рассмотрите возможность использования :ref:`push_error()<class_@GlobalScope_method_push_error>` и :ref:`push_warning()<class_@GlobalScope_method_push_warning>` для вывода сообщений об ошибках и предупреждений вместо :ref:`print()<class_@GlobalScope_method_print>` или :ref:`print_rich()<class_@GlobalScope_method_print_rich>`. Это отличает их от сообщений печати, используемых для отладки, а также отображает трассировку стека при выводе ошибки или предупреждения. См. также :ref:`Engine.print_to_stdout<class_Engine_property_print_to_stdout>` и :ref:`ProjectSettings.application/run/disable_stdout<class_ProjectSettings_property_application/run/disable_stdout>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_print_rich:

.. rst-class:: classref-method

|void| **print_rich**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_print_rich>`

Преобразует один или несколько аргументов любого типа в строку наилучшим возможным способом и выводит их в консоль.

Поддерживаются следующие теги BBCode: ``b``, ``i``, ``u``, ``s``, ``indent``, ``code``, ``url``, ``center``, ``right``, ``color``, ``bgcolor``, ``fgcolor``.

Теги URL поддерживают только URL, заключенные в тег URL, а не URL с другим заголовком.

При печати в стандартный вывод поддерживаемое подмножество BBCode преобразуется в escape-коды ANSI для отображения эмулятором терминала. Поддержка escape-кодов ANSI различается в разных эмуляторах терминала, особенно для курсива и зачеркивания. В стандартном выводе ``code`` представлен тусклым текстом, но без изменения шрифта. Неподдерживаемые теги остаются как есть в стандартном выводе.


.. tabs::

 .. code-tab:: gdscript

    print_rich("[color=green][b]Hello world![/b][/color]") # Выводит "Hello world!", зеленым цветом жирным шрифтом.

 .. code-tab:: csharp

    GD.PrintRich("[color=green][b]Hello world![/b][/color]"); // Выводит "Hello world!", зеленым цветом жирным шрифтом.



\ **Примечание:** Рассмотрите возможность использования :ref:`push_error()<class_@GlobalScope_method_push_error>` и :ref:`push_warning()<class_@GlobalScope_method_push_warning>` для печати сообщений об ошибках и предупреждений вместо :ref:`print()<class_@GlobalScope_method_print>` или :ref:`print_rich()<class_@GlobalScope_method_print_rich>`. Это отличает их от сообщений печати, используемых в целях отладки, а также отображает трассировку стека при печати ошибки или предупреждения.

\ **Примечание:** Вывод, отображаемый в редакторе, поддерживает кликабельные теги ``[url=address]text[/url]``. Значение ``address`` тега ``[url]`` обрабатывается :ref:`OS.shell_open()<class_OS_method_shell_open>` при клике.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_print_verbose:

.. rst-class:: classref-method

|void| **print_verbose**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_print_verbose>`

Если включен подробный режим (:ref:`OS.is_stdout_verbose()<class_OS_method_is_stdout_verbose>`, возвращающий ``true``), преобразует один или несколько аргументов любого типа в строку наилучшим возможным способом и выводит их на консоль.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_printerr:

.. rst-class:: classref-method

|void| **printerr**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_printerr>`

Выводит один или несколько аргументов в строки наилучшим образом в стандартную строку ошибок.


.. tabs::

 .. code-tab:: gdscript

    printerr("выводит на stderr")

 .. code-tab:: csharp

    GD.PrintErr("выводит на stderr");



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_printraw:

.. rst-class:: classref-method

|void| **printraw**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_printraw>`

Выводит один или несколько аргументов строк наилучшим образом на терминал ОС. В отличие от :ref:`print()<class_@GlobalScope_method_print>`, в конце автоматически не добавляется новая строка.

\ **Примечание:** Терминал ОС *не* то же самое, что и док-станция вывода редактора. Вывод, отправленный на терминал ОС, можно увидеть при запуске Godot из терминала. В Windows для этого требуется использовать исполняемый файл ``console.exe``.


.. tabs::

 .. code-tab:: gdscript

    # Выводит на терминал «ABC».
    printraw("A")
    printraw("B")
    printraw("C")

 .. code-tab:: csharp

    // Выводит на терминал «ABC».
    GD.PrintRaw("A");
    GD.PrintRaw("B");
    GD.PrintRaw("C");



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_prints:

.. rst-class:: classref-method

|void| **prints**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_prints>`

Выводит один или несколько аргументов на консоль с пробелом между каждым аргументом.


.. tabs::

 .. code-tab:: gdscript

    prints("A", "B", "C") # Выводит "A B C"

 .. code-tab:: csharp

    GD.PrintS("A", "B", "C"); // Выводит "A B C"



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_printt:

.. rst-class:: classref-method

|void| **printt**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_printt>`

Выводит на консоль один или несколько аргументов с табуляцией между каждым аргументом.


.. tabs::

 .. code-tab:: gdscript

    printt("A", "B", "C") # Выводит "A       B       C"

 .. code-tab:: csharp

    GD.PrintT("A", "B", "C"); // Выводит "A       B       C"



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_push_error:

.. rst-class:: classref-method

|void| **push_error**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_push_error>`

Отправляет сообщение об ошибке во встроенный отладчик Godot и на терминал ОС.


.. tabs::

 .. code-tab:: gdscript

    push_error("test error") # Выводит "test error" в отладчик и терминал как ошибку.

 .. code-tab:: csharp

    GD.PushError("test error"); // Выводит "test error" в отладчик и терминал как ошибку.



\ **Примечание:** Эта функция не приостанавливает выполнение проекта. Чтобы вывести сообщение об ошибке и приостановить выполнение проекта в отладочных сборках, используйте вместо этого ``assert(false, "test error")``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_push_warning:

.. rst-class:: classref-method

|void| **push_warning**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_push_warning>`

Отправляет предупреждающее сообщение встроенному отладчику Godot и на терминал ОС.


.. tabs::

 .. code-tab:: gdscript

    push_warning("test warning") # Выводит "test warning" на отладчик и терминал как предупреждение.

 .. code-tab:: csharp

    GD.PushWarning("test warning"); // Выводит "test warning" на отладчик и терминал как предупреждение.



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_rad_to_deg:

.. rst-class:: classref-method

:ref:`float<class_float>` **rad_to_deg**\ (\ rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_rad_to_deg>`

Преобразует угол, выраженный в радианах, в градусы.

::

    rad_to_deg(0.523599) # Возвращает 30
    rad_to_deg(PI)       # Возвращает 180
    rad_to_deg(PI * 2)   # Возвращает 360

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_rand_from_seed:

.. rst-class:: classref-method

:ref:`PackedInt64Array<class_PackedInt64Array>` **rand_from_seed**\ (\ seed\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_rand_from_seed>`

При наличии ``seed`` возвращает :ref:`PackedInt64Array<class_PackedInt64Array>` размером ``2``, где его первый элемент — это рандомизированное значение :ref:`int<class_int>`, а второй элемент совпадает с ``seed``. Передача одного и того же ``seed`` последовательно возвращает один и тот же массив.

\ **Примечание:** «Seed» здесь относится к внутреннему состоянию генератора псевдослучайных чисел, в настоящее время реализованного как 64-битное целое число.

::

    var a = rand_from_seed(4)

    print(a[0]) # Выводит 2879024997
    print(a[1]) # Выводит 4

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_randf:

.. rst-class:: classref-method

:ref:`float<class_float>` **randf**\ (\ ) :ref:`🔗<class_@GlobalScope_method_randf>`

Возвращает случайное значение с плавающей точкой между ``0.0`` и ``1.0`` (включительно).


.. tabs::

 .. code-tab:: gdscript

    randf() # Возвращает, например, 0.375671

 .. code-tab:: csharp

    GD.Randf(); // Возвращает, например, 0.375671



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_randf_range:

.. rst-class:: classref-method

:ref:`float<class_float>` **randf_range**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_randf_range>`

Возвращает случайное значение с плавающей точкой между ``from`` и ``to`` (включительно).


.. tabs::

 .. code-tab:: gdscript

    randf_range(0, 20.5) # Возвращает, например, 7.45315
    randf_range(-10, 10) # Возвращает, например, -3.844535

 .. code-tab:: csharp

    GD.RandRange(0.0, 20.5); // Возвращает, например, 7.45315
    GD.RandRange(-10.0, 10.0); // Возвращает, например, -3.844535



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_randfn:

.. rst-class:: classref-method

:ref:`float<class_float>` **randfn**\ (\ mean\: :ref:`float<class_float>`, deviation\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_randfn>`

Возвращает `нормально распределенное <https://en.wikipedia.org/wiki/Normal_distribution>`__, псевдослучайное значение с плавающей точкой из указанного ``mean`` и стандартного ``offset``. Это также известно как распределение Гаусса.

\ **Примечание:** Этот метод использует алгоритм `преобразование Box-Muller <https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform>`__.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_randi:

.. rst-class:: classref-method

:ref:`int<class_int>` **randi**\ (\ ) :ref:`🔗<class_@GlobalScope_method_randi>`

Возвращает случайное беззнаковое 32-битное целое число. Используйте остаток для получения случайного значения в интервале ``[0, N - 1]`` (где N меньше 2^32).


.. tabs::

 .. code-tab:: gdscript

    randi()           #Возвращает случайное целое число от 0 до 2^32 - 1
    randi() % 20      # Возвращает случайное целое число от 0 до 19
    randi() % 100     # Возвращает случайное целое число от 0 до 99
    randi() % 100 + 1 # Возвращает случайное целое число от 1 до 100

 .. code-tab:: csharp

    GD.Randi();           // Возвращает случайное целое число от 0 до 2^32 - 1
    GD.Randi() % 20;      // Возвращает случайное целое число от 0 до 19
    GD.Randi() % 100;     // Возвращает случайное целое число от 0 до 99
    GD.Randi() % 100 + 1; // Возвращает случайное целое число от 1 до 100



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_randi_range:

.. rst-class:: classref-method

:ref:`int<class_int>` **randi_range**\ (\ from\: :ref:`int<class_int>`, to\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_randi_range>`

Возвращает случайное 32-битное целое число со знаком между ``from`` и ``to`` (включительно). Если ``to`` меньше ``from``, они меняются местами.


.. tabs::

 .. code-tab:: gdscript

    randi_range(0, 1)      # Возвращает 0 или 1
    randi_range(-10, 1000) # Возвращает случайное целое число от -10 до 1000

 .. code-tab:: csharp

    GD.RandRange(0, 1);      // Возвращает 0 или 1
    GD.RandRange(-10, 1000); // Возвращает случайное целое число от -10 до 1000



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_randomize:

.. rst-class:: classref-method

|void| **randomize**\ (\ ) :ref:`🔗<class_@GlobalScope_method_randomize>`

Рандомизирует начальное число (или внутреннее состояние) генератора случайных чисел. Текущая реализация использует число, основанное на времени устройства.

\ **Примечание:** Эта функция вызывается автоматически при запуске проекта. Если вам нужно исправить начальное число, чтобы получить последовательные и воспроизводимые результаты, используйте :ref:`seed()<class_@GlobalScope_method_seed>` для инициализации генератора случайных чисел.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_remap:

.. rst-class:: classref-method

:ref:`float<class_float>` **remap**\ (\ value\: :ref:`float<class_float>`, istart\: :ref:`float<class_float>`, istop\: :ref:`float<class_float>`, ostart\: :ref:`float<class_float>`, ostop\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_remap>`

Отображает ``value`` из диапазона ``[istart, istop]`` в ``[ostart, ostop]``. См. также :ref:`lerp()<class_@GlobalScope_method_lerp>` и :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>`. Если ``value`` находится вне ``[istart, istop]``, то результирующее значение также будет вне ``[ostart, ostop]``. Если это нежелательно, используйте :ref:`clamp()<class_@GlobalScope_method_clamp>` для результата этой функции.

::

    remap(75, 0, 100, -1, 1) # Returns 0.5

Для сложных случаев использования, когда требуется несколько диапазонов, рассмотрите возможность использования :ref:`Curve<class_Curve>` или :ref:`Gradient<class_Gradient>`.

\ **Примечание:** Если ``istart == istop``, возвращаемое значение не определено (скорее всего, NaN, INF или -INF).

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_rid_allocate_id:

.. rst-class:: classref-method

:ref:`int<class_int>` **rid_allocate_id**\ (\ ) :ref:`🔗<class_@GlobalScope_method_rid_allocate_id>`

Выделяет уникальный идентификатор, который может использоваться реализацией для построения RID. Это используется в основном из собственных расширений для реализации серверов.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_rid_from_int64:

.. rst-class:: classref-method

:ref:`RID<class_RID>` **rid_from_int64**\ (\ base\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_rid_from_int64>`

Создает RID из ``base``. Используется в основном из собственных расширений для сборки серверов.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_rotate_toward:

.. rst-class:: classref-method

:ref:`float<class_float>` **rotate_toward**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_rotate_toward>`

Поворачивает ``from`` в сторону ``to`` на величину ``delta``. Не пройдет мимо ``to``.

Похож на :ref:`move_toward()<class_@GlobalScope_method_move_toward>`, но интерполирует правильно, когда углы оборачиваются вокруг :ref:`@GDScript.TAU<class_@GDScript_constant_TAU>`.

Если ``delta`` отрицательное значение, эта функция будет поворачиваться от ``to`` к противоположному углу и не будет выходить за пределы противоположного угла.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_round:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **round**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_round>`

Округляет ``x`` до ближайшего целого числа, при этом половинные значения округляются от 0. Поддерживаемые типы: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.

::

    round(2.4) # Возвращает 2
    round(2.5) # Возвращает 3
    round(2.6) # Возвращает 3

См. также :ref:`floor()<class_@GlobalScope_method_floor>`, :ref:`ceil()<class_@GlobalScope_method_ceil>` и :ref:`snapped()<class_@GlobalScope_method_snapped>`.

\ **Примечание:** Для лучшей безопасности типов используйте :ref:`roundf()<class_@GlobalScope_method_roundf>`, :ref:`roundi()<class_@GlobalScope_method_roundi>`, :ref:`Vector2.round()<class_Vector2_method_round>`, :ref:`Vector3.round()<class_Vector3_method_round>` или :ref:`Vector4.round()<class_Vector4_method_round>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_roundf:

.. rst-class:: classref-method

:ref:`float<class_float>` **roundf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_roundf>`

Округляет ``x`` до ближайшего целого числа, при этом средние значения округляются от 0.

Типо-безопасная версия :ref:`round()<class_@GlobalScope_method_round>`, возвращающая :ref:`float<class_float>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_roundi:

.. rst-class:: classref-method

:ref:`int<class_int>` **roundi**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_roundi>`

Округляет ``x`` до ближайшего целого числа, при этом промежуточные значения округляются от 0.

Безопасная версия для типов :ref:`round()<class_@GlobalScope_method_round>`, возвращающая :ref:`int<class_int>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_seed:

.. rst-class:: classref-method

|void| **seed**\ (\ base\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_seed>`

Устанавливает начальное значение для генератора случайных чисел в ``base``. Установка начального числа вручную может обеспечить согласованные и повторяемые результаты для большинства случайных функций.


.. tabs::

 .. code-tab:: gdscript

    var my_seed = "Godot Rocks".hash()
    seed(my_seed)
    var a = randf() + randi()
    seed(my_seed)
    var b = randf() + randi()
    # a и b теперь идентичны

 .. code-tab:: csharp

    ulong mySeed = (ulong)GD.Hash("Godot Rocks");
    GD.Seed(mySeed);
    var a = GD.Randf() + GD.Randi();
    GD.Seed(mySeed);
    var b = GD.Randf() + GD.Randi();
    // a и b теперь идентичны



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_sign:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **sign**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_sign>`

Возвращает тот же тип :ref:`Variant<class_Variant>`, что и ``x``, с ``-1`` для отрицательных значений, ``1`` для положительных значений и ``0`` для нулей. Для значений ``nan`` возвращает 0.

Поддерживаемые типы: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.

::

    sign(-6.0) # Возвращает -1
    sign(0.0)  # Возвращает 0
    sign(6.0)  # Возвращает 1
    sign(NAN)  # Возвращает 0

    sign(Vector3(-6.0, 0.0, 6.0)) # Возвращает (-1, 0, 1)

\ **Примечание:** Для лучшей безопасности типов используйте :ref:`signf()<class_@GlobalScope_method_signf>`, :ref:`signi()<class_@GlobalScope_method_signi>`, :ref:`Vector2.sign()<class_Vector2_method_sign>`, :ref:`Vector2i.sign()<class_Vector2i_method_sign>`, :ref:`Vector3.sign()<class_Vector3_method_sign>`, :ref:`Vector3i.sign()<class_Vector3i_method_sign>`, :ref:`Vector4.sign()<class_Vector4_method_sign>` или :ref:`Vector4i.sign()<class_Vector4i_method_sign>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_signf:

.. rst-class:: classref-method

:ref:`float<class_float>` **signf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_signf>`

Возвращает ``-1.0``, если ``x`` отрицательный, ``1.0``, если ``x`` положительный, и ``0.0``, если ``x`` равен нулю. Для ``nan`` значений ``x`` он возвращает 0.0.

::

    signf(-6.5) # Возвращает -1.0
    signf(0.0)  # Возвращает 0.0
    signf(6.5)  # Возвращает 1.0
    signf(NAN)  # Возвращает 0.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_signi:

.. rst-class:: classref-method

:ref:`int<class_int>` **signi**\ (\ x\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_signi>`

Возвращает ``-1``, если ``x`` отрицательный, ``1``, если ``x`` положительный, и ``0``, если ``x`` равен нулю.

::

    signi(-6) # Возвращает -1
    signi(0)  # Возвращает 0
    signi(6)  # Возвращает 1

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_sin:

.. rst-class:: classref-method

:ref:`float<class_float>` **sin**\ (\ angle_rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_sin>`

Возвращает синус угла ``angle_rad`` в радианах.

::

    sin(0.523599)       # Возвращает 0.5
    sin(deg_to_rad(90)) # Возвращает 1.0

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_sinh:

.. rst-class:: classref-method

:ref:`float<class_float>` **sinh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_sinh>`

Возвращает гиперболический синус ``x``.

::

    var a = log(2.0) # Возвращает 0.693147
    sinh(a) # Возвращает 0.75

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_smoothstep:

.. rst-class:: classref-method

:ref:`float<class_float>` **smoothstep**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_smoothstep>`

Возвращает гладкую кубическую интерполяцию Эрмита между ``0`` и ``1``.

Для положительных диапазонов (когда ``from <= to``) возвращаемое значение равно ``0``, когда ``x <= from``, и ``1``, когда ``x >= to``. Если ``x`` лежит между ``from`` и ``to``, возвращаемое значение следует S-образной кривой, которая плавно переходит от ``0`` к ``1``.

Для отрицательных диапазонов (когда ``from > to``) функция зеркально отражается и возвращает ``1``, когда ``x <= to`` и ``0``, когда ``x >= from``.

Эта S-образная кривая представляет собой кубический интерполятор Эрмита, заданный как ``f(y) = 3*y^2 - 2*y^3``, где ``y = (x-from) / (to-from)``.

::

    smoothstep(0, 2, -5.0) # Returns 0.0
    smoothstep(0, 2, 0.5) # Returns 0.15625
    smoothstep(0, 2, 1.0) # Returns 0.5
    smoothstep(0, 2, 2.0) # Returns 1.0

По сравнению с :ref:`ease()<class_@GlobalScope_method_ease>` со значением кривой ``-1.6521``, :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>` возвращает максимально гладкую кривую без резких изменений в производной. Если вам нужно выполнить более сложные переходы, используйте :ref:`Tween<class_Tween>` или :ref:`AnimationPlayer<class_AnimationPlayer>`.

\ `Сравнение возвращаемых значений smoothstep() и ease(x, -1.6521) <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/smoothstep_ease_comparison.png>`__\ 

\ `Smoothstep() возвращает значения с положительным, нулевым и отрицательным диапазонами <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/smoothstep_range.webp>`__

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_snapped:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **snapped**\ (\ x\: :ref:`Variant<class_Variant>`, step\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_snapped>`

Возвращает кратное ``step``, которое ближе всего к ``x``. Это также можно использовать для округления числа с плавающей точкой до произвольного количества десятичных знаков.

Возвращаемое значение имеет тот же тип :ref:`Variant<class_Variant>`, что и ``step``. Поддерживаемые типы: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.

::

    snapped(100, 32)  # Returns 96
    snapped(3.14159, 0.01)  # Returns 3.14

    snapped(Vector2(34, 70), Vector2(8, 8))  # Returns (32, 72)

См. также :ref:`ceil()<class_@GlobalScope_method_ceil>`, :ref:`floor()<class_@GlobalScope_method_floor>` и :ref:`round()<class_@GlobalScope_method_round>`.

\ **Примечание:** Для лучшей безопасности типов используйте :ref:`snappedf()<class_@GlobalScope_method_snappedf>`, :ref:`snappedi()<class_@GlobalScope_method_snappedi>`, :ref:`Vector2.snapped()<class_Vector2_method_snapped>`, :ref:`Vector2i.snapped()<class_Vector2i_method_snapped>`, :ref:`Vector3.snapped()<class_Vector3_method_snapped>`, :ref:`Vector3i.snapped()<class_Vector3i_method_snapped>`, :ref:`Vector4.snapped()<class_Vector4_method_snapped>`, или :ref:`Vector4i.snapped()<class_Vector4i_method_snapped>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_snappedf:

.. rst-class:: classref-method

:ref:`float<class_float>` **snappedf**\ (\ x\: :ref:`float<class_float>`, step\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_snappedf>`

Возвращает кратное ``step``, которое ближе всего к ``x``. Это также можно использовать для округления числа с плавающей точкой до произвольного количества десятичных знаков.

Типобезопасная (type-safe) версия :ref:`snapped()<class_@GlobalScope_method_snapped>`, возвращающая :ref:`float<class_float>`.

::

    snappedf(32.0, 2.5)  # Returns 32.5
    snappedf(3.14159, 0.01)  # Returns 3.14

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_snappedi:

.. rst-class:: classref-method

:ref:`int<class_int>` **snappedi**\ (\ x\: :ref:`float<class_float>`, step\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_snappedi>`

Возвращает кратное ``step``, которое ближе всего к ``x``.

Типобезопасная версия :ref:`snapped()<class_@GlobalScope_method_snapped>`, возвращающая :ref:`int<class_int>`.

::

    snappedi(53, 16)  # Returns 48
    snappedi(4096, 100)  # Returns 4100

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_sqrt:

.. rst-class:: classref-method

:ref:`float<class_float>` **sqrt**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_sqrt>`

Возвращает квадратный корень из ``x``, где ``x`` — неотрицательное число.

::

    sqrt(9)     # Returns 3
    sqrt(10.24) # Returns 3.2
    sqrt(-1)    # Returns NaN

\ **Примечание:** Отрицательные значения ``x`` возвращают NaN («Not a Number»). В C#, если вам нужны отрицательные входные данные, используйте ``System.Numerics.Complex``.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_step_decimals:

.. rst-class:: classref-method

:ref:`int<class_int>` **step_decimals**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_step_decimals>`

Возвращает позицию первой ненулевой цифры после десятичной точки. Обратите внимание, что максимальное возвращаемое значение равно 10, что является проектным решением в реализации.

::

    var n = step_decimals(5)       # n равен 0
    n = step_decimals(1.0005)      # n равен 4
    n = step_decimals(0.000000005) # n равен 9

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_str:

.. rst-class:: classref-method

:ref:`String<class_String>` **str**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_str>`

Преобразует один или несколько аргументов любого типа :ref:`Variant<class_Variant>` в :ref:`String<class_String>` наилучшим возможным способом.

::

    var a = [10, 20, 30]
    var b = str(a)
    print(len(a)) # Выводит 3 (количество элементов в массиве).
    print(len(b)) # Выводит 12 (длина строки "[10, 20, 30]").

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_str_to_var:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **str_to_var**\ (\ string\: :ref:`String<class_String>`\ ) :ref:`🔗<class_@GlobalScope_method_str_to_var>`

Преобразует отформатированную ``string``, возвращенную :ref:`var_to_str()<class_@GlobalScope_method_var_to_str>`, в исходный :ref:`Variant<class_Variant>`.


.. tabs::

 .. code-tab:: gdscript

    var data = '{ "a": 1, "b": 2 }' # data — это String (строка)
    var dict = str_to_var(data)     # dict — это Dictionary (словарь)
    print(dict["a"])                # Выводит 1

 .. code-tab:: csharp

    string data = "{ \"a\": 1, \"b\": 2 }";           // data — это string
    var dict = GD.StrToVar(data).AsGodotDictionary(); // dict — это Dictionary
    GD.Print(dict["a"]);                              // Выводит 1



.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_tan:

.. rst-class:: classref-method

:ref:`float<class_float>` **tan**\ (\ angle_rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_tan>`

Возвращает тангенс угла ``angle_rad`` в радианах.

::

    tan(deg_to_rad(45)) # Returns 1

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_tanh:

.. rst-class:: classref-method

:ref:`float<class_float>` **tanh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_tanh>`

Возвращает гиперболический тангенс ``x``.

::

    var a = log(2.0) # Returns 0.693147
    tanh(a)          # Returns 0.6

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_type_convert:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **type_convert**\ (\ variant\: :ref:`Variant<class_Variant>`, type\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_type_convert>`

Преобразует заданный ``variant`` в заданный ``type``, используя значения :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`. Этот метод щедро обрабатывает типы: он может автоматически преобразовывать типы массивов, преобразовывать числовые значения :ref:`String<class_String>` в :ref:`int<class_int>` и преобразовывать большинство объектов в :ref:`String<class_String>`.

Если преобразование типа невозможно выполнить, этот метод вернет значение по умолчанию для этого типа, например, преобразование :ref:`Rect2<class_Rect2>` в :ref:`Vector2<class_Vector2>` всегда будет возвращать :ref:`Vector2.ZERO<class_Vector2_constant_ZERO>`. Этот метод никогда не будет отображать сообщения об ошибках, пока ``type`` является допустимым типом варианта.

Возвращаемое значение — :ref:`Variant<class_Variant>`, но данные внутри и их тип будут такими же, как запрошенный тип.

::

    type_convert("Hi!", TYPE_INT) # Возвращает 0
    type_convert("123", TYPE_INT) # Возвращает 123
    type_convert(123.4, TYPE_INT) # Возвращает 123
    type_convert(5, TYPE_VECTOR2) # Returns (0, 0)
    type_convert("Hi!", TYPE_NIL) # Возвращает null

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_type_string:

.. rst-class:: classref-method

:ref:`String<class_String>` **type_string**\ (\ type\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_type_string>`

Возвращает понятное человеку имя указанного ``type``, используя значения :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.

::

    print(TYPE_INT) # Выводит 2
    print(type_string(TYPE_INT)) # Выводит "int"
    print(type_string(TYPE_STRING)) # Выводит "String"

Смотрите также :ref:`typeof()<class_@GlobalScope_method_typeof>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_typeof:

.. rst-class:: classref-method

:ref:`int<class_int>` **typeof**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_typeof>`

Returns the internal type of the given ``variable``, using the :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` values.

::

    var json = JSON.new()
    json.parse('["a", "b", "c"]')
    var result = json.get_data()
    if typeof(result) == TYPE_ARRAY:
        print(result[0]) # Prints "a"
    else:
        print("Unexpected result!")

See also :ref:`type_string()<class_@GlobalScope_method_type_string>`.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_var_to_bytes:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **var_to_bytes**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_var_to_bytes>`

Кодирует значение :ref:`Variant<class_Variant>` в массив байтов без кодирования объектов. Десериализацию можно выполнить с помощью :ref:`bytes_to_var()<class_@GlobalScope_method_bytes_to_var>`.

\ **Примечание:** Если вам нужна сериализация объектов, см. :ref:`var_to_bytes_with_objects()<class_@GlobalScope_method_var_to_bytes_with_objects>`.

\ **Примечание:** Кодировка :ref:`Callable<class_Callable>` не поддерживается и приведет к пустому значению независимо от данных.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_var_to_bytes_with_objects:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **var_to_bytes_with_objects**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_var_to_bytes_with_objects>`

Кодирует значение :ref:`Variant<class_Variant>` в массив байтов. Кодирование объектов разрешено (и может потенциально включать исполняемый код). Десериализацию можно выполнить с помощью :ref:`bytes_to_var_with_objects()<class_@GlobalScope_method_bytes_to_var_with_objects>`.

\ **Примечание:** Кодирование :ref:`Callable<class_Callable>` не поддерживается и приведет к пустому значению независимо от данных.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_var_to_str:

.. rst-class:: classref-method

:ref:`String<class_String>` **var_to_str**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_var_to_str>`

Преобразует :ref:`Variant<class_Variant>` ``variable`` в форматированную :ref:`String<class_String>`, которую затем можно проанализировать с помощью :ref:`str_to_var()<class_@GlobalScope_method_str_to_var>`.


.. tabs::

 .. code-tab:: gdscript

    var a = { "a": 1, "b": 2 }
    print(var_to_str(a))

 .. code-tab:: csharp

    var a = new Godot.Collections.Dictionary { ["a"] = 1, ["b"] = 2 };
    GD.Print(GD.VarToStr(a));



Prints:

.. code:: text

    {
        "a": 1,
        "b": 2
    }

\ **Примечание:** Преобразование :ref:`Signal<class_Signal>` или :ref:`Callable<class_Callable>` не поддерживается и приведет к пустому значению для этих типов, независимо от их данных.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_weakref:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **weakref**\ (\ obj\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_weakref>`

Возвращает экземпляр :ref:`WeakRef<class_WeakRef>`, содержащий слабую ссылку на ``obj``. Возвращает пустой экземпляр :ref:`WeakRef<class_WeakRef>`, если ``obj`` равен ``null``. Выводит ошибку и возвращает ``null``, если ``obj`` не является ни :ref:`Object<class_Object>`-производным, ни ``null``.

Слабой ссылки на объект недостаточно, чтобы сохранить объект живым: когда единственные оставшиеся ссылки на референт являются слабыми ссылками, сборка мусора может свободно уничтожить референт и повторно использовать его память для чего-то другого. Однако, пока объект фактически не уничтожен, слабая ссылка может вернуть объект, даже если на него нет сильных ссылок.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_wrap:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **wrap**\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_wrap>`

Заключает :ref:`Variant<class_Variant>` ``value`` между ``min`` и ``max``. ``min`` — *включительно*, а ``max`` — *исключительно*. Это можно использовать для создания циклов или бесконечных поверхностей.

Поддерживаются типы вариантов :ref:`int<class_int>` и :ref:`float<class_float>`. Если какой-либо из аргументов — :ref:`float<class_float>`, функция возвращает :ref:`float<class_float>`, в противном случае — :ref:`int<class_int>`.

::

    var a = wrap(4, 5, 10)
    # a это 9 (int)

    var a = wrap(7, 5, 10)
    # a это 7 (int)

    var a = wrap(10.5, 5, 10)
    # a это 5.5 (float)

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_wrapf:

.. rst-class:: classref-method

:ref:`float<class_float>` **wrapf**\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_wrapf>`

Заключает число с плавающей точкой ``value`` между ``min`` и ``max``. Значение ``min`` *включительно*, а значение ``max`` *исключительно*. Это можно использовать для создания циклов или бесконечных поверхностей.

::

    # Бесконечный цикл между 5.0 и 9.9
    value = wrapf(value + 0.1, 5.0, 10.0)

::

    # Бесконечное вращение (в радианах)
    angle = wrapf(angle + 0.1, 0.0, TAU)

::

    # Бесконечное вращение (в радианах)
    angle = wrapf(angle + 0.1, -PI, PI)

\ **Примечание:** Если ``min`` равен ``0``, это эквивалентно :ref:`fposmod()<class_@GlobalScope_method_fposmod>`, поэтому предпочтительнее использовать его. :ref:`wrapf()<class_@GlobalScope_method_wrapf>` более гибок, чем подход с :ref:`fposmod()<class_@GlobalScope_method_fposmod>`, поскольку предоставляет пользователю контроль над минимальным значением.

.. rst-class:: classref-item-separator

----

.. _class_@GlobalScope_method_wrapi:

.. rst-class:: classref-method

:ref:`int<class_int>` **wrapi**\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_wrapi>`

Заключает целое число ``value`` между ``min`` и ``max``. Значение ``min`` *включительно*, а значение ``max`` *исключительно*. Это можно использовать для создания циклов или бесконечных поверхностей.

::

    # Бесконечный цикл между 5 и 9
    frame = wrapi(frame + 1, 5, 10)

::

    # result это -2
    var result = wrapi(-6, -5, -1)

.. |virtual| replace:: :abbr:`virtual (Этот метод обычно должен быть переопределен пользователем, чтобы иметь какой-либо эффект.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Этот метод не имеет побочных эффектов. Он не изменяет ни одну из переменных-членов экземпляра.)`
.. |vararg| replace:: :abbr:`vararg (Этот метод принимает любое количество аргументов после описанных здесь.)`
.. |constructor| replace:: :abbr:`constructor (Этот метод используется для создания типа.)`
.. |static| replace:: :abbr:`static (Этот метод не нуждается в вызове экземпляра, поэтому его можно вызвать напрямую, используя имя класса.)`
.. |operator| replace:: :abbr:`operator (Этот метод описывает допустимый оператор для использования с этим типом в качестве левого операнда.)`
.. |bitfield| replace:: :abbr:`BitField (Это значение является целым числом, составленным как битовая маска следующих флагов.)`
.. |void| replace:: :abbr:`void (Нет возвращаемого значения.)`