💻 C# 스크립트에서 Input Action Asset 사용하기

Input Action Asset을 설정한 후에는 C# 스크립트에서 이를 사용할 수 있어:

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerController : MonoBehaviour
{
    // Input Action Asset 참조
    public InputActionAsset inputActions;
    
    // 개별 액션들
    private InputAction moveAction;
    private InputAction jumpAction;
    
    private void Awake()
    {
        // 액션 맵 가져오기
        var playerActionMap = inputActions.FindActionMap("Player");
        
        // 개별 액션 가져오기
        moveAction = playerActionMap.FindAction("Move");
        jumpAction = playerActionMap.FindAction("Jump");
        
        // 액션에 콜백 함수 등록
        jumpAction.performed += OnJump;
        
        // 액션 맵 활성화
        playerActionMap.Enable();
    }
    
    private void OnJump(InputAction.CallbackContext context)
    {
        // 점프 로직 구현
        Debug.Log("Jump!");
    }
    
    private void Update()
    {
        // Move 액션의 현재 값 읽기
        Vector2 moveInput = moveAction.ReadValue<Vector2>();
        
        // 이동 로직에 사용
        transform.Translate(new Vector3(moveInput.x, 0, moveInput.y) * Time.deltaTime * 5f);
    }
    
    private void OnDestroy()
    {
        // 콜백 해제
        jumpAction.performed -= OnJump;
        
        // 액션 맵 비활성화
        var playerActionMap = inputActions.FindActionMap("Player");
        playerActionMap.Disable();
    }
}
      

using UnityEngine;
using UnityEngine.InputSystem;

public class DeviceDetector : MonoBehaviour
{
    [SerializeField] private GameObject keyboardPrompts;
    [SerializeField] private GameObject gamepadPrompts;
    [SerializeField] private GameObject touchPrompts;
    
    private void Start()
    {
        // 초기 디바이스 설정
        UpdatePrompts();
        
        // 디바이스 변경 이벤트 구독
        InputSystem.onActionChange += OnInputDeviceChanged;
    }
    
    private void OnInputDeviceChanged(object obj, InputActionChange change)
    {
        if (change == InputActionChange.ActionPerformed)
        {
            UpdatePrompts();
        }
    }
    
    private void UpdatePrompts()
    {
        // 마지막으로 사용된 디바이스 확인
        var lastDevice = InputSystem.GetDevice<InputDevice>();
        
        // 디바이스 타입에 따라 UI 프롬프트 업데이트
        keyboardPrompts.SetActive(lastDevice is Keyboard || lastDevice is Mouse);
        gamepadPrompts.SetActive(lastDevice is Gamepad);
        touchPrompts.SetActive(lastDevice is Touchscreen);
    }
    
    private void OnDestroy()
    {
        // 이벤트 구독 해제
        InputSystem.onActionChange -= OnInputDeviceChanged;
    }
}
      

// Input Action Asset에서 터치 액션 설정:
// - "PrimaryTouch" (Value 타입: Vector2, Control 타입: Touch > Position)
// - "PrimaryTap" (Value 타입: Button, Control 타입: Touch > Press)

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

public class TouchController : MonoBehaviour
{
    private InputAction touchPositionAction;
    private InputAction touchPressAction;
    
    private void Awake()
    {
        var inputAsset = GetComponent<PlayerInput>().actions;
        var touchMap = inputAsset.FindActionMap("Touch");
        
        touchPositionAction = touchMap.FindAction("PrimaryTouch");
        touchPressAction = touchMap.FindAction("PrimaryTap");
        
        touchPressAction.performed += OnTap;
    }
    
    private void OnTap(InputAction.CallbackContext context)
    {
        // 탭 위치 가져오기
        Vector2 touchPos = touchPositionAction.ReadValue<Vector2>();
        
        // 터치 위치에서 레이캐스트
        Ray ray = Camera.main.ScreenPointToRay(touchPos);
        if (Physics.Raycast(ray, out RaycastHit hit))
        {
            // 터치한 오브젝트와 상호작용
            Debug.Log($"Tapped on: {hit.collider.gameObject.name}");
        }
    }
    
    private void OnDestroy()
    {
        touchPressAction.performed -= OnTap;
    }
}
      

💻 플랫폼 감지 및 설정 최적화 예시

using UnityEngine;
using UnityEngine.InputSystem;

public class PlatformOptimizer : MonoBehaviour
{
    [SerializeField] private float pcMouseSensitivity = 1.0f;
    [SerializeField] private float consoleLookSensitivity = 0.5f;
    [SerializeField] private float mobileSwipeSensitivity = 0.3f;
    
    [SerializeField] private GameObject pcUI;
    [SerializeField] private GameObject consoleUI;
    [SerializeField] private GameObject mobileUI;
    
    private void Start()
    {
        // 현재 플랫폼 감지 및 최적화
        OptimizeForCurrentPlatform();
        
        // 디바이스 변경 감지
        InputSystem.onDeviceChange += (device, change) => {
            if (change == InputDeviceChange.Added || change == InputDeviceChange.Removed)
            {
                UpdateUIForCurrentDevice();
            }
        };
    }
    
    private void OptimizeForCurrentPlatform()
    {
        // 플랫폼별 설정 최적화
#if UNITY_STANDALONE
        // PC 설정
        SetSensitivity(pcMouseSensitivity);
        ShowUI(pcUI);
#elif UNITY_IOS || UNITY_ANDROID
        // 모바일 설정
        SetSensitivity(mobileSwipeSensitivity);
        ShowUI(mobileUI);
#elif UNITY_PS4 || UNITY_PS5 || UNITY_XBOX_ONE || UNITY_SWITCH
        // 콘솔 설정
        SetSensitivity(consoleLookSensitivity);
        ShowUI(consoleUI);
#endif
    }
    
    private void UpdateUIForCurrentDevice()
    {
        var lastDevice = InputSystem.GetDevice<InputDevice>();
        
        if (lastDevice is Keyboard || lastDevice is Mouse)
        {
            ShowUI(pcUI);
        }
        else if (lastDevice is Gamepad)
        {
            ShowUI(consoleUI);
        }
        else if (lastDevice is Touchscreen)
        {
            ShowUI(mobileUI);
        }
    }
    
    private void SetSensitivity(float value)
    {
        // 감도 설정 적용
        PlayerPrefs.SetFloat("LookSensitivity", value);
    }
    
    private void ShowUI(GameObject uiToShow)
    {
        pcUI.SetActive(uiToShow == pcUI);
        consoleUI.SetActive(uiToShow == consoleUI);
        mobileUI.SetActive(uiToShow == mobileUI);
    }
}
      

💻 입력 디버깅 헬퍼 클래스

다음은 입력 시스템 디버깅에 유용한 헬퍼 클래스야:

using UnityEngine;
using UnityEngine.InputSystem;
using System.Text;
using System.Collections.Generic;

public class InputDebugger : MonoBehaviour
{
    [SerializeField] private InputActionAsset inputActions;
    [SerializeField] private bool logToConsole = true;
    [SerializeField] private TMPro.TextMeshProUGUI debugText;
    
    private Dictionary<string, string> actionStates = new Dictionary<string, string>();
    
    private void Start()
    {
        // 모든 액션 맵과 액션에 디버그 콜백 추가
        foreach (var actionMap in inputActions.actionMaps)
        {
            foreach (var action in actionMap.actions)
            {
                // 초기 상태 기록
                actionStates[action.name] = "Waiting...";
                
                // 콜백 등록
                action.performed += ctx => OnActionEvent(action.name, "Performed", ctx);
                action.started += ctx => OnActionEvent(action.name, "Started", ctx);
                action.canceled += ctx => OnActionEvent(action.name, "Canceled", ctx);
            }
            
            // 액션 맵 활성화
            actionMap.Enable();
        }
    }
    
    private void OnActionEvent(string actionName, string phase, InputAction.CallbackContext context)
    {
        // 값 읽기 시도
        string valueStr = "N/A";
        
        try
        {
            if (context.valueType == typeof(Vector2))
            {
                Vector2 value = context.ReadValue<Vector2>();
                valueStr = $"({value.x:F2}, {value.y:F2})";
            }
            else if (context.valueType == typeof(float))
            {
                float value = context.ReadValue<float>();
                valueStr = value.ToString("F2");
            }
            else if (context.valueType == typeof(bool) || context.valueType == typeof(void))
            {
                valueStr = phase;
            }
        }
        catch
        {
            valueStr = "Error reading value";
        }
        
        // 상태 업데이트
        actionStates[actionName] = $"{phase}: {valueStr}";
        
        // 콘솔에 로그
        if (logToConsole)
        {
            Debug.Log($"[Input] {actionName} - {phase} - Value: {valueStr} - Device: {context.control?.device.name}");
        }
        
        // UI 업데이트
        UpdateDebugText();
    }
    
    private void UpdateDebugText()
    {
        if (debugText != null)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("INPUT DEBUG:");
            sb.AppendLine("------------");
            
            // 현재 활성 디바이스
            var currentDevice = InputSystem.GetDevice<InputDevice>();
            sb.AppendLine($"Active Device: {currentDevice?.displayName ?? "None"}");
            sb.AppendLine();
            
            // 모든 액션 상태
            foreach (var entry in actionStates)
            {
                sb.AppendLine($"{entry.Key}: {entry.Value}");
            }
            
            debugText.text = sb.ToString();
        }
    }
    
    private void Update()
    {
        // 매 프레임 디버그 텍스트 업데이트 (디바이스 변경 감지를 위해)
        UpdateDebugText();
    }
    
    private void OnDestroy()
    {
        // 콜백 해제
        foreach (var actionMap in inputActions.actionMaps)
        {
            foreach (var action in actionMap.actions)
            {
                action.performed -= ctx => { };
                action.started -= ctx => { };
                action.canceled -= ctx => { };
            }
        }
    }
}
      

💻 성능 최적화 코드 예시

다음은 입력 시스템 성능을 최적화하는 몇 가지 코드 예시야:

using UnityEngine;
using UnityEngine.InputSystem;

public class OptimizedInputManager : MonoBehaviour
{
    [SerializeField] private InputActionAsset inputActions;
    
    // 자주 사용하는 액션 맵 캐싱
    private InputActionMap gameplayMap;
    private InputActionMap menuMap;
    
    // 자주 사용하는 액션 캐싱
    private InputAction moveAction;
    private InputAction lookAction;
    
    // 재사용 가능한 벡터 (가비지 생성 방지)
    private Vector2 moveInput;
    private Vector2 lookInput;
    
    private void Awake()
    {
        // 액션 맵 캐싱
        gameplayMap = inputActions.FindActionMap("Gameplay");
        menuMap = inputActions.FindActionMap("Menu");
        
        // 자주 사용하는 액션 캐싱
        moveAction = gameplayMap.FindAction("Move");
        lookAction = gameplayMap.FindAction("Look");
        
        // 이벤트 기반 콜백 등록 (매 프레임 폴링 대신)
        moveAction.performed += OnMovePerformed;
        moveAction.canceled += OnMoveCanceled;
        
        lookAction.performed += OnLookPerformed;
        lookAction.canceled += OnLookCanceled;
    }
    
    // 게임 상태에 따라 필요한 액션 맵만 활성화
    public void EnterGameplay()
    {
        menuMap.Disable(); // 사용하지 않는 맵 비활성화
        gameplayMap.Enable();
    }
    
    public void EnterMenu()
    {
        gameplayMap.Disable(); // 사용하지 않는 맵 비활성화
        menuMap.Enable();
    }
    
    // 이벤트 기반 콜백 (Update에서 매 프레임 폴링하지 않음)
    private void OnMovePerformed(InputAction.CallbackContext context)
    {
        // 재사용 가능한 벡터에 값 저장 (new Vector2 사용하지 않음)
        moveInput = context.ReadValue<Vector2>();
        
        // 이동 로직 처리
        HandleMovement(moveInput);
    }
    
    private void OnMoveCanceled(InputAction.CallbackContext context)
    {
        moveInput = Vector2.zero;
        HandleMovement(moveInput);
    }
    
    private void OnLookPerformed(InputAction.CallbackContext context)
    {
        lookInput = context.ReadValue<Vector2>();
        HandleLook(lookInput);
    }
    
    private void OnLookCanceled(InputAction.CallbackContext context)
    {
        lookInput = Vector2.zero;
        HandleLook(lookInput);
    }
    
    // 실제 이동 처리 로직
    private void HandleMovement(Vector2 input)
    {
        // 이동 로직 구현
    }
    
    // 실제 시점 처리 로직
    private void HandleLook(Vector2 input)
    {
        // 시점 로직 구현
    }
    
    private void OnDestroy()
    {
        // 콜백 해제
        if (moveAction != null)
        {
            moveAction.performed -= OnMovePerformed;
            moveAction.canceled -= OnMoveCanceled;
        }
        
        if (lookAction != null)
        {
            lookAction.performed -= OnLookPerformed;
            lookAction.canceled -= OnLookCanceled;
        }
    }
}