mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
1248 lines
104 KiB
ReStructuredText
1248 lines
104 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_Input:
|
||
|
||
Input
|
||
=====
|
||
|
||
**Успадковує:** :ref:`Object<class_Object>`
|
||
|
||
Однотон для введення даних.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Опис
|
||
--------
|
||
|
||
**Input** однотонні ручки клавішні преси, кнопки миші і рух, ігрові блоки і вхідні дії. Дії та події можуть бути встановлені в вкладці ** Вхідна карта ** **Проект > Параметри проекту**, або з класом :ref:`InputMap<class_InputMap>`.
|
||
|
||
\ **Примітка:** **Input** методи відображають глобальний вхідний стан і не впливають на :ref:`управління.accept_event()<class_управління_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>`
|
||
|
||
Випробувано, коли підключено пристрій Hotpad.
|
||
|
||
.. 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-beam курсор. Зазвичай використовується для відображення, коли натискається курсор тексту.
|
||
|
||
.. _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.
|
||
|
||
Скупчення введення може бути вимкнено, щоб отримати трохи більш точний/реактивний вхід за вартістю збільшення використання процесора. У додатках, де потрібно малювати вільні лінії, вводне накопичення повинно бути відключено, поки користувач є кресленням лінії, щоб отримати результати, які уважно слідують фактичному вводі.
|
||
|
||
\ **Note:** Скупчення входу *enabled* за замовчуванням.
|
||
|
||
.. 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:`_action_pressed()<class_Input_private_method__action_pressed>` і :ref:`_action_just_pressed()<class_Input_private_method__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>`.
|
||
|
||
Якщо ``точний_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("негатив_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>`
|
||
|
||
Повертає силу тяжіння в м/с² датчика акселерометра пристрою, якщо він є. В іншому випадку метод повертає :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 на платформах, які використовують відстеження GamePad, E.G. `` 030000004c050000c405000000010000 ``. Повертає порожню рядок, якщо вона не знайдена. Готе, що він використовує [url = https: //github.com/gabomdq/sdl_gamecontrollerdb] База даних ігрового контролера SDL2 [/uri], щоб визначити імена GamePad та відображення на основі цього GUID.
|
||
|
||
На Windows всі GoStoD Godot JodePad будуть перевизначені за допомогою [code] __ xinput_device __ [/code], тому що їх відображення однакові.
|
||
|
||
.. 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 контролер``. 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 - сила слабкого мотора, і є міцністю міцного двигуна.
|
||
|
||
.. 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.1s. Таким чином, швидкість мишки відставить рухи миші.
|
||
|
||
.. 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.1s. Таким чином, швидкість мишки відставить рухи миші.
|
||
|
||
.. 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>`
|
||
|
||
Повертаємо кнопки миші як трохи. Якщо кілька кліків мишки натискаються одночасно, укуси додаються разом. Equivalent to :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:`_action_pressed()<class_Input_private_method__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``, якщо будь-яка дія, ключ, кнопка Hotpad або кнопка миша натискається. Це також повернеться ``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``, надрукованим на ньому. Ви можете пройти постійний або будь-який код символів 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_phys_key_pressed()<class_Input_method_is_phys_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 = правда
|
||
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**. Режим стиснення **відеопам’яті** можна використовувати, але він буде розпакований на процесорі, що означає сповільнення часу завантаження та відсутність збереження пам’яті порівняно з режимами без втрат.
|
||
|
||
\ **Примітка:** На веб-платформі максимально дозволений розмір зображення курсора становить 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>`, скористайтеся ``email protected``.
|
||
|
||
\ **Примітка:** Цей метод генерує ``InputEventMouseMouseMouseMouseMotion`` для оновлення курсора відразу.
|
||
|
||
.. 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>`
|
||
|
||
Налаштовує значення ваги акселерометра. Може використовуватися для відбілювання на пристроях без апаратного датчика, наприклад, в редакторі на ПК.
|
||
|
||
\ **Примітка:** Дане значення може бути відразу переписано значення датчика обладнання на 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>`__ для отримання додаткової інформації.
|
||
|
||
\ **Примітка:** Деякі 3rd party інструменти можуть сприяти списку ігноруваних пристроїв. Наприклад, *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>`
|
||
|
||
Починає вібрувати гумку. Joypads, як правило, приходять з двома двигунами, міцними і слабкими. ``слабкий_magnitude`` - сила слабкого мотора (between 0 і 1) і ``strong_magnitude`` - сила сильного двигуна (between 0 і 1). ``тривалість пари`` – тривалість ефекту за секундами (тривалість 0 намагатиметься відтворити вібрацію невизначено). Вібрація може бути припинена на початку виклику :ref:`зупинки_joy_vibration()<class_Input_method_зупинки_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:`_joy_vibration()<class_Input_private_method__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. Не впливає на інші платформи.
|
||
|
||
\ **Примітка:** Для Андроїд, :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 (Значення не повертається.)`
|