Unity人物摄像机跟随简单实现

使用了 Mathf.SmoothDamp() 函数，来实现摄像机的平滑过度。

转载请注明出处：https://www.cnblogs.com/jietian331/p/12626530.html

代码如下。

版本一：

using System;
using UnityEngine;
using UnityEngine.EventSystems;

class PlayerCamera : MonoBehaviour
{
    const float
        MouseSmoothingFactor = 0.1f,
        MaxDistance = 16,
        MinDistance = 1f,
        MinAngleY = -30f,
        MaxAngleY = 60f;

    [SerializeField]
    Transform m_target;
    [SerializeField]
    float m_distance;
    [SerializeField]
    float m_offsetY;

    Camera m_camera;
    float m_mouseX;
    float m_mouseY = 30;
    float m_mouseXSmooth;
    float m_mouseYSmooth;


    #region singleton

    static PlayerCamera s_instance;
    public static PlayerCamera Singleton
    {
        get
        {
            if (s_instance == null)
            {
                var asset = Resources.Load<PlayerCamera>("Prefabs/Game/PlayerCamera");
                s_instance = GameObject.Instantiate(asset);
            }
            return s_instance;
        }
    }

    #endregion


    #region Property

    float Distance
    {
        get { return m_distance; }
        set { m_distance = Mathf.Clamp(value, MinDistance, MaxDistance); }
    }

    public Camera Camera
    {
        get { return m_camera; }
    }

    public static bool ClickedUI
    {
        get { return GUIUtility.hotControl != 0 || (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject()); }
    }

    public bool Active
    {
        set { gameObject.SetActive(value); }
    }

    #endregion


    static float ClampAngle(float angle, float min, float max)
    {
        while (angle < -360 || angle > 360)
        {
            if (angle < -360)
                angle += 360;
            if (angle > 360)
                angle -= 360;
        }

        return Mathf.Clamp(angle, min, max);
    }


    void Start()
    {
        DontDestroyOnLoad(gameObject);

        // camera
        m_camera = GetComponent<Camera>();

        // setting
        Distance = GameConfig.Instance.CameraDefaltDistance;
    }


    public void SetTarget(Transform target, float height)
    {
        if (target == null)
            throw new ArgumentNullException("target");

        m_target = target;
        m_offsetY = height * 0.8f;
    }

    Vector3 GetSmoothDir()
    {
        if (Input.GetKey(KeyCode.Mouse1))
        {
            float mouseXAxis = Input.GetAxis("Mouse X");
            float mouseYAxis = Input.GetAxis("Mouse Y");
            m_mouseX += mouseXAxis * 6;
            m_mouseY -= mouseYAxis * 4;
        }
        else
        {
            bool left = Input.GetKey(KeyCode.Q);
            bool right = Input.GetKey(KeyCode.E);
            bool downward = Input.GetKey(KeyCode.Z);
            bool upward = Input.GetKey(KeyCode.C);
            bool reset = Input.GetKey(KeyCode.X);

            if (left || right)
            {
                float eulerY = left ? -2 : 2;
                m_mouseX += eulerY;
            }
            else if (downward || upward)
            {
                float offsetY = downward ? 2f : -2f;
                m_mouseY -= offsetY;
            }
            else if (reset)
            {
                m_mouseX = 0;
                m_mouseY = 30;
            }
        }

        float currentVelX = 0, currentVelY = 0;
        m_mouseXSmooth = Mathf.SmoothDamp(m_mouseXSmooth, m_mouseX, ref currentVelX, MouseSmoothingFactor);
        m_mouseY = ClampAngle(m_mouseY, MinAngleY, MaxAngleY);
        m_mouseYSmooth = Mathf.SmoothDamp(m_mouseYSmooth, m_mouseY, ref currentVelY, MouseSmoothingFactor);
        m_mouseYSmooth = ClampAngle(m_mouseYSmooth, MinAngleY, MaxAngleY);

        // Distance
        float scrollWheel = Input.GetAxis("Mouse ScrollWheel") * 3;
        if (scrollWheel != 0)
            Distance -= scrollWheel;

        Vector3 offset = new Vector3(0, 0, Distance);
        Quaternion rotation = Quaternion.Euler(m_mouseYSmooth, m_mouseXSmooth, 0);
        return rotation * offset;
    }

    //  A follow camera should always be implemented in LateUpdate because it tracks objects that might have moved inside Update
    void LateUpdate()
    {
        if (!m_target)
            return;

        Vector3 dir = GetSmoothDir();
        ResetCamera(dir);
    }

    void ResetCamera(Vector3 forward)
    {
        Vector3 center = m_target.position + new Vector3(0, m_offsetY);

        // 摄像机不会被物体遮住，用射线检测
        RaycastHit hit;
        Ray ray = new Ray(center, -forward);
        int groundMask = StaticLayers.Ground.GetLayerMask();
        bool raycast = Physics.Raycast(ray, out hit, Distance, groundMask);
        Vector3 pos;
        if (raycast)
            pos = hit.point + forward * 0.05f;
        else
            pos = center - forward;

        transform.position = pos;
        transform.LookAt(center);
    }
}

 版本二（支持手机上的操作）：

using ClientData;
using Common;
using Common.Messenger;
using Modules.UI;
using UnityEngine;
using UnityEngine.AI;

public class CameraOperationController : MonoBehaviour
{
    public static float
    MouseSmoothingFactor = 0.1f,
    MaxDistance = 16,
    MinDistance = 1f,
    DefaultDistance = 4f,
    MinAngleY = -30f,
    MaxAngleY = 60f,
    ScaleSpeed = 10f,
    DragSpeed = 0.15f;

    static Camera s_camera;
    public static bool CanUsed = true;


    [SerializeField]
    GameObject m_targetGo;
    [SerializeField]
    float m_distance;
    [SerializeField]
    float m_offsetY;
    [SerializeField]
    float m_mouseX;
    [SerializeField]
    float m_mouseY;

    float m_mouseXSmooth;
    float m_mouseYSmooth;

    //摄像机的初始状态
    Vector3 m_originalPos;
    Vector3 m_originalAngle;
    float m_originalView;
    GameObject m_originTarget;

    //手机相关
    Vector2? m_oldTouch0;
    Vector2? m_oldTouch1;

    bool m_isDiplayUI = true;
    bool m_toAdjustDistance = false;


    public static Camera MainCamera
    {
        get
        {
            if (!s_camera)
            {
                GameObject obj = GameObject.Find("DanceRoot/Main Camera");
                if (obj)
                {
                    s_camera = obj.GetComponent<Camera>();
                }
            }
            return s_camera;
        }
    }

    float Distance
    {
        get { return m_distance; }
        set { m_distance = Mathf.Clamp(value, MinDistance, MaxDistance); }
    }

    float MouseX
    {
        get { return m_mouseX; }
        set { m_mouseX = value; }
    }

    float MouseY
    {
        get { return m_mouseY; }
        set
        {
            m_mouseY = ClampAngle(value, MinAngleY, MaxAngleY);
        }
    }


    static float ClampAngle(float angle, float min, float max)
    {
        while (angle < -360 || angle > 360)
        {
            if (angle < -360)
                angle += 360;
            if (angle > 360)
                angle -= 360;
        }

        return Mathf.Clamp(angle, min, max);
    }


    //  A follow camera should always be implemented in LateUpdate because it tracks objects that might have moved inside Update
    void LateUpdate()
    {
        if (CanUsed && m_targetGo)
        {
            ResetCamera();
        }
    }

    void ResetCamera()
    {
        // get smooth dir
        float currentVelX = 0, currentVelY = 0;
        m_mouseXSmooth = Mathf.SmoothDamp(m_mouseXSmooth, MouseX, ref currentVelX, MouseSmoothingFactor);
        m_mouseYSmooth = Mathf.SmoothDamp(m_mouseYSmooth, MouseY, ref currentVelY, MouseSmoothingFactor);
        Quaternion rotation = Quaternion.Euler(m_mouseYSmooth, m_mouseXSmooth, 0);
        Vector3 dir = new Vector3(0, 0, -Distance);
        dir = rotation * dir;

        Vector3 center = m_targetGo.transform.position + new Vector3(0, m_offsetY);

        // 摄像机不会被物体遮住，用射线检测
        RaycastHit hit;
        Ray ray = new Ray(center, dir);
        int mask = 1 << (int)CameraLayer.Default | 1 << (int)CameraLayer.Obstacles | 1 << (int)CameraLayer.Ground;
        bool raycast = Physics.Raycast(ray, out hit, Distance, mask);
        Vector3 pos;
        if (raycast)
        {
            pos = hit.point - dir * 0.05f;
        }
        else
        {
            pos = center + dir;
        }

        MainCamera.transform.position = pos;
        MainCamera.transform.LookAt(center);

#if UNITY_EDITOR
        Debug.DrawLine(m_targetGo.transform.position, center, Color.green);
        Debug.DrawLine(center, pos, Color.green);
#endif
    }

    void OnDrag(Vector2 delta)
    {
        if (!m_toAdjustDistance)
        {
            MouseX += delta.x * DragSpeed;
            MouseY -= delta.y * DragSpeed * 2f / 3f;
        }
    }

    void Update()
    {
        if (!CanUsed)
        {
            return;
        }

#if UNITY_EDITOR
        if (Application.platform == RuntimePlatform.WindowsEditor || Application.platform == RuntimePlatform.WindowsPlayer)
        {
            float scrollWheel = Input.GetAxis("Mouse ScrollWheel");
            if (scrollWheel != 0)
            {
                Distance -= scrollWheel * 3;
            }
        }
#endif

        if (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer)
        {
            m_toAdjustDistance = Input.touchCount > 1 && !JoyStick.isUsingJoyStick;
            if (m_toAdjustDistance)
            {
                var touch0 = Input.GetTouch(0);
                var touch1 = Input.GetTouch(1);
                if (touch0.phase == TouchPhase.Moved || touch1.phase == TouchPhase.Moved)
                {
                    Vector3 pos0 = touch0.position;
                    Vector3 pos1 = touch1.position;
                    float speed = ScaleSpeed * Time.deltaTime;

                    if (m_oldTouch0.HasValue && m_oldTouch1.HasValue)
                    {
                        if (IsEnlarge(m_oldTouch0.Value, m_oldTouch1.Value, pos0, pos1))
                        {
                            Distance -= speed;
                        }
                        else
                        {
                            Distance += speed;
                        }
                    }

                    m_oldTouch0 = pos0;
                    m_oldTouch1 = pos1;
                }
            }
            else
            {
                m_oldTouch0 = null;
                m_oldTouch1 = null;
            }
        }

    }

    // 是否是放大
    bool IsEnlarge(Vector3 oldP1, Vector3 oldP2, Vector3 newP1, Vector3 newP2)
    {
        float oldXDis = oldP1.x - oldP2.x;
        float oldYDis = oldP1.y - oldP2.y;
        float newXDis = newP1.x - newP2.x;
        float newYDis = newP1.y - newP2.y;
        float oldV = oldXDis * oldXDis + oldYDis * oldYDis;
        float newV = newXDis * newXDis + newYDis * newYDis;
        return oldV < newV;
    }

    void OnChangeCameraState(bool isOpen, GameObject target, float showDistance)
    {
        if (isOpen && target)
        {
            m_targetGo = target;
            Distance = showDistance;
        }
        else
        {
            m_targetGo = m_originTarget;
            DefaultCamera();
        }
    }


    void DefaultCamera()
    {
        Distance = DefaultDistance;
        MouseX = 0;
        MouseY = 0;

        var agent = m_targetGo.GetComponent<NavMeshAgent>();
        if (agent)
        {
            m_offsetY = agent.height * 0.9f;
        }
        else
        {
            m_offsetY = 1.6f;
        }
    }

    void Awake()
    {
        Messenger.AddListener(MessengerEventDef.RecardCamState, RecardCamState);
        Messenger.AddListener(MessengerEventDef.ResetCamState, ResetCamState);
        Messenger<bool>.AddListener(MessengerEventDef.ChangeFollowTargetBone, FollowTargetBone);
        Messenger<bool>.AddListener(MessengerEventDef.OnChangeUIDisplayState, OnChangeUIDisplayState);
        Messenger<bool, GameObject, float>.AddListener(MessengerEventDef.ChangeRoomCameraState, OnChangeCameraState);

        m_originalPos = MainCamera.transform.position;
        m_originalAngle = MainCamera.transform.eulerAngles;
        m_originalView = MainCamera.fieldOfView;
        MainCamera.fieldOfView = 30;
        m_targetGo = AppInterface.RoomModule.RoomPlayer.player.gameObject;
        m_originTarget = m_targetGo;

        /*
        RoomBase currRoom = AppInterface.RoomModule.GetRoom();
        m_x = currRoom.EModel == eRoomModel.Waite || currRoom.EModel == eRoomModel.SpiritCity ? 540 : 0;
        m_y = currRoom.EModel == eRoomModel.Waite || currRoom.EModel == eRoomModel.SpiritCity ? -3 : 0;  //-22.5

        if (currRoom.EModel == eRoomModel.DanceGroup)
        {
            m_x = -136;
            m_y = -3.0f;
            m_z = -7;
        }
        else if (currRoom.EModel == eRoomModel.Waite || currRoom.EModel == eRoomModel.MarryRoom || currRoom.EModel == eRoomModel.IdolNoticeRoom || currRoom.EModel == eRoomModel.IdolPlayoffRoom)
        {
            m_x = ClientRoom.cam_X;
            m_y = ClientRoom.cam_Y;
            m_z = ClientRoom.cam_Z;
        }
        else //if (currRoom.EModel == eRoomModel.SpiritCity || currRoom.EModel == eRoomModel.Guide_SpiritCity)
        {
            m_x = 540;
            m_y = -3.0f;
            m_z = -7;
        }*/

        DefaultCamera();
    }

    void FollowTargetBone(bool isFollow)
    {
        var player = AppInterface.RoomModule.RoomPlayer.player;
        m_targetGo = isFollow ? player.Bip001.gameObject : player.gameObject;
    }

    void OnClick()
    {
        if (!m_isDiplayUI)
        {
            Messenger<bool>.Broadcast(MessengerEventDef.OnChangeUIDisplayState, true);
        }
        else
        {
            Vector3 mousePos = Input.mousePosition;
            Ray ray = MainCamera.ScreenPointToRay(mousePos);
            Messenger<Ray>.Broadcast(MessengerEventDef.RoomOnClickRay, ray);
        }
    }

    void RecardCamState()
    {
        //ClientRoom.cam_X = m_x;
        //ClientRoom.cam_Y = m_y;
        //ClientRoom.cam_Z = m_z;
    }

    void ResetCamState()
    {
        ClientRoom.cam_X = 540.0f;
        ClientRoom.cam_Y = -3.0f;
        ClientRoom.cam_Z = -7.0f;
    }

    void OnDestroy()
    {
        Messenger.RemoveListener(MessengerEventDef.RecardCamState, RecardCamState);
        Messenger.RemoveListener(MessengerEventDef.ResetCamState, ResetCamState);
        Messenger<bool>.RemoveListener(MessengerEventDef.ChangeFollowTargetBone, FollowTargetBone);
        Messenger<bool>.RemoveListener(MessengerEventDef.OnChangeUIDisplayState, OnChangeUIDisplayState);
        Messenger<bool, GameObject, float>.RemoveListener(MessengerEventDef.ChangeRoomCameraState, OnChangeCameraState);

        if (MainCamera)
        {
            MainCamera.transform.position = m_originalPos;
            MainCamera.transform.eulerAngles = m_originalAngle;
            MainCamera.fieldOfView = m_originalView;
        }

        if (!m_isDiplayUI)
        {
            Messenger<bool>.Broadcast(MessengerEventDef.OnChangeUIDisplayState, true);
        }
    }

    void OnChangeUIDisplayState(bool isDisplay)
    {
        m_isDiplayUI = isDisplay;
    }
}

效果图：