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

7627 lines
380 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

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

:github_url: hide
.. _class_@GlobalScope:
@GlobalScope
============
Глобальні константи та функції.
.. rst-class:: classref-introduction-group
Опис
--------
Список глобальних констант із переліком і вбудованих функцій. Це все, що міститься в глобалах, константах щодо кодів помилок, кодів клавіш, підказок властивостей тощо.
Синглтони також задокументовані тут, оскільки до них можна отримати доступ з будь-якого місця.
Для записів, доступ до яких можна отримати лише зі сценаріїв, написаних у GDScript, див. :ref:`@GDScript<class_@GDScript>`.
.. note::
Існують значні відмінності при використанні цього API із С#. Більше інформації: 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, і Y в останню чергу.
.. _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``
Клавіша Enter на цифровій клавіатурі.
.. _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``
Клавіша Help.
.. _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``
Клавіша швидкого запуску С.
.. _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``
Клавіша швидкого запуску Е.
.. _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``
Клавіша "Globe" на клавіатурі 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``
Цифровий знак або клавіша *hash* (``#``).
.. _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``
Знак (``@``) ключ.
.. _class_@GlobalScope_constant_KEY_A:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_A** = ``65``
Клавіша А.
.. _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``
Клавіша Е.
.. _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``
Клавіша І.
.. _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``
Клавіша К.
.. _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``
Клавіша О.
.. _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``
Клавіша Т.
.. _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``
Клавіша зворотної косої риски (``\``).
.. _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``
Клавіша вертикальної смуги або *трубки* (``|``).
.. _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``
Маска клавіші Alt або Option (на macOS).
.. _class_@GlobalScope_constant_KEY_MASK_META:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_META** = ``134217728``
Маска клавіші Command (on macOS) або Meta/Windows.
.. _class_@GlobalScope_constant_KEY_MASK_CTRL:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_CTRL** = ``268435456``
Маска клавіші Control.
.. _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``
Маска клавіші Group Switch.
.. 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``
Кнопка A ігрового контролера SDL. Відповідає дії нижньої кнопки: Sony Cross, Xbox A, Nintendo B.
.. _class_@GlobalScope_constant_JOY_BUTTON_B:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_B** = ``1``
Кнопка В ігрового контролера SDL. Відповідає дії правої кнопки: Sony Circle, Xbox В, Nintendo А.
.. _class_@GlobalScope_constant_JOY_BUTTON_X:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_X** = ``2``
Кнопка Х ігрового контролера SDL. Відповідає дії лівої кнопки: Sony Square, Xbox Х, Nintendo Y.
.. _class_@GlobalScope_constant_JOY_BUTTON_Y:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_Y** = ``3``
Кнопка Y ігрового контролера SDL. Відповідає дії верхньої кнопки: Sony Triangle, Xbox Y, Nintendo X.
.. _class_@GlobalScope_constant_JOY_BUTTON_BACK:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_BACK** = ``4``
Кнопка назад Ігрового контролера SDL . Відповідає кнопці Sony Select, Xbox Back, 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. Відповідає кнопці Sony L3, Xbox L/LS.
.. _class_@GlobalScope_constant_JOY_BUTTON_RIGHT_STICK:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_RIGHT_STICK** = ``8``
Права кнопка-джойстик ігрового контролера SDL. Відповідає кнопці Sony R3, Xbox R/RS.
.. _class_@GlobalScope_constant_JOY_BUTTON_LEFT_SHOULDER:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_LEFT_SHOULDER** = ``9``
Ігровий контролер SDL з лівою плечовою кнопкою. Відповідає кнопці Sony L1, Xbox LB.
.. _class_@GlobalScope_constant_JOY_BUTTON_RIGHT_SHOULDER:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_RIGHT_SHOULDER** = ``10``
Ігровий контролер SDL на праву плечову кнопку. Відповідає кнопці Sony R1, Xbox RB.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_UP:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_UP** = ``11``
Кнопка вгору D-pad ігрового контролера.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_DOWN:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_DOWN** = ``12``
Кнопка вниз D-pad ігрового контролера.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_LEFT** = ``13``
Кнопка вліво D-pad ігрового контролера.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_RIGHT** = ``14``
Кнопка вправо D-pad ігрового контролера.
.. _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``
Вісь-х лівого джойстика ігрового контролера.
.. _class_@GlobalScope_constant_JOY_AXIS_LEFT_Y:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_LEFT_Y** = ``1``
Вісь-у лівого джойстика ігрового контролера.
.. _class_@GlobalScope_constant_JOY_AXIS_RIGHT_X:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_RIGHT_X** = ``2``
Вісь-х правого джойстика ігрового контролера.
.. _class_@GlobalScope_constant_JOY_AXIS_RIGHT_Y:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_RIGHT_Y** = ``3``
Вісь-у правого джойстика ігрового контролера.
.. _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-повідомлення, яке надсилається для позначення зміни тиску під час натискання ноти, також називається післядотиком.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_CONTROL_CHANGE:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_CONTROL_CHANGE** = ``11``
MIDI-повідомлення, що надсилається, коли змінюється значення контролера. У MIDI-пристрої контролер — це будь-який вхід, який не відтворює ноти. Це можуть бути повзунки для гучності, балансу та панорамування, а також перемикачі та педалі. Перегляньте `загальну специфікацію MIDI <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("Невдача!")
# Або ж:
if error:
printerr("Все ще не вдається!")
\ **Примітка:** Багато функцій не повертають код помилки, але виводять повідомлення про помилки на стандартний вивід.
.. _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``
Помилка Out of memory (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``
Помилка файлу: Кінець файлу (End of file (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``
Підказує, що значенням властивості є об’єкт, закодований як ідентифікатор об’єкта, тип якого вказано в рядку підказки. Використовується налагоджувачем.
.. _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:Нуль,Один,Два" % [TYPE_INT, PROPERTY_HINT_ENUM] # Масив цілих чисел (перелік).
hint_string = "%d/%d:Нуль,Один,Три:3,Шість:6" % [TYPE_INT, PROPERTY_HINT_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] # Двовимірний масив чисел з плаваючою комою.
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"; // Масив цілих чисел (перелік).
hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Three:3,Six:6"; // Масив цілих чисел (перелік).
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!,ColorRect" - кнопка з текстом "Click me!" і піктограму «ColorRect».
\ **Примітка: ** :ref:`Callable<class_Callable>` не можна правильно серіалізувати та зберегти у файлі, тому рекомендується використовувати :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``.
.. _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``.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_HIGH_END_GFX:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_HIGH_END_GFX** = ``2097152``
Властивість відображається у редакторі лише за умови підтримки сучасних рендерингів (метод рендерингу Compatibility виключено).
.. _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``
Властивість доступна лише для читання в :ref:`EditorInspector<class_EditorInspector>`.
.. _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``
Змінна має тип :ref:`Projection<class_Projection>`.
.. _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``
Оператор піднесення до степеня (``**``).
.. _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``
Оператор бітового І (AND) (``&``).
.. _class_@GlobalScope_constant_OP_BIT_OR:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_OR** = ``17``
Оператор бітового АБО (OR) (``|``).
.. _class_@GlobalScope_constant_OP_BIT_XOR:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_XOR** = ``18``
Оператор Виключної диз'юкції (XOR) (``^``).
.. _class_@GlobalScope_constant_OP_BIT_NEGATE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_NEGATE** = ``19``
Оператор бітового НЕ (NOT) (``~``).
.. _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 is 1
var b = abs(-1.2)
# b is 1.2
var c = abs(Vector2(-3.5, -4))
# c is (3.5, 4)
var d = abs(Vector2i(-5, -6))
# d is (5, 6)
var e = abs(Vector3(-7, 8.5, -3.8))
# e is (7, 8.5, 3.8)
var f = abs(Vector3i(-7, -8, -9))
# f is (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>`
Повертає абсолютне значення десяткового параметру ``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>`
Повертає абсолютне значення цілого параметру ``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) # Retruns 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]``. Коли ``from`` і ``to`` протилежні, повертає ``-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_constant_INF>`, щоб запобігти :ref:`atanh()<class_@GlobalScope_method_atanh>` повертати :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
::
var a = atanh(0,9) # Returns 1,47221948958322
tanh(a) # Returns 0,9
var b = atanh(-2) # Returns -inf
tanh(b) # Returns -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://uk.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0_%D0%91%D0%B5%D0%B7%D1%8C%D1%94>`__ визначеній за заданими точками ``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://uk.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0_%D0%91%D0%B5%D0%B7%D1%8C%D1%94>`__ визначеній заданими точками ``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
змінна 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`` або `` param 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 is20.5
speed = -10.0
var b = clampf(speed, -1.0, 1.0) # b is -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 is 20
speed = -10
var b = clampi(speed, -1, 1) # b is -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) # Returns 1.0
cos(PI) # Returns -1.0
cos(deg_to_rad(90)) # Returns 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)) # Prints 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>`
Cubic інтерполює між двома значеннями обертання з найкоротшим шляхом за коефіцієнтом, визначеним у ``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>`
Перетворює кут виражений в градусах в радіани.
::
var r = deg_to_rad(180) # r is 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
- Нижче за -1.0 (виключно): Ease in-out
- -1.0: Linear
- Між -1.0 та 0.0 (виключно): Ease out-in
- 0.0: Constant
- Між 0.0 та 1.0 (виключно): Ease out
- 1.0: Linear
- Більше від 1.0 (виключно): 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)) # Виводить "ОК"
print(error_string(ERR_BUSY)) # Виводить "Зайнято"
print(error_string(ERR_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)``.
Для піднесення до степеня інших основ степеней використовуйте метод :ref:`pow()<class_@GlobalScope_method_pow>`.
::
var a = exp(2) # Approximately 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:`Vector3<class_Vector3>`, :ref:`Vector4<class_Vector4>`.
::
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) # remainder 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 in7:
var x = i * 0,5 - 1,5
print("%4.1f %4.1f | %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])
Принти:
.. 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")) # Prints 177670
.. code-tab:: csharp
GD.Print(GD.Hash("a")); // Prints 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)
# middle тепер дорівнює 27.5.
# Тепер вдаємо, що забули початкове співвідношення і хочемо його повернути.
var ratio = inverse_lerp(20, 30, 27.5)
# ratio тепер дорівнює 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`` дорівнює або додатній, або від'ємній нескінченності.
.. 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 ("не число" або недійсне). Цей метод потрібен, оскільки :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
# Масив є довідковим типом
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:`PackedStringArray<class_PackedStringArray>`, :ref:`PackedVector2Array<class_PackedVector2Array>`, :ref:`PackedVector3Array<class_PackedVector3Array>`, :ref:`PackedVector4Array<class_PackedVector4Array>` і :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://uk.wikipedia.org/wiki/%D0%9D%D0%B0%D1%82%D1%83%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%B8%D0%B9_%D0%BB%D0%BE%D0%B3%D0%B0%D1%80%D0%B8%D1%84%D0%BC>`__ від ``x`` (з основою `[i]e[/i] <https://uk.wikipedia.org/wiki/E_(%D1%87%D0%B8%D1%81%D0%BB%D0%BE)>`__, де *e* дорівнює приблизно 2.71828). Це кількість часу, необхідна для досягнення певного рівня безперервного зростання.
\ **Примітка:** Це не те саме, що функція "log" на більшості калькуляторів, яка використовує логарифм з основою 10. Щоб використовувати логарифм з основою 10, використовуйте ``log(x) / log(10)``.
::
log(10) # Поверне 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>`
Повертає максимальне із заданих числових значень. Ця функція може приймати будь-яку кількість аргументів.
.. tabs::
max(1, 7, 3, -6, 5) # Returns 7
::
[b]Примітка:[/b] Якщо це використовувати для векторів, це [i]не[/i] буде виконувати максимум компонентів, а вибиратиме найбільше значення під час порівняння за допомогою [code]x < y[/code]. Щоб виконати максимум компонентів, використовуйте [method Vector2.max], [method Vector2i.max], [method Vector3.max], [method Vector3i.max], [method Vector4.max] і [method Vector4i.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) # Returns 24.0
maxf(-3.99, -4) # Returns -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) # Returns 2
maxi(-3, -4) # Returns -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) # Returns -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>` і :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) # Returns 3.6
minf(-3.99, -4) # Returns -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) # Returns 1
mini(-3, -4) # Returns -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) # Returns 9
move_toward(10, 5, 4) # Returns 6
move_toward(5, 10, 9) # Returns 10
move_toward(10, 5, -1.5) # Returns 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 param``.\ **
::
nearest_po2(3) # Returns 4
nearest_po2(4) # Returns 4
nearest_po2(5) # Returns 8
nearest_po2(0) # Returns 0 (це може бути неочікувано)
nearest_po2(-1) # Returns 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) # Returns 3.0
pingpong(-2.0, 3.0) # Returns 2.0
pingpong(-1.0, 3.0) # Returns 1.0
pingpong(0.0, 3.0) # Returns 0.0
pingpong(1.0, 3.0) # Returns 1.0
pingpong(2.0, 3.0) # Returns 2.0
pingpong(3.0, 3.0) # Returns 3.0
pingpong(4.0, 3.0) # Returns 2.0
pingpong(5.0, 3.0) # Returns 1.0
pingpong(6.0, 3.0) # Returns 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) # Returns 32.0
pow(4, 1.5) # Returns 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 перетворюється на ANSI-кодові екранування для відображення в емуляторі терміналу. Підтримка ANSI-кодових екранування відрізняється залежно від емулятора терміналу, особливо для курсиву та закреслення. У стандартному виводі ``code`` представлено тьмяним текстом, але без зміни шрифту. Непідтримувані теги залишаються як є у стандартному виводі.
.. tabs::
.. code-tab:: gdscript
print_rich("[color=green][b]Привіт, світе![/b][/color]") # Виводить "Привіт, світе!" зеленим шрифтом жирним шрифтом.
.. code-tab:: csharp
GD.PrintRich("[color=green][b]Привіт, світе![/b][/color]"); // Виводить "Привіт, світе!" зеленим шрифтом жирним шрифтом.
\ **Примітка:** Рекомендується використовувати :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=адреса]текст[/url]``. Значення тегу ``адреса`` ``[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("prints to stderr")
.. code-tab:: csharp
GD.PrintErr("prints to 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
printraw("A")
printraw("B")
printraw("C")
# Друкує ABC на терміналі
.. code-tab:: csharp
GD.PrintRaw("A");
GD.PrintRaw("B");
GD.PrintRaw("C");
// Друкує ABC на термінал
.. 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") # Prints A B C
.. code-tab:: csharp
GD.PrintS("A", "B", "C"); // Prints 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") # Prints A B C
.. code-tab:: csharp
GD.PrintT("A", "B", "C"); // Prints 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) # Returns 30
rad_to_deg(PI) # Returns 180
rad_to_deg(PI * 2) # Returns 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]) # Prints 2879024997
print(a[1]) # Prints 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() # Returns e.g. 0,375671
.. code-tab:: csharp
GD.Randf(); // Returns e.g. 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) # Returns e.g. 7,45315
randf_range(-10, 10) # Returns e.g. -3,844535
.. code-tab:: csharp
GD.RandRange(0,0, 20,5); // Returns e.g. 7,45315
GD.RandRange(-10,0, 10,0); // Returns e.g. -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://uk.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B8%D0%B9_%D1%80%D0%BE%D0%B7%D0%BF%D0%BE%D0%B4%D1%96%D0%BB>`__ псевдовипадкове значення з рухомою комою від указаного ``mean`` і стандартного ``deviation``. Це також відоме як розподіл Гауса.
\ **Примітка:** Цей метод використовує алгоритм `перетворення Box-Muller <https://uk.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D1%82%D0%B2%D0%BE%D1%80%D0%B5%D0%BD%D0%BD%D1%8F_%D0%91%D0%BE%D0%BA%D1%81%D0%B0-%D0%9C%D1%8E%D0%BB%D0%BB%D0%B5%D1%80%D0%B0>`__.
.. 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) # Returns 2
round(2.5) # Returns 3
round(2.6) # Returns 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) # Returns -1
sign(0.0) # Returns 0
sign(6.0) # Returns 1
sign(NAN) # Returns 0
sign(Vector3(-6.0, 0.0, 6.0)) # Returns (-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) # Returns -1.0
signf(0.0) # Returns 0.0
signf(6.5) # Returns 1.0
signf(NAN) # Returns 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) # Returns -1
signi(0) # Returns 0
signi(6) # Returns 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) # Returns 0.5
sin(deg_to_rad(90)) # Returns 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) # Returns 0.693147
sinh(a) # Returns 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``.
Для позитивних діапазонів (коли ``від <= до``) повертається значення ``0``, коли ``x <= from``, і ``1``, коли ``x >= to``. Якщо ``x`` знаходиться між ``from`` і ``to``, значення, що повертається, слідує S-подібній кривій, яка плавно переходить від ``0`` до ``1``.
Для від’ємних діапазонів (коли ``від > до``) функція відображається і повертає ``1``, коли ``x <= to``, і ``0``, коли ``x >= from``.
Ця S-подібна крива є кубічним інтерполятором Ерміта, що визначається як ``f(y) = 3*y^2 - 2*y^3``, де ``y = (x-від) / (до-від)``.
::
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``. Це також можна використовувати для округлення числа з плаваючою комою до довільної кількості десяткових знаків.
Типобезпечна версія :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 is 0
n = step_decimals(1.0005) # n is 4
n = step_decimals(0.000000005) # n is 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)) # Повертає 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) # Повертає 0.693147
tanh(a) # Повертає 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`` є дійсним типом Variant.
Поверненим значенням є :ref:`Variant<class_Variant>`, але дані всередині та їх тип будуть такими самими, як запитуваний тип.
::
type_convert("Привіт!", TYPE_INT) # Повертає 0
type_convert("123", TYPE_INT) # Повертає 123
type_convert(123.4, TYPE_INT) # Повертає 123
type_convert(5, TYPE_VECTOR2) # Повертає (0, 0)
type_convert("Привіт!", 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>`
Повертає зрозумілу людині назву заданого ``типу параметра``, використовуючи значення :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.
::
print(TYPE_INT) # Друкує 2.
print(type_string(TYPE_INT)) # Виводить "int".
print(type_string(TYPE_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));
Принти:
.. code:: text
{
"а": 1,
"б": 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 is 9 (int)
var a = wrap(7, 5, 10)
# a is 7 (int)
var a = wrap(10.5, 5, 10)
# a is 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)
::
# результат -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 (Значення не повертається.)`
Reference in New Issue View Git Blame Copy Permalink