unity鼠标控制物体旋转放大缩小，unity安卓手指控制物体旋转，放大缩小

最新推荐文章于 2024-06-04 11:22:56 发布
最新推荐文章于 2024-06-04 11:22:56 发布
阅读量1.5k 收藏 13
点赞数
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40650916/article/details/83383499
版权

PC端鼠标左键控制相机平面移动，按住鼠标右键拖动鼠标相机围绕物体旋转，滚轮相机朝着鼠标位子缩放


安卓端一个手指活动屏幕模型旋转，一个手指长按屏幕后再滑动模型平面移动，两个手指实现模型朝着两手指中间放大缩小

怎么使用，看Update（）里面注释

代码如下

直接复制，再将相应参数设置一下就可以用了就可以用了

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CameraMove : MonoBehaviour
{

    public static CameraMove instance;
    [Header("模型以及相机初始位置，自动初始化")]
    public Vector3 cameraInitialPos;
    public Vector3 cameraInitialRot;
    public Vector3 modelInitialRot;

    [Header("要控制的物体")]
    [Tooltip("要控制的相机")]
    public Camera myCamera;
    [Tooltip("相机缩放的焦点")]
    public Transform zoomTarget;
    [Tooltip("要观察的模型")]
    public Transform model;

    [Header("设置的参数")]
    [Tooltip("缩放速率")]
    public int zoomRate = 40;
    [Tooltip("最远观察距离")]
    public float maxObservationDis;
    [Tooltip("最近观察距离")]
    public float minObservationDis;
    [Tooltip("水平方向最大移动距离")]
    public float maxDisH = 2f;
    [Tooltip("竖直方向最大移动距离")]
    public float maxDisV = 5f;
    [Tooltip("水平竖直平面移动速度")]
    public float deltaMoveSpeed = 2f;
    [Tooltip("转动时的速度")]
    public float rotSpeed = 2f;
    [Tooltip("竖直方向最大旋转角度")]
    public float maxRotV = 90f;

    [Header("自动获取的变量，不需赋值")]
    public float currentObservationDis;
    public float mouseX;
    public float mouseY;
    public Vector3 zoomDir;
    Vector3 mouseScreenPos;
    Vector3 mouseWorldPos;
    float rotV = 0f;

    /// <summary>
    /// 手指控制的时候各个变量
    /// </summary>
    Touch firstFinger;
    Touch secondFinger;
    TouchType touchType;
    Vector2 deltaPos;
    bool isStartIJudgeLongPress;
    bool isStartIZoomByTwoFinger;
    float twoFingerOldDis;
    float twoFingerNewDis;
    void Awake()
    {
        Init();
    }
    // Update is called once per frame
    void Update()
    {
        //PC端调用Move()方法，功能：鼠标左键控制相机平面移动，按住鼠标右键拖动鼠标相机围绕物体旋转，滚轮相机朝着鼠标位子缩放
        //Move();


        //安卓端调用此方法功能：一个手指活动屏幕模型旋转，一个手指长按屏幕后再滑动模型平面移动，两个手指实现模型朝着两手指中间放大缩小
         //MoveByFinger();
    }
    /// <summary>
    /// 初始化
    /// </summary>
    public void Init()
    {
        instance = this;
        cameraInitialPos = myCamera.transform.position;
        cameraInitialRot = myCamera.transform.localEulerAngles;
        modelInitialRot = model.localEulerAngles;
    }
    /// <summary>
    /// PC端鼠标控制移动方法
    /// </summary>
    private void Move()
    {
        MoveByMouse0();
        ZoomByScrollWheel();
        RotByMouse1();
    }
    /// <summary>
    /// 安卓端通过手指控制
    /// </summary>
    private void MoveByFinger()
    {
        if (Input.touchCount==0)
        {
            touchType = TouchType.NoneFinger;
            StopAllCoroutines();
            isStartIJudgeLongPress = false;
            isStartIZoomByTwoFinger = false;
        }
        else if (Input.touchCount ==1)
        {
           
            if (touchType==TouchType.NoneFinger&&!isStartIJudgeLongPress)
            {
                isStartIJudgeLongPress = true;
                StartCoroutine(IJudgeLongPress());
                firstFinger = Input.GetTouch(0);
            }
        }
        else if (Input.touchCount == 2)
        {
            touchType = TouchType.TwoFingerZoom;
        }
        switch (touchType)
        {
            case TouchType.NoneFinger:
                break;
            case TouchType.OneFingerMove:
                MoveByOneFinger();
                break;
            case TouchType.OneFingerRot:
                RotByOneFinger();
                break;
            case TouchType.TwoFingerZoom:
                if (!isStartIZoomByTwoFinger)
                {
                    isStartIZoomByTwoFinger = true;
                    StartCoroutine("IZoomByTwoFinger"); 
                }
                break;
            default:
                break;
        }
       
    }
    /// <summary>
    /// 判断是否长按
    /// </summary>
    /// <returns></returns>
    IEnumerator IJudgeLongPress()
    {
       
        if (Input.touchCount!=0)
        {
            Vector2 firstPos = Input.GetTouch(0).position;
            yield return new WaitForSeconds(0.2f);
            if (Input.touchCount != 0)
            {
                Vector2 secondPos = Input.GetTouch(0).position;
                if ((secondPos-firstPos).magnitude<2f)
                {
                    touchType = TouchType.OneFingerMove;
                }
                else
                {
                    touchType = TouchType.OneFingerRot;
                }
            }
            
        }
        
    }
    /// <summary>
    /// 按住鼠标左键拖动
    /// </summary>
    public void MoveByMouse0()
    {
        if (Input.GetMouseButton(0))
        {
            if (Input.GetAxis("Mouse X") < 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(true, true);
            }
            else if (Input.GetAxis("Mouse X") > 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(true, false);

            }

            if (Input.GetAxis("Mouse Y") < 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(false, true);

            }
            else if (Input.GetAxis("Mouse Y") > 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(false, false);

            }
        }
    }
    /// <summary>
    /// 通过键盘或者方向键或者点击按钮来移动相机
    /// </summary>
    /// <param name="Hmoving" true表示水平移动></param>
    /// <param name="positiveDir" true表示正向移动></param>
    public void MoveByDeltaDistance(bool Hmoving, bool positiveDir)
    {
        //target.rotation = transform.rotation;
        if (Hmoving)
        {


            if (positiveDir)
            {
                if (myCamera.transform.position.x < maxDisH)
                {
                    myCamera.transform.Translate(Vector3.right * deltaMoveSpeed * Time.deltaTime, Space.Self);
                    //target.Translate(Vector3.right * deltaMoveSpeed * Time.deltaTime);
                }
            }
            else
            {
                if (myCamera.transform.position.x > -maxDisH)
                {
                    myCamera.transform.Translate(Vector3.right * -deltaMoveSpeed * Time.deltaTime, Space.Self);
                    //target.Translate(Vector3.right * -deltaMoveSpeed * Time.deltaTime);
                }
            }
        }
        else
        {
            if (positiveDir)
            {

                if (myCamera.transform.position.y < maxDisH)
                {
                    myCamera.transform.Translate(transform.up * deltaMoveSpeed * Time.deltaTime, Space.World);
                    //target.Translate(transform.up * deltaMoveSpeed * Time.deltaTime, Space.World); 
                }
            }
            else
            {
                if (myCamera.transform.position.y > -maxDisH)
                {
                    myCamera.transform.Translate(transform.up * -deltaMoveSpeed * Time.deltaTime, Space.World);
                    //target.Translate(transform.up * -deltaMoveSpeed * Time.deltaTime, Space.World); 
                }

            }
        }


    }
    /// <summary>
    /// 滑轮键缩放
    /// </summary>
    public void ZoomByScrollWheel()
    {
        float scrollWheel = Input.GetAxis("Mouse ScrollWheel");
        if (scrollWheel != 0)
        {

            Vector3 zoomTargetScreenPos = myCamera.WorldToScreenPoint(zoomTarget.position);
            mouseScreenPos = new Vector3(Input.mousePosition.x, Input.mousePosition.y, zoomTargetScreenPos.z);
            zoomTarget.position = myCamera.ScreenToWorldPoint(mouseScreenPos);
            Ray ray = myCamera.ScreenPointToRay(Input.mousePosition);
            RaycastHit hitInfo;
            if (Physics.Raycast(ray, out hitInfo))
            {
                zoomTarget.position = hitInfo.point;
            }
        }
        currentObservationDis = (zoomTarget.position - myCamera.transform.position).magnitude;
        zoomDir = (zoomTarget.position - myCamera.transform.position).normalized;
        Zoom(zoomDir, scrollWheel * Time.deltaTime * zoomRate);
    }

    /// <summary>
    /// 相机向物体移动
    /// </summary>
    /// <param name="zoomDir">移动方向</param>
    /// <param name="zoomDis">移动距离</param>
    public void Zoom(Vector3 zoomDir, float zoomDis)
    {
        //target.Translate(zoomDir * zoomDis, Space.World);
        if (zoomDis < 0 && currentObservationDis > maxObservationDis)
        {
            return;
        }
        else if (zoomDis > 0 && currentObservationDis < minObservationDis)
        {
            return;
        }
        myCamera.transform.Translate(zoomDir * zoomDis, Space.World);
    }
    /// <summary>
    /// 鼠标右键按住转动摄像机
    /// </summary>
    public void RotByMouse1()
    {
        if (Input.GetMouseButton(1))
        {

            mouseX = Input.GetAxis("Mouse X");
            mouseY = Input.GetAxis("Mouse Y");
            if (Mathf.Abs(mouseX) > Mathf.Abs(mouseY))
            {
                if (mouseX < 0)
                {
                    model.Rotate(Vector3.up, rotSpeed);
                    //myCamera.transform.RotateAround(model.transform.position, Vector3.up, -rotSpeed);
                }
                else if (mouseX > 0)
                {
                    model.Rotate(Vector3.up, -rotSpeed);
                    //myCamera.transform.RotateAround(model.transform.position, Vector3.up, rotSpeed);

                }
            }
            else if (Mathf.Abs(mouseX) < Mathf.Abs(mouseY))
            {
                if (mouseY < 0)
                {
                    if (rotV < maxRotV)
                    {
                        myCamera.transform.RotateAround(model.transform.position, Vector3.right, rotSpeed);
                        rotV += rotSpeed;
                    }
                }
                else if (mouseY > 0)
                {
                    if (rotV > -maxRotV)
                    {
                        myCamera.transform.RotateAround(model.transform.position, Vector3.right, -rotSpeed);
                        rotV -= rotSpeed;
                    }
                    //if (myCamera.transform.localEulerAngles.x >=90)
                    //{
                    //    myCamera.transform.RotateAround(model.transform.position, Vector3.right, -rotSpeed);
                    //}
                }
            }
        }
    }
    /// <summary>
    /// 一根手指拖动
    /// </summary>
    public void MoveByOneFinger()
    {
        
        firstFinger = Input.GetTouch(0);

        if (firstFinger.phase==TouchPhase.Moved)
        {
            deltaPos = firstFinger.deltaPosition;
            if (deltaPos.x < 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(true, true);
            }
            else if (deltaPos.x > 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(true, false);

            }

            if (deltaPos.y < 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(false, true);

            }
            else if (deltaPos.y > 0)
            {
                //SetMoveSpeed(2.0f);
                MoveByDeltaDistance(false, false);

            } 
        }
    }
    /// <summary>
    /// 一根手指长按转动
    /// </summary>
    public void RotByOneFinger()
    {
        firstFinger = Input.GetTouch(0);
        if (firstFinger.phase == TouchPhase.Moved)
        {
            deltaPos = firstFinger.deltaPosition;
            mouseX = deltaPos.x;
            mouseY = deltaPos.y;
            if (Mathf.Abs(mouseX) > Mathf.Abs(mouseY))
            {
                if (mouseX < 0)
                {
                    model.Rotate(Vector3.up, rotSpeed);
                }
                else if (mouseX > 0)
                {
                    model.Rotate(Vector3.up, -rotSpeed);

                }
            }
            else if (Mathf.Abs(mouseX) < Mathf.Abs(mouseY))
            {
                if (mouseY < 0)
                {
                    if (rotV < maxRotV)
                    {
                        myCamera.transform.RotateAround(model.transform.position, Vector3.right, rotSpeed);
                        rotV += rotSpeed;
                    }
                }
                else if (mouseY > 0)
                {
                    if (rotV > -maxRotV)
                    {
                        myCamera.transform.RotateAround(model.transform.position, Vector3.right, -rotSpeed);
                        rotV -= rotSpeed;
                    }
                    //if (myCamera.transform.localEulerAngles.x >=90)
                    //{
                    //    myCamera.transform.RotateAround(model.transform.position, Vector3.right, -rotSpeed);
                    //}
                }
            } 
        }
    }
    /// <summary>
    /// 两根手指缩放协程
    /// </summary>
    public IEnumerator IZoomByTwoFinger()
    {
        Vector2 centerPos;
        while (true)
        {
            firstFinger = Input.GetTouch(0);
            secondFinger = Input.GetTouch(1);
            twoFingerOldDis = Vector2.Distance(firstFinger.position, secondFinger.position);
            centerPos = (firstFinger.position + secondFinger.position) / 2;
            yield return 0;
            firstFinger = Input.GetTouch(0);
            secondFinger = Input.GetTouch(1);
            twoFingerNewDis = Vector2.Distance(firstFinger.position, secondFinger.position);
            float scrollWheel = twoFingerNewDis - twoFingerOldDis;
            if (scrollWheel != 0)
            {

                Vector3 zoomTargetScreenPos = myCamera.WorldToScreenPoint(zoomTarget.position);
                mouseScreenPos = new Vector3(centerPos.x, centerPos.y, zoomTargetScreenPos.z);
                zoomTarget.position = myCamera.ScreenToWorldPoint(mouseScreenPos);
                Ray ray = myCamera.ScreenPointToRay(centerPos);
                RaycastHit hitInfo;
                if (Physics.Raycast(ray, out hitInfo))
                {
                    zoomTarget.position = hitInfo.point;
                }
            }
            currentObservationDis = (zoomTarget.position - myCamera.transform.position).magnitude;
            zoomDir = (zoomTarget.position - myCamera.transform.position).normalized;
            Zoom(zoomDir, scrollWheel * Time.deltaTime * zoomRate*0.1f);
            if (Input.touchCount!=2)
            {
                isStartIZoomByTwoFinger = false;
                break;
            }
        }
       

    }
    /// <summary>
    /// 复位方法
    /// </summary>
    public void Reset()
    {
        myCamera.transform.position = cameraInitialPos;
        myCamera.transform.localEulerAngles = cameraInitialRot;
        model.localEulerAngles = modelInitialRot;
        rotV = 0;
    }
}
public enum TouchType
{
 NoneFinger,
 OneFingerMove,
 OneFingerRot,
 TwoFingerZoom
}

 

唐-三-藏
关注
  • 0
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
002-实现Unity3d中触摸屏幕控制物体的旋转和缩放 代码实现
Taoger的博客
05-03 7617
1、直接帮到物体的身上就可以了 using UnityEngine; using System.Collections; using System.IO; public class hehe : MonoBehaviour {     private Touch oldTouch1;  //上次触摸点1(手指1)       private Touch oldTouch2;
Unity滑动屏幕控制物体的旋转
Rookie0518的博客
06-13 8044
Unity滑动屏幕控制物体的旋转
unity 手指旋转物体双手控制相机的远近
wf2537的博客
05-11 2195
using UnityEngine; using System.Collections; using UnityEngine.UI; public class touchmove : MonoBehaviour {     float speed =0.1f;     public GameObject Target;     public float minDistance;   
【Unity开发小技巧】模型单指旋转双指缩放功能代码（多种情况）
热门推荐
纯技术流日常开发商业开发记录总结等
02-20 1万+
欢迎加入Unity业内qq交流群：956187480 qq扫描二维码加群 1.pc端通过鼠标中键调整相机的FieldOfView属性的值（会发生形变不建议） void Update() { if (Input.GetAxis("Mouse ScrollWheel") < 0) { Camera.main....
Unity 安卓端单指滑动，双指缩放代码，可控制角度
最新发布
qq_44148565的博客
06-04 206
unity 手指操作相机围绕中心点查看
Unity鼠标操作（平移、旋转、缩放）
04-23
完整的工程源码，利用鼠标左键实现平移操作，利用鼠标右键实现旋转操作，利用鼠标滚轮实现缩放操作。具体讲解见https://blog.csdn.net/sunbowen63/article/details/89325314
Unity 安卓屏幕触碰 旋转、移动以及缩放功能
Maddie_Mo的博客
04-15 5298
Unity 安卓屏幕触碰 旋转、移动以及缩放功能 Unity 安卓屏幕触碰 旋转、移动以及缩放 引用资料： 1.https://blog.csdn.net/m0_37184457/article/details/78720228 2.http://blog.sina.com.cn/s/blog_54d4af0e0102x20i.html 代码很简单没有难度，随便 康一康 就会了。 Rotation...
unity 根据鼠标的移动来旋转物体Rotate
wf2537的博客
05-11 1152
using UnityEngine; using System.Collections; public class RotateObj : MonoBehaviour {     float horizontalSpeed = 2.0f;     float verticalSpeed = 2.0f;     // Update is called once per frame  
Unity鼠标，触屏控制物体旋转缩放（鼠标和触屏通用）.zip
11-05
本教程将基于提供的“Unity鼠标，触屏控制物体旋转缩放（鼠标和触屏通用）.zip”资源，详细解释如何通过鼠标和触屏实现这一功能，并探讨ChinarSmoothUi3DCamera.cs脚本的关键知识点。 首先，ChinarSmoothUi3DCamera...
unity 鼠标控制物体旋转
05-23
unity 鼠标控制物体旋转
Unity 鼠标控制场景 旋转 放大 缩小 平移等功能 可自行修改源代码
11-01
1、将下载的cs文件添加作为相机（可以是MainCamera）组件 2、需要设置target目标，可在场景内新建一个空的对象，将空的对象设置在相机的正下方即可，具体...3、鼠标右键旋转、中间放大或缩小、左键平移，可自行更改。
Unity3D实现物体旋转缩放移动效果
12-31
本文实例为大家分享了Unity3D实现物体旋转缩放移动的具体代码，供大家参考，具体内容如下 由于项目运行在安卓上，运用到了插件，比较麻烦。你们可以在触发条件上进行修改，不用插件也可以。 1.下载FingerGestures 插件 下载地址 点击打开链接 2.导入插件,创建场景 将预设Finger Gestures Initializer 拖拽到 Hierarchy 视图中 3.添加脚本，拖拽到摄像机上。创建一个方块拖拽到脚本target 属性上。 using UnityEngine; using System.Collections; public class ObjectControl :
Unity制作的按钮缩放效果
09-02
Unity GUI（简称UGUI）中的常见按钮缩放效果，使用了DoTween作为缓动的方式
Unity3D实现鼠标控制旋转转盘
08-26
Unity3D实现鼠标控制旋转转盘 Unity3D实现鼠标控制旋转转盘是 Unity3D 游戏开发中的一项重要功能。该功能可以让用户通过鼠标控制旋转转盘，实现更加真实的操作体验。在培训模拟考试软件中，这种功能尤其重要，让...
Unity3D场景中对模型旋转放大缩小脚本
02-04
在Unity3D游戏引擎中，模型的旋转、缩放和移动是基本的变换操作，对于构建交互式场景和游戏至关重要。...而这个"Unity3D场景中对模型旋转放大缩小脚本"就是一个很好的起点，它帮助开发者快速实现这些常见但重要的功能。
unity滑动屏幕旋转物体
小超的博客
04-25 3175
超级简单，但是注意，有坑！ 首先创建一个脚本，把下面的代码复制进去就好啦，注意类名要和脚本名一样哦，自己改一下就好啦！ using System.Collections; using System.Collections.Generic; using UnityEngine; public class xz : MonoBehaviour { float speed = 0.1f...
Unity 物体旋转，旋转次数很多时，旋转对象发生偏移
qq_41263535的博客
01-14 1157
产生原因：父对象的Transform组件中的Rotation值不为零 解决方法：父对象的Transform组件中的Rotation值设置为零 备注：在解决问题的过程中，试过很多方法，总是会出现问题，基本确定代码解决不了这个问题，只能改变物体父对象的Transform组件中的Rotation值。 ...
Unity鼠标控制物体 拖动旋转
weixin_42304838的博客
07-24 6670
public class Script2 : MonoBehaviour {     Ray ray;     RaycastHit hit;     GameObject Obj;     Vector3 _Obj屏幕坐标_;     Vector3 _鼠标世界坐标_;     Vector3 _Obj坐标差值_;     float _水平旋转_;     float _垂直旋转_;    ...
Unity自学2——物体跟随鼠标移动，旋转，缩放
LareinaLiang的博客
08-16 455
Unity自学2——物体跟随鼠标移动，旋转，缩放 软件版本：Unity5.0 （当然这个功能不限版本） 注意：Unity中不仅物体有自己的坐标，也有物体在世界范围内的坐标，要根据你需要具体实现的功能来选取参考坐标。 但我更推荐参考世界坐标，即加个Space.World。参考自身坐标最容易出现的问题是，一旦你加入的模型变过方向，那你的移动会完全错位。比如，你左右移动，模型却前后移动。 using System.Collections; using System.Collections.Generic; us
unity鼠标控制物体旋转
06-07
可以通过以下代码实现鼠标控制物体旋转： ```csharp using UnityEngine; public class ObjectRotator : MonoBehaviour { public float rotateSpeed = 5f; // 旋转速度 void Update() { float mouseX = Input....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值