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 > 0)
        {
            for (int i = 0; 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 = 0, imax = list.Count; i < imax; ++i)
                list[i].UpdateSelf();

            int rq = 3000;
            int addRq = 0;

            // Update all draw calls, making them draw in the right order
            for (int i = 0, 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 = 0;
                    for(int j = 0; 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 != 0)
                        rq = Mathf.Max(rq, p.startingRenderQueue + p.drawCalls.Count);
                }
                else // Explicit
                {
                    p.UpdateDrawCalls();
                    if (p.drawCalls.Count != 0)
                        rq = Mathf.Max(rq, p.startingRenderQueue + 1);
                }
            }
        }
    }

UIParticlesEffectAutoSort:

using UnityEngine;
using System.Collections.Generic;

public class UIParticlesEffectAutoSort : MonoBehaviour
{
    protected UIPanel panel;
    protected List<Material> mats = new List<Material>();
    int beginRenderQ = -1, totalRenderQ = 0;
    void Start()
    {
        panel = gameObject.GetComponentInParent<UIPanel>();
        if (panel == null)
        {
            enabled = false;
        }
        else
        {
            Renderer[] rds = gameObject.GetComponentsInChildren<Renderer>(true);
            for (int i = 0; i < rds.Length; ++i)
            {
                for (int j = 0; 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 0;
        if (mats.Count > 0)
        {
            if (beginRenderQ != rq)
            {
                beginRenderQ = rq;
                int tempRenderQ = -1, addRenderQ = 0;
                for (int i = 0; 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 + 1;
            }
            return totalRenderQ;
        }
        return 0;
    }
}

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

需要注意的是，这两个方法都是调整的 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 = 0; i < rds.Length; ++i)
            {
                for (int j = 0, 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 - 1; i >= 0; --i)
            GameObject.Destroy(mats[i]);
        mats.Clear();
    }
}

主要看Start方法。