相机跟随_相机跟随人物移动 - CSDN
精华内容
参与话题
  • Unity相机跟随多种实现方式总结

    千次阅读 2020-06-01 21:27:15
    一:设置目标物为相机的父节点 描述:最简单,最基础,效果最不理想,锁死跟随视角 二:常规设置固定相对向量偏移 描述:推荐指数***,代码实现简,效果比较生硬 public Transform target; private ...

    欢迎加入Unity业内qq交流群:956187480

    qq扫描二维码加群


    一:设置目标物为相机的父节点

    描述:最简单,最基础,效果最不理想,锁死跟随视角

    二:常规设置固定相对向量偏移

    描述:推荐指数***,代码实现简,效果比较生硬

     

     public Transform target;
        private Vector3 offset;
        void Start()
        {
            //设置相对偏移
            offset = target.position - this.transform.position;
        }
        void Update()
        {
            //更新位置
            this.transform.position = target.position - offset;
        }

    三:添加旋转角度

    描述:推荐指数***,在二的基础上添加距离差值和旋转角度差值,效果流畅

    si

       private Vector3 offset;//相机相对于玩家的位置
        public Transform target;
        private Vector3 pos;
        public float speed = 2;
        private void Start()
        {
            offset =  transform.position - target.position;
        }
        // Update is called once per frame
        void Update()
        {
            pos = target.position + offset;
            this.transform.position = Vector3.Lerp(transform.position, pos, speed * Time.deltaTime);//调整相机与玩家之间的距离
    
            Quaternion angel = Quaternion.LookRotation(target.position - transform.position);//获取旋转角度
            transform.rotation = Quaternion.Slerp(transform.rotation, angel, speed * Time.deltaTime);
        }

     

    四: 第三背后视角

    描述:推荐指数*****,流畅参数可调。对相机的位置实时计算

     public Transform target;
        public float distanceUp = 10f;//相机与目标的竖直高度参数
        public float distanceAway = 10f;//相机与目标的水平距离参数
        public float smooth = 2f;//位置平滑移动插值参数值
        public float camDepthSmooth = 20f;
     
        void Update()
        {
            // 鼠标轴控制相机的远近
            if ((Input.mouseScrollDelta.y < 0 && Camera.main.fieldOfView >= 3) || Input.mouseScrollDelta.y > 0 && Camera.main.fieldOfView <= 80)
            {
                Camera.main.fieldOfView += Input.mouseScrollDelta.y * camDepthSmooth * Time.deltaTime;
            }
        }
    
        void LateUpdate()
        {
            //计算出相机的位置
            Vector3 disPos = target.position + Vector3.up * distanceUp - target.forward * distanceAway;
    
            transform.position = Vector3.Lerp(transform.position, disPos, Time.deltaTime * smooth);
            //相机的角度
            transform.LookAt(target.position);
        }

    五:自由 视角

    using UnityEngine;
    using System.Collections;
    using UnityEngine.EventSystems;
    
    public class target_control : MonoBehaviour {
    
        public Transform _target;
        public float distance = 50.0f;
        public float xSpeed = 250.0f;
        public float ySpeed = 120.0f;
    
        public int yMinLimit = -20;
        public int yMaxLimit = 80;
    
        private bool orbit = false;
        private bool pan = false;
        private bool zoom = false;
        private float zoomValue = 0;
    
        public float orbitDampX = 0.0f;
        public float orbitDampY = 0.0f;
        float panDampX = 0.0f;
        float panDampY = 0.0f;
        public float zoomDamp = 0.0f;
        public float dampingTime = 0.0f;
    
        public float x = 180.0f;
        public float y = 0.0f;
    
        public int planFactor = 5;
        public float zoomFactor = 2.0f;
        public Vector2 distLimit;
    
        public static Quaternion _rotation;
        public static Vector3 _position;
        public static target_control _target_control;
        public float _z_distance;
        private Vector3 angles;
    
        private Vector2 oldPosition1;   
        private Vector2 oldPosition2;
    
        public float _target_distance = 5;
    
        private float target_x;
        private float target_y;
        private Vector3 _target_pos = Vector3.zero;
     
        public bool change_distance() 
        {
            distance = Mathf.Lerp(distance, _target_distance, 0.04f);
            Debug.Log(distance + "/" + _target_distance);
            updateCamera();
            if (Mathf.Abs(distance - _target_distance) < 0.01f)
                return false;
            return true;
        }
        public bool change_distance(float _dis)
        {
            distance = Mathf.Lerp(distance, _dis, 0.004f);
            
            updateCamera();
            if (Mathf.Abs(distance - _dis) < 0.01f)
                return false;
            return true;
        }
    
    
        void Start()
        {
            _target_distance = distance;
            _z_distance = distance;
            angles = transform.eulerAngles;
            x = angles.y;
            y = angles.x;
    
            // Make the rigid body not change rotation
            if (GetComponent<Rigidbody>())
                GetComponent<Rigidbody>().freezeRotation = true;
        }
    	// Update is called once per frame
    	void LateUpdate () {
    
            if (EventSystem.current.IsPointerOverGameObject()||_target ==null)
            {
                return;
            }
    
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                if (Input.touchCount == 1)
                {
                    if (Input.GetTouch(0).phase == TouchPhase.Moved)
                    {
                        orbit = true;
                    }
                    else
                    {
                        orbit = false;
                    }
                }
                else
                {
                    orbit = false;
                }
    
                if (Input.touchCount > 1)
                {
                    if (Input.GetTouch(0).phase == TouchPhase.Moved || Input.GetTouch(1).phase == TouchPhase.Moved)
                    {
                        var tempPosition1 = Input.GetTouch(0).position;
                        var tempPosition2 = Input.GetTouch(1).position;
                        if (isEnlarge(oldPosition1, oldPosition2, tempPosition1, tempPosition2))
                        {
                            zoomValue = 0.1f;
                            zoom = true;
                        }
                        else
                        {
                            zoomValue = -0.1f;
                            zoom = true;
                        }
                        oldPosition1 = tempPosition1;
                        oldPosition2 = tempPosition2;
                    }
                    else
                    {
                        zoom = false;
                    }
                }
                else
                {
                    zoom = false;
                }
            } 
           else if (Application.platform == RuntimePlatform.Android)
            {
    
                if (Input.touchCount == 1)
                {
                    if (Input.GetTouch(0).phase == TouchPhase.Moved)
                    {
                        orbit = true;
                    }
                    else
                    {
                        orbit = false;
                    }
                }
                else
                {
                    orbit = false;
                }
    
                if (Input.touchCount > 1)
                {
                    if (Input.GetTouch(0).phase == TouchPhase.Moved || Input.GetTouch(1).phase == TouchPhase.Moved)
                    {
                        var tempPosition1 = Input.GetTouch(0).position;
                        var tempPosition2 = Input.GetTouch(1).position;
                        if (isEnlarge(oldPosition1, oldPosition2, tempPosition1, tempPosition2))
                        {
                            zoomValue = 0.1f;
                            zoom = true;
                        }
                        else
                        {
                            zoomValue = -0.1f;
                            zoom = true;
                        }
                        oldPosition1 = tempPosition1;
                        oldPosition2 = tempPosition2;
                    }
                    else
                    {
                        zoom = false;
                    }
                }
                else
                {
                    zoom = false;
                }
            }
            else
            {
                if (Input.GetMouseButton(1))
                {
                    orbit = true;
                }
                else
                {
                    orbit = false;
                }
    
                if (Input.GetAxisRaw("Mouse ScrollWheel") != null)
                {
                    zoomValue = Input.GetAxisRaw("Mouse ScrollWheel");
                    zoom = true;
                }
                else
                {
                    zoom = false;
                }
            }
    
    
                
            if (orbit)
            {
                
                orbitDampX = Mathf.Lerp(orbitDampX, Input.GetAxis("Mouse X"), dampingTime * Time.deltaTime);
                orbitDampY = Mathf.Lerp(orbitDampY, Input.GetAxis("Mouse Y"), dampingTime * Time.deltaTime);
            }
            else
            {
                orbitDampX = Mathf.Lerp(orbitDampX, 0, dampingTime * Time.deltaTime);
                orbitDampY = Mathf.Lerp(orbitDampY, 0, dampingTime * Time.deltaTime);
            }
     
            if (zoom)
            {
                zoomDamp = Mathf.Lerp(zoomDamp, zoomValue, dampingTime * Time.deltaTime);
            }
            else
            {
                zoomDamp = Mathf.Lerp(zoomDamp, 0, dampingTime * Time.deltaTime);
            }
    
            if (!checkLerp(orbitDampX, 0) || !checkLerp(orbitDampY, 0))
            {
                doOrbit();
            }
            if (!checkLerp(zoomDamp, 0))
            {
                doZoom();
            }
       
    
    	}
    
       
        bool isEnlarge(Vector2 oP1,Vector2 oP2 , Vector2 nP1, Vector2 nP2 )  
        {   
            var leng1 =Mathf.Sqrt((oP1.x-oP2.x)*(oP1.x-oP2.x)+(oP1.y-oP2.y)*(oP1.y-oP2.y));   
            var leng2 =Mathf.Sqrt((nP1.x-nP2.x)*(nP1.x-nP2.x)+(nP1.y-nP2.y)*(nP1.y-nP2.y));   
            if(leng1<leng2)   
            {   
                //big
                 return true;    
            }else   
            {   
                //small
                return false;    
            }   
        }
    
        bool checkLerp(float a,float b)
        {
            if (Mathf.Approximately(a, b))
            {
                return true;
            }
            return false;
        }
        void doOrbit()
        {
    	    if (_target) 
             {	 		
                 x += orbitDampX * xSpeed * 0.02f;
                 y -= orbitDampY * ySpeed * 0.02f;
    
     		    y = ClampAngle(y, yMinLimit, yMaxLimit);
    		    updateCamera();
            }
        }
        void doZoom()
        {
            distance -= zoomDamp * zoomFactor;
            distance = Mathf.Clamp(distance, -distLimit.x, distLimit.y);
            updateCamera();
        }
    
        void updateCamera()
        {
            var rotation = Quaternion.Euler(y, x, 0);
            var position = rotation * new Vector3(0.0f, 0.0f, -distance) + _target.position;
    
            transform.rotation = rotation;
            transform.position = position;
        }
    
        static float ClampAngle (float angle,float min,float max)
        {
            if (angle < -360)
                angle += 360;
            if (angle > 360)
                angle -= 360;
            return Mathf.Clamp(angle, min, max);
        }
    }
    

    欢迎加入Unity业内qq交流群:956187480

    qq扫描二维码加群

    展开全文
  • 相机跟随

    2018-08-13 15:12:54
    private Transform player;  private Vector3 offset;  private float smoothing = 3;  // Use this for initialization  void Start () {  player = GameObject.FindGameObjectWithTag("...

      private Transform player;
        private Vector3 offset;
        private float smoothing = 3;

        // Use this for initialization
        void Start () {
            player = GameObject.FindGameObjectWithTag("Player").transform;
            offset = transform.position - player.position;
        }
        
        // Update is called once per frame
        void LateUpdate () {
            Vector3 targetPosition = player.position + player.TransformDirection(offset);//将坐标差转换为局部坐标。可以使相机跟随着旋转
            transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime * smoothing);
            transform.LookAt(player.position);
        }

    展开全文
  • Unity知识总结系列(二):相机跟随人物的几种方式http://www.manew.com/thread-114711-1-1.html(出处: -【游戏蛮牛】-ar增强现实,虚拟现实,unity3d,unity3d教程下载首选u3d,unity3d官网)相机跟随一般写在生命周期...
    Unity知识总结系列(二):相机跟随人物的几种方式
    http://www.manew.com/thread-114711-1-1.html

    (出处: -【游戏蛮牛】-ar增强现实,虚拟现实,unity3d,unity3d教程下载首选u3d,unity3d官网)

    相机跟随一般写在生命周期LateUpdate

    1、最简单,无代码,固定距离,固定视角
    最简单的就是 直接 把主相机作为Player角色的子物体,并自行固定好相机的位置和角度
    优点:使用方便
    缺点:使用不灵活,相机转动死板,体验不好,相机瞬间移动位置
    2、代码控制,固定距离,固定视角,对1进行改进
    设置一个空的GameObject,并且与Player的旋转和位置保持一致,然后将 主相机 设置成该GameObject的子对象。这种做法和方案 相似。
    using UnityEngine;
    /// <summary>
    /// 创建一个空物体,
    /// 此空物体的位置信息始终与主角的位置信息保持一致,
    /// 主相机或主角相机给此空物体当子物体
    /// 当主角死亡时,空物体的位置信息更新为上一帧主角的位置信息
    /// </summary>
    public class CameraTest : MonoBehaviour{
        public Transform player;
        Vector3 tempPostion;
    Quaternion tempRotation;
        void Update(){
            if (player){
                transform.position = player.position;
                transform.rotation = player.rotation;
            }
            else{
                transform.position = tempPostion;
                transform.rotation = tempRotation;
            }
            tempPostion = player.position;
            tempRotation = player.rotation;
        }
    }
    (这种做法好处在于 当模拟角色死亡倒地的时候不会获取不到人物信息,如果采用方案 1 ,只能是重新创建一个相机,因为角色倒地的时候,子物体相机也会视角倒地,所以效率肯定方案 高)
    优点:使用方便,适合大部分游戏模式
    缺点:使用不灵活,相机转动死板(强制位移),体验不好
    3、代码控制,固定距离,固定视角,直接移动,不会旋转
    使用代码获取到一个相机的初始位置与人物之间的差值向量,在给相机赋值时再用这个差值向量与人物坐标求出相机的实时位置

    using UnityEngine;
    public class CameraTest2 : MonoBehaviour{
        public Transform player;
    Vector3 distance;
        void Start(){
            distance = transform.position - player.position;
        }
        void LateUpdate(){
            transform.position = player.position + distance;
        }
    }
    优点:简单,方便,
    缺点:无法一直跟随角色身后,适合固定视角游戏
    4、代码控制,固定距离,固定视角,插值移动(因为UpdateLateUpdate刷新率不同,会有抖动现象)
    using UnityEngine;
    public class CameraTest2 : MonoBehaviour{
        public Transform player;
        Vector3 distance;
        public float speed;
        void Start(){
            distance = transform.position - player.position;
        }
        void LateUpdate(){
            transform.position = Vector3.Lerp(transform.position, player.position + distance, Time.deltaTime * speed);
        }
    }
    不建议使用
    5、代码控制,固定距离,固定视角,平滑阻尼移动
    using UnityEngine;
    public class CameraTest2 : MonoBehaviour{
        public Transform player;
        Vector3 distance;
        public float speed;
    Vector3 ve;
        void Start(){
            distance = transform.position - player.position;
        }
        void LateUpdate(){
            transform.position = Vector3.SmoothDamp(transform.position, player.position + distance, ref ve, 0);
        }
    }
    代码实现相机跟随物体,可使用一个接口函数Vector3.SmoothDamp() 平滑阻尼 。 
    函数介绍:随着时间的推移,逐渐改变一个向量朝向预期的目标(有点类似受阻力减速运动) 在官方的手册里也有推荐用此函数 来实现 平滑的相机跟随
    public static Vector3 SmoothDamp(
    Vector3 current, //当前物体位置
    Vector3 target, //目标位置
    ref Vector3 currentVelocity, //当前速度,这个值由你每次调用这个函数时被修改
    //虽然使用ref关键字,不过函数运行时会自动修改
    //一般传入参数值为0
    float smoothTime, //到达目标的大约时间,较小的值将快速到达目标
    float maxSpeed = Mathf.Infinity,//选择允许你限制的最大速度(默认为正无穷)
    float deltaTime = Time.deltaTime//自上次调用这个函数的时间(默认为Time.deltaTime) );
    6、代码控制,固定距离,跟随主角视角,平滑阻尼移动,看向主角
    要使相机始终跟随主角身后,就要始终更新相机的位置在主角的Y轴后面,于是手动设置设置相机相对于主角的距离
    using UnityEngine;
    public class CameraTest2 : MonoBehaviour{
        public Transform player;    //角色位置信息
        Vector3 off;                //相机目标点位置信息
        Vector3 ve;                 //平滑阻尼的返回值
        Quaternion angel;           //相机看向目标的旋转值
        public float hight;         //相机的高度
    public float foward;        //相机在角色后的距离
        void LateUpdate(){
            off = player.position + hight * player.up - foward * player.forward;
            transform.position = Vector3.SmoothDamp(transform.position, off, ref ve, 0);
            transform.LookAt(player.position);
        }
    }
    这样的注视,相机移动还是太快
    7、代码控制,固定距离,平滑的旋转相机,平滑阻尼移动,看向主角
    using UnityEngine;
    public class CameraTest2 : MonoBehaviour{
        public Transform player;    //角色位置信息
        Vector3 off;                //相机目标点位置信息
        public float speed;         //相机移动速度
        Vector3 ve;                 //平滑阻尼的返回值
        Quaternion angel;           //相机看向目标的旋转值
        public float hight;         //相机的高度
        public float foward;        //相机在角色后的距离
        void LateUpdate(){
            off = player.position + hight * player.up - foward * player.forward;
            transform.position = Vector3.SmoothDamp(transform.position, off, ref ve, 0);
    //看向向量指向的方向
            angel = Quaternion.LookRotation(player.position - off);
            transform.rotation = Quaternion.Slerp(transform.rotation, angel, Time.deltaTime * speed);
        }
    }
    8、代码控制,固定距离,平滑的旋转相机,平滑阻尼移动,看向主角,有物体遮挡(方法一)
    using UnityEngine;
    /// <summary>
    /// 相机进行射线检测,如果检测不到主角,
    /// 就在起始点与结束点主角头顶的一个点之间寻找几个点,
    /// 直到找到可以看到主角的点
    /// </summary>
    public class CameraTest2 : MonoBehaviour
    {
        public Transform player;    //角色位置信息
        Vector3[] v3;        //相机自动找寻的位置点
        public int num;             //相机临时点的个数
        public Vector3 start;       //相机开始时的位置
        public Vector3 end;         //相机没有找到主角时的位置
        Vector3 tagetPostion;       //相机看向的目标点
        Vector3 ve3;                //平滑阻尼的ref参数
        Quaternion angel;           //相机看向目标的旋转值
        public float speed;         //相机移动速度
        void Start()
        {
            //外界赋值数组长度
            v3 = new Vector3[num];
        }
        void LateUpdate()
        {
            //记录相机初始位置
            start = player.position + player.up * 2.0f - player.forward * 3.0f;
            //记录相机最终位置
            end = player.position + player.up * 5.0f;
            //相机目标位置,开始等于初始位置
            tagetPostion = start;
            v3[0] = start;
            v3[num - 1] = end;
            //动态获取相机的几个点
            for (int i = 1; i < num; i++)
            {
                v3[i] = Vector3.Lerp(start, end, i / num);
            }
            //判断相机在那个点可以看到主角
            for (int i = 0; i < num; i++)
            {
                if (Function(v3[i]))
                {
                    tagetPostion = v3[i];
                    break;
                }
                if (i == num - 1)
                {
                    tagetPostion = end;
                }
            }
            //主角的移动和看向
            transform.position = Vector3.SmoothDamp(transform.position, tagetPostion, ref ve3, 0);
            angel = Quaternion.LookRotation(player.position - tagetPostion);
            transform.rotation = Quaternion.Slerp(transform.rotation, angel, speed);
        }
        /// <summary>
        /// 射线检测,相机是否能照到主角
        /// </summary>
        /// <param name="v3">计算射线发射的方向</param>
        /// <returns>是否检测到</returns>
        bool Function(Vector3 v3)
        {
            RaycastHit hit;
            if (Physics.Raycast(v3, player.position - v3, out hit))
            {
                if (hit.collider.tag == "Player")
                {
                    return true;
                }
            }
            return false;
        }
    }
    9、代码控制,固定距离,平滑的旋转相机,平滑阻尼移动,看向主角,有物体遮挡(方法二)
    using UnityEngine;
    /// <summary>
    /// 从主角发射射线检测相机的位置
    /// 检测不到,就把相机移动到,射线的碰撞点的前面
    /// </summary>
    public class CameraTest2 : MonoBehaviour
    {
        public Transform player;            //角色头部(设置空物体)位置信息
        private Vector3 tagetPostion;       //相机看向的目标点
        private Vector3 ve3;                //平滑阻尼的ref参数
        Quaternion angel;                   //相机看向目标的旋转值
        public float speed;                 //相机移动速度
        public float upFloat;               //Y轴上升距离
        public float backFloat;             //Z轴与主角的距离
        void LateUpdate()
        {
            //记录相机初始位置
            tagetPostion = player.position + player.up * upFloat - player.forward * backFloat;
            [size=12.6667px]//刷新相机目标点的坐标
            tagetPostion = Function(tagetPostion);
            //主角的移动和看向
            transform.position = Vector3.SmoothDamp(transform.position, tagetPostion, ref ve3, 0);
            angel = Quaternion.LookRotation(player.position - tagetPostion);
            transform.rotation = Quaternion.Slerp(transform.rotation, angel, speed);
        }
        /// <summary>
        /// 射线检测,主角向后检测是否有相机跟随
        /// </summary>
        /// <param name="v3">用来计算射线发射的方向</param>
        /// <returns>是否检测到</returns>
        Vector3 Function(Vector3 v3)
        {
            RaycastHit hit;
            if (Physics.Raycast(player.position, v3 - player.position, out hit, 5.0f))
            {
                if (hit.collider.tag != "MainCamera")
                {
                    v3 = hit.point + transform.forward * 0.5f;
                }
            }
            return v3;
        }
    }
    10、代码控制,固定距离,平滑的旋转相机,平滑阻尼移动,看向主角,有物体遮挡,结合手游中相机的旋转和复位
    using UnityEngine;
    /// <summary>
    /// 相机进行射线检测,如果检测不到主角,
    /// 就在起始点与结束点之间寻找几个点,
    /// 直到找到可以看到主角的点
    /// 在游戏中玩家可以用鼠标控制相机的旋转
    /// </summary>
    public class CameraTest2 : MonoBehaviour
    {
        public Transform player;    //角色位置信息
        Vector3[] v3;        //相机自动找寻的位置点
        public int num;             //相机临时点的个数
        public Vector3 start;       //相机开始时的位置
        public Vector3 end;         //相机没有找到主角时的位置
        Vector3 tagetPostion;       //相机看向的目标点
        Vector3 ve3;                //平滑阻尼的ref参数
        Quaternion angel;           //相机看向目标的旋转值
        public float speed;         //相机移动速度
        void Start()
        {
            //外界赋值数组长度
            v3 = new Vector3[num];
        }
        void LateUpdate()
        {
            //记录相机初始位置
            start = player.position + player.up * 2.0f - player.forward * 3.0f;
            //记录相机最终位置
            end = player.position + player.up * 5.0f;
            //鼠标控制相机的旋转
            if (Input.GetMouseButton(1))
            {
                //记录相机的初始位置和旋转角度
                Vector3 pos = transform.position;
                Vector3 rot = transform.eulerAngles;
                //让相机绕着指定轴向旋转
                transform.RotateAround(transform.position, Vector3.up, Input.GetAxis("Mouse X") * 10);
                transform.RotateAround(transform.position, Vector3.left, -Input.GetAxis("Mouse Y") * 10);
                //限制相机的绕X旋转的角度
                if (transform.eulerAngles.x < -60 || transform.eulerAngles.x > 60)
                {
                    transform.position = pos;
                    transform.eulerAngles = rot;
                }
                return;
            }
            //相机目标位置,开始等于初始位置
            tagetPostion = start;
            v3[0] = start;
            v3[num - 1] = end;
            //动态获取相机的几个点
            for (int i = 1; i < num; i++)
            {
                v3[i] = Vector3.Lerp(start, end, i / num);
            }
            //判断相机在那个点可以看到主角
            for (int i = 0; i < num; i++)
            {
                if (Function(v3[i]))
                {
                    tagetPostion = v3[i];
                    break;
                }
                if (i == num - 1)
                {
                    tagetPostion = end;
                }
            }
            //主角的移动和看向
            transform.position = Vector3.SmoothDamp(transform.position, tagetPostion, ref ve3, 0);
            angel = Quaternion.LookRotation(player.position - tagetPostion);
            transform.rotation = Quaternion.Slerp(transform.rotation, angel, speed);
        }
        /// <summary>
        /// 射线检测,相机是否能照到主角
        /// </summary>
        /// <param name="v3">计算射线发射的方向</param>
        /// <returns>是否检测到</returns>
        bool Function(Vector3 v3)
        {
            RaycastHit hit;
            if (Physics.Raycast(v3, player.position - v3, out hit))
            {
                if (hit.collider.tag == "Player")
                {
                    return true;
                }
            }
            return false;
        }
    }

    展开全文
  • 相机跟随(一)

    2019-05-22 11:08:00
    相机总是在角色背后distanceAway距离处,且在角色头顶上方distanceUp的高度上 public Transform player; public float distanceUp = 2f; public float distanceAway = 5f; public float smooth = 1f; ...

    相机总是在角色背后distanceAway距离处,且在角色头顶上方distanceUp的高度上

      public Transform player;
        public float distanceUp = 2f;
        public float distanceAway = 5f;
        public float smooth = 1f;
        private Vector3 targetPos;
    
        void Awake()
        {
            player = GameObject.FindGameObjectWithTag("Player").transform;
        }
    
        void LateUpdate()
        {
            targetPos = player.position + distanceUp * Vector3.up - player.forward * distanceAway;
            transform.position = Vector3.Lerp(transform.position, targetPos, Time.deltaTime * 5f);
            transform.LookAt(player);
        }

     

    展开全文
  • 相机跟随(基础)

    2018-11-15 14:21:39
    固定相机跟随 这种相机有一个参考对象,它会保持与该参考对象固定的位置,跟随改参考对象发生移动 using UnityEngine; using System.Collections; public class CameraFlow : MonoBehaviour {  public Transform...
  • 二、固定相机跟随,这种相机有一个参考对象,它会保持与该参考对象固定的位置,跟随改参考对象发生移动 优点:简单,方便 缺点:无法一直跟随角色身后,适合固定视角游戏 using UnityEngine; using System....
  • unity 常用的几种相机跟随

    万次阅读 多人点赞 2016-06-01 11:37:50
    固定相机跟随这种相机有一个参考对象,它会保持与该参考对象固定的位置,跟随改参考对象发生移动using UnityEngine; using System.Collections;public class CameraFlow : MonoBehaviour { public Transform target...
  • Unity2D游戏开发——相机跟随主角

    千次阅读 2019-11-14 16:27:25
    public class CamaraFollow: MonoBehaviour { public GameObject player;... //相机跟随速度 public float minPosx; //相机不超过背景边界允许的最小值 public float maxPosx; //相机不超过背景边界允许...
  • Unity3d 实现相机跟随物体

    千次阅读 2018-07-08 20:43:02
    添加一个Cube添加一个Shpere设置为刚体编写脚本 Camera 附加在相机上 using System.Collections; using System.Collections.Generic; using UnityEngine; public class Camera : MonoBehaviour { public ...
  • Unity3D-相机跟随抖动

    千次阅读 2016-10-27 11:02:53
    在U3D中当物体移动和相机跟随的刷新频率不同时,常常会出现物体抖动的问题。 解决这个问题的最好方法是把相机刷新放在LaterUpdate中,能很好解决物体抖动的问题。 但是如果相机在跟随物体一时,画面同时还有...
  • 1)创建一个摄像机 Camera影响的节点是game节点...2)将要跟随的物体,即hero的坐标转化为相机的坐标,注意:只想跟随x轴 cc.Class({ extends: cc.Component, properties: { target: { default: null, ...
  • 实例代码如下: using System.Collections; using System.Collections.Generic;...//相机视角跟踪 public class FollowTarget : MonoBehaviour { //游戏人物 的位置 private Transform player; //游戏人物...
  • Unity 2D游戏相机跟随

    千次阅读 2017-04-27 19:04:24
    Unity版本为5.3.2这篇文章主要是实现一下2d游戏中相机跟随首先随便创建一个2d游戏场景,然后创建一个空物体,在空物体上加上一个boxcollider2d,调整大小,使它的范围包住背景(不是包住相机),也就是图中的边框上...
  • 最简单的就是 直接 把主相机作为Player角色的子物体,并自行固定好相机的位置 方案2: 设置一个空的GameObject,并且与Player的旋转和位置保持一致,然后将 主相机 设置成该GameObject的子对象。
  • unity3d 简单的相机跟随目标

    千次阅读 2016-09-21 14:45:13
    将该脚本挂在要跟随的camera上 将要被跟随的目标设为target,就可以实现了 using UnityEngine; using System.Collections; public class FollowTaget : MonoBehaviour { public Transform target;//目标 ...
  • Unity3D中摄像机跟随方法

    万次阅读 多人点赞 2017-02-14 14:21:53
    1.第一种方法 ...// 功能:相机跟随人物 // 注意:相机只能跟随人物移动,但是如果人物转向或者做某些动作,摄像机并不跟随 using UnityEngine; using System.Collections; public class CameraSha
  • unity 摄像机(Camera)跟随物体移动

    千次阅读 2019-10-15 15:41:50
    using System.Collections; using System.Collections.Generic; using UnityEngine; public class CameraFollow : MonoBehaviour { public Transform playerTransform;... public Vector3 deviatio...
  • 相机跟随主角移动,并带有延迟效果using UnityEngine; using System.Collections;namespace CompleteProject { // 脚本使用在摄像机身上 public class CameraFollow : MonoBehaviour { public Transform player;...
  • Unity相机视野的缩放,旋转及跟随

    千次阅读 2017-04-02 11:00:43
    首先声明,博主使用的是Unity5.3.2(64)游戏开发中,经常会遇到相机视野的拉近,拉远以及旋转,跟随的问题,这里我们只搞一种方式直接上代码:using UnityEngine; using System.Collections;public class FollowPlayer...
  • 相机跟随物体移动,抖动的问题

    千次阅读 2018-02-03 13:16:26
    Question: 角色移动用FixedUpdate 相机跟随用Update,相机会在跟随主角的过程中抖动,为何? //相机跟随 m_target为跟随的目标 private void Update() { Vector3 targetPos = m_target.position + m_offset; ...
1 2 3 4 5 ... 20
收藏数 5,997
精华内容 2,398
关键字:

相机跟随