实现3d点在屏幕上、屏幕边缘的方向提示

最新推荐文章于 2023-11-02 16:17:24 发布
最新推荐文章于 2023-11-02 16:17:24 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： Unity3D相关 文章标签： 游戏 lua ui
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangkd/article/details/84823396
版权

1、首先需要解决两条线段相交的逻辑判定

2、按照方向指示类型的不同，进行不同的判定，以及显示处理

3、按不同类型处理

①需求1：在屏幕边缘，显示屏幕外进攻的敌人的来向

需要敌人点和己方点连线 与 屏幕边缘线段做相交点判定处理

②需求2：在屏幕边缘，提示玩家前进的方向

需要目标点和己方点连线 与 屏幕边缘线段做相交点判定处理

 

一、单个提示标记和线段相交逻辑文件如下（ScreenEdgeTips.cs）

using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class Line2D
{
    //共线
    public const int COLINE = 0;
    //相交
    public const int CROSS = 1;
    //平行线
    public const int PARALLEL = 2;
    //无相交
    public const int NOT_CROSS = 3;


    private double EPS = 1e-4;

    public Vector3 point1;
    public Vector3 point2;

    private float A;
    private float B;
    private float C;

    public Line2D(Vector3 point1, Vector3 point2)
    {
        this.point1 = point1;
        this.point2 = point2;
        this.calcCoefficient();
    }

    private void calcCoefficient()
    {
        this.A = this.point2.y - this.point1.y;
        this.B = this.point1.x - this.point2.x;
        this.C = this.point2.x * this.point1.y - this.point1.x * this.point2.y;
    }

    private bool checkCross(Vector3 sp1, Vector3 ep1, Vector3 sp2, Vector3 ep2)
    {
    
        if (Math.Max(sp1.x, ep1.x) < Math.Min(sp2.x, ep2.x)){
            return false;
        }

        if (Math.Min(sp1.x, ep1.x) > Math.Max(sp2.x, ep2.x)){
            return false;
        }

        if (Math.Max(sp1.y, ep1.y) < Math.Min(sp2.y, ep2.y)){
            return false;
        }

        if (Math.Min(sp1.y, ep1.y) > Math.Max(sp2.y, ep2.y)){
            return false;
        }
    
        Vector3 vectorA = sp1 - sp2;
        Vector3 vectorB = ep2 - sp2;
        Vector3 vectorC = ep2 - sp2;
        Vector3 vectorD = ep1 - sp2;
        double temp1 = (vectorA.x * vectorB.y - vectorA.y * vectorB.x) * (vectorC.x * vectorD.y - vectorC.y * vectorD.x);

        vectorA = sp2 - sp1;
        vectorB = ep1 - sp1;
        vectorC = ep1 - sp1;
        vectorD = ep2 - sp1;
        double temp2 = (vectorA.x * vectorB.y - vectorA.y * vectorB.x) * (vectorC.x * vectorD.y - vectorC.y * vectorD.x);

        if ((temp1 >= 0) && (temp2 >= 0))
        {
            return true;
        }
 
        return false;
    }

    private bool isDoubleEqualZero(double data)
    {
        if (Math.Abs(data) <= EPS){
            return true;
        }else{
            return false;
        }
    }

    public int Intersection(Line2D otherLine, out Vector3 intersectantPoint)
    {
        intersectantPoint = Vector3.zero;
        if (!checkCross(this.point1, this.point2, otherLine.point1, otherLine.point2))
        {
            return Line2D.NOT_CROSS;
        }
        if (isDoubleEqualZero(this.A * otherLine.B - this.B * otherLine.A))
        {
            if (isDoubleEqualZero((this.A + this.B) * otherLine.C - (otherLine.A + otherLine.B) * this.C))
            {
                return Line2D.COLINE;
            }
            else
            {
                return Line2D.PARALLEL;
            }
        }
        else
        {
            intersectantPoint.x = (otherLine.B * this.C - this.B * otherLine.C) / (otherLine.A * this.B - this.A * otherLine.B);
            intersectantPoint.y = (this.A * otherLine.C - otherLine.A * this.C) / (otherLine.A * this.B - this.A * otherLine.B);
            intersectantPoint.z = 0;
            return Line2D.CROSS;
        }
    }
}


public class ScreenEdgeTips : MonoBehaviour
{
    //UI
    public UILabel distanceLabel;
    public GameObject directContainer;
    public float prefabWidth;

    //cameras
    private Camera mainCamera;
    private Camera uicamera;
    
    //param
    private bool isIdle = false;
    private int type = 0;
    private int fromActorId = 0;
    private int toActorId = 0;
    private Vector3 goalPoint;
    
    private List<Line2D> screenLines;

    public ScreenEdgeTips()
    {
        this.isIdle = true;
    }

    private void InitImp()
    {
        float offsetWidth = prefabWidth / 2;
        float originalPoint = 0 + offsetWidth;
        float correctionWidth = Screen.width - offsetWidth;
        float correctionHeight = Screen.height - offsetWidth;
        Vector3 point1 = new Vector3(offsetWidth, offsetWidth, 0);
        Vector3 point2 = new Vector3(offsetWidth, correctionHeight, 0);
        Vector3 point3 = new Vector3(correctionWidth, correctionHeight, 0);
        Vector3 point4 = new Vector3(correctionWidth, offsetWidth, 0);
        this.screenLines = new List<Line2D>();
        this.screenLines.Add(new Line2D(point1, point2));
        this.screenLines.Add(new Line2D(point2, point3));
        this.screenLines.Add(new Line2D(point3, point4));
        this.screenLines.Add(new Line2D(point4, point1));

        this.mainCamera = Camera.main;
        this.uicamera = NGUITools.FindCameraForLayer(LayersDefine.Ngui);

        this.isIdle = false;
        
    }

    public void Init(int type, int fromActorId, int toActorId)
    {
        this.InitImp();

        this.type = type;
        this.fromActorId = fromActorId;
        this.toActorId = toActorId;

        this.UpdateImp();
    }

    public void Init(int type, int fromActorId, Vector3 goalPoint)
    {
        this.InitImp();

        this.type = type;
        this.fromActorId = fromActorId;
        this.goalPoint = goalPoint;

        this.UpdateImp();
    }

    public bool GetIsIdle()
    {
        return this.isIdle;
    }

    private void SetIsIdle(bool isIdle)
    {
        this.isIdle = isIdle;
        if(isIdle)
        {
            this.type = 0;
            this.fromActorId = 0;
            gameObject.SetActive(false);
        }
    }

    public int GetType()
    {
        return this.type;
    }

    private bool PointIsInScreen(Vector3 pos)
    {
        if (pos.x <= this.screenLines[0].point1.x
            || pos.x >= this.screenLines[1].point2.x
            || pos.y <= this.screenLines[0].point1.y
            || pos.y >= this.screenLines[1].point2.y)
        {
            return false;
        }
        return true;
    }

    private Vector3 WorldToScreenPoint(Vector3 pos)
    {
        if (null != this.mainCamera) 
        {
            return mainCamera.WorldToScreenPoint (pos);
        }
        return Vector3.zero;
    }

    private Vector3 ScreenToUIPoint(Vector3 pos)
    {
        if (null != this.uicamera)
        {
            Vector3 uiWorldPosInUISpace = this.uicamera.ScreenToWorldPoint(pos);
            uiWorldPosInUISpace.z = 0f;
            return uiWorldPosInUISpace;
        }
        return Vector3.zero;
    }

    public void UpdateImp()
    {
        bool isIntersce = false;
        GameObject fromHero = ActorManager.Ins.GetActor(fromActorId);
        GameObject toHero = null;
        if (fromHero != null)
        {
            Vector3 intersecPos = new Vector3();
            Vector3 fromPos = this.WorldToScreenPoint(fromHero.transform.position);
            Vector3 toPos = Vector3.zero;

            if (this.toActorId == 0)
            {
                toPos = this.WorldToScreenPoint(this.goalPoint);
            }
            else
            {
                toHero = ActorManager.Ins.GetActor(toActorId);
                if (toHero != null)
                {
                    toPos = this.WorldToScreenPoint(toHero.transform.position);
                }
                else
                {
                    this.SetIsIdle(true);
                }
            }

            if (toPos != Vector3.zero && this.PointIsInScreen(fromPos))
            {
                Line2D line = new Line2D(fromPos, toPos);
                foreach (Line2D l in this.screenLines)
                {
                    if (line.Intersection(l, out intersecPos) == Line2D.CROSS)
                    {
                        isIntersce = true;
                        break;
                    }
                }

                if (isIntersce)
                {
                    transform.position = this.ScreenToUIPoint(intersecPos);

                    if (directContainer != null)
                    {
                        if (this.type == 1)
                        {
                            float angle = Vector3.Angle(toPos - fromPos, Vector3.right);
                            directContainer.transform.rotation = new Quaternion();
                            directContainer.transform.Rotate(Vector3.forward * angle);
                        }
                        else
                        {
                            float angle = Vector3.Angle(fromPos - toPos, Vector3.right);
                            directContainer.transform.rotation = new Quaternion();
                            directContainer.transform.Rotate(Vector3.back * angle);
                        }
                    }
                    if (this.distanceLabel != null && toHero != null)
                    {
                        this.distanceLabel.text = String.Format("{0}米", Math.Round((toHero.transform.position - fromHero.transform.position).magnitude));
                    }
                }
            }
        }
        else
        {
            this.SetIsIdle(true);
        }
        this.SetIsIdle(false);
        gameObject.SetActive(isIntersce);
    }
}

 二、多个提示的刷新、管理（增删）的逻辑处理文件（ScreenEdgeTipManager.cs）

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class ScreenEdgeTipManager : MonoBehaviourX
{
    private Dictionary<int, string> prefabNameMap = new Dictionary<int, string>();
    private Dictionary<int, GameObject> prefabMap = new Dictionary<int, GameObject>();
    private ScreenEdgeTips ToGoalCtrl;

    private static ScreenEdgeTipManager instance = null;
    
    public static ScreenEdgeTipManager Ins
    { 
        get
        {
            return instance;  
        } 
    }
    
    ScreenEdgeTipManager()
    {
        instance = this;
    }

    void Start()
    {
        scope.Listen("BattleOver", OnBattleOver);
        scope.Listen("GameShutdown", OnBattleOver);

        prefabNameMap.Add(1, UIDefine.BATTLE_TIPS_GOAL);
        prefabNameMap.Add(2, UIDefine.BATTLE_TIPS_MONSTER);
        prefabNameMap.Add(3, UIDefine.BATTLE_TIPS_RAIDER);
    }

    private void OnBattleOver(object[] args)
    {
        ClearAll();
    }
    
    private void ClearAll()
    {
        gameObject.DestroyAllChildGameObject();
        prefabMap.Clear();

        NGUITools.SetActiveChildren(gameObject, false);
    }

    private GameObject GetPrefab(int type)
    {
        if (!prefabMap.ContainsKey(type))
        {
            GameObject tipsTemplate = null;
            tipsTemplate = (GameObject)ResourceMgr.LoadPrefab(prefabNameMap[type]);
            if (null != tipsTemplate)
            {
                prefabMap.Add(type, tipsTemplate);
            }
        }
        return prefabMap[type];
    }

    private ScreenEdgeTips GetNewTips(int type)
    {
        GameObject tipsTemplate = this.GetPrefab(type);
        GameObject go = GameObject.Instantiate(tipsTemplate) as GameObject;
        go.transform.parent = transform;
        go.layer = LayersDefine.Ngui;
        go.transform.localScale = Vector3.one;
        return go.GetComponent<ScreenEdgeTips>();
    }

    private ScreenEdgeTips GetTipsCtrl(int type)
    {
        if (type == 0)
        {
            return null;
        }
        //根据type复用 或 创建新的提示
        //尝试复用一个已经创建过的UI_BloodUp
        int count = transform.childCount;
        ScreenEdgeTips findTips = null;
        for (int i = 0; i < count; ++i)
        {
            GameObject obj = transform.GetChild(i).gameObject;
            if (!obj.activeSelf)
            {
                ScreenEdgeTips et = obj.GetComponent<ScreenEdgeTips>();
                if (et != null && et != this.ToGoalCtrl && et.GetType() == type && et.GetIsIdle())
                {
                    findTips = et;
                }
                break;
            }
        }
        //不存在时，创建新的tips模板
        return null != findTips ? findTips : this.GetNewTips(type);
    }

    private void _CreateTargetTips(int type, int fromActorId, int toActorId)
    {
        ScreenEdgeTips findTips = this.GetTipsCtrl(type);
        if (findTips != null)
        {
            findTips.Init(type, fromActorId, toActorId);
        }
    }

    private ScreenEdgeTips GetToGoalCtrl()
    {
        this.ToGoalCtrl = this.ToGoalCtrl != null ? this.ToGoalCtrl : this.GetNewTips(1);
        return this.ToGoalCtrl;
    }

    private void _CreatePointTips(int fromActorId, Vector3 goalPoint)
    {
        ScreenEdgeTips findTips = this.GetToGoalCtrl();
        if (findTips != null)
        {
            findTips.Init(1, fromActorId, goalPoint);
        }
    }


    void Update()
    {
        int count = transform.childCount;
        for (int i = 0; i < count; ++i)
        {
            GameObject obj = transform.GetChild(i).gameObject;
            ScreenEdgeTips et = obj.GetComponent<ScreenEdgeTips>();
            if (et != null)
            {
                et.UpdateImp();
            }
        }
    }

    public static void CreateTargetTips(int type, int fromActorId, int toActorId)
    {
        if (instance)
        {
            instance._CreateTargetTips(type, fromActorId, toActorId);
        }
    }

    public static void CreatePointTips(int fromActorId, Vector3 goalPoint)
    {
        if (instance)
        {
            instance._CreatePointTips(fromActorId, goalPoint);
        }
    }
}

 

************************************下面是用到到的基础类，不用也没关系*************************************

 

三、使用到的显示基类（MonoBehaviourX.cs）

using System;
using UnityEngine;

public class MonoBehaviourX: MonoBehaviour
{
    protected EventScope scope = null;
    
    protected MonoBehaviourX()
    {
        scope = Eventer.Create();
    }
    
    protected void OnDestroy()
    {
        scope.Destroy();
        scope= null;
    }
}

 四、使用到的事件处理类（EventScope.cs）

using System;
using System.Collections.Generic;

public class EventScope
{
    public Dictionary<string, DelegateObjList> eventTable = new Dictionary<string, DelegateObjList>();
    private EventScope parent = null;
    private List<EventScope> childer = new List<EventScope>();
    
    public EventScope(EventScope _parent)
    {
        parent = _parent;
    }
    
    public EventScope CreateChild()
    {
        EventScope scope = new EventScope(this);
        childer.Add(scope);
        return scope;
    }
    
    private void RemoveParentEvents(string name, Delegate deleObject)
    {
        if (parent == null)
        {
            return;
        }
        
        DelegateObjList list;
        if (parent.eventTable.TryGetValue(name, out list))
        {
            list.Remove(deleObject);
        }
        
        parent.RemoveParentEvents(name, deleObject);
    }
    
    public void ClearEvent()
    {
        foreach (var et in eventTable)
        {
            foreach (var _delegate in et.Value.events)
            {
                RemoveParentEvents(et.Key, _delegate);
            }
        }
        
        eventTable.Clear();
    }
    
    public void Destroy()
    {
        ClearEvent();
        
        if (parent != null)
        {
            parent.childer.Remove(this);
        }
    }
    
    public void Listen(string name, CALLBACK handler)
    {
        if (handler == null)
        {
            return;
        }
        DelegateObjList dol;
        if (!eventTable.TryGetValue(name, out dol))
        {
            dol = new DelegateObjList();
            eventTable [name] = dol;
        }
        
        dol.Add(handler);
        
        if (parent != null)
        {
            parent.Listen(name, handler);
        }
    }
}

 五、使用到的事件广播类（Eventer.cs）

using System;
using System.Collections.Generic;

public class Eventer
{
    static public EventScope globe = new EventScope(null);
    
    static public EventScope Create()
    {
        return globe.CreateChild();
    }

    public static void Fire(string name, object[] args)
    {
        DelegateObjList dol;
        if (globe.eventTable.TryGetValue(name, out dol))
        {
            dol.Enter();
            int count = dol.events.Count;
            for (int i=0; i<count; ++i)
            {
                CALLBACK callback = dol.events [i] as CALLBACK;
                callback(args);
            }
            dol.Leave();
        }
    }

    public static void Fire(string name)
    {
        object[] args = new object[0] {};
        Fire(name, args);
    }

    //  ---------------- 以下接口提供给Lua调用 ----------------------
    public static void _Fire(string name)
    {
        object[] args = new object[0] {};
        Fire(name, args);
    }

    public static void _Fire(string name, object arg1)
    {
        object[] args = new object[1] { arg1 };
        Fire(name, args);
    }

    public static void _Fire(string name, object arg1, object arg2)
    {
        object[] args = new object[2] { arg1, arg2 };
        Fire(name, args);
    }
    
    public static void _Fire(string name, object arg1, object arg2, object arg3)
    {
        object[] args = new object[3] { arg1, arg2, arg3 };
        Fire(name, args);
    }

    public static void _Fire(string name, object arg1, object arg2, object arg3, object arg4) 
    {
        object[] args = new object[4] { arg1, arg2, arg3, arg4 };
        Fire(name, args);
    }

    public static void _Fire(string name, object arg1, object arg2, object arg3, object arg4, object arg5) 
    {
        object[] args = new object[5] { arg1, arg2, arg3, arg4, arg5 };
        Fire(name, args);
    }

    public static void _Fire(string name, object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) 
    {
        object[] args = new object[6] { arg1, arg2, arg3, arg4, arg5, arg6 };
        Fire(name, args);
    }
}

 六、使用到的回调处理类（DelegateObjList）

using System;
using System.Collections.Generic;

public delegate void CALLBACK(object[] args);

public class DelegateObjList
{
    public class DynamicDelegate
    {
        public Delegate callback;
        public bool append;
    }
    
    public List<Delegate> events = new List<Delegate>();
    public List<DynamicDelegate> delayProcesList = null;
    public bool accessEvent = false;
    
    private void AddDynamicDelegate(Delegate dele, bool append)
    {
        if (delayProcesList == null)
        {
            delayProcesList = new List<DynamicDelegate>();
        }
        
        DynamicDelegate dd = new DynamicDelegate();
        dd.append = append;
        dd.callback = dele;
        delayProcesList.Add(dd);
    }
    
    public void Add(Delegate c)
    {
        if (accessEvent)
        {
            AddDynamicDelegate(c, true);
        } else
        {
            events.Add(c);
        }
    }
    
    public void Remove(Delegate c)
    {
        if (accessEvent)
        {
            AddDynamicDelegate(c, false);
        } else
        {
            events.Remove(c);
        }
    }
    
    public void Enter()
    {
        accessEvent = true;
    }
    
    public void Leave()
    {
        accessEvent = false;
        
        if (delayProcesList == null)
        {
            return;
        }
        
        int count = delayProcesList.Count;
        if (count == 0)
        {
            return;
        }
        
        for (int i=0; i<count; ++i)
        {
            var dp = delayProcesList [i];
            if (dp.append)
            {
                events.Add(dp.callback);
            } else
            {
                events.Remove(dp.callback);
            }
        }
        
        delayProcesList.Clear();
    }
}

 

[Unity3D]Unity3D游戏开发之使用UniSky呼风唤雨
素履独行 | 元培的个人博客
04-10 6750
大家好，欢迎大家关注我的博客，我的博客地址是blog.csdn.net/qinyuanpei。        好，继续我们在上一篇中实现的地形，在这一篇文章中我们来为这个地形添加天气效果。我们使用的是UniSky插件，大家可以在Assets Store中找到这个插件。首先，我们引入资源包，注意不要带有中文路径，否则会报错。此时，在项目中会增加一个UniSky的文件夹，如图所示：
3D点云处理：基于2D边缘提取的方法提取3D点云边缘（占位待补充）
lddx_123456的博客
08-29 486
文章目录：3D视觉个人入门学习路线
unity制作方向导航
成膜的博客
06-18 1383
unity方向导航制作： 设计要求是方向导航随着鼠标旋转转换方向，效果图如下： 具体的实现方法主要有两个步骤，分别为UI设计和脚本编写。我的设计思路是这个控件分为两层，第一层为东西南北指示层，第二层为图标指示层，这里我的图标采用圆形图标，方向指示这里采用控制图标旋转的方式实现，层级关系如下： 首先创建父节点1，然后在父节点下创建子节点2，3；最后调整好位置。 第二步脚本编写，脚本如...
[UGUI]游戏中的Tips贴图标边缘显示(贴边)
weixin_34008805的博客
04-16 248
Tips贴图标边缘显示 图左：当左边宽度不足于容纳Tips时，Tips放在右侧显示，顶和图标对齐 图右：当左边宽度足够容纳Tips时，Tips放在左侧显示，顶和图标对齐 适应需求：当图标和Tips是在两个UI界面下，且两个UI的渲染模式可能不一样(Canvas的Render Mode为Screen Space或Camera)，通过到Tips设置世界坐标的方式，让两者贴合在一起。 获取UI的Mes...
Unity屏幕外怪物指示器/FairyGUI屏幕边缘指示器。笔记
AlanJoe_的博客
08-12 845
回顾下初中三角函数 ** 1，tan(α的弧度) = 对边长b / 领边长a 2，弧度 = 角度 * PI / 180 3，根据Cos,就可以算出CosMax,和CosMin,角度，知道落在什么方位上，如图下图分为8个方位，顺时针** using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class UIArrow { // 角度转屏幕边
Unity3D常用游戏功能复刻：屏幕外目标UI导航效果，寻路提示，指向屏幕外敌人位置
最新发布
m0_72922928的博客
11-02 1441
本文实现了屏幕外目标UI追踪提示的效果，同时采用椭圆形的轨迹提高追踪的视觉效果
在屏幕边缘指示怪物/敌人当前所处的方位
weixin_39665110的博客
09-09 2848
连续两周的疯狂加班生活终于结束了。早就计划好的内容现在才有时间开始写。 言归正传—— 首先，明确需求，在屏幕周围展示敌人方位，效果如图： 需求分析： 1.获取怪物坐标 2.获取UI坐标 3.统一坐标系（转换为屏幕坐标系） 4.怪物数量==箭头数量 **PS：**考虑需求分析第四条，所以脚本挂在怪物身上。 怪物坐标转换为屏幕坐标系（transform即指怪物） Vector3 BPoint = Camera.main.WorldToScreenPoint(transform.position); 在Unit
unity3d 工程原理_Unity3D重要知识点
weixin_39827034的博客
12-22 1369
数据结构和算法很重要！图形学也很重要！大的游戏公司很看重个人基础，综合能力小公司看你实际工作能力，看你的Demo。1.什么是渲染管道？是指在显示器上为了显示出图像而经过的一系列必要操作。 渲染管道中的很多步骤，都要将几何物体从一个坐标系中变换到另一个坐标系中去。主要步骤有：本地坐标->视图坐标->背面裁剪->光照->裁剪->投影->视图变换->光栅化。2....
基于AM572x 和DLP 结构光的 3D 机器视觉参考设计
weixin_42208331的博客
06-27 537
DSP 投影 DLP 三维重建 结构光 嵌入式 解决方案
关于屏幕外物体在屏幕边缘的指示功能实现
xiao_shixiong的博客
07-11 795
屏幕外物体指示
Unity悬浮指针在屏幕边缘或者固定移动线路指示屏幕外目标物体
lazy_lady的博客
06-12 1335
参考文章链接： https://www.jianshu.com/p/ecbfe9c88fb2 https://blog.csdn.net/Nightmare_ak/article/details/77917438
UGUI 实现屏幕外怪物的指示箭头
akak2010110的专栏
05-07 7951
在玩ARPG手游的时候，我们常常会发现在战斗的过程中，如果有怪物在屏幕的外边（即玩家视野之外）的时候，会发现在玩家周围活屏幕边缘有指示怪物方位的箭头，而且这是在UI上的。我用UGUI来实现这个贴心的功能。 首先实现思路：肯定是把3D世界的坐标投射到屏幕坐标，再由屏幕坐标投射到UI坐标。有两种实现方式： 先在3D世界中把指示箭头的位置计算出来。 然后再把计算出来的点投射到屏幕。与玩家的点也投射到屏幕。
Unity 屏幕中心，方向指示
Witness_K的博客
02-21 2643
1.新建一个朝上的UI  Rotation为(0,0,0) 2.脚本挂在1中的UI上，Target设置为要追踪的物体，self设置为摄像机。（当摄像机移动时，UI会指向Target） using System.Collections; using System.Collections.Generic; using UnityEngine; public class DirectionTe...
【Unity】屏幕边界的世界坐标及可视化
萧然
06-12 1018
using UnityEngine; using System.Collections; using System; namespace Helper { public class ScreenBounding { Vector3[] boundingBoxes; Camera mainCamera; //UV坐标转对应世界坐...
Unity在屏幕边界追踪目标提示
gzwd博客
03-22 3030
void SetOthersAt(Vector3 playerPosition,Vector3 otherPosition,GameObject showUI) { //计算方向 Vector3 CachePosion = new Vector3(otherPosition.x, 0, otherPosition.z) - new Vector3(...
Unity 3D追踪效果的实现 目标箭头指引
热门推荐
暗光之痕的博客
01-06 1万+
版本：unity 5.4.1  语言：C#   有段时间没写博客了，就搞搞自己的小游戏自娱自乐。   今天给大家带来3D空战或者宇宙飞行目标箭头的显示，参考了网友ζ随风去旅行的2D指引效果，自己研究了3D效果的实现。   下面是代码： public class CArrowLockAt : MonoBehaviour { public Transform target;
屏幕方向
snpmyn
04-19 128
简介 xxx 分类 unspecified 默值。系统判显方向。判定策略和设备相关，不同设备会有不同显示方向。 landscape 横屏。 portrait 竖屏。 user 用户当前首选方向。 behind 同该Activity以下Activity（栈中）方向一致。 sensor 物理感应器决定。用户旋转设备时屏幕横竖屏切换。 nosensor 忽略物理感应器。即不随用户旋转设备而更改（uns...
unity 判断物体是否到达屏幕边界
TheRootone的博客
08-24 7560
public float leftBorder; public float rightBorder; public float topBorder; public float downBorder; private float width; private float height; private int count; bool fistT
Godot边缘检测和鼠标捕获
游戏开发
12-10 1616
目录 Godot边缘检测和鼠标捕捉 捕捉鼠标 动画硬币 边缘检测 结束 Godot边缘检测和鼠标捕捉 在上一部分中，我们学习了如何使用Area节点来检测物体之间的接触，为我们的角色制作硬币、子弹和尖峰物体来进行交互。在这一部分中，我们将看看一些小的改进：捕捉鼠标，动画硬币，以及检测边缘，使我们的角色不会摔倒。 捕捉鼠标 我们基于鼠标的控制有一个问题，那就是当你左右移动鼠标时，它最终会移出游戏窗口，碰到屏幕的边缘。为了解决这个问题，我们需要 "捕捉 "鼠标。然而，如果我们这样做，我们将无法关
[Unity实战]屏幕追踪显示目标
宏哥的博客
02-29 4079
参考链接：http://www.manew.com/thread-48125-1-1.html?_dsign=4edc9052 效果图： using UnityEngine; using System.Collections; using System.Collections.Generic; public enum BeaconMoveType { Rect
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值