Class Input

A singleton for handling inputs.

Inheritance: Object

Input

Remarks

The Input singleton handles key presses, mouse buttons and movement, gamepads, and input actions. Actions and their events can be set in the Input Map tab in Project > Project Settings, or with the InputMap class.

Note: Input's methods reflect the global input state and are not affected by accept_event or set_input_as_handled, as those methods only deal with the way input is propagated in the SceneTree.

Properties

emulate_mouse_from_touch

If true, sends mouse input events when tapping or swiping on the touchscreen. See also input_devices/pointing/emulate_mouse_from_touch.

var emulate_mouse_from_touch : bool

Property Value

bool

Remarks

void set_emulate_mouse_from_touch(bool value)
bool is_emulating_mouse_from_touch

emulate_touch_from_mouse

If true, sends touch input events when clicking or dragging the mouse. See also input_devices/pointing/emulate_touch_from_mouse.

var emulate_touch_from_mouse : bool

Property Value

bool

Remarks

void set_emulate_touch_from_mouse(bool value)
bool is_emulating_touch_from_mouse

mouse_mode

Controls the mouse mode. See MouseMode for more information.

var mouse_mode : int

Property Value

int

Remarks

void set_mouse_mode(int value)
int get_mouse_mode

use_accumulated_input

If true, similar input events sent by the operating system are accumulated. When input accumulation is enabled, all input events generated during a frame will be merged and emitted when the frame is done rendering. Therefore, this limits the number of input method calls per second to the rendering FPS.

Input accumulation can be disabled to get slightly more precise/reactive input at the cost of increased CPU usage. In applications where drawing freehand lines is required, input accumulation should generally be disabled while the user is drawing the line to get results that closely follow the actual input.

Note: Input accumulation is enabled by default.

var use_accumulated_input : bool

Property Value

bool

Remarks

void set_use_accumulated_input(bool value)
bool is_using_accumulated_input

Methods

action_press(StringName, float)

This will simulate pressing the specified action.

The strength can be used for non-boolean actions, it's ranged between 0 and 1 representing the intensity of the given action.

Note: This method will not cause any Node._input calls. It is intended to be used with Input.is_action_pressed and Input.is_action_just_pressed. If you want to simulate _input, use Input.parse_input_event instead.

void action_press(StringName action, float strength)

Parameters

action StringName
strength float

action_release(StringName)

If the specified action is already pressed, this will release it.

void action_release(StringName action)

Parameters

action StringName

add_joy_mapping(String, bool)

Adds a new mapping entry (in SDL2 format) to the mapping database. Optionally update already connected devices.

void add_joy_mapping(String mapping, bool update_existing)

Parameters

mapping String
update_existing bool

flush_buffered_events

Sends all input events which are in the current buffer to the game loop. These events may have been buffered as a result of accumulated input (use_accumulated_input) or agile input flushing (input_devices/buffering/agile_event_flushing).

The engine will already do this itself at key execution points (at least once per frame). However, this can be useful in advanced cases where you want precise control over the timing of event handling.

void flush_buffered_events

get_accelerometer

Qualifiers: const

Returns the acceleration in m/s² of the device's accelerometer sensor, if the device has one. Otherwise, the method returns ZERO.

Note this method returns an empty Vector3 when running from the editor even when your device has an accelerometer. You must export your project to a supported device to read values from the accelerometer.

Note: This method only works on Android and iOS. On other platforms, it always returns ZERO.

Note: For Android, input_devices/sensors/enable_accelerometer must be enabled.

Vector3 get_accelerometer

get_action_raw_strength(StringName, bool)

Qualifiers: const

Returns a value between 0 and 1 representing the raw intensity of the given action, ignoring the action's deadzone. In most cases, you should use Input.get_action_strength instead.

If exact_match is false, it ignores additional input modifiers for InputEventKey and InputEventMouseButton events, and the direction for InputEventJoypadMotion events.

float get_action_raw_strength(StringName action, bool exact_match)

Parameters

action StringName
exact_match bool

get_action_strength(StringName, bool)

Qualifiers: const

Returns a value between 0 and 1 representing the intensity of the given action. In a joypad, for example, the further away the axis (analog sticks or L2, R2 triggers) is from the dead zone, the closer the value will be to 1. If the action is mapped to a control that has no axis such as the keyboard, the value returned will be 0 or 1.

If exact_match is false, it ignores additional input modifiers for InputEventKey and InputEventMouseButton events, and the direction for InputEventJoypadMotion events.

float get_action_strength(StringName action, bool exact_match)

Parameters

action StringName
exact_match bool

get_axis(StringName, StringName)

Qualifiers: const

Get axis input by specifying two actions, one negative and one positive.

This is a shorthand for writing Input.get_action_strength("positive_action") - Input.get_action_strength("negative_action").

float get_axis(StringName negative_action, StringName positive_action)

Parameters

negative_action StringName
positive_action StringName

get_connected_joypads

Returns an Array containing the device IDs of all currently connected joypads.

int[] get_connected_joypads

get_current_cursor_shape

Qualifiers: const

Returns the currently assigned cursor shape (see CursorShape).

int get_current_cursor_shape

get_gravity

Qualifiers: const

Returns the gravity in m/s² of the device's accelerometer sensor, if the device has one. Otherwise, the method returns ZERO.

Note: This method only works on Android and iOS. On other platforms, it always returns ZERO.

Note: For Android, input_devices/sensors/enable_gravity must be enabled.

Vector3 get_gravity

get_gyroscope

Qualifiers: const

Returns the rotation rate in rad/s around a device's X, Y, and Z axes of the gyroscope sensor, if the device has one. Otherwise, the method returns ZERO.

Note: This method only works on Android and iOS. On other platforms, it always returns ZERO.

Note: For Android, input_devices/sensors/enable_gyroscope must be enabled.

Vector3 get_gyroscope

get_joy_axis(int, int)

Qualifiers: const

Returns the current value of the joypad axis at given index (see JoyAxis).

float get_joy_axis(int device, int axis)

Parameters

device int
axis int

get_joy_guid(int)

Qualifiers: const

Returns an SDL2-compatible device GUID on platforms that use gamepad remapping, e.g. 030000004c050000c405000000010000. Returns an empty string if it cannot be found. Godot uses the SDL2 game controller database to determine gamepad names and mappings based on this GUID.

On Windows, all XInput joypad GUIDs will be overridden by Godot to __XINPUT_DEVICE__, because their mappings are the same.

String get_joy_guid(int device)

Parameters

device int

get_joy_info(int)

Qualifiers: const

Returns a dictionary with extra platform-specific information about the device, e.g. the raw gamepad name from the OS or the Steam Input index.

On Windows, the dictionary contains the following fields:

xinput_index: The index of the controller in the XInput system. Undefined for DirectInput devices.

vendor_id: The USB vendor ID of the device.

product_id: The USB product ID of the device.

On Linux:

raw_name: The name of the controller as it came from the OS, before getting renamed by the godot controller database.

vendor_id: The USB vendor ID of the device.

product_id: The USB product ID of the device.

steam_input_index: The Steam Input gamepad index, if the device is not a Steam Input device this key won't be present.

Note: The returned dictionary is always empty on Web, iOS, Android, and macOS.

Dictionary get_joy_info(int device)

Parameters

device int

get_joy_name(int)

Returns the name of the joypad at the specified device index, e.g. PS4 Controller. Godot uses the SDL2 game controller database to determine gamepad names.

String get_joy_name(int device)

Parameters

device int

get_joy_vibration_duration(int)

Returns the duration of the current vibration effect in seconds.

float get_joy_vibration_duration(int device)

Parameters

device int

get_joy_vibration_strength(int)

Returns the strength of the joypad vibration: x is the strength of the weak motor, and y is the strength of the strong motor.

Vector2 get_joy_vibration_strength(int device)

Parameters

device int

get_last_mouse_screen_velocity

Returns the last mouse velocity in screen coordinates. To provide a precise and jitter-free velocity, mouse velocity is only calculated every 0.1s. Therefore, mouse velocity will lag mouse movements.

Vector2 get_last_mouse_screen_velocity

get_last_mouse_velocity

Returns the last mouse velocity. To provide a precise and jitter-free velocity, mouse velocity is only calculated every 0.1s. Therefore, mouse velocity will lag mouse movements.

Vector2 get_last_mouse_velocity

get_magnetometer

Qualifiers: const

Returns the magnetic field strength in micro-Tesla for all axes of the device's magnetometer sensor, if the device has one. Otherwise, the method returns ZERO.

Note: This method only works on Android and iOS. On other platforms, it always returns ZERO.

Note: For Android, input_devices/sensors/enable_magnetometer must be enabled.

Vector3 get_magnetometer

get_mouse_button_mask

Qualifiers: const

Returns mouse buttons as a bitmask. If multiple mouse buttons are pressed at the same time, the bits are added together. Equivalent to mouse_get_button_state.

int get_mouse_button_mask

get_vector(StringName, StringName, StringName, StringName, float)

Qualifiers: const

Gets an input vector by specifying four actions for the positive and negative X and Y axes.

This method is useful when getting vector input, such as from a joystick, directional pad, arrows, or WASD. The vector has its length limited to 1 and has a circular deadzone, which is useful for using vector input as movement.

By default, the deadzone is automatically calculated from the average of the action deadzones. However, you can override the deadzone to be whatever you want (on the range of 0 to 1).

Vector2 get_vector(StringName negative_x, StringName positive_x, StringName negative_y, StringName positive_y, float deadzone)

Parameters

negative_x StringName
positive_x StringName
negative_y StringName
positive_y StringName
deadzone float

is_action_just_pressed(StringName, bool)

Qualifiers: const

Returns true when the user has started pressing the action event in the current frame or physics tick. It will only return true on the frame or tick that the user pressed down the button.

This is useful for code that needs to run only once when an action is pressed, instead of every frame while it's pressed.

If exact_match is false, it ignores additional input modifiers for InputEventKey and InputEventMouseButton events, and the direction for InputEventJoypadMotion events.

Note: Returning true does not imply that the action is still pressed. An action can be pressed and released again rapidly, and true will still be returned so as not to miss input.

Note: Due to keyboard ghosting, Input.is_action_just_pressed may return false even if one of the action's keys is pressed. See Input examples in the documentation for more information.

Note: During input handling (e.g. Node._input), use InputEvent.is_action_pressed instead to query the action state of the current event.

bool is_action_just_pressed(StringName action, bool exact_match)

Parameters

action StringName
exact_match bool

is_action_just_released(StringName, bool)

Qualifiers: const

Returns true when the user stops pressing the action event in the current frame or physics tick. It will only return true on the frame or tick that the user releases the button.

Note: Returning true does not imply that the action is still not pressed. An action can be released and pressed again rapidly, and true will still be returned so as not to miss input.

If exact_match is false, it ignores additional input modifiers for InputEventKey and InputEventMouseButton events, and the direction for InputEventJoypadMotion events.

Note: During input handling (e.g. Node._input), use InputEvent.is_action_released instead to query the action state of the current event.

bool is_action_just_released(StringName action, bool exact_match)

Parameters

action StringName
exact_match bool

is_action_pressed(StringName, bool)

Qualifiers: const

Returns true if you are pressing the action event.

If exact_match is false, it ignores additional input modifiers for InputEventKey and InputEventMouseButton events, and the direction for InputEventJoypadMotion events.

Note: Due to keyboard ghosting, Input.is_action_pressed may return false even if one of the action's keys is pressed. See Input examples in the documentation for more information.

bool is_action_pressed(StringName action, bool exact_match)

Parameters

action StringName
exact_match bool

is_anything_pressed

Qualifiers: const

Returns true if any action, key, joypad button, or mouse button is being pressed. This will also return true if any action is simulated via code by calling Input.action_press.

bool is_anything_pressed

is_joy_button_pressed(int, int)

Qualifiers: const

Returns true if you are pressing the joypad button (see JoyButton).

bool is_joy_button_pressed(int device, int button)

Parameters

device int
button int

is_joy_known(int)

Returns true if the system knows the specified device. This means that it sets all button and axis indices. Unknown joypads are not expected to match these constants, but you can still retrieve events from them.

bool is_joy_known(int device)

Parameters

device int

is_key_label_pressed(int)

Qualifiers: const

Returns true if you are pressing the key with the keycode printed on it. You can pass a Key constant or any Unicode character code.

bool is_key_label_pressed(int keycode)

Parameters

keycode int

is_key_pressed(int)

Qualifiers: const

Returns true if you are pressing the Latin key in the current keyboard layout. You can pass a Key constant.

Input.is_key_pressed is only recommended over Input.is_physical_key_pressed in non-game applications. This ensures that shortcut keys behave as expected depending on the user's keyboard layout, as keyboard shortcuts are generally dependent on the keyboard layout in non-game applications. If in doubt, use Input.is_physical_key_pressed.

Note: Due to keyboard ghosting, Input.is_key_pressed may return false even if one of the action's keys is pressed. See Input examples in the documentation for more information.

bool is_key_pressed(int keycode)

Parameters

keycode int

is_mouse_button_pressed(int)

Qualifiers: const

Returns true if you are pressing the mouse button specified with MouseButton.

bool is_mouse_button_pressed(int button)

Parameters

button int

is_physical_key_pressed(int)

Qualifiers: const

Returns true if you are pressing the key in the physical location on the 101/102-key US QWERTY keyboard. You can pass a Key constant.

Input.is_physical_key_pressed is recommended over Input.is_key_pressed for in-game actions, as it will make W/A/S/D layouts work regardless of the user's keyboard layout. Input.is_physical_key_pressed will also ensure that the top row number keys work on any keyboard layout. If in doubt, use Input.is_physical_key_pressed.

Note: Due to keyboard ghosting, Input.is_physical_key_pressed may return false even if one of the action's keys is pressed. See Input examples in the documentation for more information.

bool is_physical_key_pressed(int keycode)

Parameters

keycode int

parse_input_event(InputEvent)

Feeds an InputEvent to the game. Can be used to artificially trigger input events from code. Also generates Node._input calls.

gdscript
C#

var cancel_event = InputEventAction.new()
cancel_event.action = "ui_cancel"
cancel_event.pressed = true
Input.parse_input_event(cancel_event)

var cancelEvent = new InputEventAction();
cancelEvent.Action = "ui_cancel";
cancelEvent.Pressed = true;
Input.ParseInputEvent(cancelEvent);

Note: Calling this function has no influence on the operating system. So for example sending an InputEventMouseMotion will not move the OS mouse cursor to the specified position (use Input.warp_mouse instead) and sending Alt/Cmd + Tab as InputEventKey won't toggle between active windows.

void parse_input_event(InputEvent event)

Parameters

event InputEvent

remove_joy_mapping(String)

Removes all mappings from the internal database that match the given GUID. All currently connected joypads that use this GUID will become unmapped.

On Android, Godot will map to an internal fallback mapping.

void remove_joy_mapping(String guid)

Parameters

guid String

set_accelerometer(Vector3)

Sets the acceleration value of the accelerometer sensor. Can be used for debugging on devices without a hardware sensor, for example in an editor on a PC.

Note: This value can be immediately overwritten by the hardware sensor value on Android and iOS.

void set_accelerometer(Vector3 value)

Parameters

value Vector3

set_custom_mouse_cursor(Resource, int, Vector2)

Sets a custom mouse cursor image, which is only visible inside the game window. The hotspot can also be specified. Passing null to the image parameter resets to the system cursor. See CursorShape for the list of shapes.

image can be either Texture2D or Image and its size must be lower than or equal to 256×256. To avoid rendering issues, sizes lower than or equal to 128×128 are recommended.

hotspot must be within image's size.

Note: AnimatedTextures aren't supported as custom mouse cursors. If using an AnimatedTexture, only the first frame will be displayed.

Note: The Lossless, Lossy or Uncompressed compression modes are recommended. The Video RAM compression mode can be used, but it will be decompressed on the CPU, which means loading times are slowed down and no memory is saved compared to lossless modes.

Note: On the web platform, the maximum allowed cursor image size is 128×128. Cursor images larger than 32×32 will also only be displayed if the mouse cursor image is entirely located within the page for security reasons.

void set_custom_mouse_cursor(Resource image, int shape, Vector2 hotspot)

Parameters

image Resource
shape int
hotspot Vector2

set_default_cursor_shape(int)

Sets the default cursor shape to be used in the viewport instead of Input.CURSOR_ARROW.

Note: If you want to change the default cursor shape for Control's nodes, use mouse_default_cursor_shape instead.

Note: This method generates an InputEventMouseMotion to update cursor immediately.

void set_default_cursor_shape(int shape)

Parameters

shape int

set_gravity(Vector3)

Sets the gravity value of the accelerometer sensor. Can be used for debugging on devices without a hardware sensor, for example in an editor on a PC.

Note: This value can be immediately overwritten by the hardware sensor value on Android and iOS.

void set_gravity(Vector3 value)

Parameters

value Vector3

set_gyroscope(Vector3)

Sets the value of the rotation rate of the gyroscope sensor. Can be used for debugging on devices without a hardware sensor, for example in an editor on a PC.

Note: This value can be immediately overwritten by the hardware sensor value on Android and iOS.

void set_gyroscope(Vector3 value)

Parameters

value Vector3

set_magnetometer(Vector3)

Sets the value of the magnetic field of the magnetometer sensor. Can be used for debugging on devices without a hardware sensor, for example in an editor on a PC.

Note: This value can be immediately overwritten by the hardware sensor value on Android and iOS.

void set_magnetometer(Vector3 value)

Parameters

value Vector3

should_ignore_device(int, int)

Qualifiers: const

Queries whether an input device should be ignored or not. Devices can be ignored by setting the environment variable SDL_GAMECONTROLLER_IGNORE_DEVICES. Read the SDL documentation for more information.

Note: Some 3rd party tools can contribute to the list of ignored devices. For example, SteamInput creates virtual devices from physical devices for remapping purposes. To avoid handling the same input device twice, the original device is added to the ignore list.

bool should_ignore_device(int vendor_id, int product_id)

Parameters

vendor_id int
product_id int

start_joy_vibration(int, float, float, float)

Starts to vibrate the joypad. Joypads usually come with two rumble motors, a strong and a weak one. weak_magnitude is the strength of the weak motor (between 0 and 1) and strong_magnitude is the strength of the strong motor (between 0 and 1). duration is the duration of the effect in seconds (a duration of 0 will try to play the vibration indefinitely). The vibration can be stopped early by calling Input.stop_joy_vibration.

Note: Not every hardware is compatible with long effect durations; it is recommended to restart an effect if it has to be played for more than a few seconds.

Note: For macOS, vibration is only supported in macOS 11 and later.

void start_joy_vibration(int device, float weak_magnitude, float strong_magnitude, float duration)

Parameters

device int
weak_magnitude float
strong_magnitude float
duration float

stop_joy_vibration(int)

Stops the vibration of the joypad started with Input.start_joy_vibration.

void stop_joy_vibration(int device)

Parameters

device int

vibrate_handheld(int, float)

Vibrate the handheld device for the specified duration in milliseconds.

amplitude is the strength of the vibration, as a value between 0.0 and 1.0. If set to -1.0, the default vibration strength of the device is used.

Note: This method is implemented on Android, iOS, and Web. It has no effect on other platforms.

Note: For Android, Input.vibrate_handheld requires enabling the VIBRATE permission in the export preset. Otherwise, Input.vibrate_handheld will have no effect.

Note: For iOS, specifying the duration is only supported in iOS 13 and later.

Note: For Web, the amplitude cannot be changed.

Note: Some web browsers such as Safari and Firefox for Android do not support Input.vibrate_handheld.

void vibrate_handheld(int duration_ms, float amplitude)

Parameters

duration_ms int
amplitude float

warp_mouse(Vector2)

Sets the mouse position to the specified vector, provided in pixels and relative to an origin at the upper left corner of the currently focused Window Manager game window.

Mouse position is clipped to the limits of the screen resolution, or to the limits of the game window if MouseMode is set to Input.MOUSE_MODE_CONFINED or Input.MOUSE_MODE_CONFINED_HIDDEN.

Note: Input.warp_mouse is only supported on Windows, macOS and Linux. It has no effect on Android, iOS and Web.

void warp_mouse(Vector2 position)

Parameters

position Vector2

Events

joy_connection_changed(int, bool)

Emitted when a joypad device has been connected or disconnected.

signal joy_connection_changed(int device, bool connected)

Parameters

device int
connected bool

Table of Contents

Class Input

Remarks

See Also

Properties

emulate_mouse_from_touch

Property Value

Remarks

emulate_touch_from_mouse

Property Value

Remarks

mouse_mode

Property Value

Remarks

use_accumulated_input

Property Value

Remarks

Methods

action_press(StringName, float)

Parameters

action_release(StringName)

Parameters

add_joy_mapping(String, bool)

Parameters

flush_buffered_events

get_accelerometer

get_action_raw_strength(StringName, bool)

Parameters

get_action_strength(StringName, bool)

Parameters

get_axis(StringName, StringName)

Parameters

get_connected_joypads

get_current_cursor_shape

get_gravity

get_gyroscope

get_joy_axis(int, int)

Parameters

get_joy_guid(int)

Parameters

get_joy_info(int)

Parameters

get_joy_name(int)

Parameters

get_joy_vibration_duration(int)

Parameters

get_joy_vibration_strength(int)

Parameters

get_last_mouse_screen_velocity

get_last_mouse_velocity

get_magnetometer

get_mouse_button_mask

get_vector(StringName, StringName, StringName, StringName, float)

Parameters

is_action_just_pressed(StringName, bool)

Parameters

is_action_just_released(StringName, bool)

Parameters

is_action_pressed(StringName, bool)

Parameters

is_anything_pressed

is_joy_button_pressed(int, int)

Parameters

is_joy_known(int)

Parameters

is_key_label_pressed(int)

Parameters

is_key_pressed(int)

Parameters

is_mouse_button_pressed(int)

Parameters

is_physical_key_pressed(int)

Parameters

parse_input_event(InputEvent)

Parameters

remove_joy_mapping(String)

Parameters

set_accelerometer(Vector3)

Parameters

set_custom_mouse_cursor(Resource, int, Vector2)