NGUI图集压缩UIAtlasMaker修改

版权声明：本文为Jumbo原创文章,采用[知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议]，转载前请保证理解此协议原文出处：https://www.jianshu.com/p/2d41e280deb7

NGUI图集压缩UIAtlasMaker修改

阅读前请先了解下 Unity3D 图片纹理格式 Unity游戏开发图片纹理压缩方案

解决的问题？
包体过大
内存占用大
优化性能
方案如何实现
- 通过修改NGUI UIAtalsMaker图集打包工具来修改图集平台对应最优格式
Android：转成两张RGB ETC 4 bits图，一张保存RGB，一张保存Alpha
iOS ：一般情况下转成RGBA PVRTC 4 bits就行，转成两张RGB PVRTC 4 bits图，一张保存RGB，一张保存Alpha精度更高，工具中转成的是两张图
先目睹下

Atlas Maker UIOptimization: 图集优化选项 Force Square：图集图片方形长宽相等 2的n次方尽量图片大小小于等于2048

RGB+Alpha合并渲染复制 NGUI\Resources\Shaders\Unlit - Transparent Colored.shader重命名Unlit - Transparent Colored Split.shader

//暴露在Unity编辑器，赋值资源、改动
    	Properties {
		     _MainTex ("Base (RGB)", 2D) = "black" {} //RGB
		       _MaskTex ("Alpha (A)", 2D) = "black" {} //Alpha
	     }

       Pass{

       //添加
       sampler2D _MaskTex;//与Properties同名贴图属性绑定

       //修改
       fixed4 frag (v2f IN) : COLOR{
				fixed4 texClr = tex2D(_MainTex, IN.texcoord);
				texClr.a = tex2D(_MaskTex, IN.texcoord).r; //顶点Alpah值
				
				return texClr * IN.color;
			}

           }

修改UIAtalsMaker.cs

//OnGUI()中添加

GUILayout.BeginHorizontal();
NGUISettings.uiOptimization = EditorGUILayout.Toggle("UIOptimization", NGUISettings.uiOptimization, GUILayout.Width(100f));
GUILayout.Label("Split texture with 2 RGB ETC 4 (and Alpha) Android ,iOS 2 RGB PVRTC4", GUILayout.MinWidth(70f));
        GUILayout.EndHorizontal();

//修改实现 static public bool UpdateTexture (UIAtlas atlas, List sprites)

static public bool UpdateTexture (UIAtlas atlas, List<SpriteEntry> sprites)
	{
        bool bUIOptimization = NGUISettings.uiOptimization;
		// Get the texture for the atlas
		Texture2D tex = atlas.texture as Texture2D;
		string oldPath = (tex != null) ? AssetDatabase.GetAssetPath(tex.GetInstanceID()) : "";
		string newPath = NGUIEditorTools.GetSaveableTexturePath(atlas);

		// Clear the read-only flag in texture file attributes
		if (System.IO.File.Exists(newPath))
		{
#if !UNITY_4_1 && !UNITY_4_0 && !UNITY_3_5
			if (!AssetDatabase.IsOpenForEdit(newPath))
			{
				LogUtil.LogError(newPath + " is not editable. Did you forget to do a check out?");
				return false;
			}
#endif
			System.IO.FileAttributes newPathAttrs = System.IO.File.GetAttributes(newPath);
			newPathAttrs &= ~System.IO.FileAttributes.ReadOnly;
			System.IO.File.SetAttributes(newPath, newPathAttrs);
		}

		bool newTexture = (tex == null || oldPath != newPath);

		if (newTexture)
		{
			// Create a new texture for the atlas
			tex = new Texture2D(1, 1, TextureFormat.ARGB32, false);
		}
		else
		{
			// Make the atlas readable so we can save it
            tex = NGUIEditorTools.ImportTexture(oldPath, true, false, false, bUIOptimization);
		}

		// Pack the sprites into this texture
		if (PackTextures(tex, sprites))
		{
			byte[] bytes = tex.EncodeToPNG();
			System.IO.File.WriteAllBytes(newPath, bytes);
			bytes = null;

			// Load the texture we just saved as a Texture2D
			AssetDatabase.SaveAssets();
			AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
			tex = NGUIEditorTools.ImportTexture(newPath, false, true, !atlas.premultipliedAlpha);

			// Update the atlas texture
			if (newTexture)
			{
				if (tex == null) LogUtil.LogError("Failed to load the created atlas saved as " + newPath);
				else atlas.spriteMaterial.mainTexture = tex;
				ReleaseSprites(sprites);
				
				AssetDatabase.SaveAssets();
				AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
			}

            if (tex != null && atlas.spriteMaterial.shader != null)
            {
                if (bUIOptimization)
                {
                    TextureProceseser.ProcessUITex(tex);
                }
                else
                {
                    if (atlas.spriteMaterial.shader.name == "Unlit/Transparent Colored Split")
                    {
                        atlas.spriteMaterial.shader = Shader.Find(NGUISettings.atlasPMA ? "Unlit/Premultiplied Colored" : "Unlit/Transparent Colored");
                        atlas.spriteMaterial.mainTexture = tex;

                        //Try delete alpha texture
                        string folderPath = StringUtils.ParseFolderPath(AssetDatabase.GetAssetPath(tex));
                        string alphaPath = folderPath + "/" + tex.name + "_a.png";
                        AssetDatabase.DeleteAsset(alphaPath);

                        AssetDatabase.SaveAssets();
                        AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
                    }
                }
            }


			return true;
		}
		else
		{
			if (!newTexture) NGUIEditorTools.ImportTexture(oldPath, false, true, !atlas.premultipliedAlpha);
			
			//LogUtil.LogError("Operation canceled: The selected sprites can't fit into the atlas.\n" +
			//	"Keep large sprites outside the atlas (use UITexture), and/or use multiple atlases instead.");
			
			EditorUtility.DisplayDialog("Operation Canceled", "The selected sprites can't fit into the atlas.\n" +
					"Keep large sprites outside the atlas (use UITexture), and/or use multiple atlases instead , ask Jubmo for help", "OK");
			return false;
		}
	}

修改NGUISettings.cs 添加 uiOptimization

static public bool uiOptimization
  {
      get { return GetBool("NGUI UIOptimization", true); }
      set { SetBool("NGUI UIOptimization", value); }
  }

修改 NGUIEditorTools.cs

static public Texture2D ImportTexture(string path, bool forInput, bool force, bool alphaTransparency, bool bUIOptimization = false)
  {
      if (!string.IsNullOrEmpty(path))
      {
          if (forInput) { if (!MakeTextureReadable(path, force, bUIOptimization)) return null; }
          else if (!MakeTextureAnAtlas(path, force, alphaTransparency, bUIOptimization)) return null;
          //return AssetDatabase.LoadAssetAtPath(path, typeof(Texture2D)) as Texture2D;

          Texture2D tex = AssetDatabase.LoadAssetAtPath(path, typeof(Texture2D)) as Texture2D;
          AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
          return tex;
      }
      return null;
  }

 static public bool MakeTextureReadable(string path, bool force, bool bUIOptimization = false)
  {
      if (string.IsNullOrEmpty(path)) return false;
      TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter;
      if (ti == null) return false;

      TextureImporterSettings settings = new TextureImporterSettings();
      ti.ReadTextureSettings(settings);

      if (force || !settings.readable || settings.npotScale != TextureImporterNPOTScale.None || settings.alphaIsTransparency)
      {
          settings.readable = true;
          if (NGUISettings.trueColorAtlas) settings.textureFormat = TextureImporterFormat.ARGB32;
          settings.npotScale = TextureImporterNPOTScale.None;
          settings.alphaIsTransparency = false;
          ti.SetTextureSettings(settings);
          //优化Andriod和iOS,防止有些图集被压缩了，原本的NGUI AtlasMaker无法重新打图集
          if (bUIOptimization)
          {
              ti.SetPlatformTextureSettings("iOS", ti.maxTextureSize, TextureImporterFormat.RGBA32, (int)TextureCompressionQuality.Normal);
              ti.SetPlatformTextureSettings("Android", ti.maxTextureSize, TextureImporterFormat.RGBA32, (int)TextureCompressionQuality.Normal);
              //AssetDatabase.WriteImportSettingsIfDirty(path);
          }
            
          AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
      }
      return true;
  }

static bool MakeTextureAnAtlas (string path, bool force, bool alphaTransparency, bool bUIOptimization = false)
  {
      if (string.IsNullOrEmpty(path)) return false;
      TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter;
      if (ti == null) return false;

      TextureImporterSettings settings = new TextureImporterSettings();
      ti.ReadTextureSettings(settings);

      if (force ||
          settings.readable ||
          settings.maxTextureSize < 4096 ||
          settings.wrapMode != TextureWrapMode.Clamp ||
          settings.npotScale != TextureImporterNPOTScale.ToNearest)
      {
          settings.readable = false;
          settings.maxTextureSize = 4096;
          settings.wrapMode = TextureWrapMode.Clamp;
          settings.npotScale = TextureImporterNPOTScale.ToNearest;

          if (NGUISettings.trueColorAtlas)
          {
              settings.textureFormat = TextureImporterFormat.ARGB32;
              settings.filterMode = FilterMode.Trilinear;
          }

          settings.aniso = 4;
          settings.alphaIsTransparency = alphaTransparency;

          // [yqq] 2015-12-8 force disable mipmap for atlas texture
          settings.mipmapEnabled = false;

          ti.SetTextureSettings(settings);

          //优化Andriod和iOS,防止有些图集被压缩了，原本的NGUI AtlasMaker无法重新打图集
          if (bUIOptimization)
          {
              ti.SetPlatformTextureSettings("iOS", ti.maxTextureSize, TextureImporterFormat.RGBA32, (int)TextureCompressionQuality.Normal);
              ti.SetPlatformTextureSettings("Android", ti.maxTextureSize, TextureImporterFormat.RGBA32, (int)TextureCompressionQuality.Normal);
              //AssetDatabase.WriteImportSettingsIfDirty(path);
          }
            
          AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
      }
      return true;
  }

Editor目录新建 TextureProceseser.cs
- 添加如下方法

    public static void ChangeTextureImportSetting(Texture tex, bool readable, int size, TextureImporterFormat format = TextureImporterFormat.RGBA32, TextureImporterType importType = TextureImporterType.Advanced)
	{
		string path = AssetDatabase.GetAssetPath(tex);
		
		TextureImporter importer = (TextureImporter)TextureImporter.GetAtPath(path);
		importer.textureType = importType;
		importer.maxTextureSize = size;
		importer.textureFormat = format;

		importer.isReadable = true;
		AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
	}

public static void ProcessUITex(Texture2D tex)
    {
        SliptAlphaChannelForlMobile(tex);
        //修改材质
        ModifyMaterial(tex);
        

        AssetDatabase.Refresh();

    }


private static void SliptAlphaChannelForlMobile(Texture2D tex)
    {
        // 将贴图的格式设置为RGBA32，获得相应的通道。
        TextureProceseser.ChangeTextureImportSetting(tex, true, Mathf.Max(tex.width, tex.height));

        TextureImporterFormat destTexFormat = TextureImporterFormat.AutomaticCompressed;
        TextureImporterFormat destAndriodTexFormat = (tex.width == tex.height && tex.width % 2 == 0) ? TextureImporterFormat.ETC_RGB4 : TextureImporterFormat.DXT5;
        TextureImporterFormat destIOSTexFormat = (tex.width == tex.height && tex.width % 2 == 0) ? TextureImporterFormat.PVRTC_RGB4 : TextureImporterFormat.RGB24;
        int maxTexSize = Mathf.Max(tex.width, tex.height);
        int width = tex.width;
        int height = tex.height;

        // 设置目标格式
        TextureImporterSettings settings = new TextureImporterSettings();
        settings.ApplyTextureType(TextureImporterType.Advanced, true);
        settings.mipmapEnabled = false;
        settings.npotScale = TextureImporterNPOTScale.ToNearest;
        settings.readable = false;
        settings.normalMap = false;
        settings.lightmap = false;
        settings.generateCubemap = TextureImporterGenerateCubemap.None;
        settings.wrapMode = TextureWrapMode.Clamp;
        settings.textureFormat = destTexFormat;
        settings.maxTextureSize = maxTexSize;
        settings.filterMode = FilterMode.Bilinear;
        settings.alphaIsTransparency = true;
        settings.aniso = 4;

        // 获取原始像素数据的引用。
        Color32[] pixels = tex.GetPixels32();
        int pixelCount = pixels.Length;
        Color32[] rawPixels = new Color32[pixelCount];
        for (int i = 0; i < pixelCount; ++i)
        {
            rawPixels[i] = new Color32(pixels[i].r, pixels[i].g, pixels[i].b, pixels[i].a);
        }
        string folderPath = StringUtils.ParseFolderPath(AssetDatabase.GetAssetPath(tex));
        string rgbPath = folderPath + "/" + tex.name + ".png";

        // 首先生成Alpha通道的贴图。
        Texture2D alpha = new Texture2D(tex.width, tex.height, TextureFormat.RGB24, false);
        Color32[] alphaPixels = new Color32[pixelCount];
        for (int i = 0; i < pixelCount; i++)
        {
            alphaPixels[i] = new Color32(rawPixels[i].a, rawPixels[i].a, rawPixels[i].a, rawPixels[i].a);
        }
        alpha.SetPixels32(alphaPixels);
        alpha.Apply(false);
        string fileName = tex.name + "_a";
        string alphaPath = folderPath + "/" + fileName + ".png";
        System.IO.File.WriteAllBytes(alphaPath, alpha.EncodeToPNG());

        /* 原图还是保留，不复写，至修改平台相关参数
        // 转换自己的格式，丢弃Alpha通道并保存。
        tex.Resize(width, height, TextureFormat.RGB24, false);
        tex.SetPixels32(rawPixels);
        tex.Apply(false);
        System.IO.File.WriteAllBytes(rgbPath, tex.EncodeToPNG());
        */
        AssetDatabase.Refresh();

        // 修改纹理的贴图设置
        TextureProceseser.ChangeTextureImportSetting(tex, settings);
        if (destTexFormat != destIOSTexFormat)
            TextureProceseser.ChangePlatformTextureImportSetting(tex, "iOS", maxTexSize, destIOSTexFormat);
        if (destTexFormat != destAndriodTexFormat)
            TextureProceseser.ChangePlatformTextureImportSetting(tex, "Android", maxTexSize, destAndriodTexFormat);

        alpha = AssetDatabase.LoadAssetAtPath(alphaPath, typeof(Texture2D)) as Texture2D;
        TextureProceseser.ChangeTextureImportSetting(alpha, settings);
        if (destTexFormat != destIOSTexFormat)
            TextureProceseser.ChangePlatformTextureImportSetting(alpha, "iOS", maxTexSize, destIOSTexFormat);
        if (destTexFormat != destAndriodTexFormat)
            TextureProceseser.ChangePlatformTextureImportSetting(alpha, "Android", maxTexSize, destAndriodTexFormat);

        // 刷新资源。
        AssetDatabase.Refresh();
    }

public static void ModifyMaterial(Texture2D tex)
    {

        string path = AssetDatabase.GetAssetPath(tex);
        int maxSize = Mathf.Max(tex.width, tex.height);
        if (tex == null || string.IsNullOrEmpty(path))
        {
            Debug.LogWarning("This Texture is null, " + path);
            return;
        }

        string foladerPath = StringUtils.ParseFolderPath(path);
        string matPath = path.Substring(0, path.Length - ".png".Length) + ".mat";
        Material mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
        //int start = path.LastIndexOf("/");
       // int end = path.LastIndexOf(".");
        //string name = path.Substring(start + 1, end - start - 1);
        string alphaPath = foladerPath + "/" + tex.name + "_a.png";
        if (mat != null)
        {
            if (mat.shader.name.CompareTo("Unlit/Transparent Colored Split") != 0)
            {
                mat.shader = Shader.Find("Unlit/Transparent Colored Split");
                mat.mainTexture = tex;
                //mat.SetTexture("_MainTex", tex);
                Texture2D alpha = AssetDatabase.LoadAssetAtPath(alphaPath, typeof(Texture2D)) as Texture2D;
                if (alpha != null)
                    mat.SetTexture("_MaskTex", alpha);
                else
                    Debug.LogError("ModifyMaterial : alpah is null path:" + alphaPath);


                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
            }
            
        }
    }

NGUI图集压缩UIAtlasMaker修改

最近文章