UnityUI或3D场景实现跟随手机陀螺仪的晃动效果

public enum EGyroType
{
 NoRotate,//不旋转
 ToUp,//手机下方向上倾斜
 ToDown,//手机下方向下倾斜
 ToLeft,//左手边向下倾斜
 ToRight,//右手边向下倾斜
}

using System;
using UnityEngine;
 
public enum EGyroType
{
 NoRotate,//不旋转
 ToUp,//手机下方向上倾斜
 ToDown,//手机下方向下倾斜
 ToLeft,//左手边向下倾斜
 ToRight,//右手边向下倾斜
}
 
public class GyroManager : MonoBehaviour
{
 Gyroscope mGyro;//陀螺仪
 Vector2 mCurrentLandscapeGyroValue, mCurrentPortraitGyroValue;//当前的水平垂直的gravity值
 Vector2 mLastLandscapeGyroValue, mLastPortraitGyroValue;//上一次的水平垂直的gravity值
 
 public EGyroType LandscapeEGyroType, PortraitEGyroType;//手机的水平垂直状态
 float mPrecision = 0.015f;//精度，若前后两次gravity值在精度内，则认为当前没有旋转
 public int LandscapeGyroDifference, PortraitGyroDifference;//模拟的一个旋转速度，gravity值差异越大，则该值越大
 
 bool mIsEnable;//是否开启陀螺仪
 
 private void Start()
 {
 mGyro = Input.gyro;
 SetGyroEnable(true);
 }
 
 //每种状态下需要执行的事件
 public Action LandscapeTransToDefault;
 public Action LandscapeTransToAdd;
 public Action LandscapeTransToReduce;
 
 public Action PortraitTransToDefault;
 public Action PortraitTransToAdd;
 public Action PortraitTransToReduce;
 
 public void ResetLandscape()
 {
 LandscapeEGyroType = EGyroType.NoRotate;
 SetLandScapeValue();
 mLastLandscapeGyroValue = mCurrentLandscapeGyroValue;
 LandscapeGyroDifference = 0;
 }
 
 public void ResetPortrait()
 {
 PortraitEGyroType = EGyroType.NoRotate;
 SetPortraitValue();
 mLastPortraitGyroValue = Vector2.zero;
 PortraitGyroDifference = 0;
 }
 
 void Update()
 {
 if (mIsEnable)
 {
  GetEGyroType();
 
  //根据解析出来的手机状态，执行对应事件
  if (LandscapeEGyroType == EGyroType.ToLeft)
  {
  LandscapeTransToReduce&＃63;.Invoke(LandscapeGyroDifference);
  }
  else if (LandscapeEGyroType == EGyroType.ToRight)
  {
  LandscapeTransToAdd&＃63;.Invoke(LandscapeGyroDifference);
  }
  else
  {
  LandscapeTransToDefault&＃63;.Invoke();
  }
 
  if (PortraitEGyroType == EGyroType.ToDown)
  {
  PortraitTransToReduce&＃63;.Invoke(PortraitGyroDifference);
  }
  else if (PortraitEGyroType == EGyroType.ToUp)
  {
  PortraitTransToAdd&＃63;.Invoke(PortraitGyroDifference);
  }
  else
  {
  PortraitTransToDefault&＃63;.Invoke();
  }
 }
 }
 
 //开启或关闭陀螺仪
 public void SetGyroEnable(bool isEnable)
 {
 if (mIsEnable != isEnable)
 {
  mIsEnable = isEnable;
  ResetLandscape();
  ResetPortrait();
  mGyro.enabled = isEnable;
 }
 }
 
 //解析当前手机状态
 public void GetEGyroType()
 {
 SetLandScapeValue();
 //Landscape
 if (IsEquals(mCurrentLandscapeGyroValue.x, mLastLandscapeGyroValue.x, true))
 {
  LandscapeEGyroType = EGyroType.NoRotate;
  LandscapeGyroDifference = 0;
 }
 else
 {
  LandscapeGyroDifference = (int)(Mathf.Abs(mCurrentLandscapeGyroValue.x - mLastLandscapeGyroValue.x) * 60);
 
  if (mCurrentLandscapeGyroValue.y <0 && mLastLandscapeGyroValue.y <0)
  {
  //当 z <0，x的值变小则为ToLeft，变大则为ToRight
  if (mCurrentLandscapeGyroValue.x  0 && mLastLandscapeGyroValue.y > 0)
  {
  //当 z > 0，x的值变大则为ToLeft，变小则为ToRight
  if (mCurrentLandscapeGyroValue.x  0，若 x <0 则为ToLeft，否则则为ToRight
   if (mCurrentLandscapeGyroValue.x > 0)
   {
   LandscapeEGyroType = EGyroType.ToLeft;
   }
   else
   {
   LandscapeEGyroType = EGyroType.ToRight;
   }
  }
  else
  {
   //当 z > 0 变为 z<0，若 x<0 则为ToRight，否则则为ToLeft
   if (mCurrentLandscapeGyroValue.x <0)
   {
   LandscapeEGyroType = EGyroType.ToLeft;
   }
   else
   {
   LandscapeEGyroType = EGyroType.ToRight;
   }
  }
  }
 }
 mLastLandscapeGyroValue = mCurrentLandscapeGyroValue;
 
 SetPortraitValue();
 //Portrait
 if (IsEquals(mCurrentPortraitGyroValue.x, mLastPortraitGyroValue.x, false))
 {
  PortraitEGyroType = EGyroType.NoRotate;
  PortraitGyroDifference = 0;
 }
 else
 {
  PortraitGyroDifference = (int)(Mathf.Abs(mCurrentPortraitGyroValue.x - mLastPortraitGyroValue.x) * 60);
 
  if (mCurrentPortraitGyroValue.y <0 && mLastPortraitGyroValue.y <0)
  {
  //当 z<0，y的值变大则为ToUp，变小则为ToDown
  if (mCurrentPortraitGyroValue.x  0 && mLastPortraitGyroValue.y > 0)
  {
  //当 z > 0，y的值变大则为ToDown，变小则为ToUp
  if (mCurrentPortraitGyroValue.x  0，则为ToDown，反之则为ToUp
  if (mCurrentPortraitGyroValue.y 0 变 <0
   PortraitEGyroType = EGyroType.ToUp;
  }
  else
  {
   PortraitEGyroType = EGyroType.ToDown;
  }
  }
 }
 mLastPortraitGyroValue = mCurrentPortraitGyroValue;
 }
 
 //读取gravity值
 public void SetLandScapeValue()
 {
 mCurrentLandscapeGyroValue.x = mGyro.gravity.x;
 mCurrentLandscapeGyroValue.y = mGyro.gravity.z;
 }
 
 public void SetPortraitValue()
 {
 mCurrentPortraitGyroValue.x = mGyro.gravity.y;
 mCurrentPortraitGyroValue.y = mGyro.gravity.z;
 }
 
 //前后两次是否相等
 bool IsEquals(float a, float b, bool isLandscape)
 {
 if ((isLandscape && LandscapeEGyroType == EGyroType.NoRotate) || (!isLandscape && PortraitEGyroType == EGyroType.NoRotate))
 {
  if (Mathf.Abs(a - b) <0.025f)
  {
  return true;
  }
 }
 if (Mathf.Abs(a - b) 

using System;
using UnityEngine;
 
public class GyroBase
{
 public float MaxValue;//最大偏移值
 public float DefaultValue;//初始位置
 float mCurrentValue;//当前偏移量
 
 public float Speed;//速度
 public float DuringTime;//等待间隔
 float mCurrentDuringTime;//当前时间间隔
 
 public Action ValueChanged;//偏移事件
 
 public GyroManager mManager;
 
 float mBackSpeed;//回弹速度（一个减速过程）
 float BackSpeed
 {
 get
 {
  if (mBackSpeed > mMinSpeed)
  {
  mBackSpeed = Mathf.Max(mBackSpeed - Speed * mDeltaTime, mMinSpeed);
  }
  return mBackSpeed;
 }
 }
 
 float mMinSpeed;//最小速度
 float mDeltaTime;//Time.deltaTime
 
 bool mIsLandScape;//检测手机水平转动还是垂直转动
 bool mIsResetBackProperty = false;
 
 //初始化赋值
 public void Init(float maxValue, float defaultValue, float speed, float duringTime, bool isLandscape, Action action)
 {
 MaxValue = maxValue;
 DefaultValue = defaultValue;
 Speed = speed;
 DuringTime = duringTime;
 mMinSpeed = Speed * 0.2f;
 mCurrentValue = DefaultValue;
 mIsLandScape = isLandscape;
 
 if (mIsLandScape)
 {
  mManager.LandscapeTransToDefault += TransToDefault;
  mManager.LandscapeTransToAdd += TransToAdd;
  mManager.LandscapeTransToReduce += TransToReduce;
 }
 else
 {
  mManager.PortraitTransToDefault += TransToDefault;
  mManager.PortraitTransToAdd += TransToAdd;
  mManager.PortraitTransToReduce += TransToReduce;
 }
 
 ValueChanged = action;
 }
 
 //事件清除
 public void Clear()
 {
 if (mIsLandScape)
 {
  mManager.LandscapeTransToDefault -= TransToDefault;
  mManager.LandscapeTransToAdd -= TransToAdd;
  mManager.LandscapeTransToReduce -= TransToReduce;
 }
 else
 {
  mManager.PortraitTransToDefault -= TransToDefault;
  mManager.PortraitTransToAdd -= TransToAdd;
  mManager.PortraitTransToReduce -= TransToReduce;
 }
 }
 
 //重设回弹参数
 void ResetBackProperty()
 {
 if (!mIsResetBackProperty)
 {
  mIsResetBackProperty = true;
  mBackSpeed = Speed * 0.8f;
  mCurrentDuringTime = 0;
 }
 }
 
 //手机没转动的时候，超过间隔时间则减速回弹至默认位置
 void TransToDefault()
 {
 mIsResetBackProperty = false;
 mDeltaTime = Time.deltaTime;
 mCurrentDuringTime += mDeltaTime;
 if (mCurrentDuringTime > 1)
 {
  ValueToDefault();
  ValueChanged&＃63;.Invoke(mCurrentValue);
 }
 }
 
 //偏移增加
 void TransToAdd(int difference)
 {
 ResetBackProperty();
 ValueAddSpeed(difference);
 ValueChanged&＃63;.Invoke(mCurrentValue);
 }
 
 //偏移减小
 void TransToReduce(int difference)
 {
 ResetBackProperty();
 ValueReduceSpeed(difference);
 ValueChanged&＃63;.Invoke(mCurrentValue);
 }
 
 void ValueToDefault()
 {
 if (mCurrentValue > DefaultValue)
 {
  mCurrentValue = Mathf.Max(mCurrentValue - BackSpeed * mDeltaTime, DefaultValue);
 }
 else if (mCurrentValue  DefaultValue - MaxValue)
 {
  mCurrentValue = Mathf.Max(mCurrentValue - Speed * mDeltaTime * difference, DefaultValue - MaxValue);
 }
 }
}

public class CameraGyro : MonoBehaviour
{
 public GyroManager mManager;
 
 Transform mTransform;
 Vector3 mCameraAngle;
 
 GyroBase mGyroBase;
 
 void Start()
 {
 mTransform = transform;
 mCameraAngle = Vector3.zero;
 
 mGyroBase = new GyroBase();
 mGyroBase.mManager = mManager;
 mGyroBase.Init(5, 0, 5, 1, false, Change);
 }
 
 void Change(float value)
 {
 mCameraAngle.x = value;
 mTransform.localEulerAngles = mCameraAngle;
 }
}

public class UIGyro : MonoBehaviour
{
 public GyroManager mManager;
 
 void Start()
 {
 GyroBase mGyroBase = new GyroBase();
 mGyroBase.mManager = mManager;
 mGyroBase.Init(80, transform.localPosition.x, 80, 1, true, Change);
 }
 
 void Change(float value)
 {
 transform.localPosition = new Vector3(value, transform.localPosition.y);
 }
}