Rebinding in runtime not saving to .inputactions

[FeikoJoosten]

The function RequestNewBinding() in the following code is triggered by an Unity UI button to rebind my input action:

private void Awake() {
    controls = new TestInputActions();
    controls.TestMap.TestBinding.performed += NewactionOnPerformed;
}

private void OnDestroy() {
    controls.TestMap.TestBinding.performed -= NewactionOnPerformed;
}

private void TestBindingOnPerformed(InputAction.CallbackContext callbackContext) {
    Debug.Log("Action performed");
}

public void RequestNewBinding() {
    InputAction actionToUse = inputActions.actionMaps[0].actions[0];
    rebindOperation = actionToUse.PerformInteractiveRebinding().WithRebindAddingNewBinding().Start();
}

Adding a rebind like this, will add the new binding to the InputActionsReference. However, it's only usable in play mode after forcing an update to the InputActionReference.

When I'm using the rebind without .WithRebindAddingNewBinding(). The rebind doesn't even seem to register at all.

Repro steps:

1. Setup a simple InputAction with a button.
2. Setup code similar to what I'm doing.
3. Setup an Unity UI button which executes the code from step 2.
4. Enter play mode and click the button.
5. Press a new button for the binding to register.
6. Exit play mode and re-open your InputActionReference asset.
7. Notice a new binding has been added to your InputActionReference.
8. Enter play mode and try executing TestBindingOnPerformed using your new button.
9. Notice that the function does not execute, however your old binding still works (as intended because we use .WithRebindAddingNewBinding().
10. Exit play mode and make a change to the InputActionReference asset (without removing your newly added bindings).
11. Enter play mode and notice TestBindingOnPerformed now executes whenever you press your newly added binding.

[FeikoJoosten]

The issue 645 seems to be similar.

[Rene-Damm]

5. Press a new button for the binding to register.
6. Exit play mode and re-open your InputActionReference asset.
7. Notice a new binding has been added to your InputActionReference.

As of 0.9.3, this should not be happening anymore.

Overall, runtime rebinds not affecting the original .inputactions file is intentional. The rebind leaking out into the asset was an unintended side-effect of how the generated C# classes were previously set up. The mechanism has since been changed such that there no longer is a direct connection to the original .inputactions asset.

When I'm using the rebind without .WithRebindAddingNewBinding(). The rebind doesn't even seem to register at all.

Are you still seeing this issue as of 0.9.3? We had a bug where rebinds didn't trigger re-resolving of bindings and thus wouldn't take effect immediately. This has since been fixed.

[FeikoJoosten]

As of 0.9.3, this should not be happening anymore.
Overall, runtime rebinds not affecting the original .inputactions file is intentional. The rebind leaking out into the asset was an unintended side-effect of how the generated C# classes were previously set up. The mechanism has since been changed such that there no longer is a direct connection to the original .inputactions asset.

I've tried this again with the latest version that is currently available to download from within Unity
0.9.4-preview.

When following my reproduction steps, I was still able to leak the new input actions onto the .inputactions asset. Even during runtime.

Simply use the code from the example above, although you do have to disable the InputAction actionToUse before you setup and start the rebind operation.

1. During runtime rebind a key using the previous example With the .inputactions asset window open.
2. After having remapped a new button, close the .inputactions asset and reopen it again using the Edit asset button.
3. Notice that the button you pressed now shows up in the .inputactions asset.

Are you still seeing this issue as of 0.9.3? We had a bug where rebinds didn't trigger re-resolving of bindings and thus wouldn't take effect immediately. This has since been fixed.

While the rebind does register into the .inputactions asset. I'm unable to use the newly added key to trigger my debug code. Is there a step I seem to be missing?

In the example gif below. I start off by showcasing my current input actions. I then press the UI button with the name F. Immediately afterwards, I press the A button on my keyboard (sorry, don't have visuals for that). I then close the .inputactions asset. Only to then reopen it. As you can see in the example gif, the newly bound input action was leaked into the .inputactions` asset.

Code used:

public void RequestNewBinding() {
    InputAction actionToUse = inputActions.actionMaps[0].actions[0];
        inputActions.Disable();
        actionToUse.Disable();
        rebindOperation = actionToUse.PerformInteractiveRebinding().WithRebindAddingNewBinding()
            .OnComplete(operation => {
                actionToUse.Enable();
                inputActions.Enable();
                ButtonRebindCompleted(GetComponent<Button>());
            })
            .Start();
}

private void ButtonRebindCompleted(Button uiButton) {
    rebindOperation.Dispose();

    buttonText.text = controls.TestMap.Newaction.controls[controls.TestMap.Newaction.controls.Count - 1].displayName;
    controls.TestMap.Enable();
}

The rest of the code is still the same as in the original example.

[Rene-Damm]

Hey, sorry for the insane lag here. It's not forgotten. Thank you for the detailed report.

We're in the process of migrating all our bug tracking to the official Unity bug tracking system (which gives us the benefit of properly integrating ourselves with Unity QA procedures) and turn off GitHub issue tracking once done. I've migrated the case over to FogBugz.

FB Ticket: 1190502
Unity Issue Tracker: https://issuetracker.unity3d.com/product/unity/issues/guid/1190502/

Closing the issue here. But no worries, we're looking into it.