pico3+unity开发学习记录之平移

修改官方传送脚本也挂在cameraRig上即可；

这个是原来脚本

修改后：

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

namespace UnityEngine.XR.Interaction.Toolkit
{

    public sealed class PlayerSnapForward : LocomotionProvider
    {

        public enum InputAxes
        {
            Primary2DAxis = 0,
            Secondary2DAxis = 1,
        };

        static readonly InputFeatureUsage<Vector2>[] m_Vec2UsageList = new InputFeatureUsage<Vector2>[] {
            CommonUsages.primary2DAxis,
            CommonUsages.secondary2DAxis,
        };

        [SerializeField]
        [Tooltip("主要设备上的2D输入轴，用于触发快速转弯。")]
        InputAxes m_TurnUsage = InputAxes.Primary2DAxis;

        public InputAxes turnUsage { get { return m_TurnUsage; } set { m_TurnUsage = value; } }

        [SerializeField]
        [Tooltip("允许快速旋转的控制器列表。如果XRController没有启用，或者没有启用输入操作。快速转弯将不起作用。")]
        List<XRController> m_Controllers = new List<XRController>();

        public List<XRController> controllers { get { return m_Controllers; } set { m_Controllers = value; } }

        [SerializeField]
        [Tooltip("前进或者后退的速度")]
        float m_MoveAmount = 1.5f;

        public float turnAmount { get { return m_MoveAmount; } set { m_MoveAmount = value; } }

        [SerializeField]
        [Tooltip("系统在开始另一个急转前等待的时间。")]
        float m_DebounceTime = 0.5f;

        public float debounceTime { get { return m_DebounceTime; } set { m_DebounceTime = value; } }

        [SerializeField]
        [Tooltip("控制器移动到触发急转弯的死区。")]
        float m_DeadZone = 0.75f;

        public float deadZone { get { return m_DeadZone; } set { m_DeadZone = value; } }

        // state data
        float m_CurrentTurnAmount = 0.0f;
        float m_TimeStarted = 0.0f;

        List<bool> m_ControllersWereActive = new List<bool>();



        public Transform cameraView;
        private void Update()
        {
            //控制器移动到触发急转弯的死区。等待一定的时间后再允许另一个回合。
            if (m_TimeStarted > 0.0f && (m_TimeStarted + m_DebounceTime < Time.time))
            {
                m_TimeStarted = 0.0f;
                return;
            }

            if (m_Controllers.Count > 0)
            {
                EnsureControllerDataListSize();

                InputFeatureUsage<Vector2> feature = m_Vec2UsageList[(int)m_TurnUsage];
                for (int i = 0; i < m_Controllers.Count; i++)
                {
                    XRController controller = m_Controllers[i];
                    if (controller != null)
                    {
                        if (controller.enableInputActions && m_ControllersWereActive[i])
                        {
                            InputDevice device = controller.inputDevice;

                            Vector2 currentState;
                            if (device.TryGetFeatureValue(feature, out currentState))
                            {
                                if (currentState.y > deadZone)//修改到Y轴
                                {
                                    StartTurn(m_MoveAmount);
                                }
                                else if (currentState.y < -deadZone)
                                {
                                    StartTurn(-m_MoveAmount);
                                }
                            }
                        }
                        else //这将在启用输入动作时增加1帧延迟，以便启用的帧不会触发快速转弯。
                        {
                            m_ControllersWereActive[i] = controller.enableInputActions;
                        }
                    }
                }
            }

            if (Math.Abs(m_CurrentTurnAmount) > 0.0f && BeginLocomotion())
            {
                var xrRig = system.xrRig;
                if (xrRig != null)
                {
                    //xrRig.transform.Translate(Vector3.forward * m_CurrentTurnAmount);//朝着cameraRig的方向前进
                    xrRig.transform.Translate(cameraView.transform.forward * m_CurrentTurnAmount, Space.World);//向着眼睛的方向前进

                }
                m_CurrentTurnAmount = 0.0f;
                EndLocomotion();
            }
        }

        void EnsureControllerDataListSize()
        {
            if (m_Controllers.Count != m_ControllersWereActive.Count)
            {
                while (m_ControllersWereActive.Count < m_Controllers.Count)
                {
                    m_ControllersWereActive.Add(false);
                }

                while (m_ControllersWereActive.Count < m_Controllers.Count)
                {
                    m_ControllersWereActive.RemoveAt(m_ControllersWereActive.Count - 1);
                }
            }
        }

        internal void FakeStartTurn(bool isLeft)
        {
            StartTurn(isLeft ? -m_MoveAmount : m_MoveAmount);
        }

        private void StartTurn(float amount)
        {
            if (m_TimeStarted != 0.0f)
                return;

            if (!CanBeginLocomotion())
                return;

            m_TimeStarted = Time.time;
            m_CurrentTurnAmount = amount;
        }
    }
}

 就是把原来的传送改成了位移，可以跟原版一样调节速度时间等等。