Unity C# 一些关于Camera的心得！

本文原创，转载请注明出处：http://www.cnblogs.com/AdvancePikachu/p/6856374.html

首先，总结了下最近工作中关于摄像机漫游的功能，

脚本如下：

     Transform _Camera;
     public LayerMask mask;

     public float checkHeight = 500f;
     public float minHeight = 20f;
     public float maxHeight = 8000f;
     public float minClamp = 50f;
     public float maxClamp = 950f;

     public float sensitivityX = 5f;
     public float sensitivityY = 5f;
     private float rotationY = 0f;

     //上下最大Y视角
     public float minimumY = -90f;
     public float maximumY = 30f;

     public Vector3 PreMouseMPos;

     public float scrollSpeed = 200f;

     void Start ()
     {
         mask.value = ;
         _Camera = Camera.main.transform;
     }

     // Update is called once per frame
     void Update ()
     {
         if(Input.GetKey(KeyCode.LeftAlt))
         {
             MouseScrollWheel ();
             CameraMove ();
             MoveEulerAngles ();
         }
     }

     /// <summary>
     /// Checks the height of the low.
     /// </summary>
     void CheckLowHeight()
     {
         if (_Camera.position.x < minClamp)
             _Camera.position = new Vector3 (minClamp, _Camera.position.y, _Camera.position.z);
         if (_Camera.position.x > maxClamp)
             _Camera.position = new Vector3 (maxClamp, _Camera.position.y, _Camera.position.z);
         if (_Camera.position.z < minClamp)
             _Camera.position = new Vector3 (_Camera.position.x, _Camera.position.y, minClamp);
         if (_Camera.position.z > maxClamp)
             _Camera.position = new Vector3 (_Camera.position.x, _Camera.position.y, maxClamp);

         RaycastHit hit;
         if(Physics.Raycast(_Camera.position+Vector3.up*checkHeight,Vector3.down,out hit ,checkHeight+minHeight,mask))
         {
             if(_Camera.position.y-hit.point.y<minClamp)
             {
                 Vector3 lowPoint = hit.point + new Vector3 (, minHeight, );
                 _Camera.position = lowPoint;
             }
         }
     }

     /// <summary>
     /// Mouses the scroll wheel.
     /// </summary>
     private void MouseScrollWheel()
     {
         if(Input.GetAxis("Mouse ScrollWheel")!=)
         {
             _Camera.Translate (new Vector3 (, , Input.GetAxis ("Mouse ScrollWheel") * Time.deltaTime * scrollSpeed));
         }

         CheckLowHeight ();

         if (_Camera.position.y >= maxHeight)
             _Camera.position = new Vector3 (_Camera.position.x, maxHeight, _Camera.position.z);
     }

     /// <summary>
     /// Cameras the move.
     /// </summary>
     private void CameraMove()
     {
         if(Input.GetMouseButton())
         {
             if(PreMouseMPos.x<=)
             {
                 PreMouseMPos = new Vector3 (Input.mousePosition.x, Input.mousePosition.y, );
             }
             else
             {
                 Vector3 CurMouseMPos = new Vector3 (Input.mousePosition.x, Input.mousePosition.y, );
                 Vector3 offset = CurMouseMPos - PreMouseMPos;
                 offset = -offset * 0.5f * ;
                 if((_Camera.position+offset).y>=minHeight
                     &&(_Camera.position+offset).y<=maxHeight)
                 {
                     _Camera.Translate(offset);

                     CheckLowHeight();

                     PreMouseMPos = CurMouseMPos;
                 }
             }
         }
         else
             PreMouseMPos = Vector3.zero;
     }

     /// <summary>
     /// Moves the euler angles.
     /// </summary>
     private void MoveEulerAngles()
     {
         if(Input.GetMouseButton())
         {
             float rotationX = _Camera.localEulerAngles.y + Input.GetAxis ("Mouse X") * sensitivityX;

             rotationY += Input.GetAxis ("Mouse Y") * sensitivityY;

             rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);

             _Camera.localEulerAngles = new Vector3 (-rotationY, rotationX, );
         }
     }

MoveRocket

第二个是关于摄像机的限制范围和遇到障碍物自动变换与target的距离的功能

代码如下：

 public Transform target;

     public LayerMask mask = new LayerMask();

     public Vector2 targetOffset = new Vector2();
     public Vector2 originRotation = new Vector2();

     public float distance = ;
     public float minDistance = ;
     public float maxDistance = ;

     public Vector2 sensitivity = new Vector2(, );

     public float zoomSpeed = ;
     public float zoomSmoothing = ;

     public float minAngle = -;
     public float maxAngle = ;

     private float _zoom_in_timer = ;
     private float _zoom_out_timer = ;

     private float _wanted_distance;
     private Quaternion _rotation;
     private Vector2 _input_rotation;

     private Transform _t;

     void Start()
     {
         mask.value = ;
         _t = transform;
         _wanted_distance = distance;
         _input_rotation = originRotation;     }

     void Update()
     {
         if (target) {

             if (Input.GetMouseButton () || Input.GetMouseButton ()) {
                 if (Input.GetAxis ("Mouse X") !=  || Input.GetAxis ("Mouse Y") != ) {
                     if (!Cursor.visible) {
                         Cursor.visible = false;
                         Cursor.lockState = CursorLockMode.Locked;
                     }
                 }

                 return;
             }
         }

         if (!Cursor.visible) {
             Cursor.visible = true;
             Cursor.lockState = CursorLockMode.None;
         }

     }
     void FixedUpdate()
     {
         if(target)
         {

             // Zoom control
             if(Input.GetAxis("Mouse ScrollWheel") <  )
             {
                 _wanted_distance += zoomSpeed;
             }
             else if(Input.GetAxis("Mouse ScrollWheel") >  )
             {
                 _wanted_distance -= zoomSpeed;
             }

             _wanted_distance = Mathf.Clamp(_wanted_distance, minDistance, maxDistance);

             if (Input.GetMouseButton () || Input.GetMouseButton ()) {

                 _input_rotation.x += Input.GetAxis ("Mouse X") * sensitivity.x;

                 ClampRotation ();

                 _input_rotation.y -= Input.GetAxis ("Mouse Y") * sensitivity.y;

                 _input_rotation.y = Mathf.Clamp (_input_rotation.y, minAngle, maxAngle);

                 _rotation = Quaternion.Euler (_input_rotation.y, _input_rotation.x, );

             }

             // Lerp from current distance to wanted distance
             distance = Mathf.Clamp(Mathf.Lerp(distance, _wanted_distance, Time.deltaTime * zoomSmoothing), minDistance, maxDistance);

             // Set wanted position based off rotation and distance
             Vector3 wanted_position = _rotation * new Vector3(targetOffset.x, , -_wanted_distance - 0.2f) + target.position + new Vector3(, targetOffset.y, );
             Vector3 current_position = _rotation * new Vector3(targetOffset.x, , ) + target.position + new Vector3(, targetOffset.y, );

             // Linecast to test if there are objects between the camera and the target using collision layers
             RaycastHit hit;

             if(Physics.Linecast(current_position, wanted_position, out hit, mask))
             {
                 distance = Vector3.Distance(current_position, hit.point) - 0.2f;
             }

             // Set the position and rotation of the camera
             _t.position = _rotation * new Vector3(targetOffset.x, 0.0f, -distance) + target.position + new Vector3(, targetOffset.y, );
             _t.rotation = _rotation;
         }
     }

     private void ClampRotation()
     {
         if(originRotation.x < -)
         {
             originRotation.x += ;
         }
         else if(originRotation.x > )
         {
             originRotation.x -= ;
         }

         if(_input_rotation.x - originRotation.x < -)
         {
             _input_rotation.x += ;
         }
         else if(_input_rotation.x - originRotation.x > )
         {
             _input_rotation.x -= ;
         }
     }