关于NGUI动态加载图片，并且实现动态打图集的过程-创新互联

注：一些代码是在网上找的，太多就没有写。

  前几天做项目，遇到所要用的的大量图片都必须从网上下载，当时用的NGUI做的UI界面，当时上网找了好多，都不行，最后找一篇还差不多，但是也不好用，我重新捋了一遍；

  首先，我想到的就是用NGUI的UITexture组件的UITexture.mainTexture来直接将WWW获取的图片给赋值上去,这样很简单，但是有新的问题，图片量比较大，如果图片少的话可以使用这种方法。

  其次，换UI界面了，用UGUI做，UGUI是自动打图集，所以说方便，也可以用一两个RawTexture，但是UGUI要显示图片，必须将图片转换成Sprite，这也是一个难点，但是能够解决，可以将WWW 获取的图片用代码转换成Sprite格式，（转换这篇博客就不说了，下一篇我在说一下，有不会的可以看一看）。

  最后，就是本博客的主要内容；NGUI动态打图集：

  研究了好长时间，这种方法的只能是将图集打出来，但是不能弄成预设，图集打在一个空的GameObject上面，直接上代码：

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class NGUIAtlasMaker : MonoBehaviour {

    public static bool atlasTrimming = true;
    public static bool atlasPMA = false;
    public static bool unityPacking = false;
    public static int atlasPadding = 1;
    public static bool allow4096 = true;

    //主要就是继承UISpriteData，我们要修改它的类型
    public class SpriteEntry : UISpriteData
    {
        // Sprite texture -- original texture or a temporary texture
        public Texture2D tex;

        // Whether the texture is temporary and should be deleted
        public bool temporaryTexture = false;
    }

    static int Compare(SpriteEntry a, SpriteEntry b)
    {
        if (a == null && b != null) return 1;
        if (a != null && b == null) return -1;

        int aPixels = a.width * a.height;
        int bPixels = b.width * b.height;

        if (aPixels > bPixels) return -1;
        else if (aPixels < bPixels) return 1;
        return 0;
    }

    //对于Android和IOS是不一样的
    static bool PackTextures(Texture2D tex, List sprites)
    {
        Texture2D[] textures = new Texture2D[sprites.Count];
        Rect[] rects;

#if UNITY_3_5 || UNITY_4_0
    int maxSize = 4096;
#else
        int maxSize = SystemInfo.maxTextureSize;
#endif

#if UNITY_ANDROID || UNITY_IPHONE
    maxSize = Mathf.Min(maxSize, allow4096 ? 4096 : 2048);
#endif
        if (unityPacking)
        {
            for (int i = 0; i < sprites.Count; ++i) textures[i] = sprites[i].tex;
            rects = tex.PackTextures(textures, atlasPadding, maxSize);
        }
        else
        {
            sprites.Sort(Compare);
            for (int i = 0; i < sprites.Count; ++i) textures[i] = sprites[i].tex;
            rects = UITexturePacker.PackTextures(tex, textures, 4, 4, atlasPadding, maxSize);
        }

        for (int i = 0; i < sprites.Count; ++i)
        {
            Rect rect = NGUIMath.ConvertToPixels(rects[i], tex.width, tex.height, true);

            if (Mathf.RoundToInt(rect.width) != textures[i].width) return false;

            SpriteEntry se = sprites[i];
            se.x = Mathf.RoundToInt(rect.x);
            se.y = Mathf.RoundToInt(rect.y);
            se.width = Mathf.RoundToInt(rect.width);
            se.height = Mathf.RoundToInt(rect.height);
        }
        return true;
    }

    static public void AddOrUpdate(UIAtlas atlas, Texture2D tex)
    {
        if (atlas != null && tex != null)
        {
            List textures = new List();
            textures.Add(tex);
            List sprites = CreateSprites(textures);
            ExtractSprites(atlas, sprites);
            UpdateAtlas(atlas, sprites);
        }
    }

    static public void UpdateAtlas(UIAtlas atlas, List sprites)
    {
        if (sprites.Count > 0)
        {

            if (UpdateTexture(atlas, sprites))
            {
                // Replace the sprites within the atlas
                ReplaceSprites(atlas, sprites);
            }

            // Release the temporary textures
            ReleaseSprites(sprites);
            return;
        }
        else
        {
            atlas.spriteList.Clear();
            NGUITools.Destroy(atlas.spriteMaterial.mainTexture);
            atlas.spriteMaterial.mainTexture = null;
        }

        atlas.MarkAsChanged();
    }

    /// 

    /// Add a new sprite to the atlas, given the texture it's coming from and the packed rect within the atlas.
    /// 

    static public UISpriteData AddSprite(List sprites, SpriteEntry se)
    {
        // See if this sprite already exists
        foreach (UISpriteData sp in sprites)
        {
            if (sp.name == se.name)
            {
                sp.CopyFrom(se);
                return sp;
            }
        }

        UISpriteData sprite = new UISpriteData();
        sprite.CopyFrom(se);
        sprites.Add(sprite);
        return sprite;
    }

    /// 

    /// Create a list of sprites using the specified list of textures.
    /// 
    /// 
    static public List CreateSprites(List textures)
    {
        List list = new List();

        foreach (Texture tex in textures)
        {
            Texture2D oldTex = tex as Texture2D;

            // If we aren't doing trimming, just use the texture as-is
            if (!atlasTrimming && !atlasPMA)
            {
                SpriteEntry sprite = new SpriteEntry();
                sprite.SetRect(0, 0, oldTex.width, oldTex.height);
                sprite.tex = oldTex;
                sprite.name = oldTex.name;
                sprite.temporaryTexture = false;
                list.Add(sprite);
                continue;
            }

            // If we want to trim transparent pixels, there is more work to be done
            Color32[] pixels = oldTex.GetPixels32();

            int xmin = oldTex.width;
            int xmax = 0;
            int ymin = oldTex.height;
            int ymax = 0;
            int oldWidth = oldTex.width;
            int oldHeight = oldTex.height;

            // Find solid pixels
            if (atlasTrimming)
            {
                for (int y = 0, yw = oldHeight; y < yw; ++y)
                {
                    for (int x = 0, xw = oldWidth; x < xw; ++x)
                    {
                        Color32 c = pixels[y * xw + x];

                        if (c.a != 0)
                        {
                            if (y < ymin) ymin = y;
                            if (y > ymax) ymax = y;
                            if (x < xmin) xmin = x;
                            if (x > xmax) xmax = x;
                        }
                    }
                }
            }
            else
            {
                xmin = 0;
                xmax = oldWidth - 1;
                ymin = 0;
                ymax = oldHeight - 1;
            }

            int newWidth = (xmax - xmin) + 1;
            int newHeight = (ymax - ymin) + 1;

            if (newWidth > 0 && newHeight > 0)
            {
                SpriteEntry sprite = new SpriteEntry();
                sprite.x = 0;
                sprite.y = 0;
                sprite.width = oldTex.width;
                sprite.height = oldTex.height;

                // If the dimensions match, then nothing was actually trimmed
                if (!atlasPMA && (newWidth == oldWidth && newHeight == oldHeight))
                {
                    sprite.tex = oldTex;
                    sprite.name = oldTex.name;
                    sprite.temporaryTexture = false;
                }
                else
                {
                    // Copy the non-trimmed texture data into a temporary buffer
                    Color32[] newPixels = new Color32[newWidth * newHeight];

                    for (int y = 0; y < newHeight; ++y)
                    {
                        for (int x = 0; x < newWidth; ++x)
                        {
                            int newIndex = y * newWidth + x;
                            int oldIndex = (ymin + y) * oldWidth + (xmin + x);
                            if (atlasPMA) newPixels[newIndex] = NGUITools.ApplyPMA(pixels[oldIndex]);
                            else newPixels[newIndex] = pixels[oldIndex];
                        }
                    }

                    // Create a new texture
                    sprite.temporaryTexture = true;
                    sprite.name = oldTex.name;
                    sprite.tex = new Texture2D(newWidth, newHeight);
                    sprite.tex.SetPixels32(newPixels);
                    sprite.tex.Apply();

                    // Remember the padding offset
                    sprite.SetPadding(xmin, ymin, oldWidth - newWidth - xmin, oldHeight - newHeight - ymin);
                }
                list.Add(sprite);
            }
        }
        return list;
    }

    /// 

    /// Release all temporary textures created for the sprites.
    /// 

    static public void ReleaseSprites(List sprites)
    {
        foreach (SpriteEntry se in sprites)
        {
            if (se.temporaryTexture)
            {
                NGUITools.Destroy(se.tex);
                se.tex = null;
            }
        }
        Resources.UnloadUnusedAssets();
    }

    static public void ReplaceSprites(UIAtlas atlas, List sprites)
    {
        // Get the list of sprites we'll be updating
        List spriteList = atlas.spriteList;
        List kept = new List();

        // Run through all the textures we added and add them as sprites to the atlas
        for (int i = 0; i < sprites.Count; ++i)
        {
            SpriteEntry se = sprites[i];
            UISpriteData sprite = AddSprite(spriteList, se);
            kept.Add(sprite);
        }

        // Remove unused sprites
        for (int i = spriteList.Count; i > 0; )
        {
            UISpriteData sp = spriteList[--i];
            if (!kept.Contains(sp)) spriteList.RemoveAt(i);
        }

        // Sort the sprites so that they are alphabetical within the atlas
        atlas.SortAlphabetically();
        atlas.MarkAsChanged();
    }

    /// 

    /// Extract the specified sprite from the atlas.
    /// 
    /// 
    static public SpriteEntry ExtractSprite(UIAtlas atlas, string spriteName)
    {
        if (atlas.texture == null) return null;
        UISpriteData sd = atlas.GetSprite(spriteName);
        if (sd == null) return null;

        Texture2D tex = atlas.texture as Texture2D;
        SpriteEntry se = ExtractSprite(sd, tex);
        return se;
    }

    /// 

    /// Extract the specified sprite from the atlas texture.
    /// 

    static SpriteEntry ExtractSprite(UISpriteData es, Texture2D tex)
    {
        return (tex != null) ? ExtractSprite(es, tex.GetPixels32(), tex.width, tex.height) : null;
    }

    /// 

    /// Extract the specified sprite from the atlas texture.
    /// 

    static SpriteEntry ExtractSprite(UISpriteData es, Color32[] oldPixels, int oldWidth, int oldHeight)
    {
        int xmin = Mathf.Clamp(es.x, 0, oldWidth);
        int ymin = Mathf.Clamp(es.y, 0, oldHeight);
        int xmax = Mathf.Min(xmin + es.width, oldWidth - 1);
        int ymax = Mathf.Min(ymin + es.height, oldHeight - 1);
        int newWidth = Mathf.Clamp(es.width, 0, oldWidth);
        int newHeight = Mathf.Clamp(es.height, 0, oldHeight);

        if (newWidth == 0 || newHeight == 0) return null;

        Color32[] newPixels = new Color32[newWidth * newHeight];

        for (int y = 0; y < newHeight; ++y)
        {
            int cy = ymin + y;
            if (cy > ymax) cy = ymax;

            for (int x = 0; x < newWidth; ++x)
            {
                int cx = xmin + x;
                if (cx > xmax) cx = xmax;

                int newIndex = (newHeight - 1 - y) * newWidth + x;
                int oldIndex = (oldHeight - 1 - cy) * oldWidth + cx;

                newPixels[newIndex] = oldPixels[oldIndex];
            }
        }

        // Create a new sprite
        SpriteEntry sprite = new SpriteEntry();
        sprite.CopyFrom(es);
        sprite.SetRect(0, 0, newWidth, newHeight);
        sprite.temporaryTexture = true;
        sprite.tex = new Texture2D(newWidth, newHeight);
        sprite.tex.SetPixels32(newPixels);
        sprite.tex.Apply();
        return sprite;
    }

    /// 

    /// Extract sprites from the atlas, adding them to the list.
    /// 

    static public void ExtractSprites(UIAtlas atlas, List finalSprites)
    {
        Texture2D tex = atlas.texture as Texture2D;

        if (tex != null)
        {
            Color32[] pixels = null;
            int width = tex.width;
            int height = tex.height;
            List sprites = atlas.spriteList;
            float count = sprites.Count;
            int index = 0;

            foreach (UISpriteData es in sprites)
            {
                bool found = false;

                foreach (SpriteEntry fs in finalSprites)
                {
                    if (es.name == fs.name)
                    {
                        fs.CopyBorderFrom(es);
                        found = true;
                        break;
                    }
                }

                if (!found)
                {
                    if (pixels == null) pixels = tex.GetPixels32();
                    SpriteEntry sprite = ExtractSprite(es, pixels, width, height);
                    if (sprite != null) finalSprites.Add(sprite);
                }
            }
        }
    }

    static public bool UpdateTexture(UIAtlas atlas, List sprites)
    {
        // Get the texture for the atlas
        Texture2D tex = atlas.texture as Texture2D;

        bool newTexture = tex == null;

        if (newTexture)
        {
            // Create a new texture for the atlas
            tex = new Texture2D(1, 1, TextureFormat.ARGB32, false);
        }

        // Pack the sprites into this texture
        if (PackTextures(tex, sprites) && tex != null)
        {
            // Update the atlas texture
            if (newTexture)
            {
                if (atlas.spriteMaterial == null)
                {
                    Shader shader = Shader.Find(atlasPMA ? "Unlit/Premultiplied Colored" : "Unlit/Transparent Colored");
                    atlas.spriteMaterial = new Material(shader);
                }
                atlas.spriteMaterial.mainTexture = tex;
                ReleaseSprites(sprites);
            }
            return true;
        }
        else
        {
            return false;
        }
    }

    // save as ngui's
  
        public UITexturePacker(int width, int height, bool rotations)
        {
            Init(width, height, rotations);
        }

        public void Init(int width, int height, bool rotations)
        {
            binWidth = width;
            binHeight = height;
            allowRotations = rotations;

            Rect n = new Rect();
            n.x = 0;
            n.y = 0;
            n.width = width;
            n.height = height;

            usedRectangles.Clear();

            freeRectangles.Clear();
            freeRectangles.Add(n);
        }

        private struct Storage
        {
            public Rect rect;
            public bool paddingX;
            public bool paddingY;
        }

        public static Rect[] PackTextures(Texture2D texture, Texture2D[] textures, int width, int height, int padding, int maxSize)
        {
            if (width > maxSize && height > maxSize) return null;
            if (width > maxSize || height > maxSize) { int temp = width; width = height; height = temp; }

            // Force square by sizing up
            // sz modify
            //if (NGUISettings.forceSquareAtlas)
            if (forceSquareAtlas)
            {
                if (width > height)
                    height = width;
                else if (height > width)
                    width = height;
            }
            UITexturePacker bp = new UITexturePacker(width, height, false);
            Storage[] storage = new Storage[textures.Length];

            for (int i = 0; i < textures.Length; i++)
            {
                Texture2D tex = textures[i];
                if (!tex) continue;

                Rect rect = new Rect();

                int xPadding = 1;
                int yPadding = 1;

                for (xPadding = 1; xPadding >= 0; --xPadding)
                {
                    for (yPadding = 1; yPadding >= 0; --yPadding)
                    {
                        rect = bp.Insert(tex.width + (xPadding * padding), tex.height + (yPadding * padding),
                                         UITexturePacker.FreeRectChoiceHeuristic.RectBestAreaFit);
                        if (rect.width != 0 && rect.height != 0) break;

                        // After having no padding if it still doesn't fit -- increase texture size.
                        else if (xPadding == 0 && yPadding == 0)
                        {
                            return PackTextures(texture, textures, width * (width <= height ? 2 : 1),
                                                height * (height < width ? 2 : 1), padding, maxSize);
                        }
                    }
                    if (rect.width != 0 && rect.height != 0) break;
                }

                storage[i] = new Storage();
                storage[i].rect = rect;
                storage[i].paddingX = (xPadding != 0);
                storage[i].paddingY = (yPadding != 0);
            }

            texture.Resize(width, height);
            texture.SetPixels(new Color[width * height]);

            // The returned rects
            Rect[] rects = new Rect[textures.Length];

            for (int i = 0; i < textures.Length; i++)
            {
                Texture2D tex = textures[i];
                if (!tex) continue;

                Rect rect = storage[i].rect;
                int xPadding = (storage[i].paddingX ? padding : 0);
                int yPadding = (storage[i].paddingY ? padding : 0);
                Color[] colors = tex.GetPixels();

                // Would be used to rotate the texture if need be.
                if (rect.width != tex.width + xPadding)
                {
                    Color[] newColors = tex.GetPixels();

                    for (int x = 0; x < rect.width; x++)
                    {
                        for (int y = 0; y < rect.height; y++)
                        {
                            int prevIndex = ((int)rect.height - (y + 1)) + x * (int)tex.width;
                            newColors[x + y * (int)rect.width] = colors[prevIndex];
                        }
                    }

                    colors = newColors;
                }

                texture.SetPixels((int)rect.x, (int)rect.y, (int)rect.width - xPadding, (int)rect.height - yPadding, colors);
                rect.x /= width;
                rect.y /= height;
                rect.width = (rect.width - xPadding) / width;
                rect.height = (rect.height - yPadding) / height;
                rects[i] = rect;
            }
            texture.Apply();
            return rects;
        }
        
        。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。代码量挺大，我就不全写出来了，如果要深入研究，可以下载附件，这个脚本只是一个要被调用的脚本。

}

下面就是我们要调用的参数：
using UnityEngine;
using System.Collections;

public class NGUIAtlasMakerTest : MonoBehaviour {

    public UITexture tt;
    private Texture[] img;
    private Texture2D[] texs;
    public UISprite sprite;
    private UIAtlas atlas;

    void Start()
    {
        StartCoroutine(GetTupian());

        Invoke("TokeImage", 3.0f);
   
      
    }

    //此方法就是调用打图集的方法
    public void TokeImage()
    {
    //将下载的图片存储到texs中，进行动态打图集
        texs = new Texture2D[img.Length];
        for (int i = 0; i < img.Length; i++)
        {
            texs[i] = img[i] as Texture2D;
        }

        NGUIAtlasMaker.atlasTrimming = true;
        NGUIAtlasMaker.atlasPMA = atlas != null ? atlas.premultipliedAlpha : false;
        NGUIAtlasMaker.unityPacking = false;
        NGUIAtlasMaker.atlasPadding = 1;
        NGUIAtlasMaker.allow4096 = true;
        NGUIAtlasMaker.UITexturePacker.forceSquareAtlas = true;

        if (atlas == null)
        {
            atlas = this.gameObject.AddComponent();
        }
        string lastName = string.Empty;
        foreach (var tex in texs)
        {
            SZUIAtlasMakerRuntime.AddOrUpdate(atlas, tex);
            lastName = tex.name;
        }
        sprite.atlas = atlas;
        sprite.spriteName = lastName;
    }

 //图片下载过程（注意：我在这里只下载了一张图片，根据需要，你可以下载多张，只要存储到img数组或者texs数组中就行）
 这些都是很简单了，但是下载的图片是没有名字的，我想了个办法给命名了，
    IEnumerator GetTupian()
    {
        Debug.Log(1212);
        WWW www = new WWW("https://cache.yisu.com/upload/information/20200310/64/129671.jpg");
        yield return www;
        Texture2D tu = 
        //命名的过程 
        tu.name = "ttt";
        Debug.Log(www.texture .name);
        img = new Texture[1];
        for (int i = 0; i < img.Length ; i++)
        {
            img[i] = tu;
            
        }
        tt.mainTexture = img[0];
    }
    
    这种动态打图集，只能将图集打到一个空的GameObject上，，也就是说GameObject就是一个图集，但却不是预设，如果大家有什么好的建议或者方法，都可以分享出来，或者联系我

另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。