Unity性能优化之特效合并

特效合并，意思是说将粒子所用的零碎图片，以shader为单位合并成一张图集，好处就是可以降低draw call。试想，合并前每个粒子使用一个material，而每一个material就要占用一个drawcall，而合并后多个粒子可以用同一个material，这样就降低了drawcall，提升了性能。

转载请注明出处：http://www.cnblogs.com/jietian331/p/8625078.html

合并工具的代码如下：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using UnityEditor;
using UnityEngine;

namespace AssetBundle
{
    public class ParticleSystemCombiner : ScriptableObject
    {
        public const string
            AtlasFolder = "Assets/Cloth/Resources/ParticleSystemAtlas",
            ParticleAtlasPath = "Assets/Cloth/Resources/ParticleSystemAtlas/particle_atlas.prefab",
            SettingFilepath = "Assets/Editor/ParticleSystemCombinerSetting.csv";

        static string[] EffectObjFolders = new string[] 
        { 
            "Assets/Cloth/Resources/Effect/Cloth",
            "Assets/Cloth/Resources/Model/Equip",
        };

        static ParticleAtlases s_atlasesData;
        static List<string> s_materials;
        static Dictionary<string, int> s_texturesSize;

        static ParticleAtlases AtlasesData
        {
            get
            {
                if (s_atlasesData == null)
                    s_atlasesData = AssetDatabase.LoadAssetAtPath<ParticleAtlases>(ParticleAtlasPath);
                return s_atlasesData;
            }
        }

        static Dictionary<string, int> TexturesSize
        {
            get
            {
                if (s_texturesSize == null)
                {
                    s_texturesSize = new Dictionary<string, int>();

                    string[] lines = File.ReadAllLines(SettingFilepath);
                    bool decode = false;
                    foreach (var line in lines)
                    {
                        if (!decode)
                        {
                            if (line.StartsWith("# Texture Size"))
                            {
                                decode = true;
                            }
                        }
                        else
                        {
                            if (line.StartsWith("#"))
                            {
                                decode = false;
                            }
                        }

                        if (decode)
                        {
                            string[] words = line.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                            if (words.Length > 1)
                            {
                                string name = words[0];
                                int size;
                                int.TryParse(words[1], out size);
                                if (size != 0)
                                    s_texturesSize[name] = size;
                            }
                        }
                    }
                }
                return s_texturesSize;
            }
        }


        static List<string> NotCombineTextures
        {
            get
            {
                List<string> list = new List<string>();
                string[] lines = File.ReadAllLines(SettingFilepath);
                bool decode = false;
                foreach (var line in lines)
                {
                    if (!decode)
                    {
                        if (line.StartsWith("# Not Combine Textures"))
                        {
                            decode = true;
                        }
                    }
                    else
                    {
                        if (line.StartsWith("#"))
                        {
                            decode = false;
                        }
                    }

                    if (decode)
                    {
                        string[] words = line.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                        if (words.Length > 0 && !string.IsNullOrEmpty(words[0]))
                        {
                            list.Add(words[0]);
                        }
                    }
                }
                return list;
            }
        }

        #region for build

        public static void ClearCache()
        {
            s_atlasesData = null;
            s_materials = null;
        }

        public static List<ParticleAtlases.TextureItem> GetParticlesUsedAtlas(GameObject effectObj)
        {
            List<ParticleAtlases.TextureItem> texturesData = new List<ParticleAtlases.TextureItem>();
            ParticleSystem[] particles = effectObj.GetComponentsInChildren<ParticleSystem>(true);

            foreach (ParticleSystem ps in particles)
            {
                ParticleSystemRenderer render = ps.GetComponent<ParticleSystemRenderer>();
                if (!render || !render.sharedMaterial)
                {
                    Debug.LogWarning("Particle no material: " + ps.name);
                    continue;
                }

                Texture texture = render.sharedMaterial.mainTexture;
                if (ps.textureSheetAnimation.enabled || !texture)
                    continue;

                foreach (var atlasData in AtlasesData.Atlases)
                {
                    foreach (var t in atlasData.Textures)
                    {
                        if (t.Name == texture.name)
                        {
                            texturesData.Add(t);
                            break;
                        }
                    }
                }
            }

            return texturesData;
        }

        public static void ProcessEffectObj(GameObject obj)
        {
            ParticleSystem[] particles = obj.GetComponentsInChildren<ParticleSystem>(true);

            foreach (ParticleSystem ps in particles)
            {
                ParticleSystemRenderer render = ps.GetComponent<ParticleSystemRenderer>();
                if (!render || !render.sharedMaterial)
                {
                    Debug.LogWarning("Particle no material: " + ps.name);
                    continue;
                }

                Texture texture = render.sharedMaterial.mainTexture;
                if (ps.textureSheetAnimation.enabled || !texture)
                    continue;

                ParticleAtlases.Atlas target = AtlasesData.Atlases.FirstOrDefault(a => a.Textures.Any(t => t.Name == texture.name && t.ShaderName == render.sharedMaterial.shader.name));

                if (target != null)
                {
                    ParticleLoader loader = ps.GetComponent<ParticleLoader>();
                    if (!loader)
                        loader = ps.gameObject.AddComponent<ParticleLoader>();
                    loader.TextureName = texture.name;
                    loader.ShaderName = render.sharedMaterial.shader.name;
                    render.sharedMaterial = null;

                    if (!ps.trails.enabled)
                        render.trailMaterial = null;
                }
            }

            EditorUtility.SetDirty(obj);
            AssetDatabase.SaveAssets();
        }

        public static List<string> GetAllMaterials()
        {
            if (s_materials != null)
                return s_materials;

            List<string> effects;
            Dictionary<Shader, List<ParticleSystem>> dic = GetAllParticles(out effects);
            s_materials = new List<string>();

            foreach (var pair in dic)
            {
                foreach (ParticleSystem ps in pair.Value)
                {
                    ParticleSystemRenderer r = ps.GetComponent<ParticleSystemRenderer>();
                    string path = AssetDatabase.GetAssetPath(r.sharedMaterial);
                    if (!s_materials.Contains(path))
                        s_materials.Add(path);
                }
            }

            return s_materials;
        }

        #endregion


        [MenuItem("BuildTool/AssetBundle/Combine Particle System")]
        static void Init()
        {
            CombineAllEffectTextures();

            EditorUtility.DisplayDialog("finished", "All work finished.", "ok");
        }

        static Dictionary<Shader, List<ParticleSystem>> GetAllParticles(out List<string> effectObjs)
        {
            // 获取所有的粒子
            List<ParticleSystem> particlesList = new List<ParticleSystem>();
            List<string> objPaths = new List<string>();
            foreach (var effectObjFolder in EffectObjFolders)
            {
                string[] paths = Directory.GetFiles(effectObjFolder, "*.prefab", SearchOption.AllDirectories);
                objPaths.AddRange(paths);
            }
            effectObjs = new List<string>();

            foreach (string path in objPaths)
            {
                string pathFixed = path.Replace("\", "/");
                effectObjs.Add(pathFixed);
                GameObject obj = AssetDatabase.LoadAssetAtPath<GameObject>(pathFixed);
                ParticleSystem[] particles = obj.GetComponentsInChildren<ParticleSystem>(true);

                foreach (ParticleSystem ps in particles)
                {
                    ParticleSystemRenderer r = ps.GetComponent<ParticleSystemRenderer>();
                    bool needCombine = !ps.textureSheetAnimation.enabled
                        && r.sharedMaterial
                        && r.sharedMaterial.shader.name != "Particles/Alpha Blended Premultiply"
                        && r.sharedMaterial.mainTexture
                        && r.sharedMaterial.mainTexture.width == r.sharedMaterial.mainTexture.height;
                    if (needCombine)
                        particlesList.Add(ps);
                }
            }

            // 分类
            Dictionary<Shader, List<ParticleSystem>> dic = new Dictionary<Shader, List<ParticleSystem>>();
            foreach (ParticleSystem ps in particlesList)
            {
                ParticleSystemRenderer r = ps.GetComponent<ParticleSystemRenderer>();
                var shader = r.sharedMaterial.shader;
                if (!dic.ContainsKey(shader))
                    dic[shader] = new List<ParticleSystem>();
                dic[shader].Add(ps);
            }

            return dic;
        }

        public static List<string> CombineAllEffectTextures()
        {
            List<string> atlases = new List<string>();

            // 获取所有的粒子
            List<string> effects;
            Dictionary<Shader, List<ParticleSystem>> dic = GetAllParticles(out effects);

            // combine
            Dictionary<Texture2D, Material> dictTextures = new Dictionary<Texture2D, Material>();
            List<ParticleAtlases.Atlas> atlasesData = new List<ParticleAtlases.Atlas>();
            List<string> notCombineTextures = NotCombineTextures;

            foreach (var pair in dic)
            {
                // get textures
                dictTextures.Clear();
                foreach (ParticleSystem ps in pair.Value)
                {
                    ParticleSystemRenderer r = ps.GetComponent<ParticleSystemRenderer>();
                    Texture2D texture = (Texture2D)r.sharedMaterial.mainTexture;
                    if (!notCombineTextures.Contains(texture.name) && !dictTextures.ContainsKey(texture))
                        dictTextures.Add(texture, r.sharedMaterial);
                }

                if (dictTextures.Count < 2)
                    continue;

                Texture2D[] texturesArray = dictTextures.Keys.ToArray();

                // combine texture
                string atlasName = string.Format("ParticleAtlas_{0}", Path.GetFileNameWithoutExtension(pair.Key.name));
                string atlasPath = string.Format("{0}/{1}.png", AtlasFolder, atlasName);
                Uploader.CreateDirectory(atlasPath);
                Rect[] rects;
                Vector2[] textureSizes;
                Texture2D atlas = CombineTextures(texturesArray, atlasPath, out rects, out textureSizes);
                atlases.Add(atlasPath);

                // create material
                string matPath = string.Format("{0}/{1}.mat", AtlasFolder, atlasName);
                Material mat = AssetDatabase.LoadAssetAtPath<Material>(matPath);
                if (mat == null)
                {
                    mat = new Material(pair.Key);
                    AssetDatabase.CreateAsset(mat, matPath);
                }
                mat.mainTexture = atlas;

                // get config
                ParticleAtlases.TextureItem[] texturesData = new ParticleAtlases.TextureItem[texturesArray.Length];
                for (int i = 0; i < texturesArray.Length; i++)
                {
                    Rect rect = rects[i];
                    Texture2D texture2D = texturesArray[i];
                    Vector2 textureSize = textureSizes[i];      // will resize temp texture, so cann't use texture2D.width
                    int numTilesX = (int)(atlas.width / textureSize.x);
                    int numTilesY = (int)(atlas.height / textureSize.y);
                    int colIndex = (int)(rect.x * numTilesX);
                    int rowIndex = (int)(numTilesY - 1 - rect.y * numTilesY);
                    int index = rowIndex * numTilesX + colIndex;

                    // get color
                    Material oldMat = dictTextures[texture2D];
                    Color32 oldColor = oldMat.GetColor("_TintColor");
                    string strColor = string.Format("{0}_{1}_{2}_{3}", oldColor.r, oldColor.g, oldColor.b, oldColor.a);

                    string shaderName = oldMat.shader.name;

                    int depth = oldMat.renderQueue;

                    texturesData[i] = new ParticleAtlases.TextureItem()
                    {
                        Color = oldColor,
                        Depth = depth,
                        Index = index,
                        Name = texture2D.name,
                        NumTilesX = numTilesX,
                        NumTilesY = numTilesY,
                        ShaderName = shaderName,
                    };
                }

                ParticleAtlases.Atlas atlasData = new ParticleAtlases.Atlas()
                {
                    Material = mat,
                    Textures = texturesData,
                };
                atlasesData.Add(atlasData);
            }

            GameObject prefabObj = AssetDatabase.LoadAssetAtPath<GameObject>(ParticleAtlasPath);
            if (!prefabObj)
                prefabObj = PrefabUtility.CreatePrefab(ParticleAtlasPath, new GameObject());
            ParticleAtlases atlasesCom = prefabObj.GetComponent<ParticleAtlases>();
            if (!atlasesCom)
                atlasesCom = prefabObj.AddComponent<ParticleAtlases>();
            atlasesCom.Atlases = atlasesData.ToArray();
            prefabObj.name = Path.GetFileNameWithoutExtension(ParticleAtlasPath);

            EditorUtility.SetDirty(prefabObj);
            AssetDatabase.SaveAssets();

            Debug.Log("All cloth effect textures combine finished!");

            return atlases;
        }

        static Texture2D CombineTextures(Texture2D[] textures, string path, out Rect[] rects, out Vector2[] textureSizes)
        {
            if (textures == null || textures.Length < 1)
            {
                Debug.LogError("None textures");
                rects = null;
                textureSizes = null;
                return null;
            }

            string tempFolderName = "_TempImages";
            string tempFolder = "Assets/" + tempFolderName;
            AssetDatabase.DeleteAsset(tempFolder);
            AssetDatabase.CreateFolder("Assets", tempFolderName);

            List<string> newPaths = new List<string>();
            var newTextures = new Texture2D[textures.Length];
            textureSizes = new Vector2[textures.Length];

            // 将原来的图片复制一份出来
            for (int i = 0; i < textures.Length; i++)
            {
                string texPath = AssetDatabase.GetAssetPath(textures[i]);
                if (File.Exists(texPath))
                {
                    string newPath = string.Format("{0}/{1}", tempFolder, Path.GetFileName(texPath));
                    AssetDatabase.CopyAsset(texPath, newPath);
                    newPaths.Add(newPath);
                }
                else
                {
                    Debug.Log("File not exists: " + texPath);
                }
            }

            // make it readable
            for (int i = 0; i < newPaths.Count; i++)
            {
                string newPath = newPaths[i];
                SetSourceTextureReadalbe(newPath);
                Texture2D t = AssetDatabase.LoadAssetAtPath<Texture2D>(newPath);
                textureSizes[i] = new Vector2(t.width, t.height);

                // 去掉边缘的一个像素
                if (t.width > 4)
                {
                    for (int j = 0; j < t.width; j++)
                    {
                        t.SetPixel(j, 0, new Color(0, 0, 0, 0));
                        t.SetPixel(j, 1, new Color(0, 0, 0, 0));
                        t.SetPixel(j, t.height - 1, new Color(0, 0, 0, 0));
                        t.SetPixel(j, t.height - 2, new Color(0, 0, 0, 0));
                    }
                }

                if (t.height > 4)
                {
                    for (int z = 0; z < t.height; z++)
                    {
                        t.SetPixel(0, z, new Color(0, 0, 0, 0));
                        t.SetPixel(1, z, new Color(0, 0, 0, 0));
                        t.SetPixel(t.width - 1, z, new Color(0, 0, 0, 0));
                        t.SetPixel(t.width - 2, z, new Color(0, 0, 0, 0));
                    }
                }

                newTextures[i] = t;
            }

            // pack
            Texture2D atlas = new Texture2D(1, 1, TextureFormat.ARGB32, false);
            rects = atlas.PackTextures(newTextures, 0, 4096, false);

            // save
            byte[] bytes = atlas.EncodeToPNG();
            File.WriteAllBytes(path, bytes);
            AssetDatabase.Refresh();
            AssetDatabase.SaveAssets();

            // setting
            TextureCompresser.CompressRGBA(path);

            // 删除临时目录
            AssetDatabase.DeleteAsset(tempFolder);

            AssetDatabase.Refresh();
            AssetDatabase.SaveAssets();

            return AssetDatabase.LoadAssetAtPath<Texture2D>(path);
        }

        static void SetSourceTextureReadalbe(string path)
        {
            string name = Path.GetFileNameWithoutExtension(path);
            int maxSize;
            TexturesSize.TryGetValue(name, out maxSize);
            if (maxSize == 0)
                maxSize = 64;

            bool readable = true;
            TextureImporterNPOTScale npotScale = TextureImporterNPOTScale.ToNearest;
            TextureWrapMode wrapMode = TextureWrapMode.Clamp;
            TextureImporterCompression compression = TextureImporterCompression.Uncompressed;

            bool changed = false;

            var importer = (TextureImporter)AssetImporter.GetAtPath(path);
            TextureImporterSettings settings = new TextureImporterSettings();
            importer.ReadTextureSettings(settings);

            settings.alphaIsTransparency = true;
            settings.mipmapEnabled = false;

            if (settings.readable != readable)
            {
                settings.readable = readable;
                changed = true;
            }

            if (settings.npotScale != npotScale)
            {
                settings.npotScale = npotScale;
                changed = true;
            }

            if (settings.wrapMode != wrapMode)
            {
                settings.wrapMode = wrapMode;
                changed = true;
            }

            if (importer.maxTextureSize != maxSize)
            {
                importer.maxTextureSize = maxSize;
                changed = true;
            }

            if (importer.textureCompression != compression)
            {
                importer.textureCompression = compression;
                changed = true;
            }

            // set platform overriten as false
            var androidSetting = importer.GetPlatformTextureSettings("Android");
            var iosSetting = importer.GetPlatformTextureSettings("iPhone");
            var pcSetting = importer.GetPlatformTextureSettings("Standalone");
            if (androidSetting.overridden)
            {
                androidSetting.overridden = false;
                changed = true;
            }
            if (iosSetting.overridden)
            {
                iosSetting.overridden = false;
                changed = true;
            }
            if (pcSetting.overridden)
            {
                pcSetting.overridden = false;
                changed = true;
            }
            importer.SetPlatformTextureSettings(androidSetting);
            importer.SetPlatformTextureSettings(iosSetting);
            importer.SetPlatformTextureSettings(pcSetting);

            if (changed)
            {
                importer.SetTextureSettings(settings);
                AssetDatabase.ImportAsset(path);
            }
        }

    }
}

加载的代码：

using UnityEngine;

public partial class ParticleLoader : MonoBehaviour
{
    public string TextureName;
    public string ShaderName;
}

using Common;
using UnityEngine;

public partial class ParticleLoader : MonoBehaviour
{
    static ParticleAtlases s_atlases;


    // 加载图集
    public static void Initialize()
    {
        BundleLoader.Singleton.LoadAssetBundle("atlases/particlesystematlas.u", r =>
        {
            GameObject[] objs = r.Bundle.LoadAllAssets<GameObject>();
            s_atlases = objs[0].GetComponent<ParticleAtlases>();
        });
    }

    void OnEnable()
    {
        Load();
    }

    void Load()
    {
        ParticleSystemRenderer renderer = GetComponent<ParticleSystemRenderer>();
        if (!renderer)
            return;

        ParticleAtlases.Atlas targetAtlas = null;
        ParticleAtlases.TextureItem targetTextureConfig = null;

        // 找对应的配置
        for (int i = 0; i < s_atlases.Atlases.Length; i++)
        {
            ParticleAtlases.Atlas atlasData = s_atlases.Atlases[i];
            for (int j = 0; j < atlasData.Textures.Length; j++)
            {
                ParticleAtlases.TextureItem textureData = atlasData.Textures[j];
                if (textureData.Name == this.TextureName && textureData.ShaderName == this.ShaderName)
                {
                    targetAtlas = atlasData;
                    targetTextureConfig = textureData;
                    break;
                }
            }

            if (targetAtlas != null)
                break;
        }

        if (targetAtlas != null && targetTextureConfig != null)
        {
            ParticleSystem ps = GetComponent<ParticleSystem>();

            renderer.sharedMaterial = targetAtlas.Material;             // 渲染

            SetTextureSheet(ps, targetTextureConfig);                   // 设置格子

            SetStartColor(ps, renderer, targetTextureConfig.Color);     // 设置颜色

            SetDepth(renderer, targetTextureConfig);                    // 排序
        }
    }

    // 设置格子
    void SetTextureSheet(ParticleSystem ps, ParticleAtlases.TextureItem targetTextureConfig)
    {
        var tsa = ps.textureSheetAnimation;
        float curveConstant = (float)targetTextureConfig.Index / targetTextureConfig.NumTilesX / targetTextureConfig.NumTilesY;
        tsa.enabled = true;
        tsa.numTilesX = targetTextureConfig.NumTilesX;
        tsa.numTilesY = targetTextureConfig.NumTilesY;
        tsa.animation = ParticleSystemAnimationType.WholeSheet;
        tsa.startFrame = new ParticleSystem.MinMaxCurve(0);
        tsa.frameOverTime = new ParticleSystem.MinMaxCurve(curveConstant);
        tsa.cycleCount = 1;
    }

    // 设置颜色
    void SetStartColor(ParticleSystem ps, ParticleSystemRenderer renderer, Color matColor)
    {
        var main = ps.main;
        switch (main.startColor.mode)
        {
            case ParticleSystemGradientMode.Color:
            case ParticleSystemGradientMode.Gradient:
            case ParticleSystemGradientMode.RandomColor:
            case ParticleSystemGradientMode.TwoGradients:
                var targetColor = main.startColor.color * matColor;
                main.startColor = new UnityEngine.ParticleSystem.MinMaxGradient(targetColor);
                break;

            case ParticleSystemGradientMode.TwoColors:
                var colorMin = main.startColor.colorMin * matColor;
                var colorMax = main.startColor.colorMax * matColor;
                main.startColor = new UnityEngine.ParticleSystem.MinMaxGradient(colorMin, colorMax);
                break;

            default:
                Debug.LogError("Unknown mode: " + main.startColor.mode);
                break;
        }

        renderer.sharedMaterial.SetColor("_TintColor", Color.white);
    }

    // 排序
    void SetDepth(ParticleSystemRenderer renderer, ParticleAtlases.TextureItem targetTextureConfig)
    {
        int depth = targetTextureConfig.Depth;
        if (depth > 0 && renderer.sharedMaterial.renderQueue < depth)
            renderer.sharedMaterial.renderQueue = depth;
    }

}

 合并后的图集如下：

 合并后的粒子如下：

效果如下：