Try & Error

Unity 6000.1.11f1

URP

InputSystem 1.14.1

NGUI 2025.07.01

----

Legacy Input System을 new Input System으로 변환하면서 기존 Third Party 에셋들이 기존 Legacy Input을 계속 사용하고 있어서(특히 NGUI)

에러나는 부분을 가능하면 손을 덜 대고 해결하기 위해서,

Legacy Input System을 New Input System으로 Wrapping하는 클래스를 만들었다.

(왠만한 건 다 Wrapping 한 것 같은데 혹시나 빠진게 있을수도 있다.)

Activate Input Handling을 New Input System으로 변경하고 아래 스크립트를 Plugins 폴더에 넣어주면 된다.

[파일] 

[코드]

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using Debug = UnityEngine.Debug;

// 별칭 지정
using InputSystemTouchPhase = UnityEngine.InputSystem.TouchPhase;
using LegacyTouchPhase = UnityEngine.TouchPhase;
using InputSystemGyroscope = UnityEngine.InputSystem.Gyroscope;



/// <summary>
/// Legacy Input System을 New Input System으로 Wrapping하는 클래스.
/// </summary>
public static class Input
{
    #region 필드

    /// <summary>
    /// 가속도계 이벤트를 나타냅니다.
    /// </summary>
    public struct AccelerationEvent
    {
        public Vector3 acceleration;
        public float deltaTime;
    }

    /// <summary>
    /// Legacy Gyroscope API를 모방하는 래퍼 클래스입니다.
    /// </summary>
    public class Gyroscope
    {
        private readonly InputSystemGyroscope device;
        private readonly GravitySensor gravityDevice;
        private readonly AttitudeSensor attitudeDevice;

        internal Gyroscope(InputSystemGyroscope device)
        {
            this.device = device;
            this.gravityDevice = GravitySensor.current;
            this.attitudeDevice = AttitudeSensor.current;
        }

        /// <summary>
        /// 자이로스코프 활성화 여부입니다.
        /// </summary>
        public bool enabled
        {
            get => device != null && device.enabled;
            set
            {
                if (device != null && device.enabled != value)
                {
                    if (value)
                    {
                        InputSystem.EnableDevice(device);
                        if (attitudeDevice != null) InputSystem.EnableDevice(attitudeDevice);
                    }
                    else
                    {
                        InputSystem.DisableDevice(device);
                        if (attitudeDevice != null) InputSystem.DisableDevice(attitudeDevice);
                    }
                }
            }
        }

        /// <summary>
        /// 장치의 자세(Attitude)를 반환합니다.
        /// </summary>
        public Quaternion attitude => attitudeDevice?.attitude.ReadValue() ?? Quaternion.identity;

        /// <summary>
        /// 장치의 중력 가속도 벡터를 반환합니다.
        /// </summary>
        public Vector3 gravity => gravityDevice?.gravity.ReadValue() ?? Vector3.zero;

        /// <summary>
        /// 장치의 회전 속도를 반환합니다. (deg/s)
        /// </summary>
        public Vector3 rotationRate => (device?.angularVelocity.ReadValue() ?? Vector3.zero) * Mathf.Rad2Deg;

        /// <summary>
        /// 바이어스가 보정된 장치의 회전 속도를 반환합니다. (New Input System에서는 rotationRate와 동일)
        /// </summary>
        public Vector3 rotationRateUnbiased => rotationRate;

        /// <summary>
        /// 자이로스코프의 업데이트 간격(초)입니다.
        /// </summary>
        public float updateInterval
        {
            get => (device != null && device.samplingFrequency > 0) ? 1.0f / device.samplingFrequency : 0;
            set
            {
                // New Input System에서는 프로그래밍 방식으로 업데이트 간격을 설정할 수 없습니다.
                LogInfo("Gyroscope.updateInterval은 New Input System에서 설정할 수 없습니다.");
            }
        }
    }


    private static readonly Dictionary<KeyCode, Key> keyMapping = new Dictionary<KeyCode, Key>();
    private static readonly Dictionary<string, InputAction> axisActions = new Dictionary<string, InputAction>();
    private static readonly List<Touch> cachedTouches = new List<Touch>();
    private static readonly List<AccelerationEvent> accelerationEventBuffer = new List<AccelerationEvent>();

    private static InputAction anyKeyAction;
    private static float lastTouchUpdateTime;
    private static bool isInitialized;
    private static bool enableDebugLogs = true;
    private static Gyroscope _gyroscope;


    // UIInput 호환성을 위한 필드
    private static readonly StringBuilder inputBuffer = new StringBuilder();
    public static string compositionString { get; private set; } = "";
    public static Vector2 compositionCursorPos { get; set; }

    // 현재 입력 장치들
    private static Mouse currentMouse => Mouse.current;
    private static Keyboard currentKeyboard => Keyboard.current;
    private static Gamepad currentGamepad => Gamepad.current;
    private static Touchscreen currentTouchscreen => Touchscreen.current;
    private static Accelerometer currentAccelerometer => Accelerometer.current;
    private static InputSystemGyroscope currentGyro => InputSystemGyroscope.current;


    private enum KeyState { Down, Up, Held }

    #endregion

    #region 초기화

    static Input()
    {
        Initialize();
    }

    /// <summary>
    /// NewInput 시스템을 명시적으로 초기화합니다.
    /// </summary>
    public static void Initialize()
    {
        if (isInitialized) return;

        try
        {
            LogInfo("NewInput 시스템 초기화 시작...");

            InitializeKeyMapping();
            InitializeDefaultActions();
            SetupAnyKeyAction();
            SetupTextHandling();

#if UNITY_ANDROID || UNITY_IOS
            if (!UnityEngine.InputSystem.EnhancedTouch.EnhancedTouchSupport.enabled)
            {
                UnityEngine.InputSystem.EnhancedTouch.EnhancedTouchSupport.Enable();
                LogInfo("EnhancedTouchSupport 활성화됨.");
            }
            if (currentAccelerometer != null && !currentAccelerometer.enabled)
            {
                InputSystem.EnableDevice(currentAccelerometer);
                LogInfo("가속도계 활성화됨.");
            }
            if (currentGyro != null && !currentGyro.enabled)
            {
                InputSystem.EnableDevice(currentGyro);
                LogInfo("자이로스코프 활성화됨.");
            }
            if (GravitySensor.current != null && !GravitySensor.current.enabled)
            {
                InputSystem.EnableDevice(GravitySensor.current);
                LogInfo("중력 센서 활성화됨.");
            }
            if (AttitudeSensor.current != null && !AttitudeSensor.current.enabled)
            {
                InputSystem.EnableDevice(AttitudeSensor.current);
                LogInfo("자세 센서 활성화됨.");
            }
#endif

            isInitialized = true;
            LogInfo("NewInput 시스템 초기화 완료.");
        }
        catch (Exception ex)
        {
            LogError($"NewInput 초기화 중 오류 발생: {ex.Message}");
        }
    }

    private static void InitializeKeyMapping()
    {
        keyMapping.Clear();
        // 알파벳, 숫자, 특수 키 매핑 (기존과 동일)
        for (int i = 0; i < 26; i++) keyMapping[(KeyCode)((int)KeyCode.A + i)] = Key.A + i;
        for (int i = 0; i < 10; i++) keyMapping[(KeyCode)((int)KeyCode.Alpha0 + i)] = Key.Digit0 + i;
        for (int i = 0; i < 10; i++) keyMapping[(KeyCode)((int)KeyCode.Keypad0 + i)] = Key.Numpad0 + i;
        for (int i = 0; i < 15; i++) keyMapping[(KeyCode)((int)KeyCode.F1 + i)] = Key.F1 + i;
        keyMapping[KeyCode.Backspace] = Key.Backspace;
        keyMapping[KeyCode.Tab] = Key.Tab;
        keyMapping[KeyCode.Return] = Key.Enter;
        keyMapping[KeyCode.Pause] = Key.Pause;
        keyMapping[KeyCode.Escape] = Key.Escape;
        keyMapping[KeyCode.Space] = Key.Space;
        keyMapping[KeyCode.Delete] = Key.Delete;
        keyMapping[KeyCode.LeftShift] = Key.LeftShift;
        keyMapping[KeyCode.RightShift] = Key.RightShift;
        keyMapping[KeyCode.LeftControl] = Key.LeftCtrl;
        keyMapping[KeyCode.RightControl] = Key.RightCtrl;
        keyMapping[KeyCode.LeftAlt] = Key.LeftAlt;
        keyMapping[KeyCode.RightAlt] = Key.RightAlt;
        keyMapping[KeyCode.LeftArrow] = Key.LeftArrow;
        keyMapping[KeyCode.RightArrow] = Key.RightArrow;
        keyMapping[KeyCode.UpArrow] = Key.UpArrow;
        keyMapping[KeyCode.DownArrow] = Key.DownArrow;
        keyMapping[KeyCode.KeypadEnter] = Key.NumpadEnter;
        keyMapping[KeyCode.Insert] = Key.Insert;
        keyMapping[KeyCode.Home] = Key.Home;
        keyMapping[KeyCode.End] = Key.End;
        keyMapping[KeyCode.PageUp] = Key.PageUp;
        keyMapping[KeyCode.PageDown] = Key.PageDown;
    }

    private static void InitializeDefaultActions()
    {
        // 기존 축 액션 정리
        if (axisActions.TryGetValue("Horizontal", out var horizontalAction)) horizontalAction.Disable();
        if (axisActions.TryGetValue("Vertical", out var verticalAction)) verticalAction.Disable();

        // Horizontal 축 설정 (키보드 좌/우 화살표, A/D 키)
        var horizontal = new InputAction("Horizontal", type: InputActionType.Value);
        horizontal.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/leftArrow")
            .With("positive", "<Keyboard>/rightArrow");
        horizontal.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/a")
            .With("positive", "<Keyboard>/d");
        horizontal.AddBinding("<Gamepad>/leftStick/x");
        horizontal.Enable();
        axisActions["Horizontal"] = horizontal;

        // Vertical 축 설정 (키보드 상/하 화살표, W/S 키)
        var vertical = new InputAction("Vertical", type: InputActionType.Value);
        vertical.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/downArrow")
            .With("positive", "<Keyboard>/upArrow");
        vertical.AddCompositeBinding("1DAxis")
            .With("negative", "<Keyboard>/s")
            .With("positive", "<Keyboard>/w");
        vertical.AddBinding("<Gamepad>/leftStick/y");
        vertical.Enable();
        axisActions["Vertical"] = vertical;

        // 마우스 축 설정
        CreateAxisAction("Mouse X", "<Mouse>/delta/x");
        CreateAxisAction("Mouse Y", "<Mouse>/delta/y");
        CreateAxisAction("Mouse ScrollWheel", "<Mouse>/scroll/y");
    }

    private static void SetupAnyKeyAction()
    {
        anyKeyAction?.Disable();
        anyKeyAction = new InputAction("AnyKey", type: InputActionType.PassThrough);
        anyKeyAction.AddBinding("<Keyboard>/anyKey");
        anyKeyAction.AddBinding("<Mouse>/leftButton");
        anyKeyAction.AddBinding("<Mouse>/rightButton");
        anyKeyAction.AddBinding("<Mouse>/middleButton");
        anyKeyAction.AddBinding("<Touchscreen>/primaryTouch/press");
        anyKeyAction.AddBinding("<Gamepad>/buttonSouth");
        anyKeyAction.AddBinding("<Gamepad>/buttonNorth");
        anyKeyAction.AddBinding("<Gamepad>/buttonEast");
        anyKeyAction.AddBinding("<Gamepad>/buttonWest");
        anyKeyAction.Enable();
    }

    private static void CreateAxisAction(string name, params string[] bindings)
    {
        var action = new InputAction(name, InputActionType.Value);
        foreach (var binding in bindings) action.AddBinding(binding);
        action.Enable();
        axisActions[name] = action;
    }

    private static void SetupTextHandling()
    {
        if (currentKeyboard != null)
        {
            currentKeyboard.onTextInput -= OnTextInput;
            currentKeyboard.onTextInput += OnTextInput;
        }
        // InputSystem.onIMECompositionChange는 존재하지 않으므로 제거합니다.
        // IME 처리는 onTextInput을 통해 간접적으로 지원됩니다.
        Application.onBeforeRender -= FrameReset;
        Application.onBeforeRender += FrameReset;
    }

    #endregion

    #region 공개 API

    // UIInput 호환성 API
    public static string inputString => inputBuffer.ToString();
    public static IMECompositionMode imeCompositionMode { get; set; }
    public static bool imeIsSelected => !string.IsNullOrEmpty(compositionString);

    public static bool GetKeyDown(KeyCode key) => GetKeyState(key, KeyState.Down);
    public static bool GetKeyUp(KeyCode key) => GetKeyState(key, KeyState.Up);
    public static bool GetKey(KeyCode key) => GetKeyState(key, KeyState.Held);

    public static bool GetKeyDown(string name)
    {
        if (TryParseKeyCode(name, out var key))
        {
            return GetKeyDown(key);
        }
        return false;
    }

    public static bool GetKeyUp(string name)
    {
        if (TryParseKeyCode(name, out var key))
        {
            return GetKeyUp(key);
        }
        return false;
    }

    public static bool GetKey(string name)
    {
        if (TryParseKeyCode(name, out var key))
        {
            return GetKey(key);
        }
        return false;
    }

    public static float GetAxis(string axisName)
    {
        if (string.IsNullOrEmpty(axisName) || !axisActions.TryGetValue(axisName, out var action) || action == null || !action.enabled)
            return 0f;

        if (action.expectedControlType == "Vector2")
        {
            var value = action.ReadValue<Vector2>();
            if (axisName.EndsWith("X") || axisName == "Horizontal") return value.x;
            if (axisName.EndsWith("Y") || axisName == "Vertical") return value.y;
            return value.magnitude;
        }
        return action.ReadValue<float>();
    }

    public static float GetAxisRaw(string axisName)
    {
        if (string.IsNullOrEmpty(axisName) || !axisActions.TryGetValue(axisName, out var action) || action == null || !action.enabled)
            return 0f;

        if (action.expectedControlType == "Vector2")
        {
            var value = action.ReadValue<Vector2>();
            if (axisName.EndsWith("X") || axisName == "Horizontal") return value.x;
            if (axisName.EndsWith("Y") || axisName == "Vertical") return value.y;
            return value.magnitude;
        }
        var rawValue = action.ReadValue<float>();
        return Mathf.Abs(rawValue) > 0 ? Mathf.Sign(rawValue) : 0;
    }

    public static bool GetButton(string buttonName) => GetButtonState(buttonName, KeyState.Held);
    public static bool GetButtonDown(string buttonName) => GetButtonState(buttonName, KeyState.Down);
    public static bool GetButtonUp(string buttonName) => GetButtonState(buttonName, KeyState.Up);

    public static bool GetMouseButton(int button) => GetKey(KeyCode.Mouse0 + button);
    public static bool GetMouseButtonDown(int button) => GetKeyDown(KeyCode.Mouse0 + button);
    public static bool GetMouseButtonUp(int button) => GetKeyUp(KeyCode.Mouse0 + button);

    public static Vector3 mousePosition => currentMouse?.position.ReadValue() ?? Vector3.zero;
    public static Vector2 mouseScrollDelta => currentMouse?.scroll.ReadValue() ?? Vector2.zero;
    public static bool mousePresent => currentMouse != null;

    public static bool anyKey => anyKeyAction?.IsPressed() ?? false;
    public static bool anyKeyDown => anyKeyAction?.triggered ?? false;

    public static bool touchSupported => currentTouchscreen != null;
    public static bool stylusTouchSupported => Pen.current != null;
    public static bool touchPressureSupported => currentTouchscreen?.pressure.IsActuated() ?? false;
    public static bool multiTouchEnabled { get; set; } = true;
    public static bool simulateMouseWithTouches { get; set; } = true;
    public static int touchCount
    {
        get
        {
            UpdateCachedTouches();
            return cachedTouches.Count;
        }
    }

    public static Touch GetTouch(int index)
    {
        UpdateCachedTouches();
        if (index < 0 || index >= cachedTouches.Count)
            throw new ArgumentOutOfRangeException(nameof(index), $"Touch index {index} is out of range. Count: {cachedTouches.Count}");
        return cachedTouches[index];
    }

    public static Touch[] touches
    {
        get
        {
            UpdateCachedTouches();
            return cachedTouches.ToArray();
        }
    }

    public static Vector3 acceleration
    {
        get
        {
            if (currentAccelerometer != null && currentAccelerometer.enabled)
            {
                return currentAccelerometer.acceleration.ReadValue();
            }
            return Vector3.zero;
        }
    }

    public static int accelerationEventCount
    {
        get
        {
            UpdateAccelerationEvents();
            return accelerationEventBuffer.Count;
        }
    }

    public static AccelerationEvent[] accelerationEvents
    {
        get
        {
            UpdateAccelerationEvents();
            return accelerationEventBuffer.ToArray();
        }
    }

    public static AccelerationEvent GetAccelerationEvent(int index)
    {
        UpdateAccelerationEvents();
        if (index < 0 || index >= accelerationEventBuffer.Count)
            throw new ArgumentOutOfRangeException(nameof(index));
        return accelerationEventBuffer[index];
    }

    public static Gyroscope gyro
    {
        get
        {
            if (_gyroscope == null && currentGyro != null)
            {
                _gyroscope = new Gyroscope(currentGyro);
            }
            return _gyroscope;
        }
    }
    public static bool isGyroAvailable => currentGyro != null && currentGyro.enabled;
    public static DeviceOrientation deviceOrientation
    {
        get
        {
            switch (Screen.orientation)
            {
                case ScreenOrientation.Portrait:
                    return DeviceOrientation.Portrait;
                case ScreenOrientation.PortraitUpsideDown:
                    return DeviceOrientation.PortraitUpsideDown;
                case ScreenOrientation.LandscapeLeft:
                    return DeviceOrientation.LandscapeLeft;
                case ScreenOrientation.LandscapeRight:
                    return DeviceOrientation.LandscapeRight;
                default:
                    return DeviceOrientation.Unknown;
            }
        }
    }

    /// <summary>
    /// 안드로이드에서 뒤로가기 버튼이 앱을 종료할지 여부를 결정합니다.
    /// New Input System에서는 이 기능을 직접 제어할 수 없으므로, 이 속성은 동작하지 않습니다.
    /// </summary>
    public static bool backButtonLeavesApp { get; set; } = true;

    public static string[] GetJoystickNames()
    {
        return Gamepad.all.Select(g => g.displayName).ToArray();
    }

    public static void ResetInputAxes()
    {
        foreach (var action in axisActions.Values)
        {
            // New Input System에서는 직접 리셋하는 기능 대신,
            // 다음 프레임에 값이 0으로 돌아가는 것을 기대합니다.
            // 필요 시, action.Disable() / action.Enable()을 고려할 수 있습니다.
        }
        LogInfo("Input axes reset requested.");
    }

    #endregion

    #region 내부 로직

    private static void OnTextInput(char character) => inputBuffer.Append(character);
    private static void FrameReset()
    {
        inputBuffer.Clear();
        accelerationEventBuffer.Clear();
    }

    private static bool TryParseKeyCode(string name, out KeyCode key)
    {
        try
        {
            key = (KeyCode)Enum.Parse(typeof(KeyCode), name, true);
            return true;
        }
        catch (ArgumentException)
        {
            LogError($"'{name}'은(는) 유효한 KeyCode가 아닙니다.");
            key = KeyCode.None;
            return false;
        }
    }

    private static bool GetButtonState(string buttonName, KeyState state)
    {
        if (TryParseKeyCode(buttonName, out var key))
        {
            return GetKeyState(key, state);
        }

        LogError($"'{buttonName}'은(는) 유효한 KeyCode 이름이 아닙니다.");
        return false;
    }

    private static bool GetKeyState(KeyCode key, KeyState state)
    {
        try
        {
            // 마우스 버튼 처리
            if (key >= KeyCode.Mouse0 && key <= KeyCode.Mouse6)
            {
                if (currentMouse == null) return false;
                var button = (key - KeyCode.Mouse0) switch
                {
                    0 => currentMouse.leftButton,
                    1 => currentMouse.rightButton,
                    2 => currentMouse.middleButton,
                    _ => null
                };
                return button != null && CheckButtonState(button, state);
            }

            // 조이스틱 버튼 처리
            if (key >= KeyCode.JoystickButton0 && key <= KeyCode.JoystickButton19)
            {
                if (currentGamepad == null) return false;
                int buttonIndex = (int)key - (int)KeyCode.JoystickButton0;
                if (currentGamepad.allControls.Count <= buttonIndex) return false;
                var button = currentGamepad.allControls[buttonIndex] as ButtonControl;
                return button != null && CheckButtonState(button, state);
            }

            // 키보드 키 처리
            if (currentKeyboard != null && keyMapping.TryGetValue(key, out var mappedKey) && mappedKey != Key.None)
            {
                return CheckButtonState(currentKeyboard[mappedKey], state);
            }
        }
        catch (Exception ex)
        {
            LogError($"GetKeyState 오류 (Key: {key}, State: {state}): {ex.Message}");
        }
        return false;
    }

    private static bool CheckButtonState(ButtonControl button, KeyState state)
    {
        return state switch
        {
            KeyState.Down => button.wasPressedThisFrame,
            KeyState.Up => button.wasReleasedThisFrame,
            KeyState.Held => button.isPressed,
            _ => false
        };
    }

    private static void UpdateCachedTouches()
    {
        if (Time.unscaledTime == lastTouchUpdateTime) return;
        lastTouchUpdateTime = Time.unscaledTime;
        cachedTouches.Clear();

#if UNITY_EDITOR || UNITY_STANDALONE
        if (simulateMouseWithTouches) SimulateMouseAsTouch();
#else
        if (currentTouchscreen == null) return;

        foreach (var activeTouch in UnityEngine.InputSystem.EnhancedTouch.Touch.activeTouches)
        {
            cachedTouches.Add(ConvertEnhancedTouch(activeTouch));
            if (!multiTouchEnabled) break;
        }
#endif
    }

    private static void UpdateAccelerationEvents()
    {
        if (currentAccelerometer != null && currentAccelerometer.enabled)
        {
            var accel = currentAccelerometer.acceleration.ReadValue();
            accelerationEventBuffer.Add(new AccelerationEvent { acceleration = accel, deltaTime = Time.deltaTime });
        }
    }

    private static Touch ConvertEnhancedTouch(UnityEngine.InputSystem.EnhancedTouch.Touch enhancedTouch)
    {
        var legacyPhase = enhancedTouch.phase switch
        {
            InputSystemTouchPhase.Began => LegacyTouchPhase.Began,
            InputSystemTouchPhase.Moved => LegacyTouchPhase.Moved,
            InputSystemTouchPhase.Stationary => LegacyTouchPhase.Stationary,
            InputSystemTouchPhase.Ended => LegacyTouchPhase.Ended,
            InputSystemTouchPhase.Canceled => LegacyTouchPhase.Canceled,
            _ => LegacyTouchPhase.Canceled
        };

        return new Touch
        {
            fingerId = enhancedTouch.finger.index,
            position = enhancedTouch.screenPosition,
            deltaPosition = legacyPhase == LegacyTouchPhase.Began ? Vector2.zero : enhancedTouch.delta,
            deltaTime = Time.unscaledDeltaTime,
            tapCount = enhancedTouch.tapCount,
            phase = legacyPhase
        };
    }

    private static void SimulateMouseAsTouch()
    {
        if (currentMouse == null) return;

        const int mouseFingerId = 0;
        var phase = LegacyTouchPhase.Canceled;
        bool addToList = false;

        if (currentMouse.leftButton.wasPressedThisFrame)
        {
            phase = LegacyTouchPhase.Began;
            addToList = true;
        }
        else if (currentMouse.leftButton.wasReleasedThisFrame)
        {
            phase = LegacyTouchPhase.Ended;
            addToList = true;
        }
        else if (currentMouse.leftButton.isPressed)
        {
            phase = currentMouse.delta.ReadValue().sqrMagnitude < 0.1f ? LegacyTouchPhase.Stationary : LegacyTouchPhase.Moved;
            addToList = true;
        }

        if (addToList)
        {
            cachedTouches.Add(new Touch
            {
                fingerId = mouseFingerId,
                position = currentMouse.position.ReadValue(),
                deltaPosition = phase == LegacyTouchPhase.Began ? Vector2.zero : currentMouse.delta.ReadValue(),
                deltaTime = Time.unscaledDeltaTime,
                tapCount = 1,
                phase = phase
            });
        }
    }

    #endregion

    #region 유틸리티 및 헬퍼 클래스

    [Conditional("UNITY_EDITOR"), Conditional("DEVELOPMENT_BUILD")]
    private static void LogInfo(string message)
    {
        if (enableDebugLogs) Debug.Log($"[Input(Legacy Input Wrapper)] {message}");
    }

    [Conditional("UNITY_EDITOR"), Conditional("DEVELOPMENT_BUILD")]
    private static void LogError(string message)
    {
        if (enableDebugLogs) Debug.LogError($"[Input(Legacy Input Wrapper)] {message}");
    }

    public static void SetDebugLogging(bool enabled) => enableDebugLogs = enabled;

    #endregion
}

[참고]

강제로 Wrapping 하지 않고, 필요한 부분만 하고싶다면,

위 Input.cs를 NewInput.cs로 클래스/파일 명을 변경하고
적용하고 싶은 스크립트 상단에 using Input = NewInput; 을 써서 해당 스크립트만 부분적으로 적용해도 될 것 같다.

[링크] https://www.postype.com/@fail-blanc/post/17808791

[링크] https://github.com/lilxyzw/lilToon

[링크]

[Unity] New Input System #1 | 세팅하기

[Unity] New Input System #2 | 키 입력을 스크립트에 전달하여 처리하기

[링크] https://gamecoke.tistory.com/entry/Unity-New-Input-System

[링크] https://github.com/Nickk888SAMP/InputSystemManager

[링크] https://devfrog.tistory.com/11

[링크]

https://cdn.bfldr.com/S5BC9Y64/at/sx8v87pg7jwpjb9hwnv84tqc/Optimize_Your_Mobile_Game_Performance_FINAL_ko_kr.pdf

[파일]

[링크] https://moondongjun.tistory.com/102

[링크] https://drehzr.tistory.com/2625