Improvements to rebinding sample to increase visibility of potential side-effects and be more similar to a real game.

Author: ekcoh

Assets/Samples/RebindingUI/ActionIndicator.cs

@@ -3,14 +3,31 @@
 using UnityEngine.InputSystem;
 using UnityEngine.UI;
 
+/// <summary>
+/// A simple visual indicator of action performed.
+/// </summary>
+/// <remarks>Error handling have been excluded for simplicity.</remarks>
+[RequireComponent(typeof(Image))]
 public class ActionUIIndicator : MonoBehaviour
 {
+    [Tooltip("Reference to the associated action to be visualized.")]
     public InputActionReference action;
-    private Image image;
+    
+    [Tooltip("The color to show when the associated action is performed.")]
+    public Color activeColor = Color.green; 
+    
+    [Tooltip("The color to show when the associated action has not been performed for the specified duration.")]
+    public Color inactiveColor = Color.black;
+    
+    [Tooltip("The duration for which the indicator should be lit before becoming completely inactive.")]
+    public float duration = 1.0f;
+    
+    private double m_RealTimeLastPerformed;
+    private Image m_Image;
 
     void Start()
     {
-        image = GetComponent<Image>();
+        m_Image = GetComponent<Image>();
     }
 
     private void OnEnable()
@@ -27,19 +44,13 @@ private void OnDisable()
 
     private void OnPerformed(InputAction.CallbackContext obj)
     {
-        image.color = ColorWithAlpha(1.0f);   
-    }
-
-    private Color ColorWithAlpha(float alpha)
-    {
-        var color = image.color;
-        return new Color(color.r, color.g, color.b, alpha);
+        m_RealTimeLastPerformed = Time.realtimeSinceStartupAsDouble;
     }
 
     private void Update()
     {
-        var color = image.color;
-        if (color.a > 0.0f)
-            image.color = ColorWithAlpha(Mathf.Max(image.color.a - Time.deltaTime * 1.0f, 0.0f));
+        var elapsedSincePerformed = Time.realtimeSinceStartupAsDouble - m_RealTimeLastPerformed;
+        m_Image.color = duration <= 0.0f ? inactiveColor : Color.Lerp(inactiveColor, activeColor, 
+            (float)Math.Max(0.0, 1.0 - elapsedSincePerformed / duration));
     }
 }

Assets/Samples/RebindingUI/GameManager.cs

@@ -0,0 +1,64 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.InputSystem;
+
+/// <summary>
+/// Simple game manager that manages enabling/disabling in-game and UI actions.
+/// </summary>
+public class GameManager : MonoBehaviour
+{
+    // TODO Its still an issue if we assign UI cancel button in rebinding,
+    //      same goes for keyboard ESC
+    
+    public GameObject menu;
+    public InputActionAsset gameplayActions;
+    public InputActionReference menuAction;
+    public InputActionReference exitMenuAction;
+    public GameObject initiallySelectedGameObject;
+    
+    void Start()
+    {
+        // Let menu initially be disabled
+        menu.SetActive(false);
+        
+        // Let gameplay actions be initially enabled
+        gameplayActions.Enable();
+    }
+
+    private void OnEnable()
+    {
+        menuAction.action.performed += OnMenu;
+        exitMenuAction.action.performed += OnExitMenu;
+    }
+
+    private void OnDisable()
+    {
+        menuAction.action.performed -= OnMenu;
+        exitMenuAction.action.performed -= OnExitMenu;
+    }
+
+    private void OnMenu(InputAction.CallbackContext obj)
+    {
+        // Disable gameplay actions while in menu
+        gameplayActions.Disable();
+        
+        // Enable menu if currently not active
+        menu.SetActive(true);
+        
+        // Make sure EventSystem has a selection to allow gamepad navigation
+        if (EventSystem.current.currentSelectedGameObject == null)
+            EventSystem.current.SetSelectedGameObject(EventSystem.current.firstSelectedGameObject);
+    }
+
+    private void OnExitMenu(InputAction.CallbackContext obj)
+    {
+        if (!menu.activeInHierarchy)
+            return;
+        
+        // Hide menu
+        menu.SetActive(false);
+        
+        // Reenable gameplay actions
+        gameplayActions.Enable();
+    }
+}

Assets/Samples/RebindingUI/GameManager.cs.meta

@@ -256,12 +256,17 @@ private void PerformInteractiveRebind(InputAction action, int bindingIndex, bool
         {
             m_RebindOperation?.Cancel(); // Will null out m_RebindOperation.
 
+            var actionWasEnabledPriorToRebind = action.enabled; // Allow restoring enabled state
+            
             void CleanUp()
             {
                 m_RebindOperation?.Dispose();
                 m_RebindOperation = null;
 
-                action.actionMap.Enable();
+                // Restore action enabled state based on state prior to rebind
+                if (actionWasEnabledPriorToRebind)
+                    action.actionMap.Enable();
+                
                 m_UIInputActionMap?.Enable();
             }
 
@@ -274,8 +279,9 @@ void CleanUp()
             // character to jump.
             //
             // In this example, we explicitly disable both the UI input action map and
-            // the action map containing the target action.
-            action.actionMap.Disable();
+            // the action map containing the target action if it was initially enabled.
+            if (actionWasEnabledPriorToRebind)
+                action.actionMap.Disable();
             m_UIInputActionMap?.Disable();
 
             // Configure the rebind.