unity 实现类似坐标轴的功能

已于 2023-11-27 17:46:51 修改
阅读量296 收藏 1
点赞数 2
CC 4.0 BY-SA版权
文章标签： unity 游戏引擎
于 2023-11-21 17:40:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WantFK/article/details/134537253
本文介绍了如何在Unity中创建一个可交互的Gizmo组件，支持平移、旋转和特定平面的操作，同时处理了与相机距离相关的旋转问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

资源下载：https://download.csdn.net/download/WantFK/88558389

核心代码

using UnityEngine;
using System.Collections;
using UnityEngine.EventSystems;


namespace AdvancedGizmo
{
    public class Gizmo : MonoBehaviour
    {


        public LayerMask layer;

        public Collider xAxis;
        public Collider yAxis;
        public Collider zAxis;

        public Collider xyPlane;
        public Collider xzPlane;
        public Collider yzPlane;

        public Collider xyRotate;
        public Collider xzRotate;
        public Collider yzRotate;

        public Collider sphereRotate;

        public float rotationSpeed = 4.0f;

        private enum GizmoAxis { X, Y, Z, XY, XZ, YZ, XYRotate, XZRotate, YZRotate, none };
        private GizmoAxis selectedAxis;

        private RaycastHit hit;
        private Ray ray;
        private Plane dragplane;
        private float rayDistance, distance;
        private Vector3 hitvector, mousePos, lookCamera, startDrag, startPos, startDragRot, lookHitPoint;
        private bool dragging, rotating;

        private EventSystem ES;

        private float sphereRadius;

        private GameObject rotationParent;
        // private Transform thisparther; //2

        Vector3 rotationAxis = Vector3.zero;

        public int i = 1;


        void Start()
        {
            ES = EventSystem.current;
            //layer = 1 << layer;
            sphereRadius = sphereRotate.bounds.extents.x;
            ChangeMode();
        }

        void LateUpdate()
        {

            bool mouseOutsideGUI = true;
            if (ES) mouseOutsideGUI = !EventSystem.current.IsPointerOverGameObject();

            if (Input.GetMouseButtonDown(1) && mouseOutsideGUI)
            {
                ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out hit, 1000f, layer))
                {
                    if (hit.transform.parent == transform) ChangeMode();
                }
            }

            if (Input.GetMouseButtonDown(0) && mouseOutsideGUI)
            {

                ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                dragplane = new Plane();

                if (Physics.Raycast(ray, out hit, 1000f, layer))
                {

                    hitvector = hit.point - transform.position;

                    if (hit.collider == xAxis)
                    {
                        selectedAxis = GizmoAxis.X;
                        dragplane.SetNormalAndPosition(transform.up, transform.position);
                    }
                    else if (hit.collider == yAxis)
                    {
                        selectedAxis = GizmoAxis.Y;
                        dragplane.SetNormalAndPosition(transform.forward, transform.position);
                    }
                    else if (hit.collider == zAxis)
                    {
                        selectedAxis = GizmoAxis.Z;
                        dragplane.SetNormalAndPosition(transform.up, transform.position);
                    }
                    else if (hit.collider == xyPlane)
                    {
                        selectedAxis = GizmoAxis.XY;
                        dragplane.SetNormalAndPosition(transform.forward, transform.position);
                    }
                    else if (hit.collider == xzPlane)
                    {
                        selectedAxis = GizmoAxis.XZ;
                        dragplane.SetNormalAndPosition(transform.up, transform.position);
                    }
                    else if (hit.collider == yzPlane)
                    {
                        selectedAxis = GizmoAxis.YZ;
                        dragplane.SetNormalAndPosition(transform.right, transform.position);
                    }
                    else if (hit.collider == xyRotate)
                    {
                        selectedAxis = GizmoAxis.XYRotate;
                        rotationAxis = -transform.forward;
                        lookHitPoint = hit.point - transform.position - Vector3.Project(hit.point - transform.position, transform.forward);
                        //Debug.DrawLine(transform.position, transform.position + lookHitPoint, Color.cyan, 10.0f);
                        dragplane.SetNormalAndPosition(lookHitPoint, hit.point);
                        //DrawPlane(lookHitPoint, transform.position + lookHitPoint, 10.0f);
                        rotating = true;
                    }
                    else if (hit.collider == xzRotate)
                    {
                        selectedAxis = GizmoAxis.XZRotate;
                        rotationAxis = -transform.up;
                        lookHitPoint = hit.point - transform.position - Vector3.Project(hit.point - transform.position, transform.up);
                        Debug.DrawLine(transform.position, transform.position + lookHitPoint, Color.cyan, 10.0f);
                        dragplane=new Plane(lookHitPoint, hit.point);
                        DrawPlane(lookHitPoint, transform.position + lookHitPoint, 10.0f);
                        rotating = true;
                    }
                    else if (hit.collider == yzRotate)
                    {
                        selectedAxis = GizmoAxis.YZRotate;
                        rotationAxis = -transform.right;
                        lookHitPoint = hit.point - transform.position - Vector3.Project(hit.point - transform.position, transform.right);
                        //Debug.DrawLine(transform.position, transform.position + lookHitPoint, Color.cyan, 10.0f);
                        dragplane=new Plane(lookHitPoint, hit.point);
                        //DrawPlane(lookHitPoint, transform.position + lookHitPoint, 10.0f);
                        rotating = true;
                    }
                    else if (hit.collider == sphereRotate)
                    {
                        selectedAxis = GizmoAxis.none;
                        lookCamera = Camera.main.transform.position - transform.position;
                        startDragRot = transform.position + lookCamera.normalized * sphereRadius;
                        dragplane=new Plane(lookCamera.normalized, startDragRot);
                        //DrawPlane(lookCamera.normalized, startDragRot, 10.0f);
                        rotating = true;
                    }
                    else
                    {
                        return;
                    }

                    if (rotating)
                    {

                        Debug.DrawRay(ray.origin, ray.direction*2, Color.white);
                        if (dragplane.Raycast(ray, out rayDistance))
                        {
                            Debug.Log("有1");
                            startDragRot = ray.GetPoint(rayDistance);
                        }
                        else
                        {
                            Debug.Log("无1");
                        }
                        rotationParent = new GameObject();            //1
                        rotationParent.transform.position = transform.position;//1
                        transform.SetParent(rotationParent.transform);//1
                        
                        //thisparther = this.transform.parent;       //2
                        //rotationParent = new GameObject();         //2
                        //rotationParent.transform.parent = thisparther;//2
                        //rotationParent.transform.localPosition = transform.localPosition;//2
                        //transform.SetParent(rotationParent.transform);//2
                    }

                    distance = hit.distance;
                    startDrag = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, distance));
                    startPos = transform.position;
                    dragging = true;
                }
                
            }

            if (dragging || rotating)
            {

                ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                Debug.DrawRay(ray.origin, ray.direction*2 , Color.green);
                if (dragplane.Raycast(ray, out rayDistance))
                {
                    mousePos = ray.GetPoint(rayDistance);
                }
                Vector3 onDrag = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, distance));
                Vector3 translation = onDrag - startDrag;
                Vector3 projectedTranslation = Vector3.zero;

                if (dragging)
                {
                    switch (selectedAxis)
                    {

                        case GizmoAxis.X:
                            {
                                projectedTranslation = Vector3.Project(translation, transform.right);
                                transform.position = startPos + projectedTranslation.normalized * translation.magnitude;
                                break;
                            }
                        case GizmoAxis.Y:
                            {
                                projectedTranslation = Vector3.Project(translation, transform.up);
                                transform.position = startPos + projectedTranslation.normalized * translation.magnitude;
                                break;
                            }
                        case GizmoAxis.Z:
                            {
                                projectedTranslation = Vector3.Project(translation, transform.forward);
                                transform.position = startPos + projectedTranslation.normalized * translation.magnitude;
                                break;
                            }
                        case GizmoAxis.XY:
                        case GizmoAxis.XZ:
                        case GizmoAxis.YZ:
                            {
                                transform.position = mousePos - hitvector;
                                break;
                            }

                    }
                }
                if (rotating)
                {
                    translation = mousePos - startDragRot;
                    //Debug.DrawLine(startDragRot, mousePos, Color.white, 6.0f);

                    Vector3 rotationAxis2 = Vector3.zero;

                    switch (selectedAxis)
                    {
                        case GizmoAxis.XYRotate:
                            {
                                projectedTranslation = translation - Vector3.Project(translation, rotationAxis);
                                //Debug.DrawLine(startDragRot, startDragRot + projectedTranslation, Color.yellow, 1.0f);
                                rotationAxis2 = Vector3.Cross(projectedTranslation, lookHitPoint);
                                //Debug.DrawLine(transform.position, transform.position + 5 * rotationAxis2.normalized, Color.magenta, 1.0f);
                                //Debug.DrawLine(transform.position, transform.position + 5 * rotationAxis.normalized, Color.cyan, 1.0f);
                                break;
                            }
                        case GizmoAxis.XZRotate:
                            {
                                projectedTranslation = translation - Vector3.Project(translation, rotationAxis);
                                //Debug.DrawLine(startDragRot, startDragRot + projectedTranslation, Color.yellow, 1.0f);
                                rotationAxis2 = Vector3.Cross(projectedTranslation, lookHitPoint);
                                //Debug.DrawLine(transform.position, transform.position + 5 * rotationAxis2.normalized, Color.magenta, 1.0f);
                                //Debug.DrawLine(transform.position, transform.position + 5 * rotationAxis.normalized, Color.magenta, 1.0f);
                                break;
                            }
                        case GizmoAxis.YZRotate:
                            {
                                projectedTranslation = translation - Vector3.Project(translation, rotationAxis);
                                //Debug.DrawLine(startDragRot, startDragRot + projectedTranslation, Color.yellow, 1.0f);
                                rotationAxis2 = Vector3.Cross(projectedTranslation, lookHitPoint);

                                //Debug.DrawLine(transform.position, transform.position + 5 * rotationAxis.normalized, Color.gray, 1.0f);
                                break;
                            }
                        case GizmoAxis.none:
                            {
                                rotationAxis2 = rotationAxis;
                                projectedTranslation = translation;
                                rotationAxis = Vector3.Cross(translation, lookCamera);
                                break;
                            }
                    }
                    float angle;
                    Quaternion delta;

                    //Debug.DrawLine(transform.position, transform.position + 5 * rotationAxis.normalized, Color.red, 1.0f);
                    angle = -Mathf.Rad2Deg * projectedTranslation.magnitude / sphereRadius;
                    delta = Quaternion.AngleAxis(angle, rotationAxis2);

                    if (selectedAxis == GizmoAxis.none)
                    {

                        rotationParent.transform.rotation = delta;

                    }
                    else
                    {

                        rotationParent.transform.rotation = delta;
                    }

                }

                if (Input.GetMouseButtonUp(0)) SetFalse();

            }

        }

        public void ChangeMode()
        {
            i = (i + 1) % 2;
            // i = 0 / translation;  i = 1 / rotation 
            bool val = (i == 1);

            xyRotate.gameObject.SetActive(val);
            xzRotate.gameObject.SetActive(val);
            yzRotate.gameObject.SetActive(val);
            sphereRotate.gameObject.SetActive(val);

            xAxis.gameObject.SetActive(!val);
            yAxis.gameObject.SetActive(!val);
            zAxis.gameObject.SetActive(!val);
            xyPlane.gameObject.SetActive(!val);
            xzPlane.gameObject.SetActive(!val);
            yzPlane.gameObject.SetActive(!val);
        }


        void SetFalse()
        {
            transform.SetParent(null);//1   
            // transform.SetParent(thisparther);//2
            if (rotationParent) Destroy(rotationParent);
            rotating = false;
            dragging = false;
        }

        void DrawPlane(Vector3 normal, Vector3 position, float t)
        {

            Vector3 v3;

            if (normal.normalized != Vector3.forward)
                v3 = Vector3.Cross(normal, Vector3.forward).normalized * normal.magnitude;
            else
                v3 = Vector3.Cross(normal, Vector3.up).normalized * normal.magnitude; ;

            var corner0 = position + v3;
            var corner2 = position - v3;
            Quaternion q = Quaternion.AngleAxis(90.0f, normal);
            v3 = q * v3;
            var corner1 = position + v3;
            var corner3 = position - v3;

            Debug.DrawLine(corner0, corner2, Color.green, t);
            Debug.DrawLine(corner1, corner3, Color.green, t);
            Debug.DrawLine(corner0, corner1, Color.green, t);
            Debug.DrawLine(corner1, corner2, Color.green, t);
            Debug.DrawLine(corner2, corner3, Color.green, t);
            Debug.DrawLine(corner3, corner0, Color.green, t);
            Debug.DrawRay(position, normal, Color.red, t);
        }
    }
}

1如果坐标轴位于物体下时 注销 //1  使用 //2

2有时候我们需要这个坐标轴随相机距离而缩放 这个时候发现有时候旋转出现bug 

是因为 sphereRadius = sphereRotate.bounds.extents.x; 在start中获取 我们需要将其放在updata下实时获取 

Unity Scene场景自定义坐标轴
Garsonlab
04-27 3867
多看看别人的代码是没有坏处的，即使学不了人家的大框架，偶尔拾起一些小东西也是可以的。 最近扒了一下DoTween(声明一下源码是自己反编译的，只为学习)，看见了如何在Scene场景中添加标注和坐标轴，具体做法是，在你的脚本Editor中，比如你重定义某个mono脚本的Inspector显示中，加入OnSceneGUI函数，使用Handles进行操作。 void OnSceneGUI()
unity 坐标系转换_Unity中坐标系转换方法
weixin_33251169的博客
12-23 1050
前言本篇文章主要是参考《Unity API 解析》---陈泉宏。这是本人在学校图书馆找到一本书，主要介绍的就是常用的类，比较实用，没有冗余的地方。在此推荐一下这本书！一、ScreenToViewportPoint方法1、函数原型public Vector3 ScreenToViewportPoint(Vector3 position);其中参数position为屏幕参考点。2、功能说明可以实现坐标...
Unity制作Scene场景的坐标轴功能
qq_42345116的博客
07-14 4088
效果图： 一、场景布局 1.制作坐标轴 设置图层 2.相机设置 效果：设置坐标模型不被其他物体遮挡 新建空节点作为相机父节点，创建一个新相机（注：空节点下有两个相机 一个Main Camera主相机 一个显示坐标模型相机）如图： 给相机父物体GameObjec添加脚本，用于旋转相机 观察操作Cube using System.Collections; using System.Collections.Generic; using UnityEngine; public..
unity Gizmos详解(TODO)
最新发布
m0_73740524的博客
05-08 1324
Gizmos 是 Unity 编辑器中的一种可视化工具，用于在Scene 视图中绘制调试信息、辅助线、形状等。它们不会出现在最终的游戏中，仅在编辑器中可见，方便开发者进行调试和设计。
Unity3D开发之自制坐标轴（二）
Jay W的博客
07-23 5842
我在上篇博客写出了如何用代码创建一个我们可以任意控制顶点得圆柱体。本片博客着重记录如何在空间创建类似unity可以控制物体的坐标轴。由于我们要控制圆柱体的长度，所以我们设计的坐标轴是两个方块在圆柱体的两端。效果图如下：                                                                                 首先我们要绘制两...
unity运行中坐标轴操作模型.rar
03-29
unity运行状态下通过坐标系操作模型，（联系我可以帮忙跳出材质）
unity 3维画线，绘制坐标轴、圆环、弧、三角面
weixin_43133970的博客
01-30 2285
using System.Collections.Generic; using UnityEngine; /// <summary> /// 绘图类 /// </summary> public class GraphicsBehaviour : MonoBehaviour { public enum PointMode { GLPoint, ScreenPoint } //private bool i...
Unity坐标轴模拟Runtime Transform Gizmos
05-30
"Unity坐标轴模拟Runtime Transform Gizmos"是Unity中一个功能强大的特性，主要用于在运行时可视化对象的Transform组件，包括位置（Position）、旋转（Rotation）和缩放（Scale）。在开发过程中，开发者通常依赖于...
unity,点击物体显示物体的xyz轴，xyz轴可以拖拽移动，换积分
04-14
在Unity引擎中，实现物体的XYZ轴显示以及可拖拽移动的功能，是游戏开发和交互设计中的常见需求。这个功能可以极大地提升用户在场景中的交互体验，使得对象的定位和调整更加直观。以下是对这一技术的详细解释： 首先...
unity 3D实现模型的缩放和旋转功能
06-20
1. **局部旋转**：旋转基于模型自身的坐标轴，不会受到父对象旋转的影响。 2. **世界旋转**：在世界坐标系中旋转模型，会影响其在场景中的全局位置。 3. **Euler Angles与Quaternion**：Euler Angles直观易懂，但...
Unity3D如何实现UI的旋转2
08-08
本篇文章将详细讲解如何利用Unity3D的矩阵变换功能来实现UI元素的旋转。 首先，我们需要理解Unity3D中的矩阵变换。在图形学中，矩阵是一种强大的工具，用于表示物体的位置、旋转和缩放等几何变换。在Unity3D中，`...
经纬度转换Unity世界坐标Demo
11-14
世界经纬度转化为Unity中的世界/模型上的坐标，需要设置的有左上，右下的基准点配准，和模型中心，或场景中心点。Test为测试脚本，本版本为double 高精度类型经纬度转化。
【转】Unity Scene场景自定义坐标轴
weixin_34128534的博客
08-06 155
来自：https://blog.csdn.net/cheng624/article/details/70859054 多看看别人的代码是没有坏处的，即使学不了人家的大框架，偶尔拾起一些小东西也是可以的。 最近扒了一下DoTween(声明一下源码是自己反编译的，只为学习)，看见了如何在Scene场景中添加标注和坐标轴，具体做法是，在你的脚本Editor中，比如你重定义某个mono脚本的Inspe...
Unity获取物体自身坐标轴的方向以及沿着该方向运动的方法
热门推荐
yangyongUestc的博客
10-27 5万+
有时候对于一个游戏对象，需要其沿着自身的坐标轴方向进行运动，那么首先如何获取自身的坐标轴方向？ 获取自身的坐标轴方向可以通过transform组件进行获取(负方向加负号即可)  Vector3 moveDirection = transform.right;  获取自身的x轴的方向  Vector3 moveDirection = transform.forward;  获取自身的z轴的方向
Shader理论（2）：Unity中的各种坐标系
qq_41904236的博客
06-06 3971
第二部分是关于写shader时经常会碰到的坐标系和坐标系转化相关的问题。
Unity3D中动态创建编辑轴（点，线，圆，圆锥）
weixin_38167363的博客
09-06 859
问题分析： 最近在搞软件底层开发，将一些工具或者底层脚本打成dll导入unity使用，有这样一需求，就是编辑功能，需要像Scene场景一样，实现那种编辑轴 实现方式： 创建Mesh，构建编辑轴，这个地方这么几步： 1.线（轴） 2.圆（旋转线） 3.正方形（轴面） 4.圆锥（轴方向） 具体步骤: 1.创建线Mesh： 代码： 1 /// <summa...
unity-记录位置的坐标系
m0_74462339的博客
07-09 938
unity使用的是左手坐标系世界坐标系：是整个游戏场景最大的坐标系，是一个标准，相当于地区的经纬度。
unity 通过鼠标让3D物体在xyz三个轴移动
防止名字重复
01-04 5791
工具 unity2018 vs2017 资源：要移动的模型 ，一个三维坐标轴 结果（暂时没找到办法放本地录屏，就先放图了）： 通过鼠标拖动xyz三个轴，实现物体在三维空间的移动（可以是本地坐标也可以是世界坐标，看个人需求，demo里我是让物体在世界坐标系移动） 一、制作一个三维坐标轴。如图 xyz三个轴分别创建一个空的子节点，放置到末端，（是为了获得三个轴的末端映射到屏幕上的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

屋檐上的大修勾

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值