unity让meshRenderer的渲染层级位于ngui的渲染序列中

后续补充：
2018-11-29 11:43:12
本文提到的方案，并不是最好的方案，只是我在做一项任务时的尝试所得！
其他自行百度 如何在NGUI中穿插特效 ，有很多好的、简单的解决方案！

参考方案：NGUI中穿插粒子或者mesh渲染层级

在UIpanel.cs/UIDrawCall.cs/UIWidget中添加 onRenderQueueChanged回调的位置参考中已经给出了，此处不赘述了

UITextureRecombine.cs

/*
 *2018-07-20 19:49:00 By Bo
 */
using UnityEngine;
using System.Collections;
using UnityEngine.Rendering;

[ExecuteInEditMode]
[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
[AddComponentMenu("NGUI/UI/NGUI TextureRecombine")]
public class UITextureRecombine : UIWidget
{
	int BaseW = 1334;
	int BaseH = 750;
    // 维护材质 贴图 以及 shader 
	[HideInInspector][SerializeField] Material mMaterial;
	[HideInInspector][SerializeField] Texture mMainTexture;
	[HideInInspector][SerializeField] Shader mShader;

	[HideInInspector][SerializeField] MeshFilter mMeshFilter;
	[HideInInspector][SerializeField] MeshRenderer mMeshRenderer;

	MeshFilter meshFilter
	{
		get
		{
			if (mMeshFilter == null) {
				mMeshFilter = GetComponent();
			}
			return mMeshFilter;
		}

		set
		{
			mMeshFilter = value;
		}
	}

	MeshRenderer meshRenderer
	{
		get
		{ 
			if (mMeshRenderer == null) {
				mMeshRenderer = GetComponent();
				mMeshRenderer.sharedMaterial = material;
				mMeshRenderer.sharedMaterial.shader = shader;
				mMeshRenderer.shadowCastingMode = ShadowCastingMode.Off;
				mMeshRenderer.receiveShadows = false;
				mMeshRenderer.motionVectors = false;
				mMeshRenderer.lightProbeUsage = LightProbeUsage.Off;
				mMeshRenderer.reflectionProbeUsage = ReflectionProbeUsage.Off;

				Recombine();
			}
			return mMeshRenderer;
		}
		set
		{
			mMeshRenderer = value;
		}
	}


    // 重写
    public override Material material
    {
        get
        {
			if (mMaterial == null) mMaterial = new Material(shader);
            return mMaterial;
        }

        set
        {
            mMaterial = value;
        }
    }

    public override Shader shader
    {
        get
        {
			if (mShader == null) mShader = Shader.Find("Unlit/UITextureRecombine");
			return mShader;
        }

        set
        {
            mShader = value;
        }
    }

    public override Texture mainTexture
    {
        get
        {
            return mMainTexture;
        }

        set
        {
            mMainTexture = value;
			meshRenderer.sharedMaterial.mainTexture = mMainTexture;
        }
    }

    protected override void Awake()
    {
		mMainTexture = meshRenderer.sharedMaterial.mainTexture;

        // 这里缓存设置Drawcall渲染层级时的回调
        onRenderQueueChanged = OnRQChanged;

		base.Awake();
    }

    void OnRQChanged(int rq)
    {
		meshRenderer.sharedMaterial.renderQueue = rq;
		meshRenderer.sharedMaterial.shader = shader;
    }
		
    protected override void OnInit()
    {
        base.OnInit();
    }

    protected override void OnStart()
    {
        base.OnStart();
    }

    protected override void OnEnable()
    {
        base.OnEnable();
    }

    protected override void OnDisable()
    {
        base.OnDisable();
    }

    protected override void OnUpdate()
    {
        base.OnUpdate();
    }

    public override void OnFill(BetterList verts, BetterList uvs, BetterList cols)
    {
        // 创建一个空四边形占据一个dc;如过这里是空的话该组件就不会生成dc所以必须有一个；
        verts.Add(new Vector3(1, 0, 1));
        verts.Add(new Vector3(1, 0, -1));
        verts.Add(new Vector3(-1, 0, 1));
        verts.Add(new Vector3(-1, 0, -1));

        uvs.Add(new Vector2(1, 1));
        uvs.Add(new Vector2(1, 0));
        uvs.Add(new Vector2(0, 1));
        uvs.Add(new Vector2(0, 0));

        cols.Add(new Color32(255, 255, 255, 0));
        cols.Add(new Color32(255, 255, 255, 0));
        cols.Add(new Color32(255, 255, 255, 0));
        cols.Add(new Color32(255, 255, 255, 0));

        base.OnFill(verts, uvs, cols);
        if (onPostFill != null)
            onPostFill(this, verts.size, verts, uvs, cols);

        meshRenderer.sharedMaterial.color = color;
		transform.localScale = new Vector3 ((float)width/BaseW,(float)height/BaseH,1f);
    }

	public override void MakePixelPerfect ()
	{
		width = BaseW;
		height = BaseH;
		transform.localScale = new Vector3 ((float)width/BaseW,(float)height/BaseH,1f);
	}
	
	//这里是自定意一个mesh的渲染规则（图片的重组方案，后续会重开一片文章写这个优化的方法）
	//https://blog.csdn.net/u010314160/article/details/81144180
    void Recombine()
    {
        float value = 1 / 1024f;
        float halfx = - 1334/2f;
        float halfy = - 750 / 2f;
        Vector3[] newVertices = {
                                    new Vector3(1024f + halfx, 476f + halfy, 0),//0
                                    new Vector3(1334f + halfx, 476f + halfy, 0),//1
                                    new Vector3(1024f + halfx, 750f + halfy, 0),//2
                                    new Vector3(1334f + halfx, 750f + halfy, 0),//3

                                    new Vector3(1024f + halfx, 202f + halfy, 0),//4
                                    new Vector3(1334f + halfx, 202f + halfy, 0),//5
                                    new Vector3(1024f + halfx, 476f + halfy, 0),//6
                                    new Vector3(1334f + halfx, 476f + halfy, 0),//7

                                    new Vector3(1024f + halfx, 0 + halfy, 0),//8
                                    new Vector3(1334f + halfx, 0 + halfy, 0),//9
                                    new Vector3(1024 + halfx, 202f + halfy, 0),//10
                                    new Vector3(1334f + halfx, 202f + halfy, 0),//11

                                    new Vector3(0 + halfx, 0 + halfy, 0),//12
                                    new Vector3(1024f + halfx, 0 + halfy, 0),//13
                                    new Vector3(0 + halfx, 750f + halfy, 0),//14
                                    new Vector3(1024f + halfx, 750f + halfy, 0),//15
                                };
        Vector2[] newUV = {
                                new Vector3(0, 0),//0
                                new Vector3(310*value, 0),//1
                                new Vector3(0, 274*value),//2
                                new Vector3(310*value, 274*value),//3

                                new Vector3(310*value, 0),//4
                                new Vector3(620*value, 0),//5
                                new Vector3(310*value, 274*value),//6
                                new Vector3(620*value, 274*value),//7

                                new Vector3(620*value, 0),//8
                                new Vector3(930*value, 0),//9
                                new Vector3(620*value, 202*value),//10
                                new Vector3(930*value, 202*value),//11

                                new Vector3(0, 274*value),//12
                                new Vector3(1024*value, 274*value),//13
                                new Vector3(0, 1024*value),//14
                                new Vector3(1024*value, 1024*value),//15
                          };
        int[] newTriangles = { 
                                 0,2,1,
                                 1,2,3,
                                 
                                 4,6,5,
                                 5,6,7,

                                 9,8,10,
                                 9,10,11,

                                 13,12,14,
                                 13,14,15,
                             };

        Mesh mesh = new Mesh();
        meshFilter.mesh = mesh;

        mesh.vertices = newVertices;
        mesh.uv = newUV;
        mesh.triangles = newTriangles;
    }
}

UITextureRecombine.shader

Shader "Unlit/UITextureRecombine"
{
    Properties
    {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Base (RGB), Alpha (A)", 2D) = "black" {}
    }
    
    SubShader
    {
        LOD 200

        Tags
        {
            "Queue" = "Transparent"
            "IgnoreProjector" = "True"
            "RenderType" = "Transparent"
        }
        
        Pass
        {
            Cull Off
            Lighting Off
            ZWrite Off
            Fog { Mode Off }
            Offset -1, -1
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag           
            #include "UnityCG.cginc"

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _Color;
    
            struct appdata_t
            {
                float4 vertex : POSITION;
                float2 texcoord : TEXCOORD0;
                fixed4 color : COLOR;
            };
    
            struct v2f
            {
                float4 vertex : SV_POSITION;
                half2 texcoord : TEXCOORD0;
                fixed4 color : COLOR;
            };
    
            v2f o;

            v2f vert (appdata_t v)
            {
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.texcoord = v.texcoord;
                o.color = v.color;
                return o;
            }
                
            fixed4 frag (v2f IN) : COLOR
            {
                return tex2D(_MainTex, IN.texcoord) * IN.color * _Color;
            }
            ENDCG
        }
    }

}

在UIRoot下新建一个空物体，添加UITextureRecombine.cs脚本,指定Texture。调节Depth测试渲染顺序。
备注：这里的Pivot属性并没有实现，只是在调节Size的时候会依据一个固定的尺寸就行缩放，做屏幕适配的话，需要自行考虑了。