Enabling this can greatly improve the responsiveness to input, specially in devices that need to run multiple physics frames per visible (process) frame, because they can't run at the target frame rate.

[b]Note:[/b] Currently implemented only on Android.

</member>

<member name="input_devices/compatibility/legacy_just_pressed_behavior" type="bool" setter="" getter="" default="false">

If [code]true[/code], [method Input.is_action_just_pressed] and [method Input.is_action_just_released] will only return [code]true[/code] if the action is still in the respective state, i.e. an action that is pressed [i]and[/i] released on the same frame will be missed.

If [code]false[/code], no input will be lost.

EDITOR_SETTING(Variant::INT, PROPERTY_HINT_ENUM, "interface/editor/vsync_mode", 1, "Disabled,Enabled,Adaptive,Mailbox")

EDITOR_SETTING(Variant::BOOL, PROPERTY_HINT_NONE, "interface/editor/update_continuously", false, "")

// Inspector

EDITOR_SETTING(Variant::INT, PROPERTY_HINT_RANGE, "interface/inspector/max_array_dictionary_items_per_page", 20, "10,100,1")

EDITOR_SETTING(Variant::BOOL, PROPERTY_HINT_NONE, "interface/inspector/show_low_level_opentype_features", false, "")

id->set_emulate_mouse_from_touch(bool(GLOBAL_DEF_BASIC("input_devices/pointing/emulate_mouse_from_touch", true)));

}

GLOBAL_DEF_BASIC("input_devices/pointing/android/enable_long_press_as_right_click", false);

GLOBAL_DEF_BASIC("input_devices/pointing/android/enable_pan_and_scale_gestures", false);

GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "input_devices/pointing/android/rotary_input_scroll_axis", PROPERTY_HINT_ENUM, "Horizontal,Vertical"), 1);

android:hasFragileUserData="false"

android:requestLegacyExternalStorage="false"

tools:ignore="GoogleAppIndexingWarning" >

<!-- Records the version of the Godot editor used for building -->

<meta-data

val longPressEnabled = enableLongPressGestures()

val panScaleEnabled = enablePanAndScaleGestures()

checkForProjectPermissionsToEnable()

runOnUiThread {

godotFragment?.godot?.renderView?.inputHandler?.apply {

enableLongPress(longPressEnabled)

enablePanningAndScalingGestures(panScaleEnabled)

}

}

}

java.lang.Boolean.parseBoolean(GodotLib.getEditorSetting("interface/touchscreen/enable_pan_and_scale_gestures"))

/**

* Whether we should launch the new godot instance in an adjacent window

* @see https://developer.android.com/reference/android/content/Intent#FLAG_ACTIVITY_LAUNCH_ADJACENT

*/

package org.godotengine.editor

/**

* Drives the 'run project' window of the Godot Editor.

*/

override fun overrideOrientationRequest() = false

override fun checkForProjectPermissionsToEnable() {

// Nothing to do.. by the time we get here, the project permissions will have already

private companion object {

private val TAG = Godot::class.java.simpleName

}

private val windowManager: WindowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager

return

}

darkMode = context.resources?.configuration?.uiMode?.and(Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES

beginBenchmarkMeasure("Startup", "Godot::onCreate")

val activity = requireActivity()

val window = activity.window

window.addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)

GodotPluginRegistry.initializePluginRegistry(this, primaryHost.getHostPlugins(this))

if (io == null) {

io = GodotIO(activity)

return false

}

beginBenchmarkMeasure("Startup", "Godot::onInitNativeLayer")

try {

if (expansionPackPath.isNotEmpty()) {

fileAccessHandler,

useApkExpansion,

)

}

if (nativeLayerInitializeCompleted && !nativeLayerSetupCompleted) {

nativeLayerSetupCompleted = GodotLib.setup(commandLine.toTypedArray(), tts)

if (!nativeLayerSetupCompleted) {

throw IllegalStateException("Unable to setup the Godot engine! Aborting...")

}

}

} finally {

throw IllegalStateException("onInitNativeLayer() must be invoked successfully prior to initializing the render view")

}

beginBenchmarkMeasure("Startup", "Godot::onInitRenderView")

try {

val activity: Activity = host.activity

}

fun onStart(host: GodotHost) {

if (host != primaryHost) {

return

}

}

fun onResume(host: GodotHost) {

if (host != primaryHost) {

return

}

}

fun onPause(host: GodotHost) {

if (host != primaryHost) {

return

}

}

fun onStop(host: GodotHost) {

if (host != primaryHost) {

return

}

}

fun onDestroy(primaryHost: GodotHost) {

if (this.primaryHost != primaryHost) {

return

}

* Invoked on the render thread when the Godot setup is complete.

*/

private fun onGodotSetupCompleted() {

}

}

}

* Invoked on the render thread when the Godot main loop has started.

*/

private fun onGodotMainLoopStarted() {

for (plugin in pluginRegistry.allPlugins) {

plugin.onGodotMainLoopStarted()

return mClipboard.hasPrimaryClip()

}

fun getClipboard(): String {

val clipData = mClipboard.primaryClip ?: return ""

val text = clipData.getItemAt(0).text ?: return ""

* @see GodotRenderer#onActivityPaused()

*/

public static native void onRendererPaused();

}

mHasSurface = true;

mFinishedCreatingEglSurface = false;

sGLThreadManager.notifyAll();

}

}

}

mHasSurface = false;

sGLThreadManager.notifyAll();

}

}

}

mRequestPaused = true;

sGLThreadManager.notifyAll();

}

}

mRequestRender = true;

mRenderComplete = false;

sGLThreadManager.notifyAll();

}

}

}

sGLThreadManager.notifyAll();

}

}

* @See https://developer.android.com/reference/android/view/GestureDetector.SimpleOnGestureListener

* @See https://developer.android.com/reference/android/view/ScaleGestureDetector.OnScaleGestureListener

*/

companion object {

private val TAG = GodotGestureHandler::class.java.simpleName

private var lastDragY: Float = 0.0f

override fun onDown(event: MotionEvent): Boolean {

nextDownIsDoubleTap = false

return true

}

override fun onSingleTapUp(event: MotionEvent): Boolean {

return true

}

}

// Cancel the previous down event

// Turn a context click into a single tap right mouse button click.

event,

MotionEvent.ACTION_DOWN,

MotionEvent.BUTTON_SECONDARY,

if (!hasCapture) {

// Dispatch a mouse relative ACTION_UP event to signal the end of the capture

}

pointerCaptureInProgress = hasCapture

}

if (contextClickInProgress || GodotInputHandler.isMouseEvent(event)) {

// This may be an ACTION_BUTTON_RELEASE event which we don't handle,

// so we convert it to an ACTION_UP event.

} else {

}

pointerCaptureInProgress = false

dragInProgress = false

private fun onActionMove(event: MotionEvent): Boolean {

if (contextClickInProgress) {

return true

} else if (!scaleInProgress) {

// The 'onScroll' event is triggered with a long delay.

if (lastDragX != event.getX(0) || lastDragY != event.getY(0)) {

lastDragX = event.getX(0)

lastDragY = event.getY(0)

return true

}

}

override fun onDoubleTapEvent(event: MotionEvent): Boolean {

if (event.actionMasked == MotionEvent.ACTION_UP) {

nextDownIsDoubleTap = false

} else if (event.actionMasked == MotionEvent.ACTION_MOVE && !panningAndScalingEnabled) {

}

return true

if (dragInProgress || lastDragX != 0.0f || lastDragY != 0.0f) {

if (originEvent != null) {

// Cancel the drag

}

dragInProgress = false

lastDragX = 0.0f

val x = terminusEvent.x

val y = terminusEvent.y

if (terminusEvent.pointerCount >= 2 && panningAndScalingEnabled && !pointerCaptureInProgress && !dragInProgress) {

} else if (!scaleInProgress) {

dragInProgress = true

lastDragX = terminusEvent.getX(0)

lastDragY = terminusEvent.getY(0)

}

return true

}

}

if (detector.scaleFactor >= 0.8f && detector.scaleFactor != 1f && detector.scaleFactor <= 1.2f) {

}

return true

}

*/

private int lastSeenToolType = MotionEvent.TOOL_TYPE_UNKNOWN;

public GodotInputHandler(GodotRenderView godotView) {

final Context context = godotView.getView().getContext();

mInputManager = (InputManager)context.getSystemService(Context.INPUT_SERVICE);

mInputManager.registerInputDeviceListener(this, null);

this.gestureDetector = new GestureDetector(context, godotGestureHandler);

this.gestureDetector.setIsLongpressEnabled(false);

this.scaleGestureDetector = new ScaleGestureDetector(context, godotGestureHandler);

}

/**

* On Wear OS devices, sets which axis of the mouse wheel rotary input is mapped to. This is 1 (vertical axis) by default.

*/

public void setRotaryInputAxis(int axis) {

if (mJoystickIds.indexOfKey(deviceId) >= 0) {

final int button = getGodotButton(keyCode);

final int godotJoyId = mJoystickIds.get(deviceId);

}

} else {

// getKeyCode(): The physical key that was pressed.

final int physical_keycode = event.getKeyCode();

final int unicode = event.getUnicodeChar();

final int key_label = event.getDisplayLabel();

};

return true;

if (mJoystickIds.indexOfKey(deviceId) >= 0) {

final int button = getGodotButton(keyCode);

final int godotJoyId = mJoystickIds.get(deviceId);

}

} else {

final int physical_keycode = event.getKeyCode();

final int unicode = event.getUnicodeChar();

final int key_label = event.getDisplayLabel();

}

return true;

if (joystick.axesValues.indexOfKey(axis) < 0 || (float)joystick.axesValues.get(axis) != value) {

// save value to prevent repeats

joystick.axesValues.put(axis, value);

}

}

if (joystick.hatX != hatX || joystick.hatY != hatY) {

joystick.hatX = hatX;

joystick.hatY = hatY;

}

}

return true;

int[] deviceIds = mInputManager.getInputDeviceIds();

for (int deviceId : deviceIds) {

InputDevice device = mInputManager.getInputDevice(deviceId);

}

}

}

}

mJoysticksDevices.put(deviceId, joystick);

}

@Override

final int godotJoyId = mJoystickIds.get(deviceId);

mJoystickIds.delete(deviceId);

mJoysticksDevices.delete(deviceId);

}

@Override

}

}

return handleMotionEvent(event, event.getActionMasked());

}

return handleMotionEvent(event, eventActionOverride, false);

}

if (isMouseEvent(event)) {

return handleMouseEvent(event, eventActionOverride, doubleTap);

}

return (float)Math.cos(orientation) * tiltMult;

}

return handleMouseEvent(event, event.getActionMasked());

}

return handleMouseEvent(event, eventActionOverride, false);

}

return handleMouseEvent(event, eventActionOverride, event.getButtonState(), doubleTap);

}

final float x = event.getX();

final float y = event.getY();

return handleMouseEvent(eventActionOverride, buttonMaskOverride, x, y, horizontalFactor, verticalFactor, doubleTap, sourceMouseRelative, pressure, getEventTiltX(event), getEventTiltY(event));

}

return handleMouseEvent(eventAction, 0, 0f, 0f, 0f, 0f, false, sourceMouseRelative, 1f, 0f, 0f);

}

// Fix the buttonsMask

switch (eventAction) {

case MotionEvent.ACTION_CANCEL:

break;

}

// We don't handle ACTION_BUTTON_PRESS and ACTION_BUTTON_RELEASE events as they typically

// follow ACTION_DOWN and ACTION_UP events. As such, handling them would result in duplicate

// stream of events to the engine.

case MotionEvent.ACTION_HOVER_MOVE:

case MotionEvent.ACTION_MOVE:

case MotionEvent.ACTION_SCROLL: {

return true;

}

}

return false;

}

return handleTouchEvent(event, event.getActionMasked());

}

return handleTouchEvent(event, eventActionOverride, false);

}

final int pointerCount = event.getPointerCount();

if (pointerCount == 0) {

return true;

case MotionEvent.ACTION_MOVE:

case MotionEvent.ACTION_POINTER_UP:

case MotionEvent.ACTION_POINTER_DOWN: {

return true;

}

}

return false;

}

}

@Override

public void beforeTextChanged(final CharSequence pCharSequence, final int start, final int count, final int after) {

for (int i = 0; i < count; ++i) {

if (mHasSelection) {

mHasSelection = false;

// Return keys are handled through action events

continue;

}

}

}

if (characters != null) {

for (int i = 0; i < characters.length(); i++) {

final int character = characters.codePointAt(i);

}

}

}

if (pActionID == EditorInfo.IME_ACTION_DONE) {

// Enter key has been pressed

mRenderView.getView().requestFocus();

return true;

}

os_android->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_PAUSED);

}

}

}

JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_onNightModeChanged(JNIEnv *env, jclass clazz);

JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_onRendererResumed(JNIEnv *env, jclass clazz);

JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_onRendererPaused(JNIEnv *env, jclass clazz);

}

#endif // JAVA_GODOT_LIB_JNI_H