Unity camera control

Unity Camera control ：

Control camera movement , rotate , The zoom , jumping ; There are visual limitations , And the higher the camera height, the greater the motion range .

View zoom ： You can zoom in by scrolling the mouse wheel forward , Roll the mouse wheel backward to widen the view .

The field of vision moves ： Hold down the left mouse button , Move the mouse to control the field of view to move smoothly in the direction of the mouse icon , That is, the field of vision can be on 、 Next 、 Left 、 Translate in the four right directions .

Field of view rotation ： Hold down the right mouse button , Move the mouse to control the field of view to rotate in the direction of the mouse icon . The vertical rotation range is -90 C to 90 degree , There is no limit in the horizontal direction , can 360 Degree of rotation .

Visual field jump ： Double click the left mouse button to control the field of view to jump a distance in the direction of the mouse icon ; Double click the right mouse button to control the field of view to jump back a certain distance .

Limited vision ： The field of view cannot be moved outside the restricted box space .

The code is as follows ：

/// file name ：CameraController.cs

/// function ： Camera free control class
/// Abstract ：
/// Date of creation ：2016.1.13
/// Modification log ：

using UnityEngine;

public class CameraController : MonoBehaviour
{
    private static Transform cameraSelf;

    public float scrollSpeed;
    public float moveSpeed;
    public float rotateSpeed    = 2;        
    public float moveSpeedMin   = 0.5f;
    public float moveSpeedMax   = 500f;
    public float scrollSpeedMax = 30000;
    public float scrollSpeedMin = 50f;
    public float heightMax      = 15000f;
    public float heightMin      = 20f;
    public float cameraXMin     = 2000f;
    public float cameraXMax     = 18000f;
    public float cameraZMin     = 3000f;
    public float cameraZMax     = 27000f;

    public  float jumpHeightMin;
    public  float jumpSpeedMax;
    public  float jumpSpeedMin;
    private float jumpDistance;

    private float mouseDownDuration = 0.3f;
    private float lastLeftDownTime  = -1;
    private float lastrightDownTime = -1;

    private float rotate_X;
    private float rotate_Y;
    private float move_X;
    private float move_Y;

    Ray ray;
    RaycastHit hitInfo;

    void Start()
    {
        cameraSelf = transform;
    }   
   
    void LateUpdate()
    {        
        CameraJump();
        CameraZoom();
        CameraRotate();
        CameraMove();
        CameraLimit();
    }   

    /// <summary>
    /// The pulley controls the zoom of the field of view
    /// </summary>
    void CameraZoom()
    {
        float scrollAxis = Input.GetAxis("Mouse ScrollWheel"); 
        if (scrollAxis != 0)
        {
            scrollSpeed = (scrollSpeedMin + (cameraSelf.position.y - heightMin)
                / (heightMax - heightMin) * (scrollSpeedMax - scrollSpeedMin));


            scrollSpeed = Mathf.Clamp(scrollSpeed, scrollSpeedMin, scrollSpeedMax);
            Vector3 targetPoint = cameraSelf.position + cameraSelf.forward
                * scrollAxis * scrollSpeed;


            cameraSelf.position = Vector3.Lerp(cameraSelf.position, targetPoint, Time.deltaTime);
        }
    }

    /// <summary>
    /// The left mouse button controls movement
    /// </summary>    
    void CameraMove()
    {      
        if (Input.GetMouseButton(0))
        {
            moveSpeed = moveSpeedMin + (cameraSelf.position.y - heightMin)
                / (heightMax - heightMin) * (moveSpeedMax - moveSpeedMin);


            moveSpeed = Mathf.Clamp(moveSpeed, moveSpeedMin, moveSpeedMax);
            move_Y    = Input.GetAxis("Mouse Y") * moveSpeed;
            move_X    = Input.GetAxis("Mouse X") * moveSpeed;
            cameraSelf.position += -cameraSelf.right * move_X - cameraSelf.up * move_Y;
        }
    }
   

    /// <summary>
    /// Right click to control rotation
    /// </summary>
    void CameraRotate()
    {      
        if (Input.GetMouseButton(1))
        {
            rotate_X = cameraSelf.eulerAngles.x;
            rotate_Y = cameraSelf.eulerAngles.y;


            rotate_X -= Input.GetAxis("Mouse Y") * rotateSpeed;
            rotate_Y += Input.GetAxis("Mouse X") * rotateSpeed;
            rotate_X  = ClampAngle(rotate_X, 1, 89);
            rotate_Y  = ClampAngle(rotate_Y, -360, 360);
            cameraSelf.rotation = Quaternion.Euler(rotate_X, rotate_Y, 0);
        }
    } 
  

    /// <summary>
    /// Planning Perspective
    /// </summary>
    /// <param name="angle"> The actual angle </param>
    /// <param name="minAngle"> The minimum Angle </param>
    /// <param name="maxAgnle"> Maximum Angle </param>
    /// <returns> Angle within limits </returns>
    float ClampAngle(float angle, float minAngle, float maxAgnle)
    {
        if (angle <= -360)
            angle += 360;
        if (angle >= 360)
            angle -= 360;


        return Mathf.Clamp(angle, minAngle, maxAgnle);
    }

    /// Visual field jump
    void CameraJump()
    {

         // Double left click the field of view to jump in the direction of mouse click
        if (Input.GetMouseButtonDown(0))
        {
            ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            Physics.Raycast(ray, out hitInfo);
           
            if (Time.time - lastLeftDownTime < mouseDownDuration)
            {
                jumpDistance = (jumpSpeedMin + (cameraSelf.position.y - jumpHeightMin) /
                                               (heightMax - jumpHeightMin) * (jumpSpeedMax - jumpSpeedMin));
                cameraSelf.position += ray.direction * jumpDistance;
            }
            lastLeftDownTime = Time.time;            
        }

        // Double click the right button to move the field of view backward
        if (Input.GetMouseButtonDown(1))
        {                

            if (Time.time - lastrightDownTime < mouseDownDuration)
            {
                jumpDistance = (jumpSpeedMin + (cameraSelf.position.y - jumpHeightMin) /
                                               (heightMax - jumpHeightMin) * (jumpSpeedMax - jumpSpeedMin));
                cameraSelf.position -= cameraSelf.forward * jumpDistance;
            }
            lastrightDownTime = Time.time;
        }
    }

    /// <summary>
    /// Camera restrictions
    /// </summary>
    void CameraLimit()
    {
        Vector3 vec = cameraSelf.position;
        vec.x = Mathf.Clamp(vec.x, cameraXMin, cameraXMax);
        vec.y = Mathf.Clamp(vec.y, heightMin, heightMax);
        vec.z = Mathf.Clamp(vec.z, cameraZMin, cameraZMax);
        cameraSelf.position = vec;
    }
}

In the actual use process, it may be necessary to implement the click in interface UI Don't change your vision when you go up , You can use EventSystem.current.IsPointerOverGameObject(), This function can be used to determine whether to click UI On , If you click UI On, it returns true, Did not click UI On, it returns false.