Unity Pico 设备按键

原创 已于 2023-12-15 16:51:56 修改 · 1.2k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#unity #游戏引擎

于 2023-11-27 18:02:23 首次发布
博客介绍了XR Interaction Toolkit 2.5.2，提及Pico系统键盘支持旧输入并发布显示，还涉及Pico设备的按键及震动相关内容，属于游戏开发领域信息技术。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在这里插入图片描述

XR Interaction Toolkit 2.5.2

Pico 系统键盘 支持旧输入 (发布显示)

Pico 设备按键、震动

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.XR;
using CommonUsages = UnityEngine.XR.CommonUsages;
using InputDevice = UnityEngine.XR.InputDevice;
using UnityEngine.XR.Interaction.Toolkit;
using UnityEngine.EventSystems;

public class InputEvent : MonoBehaviour
{
    private InputDeviceEvent leftEvent;
    private InputDeviceEvent rightEvent;
    //public InputDeviceEvent headEvent;

    [SerializeField]
    private XRRayInteractor leftHandRay;
    [SerializeField]
    private XRRayInteractor rightHandRay;
  
    void Awake()
    {
        leftEvent = new InputDeviceEvent(XRNode.LeftHand);
        rightEvent = new InputDeviceEvent(XRNode.RightHand);
        //headEvent = new InputDeviceEvent(XRNode.Head); 
        //Test();
    }

    private void FixedUpdate()
    {
        leftEvent.Update();
        rightEvent.Update();
    }

    #region Core

    /// <summary>
    /// 清空事件 
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    public void RmoveActionAll(int id = 0)
    {
        switch (id)
        {
            case 0:
                leftEvent.RmoveActionAll();
                rightEvent.RmoveActionAll(); break;
            case 1:
                leftEvent.RmoveActionAll(); break;
            case 2:
                rightEvent.RmoveActionAll(); break;
            default:
                break;
        }
    }

    /// <summary>
    /// 添加 移除事件
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    /// <param name="isAdd"></param>
    /// <param name="usagesType"></param>
    /// <param name="btnEnter"></param>
    /// <param name="btnStay"></param>
    /// <param name="btnExit"></param>
    public void AddOrRmoveAction(int id, bool isAdd, CommonUsagesType usagesType, Action<Vector2> btnEnter = null, Action<Vector2> btnStay = null, Action<Vector2> btnExit = null)
    {
        switch (id)
        {
            case 0:
                leftEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit);
                rightEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit); break;
            case 1:
                leftEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit); break;
            case 2:
                rightEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit); break;
            default:
                break;
        }
    }

    /// <summary>
    /// 添加 移除事件
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    /// <param name="isAdd"></param>
    /// <param name="usagesType"></param>
    /// <param name="btnEnter"></param>
    /// <param name="btnStay"></param>
    /// <param name="btnExit"></param>
    public void AddOrRmoveAction(int id, bool isAdd, CommonUsagesType usagesType, Action btnEnter = null, Action btnStay = null, Action btnExit = null)
    {
        switch (id)
        {
            case 0:
                leftEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit);
                rightEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit); break;
            case 1:
                leftEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit); break;
            case 2:
                rightEvent.AddOrRmoveAction(isAdd, usagesType, btnEnter, btnStay, btnExit); break;
            default:
                break;
        }
    }

    /// <summary>
    /// 震动
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    /// <param name="amplitude">振幅 0 - 1</param>
    /// <param name="duration">时长 秒</param>
    public void HapticAction(int id, float amplitude = 0.5f, float duration = 1) //  秒 
    {
        switch (id)
        {
            case 0:
                leftEvent.Haptic(amplitude, duration);
                rightEvent.Haptic(amplitude, duration); break;
            case 1:
                leftEvent.Haptic(amplitude, duration); break;
            case 2:
                rightEvent.Haptic(amplitude, duration); break;
            default:
                break;
        }
    }

    #endregion

    #region 扩展
    /// <summary>
    /// 添加事件
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    /// <param name="usagesType"></param>
    /// <param name="btnEnter"></param>
    /// <param name="btnStay"></param>
    /// <param name="btnExit"></param>
    public void AddAction(int id, CommonUsagesType usagesType, Action btnEnter = null, Action btnStay = null, Action btnExit = null)
    {
        AddOrRmoveAction(id, true, usagesType, btnEnter, btnStay, btnExit);
    }

    /// <summary>
    /// 添加事件
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    /// <param name="usagesType"></param>
    /// <param name="btnEnter"></param>
    /// <param name="btnStay"></param>
    /// <param name="btnExit"></param>
    public void AddAction(int id, CommonUsagesType usagesType, Action<Vector2> btnEnter = null, Action<Vector2> btnStay = null, Action<Vector2> btnExit = null)
    {
        AddOrRmoveAction(id, true, usagesType, btnEnter, btnStay, btnExit);
    }

    /// <summary>
    /// 移除事件
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    /// <param name="usagesType"></param>
    /// <param name="btnEnter"></param>
    /// <param name="btnStay"></param>
    /// <param name="btnExit"></param>
    public void RmoveAction(int id, CommonUsagesType usagesType, Action btnEnter = null, Action btnStay = null, Action btnExit = null)
    {
        AddOrRmoveAction(id, false, usagesType, btnEnter, btnStay, btnExit);
    }

    /// <summary>
    /// 移除事件
    /// </summary>
    /// <param name="id">0：双手 1：左手 2：右手</param>
    /// <param name="usagesType"></param>
    /// <param name="btnEnter"></param>
    /// <param name="btnStay"></param>
    /// <param name="btnExit"></param>
    public void RmoveAction(int id, CommonUsagesType usagesType, Action<Vector2> btnEnter = null, Action<Vector2> btnStay = null, Action<Vector2> btnExit = null)
    {
        AddOrRmoveAction(id, false, usagesType, btnEnter, btnStay, btnExit);
    }
    #endregion

    #region 测试

    void Test()
    {
        AddAction(2, CommonUsagesType.AXButton, null, TestActionStay, TestActionExit);
        AddAction(2, CommonUsagesType.AXButton, TestActionEnter2, TestActionStay2, null);
        AddAction(2, CommonUsagesType.Joy2DAxisMove, TestJoyActionEnter, TestJoyActionStay, TestJoyActionExit);

        Invoke("Test2", 50);
    }
    void Test2()
    {
        Debug.Log("Clear");
        RmoveAction(2, CommonUsagesType.AXButton, null, TestActionStay, TestActionExit);
        RmoveAction(2, CommonUsagesType.AXButton, TestActionEnter2, TestActionStay2, null);
        RmoveAction(2, CommonUsagesType.Joy2DAxisMove, TestJoyActionEnter, TestJoyActionStay, TestJoyActionExit);
    }

    void TestActionEnter2()
    {
        Debug.Log("TestActionEnter2:");
    }

    void TestActionStay2()
    {
        Debug.Log("TestActionStay2:");
    }
    void TestActionExit2()
    {
        Debug.Log("TestActionExit2:");
    }


    void TestActionEnter()
    {
        Debug.Log("TestActionEnter:");
    }

    void TestActionStay()
    {
        Debug.Log("TestActionStay:");
    }

    void TestActionExit()
    {
        Debug.Log("TestActionExit:");
    }

    void TestJoyActionEnter(Vector2 aix)
    {
        Debug.Log("TestJoyActionEnter:" + aix);
    }

    void TestJoyActionStay(Vector2 aix)
    {
        Debug.Log("TestJoyActionStay:" + aix);
    }

    void TestJoyActionExit(Vector2 aix)
    {
        Debug.Log("TestJoyActionExit:" + aix);
    }

    #endregion

    #region  XRRayInteractor

    public RaycastResult GetUIRaycast(int id = 0)
    {
        RaycastResult raycastResult;
        switch (id)
        {
            case 1: leftHandRay.TryGetCurrentUIRaycastResult(out raycastResult); break;
            case 2: rightHandRay.TryGetCurrentUIRaycastResult(out raycastResult); break;
            default:
                leftHandRay.TryGetCurrentUIRaycastResult(out raycastResult);
                if (raycastResult.gameObject != null)
                {

                }
                else
                {
                    rightHandRay.TryGetCurrentUIRaycastResult(out raycastResult);
                    if (raycastResult.gameObject != null)
                    {

                    }
                }
                break;
        }

        return raycastResult;
    }

    public Transform GetRaycast(int id = 0)
    {
        switch (id)
        {
            case 1: return leftHandRay.rayEndTransform; ;
            case 2: return rightHandRay.rayEndTransform;
            default:
                if (leftHandRay.rayEndTransform != null)
                {
                    return leftHandRay.rayEndTransform;
                }
                else if (rightHandRay.rayEndTransform != null)
                {
                    return rightHandRay.rayEndTransform;
                }
                break;
        }

        return null;
    }

    public bool GetRaycast(out Vector3 pos, int mask, int id = 0)
    {
        bool state = false;
        switch (id)
        {
            case 1: state = GetRaycast(leftHandRay.transform, out pos, mask); break;
            case 2: state = GetRaycast(rightHandRay.transform, out pos, mask); break;
            default:
                state = GetRaycast(leftHandRay.transform, out pos, mask);
                if (!state)
                    state = GetRaycast(rightHandRay.transform, out pos, mask); 
                break;
        }
        return state;
    }

    private bool GetRaycast(Transform rayTrans, out Vector3 pos, int mask)
    {
        pos = Vector3.zero;

        if (Physics.Raycast(rayTrans.transform.position, rayTrans.transform.forward, out RaycastHit hit, 1000, mask))
        {
            pos = hit.point;
            return true;
        }
        return false;
    }


    #endregion
}


[Serializable]
public class InputDeviceEvent
{
    #region public event

    public Action onTriggerEnter;
    public Action onTriggerStay;
    public Action onTriggerExit;

    public Action onGripEnter;
    public Action onGripStay;
    public Action onGripUp;

    public Action onAXButtonEnter;
    public Action onAXButtonStay;
    public Action onAXButtonExit;

    public Action onBYButtonEnter;
    public Action onBYButtonStay;
    public Action onBYButonExit;

    public Action onMenuButtonEnter;
    public Action onMenuButtonStay;
    public Action onMenuButtonExit;

    public Action onJoy2DAxisClickEnter;
    public Action onJoy2DAxisClickStay;
    public Action onJoy2DAxisClickExit;

    public Action<Vector2> onJoy2DAxisMoveEnter;
    public Action<Vector2> onJoy2DAxisMoveExit;
    public Action<Vector2> onJoy2DAxisMoveStay;
     
    #endregion

    //提供状态字典独立记录各个feature的状态
    private Dictionary<string, bool> stateDic = new Dictionary<string, bool>();
    private XRNode xRNode;
    private InputDevice inputDevice;

    public InputDeviceEvent()
    {

    }

    public InputDeviceEvent(XRNode xRNode)
    {
        this.xRNode = xRNode;

        Init();
    }

    private void Init()
    {
        if (inputDevice == null || !inputDevice.isValid)
        {
            inputDevice = InputDevices.GetDeviceAtXRNode(xRNode);
        }
    }

    public void Update() //******************每帧轮询监听事件***********************
    {
        if (inputDevice != null && inputDevice.isValid)
        {
            ButtonDispatchModel(inputDevice, CommonUsages.triggerButton, onTriggerEnter, onTriggerStay, onTriggerExit);//扳机
            ButtonDispatchModel(inputDevice, CommonUsages.gripButton, onGripEnter, onGripStay, onGripUp);//抓取
            ButtonDispatchModel(inputDevice, CommonUsages.primaryButton, onAXButtonEnter, onAXButtonStay, onAXButtonExit);//AX
            ButtonDispatchModel(inputDevice, CommonUsages.secondaryButton, onBYButtonEnter, onBYButtonStay, onBYButonExit);//BY

            ButtonDispatchModel(inputDevice, CommonUsages.menuButton, onMenuButtonEnter, onMenuButtonStay, onMenuButtonExit); //菜单 pico右手柄 无效  
            ButtonDispatchModel(inputDevice, CommonUsages.primary2DAxisClick, onJoy2DAxisClickEnter, onJoy2DAxisClickStay, onJoy2DAxisClickExit);//摇杆

            JoyStickDispatchModel(inputDevice, CommonUsages.primary2DAxis, onJoy2DAxisMoveEnter, onJoy2DAxisMoveStay, onJoy2DAxisMoveExit);//摇杆
        }
        else
        {
            Init();
        }
    }

    /// <summary>
    /// 手柄振动
    /// </summary>
    /// <param name="amplitude">振幅为 0 - 1</param>
    /// <param name="duration">振动时长为   秒 </param>
    public void Haptic(float amplitude = 0.5f, float duration = 1) //  秒 
    {
        if (inputDevice != null && inputDevice.isValid)
        {
            bool isTry = inputDevice.TryGetHapticCapabilities(out HapticCapabilities capabilities);
            if (isTry)
            {
                //int channel = 0;
                //uint channel = capabilities.numChannels;
                //int channel = xRNode == XRNode.LeftHand ? 0 : 1; 
                //震动方法,第一个参数为频道,默认0即可,第二个参数是震动频率0-1,第三个参数为震动时长  
                //inputDevice.SendHapticImpulse((uint)channel, amplitude, duration);

                ////震动强度：0.1f、时间2000毫秒（2秒）、震动左手柄还是右手柄（这里是两个都震动） 
                //Unity.XR.PXR.PXR_Input.SetControllerVibration(amplitude, (int)duration * 1000, xRNode == XRNode.LeftHand ? Unity.XR.PXR.PXR_Input.Controller.LeftController : Unity.XR.PXR.PXR_Input.Controller.RightController);


                //编辑器 无反应 发布有效
                //为右手柄开启触觉反馈，振幅为 0.5，振动时长为 500ms，振动频率为 100Hz
                Unity.XR.PXR.PXR_Input.SendHapticImpulse(
                     xRNode == XRNode.LeftHand ? Unity.XR.PXR.PXR_Input.VibrateType.LeftController : Unity.XR.PXR.PXR_Input.VibrateType.RightController
                    , amplitude, (int)(duration * 1000), 100);

                Log("Haptic: " + inputDevice.name);
            }
        }
        else
        {
            Init();
        }
    }

    /// <summary>
    /// 按钮事件源触发模板
    /// </summary>
    /// <param name="device">设备</param>
    /// <param name="usage">功能特征</param>
    /// <param name="btnEnter">开始事件</param>
    /// <param name="btnStay">进行中事件</param>
    /// <param name="btnExit">结束事件</param>
    private void ButtonDispatchModel(InputDevice device, InputFeatureUsage<bool> usage, Action btnEnter, Action btnStay, Action btnExit)
    {
        //为首次执行的feature添加bool状态 -- 用以判断Enter和Up状态

        string featureKey = $"{device.characteristics}_{usage.name}";
        if (!stateDic.ContainsKey(featureKey))
        {
            stateDic.Add(featureKey, false);
        }

        bool isDown;
        if (device.TryGetFeatureValue(usage, out isDown) && isDown)
        {
            if (!stateDic[featureKey])
            {
                stateDic[featureKey] = true;
                btnEnter?.Invoke();

                Haptic(0.5f, 0.01f);
                Log($"usage Enter: {featureKey}  {btnEnter}");
            }
            btnStay?.Invoke();
            Log($"usage Stay: {featureKey}  {btnStay}");
        }
        else
        {
            if (stateDic[featureKey])
            {
                btnExit?.Invoke();
                stateDic[featureKey] = false;

                Log($"usage Exit: {featureKey}  {btnExit}");
            }
        }
    }

    /// <summary>
    /// 摇杆事件源触发模板
    /// </summary>
    /// <param name="device">设备</param>
    /// <param name="usage">功能特征</param>
    /// <param name="btnEnter">开始事件</param>
    /// <param name="btnStay">进行中事件</param>
    /// <param name="btnExit">结束事件</param>
    private void JoyStickDispatchModel(InputDevice device, InputFeatureUsage<Vector2> usage, Action<Vector2> btnEnter, Action<Vector2> btnStay, Action<Vector2> btnExit)
    {
        //为首次执行的feature添加bool状态 -- 用以判断Enter和Up状态

        string featureKey = $"{device.characteristics}_{usage.name}";
        if (!stateDic.ContainsKey(featureKey))
        {
            stateDic.Add(featureKey, false);
        }
        Vector2 axis;
        bool isDown = device.TryGetFeatureValue(usage, out axis);
        if (isDown && !axis.Equals(Vector2.zero))
        {
            if (!stateDic[featureKey])
            {
                stateDic[featureKey] = true;
                btnEnter?.Invoke(axis);
                Log($"usage Enter: {featureKey}  {btnEnter}  {axis}");
            }


            btnStay?.Invoke(axis);
            Log($"usage Stay: {featureKey}  {btnStay}  {axis}");
        }
        else
        {
            if (stateDic[featureKey])
            {
                btnExit?.Invoke(axis);
                stateDic[featureKey] = false;

                Log($"usage Exit: {featureKey}  {btnExit}  {axis}");
            }
        }
    }

    private void Log(string value)
    {
        Debug.Log(value);
        DebugHelper.instance.Log(value);
    }

    #region 扩展

    public void RmoveActionAll()
    {
        string[] enumNames = Enum.GetNames(typeof(CommonUsagesType));
        int count = enumNames.Length;
        for (int i = 0; i < count; i++)
        {
            RmoveAction((CommonUsagesType)Enum.Parse(typeof(CommonUsagesType), enumNames[i]));
        }

        //foreach (CommonUsagesType item in Enum.GetValues(typeof(CommonUsagesType)))
        //{
        //    RmoveAction(item);
        //}
    }
    public void RmoveAction(CommonUsagesType usagesType)
    {
        switch (usagesType)
        {
            case CommonUsagesType.TriggerButton:

                onTriggerEnter = null;
                onTriggerStay = null;
                onTriggerExit = null;
                break;
            case CommonUsagesType.GripButton:
                onGripEnter = null;
                onGripStay = null;
                onGripUp = null;
                break;
            case CommonUsagesType.AXButton:
                onAXButtonEnter = null;
                onAXButtonStay = null;
                onAXButtonExit = null;
                break;
            case CommonUsagesType.BYButton:
                onBYButtonEnter = null;
                onBYButtonStay = null;
                onBYButonExit = null;
                break;
            case CommonUsagesType.MenuButton:
                onMenuButtonEnter = null;
                onMenuButtonStay = null;
                onMenuButtonExit = null;
                break;
            case CommonUsagesType.Joy2DAxisButton:
                onJoy2DAxisClickEnter = null;
                onJoy2DAxisClickStay = null;
                onJoy2DAxisClickExit = null;
                break;
            case CommonUsagesType.Joy2DAxisMove:
                onJoy2DAxisMoveEnter = null;
                onJoy2DAxisMoveStay = null;
                onJoy2DAxisMoveExit = null;
                break;

            default:
                break;
        }
    }

    public void AddOrRmoveAction(bool isAdd, CommonUsagesType usagesType, Action btnEnter = null, Action btnStay = null, Action btnExit = null)
    {
        switch (usagesType)
        {
            case CommonUsagesType.TriggerButton:
                AddOrRmoveAction(isAdd, ref onTriggerEnter, ref onTriggerStay, ref onTriggerExit, btnEnter, btnStay, btnExit);
                break;
            case CommonUsagesType.GripButton:
                AddOrRmoveAction(isAdd, ref onGripEnter, ref onGripStay, ref onGripUp, btnEnter, btnStay, btnExit);
                break;
            case CommonUsagesType.AXButton:
                AddOrRmoveAction(isAdd, ref onAXButtonEnter, ref onAXButtonStay, ref onAXButtonExit, btnEnter, btnStay, btnExit);
                break;
            case CommonUsagesType.BYButton:
                AddOrRmoveAction(isAdd, ref onBYButtonEnter, ref onBYButtonStay, ref onBYButonExit, btnEnter, btnStay, btnExit);
                break;
            case CommonUsagesType.MenuButton:
                AddOrRmoveAction(isAdd, ref onMenuButtonEnter, ref onMenuButtonStay, ref onMenuButtonExit, btnEnter, btnStay, btnExit);
                break;
            case CommonUsagesType.Joy2DAxisButton:
                AddOrRmoveAction(isAdd, ref onJoy2DAxisClickEnter, ref onJoy2DAxisClickStay, ref onJoy2DAxisClickExit, btnEnter, btnStay, btnExit);
                break;
            default:
                break;
        }
    }
    public void AddOrRmoveAction(bool isAdd, CommonUsagesType usagesType, Action<Vector2> btnEnter = null, Action<Vector2> btnStay = null, Action<Vector2> btnExit = null)
    {
        switch (usagesType)
        {
            case CommonUsagesType.Joy2DAxisMove:
                AddOrRmoveAction(isAdd, ref onJoy2DAxisMoveEnter, ref onJoy2DAxisMoveStay, ref onJoy2DAxisMoveExit, btnEnter, btnStay, btnExit);
                break;
            default:
                break;
        }
    }
    private void AddOrRmoveAction(bool isAdd, ref Action obtnEnter, ref Action obtnStay, ref Action obtnExit, Action btnEnter, Action btnStay, Action btnExit)
    {
        if (isAdd)
        {
            obtnEnter += btnEnter;
            obtnStay += btnStay;
            obtnExit += btnExit;
        }
        else
        {
            obtnEnter -= btnEnter;
            obtnStay -= btnStay;
            obtnExit -= btnExit;
        }
    }
    private void AddOrRmoveAction(bool isAdd, ref Action<Vector2> obtnEnter, ref Action<Vector2> obtnStay, ref Action<Vector2> obtnExit, Action<Vector2> btnEnter, Action<Vector2> btnStay, Action<Vector2> btnExit)
    {
        if (isAdd)
        {
            obtnEnter += btnEnter;
            obtnStay += btnStay;
            obtnExit += btnExit;
        }
        else
        {
            obtnEnter -= btnEnter;
            obtnStay -= btnStay;
            obtnExit -= btnExit;
        }
    }

    #endregion
}

public enum CommonUsagesType
{
    TriggerButton,
    GripButton,
    AXButton,
    BYButton,
    MenuButton,
    Joy2DAxisButton,
    Joy2DAxisMove,
}
cwl72
关注
【VR设备PICO 4教程】Unity3D中实现对PICO 4的手柄按键响应
优快云博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
03-06 2629
最近在搞PICO 4开发，尝试了几种PICO 4的手柄按钮响应方法，这篇文章就总结一下几种按钮响应方法。后面，还会根据PICO 4开发的项目配置、开发环境配置、SDK导入、创建场景、移动、瞬移、射线、抓握等内容进行总结，形成PICO 4系列开发文章，尽请期待。
Unity-Pico高级开发（一）按键监听，射线交互物体变色
2201_75516689的博客
02-19 4328
picoXR为Unity提供的Unity XR SDK是基于Unity XR实现的各个功能，针对手柄和头盔的各个按键摇杆事件的获取，均是采用的Unity XR提供的方法。目前UnityXR只提供了if判断的方式每帧监听的方式，还未提供事件接口等形式。以及XR射线也是仅针对于UGUI的，未对物体有变色状态，我们这里就是进行完善。为方便读者理解后续API，先粗略介绍一下Unity XR监听按键摇杆的步骤。
Pico键盘输入工程文件
06-28
使用Unity开发Pico程序中无法调取系统键盘，自己写了一个Pico键盘输入文件（只有英文数字，没有拼音）
Unity中PICO按键事件绑定
最新发布
qq_60586261的博客
05-23 1040
/定义手柄按键。
Unity Pico开发之键盘输入
09-16 5854
在Pico的开发过程中，发现了一个严重的问题，Pico没有办法像手机那样调取键盘输入，如果想要调取，需要Pico那面的技术支持，非常的麻烦，所以就自己做了一个输入键盘，唯一的缺点就是不能进行中文输入，只能输入英文和数字。有需要的小伙伴可以借鉴一下，如果有更好的方法，欢迎指导，大家共同学习。工程文件会在文章末尾分想给大家 效果如下： 下面来分享一下实现过程： Pico开发最好不要用UI（Canva...
Pico Unity开发（用户键盘输入）——5.11山大软院项目实训
m0_63143408的博客
05-11 830
因为当前项目有这样的需求，所以在网上搜了半天怎么做用户键盘输入，发现大部分人都是在尝试自己键盘，没有说这样的尝试不好的意思，我的意思是Pico有现成的系统键盘可以直接调用。下面介绍操作方法。
Unity的pico开发VR输入法.7z
05-27
适应于最新版pico开发的VR输入发，适应快速开发
Pico4 MR Unity零基础开发之获取手柄按键
十画的博客
06-07 2453
1、打开Package Manager面板，导入示例资源。2、打开示例场景，方面后面测试。
Unity之Pico手柄按键（G2控制器按键）
热门推荐
团团小团团的博客
09-04 1万+
主要针对Pico的G2手柄 官方文档：https://sdk.picovr.com/docs/sdk/cn/chapter_five.html#pico-goblin-g2-g2-4k-vr-glasses 下面写一些常用的按键（基本都是写在Update中）： 1、圆盘相关： 圆盘中心位置 1>Pvr_UnitySDKAPI.Controller.UPvr_GetKey(0,Pvr_KeyCode.TOUCHPAD)//圆盘按下（按下状态会持续触发） 2>Pvr_UnitySDKAP
unity pico3 按键获取
11-09
在Unity中，你可以通过以下步骤获取Pico 3控制器的按键状态： 1. **启用Input System**: 确保在项目设置里启用了Input System插件，这会自动创建Input Manager并处理设备输入。 2. **添加组件**: 将`Pico Input ...
Raspberry Pi Pico SDK开发-GPIO与按键输入控制
视觉与物联智能
03-27 780
RP2040 由 Raspberry Pi 设计，具有双核 Arm Cortex-M0+ 处理器和 264KB 内部 RAM，并支持高达 16MB 的片外闪存。 广泛的灵活 I/O 选项包括 I2C、SPI 和独特的可编程 I/O (PIO)。 文本将实现按键输入控制LED。
unity3d 虚拟屏幕键盘
05-09
Unity 虚拟开发中需要的虚拟键盘插件
Unity 虚拟键盘插件资源包
06-07
Unity 虚拟开发中需要的虚拟键盘插件，也可以自己在AssetStore下载，网络不佳的就在这下载吧！
UnityUGUI模拟中文输入法
11-05
UnityUGUI模拟中文输入法,输入英文字母就可以联想中文输入
Unity 调用系统自带的虚拟键盘
qq_42127428的博客
10-30 3246
说明 两种方式启动了Win10自带的两种虚拟键盘。 tabtip.exe 在有些系统上启动不了（不知道为啥，所以才有了第一种） 代码 using System; using System.Diagnostics; using System.Runtime.InteropServices; using UnityEngine; public class TouchKeyboard { static Process sf; [DllImport("user32")] static extern
【CircuitPython】RaspberryPi Pico RP2040 自定义机械键盘实例
perseverance51博客
08-31 3652
【CircuitPython】RaspberryPi Pico RP2040 自定义机械键盘实例
抽奖 | 送树莓派PICO开发板、机械键盘、声控鼠标
张巧龙的博客
10-08 224
上次国庆送了一波，这次继续。礼品介绍1.树莓派MCU PICO开发板2.机械键盘3.科大讯飞语音鼠标参与方式1. 点击下方公众号卡片，后台回复关键词：10，获取礼品抽奖链接/...
树莓派pico入坑笔记，快捷键键盘制作
m0_74644005的博客
06-17 1151
使用usb_hid功能制作快捷键小键盘，定义了6个键，分别是。boot启动程序代码，作用是防止被识别为usb存储设备。需要用到的库，记得复制进单片机存储里面。更多hid设备参考以下教程。然后是main主程序代码。
Unity中PICO中手柄按键返回值
楠溪泽岸的博客
03-13 3106
在上篇文章中，我们实现了PICO中 隔空取物 和 接触抓取。在这篇文章中，我们来实现 手柄C#脚本交互。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值