unity标准资源包FirstPersonController的分析

1.鼠标转动

基类MouseLook,负责处理鼠标转向和准星是否锁定,这个比较简单

using System;
using UnityEngine;
using UnityStandardAssets.CrossPlatformInput;

namespace UnityStandardAssets.Characters.FirstPerson
{
    [Serializable]
    public class MouseLook
    {
        public float XSensitivity = 2f;    //x轴灵敏度
        public float YSensitivity = 2f;    //y轴灵敏地
        public bool clampVerticalRotation = true;   //是否限制俯仰角
        public float MinimumX = -90F;   //最小俯角
        public float MaximumX = 90F;    //最大仰角
        public bool smooth;       
        public float smoothTime = 5f;
        public bool lockCursor = true;   //锁定准星


        private Quaternion m_CharacterTargetRot;  //这个是角色的属性
        private Quaternion m_CameraTargetRot;     //这个是摄像机的属性,这里有必要说下,
        //这里鼠标控制的横向转动是角色转,角色带动摄像机转,但竖着转动是摄像机转,角色不动
        //这样就可以避免出现角色扭曲的情况
        private bool m_cursorIsLocked = true;

        public void Init(Transform character, Transform camera)
        {
            m_CharacterTargetRot = character.localRotation;
            m_CameraTargetRot = camera.localRotation;
        }

        public void LookRotation(Transform character, Transform camera)
        {
            float yRot = CrossPlatformInputManager.GetAxis("Mouse X") * XSensitivity;
            float xRot = CrossPlatformInputManager.GetAxis("Mouse Y") * YSensitivity;//x和y轴的转动角度

            m_CharacterTargetRot *= Quaternion.Euler (0f, yRot, 0f);   //数学关系,不懂= =
            m_CameraTargetRot *= Quaternion.Euler (-xRot, 0f, 0f);

            if(clampVerticalRotation)
                m_CameraTargetRot = ClampRotationAroundXAxis (m_CameraTargetRot);  //得到俯仰角

            if(smooth)   //平滑鼠标,第一人称大部分都不需要,所以不看这个
            {
                character.localRotation = Quaternion.Slerp (character.localRotation, m_CharacterTargetRot,
                    smoothTime * Time.deltaTime);
                camera.localRotation = Quaternion.Slerp (camera.localRotation, m_CameraTargetRot,
                    smoothTime * Time.deltaTime);
            }
            else
            {
                character.localRotation = m_CharacterTargetRot;   //更新坐标,发现这里更新的是两部分,也就是角色和摄像机
                camera.localRotation = m_CameraTargetRot;
            }

            UpdateCursorLock();    //处理准星是否锁定的问题
        }

        public void SetCursorLock(bool value)
        {
            lockCursor = value;
            if(!lockCursor)
            {//we force unlock the cursor if the user disable the cursor locking helper
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible = true;
            }
        }

        public void UpdateCursorLock()
        {
            //if the user set "lockCursor" we check & properly lock the cursos
            if (lockCursor)
                InternalLockUpdate();
        }

        private void InternalLockUpdate()//如果要锁定准星,执行这个方法
        {
            if(Input.GetKeyUp(KeyCode.Escape))
            {
                m_cursorIsLocked = false;  //按下Esc取消锁定
            }
            else if(Input.GetMouseButtonUp(0))
            {
                m_cursorIsLocked = true;
            }

            if (m_cursorIsLocked)  //锁定
            {
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible = false;
            }
            else if (!m_cursorIsLocked)  //取消锁定
            {
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible = true;
            }
            //个人感觉这个m_cursorIsLocked没有必要.....
        }

        Quaternion ClampRotationAroundXAxis(Quaternion q)//Clamp俯仰角
        {
            q.x /= q.w;
            q.y /= q.w;
            q.z /= q.w;
            q.w = 1.0f;

            float angleX = 2.0f * Mathf.Rad2Deg * Mathf.Atan (q.x);

            angleX = Mathf.Clamp (angleX, MinimumX, MaximumX);

            q.x = Mathf.Tan (0.5f * Mathf.Deg2Rad * angleX);

            return q;
        }

    }
}
主要功能在LookRotation()方法上,大体思路就是通过输入得到x和y的转动角,再通过ClampRotationAroundXAxis()方法限制一下俯仰角,最后判断何时锁定准星就可以了。注意这里横着是角色转,带动摄像机转,竖着是摄像机转,角色不转。

在主类FirstPersonController的Update()方法下运行(LookRotation被封装在RotateView()中),在FixUpdated()方法下运行UpdateCursorLock()方法
2.移动,跳跃,人物碰撞
在主类FirstPersonController中,运动之类的都放到FixedUpdate()中,检测跳跃按钮是否按下的在Update()方法里,通过GetInput()方法获取到输入,判断好是走还是跑,然后在FixedUpdate()里通过m_CharacterController.Move()方法让角色运动起来,并通过isGrounded属性判断跳跃的情况,应该有个用球形碰撞检测斜坡的,但是暂时没看懂,碰撞到其他物体后通过OnControllerColliderHit()回调函数执行给碰到的物体的加力的操作。
先给出FirstPersonController类的变量定义和初始化

public class FirstPersonController : MonoBehaviour
    {
        [SerializeField] private bool m_IsWalking;
        [SerializeField] private float m_WalkSpeed;
        [SerializeField] private float m_RunSpeed;
        [SerializeField] [Range(0f, 1f)] private float m_RunstepLenghten;
        [SerializeField] private float m_JumpSpeed;
        [SerializeField] private float m_StickToGroundForce;
        [SerializeField] private float m_GravityMultiplier;
        [SerializeField] private MouseLook m_MouseLook;
        [SerializeField] private bool m_UseFovKick;
        [SerializeField] private FOVKick m_FovKick = new FOVKick();
        [SerializeField] private bool m_UseHeadBob;
        [SerializeField] private CurveControlledBob m_HeadBob = new CurveControlledBob();
        [SerializeField] private LerpControlledBob m_JumpBob = new LerpControlledBob();
        [SerializeField] private float m_StepInterval;
        [SerializeField] private AudioClip[] m_FootstepSounds;    // an array of footstep sounds that will be randomly selected from.
        [SerializeField] private AudioClip m_JumpSound;           // the sound played when character leaves the ground.
        [SerializeField] private AudioClip m_LandSound;           // the sound played when character touches back on ground.

        private Camera m_Camera;
        private bool m_Jump;
        private float m_YRotation;
        private Vector2 m_Input;
        private Vector3 m_MoveDir = Vector3.zero;
        private CharacterController m_CharacterController;
        private CollisionFlags m_CollisionFlags;
        private bool m_PreviouslyGrounded;
        private Vector3 m_OriginalCameraPosition;
        private float m_StepCycle;
        private float m_NextStep;
        private bool m_Jumping;
        private AudioSource m_AudioSource;

        private void Start()
        {
            m_CharacterController = GetComponent<CharacterController>();   //加载角色控制器
            m_Camera = Camera.main;    //得到摄像机
            m_OriginalCameraPosition = m_Camera.transform.localPosition;   //得到摄像机一开始的位置
            m_FovKick.Setup(m_Camera);
            m_HeadBob.Setup(m_Camera, m_StepInterval);
            m_StepCycle = 0f;
            m_NextStep = m_StepCycle/2f;
            m_Jumping = false;    //跳跃状态=false
            m_AudioSource = GetComponent<AudioSource>();
			m_MouseLook.Init(transform , m_Camera.transform);
        }
}
下面是调用到的函数
private void Update()
        {
            RotateView();
            // the jump state needs to read here to make sure it is not missed
            if (!m_Jump)
            {
                m_Jump = CrossPlatformInputManager.GetButtonDown("Jump");  //按下跳跃键
            }

            if (!m_PreviouslyGrounded && m_CharacterController.isGrounded)//处理刚落地的情况
            {
                StartCoroutine(m_JumpBob.DoBobCycle());  //镜头摇晃
                PlayLandingSound();//播放声音
                m_MoveDir.y = 0f;
                m_Jumping = false;
            }
            if (!m_CharacterController.isGrounded && !m_Jumping && m_PreviouslyGrounded)//刚起跳的时候
            {
                m_MoveDir.y = 0f;
            }

            m_PreviouslyGrounded = m_CharacterController.isGrounded;
        }
private void FixedUpdate()
        {
            float speed;     //定义速度,行走还是跑动两个速度二选一
            GetInput(out speed);   //键盘输入并决定是跑还是走,将移动方向存到m_Input中,注意跳的输入放在了Update()里
            // always move along the camera forward as it is the direction that it being aimed at
            Vector3 desiredMove = transform.forward*m_Input.y + transform.right*m_Input.x;  //将m_Input从二维转存到三维中去

            // get a normal for the surface that is being touched to move along it 
            RaycastHit hitInfo;
        /* 
            * Physics.SphereCast, 进行一次球形的碰撞 
            * param: 
            *  origin, 触碰的起始点 
            *  radius, 球形的半径 
            *  direction, 碰撞的方向 
            *  hitInfo, 碰撞的结果 
            *  maxDistance, 碰撞到的最大距离 
            *  layerMask, 碰撞层,所有的都可以碰撞 
            *  queryTriggerInteraction, 是否要触发triiger 
        */
            Physics.SphereCast(transform.position, m_CharacterController.radius, Vector3.down, out hitInfo,
                               m_CharacterController.height/2f, Physics.AllLayers, QueryTriggerInteraction.Ignore);
            //进行球形碰撞,碰撞到的信息存储到了hitInfo中
            desiredMove = Vector3.ProjectOnPlane(desiredMove, hitInfo.normal).normalized;
            //看不懂

            m_MoveDir.x = desiredMove.x*speed;
            m_MoveDir.z = desiredMove.z*speed;
            if (m_CharacterController.isGrounded)
            {
                m_MoveDir.y =-m_StickToGroundForce;

                if (m_Jump)//跳跃情况
                {
                    m_MoveDir.y = m_JumpSpeed;//跳跃速度
                    PlayJumpSound();//播放声音
                    m_Jump = false;
                    m_Jumping = true;
                }
            }
            else
            {
                m_MoveDir += Physics.gravity*m_GravityMultiplier*Time.fixedDeltaTime;//不在地上的时候收到重力作用
            }
            m_CollisionFlags = m_CharacterController.Move(m_MoveDir*Time.fixedDeltaTime);  //通过CharacterController类的Move()方法移动
            //move方法不处理重力
            //m_CollisionFlags是一个存储着在路上碰撞到物体跟角色相对位置的枚举变量
            ProgressStepCycle(speed);   //处理脚步声
            UpdateCameraPosition(speed);//处理镜头晃动

            m_MouseLook.UpdateCursorLock();  //处理准星锁定非锁定
        }
private void GetInput(out float speed)
        {
            // Read input
            float horizontal = CrossPlatformInputManager.GetAxis("Horizontal");
            float vertical = CrossPlatformInputManager.GetAxis("Vertical");

            bool waswalking = m_IsWalking; //定义一个正在walking的bool值

#if !MOBILE_INPUT
            // On standalone builds, walk/run speed is modified by a key press.
            // keep track of whether or not the character is walking or running
            m_IsWalking = !Input.GetKey(KeyCode.LeftShift);  //按住shift让m_IsWalking转换成跑步状态
#endif
            // set the desired speed to be walking or running
            speed = m_IsWalking ? m_WalkSpeed : m_RunSpeed;   //按照跑动还是行走的逻辑决定速度
            m_Input = new Vector2(horizontal, vertical);   

            // normalize input if it exceeds 1 in combined length:
            if (m_Input.sqrMagnitude > 1)  //如果移动二维向量的模大于1,把它转换成单位向量
            {
                m_Input.Normalize();  //不知道有啥用,可能是控制玩家速度是均匀的吧,不会存在斜着走更快
            }

            // handle speed change to give an fov kick
            // only if the player is going to a run, is running and the fovkick is to be used
            if (m_IsWalking != waswalking && m_UseFovKick && m_CharacterController.velocity.sqrMagnitude > 0)
            {
                StopAllCoroutines();
                StartCoroutine(!m_IsWalking ? m_FovKick.FOVKickUp() : m_FovKick.FOVKickDown());
            }
        }
private void OnControllerColliderHit(ControllerColliderHit hit)//当角色碰到物体的时候
        {
            Rigidbody body = hit.collider.attachedRigidbody;
            //dont move the rigidbody if the character is on top of it
            if (m_CollisionFlags == CollisionFlags.Below)
            {
                return;
            }

            if (body == null || body.isKinematic)
            {
                return;
            }
            body.AddForceAtPosition(m_CharacterController.velocity*0.1f, hit.point, ForceMode.Impulse);//给碰到的物体加力
        }
3.镜头晃动
镜头晃动共有两种情况,一种是刚落地的时候镜头会往下压调用LerpControlledBob类对象,第二种是跑动或者行走的时候镜头的正常晃动调用CurveControlledBob类对象。
刚落地的情况是在Update()方法下的if (!m_PreviouslyGrounded && m_CharacterController.isGrounded){}条件下调用StartCoroutine(m_JumpBob.DoBobCycle());
using System;
using System.Collections;
using UnityEngine;

namespace UnityStandardAssets.Utility
{
    [Serializable]
    public class LerpControlledBob
    {
        public float BobDuration;   //晃动持续时间
        public float BobAmount;    //往下晃动的深度

        private float m_Offset = 0f;


        // provides the offset that can be used
        public float Offset()
        {
            return m_Offset;
        }


        public IEnumerator DoBobCycle()
        {
            // make the camera move down slightly
            //下降
            float t = 0f;
            while (t < BobDuration)//计时器
            {
                m_Offset = Mathf.Lerp(0f, BobAmount, t/BobDuration);//计算补偿
                t += Time.deltaTime;
                yield return new WaitForFixedUpdate();//等待FixedUpdate()方法执行完
            }

            // make it move back to neutral
            //上升恢复
            t = 0f;
            while (t < BobDuration)
            {
                m_Offset = Mathf.Lerp(BobAmount, 0f, t/BobDuration);
                t += Time.deltaTime;
                yield return new WaitForFixedUpdate();
            }
            m_Offset = 0f;
        }
    }
}
行走跑步晃动的是FixedUpdate()方法下的UpdateCameraPosition(speed);
这个方法也会影响跳跃晃动
private void UpdateCameraPosition(float speed)
        {
            Vector3 newCameraPosition;   //定义摄像机要移动到的位置
            if (!m_UseHeadBob)
            {
                return;
            }
            if (m_CharacterController.velocity.magnitude > 0 && m_CharacterController.isGrounded)//玩家在地上运动的时候
            {
                m_Camera.transform.localPosition =
                    m_HeadBob.DoHeadBob(m_CharacterController.velocity.magnitude +
                                      (speed*(m_IsWalking ? 1f : m_RunstepLenghten)));//求出一个晃动速度,让摄像机晃动
                newCameraPosition = m_Camera.transform.localPosition;
                newCameraPosition.y = m_Camera.transform.localPosition.y - m_JumpBob.Offset();
            }
            else
            {
                newCameraPosition = m_Camera.transform.localPosition;
                newCameraPosition.y = m_OriginalCameraPosition.y - m_JumpBob.Offset();
            }
            m_Camera.transform.localPosition = newCameraPosition;
        }
4.脚步声
脚步声分两种,一个是跳跃,一个是走跑
用AudioClip播放
着陆是在Update()方法下的PlayLandingSound(),跳跃是在FixedUpdate()下的PlayJumpSound();比较好找
走跑是在FixedUpdate()下的ProgressStepCycle(speed)

private void PlayJumpSound()
        {
            m_AudioSource.clip = m_JumpSound;
            m_AudioSource.Play();
        }
       private void PlayLandingSound()
     {
        m_AudioSource.clip = m_LandSound;
        m_AudioSource.Play();
        m_NextStep = m_StepCycle + .5f;
    }
       private void PlayFootStepAudio()
    {
        if (!m_CharacterController.isGrounded)
        {
           return;
        }
        // pick & play a random footstep sound from the array,
        // excluding sound at index 0
        int n = Random.Range(1, m_FootstepSounds.Length);
        m_AudioSource.clip = m_FootstepSounds[n];
        m_AudioSource.PlayOneShot(m_AudioSource.clip);
        // move picked sound to index 0 so it's not picked next time
        m_FootstepSounds[n] = m_FootstepSounds[0];
        m_FootstepSounds[0] = m_AudioSource.clip;
    }
脚步声通过ProgressStepCycle()调用
private void ProgressStepCycle(float speed)
        {
            if (m_CharacterController.velocity.sqrMagnitude > 0 && (m_Input.x != 0 || m_Input.y != 0))
            {
                m_StepCycle += (m_CharacterController.velocity.magnitude + (speed*(m_IsWalking ? 1f : m_RunstepLenghten)))*
                             Time.fixedDeltaTime;
            }


            if (!(m_StepCycle > m_NextStep))
            {
                return;
            }


            m_NextStep = m_StepCycle + m_StepInterval;


            PlayFootStepAudio();
        }
5FOV
目前我只发现奔跑的时候Fov会变大,行走时恢复,没看到有其他的效果
通过FOVKick类对象在主类的GetInput()方法调用StartCoroutine(!m_IsWalking ? m_FovKick.FOVKickUp() : m_FovKick.FOVKickDown());
using System;
using System.Collections;
using UnityEngine;

namespace UnityStandardAssets.Utility
{
    [Serializable]
    public class FOVKick
    {
        public Camera Camera;                           // optional camera setup, if null the main camera will be used
        [HideInInspector] public float originalFov;     // the original fov
        public float FOVIncrease = 3f;                  // the amount the field of view increases when going into a run
        public float TimeToIncrease = 1f;               // the amount of time the field of view will increase over
        public float TimeToDecrease = 1f;               // the amount of time the field of view will take to return to its original size
        public AnimationCurve IncreaseCurve;


        public void Setup(Camera camera)
        {
            CheckStatus(camera);

            Camera = camera;
            originalFov = camera.fieldOfView;
        }


        private void CheckStatus(Camera camera)
        {
            if (camera == null)
            {
                throw new Exception("FOVKick camera is null, please supply the camera to the constructor");
            }

            if (IncreaseCurve == null)
            {
                throw new Exception(
                    "FOVKick Increase curve is null, please define the curve for the field of view kicks");
            }
        }


        public void ChangeCamera(Camera camera)
        {
            Camera = camera;
        }


        public IEnumerator FOVKickUp()
        {
            float t = Mathf.Abs((Camera.fieldOfView - originalFov)/FOVIncrease);
            while (t < TimeToIncrease)
            {
                Camera.fieldOfView = originalFov + (IncreaseCurve.Evaluate(t/TimeToIncrease)*FOVIncrease);
                t += Time.deltaTime;
                yield return new WaitForEndOfFrame();
            }
        }


        public IEnumerator FOVKickDown()
        {
            float t = Mathf.Abs((Camera.fieldOfView - originalFov)/FOVIncrease);
            while (t > 0)
            {
                Camera.fieldOfView = originalFov + (IncreaseCurve.Evaluate(t/TimeToDecrease)*FOVIncrease);
                t -= Time.deltaTime;
                yield return new WaitForEndOfFrame();
            }
            //make sure that fov returns to the original size
            Camera.fieldOfView = originalFov;
        }
    }
}
通过计时器,方法类似,就不说了


总体来说,就是通过FirstPersonController类
调用MouseLook类对象处理鼠标转向
调用CharacterController类对象处理运动碰撞
调用LerpControlledBob和CurveControlledBob类对象处理摄像机晃动
调用AudioSource类对象处理声音
调用FOVKick类对象处理Fov变化
剩下的可以再细细研究了


本来我想比着这个轮子再造一个更清晰点的,把CharacterController类的调用再单独封装到一个类中,结果却发现在基类里调用CharacterController得不到,空指针,在面板上序列化才可以使用,但是每次都得开始游戏后在scene界面手动给它赋值,可能是因为我的对象是new出来的吧,不用new了也是不行,所以后来干脆放弃了(白琢磨几百行代码了T_T)。越来越感觉unity的c#跟平时用到的c#不能一样用,必定有些坑等着我们踩。。。

阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页