devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Unity编辑器扩展】包体优化神器,图片压缩,批量生成图集/图集变体,动画压缩_sprite atlas v1 v2

作者：我家自动化 | 2024-05-28 09:52:12

赞

踩

sprite atlas v1 v2

功能介绍：

1. 压缩工具支持对图片原文件压缩(支持png/jpg)，也支持使用Unity内置图片压缩批量对图片设置压缩参数。

2. 支持以文件夹或及其子文件夹为单位批量生成图集(SpriteAtlas), 支持同时生成图集变体(SpriteAtlas Variant)，支持忽略像素宽高大于限定值的图片打进图集。

3. 批量给现有图集(SpriteAtlas)生成图集变体，生成图集变体后可以调整图集的缩放

4. 动画压缩，降低animation clip序列化文件的浮点型精度，保留较少的小数以降低文件大小。

工具预览：

工具完整代码参见开源框架GF_HybridCLR

图片无疑是游戏资源大户，无论数量还是文件大小占比都非常高。使用TinyPng等压缩工具压缩，近乎疯狂的压缩比，通常可以将图片文件大小降低70%左右。

对于Cocos2d-x时代的项目通常都会使用TinyPng进行图片压缩。

然而对于Unity来说，压缩图片虽然能大幅降低图片文件大小，但是最终打出的包(AssetBundle或Addressables)文件大小并不会明显降低，甚至会比压缩图片前还大。这是因为Unity针对不同平台都有对应的图片压缩模式，无论你再怎么压缩，Unity导入图片或打包时都会再次使用对应平台的压缩方式重新压缩图片，这就导致在图片分辨率不变的情况下，最终打包后的资源大小并不能有效降低。

OpenAI的问答结果

但是。。。没错，还有但是，对于庞大的项目来说，合理压缩图片原文件可以有效降低工程大小，提高打开工程的加载速度等。然后通过工具的Unity内置图片压缩批量操作可以快速方便设置图片压缩参数。

AssetBundle提供了LZ4和LZMA两种压缩方式:

LZ4: 压缩/解压较快，压缩后的文件大。适用于在线压缩/解压、网络数据等需要频繁压缩/解压的情况。

LZMA: 压缩/解压较慢，压缩后的文件小。适用于对文件大小要求高，且不频繁压缩/解压的情况。

以上两种压缩再结合GF的额外压缩，又能进一步降低包体大小。当然，也需要根据需求平衡文件加载速度和文件资源大小的取舍。

模式一：图片原文件压缩模式

一，图片原文件压缩工具功能设计：

 1. 压缩算法的选择：

tinypng在线压缩 + pngquant和ImageSharp离线压缩：

tinypng压缩比极高，支持png/jpg/webp, 并且提供了包括.Net的多种编程语言API支持，适合做批处理。但是，tinypng需要上传图片到服务器，压缩完后还要下载压缩后的图片。图片较大较多时处理过程会巨慢。如果有离线压缩算法就完美了，离线压缩库使用的是pngquant和ImageSharp，都是开源压缩算法：

pngquant: 只支持png压缩，对png的压缩比接近tinypng；也可从官网可以下载命令行工具，支持windows和mac；

ImageSharp：C#实现，跨平台。对jpg的压缩比tinypng还要好。

Tinypng API : TinyPNG – API Reference

 2. 添加需要压缩的文件/文件夹，并在列表中显示已经添加的文件/文件夹，支持添加/删除：

如上图，用户可以点击列表的"+"号弹出Unity自带的资源选择界面(支持选择文件夹/图片文件)，

但是Unity自带选择界面仅支持单选，所以还需要做个拖拽功能以支持批量添加。

3. 压缩设置项：

对于tinypng，需要注册序列号，每个序列号可以免费压缩500张。可以一次配置多个序列号，压缩时取首行序列号。

离线压缩：对于png格式，勾选离线压缩后使用pngquant本地压缩。

覆盖原图片：勾选后压缩后的图片直接覆盖原图。

压缩质量(仅对pngquant离线压缩有效)：为区间数值(min, max)，当压缩质量小于min时则不对该图片压缩，其实就是为了把图片控制在一定质量范围，不至于太糊。

快压等级：等级越高，压缩处理速度越快，但压缩比随之小幅降低。一般为了极致压缩比会把快压等级调到最低。

输出路径：压缩后的图片存放路径。

备份路径：点击备份会自动把当前选择的原图备份到指定目录，以便后续还原需求。

4. 功能：

功能按钮包含压缩、备份、还原、保存当前设置。

二，功能实现：

下载tinypng压缩库：可以在Visual Studio的NuGet中搜索下载tinypng库，然后把dll放入Unity工程。

 下载pngquant命令行版(有Window，Mac版本)，放入Unity工程。

1. tinypng在线压缩：

  1. /// <summary>
  2.     /// 使用TinyPng在线压缩,支持png,jpg,webp
  3.     /// </summary>
  4.     private async Task<bool> CompressOnlineAsync(string imgFileName, string outputFileName)
  5.     {
  6.         if (string.IsNullOrWhiteSpace(TinifyAPI.Tinify.Key))
  7.         {
  8.             return false;
  9.         }
  10.  
  11.         var srcImg = TinifyAPI.Tinify.FromFile(imgFileName);
  12.         await srcImg.ToFile(outputFileName);
  13.         return srcImg.IsCompletedSuccessfully;
  14.     }

 2. pngquant和ImageSharp本地压缩：

  1. /// <summary>
  2.         /// 使用ImageSharp压缩jpg图片
  3.         /// </summary>
  4.         /// <param name="imgFileName"></param>
  5.         /// <param name="outputFileName"></param>
  6.         /// <returns></returns>
  7.         private static bool CompressJpgOffline(string imgFileName, string outputFileName)
  8.         {
  9.             using (var img = SixLabors.ImageSharp.Image.Load(imgFileName))
  10.             {
  11.                 var encoder = new SixLabors.ImageSharp.Formats.Jpeg.JpegEncoder()
  12.                 {
  13.                     Quality = (int)AppBuildSettings.Instance.CompressImgToolQualityLv
  14.                 };
  15.                 using (var outputStream = new FileStream(outputFileName, FileMode.Create))
  16.                 {
  17.                     img.Save(outputStream, encoder);
  18.                 }
  19.  
  20.             }
  21.  
  22.             return true;
  23.         }
  24.         /// <summary>
  25.         /// 使用pngquant压缩png图片
  26.         /// </summary>
  27.         /// <param name="imgFileName"></param>
  28.         /// <param name="outputFileName"></param>
  29.         /// <returns></returns>
  30.         private static bool CompressPngOffline(string imgFileName, string outputFileName)
  31.         {
  32.             string pngquant = Path.Combine(Directory.GetParent(Application.dataPath).FullName, pngquantTool);
  33.  
  34.             StringBuilder strBuilder = new StringBuilder();
  35.             strBuilder.AppendFormat(" --force --quality {0}-{1}", (int)AppBuildSettings.Instance.CompressImgToolQualityMinLv, (int)AppBuildSettings.Instance.CompressImgToolQualityLv);
  36.             strBuilder.AppendFormat(" --speed {0}", AppBuildSettings.Instance.CompressImgToolFastLv);
  37.             strBuilder.AppendFormat(" --output \"{0}\"", outputFileName);
  38.             strBuilder.AppendFormat(" -- \"{0}\"", imgFileName);
  39.  
  40.             var proceInfo = new System.Diagnostics.ProcessStartInfo(pngquant, strBuilder.ToString());
  41.             proceInfo.CreateNoWindow = true;
  42.             proceInfo.UseShellExecute = false;
  43.             bool success;
  44.             using (var proce = System.Diagnostics.Process.Start(proceInfo))
  45.             {
  46.                 proce.WaitForExit();
  47.                 success = proce.ExitCode == 0;
  48.                 if (!success)
  49.                 {
  50.                     Debug.LogWarningFormat("离线压缩图片:{0}失败,ExitCode:{1}", imgFileName, proce.ExitCode);
  51.                 }
  52.             }
  53.             return success;
  54.         }

3. 弹出Unity编辑器内置资源选择窗口：

 通过反射调用Unity编辑器内置选文件窗口，需要注意反射调用不支持重载函数，所以需要把参数填写完整才能成功调用：

  1. public class EditorUtilityExtension
  2. {
  3.  
  4.     /// <summary>
  5.     /// 选择相对工程路径文件夹
  6.     /// </summary>
  7.     /// <param name="title">标题</param>
  8.     /// <param name="relativePath">默认打开的路径(相对路径)</param>
  9.     /// <returns></returns>
  10.     public static string OpenRelativeFolderPanel(string title, string relativePath)
  11.     {
  12.         var rootPath = Directory.GetParent(Application.dataPath).FullName;
  13.         var curFullPath = Path.Combine(rootPath, relativePath);
  14.         var selectPath = EditorUtility.OpenFolderPanel(title, curFullPath, curFullPath);
  15.  
  16.         return string.IsNullOrWhiteSpace(selectPath) ? selectPath : Path.GetRelativePath(rootPath, selectPath);
  17.     }
  18.  
  19.     /// <summary>
  20.     /// 打开UnityEditor内置文件选择界面
  21.     /// </summary>
  22.     /// <param name="assetTp"></param>
  23.     /// <param name="searchFilter"></param>
  24.     /// <param name="onObjectSelectorClosed"></param>
  25.     /// <param name="objectSelectorID"></param>
  26.     /// <returns></returns>
  27.     public static bool OpenAssetSelector(Type assetTp, string searchFilter = null, Action<UnityEngine.Object> onObjectSelectorClosed = null, int objectSelectorID = 0)
  28.     {
  29.         var objSelector = Utility.Assembly.GetType("UnityEditor.ObjectSelector");
  30.         var objSelectorInst = objSelector?.GetProperty("get", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)?.GetValue(objSelector);
  31.         if (objSelectorInst == null) return false;
  32.  
  33.         var objSelectorInstTp = objSelectorInst.GetType();
  34.         var showFunc = objSelectorInstTp.GetMethod("Show", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new System.Type[] { typeof(UnityEngine.Object), typeof(Type), typeof(UnityEngine.Object), typeof(bool), typeof(List<int>), typeof(Action<UnityEngine.Object>), typeof(Action<UnityEngine.Object>) }, null);
  35.         if (showFunc == null) return false;
  36.  
  37.         showFunc.Invoke(objSelectorInst, new object[] { null, assetTp, null, false, null, onObjectSelectorClosed, null });
  38.         if (!string.IsNullOrEmpty(searchFilter))
  39.         {
  40.             objSelectorInstTp.GetProperty("searchFilter", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).SetValue(objSelectorInst, searchFilter);
  41.         }
  42.  
  43.         objSelectorInstTp.GetField("objectSelectorID", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).SetValue(objSelectorInst, objectSelectorID);
  44.  
  45.         return true;
  46.     }
  47. }

4. 拖拽批量添加功能：

  1. private void DrawDropArea()
  2.     {
  3.         var dragRect = EditorGUILayout.BeginVertical("box");
  4.         {
  5.             GUILayout.FlexibleSpace();
  6.             EditorGUILayout.LabelField(dragAreaContent, centerLabelStyle);
  7.             if (dragRect.Contains(Event.current.mousePosition))
  8.             {
  9.                 if (Event.current.type == EventType.DragUpdated)
  10.                 {
  11.                     DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
  12.                 }
  13.                 else if (Event.current.type == EventType.DragExited)
  14.                 {
  15.                     if (DragAndDrop.objectReferences != null && DragAndDrop.objectReferences.Length > 0)
  16.                     {
  17.                         OnItemsDrop(DragAndDrop.objectReferences);
  18.                     }
  19.  
  20.                 }
  21.             }
  22.             GUILayout.FlexibleSpace();
  23.             EditorGUILayout.EndVertical();
  24.         }
  25.     }
  26.  
  27. /// <summary>
  28.     /// 拖拽松手
  29.     /// </summary>
  30.     /// <param name="objectReferences"></param>
  31.     /// <exception cref="NotImplementedException"></exception>
  32.     private void OnItemsDrop(UnityEngine.Object[] objectReferences)
  33.     {
  34.         foreach (var item in objectReferences)
  35.         {
  36.             if (CheckItemType(item) == ItemType.NoSupport)
  37.             {
  38.                 Debug.LogWarningFormat("添加失败! 不支持的文件格式:{0}", AssetDatabase.GetAssetPath(item));
  39.                 continue;
  40.             }
  41.             AddItem(item);
  42.         }
  43.     }

模式二：Unity内置压缩批处理

 1. 通过编辑器脚本批量修改图片TextureImporter属性：

 通过下面代码可以获取上图红色区域的设置参数：

  1. var texSetting = new TextureImporterSettings();
  2. texImporter.ReadTextureSettings(texSetting);

 通过下面代码可以获取针对各个平台的设置参数：

  1. var texImporter = AssetImporter.GetAtPath(assetName) as TextureImporter;
  2. var texPlatformSetting = texImporter.GetPlatformTextureSettings(EditorUserBuildSettings.activeBuildTarget.ToString());

 需要注意的是，不同平台支持的图片压缩方式(Format)不同，可以通过反射调用Unity内置API获取对应平台支持的所有Format类型以供下拉选择：

  1. var getOptionsFunc = Utility.Assembly.GetType("UnityEditor.TextureImportValidFormats").GetMethod("GetPlatformTextureFormatValuesAndStrings", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
  2. var paramsObjs = new object[] { TextureImporterType.Sprite, EditorUserBuildSettings.activeBuildTarget, null, null };
  3. getOptionsFunc.Invoke(null, paramsObjs);
  4.  
  5. var formatValues = paramsObjs[2] as int[];
  6. var formatDisplayOptions = paramsObjs[3] as string[];
  7.  
  8.  
  9. ...
  10. //Format
  11.         EditorGUILayout.BeginHorizontal();
  12.         {
  13.             overrideFormat = EditorGUILayout.ToggleLeft("Format", overrideFormat, GUILayout.Width(150));
  14.             EditorGUI.BeginDisabledGroup(!overrideFormat);
  15.             {
  16.                 compressPlatformSettings.format = (TextureImporterFormat)EditorGUILayout.IntPopup((int)compressPlatformSettings.format, formatDisplayOptions, formatValues);
  17.                 EditorGUI.EndDisabledGroup();
  18.             }
  19.             EditorGUILayout.EndHorizontal();
  20.         }

2. 通过EditorUtility.FormatBytes(UnityEditor.TextureUtil.GetStorageMemorySizeLong(texture))方法可以获取到对应压缩格式的文件占用大小，这样就可以通过自动比对筛选出最合适的压缩格式。此方法不是公开方法，需要通过反射调用。

3. 编辑器代码判断贴图是否符合压缩格式要求

 

比如ETC2要求图片像素宽高必须是4的倍数，Crunch格式要求图片宽高必须为POT(即2的N次方),对于不支持的压缩的贴图Unity还给了贴心警告，压缩失败时压缩格式会回滚到默认的通用格式，会造成贴图大小不降反升。所以需要判断贴图是否压缩成功，如果失败了就设置一个相对通用的压缩格式。

遗憾的是在Unity开源代码中并没有找到直接获取是否压缩成功的方法，但是可以通过判断是否有警告字符以判断是否压缩成功：

  1. /// <summary>
  2.         /// 检测贴图是否适用压缩格式
  3.         /// </summary>
  4.         /// <param name="texImporter"></param>
  5.         /// <param name="warning"></param>
  6.         /// <returns></returns>
  7.         bool CheckTexFormatValid(TextureImporter texImporter, out string warning)
  8.         {
  9.             var impWarningFunc = texImporter.GetType().GetMethod("GetImportWarnings", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
  10.             warning = impWarningFunc.Invoke(texImporter, null) as string;
  11.             return string.IsNullOrWhiteSpace(warning);
  12.         }

模式三：创建图集，图集变体

 功能需求：

1. 根据用户选定的文件夹，支持以文件夹或文件夹及其子文件夹为单位批量创建图集(每个文件夹生成一个图集文件)，并且支持忽略把像素宽/高大于限制大小的图片打进图集。

2. 创建AtlasVariant，AtlasVariant是用来按比例缩放SpriteAtlas的，用于资源大小优化。勾选AtlasVariant后，生成图集同时生成AtlasVariant。

3. 其他图集设置参数，同图集的Inspector设置面板。

需要注意的是SpriteAtlas目前有v1和v2两个版本，图集格式分别为spriteatlas和spriteatlasv2:

 两个版本的图集创建方法不同, v1是SpriteAtlas，v2是SpriteAtlasAsset，可通过EditorSettings.spritePackerMode获取当前使用的图集版本。

使用编辑器代码创建图集(SpriteAtlas)，支持v1和v2：

  1. /// <summary>
  2.         /// 创建图集
  3.         /// </summary>
  4.         /// <param name="atlasFilePath"></param>
  5.         /// <param name="settings"></param>
  6.         /// <param name="objectsForPack"></param>
  7.         /// <param name="createAtlasVariant"></param>
  8.         /// <param name="atlasVariantScale"></param>
  9.         /// <returns></returns>
  10.         public static SpriteAtlas CreateAtlas(string atlasName, AtlasSettings settings, UnityEngine.Object[] objectsForPack, bool createAtlasVariant = false, float atlasVariantScale = 1f)
  11.         {
  12.             CreateEmptySpriteAtlas(atlasName);
  13.             SpriteAtlas result;
  14.             if (EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2)
  15.             {
  16.                 var atlas = SpriteAtlasAsset.Load(atlasName);
  17.                 atlas.SetIncludeInBuild(settings.includeInBuild ?? true);
  18.                 atlas.Add(objectsForPack);
  19.                 var packSettings = atlas.GetPackingSettings();
  20.                 var texSettings = atlas.GetTextureSettings();
  21.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  22.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  23.                 atlas.SetPackingSettings(packSettings);
  24.                 atlas.SetTextureSettings(texSettings);
  25.                 atlas.SetPlatformSettings(platformSettings);
  26.                 SpriteAtlasAsset.Save(atlas, atlasName);
  27.  
  28.                 result = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasName);
  29.             }
  30.             else
  31.             {
  32.                 var atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasName);
  33.                 atlas.SetIncludeInBuild(settings.includeInBuild ?? true);
  34.                 atlas.Add(objectsForPack);
  35.                 var packSettings = atlas.GetPackingSettings();
  36.                 var texSettings = atlas.GetTextureSettings();
  37.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  38.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  39.                 atlas.SetPackingSettings(packSettings);
  40.                 atlas.SetTextureSettings(texSettings);
  41.                 atlas.SetPlatformSettings(platformSettings);
  42.                 result = atlas;
  43.                 AssetDatabase.SaveAssets();
  44.             }
  45.  
  46.             if (createAtlasVariant)
  47.             {
  48.                 var atlasVarSets = new AtlasVariantSettings()
  49.                 {
  50.                     variantScale = atlasVariantScale,
  51.                     readWrite = settings.readWrite,
  52.                     mipMaps = settings.mipMaps,
  53.                     sRGB = settings.sRGB,
  54.                     filterMode = settings.filterMode,
  55.                     texFormat = settings.texFormat,
  56.                     compressQuality = settings.compressQuality
  57.                 };
  58.                 CreateAtlasVariant(result, atlasVarSets);
  59.             }
  60.             return result;
  61.         }

使用编辑器代码为指定图集创建图集变体:

  1. /// <summary>
  2.         /// 根据图集对象生成图集变体
  3.         /// </summary>
  4.         /// <param name="atlas"></param>
  5.         /// <param name="settings"></param>
  6.         /// <returns></returns>
  7.         public static SpriteAtlas CreateAtlasVariant(SpriteAtlas atlasMaster, AtlasVariantSettings settings)
  8.         {
  9.             if (atlasMaster == null || atlasMaster.isVariant) return atlasMaster;
  10.             var atlasFileName = AssetDatabase.GetAssetPath(atlasMaster);
  11.             if (string.IsNullOrEmpty(atlasFileName))
  12.             {
  13.                 Debug.LogError($"atlas '{atlasMaster.name}' is not a asset file.");
  14.                 return null;
  15.             }
  16.  
  17.             var atlasVariantName = UtilityBuiltin.ResPath.GetCombinePath(Path.GetDirectoryName(atlasFileName), $"{Path.GetFileNameWithoutExtension(atlasFileName)}_Variant{Path.GetExtension(atlasFileName)}");
  18.  
  19.             SpriteAtlas varAtlas;
  20.             if (EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2)
  21.             {
  22.                 var atlas = SpriteAtlasAsset.Load(atlasFileName);
  23.                 atlas.SetIncludeInBuild(false);
  24.                 var packSettings = atlas.GetPackingSettings();
  25.                 var texSettings = atlas.GetTextureSettings();
  26.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  27.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  28.                 atlas.SetPackingSettings(packSettings);
  29.                 atlas.SetTextureSettings(texSettings);
  30.                 atlas.SetPlatformSettings(platformSettings);
  31.                 SpriteAtlasAsset.Save(atlas, atlasFileName);
  32.  
  33.                 CreateEmptySpriteAtlas(atlasVariantName);
  34.                 var tmpVarAtlas = SpriteAtlasAsset.Load(atlasVariantName);
  35.                 tmpVarAtlas.SetIncludeInBuild(true);
  36.                 tmpVarAtlas.SetIsVariant(true);
  37.                 packSettings = tmpVarAtlas.GetPackingSettings();
  38.                 texSettings = tmpVarAtlas.GetTextureSettings();
  39.                 platformSettings = tmpVarAtlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  40.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  41.                 tmpVarAtlas.SetPackingSettings(packSettings);
  42.                 tmpVarAtlas.SetTextureSettings(texSettings);
  43.                 tmpVarAtlas.SetPlatformSettings(platformSettings);
  44.                 tmpVarAtlas.SetMasterAtlas(atlasMaster);
  45.                 tmpVarAtlas.SetVariantScale(settings.variantScale);
  46.                 SpriteAtlasAsset.Save(tmpVarAtlas, atlasVariantName);
  47.  
  48.                 varAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasVariantName);
  49.             }
  50.             else
  51.             {
  52.                 var atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasFileName);
  53.                 atlas.SetIncludeInBuild(false);
  54.                 var packSettings = atlas.GetPackingSettings();
  55.                 var texSettings = atlas.GetTextureSettings();
  56.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  57.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  58.                 atlas.SetPackingSettings(packSettings);
  59.                 atlas.SetTextureSettings(texSettings);
  60.                 atlas.SetPlatformSettings(platformSettings);
  61.  
  62.                 CreateEmptySpriteAtlas(atlasVariantName);
  63.                 var tmpVarAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasVariantName);
  64.                 tmpVarAtlas.SetIncludeInBuild(true);
  65.                 tmpVarAtlas.SetIsVariant(true);
  66.                 packSettings = tmpVarAtlas.GetPackingSettings();
  67.                 texSettings = tmpVarAtlas.GetTextureSettings();
  68.                 platformSettings = tmpVarAtlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  69.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  70.                 tmpVarAtlas.SetPackingSettings(packSettings);
  71.                 tmpVarAtlas.SetTextureSettings(texSettings);
  72.                 tmpVarAtlas.SetPlatformSettings(platformSettings);
  73.                 tmpVarAtlas.SetMasterAtlas(atlasMaster);
  74.                 tmpVarAtlas.SetVariantScale(settings.variantScale);
  75.                 AssetDatabase.SaveAssets();
  76.  
  77.                 varAtlas = tmpVarAtlas;
  78.             }
  79.  
  80.             return varAtlas;
  81.         }

模式四：Animation Clip动画文件大小优化

原理非常简单，动画文件的位置、旋转、缩放等数据以浮点型保存在动画文件，默认精度太高，保留了一大串小数点后的数字，实际上不需要精度过大，保留3位小数即可。降低浮点型精度可以降低动画文件大小以减少打包后包体大小。

我这里直接偷懒使用正则匹配动画文件里的小数并降低小数的精度(注意，此方式只适用于Asset Serialization位Force Text模式，不支持Force Binary，Unity工程默认是Force Text模式)：

  1. public static void OptimizeAnimationClips(List<string> list, int precision)
  2.         {
  3.             string pattern = $"(\\d+\\.[\\d]{{{precision},}})";
  4.  
  5.             int totalCount = list.Count;
  6.             int finishCount = 0;
  7.             foreach (var itmName in list)
  8.             {
  9.                 if (File.GetAttributes(itmName) != FileAttributes.ReadOnly)
  10.                 {
  11.                     if (Path.GetExtension(itmName).ToLower().CompareTo(".anim") == 0)
  12.                     {
  13.                         finishCount++;
  14.                         if (EditorUtility.DisplayCancelableProgressBar(string.Format("压缩浮点精度({0}/{1})", finishCount, totalCount), itmName, finishCount / (float)totalCount))
  15.                         {
  16.                             break;
  17.                         }
  18.                         var allTxt = File.ReadAllText(itmName);
  19.                         // 将匹配到的浮点型数字替换为精确到3位小数的浮点型数字
  20.                         string outputString = Regex.Replace(allTxt, pattern, match =>
  21.                         float.Parse(match.Value).ToString($"F{precision}"));
  22.                         File.WriteAllText(itmName, outputString);
  23.                         Debug.LogFormat("----->压缩动画浮点精度:{0}", itmName);
  24.                     }
  25.                 }
  26.             }
  27.             EditorUtility.ClearProgressBar();
  28.             AssetDatabase.Refresh();
  29.         }

 工具的功能代码：

  1. using UnityEditor.U2D;
  2. using UnityEditor;
  3. using UnityEngine;
  4. using UnityEngine.U2D;
  5. using System.IO;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8. using TinifyAPI;
  9. using SixLabors.ImageSharp.Processing;
  10. using SixLabors.ImageSharp;
  11. using GameFramework;
  12. using System.Collections.Generic;
  13. using System.Text.RegularExpressions;
  14.  
  15. namespace UGF.EditorTools
  16. {
  17.     public class AtlasSettings : IReference
  18.     {
  19.         public bool? includeInBuild = null;
  20.         public bool? allowRotation = null;
  21.         public bool? tightPacking = null;
  22.         public bool? alphaDilation = null;
  23.         public int? padding = null;
  24.         public bool? readWrite = null;
  25.         public bool? mipMaps = null;
  26.         public bool? sRGB = null;
  27.         public FilterMode? filterMode = null;
  28.         public int? maxTexSize = null;
  29.         public TextureImporterFormat? texFormat = null;
  30.         public int? compressQuality = null;
  31.         public virtual void Clear()
  32.         {
  33.             includeInBuild = null;
  34.             allowRotation = null;
  35.             tightPacking = null;
  36.             alphaDilation = null;
  37.             padding = null;
  38.             readWrite = null;
  39.             mipMaps = null;
  40.             sRGB = null;
  41.             filterMode = null;
  42.             maxTexSize = null;
  43.             texFormat = null;
  44.             compressQuality = null;
  45.         }
  46.     }
  47.     public class AtlasVariantSettings : AtlasSettings
  48.     {
  49.         public float variantScale = 0.5f;
  50.         public override void Clear()
  51.         {
  52.             base.Clear();
  53.             variantScale = 0.5f;
  54.         }
  55.         public static AtlasVariantSettings CreateFrom(AtlasSettings atlasSettings, float scale = 1f)
  56.         {
  57.             var settings = ReferencePool.Acquire<AtlasVariantSettings>();
  58.             settings.includeInBuild = atlasSettings.includeInBuild;
  59.             settings.allowRotation = atlasSettings.allowRotation;
  60.             settings.tightPacking = atlasSettings.tightPacking;
  61.             settings.alphaDilation = atlasSettings.alphaDilation;
  62.             settings.padding = atlasSettings.padding;
  63.             settings.readWrite = atlasSettings.readWrite;
  64.             settings.mipMaps = atlasSettings.mipMaps;
  65.             settings.sRGB = atlasSettings.sRGB;
  66.             settings.filterMode = atlasSettings.filterMode;
  67.             settings.maxTexSize = atlasSettings.maxTexSize;
  68.             settings.texFormat = atlasSettings.texFormat;
  69.             settings.compressQuality = atlasSettings.compressQuality;
  70.             settings.variantScale = scale;
  71.             return settings;
  72.         }
  73.     }
  74.     public class CompressTool
  75.     {
  76. #if UNITY_EDITOR_WIN
  77.         const string pngquantTool = "Tools/CompressImageTools/pngquant_win/pngquant.exe";
  78. #elif UNITY_EDITOR_OSX
  79.         const string pngquantTool = "Tools/CompressImageTools/pngquant_mac/pngquant";
  80. #endif
  81.         /// <summary>
  82.         /// 使用TinyPng在线压缩,支持png,jpg,webp
  83.         /// </summary>
  84.         public static async Task<bool> CompressOnlineAsync(string imgFileName, string outputFileName, string tinypngKey)
  85.         {
  86.             if (string.IsNullOrWhiteSpace(tinypngKey))
  87.             {
  88.                 return false;
  89.             }
  90.             Tinify.Key = tinypngKey;
  91.             var srcImg = TinifyAPI.Tinify.FromFile(imgFileName);
  92.             await srcImg.ToFile(outputFileName);
  93.             return srcImg.IsCompletedSuccessfully;
  94.         }
  95.  
  96.         /// <summary>
  97.         /// 使用pngquant离线压缩,只支持png
  98.         /// </summary>
  99.         public static bool CompressImageOffline(string imgFileName, string outputFileName)
  100.         {
  101.             var fileExt = Path.GetExtension(imgFileName).ToLower();
  102.             switch (fileExt)
  103.             {
  104.                 case ".png":
  105.                     return CompressPngOffline(imgFileName, outputFileName);
  106.                 case ".jpg":
  107.                     return CompressJpgOffline(imgFileName, outputFileName);
  108.             }
  109.             return false;
  110.         }
  111.         /// <summary>
  112.         /// 按比例缩放图片尺寸
  113.         /// </summary>
  114.         /// <param name="imgFileName"></param>
  115.         /// <param name="outputFileName"></param>
  116.         /// <param name="scale"></param>
  117.         /// <returns></returns>
  118.         public static bool ResizeImage(string imgFileName, string outputFileName, float scale)
  119.         {
  120.             using (var img = SixLabors.ImageSharp.Image.Load(imgFileName))
  121.             {
  122.                 int scaleWidth = (int)(img.Width * scale);
  123.                 int scaleHeight = (int)(img.Height * scale);
  124.                 img.Mutate(x => x.Resize(scaleWidth, scaleHeight));
  125.                 img.Save(outputFileName);
  126.             }
  127.             return true;
  128.         }
  129.         /// <summary>
  130.         /// 设置图片尺寸
  131.         /// </summary>
  132.         /// <param name="imgFileName"></param>
  133.         /// <param name="outputFileName"></param>
  134.         /// <param name="width"></param>
  135.         /// <param name="height"></param>
  136.         /// <returns></returns>
  137.         public static bool ResizeImage(string imgFileName, string outputFileName, int width, int height)
  138.         {
  139.             using (var img = SixLabors.ImageSharp.Image.Load(imgFileName))
  140.             {
  141.                 img.Mutate(x => x.Resize(width, height));
  142.                 img.Save(outputFileName);
  143.             }
  144.             return true;
  145.         }
  146.         /// <summary>
  147.         /// 使用ImageSharp压缩jpg图片
  148.         /// </summary>
  149.         /// <param name="imgFileName"></param>
  150.         /// <param name="outputFileName"></param>
  151.         /// <returns></returns>
  152.         private static bool CompressJpgOffline(string imgFileName, string outputFileName)
  153.         {
  154.             using (var img = SixLabors.ImageSharp.Image.Load(imgFileName))
  155.             {
  156.                 var encoder = new SixLabors.ImageSharp.Formats.Jpeg.JpegEncoder()
  157.                 {
  158.                     Quality = (int)EditorToolSettings.Instance.CompressImgToolQualityLv
  159.                 };
  160.                 using (var outputStream = new FileStream(outputFileName, FileMode.Create))
  161.                 {
  162.                     img.Save(outputStream, encoder);
  163.                 }
  164.  
  165.             }
  166.  
  167.             return true;
  168.         }
  169.         /// <summary>
  170.         /// 使用pngquant压缩png图片
  171.         /// </summary>
  172.         /// <param name="imgFileName"></param>
  173.         /// <param name="outputFileName"></param>
  174.         /// <returns></returns>
  175.         private static bool CompressPngOffline(string imgFileName, string outputFileName)
  176.         {
  177.             string pngquant = Path.Combine(Directory.GetParent(Application.dataPath).FullName, pngquantTool);
  178.  
  179.             StringBuilder strBuilder = new StringBuilder();
  180.             strBuilder.AppendFormat(" --force --quality {0}-{1}", (int)EditorToolSettings.Instance.CompressImgToolQualityMinLv, (int)EditorToolSettings.Instance.CompressImgToolQualityLv);
  181.             strBuilder.AppendFormat(" --speed {0}", EditorToolSettings.Instance.CompressImgToolFastLv);
  182.             strBuilder.AppendFormat(" --output \"{0}\"", outputFileName);
  183.             strBuilder.AppendFormat(" -- \"{0}\"", imgFileName);
  184.  
  185.             var proceInfo = new System.Diagnostics.ProcessStartInfo(pngquant, strBuilder.ToString());
  186.             proceInfo.CreateNoWindow = true;
  187.             proceInfo.UseShellExecute = false;
  188.             bool success;
  189.             using (var proce = System.Diagnostics.Process.Start(proceInfo))
  190.             {
  191.                 proce.WaitForExit();
  192.                 success = proce.ExitCode == 0;
  193.                 if (!success)
  194.                 {
  195.                     Debug.LogWarningFormat("离线压缩图片:{0}失败,ExitCode:{1}", imgFileName, proce.ExitCode);
  196.                 }
  197.             }
  198.             return success;
  199.         }
  200.         /// <summary>
  201.         /// 创建图集
  202.         /// </summary>
  203.         /// <param name="atlasFilePath"></param>
  204.         /// <param name="settings"></param>
  205.         /// <param name="objectsForPack"></param>
  206.         /// <param name="createAtlasVariant"></param>
  207.         /// <param name="atlasVariantScale"></param>
  208.         /// <returns></returns>
  209.         public static SpriteAtlas CreateAtlas(string atlasName, AtlasSettings settings, UnityEngine.Object[] objectsForPack, bool createAtlasVariant = false, float atlasVariantScale = 1f)
  210.         {
  211.             CreateEmptySpriteAtlas(atlasName);
  212.             SpriteAtlas result;
  213.             if (EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2)
  214.             {
  215.                 var atlas = SpriteAtlasAsset.Load(atlasName);
  216.                 atlas.SetIncludeInBuild(settings.includeInBuild ?? true);
  217.                 atlas.Add(objectsForPack);
  218.                 var packSettings = atlas.GetPackingSettings();
  219.                 var texSettings = atlas.GetTextureSettings();
  220.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  221.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  222.                 atlas.SetPackingSettings(packSettings);
  223.                 atlas.SetTextureSettings(texSettings);
  224.                 atlas.SetPlatformSettings(platformSettings);
  225.                 SpriteAtlasAsset.Save(atlas, atlasName);
  226.  
  227.                 result = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasName);
  228.             }
  229.             else
  230.             {
  231.                 var atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasName);
  232.                 atlas.SetIncludeInBuild(settings.includeInBuild ?? true);
  233.                 atlas.Add(objectsForPack);
  234.                 var packSettings = atlas.GetPackingSettings();
  235.                 var texSettings = atlas.GetTextureSettings();
  236.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  237.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  238.                 atlas.SetPackingSettings(packSettings);
  239.                 atlas.SetTextureSettings(texSettings);
  240.                 atlas.SetPlatformSettings(platformSettings);
  241.                 result = atlas;
  242.                 AssetDatabase.SaveAssets();
  243.             }
  244.  
  245.             if (createAtlasVariant)
  246.             {
  247.                 var atlasVarSets = new AtlasVariantSettings()
  248.                 {
  249.                     variantScale = atlasVariantScale,
  250.                     readWrite = settings.readWrite,
  251.                     mipMaps = settings.mipMaps,
  252.                     sRGB = settings.sRGB,
  253.                     filterMode = settings.filterMode,
  254.                     texFormat = settings.texFormat,
  255.                     compressQuality = settings.compressQuality
  256.                 };
  257.                 CreateAtlasVariant(result, atlasVarSets);
  258.             }
  259.             return result;
  260.         }
  261.         private static void ModifySpriteAtlasSettings(AtlasSettings input, ref SpriteAtlasPackingSettings packSets, ref SpriteAtlasTextureSettings texSets, ref TextureImporterPlatformSettings platSets)
  262.         {
  263.             packSets.enableRotation = input.allowRotation ?? packSets.enableRotation;
  264.             packSets.enableTightPacking = input.tightPacking ?? packSets.enableTightPacking;
  265.             packSets.enableAlphaDilation = input.alphaDilation ?? packSets.enableAlphaDilation;
  266.             packSets.padding = input.padding ?? packSets.padding;
  267.             texSets.readable = input.readWrite ?? texSets.readable;
  268.             texSets.generateMipMaps = input.mipMaps ?? texSets.generateMipMaps;
  269.             texSets.sRGB = input.sRGB ?? texSets.sRGB;
  270.             texSets.filterMode = input.filterMode ?? texSets.filterMode;
  271.             platSets.overridden = null != input.maxTexSize || null != input.texFormat || null != input.compressQuality;
  272.             platSets.maxTextureSize = input.maxTexSize ?? platSets.maxTextureSize;
  273.             platSets.format = input.texFormat ?? platSets.format;
  274.             platSets.compressionQuality = input.compressQuality ?? platSets.compressionQuality;
  275.         }
  276.         /// <summary>
  277.         /// 根据文件夹名字返回一个图集名
  278.         /// </summary>
  279.         /// <param name="folder"></param>
  280.         /// <returns></returns>
  281.         public static string GetAtlasExtensionV1V2()
  282.         {
  283.             return EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2 ? ".spriteatlasv2" : ".spriteatlas";
  284.         }
  285.         public static void CreateEmptySpriteAtlas(string atlasAssetName)
  286.         {
  287.             if (EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2)
  288.             {
  289.                 SpriteAtlasAsset.Save(new SpriteAtlasAsset(), atlasAssetName);
  290.             }
  291.             else
  292.             {
  293.                 AssetDatabase.CreateAsset(new SpriteAtlas(), atlasAssetName);
  294.             }
  295.             AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
  296.         }
  297.         /// <summary>
  298.         /// 根据图集对象生成图集变体
  299.         /// </summary>
  300.         /// <param name="atlas"></param>
  301.         /// <param name="settings"></param>
  302.         /// <returns></returns>
  303.         public static SpriteAtlas CreateAtlasVariant(SpriteAtlas atlasMaster, AtlasVariantSettings settings)
  304.         {
  305.             if (atlasMaster == null || atlasMaster.isVariant) return atlasMaster;
  306.             var atlasFileName = AssetDatabase.GetAssetPath(atlasMaster);
  307.             if (string.IsNullOrEmpty(atlasFileName))
  308.             {
  309.                 Debug.LogError($"atlas '{atlasMaster.name}' is not a asset file.");
  310.                 return null;
  311.             }
  312.  
  313.             var atlasVariantName = UtilityBuiltin.ResPath.GetCombinePath(Path.GetDirectoryName(atlasFileName), $"{Path.GetFileNameWithoutExtension(atlasFileName)}_Variant{Path.GetExtension(atlasFileName)}");
  314.  
  315.             SpriteAtlas varAtlas;
  316.             if (EditorSettings.spritePackerMode == SpritePackerMode.SpriteAtlasV2)
  317.             {
  318.                 var atlas = SpriteAtlasAsset.Load(atlasFileName);
  319.                 atlas.SetIncludeInBuild(false);
  320.                 var packSettings = atlas.GetPackingSettings();
  321.                 var texSettings = atlas.GetTextureSettings();
  322.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  323.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  324.                 atlas.SetPackingSettings(packSettings);
  325.                 atlas.SetTextureSettings(texSettings);
  326.                 atlas.SetPlatformSettings(platformSettings);
  327.                 SpriteAtlasAsset.Save(atlas, atlasFileName);
  328.  
  329.                 CreateEmptySpriteAtlas(atlasVariantName);
  330.                 var tmpVarAtlas = SpriteAtlasAsset.Load(atlasVariantName);
  331.                 tmpVarAtlas.SetIncludeInBuild(true);
  332.                 tmpVarAtlas.SetIsVariant(true);
  333.                 packSettings = tmpVarAtlas.GetPackingSettings();
  334.                 texSettings = tmpVarAtlas.GetTextureSettings();
  335.                 platformSettings = tmpVarAtlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  336.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  337.                 tmpVarAtlas.SetPackingSettings(packSettings);
  338.                 tmpVarAtlas.SetTextureSettings(texSettings);
  339.                 tmpVarAtlas.SetPlatformSettings(platformSettings);
  340.                 tmpVarAtlas.SetMasterAtlas(atlasMaster);
  341.                 tmpVarAtlas.SetVariantScale(settings.variantScale);
  342.                 SpriteAtlasAsset.Save(tmpVarAtlas, atlasVariantName);
  343.  
  344.                 varAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasVariantName);
  345.             }
  346.             else
  347.             {
  348.                 var atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasFileName);
  349.                 atlas.SetIncludeInBuild(false);
  350.                 var packSettings = atlas.GetPackingSettings();
  351.                 var texSettings = atlas.GetTextureSettings();
  352.                 var platformSettings = atlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  353.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  354.                 atlas.SetPackingSettings(packSettings);
  355.                 atlas.SetTextureSettings(texSettings);
  356.                 atlas.SetPlatformSettings(platformSettings);
  357.  
  358.                 CreateEmptySpriteAtlas(atlasVariantName);
  359.                 var tmpVarAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasVariantName);
  360.                 tmpVarAtlas.SetIncludeInBuild(true);
  361.                 tmpVarAtlas.SetIsVariant(true);
  362.                 packSettings = tmpVarAtlas.GetPackingSettings();
  363.                 texSettings = tmpVarAtlas.GetTextureSettings();
  364.                 platformSettings = tmpVarAtlas.GetPlatformSettings(EditorUserBuildSettings.activeBuildTarget.ToString());
  365.                 ModifySpriteAtlasSettings(settings, ref packSettings, ref texSettings, ref platformSettings);
  366.                 tmpVarAtlas.SetPackingSettings(packSettings);
  367.                 tmpVarAtlas.SetTextureSettings(texSettings);
  368.                 tmpVarAtlas.SetPlatformSettings(platformSettings);
  369.                 tmpVarAtlas.SetMasterAtlas(atlasMaster);
  370.                 tmpVarAtlas.SetVariantScale(settings.variantScale);
  371.                 AssetDatabase.SaveAssets();
  372.  
  373.                 varAtlas = tmpVarAtlas;
  374.             }
  375.  
  376.             return varAtlas;
  377.         }
  378.         /// <summary>
  379.         /// 根据Atlas文件名为Atlas生成Atlas变体(Atlas Variant)
  380.         /// </summary>
  381.         /// <param name="atlasFile"></param>
  382.         /// <param name="settings"></param>
  383.         /// <returns></returns>
  384.         public static SpriteAtlas CreateAtlasVariant(string atlasFile, AtlasVariantSettings settings)
  385.         {
  386.             var atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasFile);
  387.  
  388.             return CreateAtlasVariant(atlas, settings);
  389.         }
  390.  
  391.         /// <summary>
  392.         /// 批量重新打包图集
  393.         /// </summary>
  394.         /// <param name="spriteAtlas"></param>
  395.         public static void PackAtlases(SpriteAtlas[] spriteAtlas)
  396.         {
  397.             SpriteAtlasUtility.PackAtlases(spriteAtlas, EditorUserBuildSettings.activeBuildTarget);
  398.         }
  399.  
  400.         public static void OptimizeAnimationClips(List<string> list, int precision)
  401.         {
  402.             string pattern = $"(\\d+\\.[\\d]{{{precision},}})";
  403.  
  404.             int totalCount = list.Count;
  405.             int finishCount = 0;
  406.             foreach (var itmName in list)
  407.             {
  408.                 if (File.GetAttributes(itmName) != FileAttributes.ReadOnly)
  409.                 {
  410.                     if (Path.GetExtension(itmName).ToLower().CompareTo(".anim") == 0)
  411.                     {
  412.                         finishCount++;
  413.                         if (EditorUtility.DisplayCancelableProgressBar(string.Format("压缩浮点精度({0}/{1})", finishCount, totalCount), itmName, finishCount / (float)totalCount))
  414.                         {
  415.                             break;
  416.                         }
  417.                         var allTxt = File.ReadAllText(itmName);
  418.                         // 将匹配到的浮点型数字替换为精确到3位小数的浮点型数字
  419.                         string outputString = Regex.Replace(allTxt, pattern, match =>
  420.                         float.Parse(match.Value).ToString($"F{precision}"));
  421.                         File.WriteAllText(itmName, outputString);
  422.                         Debug.LogFormat("----->压缩动画浮点精度:{0}", itmName);
  423.                     }
  424.                 }
  425.             }
  426.             EditorUtility.ClearProgressBar();
  427.             AssetDatabase.Refresh();
  428.         }
  429.     }
  430. }
  431.
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/636906
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号