Unity limits camera movement area (no collision detection required)

Restriction function original address: unity restricts the movable area of the camera (box collider)_unity restricts the movable area of the camera_manson-liao’s blog-CSDN blog

1. Create restricted areas

Create a Cube, Scale size = 1, add component: BoxCollder, adjust the Size of BoxCollder (this is a restricted area)

2. Code (function: WADS (or up, down, left, and right direction keys) and use Q E to move up and down and the mouse to control the movement and direction of the camera, etc. The limiting function is the method in the class: limitation(), which can be executed in Update )

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
namespace Twq
{
    /// <summary>
    /// wasd control (in use)
    /// </summary>
    public class CameraController03 : MonoBehaviour
    {

        public static CameraController03 Instance;
        [Header("Model")]
        public Transform targetmodel;
        public static Transform target;
        [Header("Mouse wheel sensitivity")]
        [SerializeField]
        private int MouseWheelSensitivity = 2;
        [Header("closest distance")]
        [SerializeField]
        public int MouseZoomMin = 750;
        [Header("farthest distance")]
        [SerializeField]
        public int MouseZoomMax = 2000;

        [Header("Horizontal rotation speed")]
        [SerializeField]
        private float xSpeed = 150.0f;
        [Header("Vertical rotation speed")]
        [SerializeField]
        private float ySpeed = 80.0f;
        [Header("Mouse movement sensitivity")]
        [SerializeField]
        private float mouseMoveSensitivity = 3.0f;

        [Header("Angle Limit")]
        [SerializeField]
        private int yMinLimit = 0;
        [SerializeField]
        private int yMaxLimit = 89;

        [Header("Camera Initial Angle")]
        [SerializeField]
        private float xRot = 0;
        [SerializeField]
        private float yRot = 0;


        [Header("Camera Position")]
        [SerializeField]
        private Vector3 camPos;//= new Vector3(0, 0, 0);
        public float normalDistance;//Initial camera distance, cannot be displayed on the panel

        public static float x;//= 69f;
        public static float y;// 34.2f;


        private Quaternion rotation;
        public static Vector3 CameraTarget;
        // [HideInInspector]
        public bool isExit;//Open control camera
        public bool isShuBiao;//Flase=Zoom status

        public Transform SelfTransform;
        private void Awake()
        {
            Instance = this;
            SelfTransform = this.transform;
        }
        void Start()
        {
            //initialization
            isExit = true;
            isShuBiao = true;
            x = yRot;
            y = xRot;
            target = targetmodel;
            Vector3 posC = camPos - target.position;
            normalDistance = Mathf.Sqrt(Mathf.Pow(posC.x, 2) + Mathf.Pow(posC.y, 2) + Mathf.Pow(posC.z, 2));

            rotation = Quaternion.Euler(new Vector3(y, x, 0f));

            transform.rotation = rotation;
            float z = target.transform.position.z - normalDistance;
            transform.position = camPos;//rotation * new Vector3(transform.position.x, transform.position.y, z);
            CameraTarget = transform.position + transform.forward.normalized * normalDistance;

            x = transform.localEulerAngles.x;
            y = transform.localEulerAngles.y;

        }
        public void Init()
        {
            isExit = true;
            isShuBiao = true;

            Vector3 posC = camPos - target.position;

            normalDistance = Mathf.Sqrt(Mathf.Pow(posC.x, 2) + Mathf.Pow(posC.y, 2) + Mathf.Pow(posC.z, 2));

            rotation = Quaternion.Euler(new Vector3(90f, 0f, 0f));

            transform.rotation = rotation;

            transform.position = new Vector3(0f, 0f, 0f);
            CameraTarget = transform.position + transform.forward.normalized * normalDistance;

            x = transform.localEulerAngles.x;
            y = transform.localEulerAngles.y;

        }
        public float movespeed = 500;
        void LateUpdate()
        {
            if (IsPointerOverGameObject(Input.mousePosition))
                if(isExit)
                {
                    if (isShuBiao)
                    {
                        // Define 3 values to control movement
                        float xm = 0, zm = 0;

                       
                        if (Input.GetKey(KeyCode.Q)) //Rise
                        {
                            if (transform.position.y >= MouseZoomMax)//limit the maximum distance
                            {
                                transform.position = new Vector3(transform.position.x, MouseZoomMax, transform.position.z);
                            }
                            else
                            {
                                transform.position = new Vector3(transform.position.x, transform.position.y + movespeed * Time.deltaTime, transform.position.z);
                            }
                        }
                        else if (Input.GetKey(KeyCode.E))//Descend
                        {
                            if (transform.position.y <= MouseZoomMin)//limit the minimum distance
                            {
                                transform.position = new Vector3(transform.position.x, MouseZoomMin, transform.position.z);
                            }
                            else
                            {
                                transform.position = new Vector3(transform.position.x, transform.position.y - movespeed * Time.deltaTime, transform.position.z);
                            }
                        }

                        //Press keyboard W to move up
                        if (Input.GetKey(KeyCode.UpArrow) || Input.GetKey(KeyCode.W))
                        {

                            if (transform.position.y < MouseZoomMin)//limit the minimum distance
                            {
                                transform.position = new Vector3(transform.position.x, MouseZoomMin, transform.position.z);
                            }
                            else
                            {
                                this.transform.Translate(Vector3.forward * movespeed * Time.deltaTime);
                            }

                        }
                        else if (Input.GetKey(KeyCode.DownArrow) || Input.GetKey(KeyCode.S))//Press keyboard S to move down
                        {
                            if (transform.position.y > MouseZoomMax)//limit the maximum distance
                            {
                                transform.position = new Vector3(transform.position.x, MouseZoomMax, transform.position.z);
                            }
                            else
                            {
                                this.transform.Translate(Vector3.back * movespeed * Time.deltaTime);
                            }

                        }

                        if (Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.A))//Press keyboard A to move left
                        {
                            // xm -= 500 * Time.deltaTime;
                            this.transform.Translate(Vector3.left * movespeed * Time.deltaTime);
                        }
                        else if (Input.GetKey(KeyCode.RightArrow) || Input.GetKey(KeyCode.D))//Press keyboard D to move to the right
                        {
                            // xm + = 500 * Time.deltaTime;
                            this.transform.Translate(Vector3.right * movespeed * Time.deltaTime);
                        }
                        if (Input.GetMouseButton(GlobalVariableManage.GetMouseButtonType))// 1 right mouse button 0 left mouse button
                        {
                            y + = Input.GetAxis("Mouse X") * xSpeed * 0.02f;
                            x -= Input.GetAxis("Mouse Y") * ySpeed * 0.02f;
                            x = ClampAngle(x, yMinLimit, yMaxLimit);
                            var rotation = Quaternion.Euler(x, y, 0);

                            transform.rotation = rotation;
                        }
                        else if (Input.GetAxis("Mouse ScrollWheel") != 0)//Mouse wheel
                        {
                            // normalized = (transform.position - CameraTarget).normalized;
                            if (normalDistance >= MouseZoomMin & amp; & amp; normalDistance <= MouseZoomMax)
                            {
                                this.transform.position + = this.transform.forward * Input.GetAxisRaw("Mouse ScrollWheel") * Time.timeScale * MouseWheelSensitivity;
                                Vector3 p = this.transform.position - CameraTarget;
                                normalDistance = Mathf.Sqrt(Mathf.Pow(p.x, 2) + Mathf.Pow(p.y, 2) + Mathf.Pow(p.z, 2));
                            }
                            if (normalDistance < MouseZoomMin)
                            {
                                normalDistance = MouseZoomMin;
                            }
                            if (normalDistance > MouseZoomMax)
                            {
                                normalDistance = MouseZoomMax;
                            }
                            if (transform.position.y < MouseZoomMin)//limit the minimum distance
                            {
                                transform.position = new Vector3(transform.position.x, MouseZoomMin, transform.position.z);
                            }
                            if (transform.position.y > MouseZoomMax)//limit the maximum distance
                            {
                                transform.position = new Vector3(transform.position.x, MouseZoomMax, transform.position.z);
                            }
                        }

                    }
                    else
                    {
                        if (transform.position.y > MouseZoomMax)//limit the minimum distance
                        {
                            isShuBiao = true;
                        }
                        //Zoom
                        if (Input.GetAxis("Mouse ScrollWheel") > 0)
                        {
                            transform.Translate(Vector3.forward * 100f);//The speed is adjustable and can be adjusted by yourself
                        }
                        if (Input.GetAxis("Mouse ScrollWheel") < 0)
                        {
                            transform.Translate(Vector3.forward * -100f);//The speed is adjustable and can be adjusted by yourself
                        }
                        //Rotate
                        x = transform.localEulerAngles.x;
                        y = transform.localEulerAngles.y;

                    }
                    limitation();
                }
        }

        public GameObject box;
//Restricted area

        private void limitation()
        {
            if(box)
            {
                Vector3 boxSize = box.GetComponent<BoxCollider>().size;
                Vector3 boxCenter = box.GetComponent<BoxCollider>().center;
                Vector3 min = box.transform.position + boxCenter - boxSize * 0.5f;
                Vector3 max = box.transform.position + boxCenter + boxSize * 0.5f;

                Vector3 cameraP = transform.position;

                Debug.Log("min.x=" + min.x + " max.x=" + max.x);


                if (cameraP.x < min.x)
                {
                    cameraP.x = min.x;
                }
                else if (cameraP.x > max.x)
                {
                    cameraP.x = max.x;
                }

                //if (cameraP.y < min.y)
                //{
                // cameraP.y = min.y;
                //}
                //else if (cameraP.y > max.y)
                //{
                // cameraP.y = max.y;
                //}

                if (cameraP.z < min.z)
                {
                    cameraP.z = min.z;
                }
                else if (cameraP.z > max.z)
                {
                    cameraP.z = max.z;
                }

                transform.position = cameraP;
            }

        }





        /// <summary>
        /// Check whether the UI is clicked
        /// </summary>
        /// <param name="mousePosition">Mouse position</param>
        /// <returns></returns>
        private bool IsPointerOverGameObject(Vector2 mousePosition)
        {
            //Create a click event
            PointerEventData eventData = new PointerEventData(EventSystem.current);
            eventData.position = mousePosition;
            List<RaycastResult> raycastResults = new List<RaycastResult>();
            //Emit a ray to the clicked position to detect whether the UI is clicked
            EventSystem.current.RaycastAll(eventData, raycastResults);
            if (raycastResults.Count > 0)//greater than 0 means there is a UI
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        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);
        }

        //--------------------surrounding the object and the camera positioning the object--------------------//
        #region
        //public Transform CenObj;//surrounding objects
        //private Vector3 Rotion_Transform;
        //private new Camera camera;

        bool bo;


        //private Transform mainCameraTr; //main camera
        //public Transform lookAtTarget; //The target the camera is looking at
        //private float cameraDistance = 50.0F; //The distance between the camera and the target
        //private float cameraHeight = 800.0F; //Camera height
        //private float cmaeraOffset = 1000.0F; //Camera offset
        //private float mainCameraMoveSpeed = 1F; //The speed of main camera movement

        //private Vector3 lookAtTargetPosition; //The position when looking at the target
        //private Quaternion lookAtTargetRotation; //Look at the target and rotate

        //public bool isLookAtAppointTarget = false; //Whether to look at the specified object


        //public void SetInit(Transform CenObj_)
        //{
        // Debug.Log("Clicked=" + CenObj_.name);

        // isShuBiao = true;
        // CenObj = CenObj_;
        // Rotion_Transform = CenObj.position;

        // lookAtTarget = CenObj_;
        // LookAtAppointTarget();
        // isShuBiao = false;
        //}
        //void Update()
        //{
        // //if (!isExit)
        // //{
        // // Ctrl_Cam_Move();
        // // Cam_Ctrl_Rotation();
        // //}
        //}


        / <summary>
        / Method for the camera to look at the specified object
        / </summary>
        //public void LookAtAppointTarget()
        //{
        // if (lookAtTarget != null)
        // {
        // lookAtTargetPosition = new Vector3(lookAtTarget.transform.position.x + cmaeraOffset,
        // lookAtTarget.transform.position.y + cameraHeight, lookAtTarget.transform.position.z + cameraDistance);
        // isLookAtAppointTarget = true;

        // }
        //else
        // {
        // Debug.LogError(GetType() + "/LookAtAppointTarget()/The object you are looking at does not exist, please check!!!");
        // }

        // if (isLookAtAppointTarget == true) // Whether to look at the object
        // {
        // mainCameraTr.position = Vector3.Lerp(mainCameraTr.position, lookAtTargetPosition, 1 * mainCameraMoveSpeed);
        // mainCameraTr.LookAt(lookAtTarget);
        // }
        // //if (isBack == true)
        // //{
        // // mainCameraTr.position = Vector3.Lerp(mainCameraTr.position, lookAtTargetPosition, 10 * mainCameraMoveSpeed);
        // //}
        //}
        #endregion
    }
}