【转】Unity 关于Spine不规则响应区域解决方法

转载自：http://blog.csdn.net/u010019717

             起这个标题完全是为了区分于 《Unity 关于UGUI不规则图片响应区域解决方法》

 

         最近看到 《Unity 关于NGUI不规则图片响应区域解决方法》    之所以要记录这个也是多自己之前项目的一个总结， 看看那里不好， 该怎么解决！。  我们卡牌游戏就是 UGUI + spine

 

 

 

推荐  雨凇的（看一下评论） 

UGUI研究院之不规则按钮的响应区域（十四）

 

来自 <http://www.xuanyusong.com/archives/3492>

           非常巧妙 使用  Polygon Collider2D 作为区域编辑和判断， 但是不能跟随图片的分辨率变化！  这是硬伤！

    而且代码可以简化使用  Collider2D.OverlapPoint    判断点在没在多边形碰撞体中

 

推荐  秦元培 的总结（多边形碰撞器<还是  雨凇  的> 和  精灵像素检测  <出处 http://m.manew.com/forum.php?mod=viewthread&tid=45046&highlight=uGUI%2B%E4%B8%8D%E8%A7%84%E5%88%99&mobile=2 >）

Unity3D游戏开发之在uGUI中使用不规则精灵制作按钮

 

来自 <http://blog.csdn.net/qinyuanpei/article/details/51868638>

         首先指出雨凇的代码实现问题（判断一个点在没在多边形内的算法 http://geomalgorithms.com/a03-_inclusion.html ）。     同时也说明了 Image.eventAlphaThreshold  的 意义用处！

 

 

 

 开始正题吧

扩展  UGUI组件呗！

               1、自己设置多边形组件（判断一个点是否在一个多边形内）。  2、就是镂空精灵（透明度）。  首先为什么要有第一种需求， 我们游戏当时使用的是Spine动画， 不是精灵， 所以当时用的 2d碰撞体。 如果用镂空精灵作为检测区域的话，就会增加游戏无用的资源， 因为不参与显示（显示的是spine动画）。所以就有了需求1.               对于2、镂空精灵， 就是 秦元培  他们网上所说的方式！也是需要Sprite资源的！

 

        主要是根据IsRaycastLocationValid这个方法的返回值来进行判断的，而这个方法用到的基本原理则是判断指定点对应像素的RGBA数值中的Alpha是否大于某个指定临界值。

 

     而且

        public override boolIsRaycastLocationValid(Vector2 screenPoint, Camera eventCamera)

        {

            //当透明度>=1.0时，表示点击在可响应区域返回true

            if (m_EventAlphaThreshold >= 1)

                return true;

 

            //当没有指定精灵时为什么要返回true?

            Debug.Log("射线检测");

            Sprite sprite = overrideSprite;

           if (sprite == null)      //  注意这个，如果要想像素检测这个不能为空！， 编辑器一定要赋值一个内容

               return true;

 

1、自己设置多边形组件

   参考 我之前的博客： 《Unity游戏选/创建角色界面中职业能力图六角形》     来自 <http://blog.csdn.net/u010019717/article/details/52279010>

中的   脚本  UIPolygon.cs

 

 

我的想法是错的，  我没有办法得到    最终显示的渲染状态（颜色表）。     也就没办法脱离  贴图  做判断！， 唉~

 

还好想到了           Mesh能得到顶点数，  能得到三角形，判断在没在多边形内， 所有三角形内就可以了！！！！！！！！     哈哈~

[csharp]  view plain  copy

1. using UnityEngine;  
2. using System.Collections.Generic;  
3. using UnityEngine.UI;  
4. using UnityEngine.Events;  
5. using UnityEngine.EventSystems;  
6. using UnityEngine.Assertions.Must;  
7. using UnityEngine.UI.Extensions;  
8.   
9. namespace SGD  
10. {  
11.     /// <summary>  
12.     /// 描述：  
13.     /// author： sunguangdong  
14.     /// </summary>  
15.     [AddComponentMenu("SGD/PolygonButtonWithPixel")]  
16.     public class PolygonButtonWithPixel : UIPrimitiveBase, IPointerClickHandler  
17.     {  
18.         public bool fill = true;  
19.         public float thickness = 5;  
20.         [Range(3, 360)]  
21.         public int sides = 3;  
22.         [Range(0, 360)]  
23.         public float rotation = 0;  
24.         [Range(0, 1)]  
25.         public float[] VerticesDistances = new float[3];  
26.         private float size = 0;  
27.   
28.   
29.         /// /       针对 多边形响应区域检测  start  
30.         public bool _isShowUI;  
31.   
32.         public UnityEvent _ClickEvent = new UnityEvent();  
33.   
34.   
35.         public void Start()  
36.         {  
37.             useLegacyMeshGeneration = false;  
38.         }  
39.   
40.   
41.         public void OnPointerClick(PointerEventData eventData)  
42.         {  
43.             Debug.LogError("点击到精灵");  
44.             _ClickEvent.Invoke();  
45.         }  
46.   
47.         / <summary>  
48.         / 只参与 点击响应， 不参与绘制   todo 但是在编辑器下也看不到了？？？？？  
49.         / </summary>  
50.         / <param name="toFill"></param>  
51.         //protected override void OnPopulateMesh(VertexHelper toFill)  
52.         //{  
53.         //    toFill.Clear();  
54.         //}  
55.   
56.   
57.         /// <summary>  
58.         /// 自定义 多边形响应区域（根据Mesh内的顶点 和 三角形弄的）  
59.         /// </summary>  
60.         /// <param name="screenPoint"></param>  
61.         /// <param name="eventCamera"></param>  
62.         /// <returns></returns>  
63.         public override bool IsRaycastLocationValid(Vector2 screenPoint, Camera eventCamera)  
64.         {  
65.             Vector2 local;  
66.             RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, screenPoint, eventCamera, out local);  
67.   
68.             try  
69.             {  
70.                 return InPolygon(new Vector3(local.x, local.y, 0));  
71.             }  
72.             catch (UnityException e)  
73.             {  
74.                 Debug.LogError("Using clickAlphaThreshold lower than 1 on Image whose sprite texture cannot be read. " + e.Message + " Also make sure to disable sprite packing for this sprite.", this);  
75.                 return true;  
76.             }  
77.         }  
78.   
79.         /// <summary>  
80.         ///  判断一个点  在没在多边形内！  
81.         /// </summary>  
82.         /// <param name="_target"></param>  
83.         /// <returns></returns>  
84.         protected bool InPolygon(Vector3 _target)  
85.         {  
86.             Vector2 prevX = Vector2.zero;  
87.             Vector2 prevY = Vector2.zero;  
88.             Vector2 pos0;  
89.             Vector2 pos1;  
90.             Vector2 pos2;  
91.             float degrees = 360f / sides;  
92.             int vertices = sides + 1;  
93.             if (VerticesDistances.Length != vertices)  
94.             {  
95.                 VerticesDistances = new float[vertices];  
96.                 for (int i = 0; i < vertices - 1; i++) VerticesDistances[i] = 1;  
97.             }  
98.             // last vertex is also the first!  
99.             VerticesDistances[vertices - 1] = VerticesDistances[0];  
100.             for (int i = 0; i < vertices; i++)  
101.             {  
102.                 float outer = -rectTransform.pivot.x * size * VerticesDistances[i];  
103.                 float inner = -rectTransform.pivot.x * size * VerticesDistances[i] + thickness;  
104.                 float rad = Mathf.Deg2Rad * (i * degrees + rotation);  
105.                 float c = Mathf.Cos(rad);  
106.                 float s = Mathf.Sin(rad);  
107.                 pos0 = prevX;  
108.                 pos1 = new Vector2(outer * c, outer * s);  
109.                 if (fill)  
110.                 {  
111.                     pos2 = Vector2.zero;  
112.                 }  
113.                 else  
114.                 {  
115.                     pos2 = new Vector2(inner * c, inner * s);  
116.                 }  
117.                 prevX = pos1;  
118.                 prevY = pos2;  
119.   
120.                 if (InTrigon(_target, pos0, pos1, pos2))  
121.                 {  
122.                     return true;  
123.                 }  
124.                   
125.             }  
126.   
127.             return false;  
128.         }  
129.   
130.         /// <summary>  
131.         ///  判断一个点  在没在三角形内！  
132.         /// </summary>  
133.         /// <param name="_target"></param>  
134.         /// <param name="_center"></param>  
135.         /// <param name="_left"></param>  
136.         /// <param name="_right"></param>  
137.         /// <returns></returns>  
138.         public static bool InTrigon(Vector3 _target, Vector3 _center, Vector3 _left, Vector3 _right)  
139.         {  
140.             Debug.Log(_target.ToString() + _center.ToString() + _left.ToString() + _right.ToString());  
141.   
142.             Vector3 Ctl = _left - _center;  
143.             Vector3 Ctr = _right - _center;  
144.             Vector3 Ctt = _target - _center;  
145.             Vector3 Ltr = _right - _left;  
146.             Vector3 Ltc = _right - _center;  
147.             Vector3 Ltt = _left - _target;  
148.             Vector3 Rtl = _left - _right;  
149.             Vector3 Rtc = _center - _right;  
150.             Vector3 Rtt = _target - _right;  
151.             if (  
152.                Vector3.Dot(Vector3.Cross(Ctl, Ctr).normalized, Vector3.Cross(Ctl, Ctt).normalized) == 1 &&  
153.                Vector3.Dot(Vector3.Cross(Ltr, Ltc).normalized, Vector3.Cross(Ltr, Ltt).normalized) == 1 &&  
154.                Vector3.Dot(Vector3.Cross(Rtc, Rtl).normalized, Vector3.Cross(Rtc, Rtt).normalized) == 1  
155.                )  
156.                 return true;  
157.             else  
158.                 return false;  
159.         }  
160.   
161.         ///  /       针对 多边形响应区域检测  end  
162.   
163.   
164.   
165.         public void DrawPolygon(int _sides)  
166.         {  
167.             sides = _sides;  
168.             VerticesDistances = new float[_sides + 1];  
169.             for (int i = 0; i < _sides; i++) VerticesDistances[i] = 1; ;  
170.             rotation = 0;  
171.         }  
172.         public void DrawPolygon(int _sides, float[] _VerticesDistances)  
173.         {  
174.             sides = _sides;  
175.             VerticesDistances = _VerticesDistances;  
176.             rotation = 0;  
177.         }  
178.         public void DrawPolygon(int _sides, float[] _VerticesDistances, float _rotation)  
179.         {  
180.             sides = _sides;  
181.             VerticesDistances = _VerticesDistances;  
182.             rotation = _rotation;  
183.         }  
184.         void Update()  
185.         {  
186.             size = rectTransform.rect.width;  
187.             if (rectTransform.rect.width > rectTransform.rect.height)  
188.                 size = rectTransform.rect.height;  
189.             else  
190.                 size = rectTransform.rect.width;  
191.             thickness = (float)Mathf.Clamp(thickness, 0, size / 2);  
192.         }  
193.   
194.         protected override void OnPopulateMesh(VertexHelper vh)  
195.         {  
196.             vh.Clear();  
197.   
198.             if (_isShowUI)  
199.             {  
200.                 Vector2 prevX = Vector2.zero;  
201.                 Vector2 prevY = Vector2.zero;  
202.                 Vector2 uv0 = new Vector2(0, 0);  
203.                 Vector2 uv1 = new Vector2(0, 1);  
204.                 Vector2 uv2 = new Vector2(1, 1);  
205.                 Vector2 uv3 = new Vector2(1, 0);  
206.                 Vector2 pos0;  
207.                 Vector2 pos1;  
208.                 Vector2 pos2;  
209.                 Vector2 pos3;  
210.                 float degrees = 360f / sides;  
211.                 int vertices = sides + 1;  
212.                 if (VerticesDistances.Length != vertices)  
213.                 {  
214.                     VerticesDistances = new float[vertices];  
215.                     for (int i = 0; i < vertices - 1; i++) VerticesDistances[i] = 1;  
216.                 }  
217.                 // last vertex is also the first!  
218.                 VerticesDistances[vertices - 1] = VerticesDistances[0];  
219.                 for (int i = 0; i < vertices; i++)  
220.                 {  
221.                     float outer = -rectTransform.pivot.x * size * VerticesDistances[i];  
222.                     float inner = -rectTransform.pivot.x * size * VerticesDistances[i] + thickness;  
223.                     float rad = Mathf.Deg2Rad * (i * degrees + rotation);  
224.                     float c = Mathf.Cos(rad);  
225.                     float s = Mathf.Sin(rad);  
226.                     uv0 = new Vector2(0, 1);  
227.                     uv1 = new Vector2(1, 1);  
228.                     uv2 = new Vector2(1, 0);  
229.                     uv3 = new Vector2(0, 0);  
230.                     pos0 = prevX;  
231.                     pos1 = new Vector2(outer * c, outer * s);  
232.                     if (fill)  
233.                     {  
234.                         pos2 = Vector2.zero;  
235.                         pos3 = Vector2.zero;  
236.                     }  
237.                     else  
238.                     {  
239.                         pos2 = new Vector2(inner * c, inner * s);  
240.                         pos3 = prevY;  
241.                     }  
242.                     prevX = pos1;  
243.                     prevY = pos2;  
244.                     vh.AddUIVertexQuad(SetVbo(new[] { pos0, pos1, pos2, pos3 }, new[] { uv0, uv1, uv2, uv3 }));  
245.                 }  
246.             }  
247.   
248.         }  
249.     }  
250. }  

[csharp]  view plain  copy

1. using System;  
2.   
3. namespace UnityEngine.UI.Extensions  
4. {  
5.     public class UIPrimitiveBase : MaskableGraphic, ILayoutElement, ICanvasRaycastFilter  
6.     {  
7.   
8.         [SerializeField]  
9.         private Sprite m_Sprite;  
10.         public Sprite sprite { get { return m_Sprite; } set { if (SetPropertyUtility.SetClass(ref m_Sprite, value)) SetAllDirty(); } }  
11.   
12.         [NonSerialized]  
13.         private Sprite m_OverrideSprite;  
14.         public Sprite overrideSprite { get { return m_OverrideSprite == null ? sprite : m_OverrideSprite; } set { if (SetPropertyUtility.SetClass(ref m_OverrideSprite, value)) SetAllDirty(); } }  
15.   
16.         // Not serialized until we support read-enabled sprites better.  
17.         internal float m_EventAlphaThreshold = 1;  
18.         public float eventAlphaThreshold { get { return m_EventAlphaThreshold; } set { m_EventAlphaThreshold = value; } }  
19.   
20.   
21.   
22.         /// <summary>  
23.         /// Image's texture comes from the UnityEngine.Image.  
24.         /// </summary>  
25.         public override Texture mainTexture  
26.         {  
27.             get  
28.             {  
29.                 if (overrideSprite == null)  
30.                 {  
31.                     if (material != null && material.mainTexture != null)  
32.                     {  
33.                         return material.mainTexture;  
34.                     }  
35.                     return s_WhiteTexture;  
36.                 }  
37.   
38.                 return overrideSprite.texture;  
39.             }  
40.         }  
41.   
42.         public float pixelsPerUnit  
43.         {  
44.             get  
45.             {  
46.                 float spritePixelsPerUnit = 100;  
47.                 if (sprite)  
48.                     spritePixelsPerUnit = sprite.pixelsPerUnit;  
49.   
50.                 float referencePixelsPerUnit = 100;  
51.                 if (canvas)  
52.                     referencePixelsPerUnit = canvas.referencePixelsPerUnit;  
53.   
54.                 return spritePixelsPerUnit / referencePixelsPerUnit;  
55.             }  
56.         }  
57.   
58.   
59.         protected UIVertex[] SetVbo(Vector2[] vertices, Vector2[] uvs)  
60.         {  
61.             UIVertex[] vbo = new UIVertex[4];  
62.             for (int i = 0; i < vertices.Length; i++)  
63.             {  
64.                 var vert = UIVertex.simpleVert;  
65.                 vert.color = color;  
66.                 vert.position = vertices[i];  
67.                 vert.uv0 = uvs[i];  
68.                 vbo[i] = vert;  
69.             }  
70.             return vbo;  
71.         }  
72.  
73.  
74.         #region ILayoutElement Interface  
75.   
76.         public virtual void CalculateLayoutInputHorizontal() { }  
77.         public virtual void CalculateLayoutInputVertical() { }  
78.   
79.         public virtual float minWidth { get { return 0; } }  
80.   
81.         public virtual float preferredWidth  
82.         {  
83.             get  
84.             {  
85.                 if (overrideSprite == null)  
86.                     return 0;  
87.                 return overrideSprite.rect.size.x / pixelsPerUnit;  
88.             }  
89.         }  
90.   
91.         public virtual float flexibleWidth { get { return -1; } }  
92.   
93.         public virtual float minHeight { get { return 0; } }  
94.   
95.         public virtual float preferredHeight  
96.         {  
97.             get  
98.             {  
99.                 if (overrideSprite == null)  
100.                     return 0;  
101.                 return overrideSprite.rect.size.y / pixelsPerUnit;  
102.             }  
103.         }  
104.   
105.         public virtual float flexibleHeight { get { return -1; } }  
106.   
107.         public virtual int layoutPriority { get { return 0; } }  
108.  
109.         #endregion  
110.  
111.         #region ICanvasRaycastFilter Interface  
112.         public virtual bool IsRaycastLocationValid(Vector2 screenPoint, Camera eventCamera)  
113.         {  
114.             if (m_EventAlphaThreshold >= 1)  
115.                 return true;  
116.   
117.             Sprite sprite = overrideSprite;  
118.             if (sprite == null)  
119.                 return true;  
120.   
121.             Vector2 local;  
122.             RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, screenPoint, eventCamera, out local);  
123.   
124.             Rect rect = GetPixelAdjustedRect();  
125.   
126.             // Convert to have lower left corner as reference point.  
127.             local.x += rectTransform.pivot.x * rect.width;  
128.             local.y += rectTransform.pivot.y * rect.height;  
129.   
130.             local = MapCoordinate(local, rect);  
131.   
132.             // Normalize local coordinates.  
133.             Rect spriteRect = sprite.textureRect;  
134.             Vector2 normalized = new Vector2(local.x / spriteRect.width, local.y / spriteRect.height);  
135.   
136.             // Convert to texture space.  
137.             float x = Mathf.Lerp(spriteRect.x, spriteRect.xMax, normalized.x) / sprite.texture.width;  
138.             float y = Mathf.Lerp(spriteRect.y, spriteRect.yMax, normalized.y) / sprite.texture.height;  
139.   
140.             try  
141.             {  
142.                 return sprite.texture.GetPixelBilinear(x, y).a >= m_EventAlphaThreshold;  
143.             }  
144.             catch (UnityException e)  
145.             {  
146.                 Debug.LogError("Using clickAlphaThreshold lower than 1 on Image whose sprite texture cannot be read. " + e.Message + " Also make sure to disable sprite packing for this sprite.", this);  
147.                 return true;  
148.             }  
149.         }  
150.   
151.         /// <summary>  
152.         /// Return image adjusted position  
153.         /// **Copied from Unity's Image component for now and simplified for UI Extensions primatives  
154.         /// </summary>  
155.         /// <param name="local"></param>  
156.         /// <param name="rect"></param>  
157.         /// <returns></returns>  
158.         private Vector2 MapCoordinate(Vector2 local, Rect rect)  
159.         {  
160.             Rect spriteRect = sprite.rect;  
161.                 return new Vector2(local.x * spriteRect.width / rect.width, local.y * spriteRect.height / rect.height);  
162.         }  
163.   
164.         Vector4 GetAdjustedBorders(Vector4 border, Rect rect)  
165.         {  
166.             for (int axis = 0; axis <= 1; axis++)  
167.             {  
168.                 float combinedBorders = border[axis] + border[axis + 2];  
169.                 if (rect.size[axis] < combinedBorders && combinedBorders != 0)  
170.                 {  
171.                     float borderScaleRatio = rect.size[axis] / combinedBorders;  
172.                     border[axis] *= borderScaleRatio;  
173.                     border[axis + 2] *= borderScaleRatio;  
174.                 }  
175.             }  
176.             return border;  
177.         }  
178.  
179.         #endregion  
180.   
181.   
182.     }  
183. }  

            其中要说明的    1、  是否参与绘制 _isShowUI  （只是接受检测，涉及到填充率, 在编辑器下编辑完多边形测试OK，就设置为false） 。   2、算法不涉及到  镂空精灵的算法，所以可以设置Sprite属性。

2、镂空精灵

          镂空就是  透明的区域不接受检测，不透明区域接受检测。  透明不透明的指标自己定吧！

[csharp]  view plain  copy

1. using UnityEngine;  
2. using System.Collections.Generic;  
3. using UnityEngine.UI;  
4. using UnityEngine.EventSystems;  
5. using UnityEngine.Assertions.Must;  
6.   
7. namespace SGD  
8. {  
9.     /// <summary>  
10.     /// 描述：  
11.     /// author： sunguangdong  
12.     /// </summary>  
13.     [AddComponentMenu("SGD/UnregularButtonWithPixel ")]  
14.     [RequireComponent(typeof(Image))]  
15.     public class UnregularButtonWithPixel : MonoBehaviour, IPointerClickHandler  
16.     {  
17.         /// <summary>  
18.         /// Image组件  
19.         /// </summary>  
20.         private Image _image;  
21.   
22.         /// <summary>  
23.         /// 透明度临界值  
24.         /// </summary>  
25.         [Range(0.0f, 0.5f)]  
26.         public float _Alpha;  
27.   
28.         // 编辑器脚本 start  
29.         void Reset()  
30.         {  
31.             _image = transform.GetComponent<Image>();  
32.         }  
33.   
34.         public void OnValidate()  
35.         {  
36.             MustExtensions.MustBeFalse(!_image , "UnregularButtonWithPixel 脚本的 Inspector 面板的赋值 不全！");  
37.         }  
38.   
39.         // 编辑器脚本 end   
40.   
41.         public void Start()  
42.         {  
43.             //获取Image组件  
44.             _image = transform.GetComponent<Image>();  
45.             //设定透明度临界值  
46.             _image.eventAlphaThreshold = _Alpha;  
47.         }  
48.   
49.   
50.         public void OnPointerClick(PointerEventData eventData)  
51.         {  
52.             Debug.Log("点击到精灵");  
53.         }  
54.     }  
55. }  

             Canvas 下的空对象上  添加这个组件  测试

提醒，  检测的开关还有  （这两种方式  都会受到  下面的开关影响！）