Unity-New Input System

Unity新输入系统（New Input System）详解

简介

本文详细介绍Unity中的New Input System。这是Unity全新的输入系统，比旧的输入系统更加强大和灵活，可以更好地管理复杂的输入（如手柄、键盘、鼠标、触摸屏等），并且更好地支持跨平台游戏开发。

安装与配置

1. 安装步骤

1. 打开Unity编辑器的Package Manager（菜单栏：Window -> Package Manager）
2. 点击右上角的"+"按钮
3. 选择"Unity注册表"
4. 搜索"New Input System"并安装

2. 项目设置

1. 进入 Edit -> Project Settings -> Player
2. 在配置中将"活动输入处理"设置为"New Input System"

3. 创建Input Actions

1. 在项目中右键新建Input Actions文件
2. 勾选"Generate C# Class"
3. 应用后会自动生成辅助脚本类

配置界面说明

1. 主要属性

• Action Maps: 动作映射，用于配置输入设备和输入动作
• Actions: 具体动作配置
• Action Properties: 动作属性配置

2. 配置示例

以创建Player输入动作为例：

1. 在Action Maps中创建Player的Action Map
2. 在Actions中创建具体行为（移动、跳跃、射击等）
3. 在Action Properties中配置具体行为

注意：要区分Action Properties下的Action Type（动作类型）和Control Type（输入设备类型）

Player Input组件

1. 组件配置

在游戏对象下添加Player Input组件，用于管理输入动作。

2. Behavior属性选项

• Send Message: 发送消息
• Invoke Unity Events: 调用Unity事件
• Invoke C# Events: 调用C#事件

推荐使用Invoke Unity Events，便于在Unity事件中管理输入动作

代码实现

代码均为可实现代码,博主非常懒没有剪成代码块,如有需要,在Unity中配置好后,复制粘贴直接就可使用！

1. 轮询方式

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerReconstruction : MonoBehaviour
{
    [SerializeField] private Transform cameraTransform;
    private CharacterController controller;
    private float moveSpeed = 5f;
    private float jumpForce = 5f;
    private float sensitivity = 2f;
    private float gravity = -9.81f;
    private Vector3 moveDirection;
    private Vector3 moveVelocity;
    private float velocityRotation;
    private float verticalVelocity;
    private ActionsReconstruction actionsReconstruction;

    void Awake()
    {
        controller = GetComponent<CharacterController>();
        actionsReconstruction = new ActionsReconstruction();
    }

    void OnEnable()
    {
        actionsReconstruction.Enable();
    }

    void OnDisable()
    {
        actionsReconstruction.Disable();
    }

    void Update()
    {
        HandleMove();
        HandleLook();
        HandleJump();
    }

    private void HandleMove()
    {
        Vector2 moveInput = actionsReconstruction.Player.Move.ReadValue<Vector2>();
        moveDirection = transform.right * moveInput.x + transform.forward * moveInput.y;
        moveVelocity = moveDirection * moveSpeed;

        Vector3 finalVelocity = moveVelocity + Vector3.up * verticalVelocity;
        controller.Move(finalVelocity * Time.deltaTime);
    }

    private void HandleLook()
    {
        Vector2 lookInput = actionsReconstruction.Player.Look.ReadValue<Vector2>();
        transform.Rotate(Vector3.up * lookInput.x * sensitivity * Time.deltaTime);

        velocityRotation -= lookInput.y * sensitivity * Time.deltaTime;
        velocityRotation = Mathf.Clamp(velocityRotation, -90f, 90f);
        cameraTransform.localRotation = Quaternion.Euler(velocityRotation, 0f, 0f);
    }

    private void HandleJump()
    {
        if (controller.isGrounded)
        {
            verticalVelocity = -0.5f;
        }
        else
        {
            verticalVelocity += gravity * Time.deltaTime;
        }
    }
}

上述实现方式利用轮训式正确的调用了全新的输入系统,但是我们会发现,如果在Update中调用,会存在卡顿的现象,这是因为NewInputSystem的输入动作是每帧都会调用的,但是我们每一帧都会执行一遍Update方法,我们就可能想到用事件调用的方式来解决这个问题。

2. 回调方式

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.InputSystem;  // 添加InputSystem命名空间

public class PlayerReconstruction : MonoBehaviour
{
    [SerializeField] private Transform cameraTransform;
    private CharacterController controller;
    private float moveSpeed = 5f;
    private float jumpForce = 5f;
    private float sensitivity = 2f;
    private float gravity = -9.81f;
    private Vector3 moveDirection;
    private Vector3 moveVelocity;
    private float velocityRotation;
    private float verticalVelocity;
    private Vector2 moveInput; 
    private Vector2 lookInput;   
    private ActionsReconstruction actionsReconstruction;

    void Awake()
    {
        controller = GetComponent<CharacterController>();
        actionsReconstruction = new ActionsReconstruction();

        // 注册输入回调
        actionsReconstruction.Player.Move.performed += OnMove;
        actionsReconstruction.Player.Move.canceled += OnMove;
        actionsReconstruction.Player.Look.performed += OnLook;
        actionsReconstruction.Player.Look.canceled += OnLook;
        actionsReconstruction.Player.Jump.performed += OnJump;
    }

    void OnEnable()
    {
        actionsReconstruction.Enable();
    }

    void OnDisable()
    {
        actionsReconstruction.Disable();
    }

    void OnDestroy()
    {
        // 取消注册输入回调
        actionsReconstruction.Player.Move.performed -= OnMove;
        actionsReconstruction.Player.Look.performed -= OnLook;
        actionsReconstruction.Player.Jump.performed -= OnJump;
    }

    void Update()
    {
        HandleMove();
        HandleLook();
        HandleJump();
    }

    // 移动输入回调
    private void OnMove(InputAction.CallbackContext context)
    {
        moveInput = context.ReadValue<Vector2>();
    }

    // 视角输入回调
    private void OnLook(InputAction.CallbackContext context)
    {
        lookInput = context.ReadValue<Vector2>();
    }

    // 跳跃输入回调
    private void OnJump( InputAction.CallbackContext context)
    {
        if (controller.isGrounded)
        {
            verticalVelocity = jumpForce;
        }
    }
    private void OnMoveCanceled(InputAction.CallbackContext context)
    {
        moveInput = Vector2.zero;
    }
    private void OnLookCanceled(InputAction.CallbackContext context)
    {
        lookInput = Vector2.zero;
    }

    private void HandleMove()
    {
        moveDirection = transform.right * moveInput.x + transform.forward * moveInput.y;
        moveVelocity = moveDirection * moveSpeed;

        Vector3 finalVelocity = moveVelocity + Vector3.up * verticalVelocity;
        controller.Move(finalVelocity * Time.deltaTime);
    }

    private void HandleLook()
    {
        transform.Rotate(Vector3.up * lookInput.x * sensitivity * Time.deltaTime);

        velocityRotation -= lookInput.y * sensitivity * Time.deltaTime;
        velocityRotation = Mathf.Clamp(velocityRotation, -90f, 90f);
        cameraTransform.localRotation = Quaternion.Euler(velocityRotation, 0f, 0f);
    }

    private void HandleJump()
    {
        if (controller.isGrounded)
        {
            verticalVelocity = -0.5f;
        }
        else
        {
            verticalVelocity += gravity * Time.deltaTime;
        }
    }
}

实现方式比较

1. 轮询方式特点

• 在Update中调用
• 可能存在卡顿现象
• 每帧都会执行检查

2. 回调方式特点

• 只在输入发生时调用
• 避免了轮询的性能开销
• 高频输入时可能影响性能

使用建议

上述方法用回调的方法完成了新输入系统的操作,避免了轮训式调用,只在用户输入的时候回调方法,但是我们会发现,如果用户输入的频率很高,比如玩家一直按着移动键,那么就会一直回调方法,这样就会导致性能的下降,随着输入频率的增加可能会出现丢包的现象,所以在特定的情况我们还需要轮训的方法调用,让我们思考一下什么时候需要轮训的方法调用,什么时候需要事件调用的方法调用。

从以上的实例讲,类似于玩家移动视角移动,我们可能会一直按着移动键,那么我们就可以使用轮训的方法调用,如果玩家只是偶尔移动一下,那么我们就可以使用事件调用的方法调用,比如跳跃的逻辑我们就可以使用事件调用的方法调用,因为跳跃的逻辑只需要在玩家按下跳跃键的时候调用一次就可以了。

总结

1. 轮询适用场景

• 持续性输入（如移动、视角控制）
• 需要每帧检查的输入

2. 回调适用场景

• 离散性输入（如跳跃、开火）
• 单次触发的操作

Behavior属性详解

1. Send Message

• 依赖自动生成的脚本类
• 需要遵循命名规范
• 示例：

private void OnJump(InputValue inputValue)
{
    if (controller.isGrounded)
    {
        verticalVelocity = jumpForce;
    }
}

2. Invoke Unity Events

• 可手动编写回调方法
• 更灵活的实现方式
• 使用方式与最初示例一致