unity 纹理属性及UI图片导入设置

using System.Reflection;
using UnityEditor;
using UnityEngine;

public class ImportTexture : AssetPostprocessor
{
    public override uint GetVersion() { return 1; }
    static bool isForceImport = false;
    static string uiPath = ResDefine.GetResRelaPath(ResType.resPicture);

    //资源变化时处理
    static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
    {
        isForceImport = false;

        //移动资源的处理
        foreach (string str in movedAssets)
        {
            if (str.Contains(uiPath))
            {
                isForceImport = true;

                // 如果是移动到指定UI目录下，需要重新Import
                AssetDatabase.ImportAsset(str);
            }
        }
    }

    /// <summary>
    /// 图片导入前处理
    /// </summary>
    void OnPreprocessTexture()
    {
        if(assetPath.EndsWith(".dds"))
        {
            Debug.LogError("禁止使用dds格式图片，请检查：" + assetPath);
            return;
        }

        TextureImporter importer = assetImporter as TextureImporter;
        if (importer.userData != GetVersion().ToString() || isForceImport)
        {
            TextureImporterPlatformSettings setting = importer.GetDefaultPlatformTextureSettings();
            if (setting.maxTextureSize > 1024) Debug.LogWarningFormat("{0} 大小超过1024，已默认修改为1024，请自行检查，如需要请手动更改大小", assetPath);
            setting.maxTextureSize = DefineSpritePacker.kDefaultMaxSprite;
            importer.SetPlatformTextureSettings(setting);


            //此处只对UI图片进行处理，其他类型图片unity会默认设置ToNerest，默认情况下会得到最好的压缩
            if (assetPath.Contains(uiPath))
            {
                string spritrName = "";
                spritrName = assetPath.Replace("\\", "/");
                int _position = spritrName.LastIndexOf(@"/");
                spritrName = spritrName.Substring(0, _position);
                spritrName = spritrName.Replace("/", "_");
                spritrName.ToUpper();

                importer.textureType = TextureImporterType.Sprite;                              //精灵
                importer.spriteImportMode = SpriteImportMode.Single;                            //单图
                importer.wrapMode = TextureWrapMode.Clamp;                                      //循环 采样模式
                importer.filterMode = FilterMode.Bilinear;                                      //纹理拉伸时过滤模式
                importer.spritePixelsPerUnit = 100;                                             //每单位像素数
                importer.spritePackingTag = spritrName;                                         //图集名称
                importer.mipmapEnabled = false;                                                 //mip maps
                importer.isReadable = false;                                                    //可读写属性
                importer.alphaIsTransparency = importer.DoesSourceTextureHaveAlpha();           //透明通道是否透明
            }
        }
    }

    /// <summary>
    /// 图片导入后处理
    /// </summary>
    /// <param name="texture"></param>
    void OnPostprocessTexture(Texture2D texture)
    {
        TextureImporter importer = assetImporter as TextureImporter;

        if (importer.userData != GetVersion().ToString())
        {
            importer.userData = GetVersion().ToString();

            if(assetPath.Contains(uiPath))
            {
                TextureImporterPlatformSettings setting = importer.GetDefaultPlatformTextureSettings();

                TextureImporterPlatformSettings isettings = importer.GetPlatformTextureSettings("iPhone");
                isettings.overridden = true;
                isettings.maxTextureSize = setting.maxTextureSize;
                bool isPowerOfTwo = IsPowerOfTwo(texture);
                TextureImporterFormat defaultAlpha = isPowerOfTwo ? TextureImporterFormat.PVRTC_RGBA4 : TextureImporterFormat.ASTC_RGBA_4x4;
                TextureImporterFormat defaultNotAlpha = isPowerOfTwo ? TextureImporterFormat.PVRTC_RGB4 : TextureImporterFormat.ASTC_RGB_6x6;
                isettings.format = importer.DoesSourceTextureHaveAlpha() ? defaultAlpha : defaultNotAlpha;
                importer.SetPlatformTextureSettings(isettings);

                TextureImporterPlatformSettings asettings = importer.GetPlatformTextureSettings("Android");
                asettings.overridden = true;
                asettings.allowsAlphaSplitting = false;
                asettings.maxTextureSize = setting.maxTextureSize;
                bool divisible4 = IsDivisibleOf4(texture);
                defaultAlpha = divisible4 ? TextureImporterFormat.ETC2_RGBA8Crunched : TextureImporterFormat.ASTC_RGBA_4x4;
                defaultNotAlpha = divisible4 ? TextureImporterFormat.ETC_RGB4Crunched : TextureImporterFormat.ASTC_RGB_6x6;
                asettings.format = importer.DoesSourceTextureHaveAlpha() ? defaultAlpha : defaultNotAlpha;
                importer.SetPlatformTextureSettings(asettings);

                importer.SaveAndReimport();
                EditorUtility.SetDirty(importer);
            }
        }
    }

    /// <summary>
    /// 是否2的次幂
    /// </summary>
    /// <param name="importer"></param>
    /// <returns></returns>
    bool IsPowerOfTwo(TextureImporter importer)
    {
        (int width, int height) = GetTextureImporterSize(importer);
        return (width == height) && (width > 0) && ((width & (width - 1)) == 0);
    }

    /// <summary>
    /// 是否2的次幂
    /// </summary>
    /// <param name="texture"></param>
    /// <returns></returns>
    bool IsPowerOfTwo(Texture2D texture)
    {
        return (texture.width == texture.height) && (texture.width > 0) && ((texture.width & (texture.width - 1)) == 0);
    }

    /// <summary>
    /// 是否被4整除
    /// </summary>
    /// <param name="importer"></param>
    /// <returns></returns>
    bool IsDivisibleOf4(TextureImporter importer)
    {
        (int width, int height) = GetTextureImporterSize(importer);
        return (width % 4 == 0 && height % 4 == 0);
    }

    /// <summary>
    /// 是否被4整除
    /// </summary>
    /// <param name="texture"></param>
    /// <returns></returns>
    bool IsDivisibleOf4(Texture2D texture)
    {
        return (texture.width % 4 == 0 && texture.height % 4 == 0);
    }

    /// <summary>
    /// 获取图片的尺寸 - 获取的是资源原始尺寸，不是unity内显示的
    /// </summary>
    /// <param name="importer"></param>
    /// <returns></returns>
    (int, int) GetTextureImporterSize(TextureImporter importer)
    {
        if (importer != null)
        {
            object[] args = new object[2];
            MethodInfo mi = typeof(TextureImporter).GetMethod("GetWidthAndHeight", BindingFlags.NonPublic | BindingFlags.Instance);
            mi.Invoke(importer, args);
            return ((int)args[0], (int)args[1]);
        }
        return (0, 0);
    }