unity中Game视图中实现和Scene视图中一样的摄像机操作

最新推荐文章于 2024-07-24 17:14:15 发布
最新推荐文章于 2024-07-24 17:14:15 发布
阅读量3.3k 收藏 14
点赞数 2
分类专栏： unity随笔记录 文章标签： unity 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26459233/article/details/127105194
版权

代码运行，是可行的，在github上找的，侵权请告知，忘记在哪下的了。

using UnityEngine;
using System.Collections;

public class CameraController : MonoBehaviour
{
    /// <summary>
    /// 视角类型.
    /// </summary>
    private enum ViewType
    {
        _2D = 0,
        _3D
    }

    /// <summary>
    /// 鼠标按键.
    /// </summary>
    private enum MouseButton
    {
        /// <summary>
        /// 鼠标左键.
        /// </summary>
        LEFT = 0,
        /// <summary>
        /// 鼠标右键.
        /// </summary> 
        RIGHT,
        /// <summary>
        /// 鼠标中键.
        /// </summary>
        MIDDLE
    }

    /// <summary>
    /// 指针样式.
    /// </summary>
    private enum CursorType
    {
        /// <summary>
        /// 默认样式.
        /// </summary>
        DEFAULT = 0,
        /// <summary>
        /// 小手.
        /// </summary>
        HAND,
        /// <summary>
        /// 眼睛.
        /// </summary>
        EYE,
        /// <summary>
        /// 放大镜.
        /// </summary>
        MAGNIFIER
    }

    #region 字段
    private const string MOUSESCROLLWHEEL = "Mouse ScrollWheel";        // 鼠标滚轮.
    private const string MOUSEX = "Mouse X";
    private const string MOUSEY = "Mouse Y";

    #region 输入

    private bool leftAltKeyDown;                                        // 左Alt键-按下.
    private bool rightAltKeyDown;                                       // 右Alt键-按下.
    private bool leftAltKey;                                            // 左Alt键-长按.
    private bool rightAltKey;                                           // 右Alt键-长按.
    private bool leftAltKeyUp;                                          // 左Alt键-抬起.
    private bool rightAltKeyUp;                                         // 右Alt键-抬起.
    private bool leftMouseButtonDown;                                   // 鼠标左键-按下.
    private bool rightMouseButtonDown;                                  // 鼠标右键-按下.
    private bool leftMouseButton;                                       // 鼠标左键-长按.
    private bool rightMouseButton;                                      // 鼠标右键-长按.
    private bool rightMouseButtonUp;                                    // 鼠标右键-抬起.
    private bool middleMouseButton;                                     // 鼠标中键-长按.
    private bool middleMouseButtonUp;                                   // 鼠标中键-抬起.

    #endregion

    private Camera m_Camera;                                            // 相机.
    private Texture2D handCursorTexture;                                // 小手.
    private Texture2D eyeCursorTexture;                                 // 眼睛.
    private Texture2D magnifierCursorTexture;                           // 放大镜.

    private Vector2 hotSpot = Vector2.zero;
    private CursorMode cursorMode = CursorMode.Auto;

    private float angle_X;                                              // 水平方向的角度值，绕Transform的y轴旋转（左右）
    private float angle_Y;                                              // 竖直方向的角度值，绕Transform的x轴旋转（上下）
    private float angle_Z;

    // 切换视角
    private Matrix4x4 defaultOrthProjMat;                               // 相机默认的正交投影矩阵.
    private Matrix4x4 defaultPersProjMat;                               // 相机默认的透视投影矩阵.
    private Matrix4x4 currentProjMat;                                   // 相机当前的投影矩阵.
    private bool isChangingViewType = false;                            // 正在切换视角.
    private float viewTypeLerpTime = 0f;                                // 插值时间.
    private ViewType viewType;                                          // 当前视角.

    [Header("Zoom")]
    // 相机拉近拉远 Zoom
    [SerializeField]
    private float distance = 20f;                      // 相机与lookAroudPos点的距离.
    [SerializeField, Range(1f, 20f)]
    private float zoomSpeed = 10f;                                      // 滚轮缩放速度.
    [SerializeField]
    private float maxDistance = 100f;                  // 相机最远距离.
    [SerializeField]
    private float minDistance = 1f;                    // 相机最近距离.

    [Header("360° Rotate")]
    // Alt+鼠标拖动, 360度观察
    [SerializeField, Range(2f, 10f)]
    private float rotateSensitivity = 5f;                               // 旋转灵敏度.
    private Vector3 lookAroundPos = Vector3.zero;

    // Alt+鼠标右键 放大缩小
    [Header("Field Of View")]
    private float minFov = 20f;                                         // 最小视角.
    private float maxFov = 135f;                                        // 最大视角.
    private Vector3 lastMousePosFov = Vector3.zero;
    [SerializeField, Range(0.01f, 0.1f)]
    private float fovSensitivity = 0.05f;                               // 视角灵敏度.

    // 选中物体聚焦
    private GameObject selectedObj = null;                              // 选中的物体.
    private float raycastMaxDistance = 1000f;
    private LayerMask raycastLayerMask;
    private RaycastHit raycastHit;

    [Header("Focus")]
    [SerializeField, Range(0.1f, 5f)]
    private float focusSpeed = 3.0f;                                    // 聚焦的速度.
    [SerializeField]
    private float focusDistance = 3f;                                   // 聚焦时与物体的距离.
    private bool isFocusing = false;                                    // 相机正看向物体中.
    private float focusTime = 0f;                                       // 聚焦时间.
    private Vector3 cameraInitForward;                                  // 相机最初的前方.
    private Vector3 focusTargetForward;                                 // 聚焦目标前方.
    private Vector3 focusInitPos;                                       // 聚焦前相机初始位置.
    private Vector3 focusTargetPos;                                     // 聚焦目标位置.
    #endregion

    #region Unity_Method

    private void Start()
    {
        Init();
    }
    private float mMoveSpeed = 0.2f;
    private void LateUpdate()
    {
        // 更新输入.
        UpdateInput();
        // 切换视角.
        SwitchViewType();
        // 拉近拉远.
        Zoom();
        // 拖动相机.
        Drag();
        // 360°查看.
        LookAround();
        // 放大缩小. 和切换视角共同使用时有Bug.
        Magnifier();
        // 聚焦.
        Focus();

        if (Input.GetKey(KeyCode.W))
        {
            m_Camera.transform.position += m_Camera.transform.forward * mMoveSpeed;
        }
        else if (Input.GetKey(KeyCode.S))
        {
            m_Camera.transform.position += -m_Camera.transform.forward * mMoveSpeed;
        }
        else if (Input.GetKey(KeyCode.A))
        {
            m_Camera.transform.position += -m_Camera.transform.right * mMoveSpeed;
        }
        else if (Input.GetKey(KeyCode.D))
        {
            m_Camera.transform.position += m_Camera.transform.right * mMoveSpeed;
        }

    }
    private void OnGUI()
    {
       

        //if (GUI.Button(new Rect(Vector2.zero, new Vector2(100, 50)), "正交"))
        //{
        //    SetViewType(ViewType._2D);
        //}

        //if (GUI.Button(new Rect(Vector2.up * 60, new Vector2(100, 50)), "透视"))
        //{
        //    SetViewType(ViewType._3D);
        //}

        //if (GUI.Button(new Rect(Vector2.up * 120, new Vector2(100, 50)), "正视图"))
        //{
        //    Front();
        //}

        //if (GUI.Button(new Rect(Vector2.up * 180, new Vector2(100, 50)), "后视图"))
        //{
        //    Back();
        //}

        //if (GUI.Button(new Rect(Vector2.up * 240, new Vector2(100, 50)), "左视图"))
        //{
        //    Left();
        //}

        //if (GUI.Button(new Rect(Vector2.up * 300, new Vector2(100, 50)), "右视图"))
        //{
        //    Right();
        //}

        //if (GUI.Button(new Rect(Vector2.up * 360, new Vector2(100, 50)), "上视图"))
        //{
        //    Top();
        //}

        //if (GUI.Button(new Rect(Vector2.up * 420, new Vector2(100, 50)), "下视图"))
        //{
        //    Down();
        //}
    }

    #endregion

    #region 初始化相关

    /// <summary>
    /// 初始化.
    /// </summary>
    private void Init()
    {
        m_Camera = GetComponent<Camera>();
        raycastLayerMask = 1 << LayerMask.NameToLayer("Default");

        RecalcDistance();
        CalculateProjMatrix();                  // 获取相机默认矩阵.
        ResetLookAroundPos();                   // 重置观察中心.
        LoadCursorTexture();                    // 加载鼠标图标.
    }

    /// <summary>
    /// 重置观察中心(观察中心在相机的前方).
    /// </summary>
    private void ResetLookAroundPos()
    {
        lookAroundPos = m_Camera.transform.position + m_Camera.transform.rotation * (Vector3.forward * distance);
    }

    /// <summary>
    /// 加载鼠标指针图标.
    /// </summary>
    private void LoadCursorTexture()
    {
        handCursorTexture = Resources.Load<Texture2D>("Textures/Hand");
        eyeCursorTexture = Resources.Load<Texture2D>("Textures/Eye");
        magnifierCursorTexture = Resources.Load<Texture2D>("Textures/Magnifier");
    }

    /// <summary>
    /// 设置鼠标样式.
    /// </summary>
    private void SetCursor(CursorType cursorType)
    {
        switch (cursorType)
        {
            case CursorType.DEFAULT:
                Cursor.SetCursor(null, hotSpot, cursorMode);
                break;
            case CursorType.HAND:
                Cursor.SetCursor(handCursorTexture, hotSpot, cursorMode);
                break;
            case CursorType.EYE:
                Cursor.SetCursor(eyeCursorTexture, hotSpot, cursorMode);
                break;
            case CursorType.MAGNIFIER:
                Cursor.SetCursor(magnifierCursorTexture, hotSpot, cursorMode);
                break;
            default:
                Debug.LogError("未知指针类型.");
                break;
        }
    }

    /// <summary>
    /// 更新输入.
    /// </summary>
    private void UpdateInput()
    {
        leftAltKeyDown = Input.GetKeyDown(KeyCode.LeftAlt);                            // 左Alt键-按下.
        rightAltKeyDown = Input.GetKeyDown(KeyCode.RightAlt);                          // 右Alt键-按下.
        leftAltKey = Input.GetKey(KeyCode.LeftAlt);                                    // 左Alt键-长按.
        rightAltKey = Input.GetKey(KeyCode.RightAlt);                                  // 右Alt键-长按.
        leftAltKeyUp = Input.GetKeyUp(KeyCode.LeftAlt);                                // 左Alt键-抬起.
        rightAltKeyUp = Input.GetKeyUp(KeyCode.RightAlt);                              // 右Alt键-抬起.
        rightMouseButtonDown = Input.GetMouseButtonDown((int)MouseButton.RIGHT);       // 鼠标右键-按下.
        leftMouseButtonDown = Input.GetMouseButtonDown((int)MouseButton.LEFT);         // 鼠标左键-按下.
        leftMouseButton = Input.GetMouseButton((int)MouseButton.LEFT);                 // 鼠标左键-长按.
        rightMouseButton = Input.GetMouseButton((int)MouseButton.RIGHT);               // 鼠标右键-长按.
        rightMouseButtonUp = Input.GetMouseButtonUp((int)MouseButton.RIGHT);           // 鼠标右键-抬起.

        middleMouseButton = Input.GetMouseButton((int)MouseButton.MIDDLE);             // 鼠标中键-按下.  
        middleMouseButtonUp = Input.GetMouseButtonUp((int)MouseButton.MIDDLE);         // 鼠标中键-抬起.
    }

    /// <summary>
    /// 计算距离.
    /// </summary>
    private void RecalcDistance()
    {
        Vector3 checkFarPos = m_Camera.transform.position + m_Camera.transform.rotation * (Vector3.forward * 1000);
        if (Physics.Linecast(m_Camera.transform.position, checkFarPos, out raycastHit))
        {
            // 如果相机中心有物体，则以物体到相机为距离
            distance = raycastHit.distance;
            if (selectedObj == null)
            {
                selectedObj = raycastHit.collider.gameObject;
            }
        }
    }

    #endregion

    #region 切换视角

    /// <summary>
    /// 计算投影矩阵.
    /// </summary>
    private void CalculateProjMatrix()
    {
        currentProjMat = m_Camera.projectionMatrix;

        float aspect = m_Camera.aspect;
        float fov = m_Camera.fieldOfView;
        float size = m_Camera.orthographicSize;
        float far = m_Camera.farClipPlane;
        float near = m_Camera.nearClipPlane;
        float tan = Mathf.Tan(Mathf.Deg2Rad * fov * 0.5f);

        if (m_Camera.orthographic)
        {
            // 启动时相机是正交的
            viewType = ViewType._2D;
            fov = SetFovBySize(size);
        }
        else
        {
            // 启动时相机是透视的
            viewType = ViewType._3D;
            size = SetSizeByFov(fov);
        }

        // 透视投影矩阵.
        defaultPersProjMat = new Matrix4x4();
        //defaultPersProjMat = Matrix4x4.Perspective(fov, aspect, near, far);           // 透视矩阵也可直接调用这个来计算.
        defaultPersProjMat.SetRow(0, new Vector4(1.0f / (tan * aspect), 0, 0, 0));
        defaultPersProjMat.SetRow(1, new Vector4(0, 1.0f / tan, 0, 0));
        defaultPersProjMat.SetRow(2, new Vector4(0, 0, -(far + near) / (far - near), -2 * far * near / (far - near)));
        defaultPersProjMat.SetRow(3, new Vector4(0, 0, -1, 0));

        // 正交投影矩阵.
        defaultOrthProjMat = new Matrix4x4();
        defaultOrthProjMat.SetRow(0, new Vector4(1.0f / (aspect * size), 0, 0, 0));
        defaultOrthProjMat.SetRow(1, new Vector4(0, 1.0f / size, 0, 0));
        defaultOrthProjMat.SetRow(2, new Vector4(0, 0, -2f / (far - near), -(far + near) / (far - near)));
        defaultOrthProjMat.SetRow(3, new Vector4(0, 0, 0, 1));
    }

    /// <summary>
    /// 切换视角.
    /// </summary>
    private void SwitchViewType()
    {
        if (isChangingViewType)
        {
            viewTypeLerpTime += Time.deltaTime * 2.0f;
            if (viewType == ViewType._2D)
            {
                // 切换到正交视图.
                currentProjMat = Utils.Math.MatrixLerp(currentProjMat, defaultOrthProjMat, viewTypeLerpTime);
            }
            else
            {
                // 切换到透视视图.
                currentProjMat = Utils.Math.MatrixLerp(currentProjMat, defaultPersProjMat, viewTypeLerpTime);
            }
            m_Camera.projectionMatrix = currentProjMat;
            if (viewTypeLerpTime >= 1.0f)
            {
                isChangingViewType = false;
                viewTypeLerpTime = 0f;

                if (viewType == ViewType._2D)
                {
                    m_Camera.orthographic = true;
                }
                else
                {
                    m_Camera.orthographic = false;
                }
                m_Camera.ResetProjectionMatrix();
            }
        }
    }

    /// <summary>
    /// 设置将要切换的视角.
    /// </summary>
    /// <param name="targetViewType">目标视角.</param>
    private void SetViewType(ViewType targetViewType)
    {
        if (viewType != targetViewType)
        {
            viewType = targetViewType;
            isChangingViewType = true;
            viewTypeLerpTime = 0f;
        }
    }

    /// <summary>
    /// 根据正交相机的size设置对应透视相机的fov
    /// </summary>
    /// <param name="size">正交相机高度的一半，即orthographicSize</param>
    private float SetFovBySize(float size)
    {
        float fov = 2.0f * Mathf.Atan(size / distance) * Mathf.Rad2Deg;
        m_Camera.fieldOfView = fov;
        return fov;
    }

    /// <summary>
    /// 根据透视相机的fov设置对应正交相机的即orthographicSize
    /// </summary>
    /// <param name="fov">透视相机的fov</param>
    private float SetSizeByFov(float fov)
    {
        float size = distance * Mathf.Tan(fov * 0.5f * Mathf.Deg2Rad);
        m_Camera.orthographicSize = size;
        return size;
    }

    #endregion

    #region 拉近拉远

    /// <summary>
    /// 拉近拉远.
    /// </summary>
    /// <remarks>鼠标滚轮滚动，向上滚动拉近相机，向下滚动拉远相机</remarks>
    private void Zoom()
    {
        float scrollWheelValue = Input.GetAxis(MOUSESCROLLWHEEL);
        if (!Utils.Math.IsEqual(scrollWheelValue, 0f))
        {
            // scrollWheelValue：滚轮向上为+ 向下为-
            // 同时滚轮向上，拉近相机；滚轮向下，拉远相机
            distance -= scrollWheelValue * zoomSpeed;
            distance = Mathf.Clamp(distance, minDistance, maxDistance);

            m_Camera.transform.position = lookAroundPos - m_Camera.transform.rotation * (Vector3.forward * distance);

            // 相机距离改变后需同时修改fov或orthographicSize以及投影矩阵，保证正交/透视视图切换效果
            CalculateProjMatrix();
        }
    }

    #endregion

    #region 拖动

    private bool isDraging = false;
    private Vector3 lastMousePos;

    /// <summary>
    /// 拖动.
    /// </summary>
    /// <remark>长按鼠标中键拖动</remark>
    private void Drag()
    {
        // 鼠标中键拖动相机.
        if (middleMouseButton)
        {
            if (isDraging == false)
            {
                isDraging = true;
                // 设置小手指针.
                SetCursor(CursorType.HAND);

                lastMousePos = Input.mousePosition;
            }
            else
            {
                Vector3 newMousePos = Input.mousePosition;
                Vector3 delta = newMousePos - lastMousePos;
                m_Camera.transform.position += CalcDragLength(m_Camera, delta, distance);
                lastMousePos = newMousePos;

                // 相机移动，重新设置目标位置.
                ResetLookAroundPos();
            }
        }
        if (middleMouseButtonUp)
        {
            isDraging = false;
            // 恢复默认指针.
            SetCursor(CursorType.DEFAULT);
        }
    }

    /// <summary>
    /// 计算拖拽距离.
    /// </summary>
    /// <param name="camera">相机</param>
    /// <param name="mouseDelta">鼠标移动距离</param>
    /// <param name="distance">相机距离观察物体的距离</param>
    private Vector3 CalcDragLength(Camera camera, Vector2 mouseDelta, float distance)
    {
        float rectHeight = -1;
        float rectWidth = -1;
        if (camera.orthographic)
        {
            rectHeight = 2 * camera.orthographicSize;
            //rectWidth = rectHeight / camera.aspect;
        }
        else
        {
            rectHeight = 2 * distance * Mathf.Tan(camera.fieldOfView * 0.5f * Mathf.Deg2Rad);
        }
        rectWidth = Screen.width * rectHeight / Screen.height;
        Vector3 moveDir = -rectWidth / Screen.width * mouseDelta.x * camera.transform.right - rectHeight / Screen.height * mouseDelta.y * camera.transform.up;

        return moveDir;
    }

    #endregion

    #region 360°旋转观察

    /// <summary>
    /// 360°旋转查看.
    /// </summary>
    /// <remark>Alt+鼠标左键 或 鼠标右键</remark>
    private void LookAround()
    {
        if (leftAltKeyDown || rightAltKeyDown || rightMouseButtonDown)
        {
            SetCursor(CursorType.EYE);

            angle_X = m_Camera.transform.eulerAngles.y;
            angle_Y = m_Camera.transform.eulerAngles.x;
            angle_Z = m_Camera.transform.eulerAngles.z;
        }

        if ((leftAltKey && leftMouseButton)
            || (rightAltKey && leftMouseButton)
            || (!leftAltKey && !rightAltKey && rightMouseButton))
        {
            float deltaX = Input.GetAxis(MOUSEX);
            float deltaY = Input.GetAxis(MOUSEY);

            // 相机朝前和朝后,与鼠标的滑动方向相反
            if ((angle_Y > 90f && angle_Y < 270f) || (angle_Y < -90 && angle_Y > -270f))
            {
                angle_X -= deltaX * rotateSensitivity;
            }
            else
            {
                angle_X += deltaX * rotateSensitivity;
            }
            angle_Y -= deltaY * rotateSensitivity;

            angle_X = Utils.Math.ClampAngle(angle_X, -365, 365);
            angle_Y = Utils.Math.ClampAngle(angle_Y, -365, 365);

            SetCameraPos();
        }

        if (leftAltKeyUp || rightAltKeyUp || rightMouseButtonUp)
        {
            SetCursor(CursorType.DEFAULT);
        }
    }

    private void SetCameraPos()
    {
        Quaternion rotation = Quaternion.Euler(angle_Y, angle_X, angle_Z);
        Vector3 dir = Vector3.forward * -distance;
        m_Camera.transform.rotation = rotation;
        m_Camera.transform.position = lookAroundPos + rotation * dir;
    }

    #endregion

    #region 聚焦选中物体

    /// <summary>
    /// 聚焦选中物体.
    /// </summary>
    private void Focus()
    {
        if (leftMouseButtonDown)
        {
            Ray ray = m_Camera.ScreenPointToRay(Input.mousePosition);

            // Scene视图绘制射线方便测试.
            //Debug.DrawLine(ray.origin, ray.origin + ray.direction * raycastMaxDistance, Color.red, 3f);

            if (Physics.Raycast(ray, out raycastHit, raycastMaxDistance, raycastLayerMask))
            {
                selectedObj = raycastHit.collider.gameObject;
            }
            else
            {
                selectedObj = null;
                ResetLookAroundPos();
            }
        }

        if (selectedObj != null)
        {
            if (Input.GetKeyDown(KeyCode.F))
            {
                isFocusing = true;
                focusTime = 0f;
                cameraInitForward = m_Camera.transform.forward;
                focusTargetForward = Vector3.Normalize(selectedObj.transform.position - m_Camera.transform.position);

                focusInitPos = m_Camera.transform.position;
                distance = focusDistance;
                focusTargetPos = selectedObj.transform.position - focusTargetForward * distance;
            }
        }

        if (isFocusing)
        {
            focusTime += Time.deltaTime * focusSpeed;
            Vector3 forward = Vector3.Lerp(cameraInitForward, focusTargetForward, focusTime);
            m_Camera.transform.rotation = Quaternion.LookRotation(forward);

            m_Camera.transform.position = Vector3.Lerp(focusInitPos, focusTargetPos, focusTime);

            if (focusTime >= 1f)
            {
                // 聚焦完毕.
                focusTime = 0f;
                isFocusing = false;
                m_Camera.transform.rotation = Quaternion.LookRotation(focusTargetForward);
                m_Camera.transform.position = focusTargetPos;

                // 设置观察中心.
                lookAroundPos = selectedObj.transform.position;
            }
        }
    }

    #endregion

    #region 各种视图

    /// <summary>
    /// 正视图.
    /// </summary>
    private void Front()
    {
        angle_X = 180;
        angle_Y = 0;

        SetCameraPos();
    }

    /// <summary>
    /// 后视图.
    /// </summary>
    private void Back()
    {
        angle_X = 0;
        angle_Y = 0;

        SetCameraPos();
    }

    /// <summary>
    /// 右视图.
    /// </summary>
    private void Right()
    {
        angle_X = -90;
        angle_Y = 0;

        SetCameraPos();
    }

    /// <summary>
    /// 左视图.
    /// </summary>
    private void Left()
    {
        angle_X = 90;
        angle_Y = 0;

        SetCameraPos();
    }

    /// <summary>
    /// 上视图(俯视图).
    /// </summary>
    private void Top()
    {
        angle_X = 0;
        angle_Y = 90;

        SetCameraPos();
    }

    /// <summary>
    /// 下视图.
    /// </summary>
    private void Down()
    {
        angle_X = 0;
        angle_Y = -90;

        SetCameraPos();
    }

    #endregion

    #region 放大/缩小

    /// <summary>
    /// 放大缩小.
    /// </summary>
    private void Magnifier()
    {
        if ((leftAltKey || rightAltKey) && rightMouseButton)
        {
            if (lastMousePosFov.Equals(Vector3.zero))
            {
                lastMousePosFov = Input.mousePosition;
                SetCursor(CursorType.MAGNIFIER);
            }

            float deltaX = lastMousePosFov.x - Input.mousePosition.x;

            if (viewType == ViewType._2D)
            {
                // 透视视图改size
                float size = m_Camera.orthographicSize + deltaX * 0.01f;
                size = Mathf.Clamp(size, 1.0f, 8f);
                m_Camera.orthographicSize = size;

                // 调节size需同时修改相机透视模式下的fov
                SetFovBySize(size);
            }
            else
            {
                // 透视视图改fov
                float fov = m_Camera.fieldOfView + deltaX * fovSensitivity;
                fov = Mathf.Clamp(fov, minFov, maxFov);
                m_Camera.fieldOfView = fov;

                // 调节了fov需同时修改相机正交模式下的size
                SetSizeByFov(fov);
            }

            lastMousePosFov = Input.mousePosition;
        }

        if (rightMouseButtonUp)
        {
            SetCursor(CursorType.DEFAULT);
            lastMousePosFov = Vector3.zero;

            // 重新计算投影矩阵.
            CalculateProjMatrix();
        }
    }

    #endregion
}
93年大叔
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Unity Game窗口中还原Scene窗口摄像机操作
龙____
05-16 4004
最近在弄AI，调试程序的时候总是要调整摄像机的视角。灰常不爽然后自己写了个脚本。比较习惯Scene窗口下的摄像机操作所以就仿造了一个一样的操作脚本。首相我们要知道Scene下的摄像机的操作方式 WASD分别控制前后左右的位移，注意：位移是已当前视角为基准的。 QE分别控制上下，注意：这个是针对世界坐标的。 鼠标右键控制自由视角旋转。（难点） 对于第一条来说，主要的问题就是现在玩家朝向问题。我怎么知道
[Unity]Game视图和Scene视图显示一样碰撞体的辅助线界面
BuladeMian的博客，菜得抠脚，菜得真实
04-09 2827
偶然间 Game视图也显示了 和Scene 视图一样的 碰撞体的 边界以及 UGUI 的边框。 当Gizmos选项都勾选 当Scene视图选中Gizmos 当Scene视图没有选中Gizmos Game视图选中Gizmos Game视图没有选中Gizmos 当Gizmos选项都没有勾选 ...
Unity3D相机操控(完整模拟Scene视图操作)
老王的博客
03-14 6519
1. 需求   一直想把Scene视图相机的操作复制到Game视图来，之前工作实现了一部分，但是不完善，前几天晚上抽空重新写了个。   在写的过程中遇到一些问题，这里记录一下。   Scene视图的操作总结如下：   1. 正交/透视视图的缓动切换    2. 滚动鼠标滚轮能够拉近、缩远   3. 按住鼠标中键能够上下左右拖拽相机   4. ALT+鼠标左键 或 按住鼠标右键 可360查看场景  ...
【unity】Game视图与Scene视图同步
xinjaystudio的博客
08-17 8876
一.应用背景 在大中型项目中，经常需要Game视图和Scene视图实时同步，以便观察分析场景的渲染效果，因此我们需要实时将Game视图相机调整到Scene视图中场景观察相机的状态，主要涉及到Game视图相机的位置（position）及旋转角（rotation）的调整。 二.设计思想 1.通过SceneView.lastActiveSceneView.camera获取当前Scene视图中的观察相机； 2.每帧调整Game视图相机的position和rotation； 3.为了保证脚本在编辑器模式下也
Unity鼠标控制物体位移，旋转，缩放，类似于Scene视角的操作
weixin_40650916的博客
03-17 896
最近项目中的需求，就是可以创建模型，然后创建出来的模型可以随意摆放，随意缩放，旋转，看看录屏吧，代码太多了，就直接上unitypackage包，自取。链接：https://pan.baidu.com/s/1XMJXYPNbE_poivPxxp9UMw。Unity鼠标控制物体位移，旋转，缩放，类似于Scene视角。
Unity3D：Scene 视图摄像机
ygtu2018的博客
06-16 1675
摄像机设置菜单包含用于配置 Scene 视图摄像机的选项。这些调整不会影响带有摄像机组件的游戏对象上的设置。在飞越模式中，可以更改移动过程中摄像机的速度。为此，请使用鼠标滚轮或在触控板上拖动两根手指。还可以在脚本中使用 SceneView.CameraSetting API 来配置摄像机。：要将属性重置为默认值，请单击摄像机设置菜单右上角中的齿轮图标，然后选择。要访问摄像机设置菜单，请单击 Scene 视图工具栏中的摄像机图标。Scene 视图工具栏的上下文中的摄像机设置菜单。整理翻译，转载请注明出处！
Tips7:Unity中 Scene视图 和 Game视图 中 视角(Camera)的控制
weixin_30945039的博客
10-05 1165
选中你要改变的相机,然后点击GameObject-->Align With View 选项(快捷键Ctrl+Shift+F)使相机视角和当前Sence视图中一样 通过这样可以控制在Game视图(也就是运行中)中的样子. 相反的,也可以通过选择游戏物体并点击GameObject-->Align View to Selected 选项的方法,来控制Scene中的视图: 转...
码云下载Game视图选择物体unitypackage.txt
02-19
Game视图选择Scene物体
unity camera sync（摄像机同步）
06-07
包含两种模式： 第一种. 操作 scene里的 场景摄像机 同步 Game 视图里的 maincamera 第二种. 操作maincamera摄像机 同步 scene里的 场景摄像机
Game-Tools-Intro：Unity中的游戏工具简介
02-24
Unity编辑器提供了直观的界面，包括层次视图(Hierarchy)、场景视图(Scene View)、游戏视图(Game View)、项目视图(Project View)和Inspector视图。这些视图帮助开发者组织游戏对象、调整场景、预览游戏效果以及查看和...
Unity中改模型得轴心点
10-20
6. **检查结果**：在Game视图中预览对象，确认轴心点是否按预期工作。如果需要，可以重复以上步骤进行微调。 除了手动选择，Unity还提供了其他方法来调整轴心点： - **Center Pivot**：在Transform组件中，点击...
Unity3D中文菜单手册
12-28
**网(Mesh)**、**粒子(Particles)**、**物理(Physics)**、**音频(Audio)**、**渲染(Rendering)**、**杂项(Miscellaneous)**、**脚本(Scripts)**和**摄像机控制(Camera-Control)**：这些是Unity3D中可添加到游戏对象...
Unity中Scene场景的视角设置成Game视图中的相机视角
qq_1208409371的博客
12-03 3289
最近写了一个超级实用的一个工具,就是把Game视图的相机视角设置成Scene视图的场景视角, 方便定位Scene视图的物体,调试,查找错误,分享给大家,代码如下 [MenuItem("扩展/跟踪游戏摄像机")] public static void FollowGameCamera() { var camera = Camera.allCameras.FirstOrDefault(); SceneView.lastActiveSceneView
unity scene场景调整好后让game窗口的视角与scene相同
moonlightpeng的博客
09-08 2767
即scene的视角与game的一样则。调整scene中场景视角。如果要实现相反的功能。
Unity3D基础5：摄像机与Game视图
加载中...
02-02 8499
一、Game视图 游戏(Game)视图：游戏的预览（运行）窗口。 游戏视图为场景中的摄像机视角 当点击“播放”按钮后，视图会自动切换到游戏视图进行预览；再一次的点击“播放”按钮，就可以退出游戏的运行状态 游戏在运行状态时，做的任何操作都不会被保留 二、基本组件：摄像机 摄像机(Camera)就相当于我们的眼睛，用于观察我们的游戏世界 摄像机的观察区间叫做“视锥体”，...
Unity中实现Scene模式下的鼠标操作效果
liamzhu的专栏
11-11 1021
using System.Collections; using System.Collections.Generic; using UnityEngine; public class CameraAction : MonoBehaviour { public float mouseScrollSpeed = 40, //滚滚轮放大缩小速度 mouseDra...
Unity研究 粒子在Scene上显示，但在Game视图不显示的问题
cuijiahao的专栏
10-26 6442
如果你确认的Scene视图没有问题，试着检查一下 物体的Layer 与 camera的Culling mask是否一致，或者说camera的Culling mask中是否包含物体的layer 这是相机的渲染层次，只有将物体的Layer选成这个层次才能被相机渲染出来 ...
Unity在Scene窗口有显示，在Game窗口不显示
热门推荐
HJS852275113的博客
07-07 3万+
今天在修改项目中的图片布局时出现了一个问题，我新添加了一个sprite，由于这个新的图片在一个新的图集中，所以无法嵌入到之前的几个图片的中间，所以我就新建了一个Panel来放这个图片和这个图片上层的几个图片。结果出现了一个问题，这个新建的panel下的所有的子物体都显示不了了，今天无意中在一个视频中发现，原来是Layer的问题，将Panel的Layer修改成与camera的Culling mask
GAMES104：05游戏引擎中的渲染系统2：渲染中的光照、材质和shader-学习笔记
最新发布
噗噗噗的博客
07-24 1231
PBR+IBL。
如何在unity的game视图中绘制一个视椎体
03-14
你可以使用Unity的Gizmos功能来绘制一个视椎体。首先，在脚本中使用Gizmos.DrawFrustum函数来绘制视椎体。你需要提供视椎体的位置、方向、视角、近裁剪面和远裁剪面等参数。然后，在Unity的Scene视图中选择你的游戏对象，你将在Game视图中看到绘制的视椎体。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值