0312 删除旧的配置

hch

2024-07-23 5cdea335881fb992111553e68f9e546c2025d643

 Assets/Editor/Tool/UpdateSpritePackingSetting.cs

@@ -4,152 +4,339 @@
using UnityEditor;
using System.IO;
using System;
using UnityEditor.U2D;
using UnityEngine.U2D;

public class UpdateSpritePackingSetting

public class UpdateSpritePackingSetting

{
    static string rootPath = Application.dataPath + "/ResourcesOut/UI/Sprite";
    static string spriteRelativePath = "Assets/ResourcesOut/UI/Sprite";

    static string spriteRelativePath = "Assets/ResourcesOut/UI/Sprite";



    [MenuItem("程序/Sprite/标准化Sprite设置")]
    public static void UpdateAllSpritePackingSetting()
    {
        var path = "Assets/Editor/SpritePacking/SpriteSettings.asset";
        var so = AssetDatabase.LoadAssetAtPath<SpriteSettingConfig>(path);

        if (so == null)
        {
            return;
        }

        foreach (var setting in so.spriteSettings)
        {
            var directoryPath = StringUtility.Contact(rootPath, Path.DirectorySeparatorChar, setting.folderName);

            if (!Directory.Exists(directoryPath))
            {
                return;
            }

            var files = new DirectoryInfo(directoryPath).GetFiles("*.png", SearchOption.TopDirectoryOnly);

            var total = files.Length;
            var count = 0;

            var textureImporterPlatformSettings = new TextureImporterPlatformSettings[3];
            var index = 0;
            foreach (var platform in setting.platformSettings)
            {
                var platformSetting = textureImporterPlatformSettings[index] = new TextureImporterPlatformSettings();
                platformSetting.allowsAlphaSplitting = false;
                platformSetting.name = platform.name;
                platformSetting.allowsAlphaSplitting = false;
                platformSetting.overridden = true;
                platformSetting.maxTextureSize = platform.maxTextureSize;
                platformSetting.format = platform.textureFormat;
                platformSetting.compressionQuality = platform.compressionQuality;

                index++;
            }

            foreach (var file in files)
            {
                try
                {
                    var folderName = setting.folderName;
                    var importerPath = spriteRelativePath + "/" + folderName + "/" + file.Name;
                    var importer = AssetImporter.GetAtPath(importerPath);

                    if (importer == null)
                    {
                        continue;
                    }

                    var textureImporter = importer as TextureImporter;
                    if (textureImporter == null)
                    {
                        continue;
                    }

                    if (!setting.Equal(textureImporter))
                    {
                        textureImporter.textureType = TextureImporterType.Sprite;
                        textureImporter.spriteImportMode = SpriteImportMode.Single;
                        textureImporter.assetBundleName = StringUtility.Contact("ui/sprite/", setting.folderName.ToLower());
                        textureImporter.mipmapEnabled = false;
                        textureImporter.alphaSource = setting.alphaSource;
                        textureImporter.alphaIsTransparency = true;
                        textureImporter.spritePackingTag = folderName;
                        textureImporter.wrapMode = TextureWrapMode.Clamp;
                        textureImporter.filterMode = FilterMode.Bilinear;

                        foreach (var platformSetting in textureImporterPlatformSettings)
                        {
                            textureImporter.SetPlatformTextureSettings(platformSetting);
                        }

                        AssetDatabase.ImportAsset(importerPath);
                        EditorUtility.SetDirty(textureImporter);
                    }

                    count++;

                    EditorUtility.DisplayProgressBar(StringUtility.Contact("设置图集标签:", setting.folderName), file.Name, count / (float)total);
                }
                catch (Exception ex)
                {
                    DesignDebug.Log(ex);
                    EditorUtility.ClearProgressBar();
                }
            }

        }

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

        EditorUtility.ClearProgressBar();
    }

    [MenuItem("程序/Sprite/初始化Sprite设置")]
    public static void Init()
    {
        var path = "Assets/Editor/SpritePacking/SpriteSettings.asset";
        var so = ScriptableObject.CreateInstance<SpriteSettingConfig>();

        var directorys = Directory.GetDirectories(rootPath);
        so.spriteSettings = new SpriteSettingConfig.SpriteSetting[directorys.Length];

        var index = 0;
        foreach (var directory in directorys)
        {
            var spriteSetting = so.spriteSettings[index] = new SpriteSettingConfig.SpriteSetting();

            spriteSetting.alphaSource = TextureImporterAlphaSource.FromInput;
            spriteSetting.folderName = Path.GetFileName(directory);
            spriteSetting.meshType = SpriteMeshType.Tight;

            spriteSetting.platformSettings = new SpriteSettingConfig.PlatformSetting[3];

            spriteSetting.platformSettings[0] = new SpriteSettingConfig.PlatformSetting();
            spriteSetting.platformSettings[1] = new SpriteSettingConfig.PlatformSetting();
            spriteSetting.platformSettings[2] = new SpriteSettingConfig.PlatformSetting();

            spriteSetting.platformSettings[0].name = "Standalone";
            spriteSetting.platformSettings[1].name = "Android";
            spriteSetting.platformSettings[2].name = "iPhone";

            spriteSetting.platformSettings[0].textureFormat = TextureImporterFormat.RGBA32;
            spriteSetting.platformSettings[1].textureFormat = TextureImporterFormat.ETC2_RGBA8;
            spriteSetting.platformSettings[2].textureFormat = TextureImporterFormat.PVRTC_RGBA4;

            index++;
        }

        AssetDatabase.DeleteAsset(path);
        AssetDatabase.CreateAsset(so, path);
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();

    }

}
    public static void UpdateAllSpritePackingSetting()

    {

        var path = "Assets/Editor/SpritePacking/SpriteSettings.asset";

        var so = AssetDatabase.LoadAssetAtPath<SpriteSettingConfig>(path);



        if (so == null)

        {

            return;

        }



        foreach (var setting in so.spriteSettings)

        {

            var directoryPath = StringUtility.Contact(rootPath, Path.DirectorySeparatorChar, setting.folderName);



            if (!Directory.Exists(directoryPath))

            {

                return;

            }



            var files = new DirectoryInfo(directoryPath).GetFiles("*.png", SearchOption.TopDirectoryOnly);



            var total = files.Length;

            var count = 0;







            foreach (var file in files)

            {

                try

                {

                    var folderName = setting.folderName;

                    var importerPath = spriteRelativePath + "/" + folderName + "/" + file.Name;

                    var importer = AssetImporter.GetAtPath(importerPath);



                    if (importer == null)

                    {

                        continue;

                    }



                    var textureImporter = importer as TextureImporter;

                    if (textureImporter == null)

                    {

                        continue;

                    }

                    bool isChange = false;

                    if (textureImporter.textureType != TextureImporterType.Sprite)

                    {

                        textureImporter.textureType = TextureImporterType.Sprite;

                        isChange = true;

                    }



                    if (textureImporter.spriteImportMode != SpriteImportMode.Single)

                    {

                        textureImporter.spriteImportMode = SpriteImportMode.Single;

                        isChange = true;

                    }



                    if (isChange)

                    {

                        AssetDatabase.ImportAsset(importerPath);

                        EditorUtility.SetDirty(textureImporter);

                    }



                    count++;



                    EditorUtility.DisplayProgressBar(StringUtility.Contact("设置图集标签:", setting.folderName), file.Name, count / (float)total);

                }

                catch (Exception ex)

                {

                    DebugEx.Log(ex);

                    EditorUtility.ClearProgressBar();

                }

            }



        }



        AssetDatabase.SaveAssets();

        AssetDatabase.Refresh();



        EditorUtility.ClearProgressBar();



        SpritePack();

    }



    [MenuItem("程序/Sprite/打包BuiltIn图集")]

    public static void SpritePack_BuiltIn()

    {

        string rootPath_BuiltIn = Application.dataPath + "/ResourcesOut/BuiltIn/Sprites";

        string spriteRelativePath_BuiltIn = "Assets/ResourcesOut/BuiltIn/Sprites";

        var builtInSpritePath = spriteRelativePath_BuiltIn + "/sprites.spriteatlasv2";

        SpriteAtlasAsset spriteAtlas = SpriteAtlasAsset.Load(builtInSpritePath);



        // 不存在则创建后更新图集

        if (spriteAtlas == null)

        {

            var setting = new SpriteSettingConfig.SpriteSetting()

            {

                folderName = "sprites",

                blockOffset = 1,

                enableRotation = false,

                enableTightPacking = false,

                padding = 4,

                readable = false,

                generateMipMaps = false,

                sRGB = true,

                filterMode = FilterMode.Bilinear,

                platformSettings = new SpriteSettingConfig.PlatformSetting[]

                {

                    new SpriteSettingConfig.PlatformSetting()

                    {

                        name = "Android",

                        maxTextureSize = 2048,

                        textureCompression = TextureImporterCompression.Compressed,

                        textureFormat = TextureImporterFormat.ASTC_6x6

                    },

                    new SpriteSettingConfig.PlatformSetting()

                    {

                        name = "iPhone",

                        maxTextureSize = 2048,

                        textureCompression = TextureImporterCompression.Compressed,

                        textureFormat = TextureImporterFormat.ASTC_6x6

                    }

                }

            };

            spriteAtlas = CreateSpriteAtlas(spriteRelativePath_BuiltIn, setting);

        }

        List<string> excludePngs = new List<string>() { "Launch_1.png", "Launch_2.png", "Launch_3.png", "LoginBackGround.png", "TB_DL_Logo.png" };



        SpriteAtlas spriteAtlasTmp = AssetDatabase.LoadAssetAtPath(builtInSpritePath, typeof(UnityEngine.Object)) as SpriteAtlas;

        UpdateAtlas(spriteAtlas, rootPath_BuiltIn, excludePngs, builtInSpritePath);



        AssetDatabase.Refresh();



        Debug.Log("打包BuiltIn图集执行结束");

    }



    [MenuItem("程序/Sprite/打包图集")]

    public static void SpritePack()

    {

        var path = "Assets/Editor/SpritePacking/SpriteSettings.asset";

        var so = AssetDatabase.LoadAssetAtPath<SpriteSettingConfig>(path);



        if (so == null)

        {

            return;

        }



        int index = 0;

        foreach (SpriteSettingConfig.SpriteSetting setting in so.spriteSettings)

        {

            var directoryPath = StringUtility.Contact(rootPath, Path.DirectorySeparatorChar, setting.folderName);



            if (!Directory.Exists(directoryPath))

            {

                return;

            }

            


            spritefilePathName = setting.folderName;



            var filePath = spriteRelativePath + "/" + spritefilePathName + ".spriteatlasv2";

            SpriteAtlasAsset spriteAtlas = SpriteAtlasAsset.Load(filePath);



            // 不存在则创建后更新图集

            if (spriteAtlas == null)

            {

                spriteAtlas = CreateSpriteAtlas(spriteRelativePath, setting);

            }



            string spriteFilePath = rootPath + "/" + spritefilePathName;

            


            UpdateAtlas(spriteAtlas, spriteFilePath, new List<string>(), filePath);



            // 打包进度

            EditorUtility.DisplayProgressBar("打包图集中...", "正在处理:" + spritefilePathName, index / so.spriteSettings.Length);

            index++;

        }



        EditorUtility.ClearProgressBar();

        AssetDatabase.Refresh();

        UpdateSpriteSetting.SetAllSpriteAssetBundleName();



        Debug.Log("打包图集执行结束");



    }







    /// <summary>

    /// 每个需要打图集的文件夹名 -- 即图集名

    /// </summary>

    private static string spritefilePathName;



    /// <summary>

    /// 创建图集

    /// </summary>

    /// <param name="atlasName">图集名字</param>

    private static SpriteAtlasAsset CreateSpriteAtlas(string outPath, SpriteSettingConfig.SpriteSetting setting)

    {

        string atlasPath = outPath + "/" + setting.folderName + ".spriteatlasv2";

        CreateEmptySpriteAtlas(atlasPath);



        
        SpriteAtlasImporter atlasImporter = SpriteAtlasImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;



        #region 图集基础设置



        SpriteAtlasPackingSettings packSetting = new SpriteAtlasPackingSettings()

        {

            blockOffset = setting.blockOffset,

            enableRotation = setting.enableRotation,

            enableTightPacking = setting.enableTightPacking,

            padding = setting.padding,

        };

        atlasImporter.packingSettings = packSetting;



        #endregion



        #region 图集纹理设置



        SpriteAtlasTextureSettings textureSettings = new SpriteAtlasTextureSettings()

        {

            readable = setting.readable,

            generateMipMaps = setting.generateMipMaps,

            sRGB = setting.sRGB,

            filterMode = setting.filterMode,

        };

        atlasImporter.textureSettings = textureSettings;



        #endregion



        #region 分平台设置图集格式



        foreach (SpriteSettingConfig.PlatformSetting platformSetting in setting.platformSettings)

        {

            TextureImporterPlatformSettings settingPlatform = atlasImporter.GetPlatformSettings(platformSetting.name);

            settingPlatform.overridden = true;

            settingPlatform.maxTextureSize = platformSetting.maxTextureSize;

            settingPlatform.textureCompression = platformSetting.textureCompression;

            settingPlatform.format = platformSetting.textureFormat;

            atlasImporter.SetPlatformSettings(settingPlatform);

        }



        #endregion

        atlasImporter.includeInBuild = true;

        atlasImporter.SaveAndReimport();

        //atlas.Add(objectsForPack);

        SpriteAtlasAsset atlas = SpriteAtlasAsset.Load(atlasPath);

        


        return atlas;

    }



    static void CreateEmptySpriteAtlas(string atlasPath)

    {

        SpriteAtlasAsset.Save(new SpriteAtlasAsset(), atlasPath);

        AssetDatabase.SaveAssets();

        AssetDatabase.Refresh();

    }



    


    /// <summary>

    /// 每个图集的所有图片路径  --  记得用之前清空

    /// </summary>

    private static List<string> textureFullName = new List<string>();



    /// <summary>

    /// 更新图集内容

    /// </summary>

    /// <param name="atlas">图集</param>

    static void UpdateAtlas(SpriteAtlasAsset atlas, string spriteFilePath, List<string> excludePng, string filePath)

    {

        textureFullName.Clear();

        FileName(spriteFilePath, excludePng);



        SpriteAtlas spriteAtlasTmp = AssetDatabase.LoadAssetAtPath(filePath, typeof(UnityEngine.Object)) as SpriteAtlas;



        // 获取图集下图片

        List<UnityEngine.Object> packables = new List<UnityEngine.Object>(spriteAtlasTmp.GetPackables());



        foreach (string item in textureFullName)

        {

            // 加载指定目录

            UnityEngine.Object spriteObj = AssetDatabase.LoadAssetAtPath(item, typeof(UnityEngine.Object));

            //Debug.Log("存png和jpg后缀的图片: " + item + " , " + !packables.Contains(spriteObj));

            if (!packables.Contains(spriteObj))

            {

                atlas.Add(new UnityEngine.Object[] { spriteObj });

            }

        }



        SpriteAtlasAsset.Save(atlas, filePath);

    }



    /// <summary>

    /// 递归文件夹下的图

    /// </summary>

    /// <param name="folderPath"></param>

    static void FileName(string folderPath, List<string> excludePng)

    {

        DirectoryInfo info = new DirectoryInfo(folderPath);

        string str = Application.dataPath.Replace(@"/", @"\");



        foreach (DirectoryInfo item in info.GetDirectories())

        {

            FileName(item.FullName, excludePng);

        }

        foreach (FileInfo item in info.GetFiles())

        {

            // 存png和jpg后缀的图片

            if (item.FullName.EndsWith(".png", StringComparison.Ordinal) && !excludePng.Contains(item.Name))

            {

                textureFullName.Add("Assets" + item.FullName.Replace(str, ""));

            }

            if (item.FullName.EndsWith(".PNG", StringComparison.Ordinal))

            { 
                Debug.LogError("请将图片后缀改为小写: " + item.FullName);

            }

        }

    }



   


}