Main/Assets/Plugins/References/FuncellBase/Math/ForwardRoter.cs

using UnityEngine;

namespace Thousandto.Core.Base
{
    //朝向旋转工具
    public class ForwardRoter
    {
        #region//私有变量
        //模板朝向
        private Vector3 _destForward = Vector3.forward;
        //当前朝向
        private Vector3 _curForward = Vector3.forward;
        //开始旋转朝向
        private Vector3 _startForward = Vector3.forward;
        //计时器
        private float _updateTimer = 0f;
        //旋转时间
        private float _roteTime = 0f;
        //旋转速度（秒/圈）
        private float _curSpeed = 1f;
        //当前朝向角度
        private float _curFacing = 0f;
        #endregion

        #region//属性
        //目标朝向
        public Vector3 DestForward
        {
            get
            {
                return _destForward;
            }
            set
            {
                if(value.normalized != _destForward)
                {
                    _destForward = value;
                    ReCalculate();
                }
            }
        }
        //当前朝向
        public Vector3 CurForward
        {
            get
            {
                return _curForward;
            }
            set
            {
                _curForward = value.normalized;
                _destForward = _curForward;
                _roteTime = _updateTimer = 0f;
                CalculateFacing();
            }
        }
        //当前朝向角度
        public float CurFacing
        {
            get
            {
                return _curFacing;
            }
        }
        //旋转速度（秒/圈）
        public float CurSpeed
        {
            get
            {
                return _curSpeed;
            }
            set
            {
                if(value > 0f && _curSpeed != value)
                {
                    _curSpeed = value;
                }
            }
        }
        #endregion

        #region//公有函数
        /// <summary>
        /// 更新,返回为True时,表示正在旋转,如果返回false表示当前没有做旋转处理
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public bool Update(float dt)
        {
            if (_roteTime > 0f)
            {
                var tmp = _curForward;
                if (_updateTimer < _roteTime)
                {
                    _updateTimer += dt;
                    var dtAngle = _curSpeed * dt;
                    _curForward = Vector3.Slerp(_startForward, _destForward, _updateTimer / _roteTime).normalized;
                }
                else
                {
                    _curForward = _destForward;
                    _updateTimer = _roteTime = 0f;
                }
                CalculateFacing();
                return _curForward != tmp;
            }
            return false;
        }
        #endregion

        #region//私有函数
        private void ReCalculate()
        {
            _startForward = _curForward;
            float angle = Vector3.Angle(_curForward, _destForward);
            if(angle >= 180f)
            {
                _startForward = Vector3.Slerp(_curForward, _destForward, 1f - (170f/ angle));
            }
            _roteTime = angle / 360f * _curSpeed;
            _updateTimer = 0f;
        }
        private void CalculateFacing()
        {
            _curFacing = Vector3.Angle(Vector3.forward, _curForward);
            if (_curForward.x < 0f)
            {
                _curFacing = 360f - _curFacing;
            }
        }
        #endregion
    }
}