public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
        {
            if ((renderingData.cameraData.camera.cullingMask & m_settings.LayerMask) != 0)
            {
                IMeshesCache    meshesCache    = IOC.Resolve <IMeshesCache>(m_settings.MeshesCacheName);
                IRenderersCache renderersCache = IOC.Resolve <IRenderersCache>(m_settings.RenderersCacheName);
                ICustomOutlineRenderersCache customRenderersCache = IOC.Resolve <ICustomOutlineRenderersCache>(m_settings.CustomRenderersCacheName);

                if ((meshesCache == null || meshesCache.IsEmpty) && (renderersCache == null || renderersCache.IsEmpty) && (customRenderersCache == null || customRenderersCache.GetOutlineRendererItems().Count == 0))
                {
                    return;
                }

                var src = renderer.cameraColorTarget;
                m_scriptablePass.Setup(src, meshesCache, renderersCache, customRenderersCache);
                renderer.EnqueuePass(m_scriptablePass);
            }
        }
            public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
            {
                CommandBuffer cmd = CommandBufferPool.Get("RenderSelection");

                if (m_meshesCache != null)
                {
                    IList <RenderMeshesBatch> batches = m_meshesCache.Batches;
                    for (int i = 0; i < batches.Count; ++i)
                    {
                        RenderMeshesBatch batch = batches[i];
                        for (int j = 0; j < batch.Mesh.subMeshCount; ++j)
                        {
                            if (batch.Mesh != null)
                            {
                                cmd.DrawMeshInstanced(batch.Mesh, j, Settings.PrepassMaterial, 0, batch.Matrices, batch.Matrices.Length);
                            }
                        }
                    }
                }

                if (m_renderersCache != null)
                {
                    IList <Renderer> renderers = m_renderersCache.Renderers;
                    for (int i = 0; i < renderers.Count; ++i)
                    {
                        Renderer renderer = renderers[i];
                        if (renderer != null && renderer.enabled && renderer.gameObject.activeSelf)
                        {
                            Material[] materials = renderer.sharedMaterials;

                            for (int j = 0; j < materials.Length; ++j)
                            {
                                if (materials[j] != null)
                                {
                                    cmd.DrawRenderer(renderer, Settings.PrepassMaterial, j);
                                }
                            }
                        }
                    }
                }

                if (m_customRenderersCache != null)
                {
                    List <ICustomOutlinePrepass> renderers = m_customRenderersCache.GetOutlineRendererItems();
                    for (int i = 0; i < renderers.Count; ++i)
                    {
                        ICustomOutlinePrepass renderer = renderers[i];
                        if (renderer != null && renderer.GetRenderer().gameObject.activeSelf)
                        {
                            Material[] materials = renderer.GetRenderer().sharedMaterials;

                            for (int j = 0; j < materials.Length; ++j)
                            {
                                if (materials[j] != null)
                                {
                                    cmd.DrawRenderer(renderer.GetRenderer(), renderer.GetOutlinePrepassMaterial(), j);
                                }
                            }
                        }
                    }
                }

                cmd.Blit(m_prepassRT, m_blurredRT);
                cmd.SetGlobalFloat(m_outlineStrengthId, Settings.OutlineStength);
                cmd.SetGlobalVector(m_blurDirectionId, new Vector2(Settings.BlurSize, 0));
                cmd.Blit(m_blurredRT, m_tmpRT, Settings.BlurMaterial, 0);
                cmd.SetGlobalVector(m_blurDirectionId, new Vector2(0, Settings.BlurSize));
                cmd.Blit(m_tmpRT, m_blurredRT, Settings.BlurMaterial, 0);

                cmd.Blit(m_cameraColorRT, m_tmpRT);
                cmd.SetGlobalTexture(m_prepassId, m_prepassRT);
                cmd.SetGlobalTexture(m_blurredId, m_blurredId);
                cmd.SetGlobalColor(m_outlineColorId, Settings.OutlineColor);
                cmd.Blit(m_tmpRT, m_cameraColorRT, Settings.CompositeMaterial);

                context.ExecuteCommandBuffer(cmd);
                CommandBufferPool.Release(cmd);
            }