unity3d 设置相机跟随_unity3d 相机跟随 - CSDN
  • 在设计第一人称射击游戏以及RPG游戏时,往往需要在主角身上或者近邻位置设置一个摄像机,使其能够跟随主角的移动,提升游戏体验,这里介绍三种实现摄像机跟随的方法。 (一)固定摄像机方法,常用于RPG游戏第一种...

           在设计第一人称射击游戏以及RPG游戏时,往往需要在主角身上或者近邻位置设置一个摄像机,使其能够跟随主角的移动,提升游戏体验,这里介绍三种实现摄像机跟随的方法。

           (一)固定摄像机方法,常用于RPG游戏

    第一种方法,在Unity的坐标系中,我将摄像机固定在主角头部上边靠后位置,这样,主角在移动过程中,摄像机也随着移动,最后在游戏场景中大概是这个样子:

            也就是说,摄像机相对于主角,总是在Vector3.forward方向上靠后一些,在Vector3.up方向上偏上一些。同时为了使摄像机的移动更加平滑,避免掉帧现象,引入差值函数Vector3.Lerp(),使摄像机的移动更加圆润。

             相关代码如下:

    using UnityEngine;
    using System.Collections;
    
    /// <summary>
    /// Third person camera.
    /// </summary>
    public class TheThirdPersonCamera : MonoBehaviour
    {
    	public float distanceAway=1.7f;			
    	public float distanceUp=1.3f;			
    	public float smooth=2f;				// how smooth the camera movement is
    		
    	private Vector3 m_TargetPosition;		// the position the camera is trying to be in)
    	
    	Transform follow;        //the position of Player
    	
    	void Start(){
    		follow = GameObject.FindWithTag ("Player").transform;	
    	}
    	
    	void LateUpdate ()
    	{
    		// setting the target position to be the correct offset from the 
    		m_TargetPosition = follow.position + Vector3.up * distanceUp - follow.forward * distanceAway;
    		
    		// making a smooth transition between it's current position and the position it wants to be in
    		transform.position = Vector3.Lerp(transform.position, m_TargetPosition, Time.deltaTime * smooth);
    		
    		// make sure the camera is looking the right way!
    		transform.LookAt(follow);
    	}
    }
    

         (二)摄像机替代主角方法,常用于第一人称射击

           如图所示,直接用摄像机替代主角视角,摄像机看到的便是玩家在游戏场景中看到的。首先在Hierachy视图中建立空物体作为Player,使其旋转方向与摄像机保持一致。

            相关代码如下:

    // 摄像机Transform
        Transform m_camTransform;
    
        // 摄像机旋转角度
        Vector3 m_camRot;
    
        // 摄像机高度(即表示主角的身高)
        float m_camHeight = 1.4f;
     void Start () {
    
            m_transform = this.transform;
            
             
            // 获取摄像机
            m_camTransform = Camera.main.transform;
    
            // 设置摄像机初始位置
            m_camTransform.position = m_transform.TransformPoint(0, m_camHeight, 0);    //摄像机初始位置从本地坐标转化成世界坐标,且在X-Z平面的初始位置
    
            // 设置摄像机的旋转方向与主角一致
            m_camTransform.rotation = m_transform.rotation;  //rotation为物体在世界坐标中的旋转角度,用Quaternion赋值
            m_camRot = m_camTransform.eulerAngles;    //在本游戏实例中用欧拉角表示旋转
            }
    Quaternion赋值
            m_camRot = m_camTransform.eulerAngles;    //在本游戏实例中用欧拉角表示旋转
            }
    

     

    void Control()
        {
    
            //获取鼠标移动距离
            float rh = Input.GetAxis("Mouse X");
            float rv = Input.GetAxis("Mouse Y");
    
            // 旋转摄像机
            m_camRot.x -= rv;
            m_camRot.y += rh;
            m_camTransform.eulerAngles = m_camRot;   //通过改变XYZ轴的旋转改变欧拉角
    
            // 使主角的面向方向与摄像机一致
            Vector3 camrot = m_camTransform.eulerAngles;
            camrot.x = 0; camrot.z = 0;
            m_transform.eulerAngles = camrot;
    
        }

          (三)类似于第一种方法

    此方法在学习制作一款坦克大战时用到,原理其实和第一种方法类似,只不过用到了正余弦函数。

        相关代码如下:

     public float distance = 8;
        //横向角度
        public float rot = 0;    //用弧度表示
        //纵向角度
        private float roll = 30f * Mathf.PI * 2 / 360;    //弧度
        //目标物体
        private GameObject target;
     void Start()
        {
            //找到坦克
            target = GameObject.Find("Tank");
            
        }
    
     
    void LateUpdate() 
        {
            //一些判断
            if (target == null)
                return;
            if (Camera.main == null)
                return;
            //目标的坐标
            Vector3 targetPos = target.transform.position;
            //用三角函数计算相机位置
            Vector3 cameraPos;
            float d = distance *Mathf.Cos (roll);
            float height = distance * Mathf.Sin(roll);
            cameraPos.x = targetPos.x +d * Mathf.Cos(rot);
            cameraPos.z = targetPos.z + d * Mathf.Sin(rot);
            cameraPos.y = targetPos.y + height;
            Camera.main.transform.position = cameraPos;
            //对准目标
            Camera.main.transform.LookAt(target.transform);
         }

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Unity3D 相机跟随算法

    2017-08-29 12:19:48
    1.向量转四元数 Quaternion.LookRotation(dir);—>返回值就是一个四元数 2.开始旋转 transform.rotation = Quaternion.Lerp...普通相机跟随using System.Collections; using System.Collections.Generic; using U

    1.向量转四元数
    Quaternion.LookRotation(dir);—>返回值就是一个四元数
    2.开始旋转
    transform.rotation = Quaternion.Lerp(当前的四元数, 目标四元数, 旋转的速度);
    3.普通相机跟随

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class CameraMovement : MonoBehaviour {
        /// <summary>
        /// 跟随目标
        /// </summary>
        public Transform followTarget;
        /// <summary>
        /// 方向向量
        /// </summary>
        private Vector3 dir;
    
        private void Start()
        {
            //获取方向向量
            dir = transform.position - followTarget.position;
        }
    
        private void Update()
        {
            transform.position = dir + followTarget.position;
        }
    
    }
    

    4.高级相机跟随,保证看到目标的相机最佳视角

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class CameraMovement : MonoBehaviour {
    
        /// <summary>
        /// 俯视距离的偏移量
        /// </summary>
        public float offset = 0.5f;
        /// <summary>
        /// 设置中间的相机位置个数
        /// </summary>
        public int gears = 5;
        /// <summary>
        /// 跟随目标
        /// </summary>
        public Transform followTarget;
        /// <summary>
        /// 方向向量
        /// </summary>
        private Vector3 dir;
        /// <summary>
        /// 待选的相机位置(观察点)
        /// </summary>
        private Vector3[] readyPosition;
        /// <summary>
        /// 射线碰撞检测器
        /// </summary>
        private RaycastHit hit;
        /// <summary>
        /// 相机跟随的移动速度
        /// </summary>
        public int moveSpeed = 1;
        /// <summary>
        /// 相机旋转的速度
        /// </summary>
        public float turnSpeed = 10f;
        private void Start()
        {
            //获取方向向量
            dir = transform.position - followTarget.position;
            //实例化观察点数组
            readyPosition = new Vector3[gears];
    
        }
    
        private void Update()
        {
            //相机的起点--->相机最佳视角
            Vector3 begin = dir + followTarget.position;
            //相机的终点--->相机最差视角保证能看到玩家
            Vector3 end = followTarget.position + Vector3.up * (dir.magnitude - offset);
            //把起点和终点放到观察点的数组中
            readyPosition[0] = begin;
            readyPosition[readyPosition.Length - 1] = end;
            //获取相机中间点的位置
            for (int i = 1; i < readyPosition.Length - 1; i++)
            {
                //求中间点各个点的坐标,比例为i / (gears - 1)
                readyPosition[i] = Vector3.Lerp(begin, end, i / (readyPosition.Length - 1));
            }
            //备选方案--->前面所有的观察点都看不到玩家
            //都看不到就把相机放到最佳视角
            Vector3 watchPoint = begin;
            //遍历观察点数组,挑选我们最佳观察点
            for (int i = 0; i < readyPosition.Length; i++)
            {
                if (CheckWatchPoint(readyPosition[i]))
                {
                    //设置观察点
                    watchPoint = readyPosition[i];
                    //得到观察点退出循环
                    break;
                }
            }
            //相机平滑移动到最佳观察点
            transform.position = Vector3.Lerp(transform.position, watchPoint, Time.deltaTime * moveSpeed);
            /*
              //旋转的不是很平滑
              //相机旋转到最佳角度看向玩家
              transform.LookAt(followTarget);
             */
            //获取方向向量
            Vector3 lookDir = followTarget.position - watchPoint;
            //获取四元数
            Quaternion lookQua = Quaternion.LookRotation(lookDir);
            //平滑转向玩家
            transform.rotation = Quaternion.Lerp(transform.rotation, lookQua, Time.deltaTime * turnSpeed);
            //固定相机y轴z轴的旋转
            transform.eulerAngles = new Vector3(transform.eulerAngles.x, 0, 0);
    
        }
        /// <summary>
        /// 检测观察点是否可以看到目标
        /// </summary>
        /// <param name="point">待选的观察点</param>
        /// <returns><c>true</c>看得到<c>false</c>看不到</returns>
        bool CheckWatchPoint(Vector3 point)
        {
            if (Physics.Raycast(point,followTarget.position - point,out hit))
            {
                //如果射线检测到的是玩家
                if (hit.collider.tag == "Player")
                {
                    return true;
                }
            }
    
            return false;
        }
    
    }
    

    相机跟随一直观察角色背部

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class CameraFollow : MonoBehaviour {
    
        public Transform target;
        public float distanceUp = 5f;
        public float distanceAway = 5f;
        public float smooth = 2f;//位置平滑移动值
        public float camDepthSmooth = 2f;
        // Use this for initialization
        void Start()
        {
    
        }
    
        // Update is called once per frame
        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);
        }
    
    
    }
    
    展开全文
  • 添加一个Cube添加一个Shpere设置为刚体编写脚本 Camera 附加在相机上 using System.Collections; using System.Collections.Generic; using UnityEngine; public class Camera : MonoBehaviour { public ...
    添加一个Cube
    添加一个Shpere设置为刚体
    编写脚本 Camera 附加在相机上
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class Camera : MonoBehaviour {
    
        public Transform playerTransform;//跟踪的对象
        private Vector3 offset;
    	// Use this for initialization
    	void Start () {
            //         当前位置              物体的位置
            offset = transform.position - playerTransform.position;//计算相对距离
    	}
    	
    	// Update is called once per frame
    	void Update () {
            transform.position = playerTransform.position + offset; //保持相对距离
    	}
        
    }
    


    保存后,把脚本拖到左边Camera 相机上。


    点击Main Camera 右边色Inspector下边 出现了 Player Transform 这个就是刚刚脚本里面的属性,需要把Sphere拖过去(设置)。


    运行项目,不管球体怎么滚动,都是保持了位置相对不变。(跟随)。


    展开全文
  • Unity-3D相机跟随控制

    2020-07-04 12:29:08
    Unity-3D相机跟随控制跟随算法 跟随算法 要实现3D摄像机的控制第一步就是先实现摄像机跟随物体移动。 要想让相机跟随物体移动,就要明白在一定角度下相机与物体的位置关系。 首先设置相机与物体之间的距离distance,...

    跟随算法

    要实现3D摄像机的控制第一步就是先实现摄像机跟随物体移动。
    要想让相机跟随物体移动,就要明白在一定角度下相机与物体的位置关系。

    首先设置相机与物体之间的距离distance,相机与xz平面的角度为roll
    所以根据三角关系可以求得映射在xz平面的距离d为distancecos(rool),相机高度为distancesin(roll)。
    如下图
    在这里插入图片描述
    现在就可以确定相机的高度了即y轴的坐标相机的y轴坐标应该为 Camera.Main.y=物体.y+height

    在xz平面中,设相机与物体的距离为d(就是上面说的那个d,distance映射在xz平面的长度),相机的旋转角度为rot。根据下图可以看到,相机与物体的连线与x轴的角度为rot-180.根据三角函数,既可以得出x轴的位移为d*sin(rot),z轴的位移为d*cos(rot)
    在这里插入图片描述所以说开始的时候指定distance和rot和roll就可以实现跟随了。实现跟随的代码如下

    public class CameraFollow : MonoBehaviour
    {
        //距离
        public float distance = 15;
        //横向角度
        public float rot = 0;
        //纵向角度  30d度
        public float roll = 30f * Mathf.PI * 2 / 360;
        //目标物体
        public GameObject target;
        
        private void Start()
        {
            target = GameObject.Find("Black Track");
        }
        
        private void LateUpdate()
        {
            if (target == null)
                return;
            if (Camera.main == null)
                return;
                
            //目标的坐标
            Vector3 targetPos = target.transform.position;
            //用三角函数计算相机的位置
            Vector3 cameraPos;
            float d = distance * Mathf.Cos(roll);
            float height = distance * Mathf.Sin(roll);
            cameraPos.x = targetPos.x + d * Mathf.Cos(rot);
            cameraPos.z = targetPos.z + d * Mathf.Sin(rot);
            cameraPos.y = targetPos.y + height;
            Camera.main.transform.position = cameraPos;
            Camera.main.transform.LookAt(target.transform);
        }
    }

    在跟随的时候我们可以在要跟随的物体下放置一个子物体命名为cameraPoint使相机对准这个子物体从而方便的更改摄像机的视角。
    所以在物体下添加一个cameraPoint的子物体
    在这里插入图片描述
    并且添加代码

    //设置目标
        public void SetTarget(GameObject target)
        {
            if (target.transform.Find("cameraPoint") != null)
                this.target = target.transform.Find("cameraPoint").gameObject;
            else
                this.target = target;
        }

    如果准的物体有名为cameraPoint的子物体,那么相机对准cameraPoint子物体。

    横向与纵向旋转摄像机

    当鼠标向左移动时,相机随之左转,当鼠标向右移动时,相机随之右转。
    Unity的输入轴Mouse X 和 Mouse Y 代表着鼠标的移动增量,也就是说当鼠标向左移动时,Input.GetAxis(“Mouse X”)的值会增大,向右则减少。只要让旋转角度rot与Mouse X成正比关系,便能通过鼠标控制摄像机的角度。
    代码如下

        //横向旋转速度
        public float rotSpeed=0.1f;
        //横向旋转
        public void Rotate()
        {
            float w = Input.GetAxis("Mouse X") * rotSpeed;
            rot -= w;
        }

    同理对于纵向旋转我们需要设定一个范围 所以代码如下

        //纵向旋转角度
        public float maxRoll = 70f * Mathf.PI * 2 / 360;
        public float minRoll = 0f * Mathf.PI * 2 / 360;
        //纵向旋转速度
        private float rollSpeed = 0.1f;
        //纵向旋转
        public void Roll()
        {
            float w = Input.GetAxis("Mouse Y") * rollSpeed;
            roll -= w;
            if (roll > maxRoll)
                roll = maxRoll;
            if (roll < minRoll)
                roll = minRoll;
        }

    滚轮调节距离

    通过鼠标滚轮调整相机与物体之间的距离
    代码如下

        //距离范围
        public float maxDistance = 22f;
        public float minDistance = 5f;
        //距离变化速度
        public float zoomSpeed = 0.2f;
        //调整距离
        public void Zoom()
        {
            if(Input.GetAxis("Mouse ScrollWheel") >0)
            {
                if (distance > minDistance)
                    distance -= zoomSpeed;
            }
            else if (Input.GetAxis("Mouse ScrollWheel") < 0)
            {
                if (distance < maxDistance)
                    distance += zoomSpeed;
            }
        }

    全部代码

    public class CameraFollow : MonoBehaviour
    {
        //距离
        public float distance = 15;
        //横向角度
        public float rot = 0;
        //纵向角度  30d度
        public float roll = 30f * Mathf.PI * 2 / 360;
        
        //目标物体
        public GameObject target;
        
        //横向旋转速度
        public float rotSpeed=0.1f;
        
        //纵向旋转角度
        public float maxRoll = 70f * Mathf.PI * 2 / 360;
        public float minRoll = 0f * Mathf.PI * 2 / 360;
        //纵向旋转速度
        private float rollSpeed = 0.1f;
        
        //距离范围
        public float maxDistance = 22f;
        public float minDistance = 5f;
        //距离变化速度
        public float zoomSpeed = 0.2f;
        
        private void Start()
        {
            target = GameObject.Find("Black Track");
            SetTarget(target);
        }
        
        private void LateUpdate()
        {
            if (target == null)
                return;
            if (Camera.main == null)
                return;
            //横向旋转
            Rotate();
            //纵向旋转
            Roll();
            //缩放
            Zoom();
            //目标的坐标
            Vector3 targetPos = target.transform.position;
            //用三角函数计算相机的位置
            Vector3 cameraPos;
            float d = distance * Mathf.Cos(roll);
            float height = distance * Mathf.Sin(roll);
            cameraPos.x = targetPos.x + d * Mathf.Cos(rot);
            cameraPos.z = targetPos.z + d * Mathf.Sin(rot);
            cameraPos.y = targetPos.y + height;
            Camera.main.transform.position = cameraPos;
            Camera.main.transform.LookAt(target.transform);
        }
        
        //设置目标
        public void SetTarget(GameObject target)
        {
            if (target.transform.Find("cameraPoint") != null)
                this.target = target.transform.Find("cameraPoint").gameObject;
            else
                this.target = target;
        }
        
        //横向旋转
        public void Rotate()
        {
            float w = Input.GetAxis("Mouse X") * rotSpeed;
            rot -= w;
        }
        
        //纵向旋转
        public void Roll()
        {
            float w = Input.GetAxis("Mouse Y") * rollSpeed;
            roll -= w;
            if (roll > maxRoll)
                roll = maxRoll;
            if (roll < minRoll)
                roll = minRoll;
        }
        
        //调整距离
        public void Zoom()
        {
            if(Input.GetAxis("Mouse ScrollWheel") >0)
            {
                if (distance > minDistance)
                    distance -= zoomSpeed;
            }
            else if (Input.GetAxis("Mouse ScrollWheel") < 0)
            {
                if (distance < maxDistance)
                    distance += zoomSpeed;
            }
        }
    }
    展开全文
  • Unity3D-相机跟随抖动

    2016-10-27 11:02:53
    在U3D中当物体移动和相机跟随的刷新频率不同时,常常会出现物体抖动的问题。 解决这个问题的最好方法是把相机刷新放在LaterUpdate中,能很好解决物体抖动的问题。 但是如果相机在跟随物体一时,画面同时还有...
  • unity3d中控制相机对游戏物体的跟随
  • 将该脚本挂在要跟随的camera上 将要被跟随的目标设为target,就可以实现了 using UnityEngine; using System.Collections; public class FollowTaget : MonoBehaviour { public Transform target;//目标 ...
  • Unity3D 常用相机跟随

    2018-06-20 13:54:44
    1.向量转四元数 Quaternion.LookRotation(dir);—&gt;返回值就是一个四元数 2.开始旋转 transform.rotation = ...普通相机跟随using System.Collections; using System.Collections.Generic; using Unity...
  • Unity知识总结系列(二):相机跟随人物的几种方式http://www.manew.com/thread-114711-1-1.html(出处: -【游戏蛮牛】-ar增强现实,虚拟现实,unity3d,unity3d教程下载首选u3d,unity3d官网)相机跟随一般写在生命周期...
  • using UnityEngine; using System.Collections; public class follwCam : MonoBehaviour { public Transform targetTr; public float dist = 10f; public float height = 3.0f;... public float dampTrace = 20.0f
  • unity3d相机跟随人物

    2019-06-29 17:55:44
    设置相机与玩家之间的角度 给相机添加代码 1 using UnityEngine; 2 using System.Collections; 3 4 namespace CompleteProject 5 { 6 public class CameraFollow : MonoBehaviour 7 { 8...
  • unity 第三人称相机跟随脚本
  • Unity3D手指滑动屏幕更改相机视角,相机跟随代码。安卓端的相机跟随代码。
  • 首先介绍两个重要的方法: 1.FixedUpdate():官方解释是,当我们处理受力物体的时候,需要使用FixedUpdate()而不是Update(),当你为一个刚体加上作用力后,你需要在FixedUpdate()方法中处理这个力。...
  • 完整脚本CamaraController.cs,直接挂载到Camera上就可以运行了 using System.Collections; using System.Collections.Generic; using UnityEngine; public class CameraController : MonoBehaviour { ...
  • public Transform target; public float moveSmooth=5f; Vector3 offset; void Start () { offset = transform.position - target.position;//获取相对位置 } void Update () { Vector3 targetPost...
  • Unity3D摄像机跟随要写在LateUpdate函数中,否者摄像机会强烈抖动。 转载于:https://www.cnblogs.com/chenshiran/archive/2013/04/17/3026794.html
  • Unity3D中摄像机跟随方法,脚本文件附在文档中, 通过Tag得到这个要跟随的人物
  • 在网上搜到的,在这里记录下,以后用,如果有侵权的地方,谅解下!!! using System.Collections; using System.Collections.Generic; using UnityEngine;...using UnityEngine.UI;...public class MouseLook : ...
  • 第一种方式(Vector3....将FollowTarget.cs挂载在相机上,再指定一个相机想要跟随的物体,将其赋给共有属性targetTrans。 public class FollowTarget : MonoBehaviour { public Transform targetTrans; priv...
1 2 3 4 5 ... 20
收藏数 1,594
精华内容 637
关键字:

unity3d 设置相机跟随