Unity中的粒子特效的 RendererQ 排序

这里接https://www.cnblogs.com/luguoshuai/p/10021660.html

这里介绍两套粒子排序的方法。

首先声明，这两套排序方法均不是本人所写，是在项目开发的过程当中，看到同事的设计，然后我就记录了下来了，作为后续的学习与使用。

方法一：

 using System.Collections.Generic;
 using UnityEngine;

 public class UIRenderQueueSorter : MonoBehaviour
 {
     [SerializeField]
     UIWidget m_source;  //基础RendererQ，粒子的 RendererQ 均是在此基础上递增的
     [SerializeField]
     int m_offset;       //每次递增的幅度
     [SerializeField]
     List<Renderer> m_renderers = new List<Renderer>();

     public void Initialize()
     {
         Renderer[] renders = transform.GetComponentsInChildren<Renderer>(true);
         m_renderers.AddRange(renders);
     }

     void Update()
     {
         if (m_source && m_renderers.Count > )
         {
             for (int i = ; i < m_renderers.Count; i++)
             {
                 Renderer r = m_renderers[i];
                 if (r && r.sharedMaterial && m_source.drawCall != null)
                     r.sharedMaterial.renderQueue = m_source.drawCall.renderQueue + m_offset;
             }
         }
     }

     public void AddRenderer(Renderer r)
     {
         if (!m_renderers.Contains(r))
         {
             m_renderers.Add(r);
         }
     }

     public void ClearAllRenderers()
     {
         m_renderers.Clear();
     }

     public UIWidget Source
     {
         set { m_source = value; }
     }

     public int Offset
     {
         set { m_offset = value; }
     }
 }

用法介绍，将该脚本挂载到粒子特效的父级对象上，使用的时候，只需要调用一下Initialize()方法即可。

方法二:

这个其实是对NGUI的一个简答扩展，粒子的 RendererQ 是以Panel为单位来计算的

对NGUI的修改，添加如下变量:

     public List<UIParticlesEffectAutoSort> uiEffectList = new List<UIParticlesEffectAutoSort>();

修改NGUI的 LateUpdate 方法为如下:

 void LateUpdate ()
     {
 #if UNITY_EDITOR
         if (mUpdateFrame != Time.frameCount || !Application.isPlaying)
 #else
         if (mUpdateFrame != Time.frameCount)
 #endif
         {
             mUpdateFrame = Time.frameCount;

             // Update each panel in order
             for (int i = , imax = list.Count; i < imax; ++i)
                 list[i].UpdateSelf();

             int rq = ;
             int addRq = ;

             // Update all draw calls, making them draw in the right order
             for (int i = , imax = list.Count; i < imax; ++i)
             {
                 UIPanel p = list[i];

                 if (p.renderQueue == RenderQueue.Automatic)
                 {
                     p.startingRenderQueue = rq;
                     p.UpdateDrawCalls();
                     rq += p.drawCalls.Count;
                     addRq = ;
                     for(int j = ; j < p.uiEffectList.Count; ++j)
                     {
                         addRq = Mathf.Max(addRq, p.uiEffectList[j].UpdateRendererQueue(rq));
                     }
                     rq += addRq;
                 }
                 else if (p.renderQueue == RenderQueue.StartAt)
                 {
                     p.UpdateDrawCalls();
                     if (p.drawCalls.Count != )
                         rq = Mathf.Max(rq, p.startingRenderQueue + p.drawCalls.Count);
                 }
                 else // Explicit
                 {
                     p.UpdateDrawCalls();
                     if (p.drawCalls.Count != )
                         rq = Mathf.Max(rq, p.startingRenderQueue + );
                 }
             }
         }
     }

UIParticlesEffectAutoSort:

 using UnityEngine;
 using System.Collections.Generic;

 public class UIParticlesEffectAutoSort : MonoBehaviour
 {
     protected UIPanel panel;
     protected List<Material> mats = new List<Material>();
     int beginRenderQ = -, totalRenderQ = ;
     void Start()
     {
         panel = gameObject.GetComponentInParent<UIPanel>();
         if (panel == null)
         {
             enabled = false;
         }
         else
         {
             Renderer[] rds = gameObject.GetComponentsInChildren<Renderer>(true);
             for (int i = ; i < rds.Length; ++i)
             {
                 for (int j = ; j < rds[i].sharedMaterials.Length; ++j)
                 {
                     if (rds[i].sharedMaterials[j] != null)
                         mats.Add(rds[i].sharedMaterials[j]);
                 }
             }
             mats.Sort(delegate(Material a, Material b)
             {
                 return a.renderQueue.CompareTo(b.renderQueue);
             });
             panel.uiEffectList.Add(this);
         }
     }
     void OnDestroy()
     {
         if (panel != null)
             panel.uiEffectList.Remove(this);
     }
     public int UpdateRendererQueue(int rq)
     {
         if (panel == null)
             return ;
         if (mats.Count > )
         {
             if (beginRenderQ != rq)
             {
                 beginRenderQ = rq;
                 int tempRenderQ = -, addRenderQ = ;
                 for (int i = ; i < mats.Count; ++i)
                 {
                     if (mats[i] == null)
                         continue;
                     if (tempRenderQ != mats[i].renderQueue)
                     {
                         tempRenderQ = mats[i].renderQueue;
                         ++addRenderQ;
                     }
                     mats[i].renderQueue = beginRenderQ + addRenderQ;
                 }
                 totalRenderQ = addRenderQ + ;
             }
             return totalRenderQ;
         }
         return ;
     }
 }

用法:将该脚本挂载到粒子特效的父级对象上即可。

需要注意的是，这两个方法都是调整的 sharedMaterials，如果在使用的过程中发现粒子的层级不正确，试着调整materials即可。

比如，方法二：

 using System.Collections.Generic;
 using UnityEngine;

 public class UISelfParticalEffectAutoSort : UIParticlesEffectAutoSort
 {
     void Start()
     {
         panel = gameObject.GetComponentInParent<UIPanel>();
         if (panel == null)
         {
             enabled = false;
         }
         else
         {
             Renderer[] rds = gameObject.GetComponentsInChildren<Renderer>(true);
             for (int i = ; i < rds.Length; ++i)
             {
                 for (int j = , jMax = rds[i].materials.Length; j < jMax; ++j)
                 {
                     if (rds[i].materials[j] != null)
                         mats.Add(rds[i].materials[j]);
                 }
             }
             mats.Sort(delegate(Material a, Material b)
             {
                 return a.renderQueue.CompareTo(b.renderQueue);
             });
             panel.uiEffectList.Add(this);
         }
     }
     void OnDestroy()
     {
         if (panel != null)
             panel.uiEffectList.Remove(this);
         for (int i = mats.Count - ; i >= ; --i)
             GameObject.Destroy(mats[i]);
         mats.Clear();
     }
 }

主要看Start方法。