0312 HttpWebRequest请求CDN资源改用UnityWebRequest

hch

2024-09-26 f44f7df16e9f510c21aadee1d9f08e29a3bb415e

 Assets/Editor/Tool/UpdateSpritePackingSetting.cs

@@ -4,6 +4,9 @@
using UnityEditor;
using System.IO;
using System;
using UnityEditor.U2D;
using UnityEngine.U2D;


public class UpdateSpritePackingSetting

{
@@ -35,21 +38,7 @@
            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)

            {

@@ -69,24 +58,21 @@
                    {

                        continue;

                    }



                    if (!setting.Equal(textureImporter))

                    bool isChange = false;

                    if (textureImporter.textureType != TextureImporterType.Sprite)

                    {

                        textureImporter.textureType = TextureImporterType.Sprite;

                        isChange = true;

                    }



                    if (textureImporter.spriteImportMode != SpriteImportMode.Single)

                    {

                        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;

                        isChange = true;

                    }



                        foreach (var platformSetting in textureImporterPlatformSettings)

                        {

                            textureImporter.SetPlatformTextureSettings(platformSetting);

                        }



                    if (isChange)

                    {

                        AssetDatabase.ImportAsset(importerPath);

                        EditorUtility.SetDirty(textureImporter);

                    }

@@ -108,48 +94,249 @@
        AssetDatabase.Refresh();



        EditorUtility.ClearProgressBar();



        SpritePack();

    }



    [MenuItem("程序/Sprite/初始化Sprite设置")]

    public static void Init()

    [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 = ScriptableObject.CreateInstance<SpriteSettingConfig>();

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



        var directorys = Directory.GetDirectories(rootPath);

        so.spriteSettings = new SpriteSettingConfig.SpriteSetting[directorys.Length];



        var index = 0;

        foreach (var directory in directorys)

        if (so == null)

        {

            var spriteSetting = so.spriteSettings[index] = new SpriteSettingConfig.SpriteSetting();

            return;

        }



            spriteSetting.alphaSource = TextureImporterAlphaSource.FromInput;

            spriteSetting.folderName = Path.GetFileName(directory);

            spriteSetting.meshType = SpriteMeshType.Tight;

        int index = 0;

        foreach (SpriteSettingConfig.SpriteSetting setting in so.spriteSettings)

        {

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



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

            if (!Directory.Exists(directoryPath))

            {

                return;

            }

            


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

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

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

            spritefilePathName = setting.folderName;



            spriteSetting.platformSettings[0].name = "Standalone";

            spriteSetting.platformSettings[1].name = "Android";

            spriteSetting.platformSettings[2].name = "iPhone";

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

            SpriteAtlasAsset spriteAtlas = SpriteAtlasAsset.Load(filePath);



            spriteSetting.platformSettings[0].textureFormat = TextureImporterFormat.RGBA32;

            spriteSetting.platformSettings[1].textureFormat = TextureImporterFormat.ETC2_RGBA8;

            spriteSetting.platformSettings[2].textureFormat = TextureImporterFormat.PVRTC_RGBA4;

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

            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++;

        }



        AssetDatabase.DeleteAsset(path);

        AssetDatabase.CreateAsset(so, path);

        AssetDatabase.SaveAssets();

        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);

            }

        }

    }



   


}