godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/ru/class_input.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

1248 lines
107 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_Input:
Input
=====
**Наследует:** :ref:`Object<class_Object>`
Синглтон для обработки входных данных.
.. rst-class:: classref-introduction-group
Описание
----------------
Синглтон **Input** обрабатывает нажатия клавиш, кнопки мыши и движение, геймпады и действия ввода. Действия и их события можно задать на вкладке **Input Map** в **Project > Project Settings** или с помощью класса :ref:`InputMap<class_InputMap>`.
\ **Примечание:** Методы **Input** отражают глобальное состояние ввода и не зависят от :ref:`Control.accept_event()<class_Control_method_accept_event>` или :ref:`Viewport.set_input_as_handled()<class_Viewport_method_set_input_as_handled>`, поскольку эти методы имеют дело только со способом распространения ввода в :ref:`SceneTree<class_SceneTree>`.
.. rst-class:: classref-introduction-group
Обучающие материалы
--------------------------------------
- :doc:`Указатель документации ввода <../tutorials/inputs/index>`
- `2D Dodge The Creeps Демо <https://godotengine.org/asset-library/asset/2712>`__
- `Демоверсия 3D вокселей <https://godotengine.org/asset-library/asset/2755>`__
.. rst-class:: classref-reftable-group
Свойства
----------------
.. table::
:widths: auto
+----------------------------------------+--------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`emulate_mouse_from_touch<class_Input_property_emulate_mouse_from_touch>` |
+----------------------------------------+--------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`emulate_touch_from_mouse<class_Input_property_emulate_touch_from_mouse>` |
+----------------------------------------+--------------------------------------------------------------------------------+
| :ref:`MouseMode<enum_Input_MouseMode>` | :ref:`mouse_mode<class_Input_property_mouse_mode>` |
+----------------------------------------+--------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_accumulated_input<class_Input_property_use_accumulated_input>` |
+----------------------------------------+--------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Методы
------------
.. table::
:widths: auto
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`action_press<class_Input_method_action_press>`\ (\ action\: :ref:`StringName<class_StringName>`, strength\: :ref:`float<class_float>` = 1.0\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`action_release<class_Input_method_action_release>`\ (\ action\: :ref:`StringName<class_StringName>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_joy_mapping<class_Input_method_add_joy_mapping>`\ (\ mapping\: :ref:`String<class_String>`, update_existing\: :ref:`bool<class_bool>` = false\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`flush_buffered_events<class_Input_method_flush_buffered_events>`\ (\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_accelerometer<class_Input_method_get_accelerometer>`\ (\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_action_raw_strength<class_Input_method_get_action_raw_strength>`\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_action_strength<class_Input_method_get_action_strength>`\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_axis<class_Input_method_get_axis>`\ (\ negative_action\: :ref:`StringName<class_StringName>`, positive_action\: :ref:`StringName<class_StringName>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`int<class_int>`\] | :ref:`get_connected_joypads<class_Input_method_get_connected_joypads>`\ (\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`CursorShape<enum_Input_CursorShape>` | :ref:`get_current_cursor_shape<class_Input_method_get_current_cursor_shape>`\ (\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_gravity<class_Input_method_get_gravity>`\ (\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_gyroscope<class_Input_method_get_gyroscope>`\ (\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_joy_axis<class_Input_method_get_joy_axis>`\ (\ device\: :ref:`int<class_int>`, axis\: :ref:`JoyAxis<enum_@GlobalScope_JoyAxis>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_joy_guid<class_Input_method_get_joy_guid>`\ (\ device\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Dictionary<class_Dictionary>` | :ref:`get_joy_info<class_Input_method_get_joy_info>`\ (\ device\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_joy_name<class_Input_method_get_joy_name>`\ (\ device\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_joy_vibration_duration<class_Input_method_get_joy_vibration_duration>`\ (\ device\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_joy_vibration_strength<class_Input_method_get_joy_vibration_strength>`\ (\ device\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_last_mouse_screen_velocity<class_Input_method_get_last_mouse_screen_velocity>`\ (\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_last_mouse_velocity<class_Input_method_get_last_mouse_velocity>`\ (\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_magnetometer<class_Input_method_get_magnetometer>`\ (\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |bitfield|\[:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>`\] | :ref:`get_mouse_button_mask<class_Input_method_get_mouse_button_mask>`\ (\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_vector<class_Input_method_get_vector>`\ (\ negative_x\: :ref:`StringName<class_StringName>`, positive_x\: :ref:`StringName<class_StringName>`, negative_y\: :ref:`StringName<class_StringName>`, positive_y\: :ref:`StringName<class_StringName>`, deadzone\: :ref:`float<class_float>` = -1.0\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_joy_light<class_Input_method_has_joy_light>`\ (\ device\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_action_just_pressed<class_Input_method_is_action_just_pressed>`\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_action_just_pressed_by_event<class_Input_method_is_action_just_pressed_by_event>`\ (\ action\: :ref:`StringName<class_StringName>`, event\: :ref:`InputEvent<class_InputEvent>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_action_just_released<class_Input_method_is_action_just_released>`\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_action_just_released_by_event<class_Input_method_is_action_just_released_by_event>`\ (\ action\: :ref:`StringName<class_StringName>`, event\: :ref:`InputEvent<class_InputEvent>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_action_pressed<class_Input_method_is_action_pressed>`\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_anything_pressed<class_Input_method_is_anything_pressed>`\ (\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_joy_button_pressed<class_Input_method_is_joy_button_pressed>`\ (\ device\: :ref:`int<class_int>`, button\: :ref:`JoyButton<enum_@GlobalScope_JoyButton>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_joy_known<class_Input_method_is_joy_known>`\ (\ device\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_key_label_pressed<class_Input_method_is_key_label_pressed>`\ (\ keycode\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_key_pressed<class_Input_method_is_key_pressed>`\ (\ keycode\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_mouse_button_pressed<class_Input_method_is_mouse_button_pressed>`\ (\ button\: :ref:`MouseButton<enum_@GlobalScope_MouseButton>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_physical_key_pressed<class_Input_method_is_physical_key_pressed>`\ (\ keycode\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`parse_input_event<class_Input_method_parse_input_event>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_joy_mapping<class_Input_method_remove_joy_mapping>`\ (\ guid\: :ref:`String<class_String>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_accelerometer<class_Input_method_set_accelerometer>`\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_custom_mouse_cursor<class_Input_method_set_custom_mouse_cursor>`\ (\ image\: :ref:`Resource<class_Resource>`, shape\: :ref:`CursorShape<enum_Input_CursorShape>` = 0, hotspot\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_default_cursor_shape<class_Input_method_set_default_cursor_shape>`\ (\ shape\: :ref:`CursorShape<enum_Input_CursorShape>` = 0\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_gravity<class_Input_method_set_gravity>`\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_gyroscope<class_Input_method_set_gyroscope>`\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`set_joy_light<class_Input_method_set_joy_light>`\ (\ device\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_magnetometer<class_Input_method_set_magnetometer>`\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`should_ignore_device<class_Input_method_should_ignore_device>`\ (\ vendor_id\: :ref:`int<class_int>`, product_id\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`start_joy_vibration<class_Input_method_start_joy_vibration>`\ (\ device\: :ref:`int<class_int>`, weak_magnitude\: :ref:`float<class_float>`, strong_magnitude\: :ref:`float<class_float>`, duration\: :ref:`float<class_float>` = 0\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`stop_joy_vibration<class_Input_method_stop_joy_vibration>`\ (\ device\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`vibrate_handheld<class_Input_method_vibrate_handheld>`\ (\ duration_ms\: :ref:`int<class_int>` = 500, amplitude\: :ref:`float<class_float>` = -1.0\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`warp_mouse<class_Input_method_warp_mouse>`\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Сигналы
--------------
.. _class_Input_signal_joy_connection_changed:
.. rst-class:: classref-signal
**joy_connection_changed**\ (\ device\: :ref:`int<class_int>`, connected\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_Input_signal_joy_connection_changed>`
Издается при подключении или отключении джойстика.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Перечисления
------------------------
.. _enum_Input_MouseMode:
.. rst-class:: classref-enumeration
enum **MouseMode**: :ref:`🔗<enum_Input_MouseMode>`
.. _class_Input_constant_MOUSE_MODE_VISIBLE:
.. rst-class:: classref-enumeration-constant
:ref:`MouseMode<enum_Input_MouseMode>` **MOUSE_MODE_VISIBLE** = ``0``
Делает курсор мыши видимым, если он скрыт.
.. _class_Input_constant_MOUSE_MODE_HIDDEN:
.. rst-class:: classref-enumeration-constant
:ref:`MouseMode<enum_Input_MouseMode>` **MOUSE_MODE_HIDDEN** = ``1``
Делает курсор мыши скрытым, если он виден.
.. _class_Input_constant_MOUSE_MODE_CAPTURED:
.. rst-class:: classref-enumeration-constant
:ref:`MouseMode<enum_Input_MouseMode>` **MOUSE_MODE_CAPTURED** = ``2``
Захватывает мышь. Мышь будет скрыта, а ее положение зафиксировано в центре окна менеджера окон.
\ **Примечание:** Если вы хотите обрабатывать движение мыши в этом режиме, вам нужно использовать :ref:`InputEventMouseMotion.relative<class_InputEventMouseMotion_property_relative>`.
.. _class_Input_constant_MOUSE_MODE_CONFINED:
.. rst-class:: classref-enumeration-constant
:ref:`MouseMode<enum_Input_MouseMode>` **MOUSE_MODE_CONFINED** = ``3``
Ограничивает курсор мыши окном игры и делает его видимым.
.. _class_Input_constant_MOUSE_MODE_CONFINED_HIDDEN:
.. rst-class:: classref-enumeration-constant
:ref:`MouseMode<enum_Input_MouseMode>` **MOUSE_MODE_CONFINED_HIDDEN** = ``4``
Ограничивает курсор мыши окном игры и делает его скрытым.
.. _class_Input_constant_MOUSE_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`MouseMode<enum_Input_MouseMode>` **MOUSE_MODE_MAX** = ``5``
Максимальное значение :ref:`MouseMode<enum_Input_MouseMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Input_CursorShape:
.. rst-class:: classref-enumeration
enum **CursorShape**: :ref:`🔗<enum_Input_CursorShape>`
.. _class_Input_constant_CURSOR_ARROW:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_ARROW** = ``0``
Курсор-стрелка. Стандартный, указывающий курсор по умолчанию.
.. _class_Input_constant_CURSOR_IBEAM:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_IBEAM** = ``1``
Курсор в виде I-образной линии. Обычно используется для указания того, где появится текстовый курсор при щелчке мыши.
.. _class_Input_constant_CURSOR_POINTING_HAND:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_POINTING_HAND** = ``2``
Курсор в виде указывающей руки. Обычно используется для обозначения того, что указатель находится над ссылкой или другим интерактивным элементом.
.. _class_Input_constant_CURSOR_CROSS:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_CROSS** = ``3``
Перекрестный курсор. Обычно появляется над областями, в которых можно выполнить операцию рисования или для выделения.
.. _class_Input_constant_CURSOR_WAIT:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_WAIT** = ``4``
Курсор ожидания. Указывает, что приложение занято выполнением операции и что оно не может быть использовано во время операции (например, что-то блокирует его основной поток).
.. _class_Input_constant_CURSOR_BUSY:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_BUSY** = ``5``
Занятый курсор. Указывает, что приложение занято выполнением операции и что оно все еще может использоваться во время операции.
.. _class_Input_constant_CURSOR_DRAG:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_DRAG** = ``6``
Курсор перетаскивания. Обычно отображается при перетаскивании чего-либо.
\ **Примечание:** В Windows отсутствует курсор перетаскивания, поэтому :ref:`CURSOR_DRAG<class_Input_constant_CURSOR_DRAG>` совпадает с :ref:`CURSOR_MOVE<class_Input_constant_CURSOR_MOVE>` для этой платформы.
.. _class_Input_constant_CURSOR_CAN_DROP:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_CAN_DROP** = ``7``
Можно отпустить курсор. Обычно отображается при перетаскивании чего-либо, чтобы указать, что его можно отпустить в текущей позиции.
.. _class_Input_constant_CURSOR_FORBIDDEN:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_FORBIDDEN** = ``8``
Запрещенный курсор. Указывает, что текущее действие запрещено (например, при перетаскивании чего-либо) или что элемент управления в позиции отключен.
.. _class_Input_constant_CURSOR_VSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_VSIZE** = ``9``
Вертикальное изменение размера курсора мыши. Двунаправленная вертикальная стрелка. Сообщает пользователю, что он может изменять размер окна или панели по вертикали.
.. _class_Input_constant_CURSOR_HSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_HSIZE** = ``10``
Курсор мыши для изменения размера по горизонтали. Двунаправленная горизонтальная стрелка. Сообщает пользователю, что он может изменять размер окна или панели по горизонтали.
.. _class_Input_constant_CURSOR_BDIAGSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_BDIAGSIZE** = ``11``
Курсор мыши для изменения размера окна. Курсор представляет собой двунаправленную стрелку, которая идет из нижнего левого угла в верхний правый угол. Он сообщает пользователю, что он может изменять размер окна или панели как по горизонтали, так и по вертикали.
.. _class_Input_constant_CURSOR_FDIAGSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_FDIAGSIZE** = ``12``
Курсор мыши для изменения размера окна. Курсор — это двунаправленная стрелка, которая идет из верхнего левого угла в нижний правый угол, противоположность :ref:`CURSOR_BDIAGSIZE<class_Input_constant_CURSOR_BDIAGSIZE>`. Он сообщает пользователю, что он может изменять размер окна или панели как по горизонтали, так и по вертикали.
.. _class_Input_constant_CURSOR_MOVE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_MOVE** = ``13``
Переместить курсор. Указывает, что что-то можно переместить.
.. _class_Input_constant_CURSOR_VSPLIT:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_VSPLIT** = ``14``
Вертикальный разделенный курсор мыши. В Windows это то же самое, что :ref:`CURSOR_VSIZE<class_Input_constant_CURSOR_VSIZE>`.
.. _class_Input_constant_CURSOR_HSPLIT:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_HSPLIT** = ``15``
Горизонтальный разделенный курсор мыши. В Windows это то же самое, что :ref:`CURSOR_HSIZE<class_Input_constant_CURSOR_HSIZE>`.
.. _class_Input_constant_CURSOR_HELP:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Input_CursorShape>` **CURSOR_HELP** = ``16``
Курсор помощи. Обычно вопросительный знак.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания свойств
--------------------------------
.. _class_Input_property_emulate_mouse_from_touch:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **emulate_mouse_from_touch** :ref:`🔗<class_Input_property_emulate_mouse_from_touch>`
.. rst-class:: classref-property-setget
- |void| **set_emulate_mouse_from_touch**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_emulating_mouse_from_touch**\ (\ )
Если ``true``, отправляет события ввода мыши при нажатии или пролистывании на сенсорном экране. См. также :ref:`ProjectSettings.input_devices/pointing/emulate_mouse_from_touch<class_ProjectSettings_property_input_devices/pointing/emulate_mouse_from_touch>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_property_emulate_touch_from_mouse:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **emulate_touch_from_mouse** :ref:`🔗<class_Input_property_emulate_touch_from_mouse>`
.. rst-class:: classref-property-setget
- |void| **set_emulate_touch_from_mouse**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_emulating_touch_from_mouse**\ (\ )
Если ``true``, отправляет события сенсорного ввода при щелчке или перетаскивании мыши. См. также :ref:`ProjectSettings.input_devices/pointing/emulate_touch_from_mouse<class_ProjectSettings_property_input_devices/pointing/emulate_touch_from_mouse>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_property_mouse_mode:
.. rst-class:: classref-property
:ref:`MouseMode<enum_Input_MouseMode>` **mouse_mode** :ref:`🔗<class_Input_property_mouse_mode>`
.. rst-class:: classref-property-setget
- |void| **set_mouse_mode**\ (\ value\: :ref:`MouseMode<enum_Input_MouseMode>`\ )
- :ref:`MouseMode<enum_Input_MouseMode>` **get_mouse_mode**\ (\ )
Управляет режимом мыши.
.. rst-class:: classref-item-separator
----
.. _class_Input_property_use_accumulated_input:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_accumulated_input** :ref:`🔗<class_Input_property_use_accumulated_input>`
.. rst-class:: classref-property-setget
- |void| **set_use_accumulated_input**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_accumulated_input**\ (\ )
Если ``true``, накапливаются похожие события ввода, отправленные операционной системой. Когда накопление ввода включено, все события ввода, сгенерированные во время кадра, будут объединены и отправлены, когда кадр завершит рендеринг. Таким образом, это ограничивает количество вызовов методов ввода в секунду до FPS рендеринга.
Накопление ввода можно отключить, чтобы получить немного более точный/реактивный ввод за счет увеличения загрузки ЦП. В приложениях, где требуется рисовать линии от руки, накопление ввода обычно следует отключать, пока пользователь рисует линию, чтобы получить результаты, которые точно соответствуют фактическому вводу.
\ **Примечание:** Накопление ввода *включено* по умолчанию.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания метода
------------------------------
.. _class_Input_method_action_press:
.. rst-class:: classref-method
|void| **action_press**\ (\ action\: :ref:`StringName<class_StringName>`, strength\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_Input_method_action_press>`
Это сымитирует нажатие указанного действия.
Силу можно использовать для небулевых действий, она находится в диапазоне от 0 до 1, представляя интенсивность данного действия.
\ **Примечание:** Этот метод не вызовет никаких вызовов :ref:`Node._input()<class_Node_private_method__input>`. Он предназначен для использования с :ref:`is_action_pressed()<class_Input_method_is_action_pressed>` и :ref:`is_action_just_pressed()<class_Input_method_is_action_just_pressed>`. Если вы хотите симулировать ``_input``, используйте вместо этого :ref:`parse_input_event()<class_Input_method_parse_input_event>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_action_release:
.. rst-class:: classref-method
|void| **action_release**\ (\ action\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_Input_method_action_release>`
Если указанное действие уже нажато, это отменит его.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_add_joy_mapping:
.. rst-class:: classref-method
|void| **add_joy_mapping**\ (\ mapping\: :ref:`String<class_String>`, update_existing\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Input_method_add_joy_mapping>`
Добавляет новую запись сопоставления (в формате SDL2) в базу данных сопоставления. При желании можно обновить уже подключенные устройства.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_flush_buffered_events:
.. rst-class:: classref-method
|void| **flush_buffered_events**\ (\ ) :ref:`🔗<class_Input_method_flush_buffered_events>`
Отправляет все события ввода, которые находятся в текущем буфере, в игровой цикл. Эти события могли быть буферизованы в результате накопленного ввода (:ref:`use_accumulated_input<class_Input_property_use_accumulated_input>`) или гибкой очистки ввода (:ref:`ProjectSettings.input_devices/buffering/agile_event_flushing<class_ProjectSettings_property_input_devices/buffering/agile_event_flushing>`).
Движок уже сделает это сам в ключевых точках выполнения (по крайней мере один раз за кадр). Однако это может быть полезно в сложных случаях, когда вам нужен точный контроль над временем обработки событий.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_accelerometer:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_accelerometer**\ (\ ) |const| :ref:`🔗<class_Input_method_get_accelerometer>`
Возвращает ускорение в м/с² акселерометрического датчика устройства, если он есть. В противном случае метод возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
Обратите внимание, что этот метод возвращает пустой :ref:`Vector3<class_Vector3>` при запуске из редактора, даже если на вашем устройстве есть акселерометр. Вам необходимо экспортировать свой проект на поддерживаемое устройство, чтобы считать значения с акселерометра.
\ **Примечание:** Этот метод работает только на Android и iOS. На других платформах он всегда возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
\ **Примечание:** Для Android необходимо включить :ref:`ProjectSettings.input_devices/sensors/enable_accelerometer<class_ProjectSettings_property_input_devices/sensors/enable_accelerometer>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_action_raw_strength:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_action_raw_strength**\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Input_method_get_action_raw_strength>`
Возвращает значение от 0 до 1, представляющее собой необработанную интенсивность данного действия, игнорируя мертвую зону действия. В большинстве случаев вместо этого следует использовать :ref:`get_action_strength()<class_Input_method_get_action_strength>`.
Если ``exact_match`` равен ``false``, он игнорирует дополнительные модификаторы ввода для событий :ref:`InputEventKey<class_InputEventKey>` и :ref:`InputEventMouseButton<class_InputEventMouseButton>`, а также направление для событий :ref:`InputEventJoypadMotion<class_InputEventJoypadMotion>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_action_strength:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_action_strength**\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Input_method_get_action_strength>`
Возвращает значение от 0 до 1, представляющее интенсивность данного действия. Например, в джойстике, чем дальше ось (аналоговые джойстики или триггеры L2, R2) от мертвой зоны, тем ближе значение будет к 1. Если действие сопоставлено с элементом управления, не имеющим оси, например клавиатурой, возвращаемое значение будет равно 0 или 1.
Если ``exact_match`` равен ``false``, он игнорирует дополнительные модификаторы ввода для событий :ref:`InputEventKey<class_InputEventKey>` и :ref:`InputEventMouseButton<class_InputEventMouseButton>`, а также направление для событий :ref:`InputEventJoypadMotion<class_InputEventJoypadMotion>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_axis:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_axis**\ (\ negative_action\: :ref:`StringName<class_StringName>`, positive_action\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_Input_method_get_axis>`
Получите входные данные оси, указав два действия, одно отрицательное и одно положительное.
Это сокращение для записи ``Input.get_action_strength("positive_action") - Input.get_action_strength("negative_action")``.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_connected_joypads:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`int<class_int>`\] **get_connected_joypads**\ (\ ) :ref:`🔗<class_Input_method_get_connected_joypads>`
Возвращает :ref:`Array<class_Array>`, содержащий идентификаторы устройств всех подключенных в данный момент джойстиков.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_current_cursor_shape:
.. rst-class:: classref-method
:ref:`CursorShape<enum_Input_CursorShape>` **get_current_cursor_shape**\ (\ ) |const| :ref:`🔗<class_Input_method_get_current_cursor_shape>`
Возвращает текущую назначенную форму курсора.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_gravity:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_gravity**\ (\ ) |const| :ref:`🔗<class_Input_method_get_gravity>`
Возвращает силу тяжести (gravity) в м/с² акселерометрического датчика устройства, если он есть. В противном случае метод возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
\ **Примечание:** Этот метод работает только на Android и iOS. На других платформах он всегда возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
\ **Примечание:** Для Android необходимо включить :ref:`ProjectSettings.input_devices/sensors/enable_gravity<class_ProjectSettings_property_input_devices/sensors/enable_gravity>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_gyroscope:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_gyroscope**\ (\ ) |const| :ref:`🔗<class_Input_method_get_gyroscope>`
Возвращает скорость вращения в рад/с вокруг осей X, Y и Z устройства датчика гироскопа, если устройство имеет таковой. В противном случае метод возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
\ **Примечание:** Этот метод работает только на Android и iOS. На других платформах он всегда возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
\ **Примечание:** Для Android :ref:`ProjectSettings.input_devices/sensors/enable_gyroscope<class_ProjectSettings_property_input_devices/sensors/enable_gyroscope>` должен быть включен.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_joy_axis:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_joy_axis**\ (\ device\: :ref:`int<class_int>`, axis\: :ref:`JoyAxis<enum_@GlobalScope_JoyAxis>`\ ) |const| :ref:`🔗<class_Input_method_get_joy_axis>`
Возвращает текущее значение оси джойстика по индексу ``axis``.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_joy_guid:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_joy_guid**\ (\ device\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Input_method_get_joy_guid>`
Возвращает совместимый с SDL2 GUID устройства на платформах, использующих переназначение геймпада, например, ``030000004c050000c405000000010000``. Возвращает пустую строку, если не может быть найдена. Godot использует `базу данных игровых контроллеров SDL2 <https://github.com/gabomdq/SDL_GameControllerDB>`__ для определения имен геймпадов и сопоставлений на основе этого GUID.
В Windows все GUID джойстиков XInput будут переопределены Godot на ``__XINPUT_DEVICE__``, поскольку их сопоставления одинаковы.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_joy_info:
.. rst-class:: classref-method
:ref:`Dictionary<class_Dictionary>` **get_joy_info**\ (\ device\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Input_method_get_joy_info>`
Возвращает словарь с дополнительной платформенно-специфичной информацией об устройстве, например, исходное имя геймпада из ОС или индекс Steam Input.
В Windows, Linux и macOS словарь содержит следующие поля:
\ ``raw_name``: Имя контроллера, полученное из ОС до переименования базой данных контроллеров.
\ ``vendor_id``: Идентификатор поставщика USB-устройства.
\ ``product_id``: Идентификатор продукта USB-устройства.
\ ``steam_input_index``: Индекс геймпада Steam Input. Если устройство не является устройством Steam Input, этот ключ отсутствует.
В Windows словарь может содержать дополнительное поле:
\ ``xinput_index``: Индекс контроллера в системе XInput. Этот ключ отсутствует для устройств, не поддерживаемых XInput.
\ **Примечание:** Возвращаемый словарь всегда пуст на Android, iOS, visionOS и Web.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_joy_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_joy_name**\ (\ device\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Input_method_get_joy_name>`
Возвращает имя джойстика по указанному индексу устройства, например, ``PS4 Controller``. Godot использует `Базу данных игровых контроллеров SDL2 <https://github.com/gabomdq/SDL_GameControllerDB>`__ для определения имен геймпадов.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_joy_vibration_duration:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_joy_vibration_duration**\ (\ device\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Input_method_get_joy_vibration_duration>`
Возвращает длительность текущего эффекта вибрации в секундах.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_joy_vibration_strength:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_joy_vibration_strength**\ (\ device\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Input_method_get_joy_vibration_strength>`
Возвращает силу вибрации джойстика: x — сила слабого мотора, y — сила сильного мотора.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_last_mouse_screen_velocity:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_last_mouse_screen_velocity**\ (\ ) :ref:`🔗<class_Input_method_get_last_mouse_screen_velocity>`
Возвращает последнюю скорость мыши в координатах экрана. Чтобы обеспечить точную и свободную от дрожания скорость, скорость мыши вычисляется только каждые 0,1 с. Поэтому скорость мыши будет отставать от движений мыши.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_last_mouse_velocity:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_last_mouse_velocity**\ (\ ) :ref:`🔗<class_Input_method_get_last_mouse_velocity>`
Возвращает последнюю скорость мыши. Чтобы обеспечить точную и свободную от дрожания скорость, скорость мыши вычисляется только каждые 0,1 с. Поэтому скорость мыши будет отставать от движений мыши.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_magnetometer:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_magnetometer**\ (\ ) |const| :ref:`🔗<class_Input_method_get_magnetometer>`
Возвращает напряженность магнитного поля в микротеслах для всех осей датчика магнитометра устройства, если он есть. В противном случае метод возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
\ **Примечание:** Этот метод работает только на Android и iOS. На других платформах он всегда возвращает :ref:`Vector3.ZERO<class_Vector3_constant_ZERO>`.
\ **Примечание:** Для Android необходимо включить :ref:`ProjectSettings.input_devices/sensors/enable_magnetometer<class_ProjectSettings_property_input_devices/sensors/enable_magnetometer>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_mouse_button_mask:
.. rst-class:: classref-method
|bitfield|\[:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>`\] **get_mouse_button_mask**\ (\ ) |const| :ref:`🔗<class_Input_method_get_mouse_button_mask>`
Возвращает кнопки мыши как битовую маску. Если одновременно нажато несколько кнопок мыши, биты суммируются. Эквивалентно :ref:`DisplayServer.mouse_get_button_state()<class_DisplayServer_method_mouse_get_button_state>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_get_vector:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_vector**\ (\ negative_x\: :ref:`StringName<class_StringName>`, positive_x\: :ref:`StringName<class_StringName>`, negative_y\: :ref:`StringName<class_StringName>`, positive_y\: :ref:`StringName<class_StringName>`, deadzone\: :ref:`float<class_float>` = -1.0\ ) |const| :ref:`🔗<class_Input_method_get_vector>`
Получает входной вектор, указывая четыре действия для положительных и отрицательных осей X и Y.
Этот метод полезен при получении векторного ввода, например, с джойстика, навигационной панели, стрелок или WASD. Длина вектора ограничена 1, и он имеет круговую мертвую зону, что полезно для использования векторного ввода в качестве движения.
По умолчанию мертвая зона автоматически рассчитывается из среднего значения мертвых зон действий. Однако вы можете переопределить мертвую зону, чтобы она была любой, которую вы хотите (в диапазоне от 0 до 1).
.. rst-class:: classref-item-separator
----
.. _class_Input_method_has_joy_light:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_joy_light**\ (\ device\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Input_method_has_joy_light>`
Returns ``true`` if the joypad has an LED light that can change colors and/or brightness. See also :ref:`set_joy_light()<class_Input_method_set_joy_light>`.
\ **Note:** This feature is only supported on Windows, Linux, and macOS.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_action_just_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_action_just_pressed**\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Input_method_is_action_just_pressed>`
Возвращает ``true``, когда пользователь *начал* нажатие кнопки действия в текущем кадре или тике физики. Возвращает ``true`` только в том кадре или тике, когда пользователь нажал кнопку.
Это полезно для кода, который должен выполняться только один раз при нажатии кнопки действия, а не каждый кадр, пока она нажата.
Если ``exact_match`` равен ``false``, он игнорирует дополнительные модификаторы ввода для событий :ref:`InputEventKey<class_InputEventKey>` и :ref:`InputEventMouseButton<class_InputEventMouseButton>`, а также направление для событий :ref:`InputEventJoypadMotion<class_InputEventJoypadMotion>`.
\ **Примечание:** Возврат ``true`` не означает, что действие *всё ещё* нажато. Действие можно быстро нажать и отпустить, и ``true`` всё равно будет возвращён, чтобы не пропустить ввод.
\ **Примечание:** Из-за эффекта фантомного нажатия клавиатуры, :ref:`is_action_just_pressed()<class_Input_method_is_action_just_pressed>` может возвращать ``false``, даже если нажата одна из клавиш действия. Подробнее см. в разделе `Примеры ввода <../tutorials/inputs/input_examples.html#keyboard-events>`__ в документации.
\ **Примечание:** При обработке ввода (например, :ref:`Node._input()<class_Node_private_method__input>`) используйте :ref:`InputEvent.is_action_pressed()<class_InputEvent_method_is_action_pressed>` для запроса состояния действия текущего события. См. также :ref:`is_action_just_pressed_by_event()<class_Input_method_is_action_just_pressed_by_event>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_action_just_pressed_by_event:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_action_just_pressed_by_event**\ (\ action\: :ref:`StringName<class_StringName>`, event\: :ref:`InputEvent<class_InputEvent>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Input_method_is_action_just_pressed_by_event>`
Возвращает ``true``, когда пользователь *начал* нажатие кнопки действия в текущем кадре или такте физики, и первым событием, вызвавшим нажатие кнопки действия в текущем кадре/такте физики, было ``event``. Возвращает ``true`` только в том кадре или такте, когда пользователь нажал кнопку.
Это полезно для кода, который должен выполняться только один раз при нажатии кнопки действия, и действие обрабатывается во время обработки ввода (например, :ref:`Node._input()<class_Node_private_method__input>`).
Если ``exact_match`` равен ``false``, он игнорирует дополнительные модификаторы ввода для событий :ref:`InputEventKey<class_InputEventKey>` и :ref:`InputEventMouseButton<class_InputEventMouseButton>`, а также направление для событий :ref:`InputEventJoypadMotion<class_InputEventJoypadMotion>`.
\ **Примечание:** Возврат ``true`` не означает, что действие *всё ещё* нажато. Действие можно быстро нажать и отпустить, и при этом ``true`` всё равно будет возвращён, чтобы не пропустить ввод.
\ **Примечание:** Из-за эффекта фантомного нажатия клавиатуры :ref:`is_action_just_pressed()<class_Input_method_is_action_just_pressed>` может возвращать ``false``, даже если нажата одна из клавиш действия. Подробнее см. `Примеры ввода <../tutorials/inputs/input_examples.html#keyboard-events>`__ в документации.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_action_just_released:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_action_just_released**\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Input_method_is_action_just_released>`
Возвращает ``true``, когда пользователь *прекращает* нажатие на событие действия в текущем кадре или такте физики. Возвращает ``true`` только в том кадре или такте, когда пользователь отпускает кнопку.
\ **Примечание:** Возвращение ``true`` не означает, что действие *ещё* не нажато. Действие можно быстро отпустить и снова нажать, и ``true`` всё равно будет возвращено, чтобы не пропустить ввод.
Если ``exact_match`` равен ``false``, он игнорирует дополнительные модификаторы ввода для событий :ref:`InputEventKey<class_InputEventKey>` и :ref:`InputEventMouseButton<class_InputEventMouseButton>`, а также направление для событий :ref:`InputEventJoypadMotion<class_InputEventJoypadMotion>`.
\ **Примечание:** Во время обработки входных данных (например, :ref:`Node._input()<class_Node_private_method__input>`) используйте :ref:`InputEvent.is_action_released()<class_InputEvent_method_is_action_released>` для запроса состояния действия текущего события. См. также :ref:`is_action_just_released_by_event()<class_Input_method_is_action_just_released_by_event>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_action_just_released_by_event:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_action_just_released_by_event**\ (\ action\: :ref:`StringName<class_StringName>`, event\: :ref:`InputEvent<class_InputEvent>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Input_method_is_action_just_released_by_event>`
Возвращает ``true``, когда пользователь *прекращает* нажатие кнопки действия в текущем кадре или такте физики, и первым событием, вызвавшим отпускание кнопки в текущем кадре/такте физики, было ``event``. Возвращает ``true`` только в том кадре или такте, когда пользователь отпускает кнопку.
Это полезно, когда действие обрабатывается во время обработки ввода (например, :ref:`Node._input()<class_Node_private_method__input>`).
\ **Примечание:** Возврат ``true`` не означает, что действие *ещё* не нажато. Действие можно быстро отпустить и снова нажать, и ``true`` всё равно будет возвращён, чтобы не пропустить ввод.
Если ``exact_match`` равен ``false``, он игнорирует дополнительные модификаторы ввода для событий :ref:`InputEventKey<class_InputEventKey>` и :ref:`InputEventMouseButton<class_InputEventMouseButton>`, а также направление для событий :ref:`InputEventJoypadMotion<class_InputEventJoypadMotion>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_action_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_action_pressed**\ (\ action\: :ref:`StringName<class_StringName>`, exact_match\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Input_method_is_action_pressed>`
Возвращает ``true``, если вы нажимаете событие действия.
Если ``exact_match`` равен ``false``, он игнорирует дополнительные модификаторы ввода для событий :ref:`InputEventKey<class_InputEventKey>` и :ref:`InputEventMouseButton<class_InputEventMouseButton>`, а также направление для событий :ref:`InputEventJoypadMotion<class_InputEventJoypadMotion>`.
\ **Примечание:** Из-за эффекта фантомного нажатия клавиатуры :ref:`is_action_pressed()<class_Input_method_is_action_pressed>` может возвращать ``false``, даже если нажата одна из клавиш действия. Для получения дополнительной информации см. `Примеры ввода <../tutorials/inputs/input_examples.html#keyboard-events>`__ в документации.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_anything_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_anything_pressed**\ (\ ) |const| :ref:`🔗<class_Input_method_is_anything_pressed>`
Возвращает ``true``, если нажато какое-либо действие, клавиша, кнопка джойстика или кнопка мыши. Это также вернет ``true``, если какое-либо действие имитируется через код путем вызова :ref:`action_press()<class_Input_method_action_press>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_joy_button_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_joy_button_pressed**\ (\ device\: :ref:`int<class_int>`, button\: :ref:`JoyButton<enum_@GlobalScope_JoyButton>`\ ) |const| :ref:`🔗<class_Input_method_is_joy_button_pressed>`
Возвращает ``true``, если вы нажимаете кнопку джойстика с индексом ``button``.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_joy_known:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_joy_known**\ (\ device\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Input_method_is_joy_known>`
Возвращает ``true``, если система знает указанное устройство. Это означает, что она устанавливает все индексы кнопок и осей. Неизвестные джойстики не должны соответствовать этим константам, но вы все равно можете извлекать из них события.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_key_label_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_key_label_pressed**\ (\ keycode\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| :ref:`🔗<class_Input_method_is_key_label_pressed>`
Возвращает ``true``, если вы нажимаете клавишу с напечатанным на ней ``keycode``. Вы можете передать константу :ref:`Key<enum_@GlobalScope_Key>` или любой код символа Unicode.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_key_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_key_pressed**\ (\ keycode\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| :ref:`🔗<class_Input_method_is_key_pressed>`
Возвращает ``true``, если вы нажимаете латинскую клавишу в текущей раскладке клавиатуры. Вы можете передать константу :ref:`Key<enum_@GlobalScope_Key>`.
\ :ref:`is_key_pressed()<class_Input_method_is_key_pressed>` рекомендуется только вместо :ref:`is_physical_key_pressed()<class_Input_method_is_physical_key_pressed>` в неигровых приложениях. Это гарантирует, что сочетания клавиш ведут себя ожидаемым образом в зависимости от раскладки клавиатуры пользователя, поскольку сочетания клавиш, как правило, зависят от раскладки клавиатуры в неигровых приложениях. Если есть сомнения, используйте :ref:`is_physical_key_pressed()<class_Input_method_is_physical_key_pressed>`.
\ **Примечание:** Из-за эффекта фантомных нажатий клавиатуры :ref:`is_key_pressed()<class_Input_method_is_key_pressed>` может возвращать ``false``, даже если нажата одна из клавиш действия. См. `Примеры ввода <../tutorials/inputs/input_examples.html#keyboard-events>`__ в документации для получения дополнительной информации.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_mouse_button_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_mouse_button_pressed**\ (\ button\: :ref:`MouseButton<enum_@GlobalScope_MouseButton>`\ ) |const| :ref:`🔗<class_Input_method_is_mouse_button_pressed>`
Возвращает ``true``, если вы нажимаете кнопку мыши, указанную с помощью :ref:`MouseButton<enum_@GlobalScope_MouseButton>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_is_physical_key_pressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_physical_key_pressed**\ (\ keycode\: :ref:`Key<enum_@GlobalScope_Key>`\ ) |const| :ref:`🔗<class_Input_method_is_physical_key_pressed>`
Возвращает ``true``, если вы нажимаете клавишу в физическом месте на 101/102-клавишной клавиатуре US QWERTY. Вы можете передать константу :ref:`Key<enum_@GlobalScope_Key>`.
\ :ref:`is_physical_key_pressed()<class_Input_method_is_physical_key_pressed>` рекомендуется вместо :ref:`is_key_pressed()<class_Input_method_is_key_pressed>` для действий в игре, так как он заставит раскладки :kbd:`W`/:kbd:`A`/:kbd:`S`/:kbd:`D` работать независимо от раскладки клавиатуры пользователя. :ref:`is_physical_key_pressed()<class_Input_method_is_physical_key_pressed>` также гарантирует, что клавиши с цифрами верхнего ряда будут работать на любой раскладке клавиатуры. Если вы сомневаетесь, используйте :ref:`is_physical_key_pressed()<class_Input_method_is_physical_key_pressed>`.
\ **Примечание:** Из-за фантомного нажатия клавиатуры :ref:`is_physical_key_pressed()<class_Input_method_is_physical_key_pressed>` может возвращать ``false``, даже если нажата одна из клавиш действия. Для получения дополнительной информации см. `Примеры ввода <../tutorials/inputs/input_examples.html#keyboard-events>`__ в документации.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_parse_input_event:
.. rst-class:: classref-method
|void| **parse_input_event**\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) :ref:`🔗<class_Input_method_parse_input_event>`
Подает :ref:`InputEvent<class_InputEvent>` в игру. Может использоваться для искусственного запуска событий ввода из кода. Также генерирует вызовы :ref:`Node._input()<class_Node_private_method__input>`.
.. tabs::
.. code-tab:: gdscript
var cancel_event = InputEventAction.new()
cancel_event.action = "ui_cancel"
cancel_event.pressed = true
Input.parse_input_event(cancel_event)
.. code-tab:: csharp
var cancelEvent = new InputEventAction();
cancelEvent.Action = "ui_cancel";
cancelEvent.Pressed = true;
Input.ParseInputEvent(cancelEvent);
\ **Примечание:** Вызов этой функции не влияет на операционную систему. Так, например, отправка :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` не переместит курсор мыши ОС в указанную позицию (используйте вместо этого :ref:`warp_mouse()<class_Input_method_warp_mouse>`), а отправка :kbd:`Alt/Cmd + Tab` в качестве :ref:`InputEventKey<class_InputEventKey>` не будет переключать между активными окнами.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_remove_joy_mapping:
.. rst-class:: classref-method
|void| **remove_joy_mapping**\ (\ guid\: :ref:`String<class_String>`\ ) :ref:`🔗<class_Input_method_remove_joy_mapping>`
Удаляет все сопоставления из внутренней базы данных, которые соответствуют данному GUID. Все подключенные в данный момент джойпады, которые используют этот GUID, станут не сопоставленными.
На Android Godot будет сопоставлен с внутренним резервным сопоставлением.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_set_accelerometer:
.. rst-class:: classref-method
|void| **set_accelerometer**\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Input_method_set_accelerometer>`
Устанавливает значение ускорения акселерометрического датчика. Может использоваться для отладки на устройствах без аппаратного датчика, например, в редакторе на ПК.
\ **Примечание:** Это значение может быть немедленно перезаписано значением аппаратного датчика на Android и iOS.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_set_custom_mouse_cursor:
.. rst-class:: classref-method
|void| **set_custom_mouse_cursor**\ (\ image\: :ref:`Resource<class_Resource>`, shape\: :ref:`CursorShape<enum_Input_CursorShape>` = 0, hotspot\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) :ref:`🔗<class_Input_method_set_custom_mouse_cursor>`
Устанавливает пользовательское изображение курсора мыши, которое отображается только внутри игрового окна для заданной мыши ``shape``. Также можно указать горячую точку. Передача ``null`` в параметр image сбрасывает его до системного курсора.
\ ``image`` может быть либо :ref:`Texture2D<class_Texture2D>`, либо :ref:`Image<class_Image>`, а его размер должен быть меньше или равен 256×256. Чтобы избежать проблем с рендерингом, рекомендуются размеры меньше или равны 128×128.
\ ``hotspot`` должен быть в пределах размера ``image``.
\ **Примечание:** :ref:`AnimatedTexture<class_AnimatedTexture>` не поддерживаются в качестве пользовательских курсоров мыши. При использовании :ref:`AnimatedTexture<class_AnimatedTexture>` будет отображаться только первый кадр.
\ **Примечание:** Рекомендуются режимы сжатия **Lossless**, **Lossy** или **Uncompressed**. Режим сжатия **Video RAM** может использоваться, но он будет распакован на ЦП, что означает замедление времени загрузки и отсутствие экономии памяти по сравнению с режимами без потерь.
\ **Примечание:** На веб-платформе максимально допустимый размер изображения курсора составляет 128×128. Изображения курсора размером более 32×32 также будут отображаться только в том случае, если изображение курсора мыши полностью расположено на странице по `соображениям безопасности <https://chromestatus.com/feature/5825971391299584>`__.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_set_default_cursor_shape:
.. rst-class:: classref-method
|void| **set_default_cursor_shape**\ (\ shape\: :ref:`CursorShape<enum_Input_CursorShape>` = 0\ ) :ref:`🔗<class_Input_method_set_default_cursor_shape>`
Устанавливает форму курсора по умолчанию для использования в области просмотра вместо :ref:`CURSOR_ARROW<class_Input_constant_CURSOR_ARROW>`.
\ **Примечание:** Если вы хотите изменить форму курсора по умолчанию для узлов :ref:`Control<class_Control>`, используйте вместо этого :ref:`Control.mouse_default_cursor_shape<class_Control_property_mouse_default_cursor_shape>`.
\ **Примечание:** Этот метод генерирует :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` для немедленного обновления курсора.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_set_gravity:
.. rst-class:: classref-method
|void| **set_gravity**\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Input_method_set_gravity>`
Устанавливает значение силы тяжести (gravity) акселерометрического датчика. Может использоваться для отладки на устройствах без аппаратного датчика, например, в редакторе на ПК.
\ **Примечание:** Это значение может быть немедленно перезаписано значением аппаратного датчика на Android и iOS.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_set_gyroscope:
.. rst-class:: classref-method
|void| **set_gyroscope**\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Input_method_set_gyroscope>`
Устанавливает значение скорости вращения датчика гироскопа. Может использоваться для отладки на устройствах без аппаратного датчика, например в редакторе на ПК.
\ **Примечание:** Это значение может быть немедленно перезаписано значением аппаратного датчика на Android и iOS.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_set_joy_light:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **set_joy_light**\ (\ device\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Input_method_set_joy_light>`
Sets the joypad's LED light, if available, to the specified color. Returns ``true`` if the operation was successful. See also :ref:`has_joy_light()<class_Input_method_has_joy_light>`.
\ **Note:** There is no way to get the color of the light from a joypad. If you need to know the assigned color, store it separately.
\ **Note:** This feature is only supported on Windows, Linux, and macOS.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_set_magnetometer:
.. rst-class:: classref-method
|void| **set_magnetometer**\ (\ value\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Input_method_set_magnetometer>`
Устанавливает значение магнитного поля датчика магнитометра. Может использоваться для отладки на устройствах без аппаратного датчика, например в редакторе на ПК.
\ **Примечание:** Это значение может быть немедленно перезаписано значением аппаратного датчика на Android и iOS.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_should_ignore_device:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **should_ignore_device**\ (\ vendor_id\: :ref:`int<class_int>`, product_id\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Input_method_should_ignore_device>`
Запрашивает, следует ли игнорировать устройство ввода или нет. Устройства можно игнорировать, установив переменную среды ``SDL_GAMECONTROLLER_IGNORE_DEVICES``. Прочтите `документацию SDL <https://wiki.libsdl.org/SDL2>`__ для получения дополнительной информации.
\ **Примечание:** Некоторые сторонние инструменты могут вносить свой вклад в список игнорируемых устройств. Например, *SteamInput* создает виртуальные устройства из физических устройств для целей переназначения. Чтобы избежать обработки одного и того же устройства ввода дважды, исходное устройство добавляется в список игнорируемых.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_start_joy_vibration:
.. rst-class:: classref-method
|void| **start_joy_vibration**\ (\ device\: :ref:`int<class_int>`, weak_magnitude\: :ref:`float<class_float>`, strong_magnitude\: :ref:`float<class_float>`, duration\: :ref:`float<class_float>` = 0\ ) :ref:`🔗<class_Input_method_start_joy_vibration>`
Начинает вибрировать джойпад. Джойпады обычно поставляются с двумя вибрирующими моторами, сильным и слабым. ``weak_magnitude`` — это сила слабого мотора (от 0 до 1), а ``strong_magnitude`` — это сила сильного мотора (от 0 до 1). ``duration`` — это длительность эффекта в секундах (длительность 0 будет пытаться воспроизводить вибрацию бесконечно). Вибрацию можно остановить заранее, вызвав :ref:`stop_joy_vibration()<class_Input_method_stop_joy_vibration>`.
\ **Примечание:** Не все устройства совместимо с длительными эффектами; рекомендуется перезапустить эффект, если его нужно воспроизводить более нескольких секунд.
\ **Примечание:** Для macOS вибрация поддерживается только в macOS 11 и более поздних версиях.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_stop_joy_vibration:
.. rst-class:: classref-method
|void| **stop_joy_vibration**\ (\ device\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Input_method_stop_joy_vibration>`
Останавливает вибрацию джойстика, запущенную с помощью :ref:`start_joy_vibration()<class_Input_method_start_joy_vibration>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_vibrate_handheld:
.. rst-class:: classref-method
|void| **vibrate_handheld**\ (\ duration_ms\: :ref:`int<class_int>` = 500, amplitude\: :ref:`float<class_float>` = -1.0\ ) :ref:`🔗<class_Input_method_vibrate_handheld>`
Вибрировать портативное устройство в течение указанной продолжительности в миллисекундах.
\ ``Amplitude`` — это сила вибрации, как значение между ``0.0`` и ``1.0``. Если установлено значение ``-1.0``, используется сила вибрации устройства по умолчанию.
\ **Примечание:** Этот метод реализован на Android, iOS и Web. Он не влияет на другие платформы.
\ **Примечание:** Для Android :ref:`vibrate_handheld()<class_Input_method_vibrate_handheld>` требует включения разрешения ``VIBRATE`` в предустановке экспорта. В противном случае :ref:`vibrate_handheld()<class_Input_method_vibrate_handheld>` не будет иметь никакого эффекта.
\ **Примечание:** Для iOS указание продолжительности поддерживается только в iOS 13 и более поздних версиях.
\ **Примечание:** Для Web амплитуду изменить нельзя.
\ **Примечание:** Некоторые веб-браузеры, такие как Safari и Firefox для Android, не поддерживают :ref:`vibrate_handheld()<class_Input_method_vibrate_handheld>`.
.. rst-class:: classref-item-separator
----
.. _class_Input_method_warp_mouse:
.. rst-class:: classref-method
|void| **warp_mouse**\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Input_method_warp_mouse>`
Устанавливает положение мыши на указанный вектор, указанный в пикселях и относительно начала координат в верхнем левом углу текущего окна игры диспетчера окон.
Положение мыши обрезается до границ разрешения экрана или до границ окна игры, если :ref:`MouseMode<enum_Input_MouseMode>` установлен на :ref:`MOUSE_MODE_CONFINED<class_Input_constant_MOUSE_MODE_CONFINED>` или :ref:`MOUSE_MODE_CONFINED_HIDDEN<class_Input_constant_MOUSE_MODE_CONFINED_HIDDEN>`.
\ **Примечание:** :ref:`warp_mouse()<class_Input_method_warp_mouse>` поддерживается только в Windows, macOS и Linux. Он не действует на Android, iOS и Web.
.. |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