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

屏幕边缘提示逻辑
最新推荐文章于 2023-11-02 16:17:24 发布
原创 最新推荐文章于 2023-11-02 16:17:24 发布 · 1.1k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#游戏 #lua #ui

本文介绍了一种用于游戏或应用中屏幕边缘提示的实现方案，包括单个提示标记和线段相交逻辑处理、多个提示的刷新及管理逻辑，并提供了相关的代码实现。
部署运行你感兴趣的模型镜像

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();
    }
}

 

您可能感兴趣的与本文相关的镜像

Dify

Dify

AI应用
Agent编排

Dify 是一款开源的大语言模型（LLM）应用开发平台，它结合了 后端即服务(Backend as a Service) 和LLMOps 的理念，让开发者能快速、高效地构建和部署生产级的生成式AI应用。 它提供了包含模型兼容支持、Prompt 编排界面、RAG 引擎、Agent 框架、工作流编排等核心技术栈，并且提供了易用的界面和API，让技术和非技术人员都能参与到AI应用的开发过程中

Unity中实现超出屏幕的敌人/队友位置显示
L的博客
05-08 4659
using UnityEngine; using UnityEngine.UI; public class Test : MonoBehaviour { public GameObject go;//物体 public GameObject targetGo;//目标物体 public Image labelUI;//标记UI private void Update() { if (IsInView(targetGo.transform.pos.
小程序3D效果实现：WebGL与Three.js应用
移动开发前沿的博客
06-11 2090
随着小程序生态的爆发（2023年微信小程序月活已超12亿），用户对交互体验的要求从“能用”升级为“惊艳”。3D效果作为提升用户沉浸感的利器，逐渐成为电商、教育、文旅等领域的“标配”。本文将聚焦如何在小程序中高效实现3D效果，覆盖从底层图形技术（WebGL）到上层开发框架（Three.js）的完整链路，以及具体的代码实战。本文将按照“从抽象到具体”的逻辑展开：假设你是一个“数字画家”，想在手机上画出会动的3D城堡。如果直接用最原始的工具（比如“魔法画笔”WebGL），你需要：这显然太麻烦了！于是有个聪明的发明
unity制作方向导航
成膜的博客
06-18 1511
unity方向导航制作： 设计要求是方向导航随着鼠标旋转转换方向，效果图如下： 具体的实现方法主要有两个步骤，分别为UI设计和脚本编写。我的设计思路是这个控件分为两层，第一层为东西南北指示层，第二层为图标指示层，这里我的图标采用圆形图标，方向指示这里采用控制图标旋转的方式实现，层级关系如下： 首先创建父节点1，然后在父节点下创建子节点2，3；最后调整好位置。 第二步脚本编写，脚本如...
Unity3D常用游戏功能复刻：屏幕外目标UI导航效果，寻路提示，指向屏幕外敌人位置
m0_72922928的博客
11-02 2285
本文实现了屏幕外目标UI追踪提示的效果，同时采用椭圆形的轨迹提高追踪的视觉效果
[UGUI]游戏中的Tips贴图标边缘显示(贴边)
weixin_34008805的博客
04-16 288
Tips贴图标边缘显示 图左：当左边宽度不足于容纳Tips时，Tips放在右侧显示，顶和图标对齐 图右：当左边宽度足够容纳Tips时，Tips放在左侧显示，顶和图标对齐 适应需求：当图标和Tips是在两个UI界面下，且两个UI的渲染模式可能不一样(Canvas的Render Mode为Screen Space或Camera)，通过到Tips设置世界坐标的方式，让两者贴合在一起。 获取UI的Mes...
Unity屏幕外怪物指示器/FairyGUI屏幕边缘指示器。笔记
AlanJoe_的博客
08-12 949
回顾下初中三角函数 ** 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 { // 角度转屏幕边
unity中将场景3d目标位置转化到屏幕坐标后，使该屏幕坐标的ui能够准确标记位置
最新发布
12-02
在Unity开发中，将3D目标位置转换为屏幕坐标后使UI元素准确标记该位置，是实现角色标记、交互提示等功能的核心技术。以下基于引用内容，逐步解释实现方法。关键点在于使用Unity内置API进行坐标转换和UI定位[^1][^3]...
Android手势实现3D旋转效果源码解析
例如，当用户在屏幕上向右滑动时，可触发绕Y轴正向旋转；向上滑动则可能对应绕X轴旋转。通过将滑动距离映射为旋转角度（如每10像素对应5度），即可实现流畅的手势驱动3D动画。 再者，动画效果的实现不仅依赖于实时...
Unity物体边缘发光Shader实现方法
当视线接近与表面平行时（即视角方向与法线垂直），该点被视为边缘区域，此时增加发光颜色输出。数学上可通过计算 ViewDir 与 Normal 的点积（dot product），然后用 1 - abs(dot) 来获得边缘强度。为了控制发光范围...
Flash读取OBJ文件实现3D贴图模型渲染
系统根据当前摄像机角度计算其在屏幕上的投影坐标，然后利用Matrix类（如MatrixTransformer）对原始纹理图像进行仿射变换，使其四个角对应到目标四边形的顶点上，从而实现透视扭曲效果。这种技术本质上是对...
unity3d 边缘发光的凹凸材质
02-13
2个文件1个shader文件 1个基础说明文件
屏幕外目标点标记的实现方法
l17768346260的博客
06-30 412
屏幕外目标点标记的实现方法
unity屏幕特效综述4 边缘检测
Magic_Conch
09-18 462
这个屏幕特效我挺喜欢的，可以用来描边，也可以用来提取边缘，获得很多很棒的效果。 什么样的点可能是边缘部分所在的点呢，如果该点附近的法线值相差的很多，那么这个点就可以被认为是一条边，具体的值可以用参数来控制。法线的差值我们通过卷积来获取，使用2x2的矩阵(-1,0,0,1)检测x方向以及2x2矩阵(0,-1,1,0)检测y方向，这个卷积核叫做Roberts算子。 这个屏幕特效的脚本部分没什么好说的，...
Unity实现UI在屏幕边缘跟随并指向视野外敌人
lcy的博客
11-29 6011
最终效果 实现 心急的小伙伴可以直接跳到文章末尾查看最终代码，如果有问题再来看下思路。 首先我们需要确定实现思路。我想到的方案是将玩家和敌人的世界坐标转换为UI坐标，然后求玩家和敌人坐标的线段与Canvas边界的交点即为箭头坐标。 下面是求出交点的代码。 using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class FindTest : M
在屏幕边缘指示怪物/敌人当前所处的方位
weixin_39665110的博客
09-09 3211
连续两周的疯狂加班生活终于结束了。早就计划好的内容现在才有时间开始写。 言归正传—— 首先，明确需求，在屏幕周围展示敌人方位，效果如图： 需求分析： 1.获取怪物坐标 2.获取UI坐标 3.统一坐标系（转换为屏幕坐标系） 4.怪物数量==箭头数量 **PS：**考虑需求分析第四条，所以脚本挂在怪物身上。 怪物坐标转换为屏幕坐标系（transform即指怪物） Vector3 BPoint = Camera.main.WorldToScreenPoint(transform.position); 在Unit
Unity悬浮指针在屏幕边缘或者固定移动线路指示屏幕外目标物体
lazy_lady的博客
06-12 1431
参考文章链接： https://www.jianshu.com/p/ecbfe9c88fb2 https://blog.youkuaiyun.com/Nightmare_ak/article/details/77917438
[Unity][UGUI][NGUI]地图指示UI屏幕边缘显示
BuladeMian的博客，菜得抠脚，菜得真实
04-22 777
UGUI euler.z 参考资料： 1. Unity3D 世界坐标转屏幕坐标的坑 2. 在屏幕边缘指示怪物/敌人当前所处的方位 3.
Unity获取屏幕边缘与检测物体是否在视野内
买烤麸烤饼儿的博客
09-11 2185
Unity获取屏幕边缘与检测物体是否在视野内 1. 需求描述 当游戏打包发布时，需要解决目前市场上各式各样屏幕比例的自适应问题。 UI方面只要在编辑器中设置好就问题不大，主要是游戏实体的缩放与生成和销毁位置的问题。 需求如下： 陆地块的生成位置必须在屏幕外 陆地块的开始运动位置必须在屏幕右侧边缘 陆地块运动至屏幕外需要销毁 陆地块右侧边缘位于屏幕右侧边缘时，需要启动下一个陆地块 时间环无论在什么屏幕下都应该充满背景 3.3.4.2 代码实现 想要实现如上需求，就必须要知道屏幕的边缘在哪里，也就是将屏幕的
【Unity3D】在Unity中实现UI指向箭头
lihui061119的专栏
05-14 6187
本问转载自http://ghostyii.com/uiarrow/，为什么转载呢，怕以后找不到了！ ps：博主写到超级详细，复制粘贴即可使用，超赞的！ 0x0.引言 屏幕UI指示箭头，非常常见的游戏UI元素。它是一个动态的，可以帮助玩家在目标脱离屏幕范围时指示出大概方位的UI元素。 它在游戏中可以充当多种功能，如在玩家受到伤害时只是伤害来源位置、如显示任务目标点或游戏资源的位置、如在多人游戏中显示队友的位置等等。下图是游戏COD16的一张截图，此图非常直观的显示出了UI Arrow的作用。　　 .
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值