【Unity3D】【NGUI】Atlas的动态创建

最新推荐文章于 2023-07-26 19:55:03 发布

一片

最新推荐文章于 2023-07-26 19:55:03 发布

阅读量1.5k

点赞数

分类专栏： unity3d

unity3d 专栏收录该内容

165 篇文章 8 订阅

订阅专栏

1、参见SZUIAtlasMakerRuntimeTest设置相应的值以上值需要提前设置好
2、没有检查是否atlas能够正确创建，自己可以改，加入返回值
3、代码都是在NGUI里面拷贝出来的，只是进行改动，没有新代码
4、适用与那种从网上下图片，之后还不想用UITexture的人，但是还是建议用UITexture如果drawcall不是问题的话
5、自己以后更新按我的方式改改就可以
6、动态创建速度较慢，建议在游戏启动的时候运行
7、游戏时可以将创建的atlas保存到可写目录，避免每次都新创建

SZUIAtlasMakerRuntimeTest.cs

[csharp]view plaincopy 
   
 using UnityEngine;  
 using System.Collections;  
   
 public class SZUIAtlasMakerRuntimeTest : MonoBehaviour {  
   
     public Texture2D[] texs;  
     public UISprite sprite;  
     private UIAtlas atlas;  
   
     void Start () {  
   
         SZUIAtlasMakerRuntime.atlasTrimming = true;  
         SZUIAtlasMakerRuntime.atlasPMA = atlas != null ? atlas.premultipliedAlpha : false;  
         SZUIAtlasMakerRuntime.unityPacking = false;  
         SZUIAtlasMakerRuntime.atlasPadding = 1;  
         SZUIAtlasMakerRuntime.allow4096 = true;  
         SZUIAtlasMakerRuntime.UITexturePacker.forceSquareAtlas = true;  
   
         if (atlas == null)  
         {  
             atlas = this.gameObject.AddComponent<UIAtlas>();  
         }  
         string lastName = string.Empty;  
         foreach (var tex in texs)  
         {  
             SZUIAtlasMakerRuntime.AddOrUpdate(atlas, tex);  
             lastName = tex.name;  
         }  
         sprite.atlas = atlas;  
         sprite.spriteName = lastName;  
     }  
   
 }  

SZUIAtlasMakerRuntime.cs

[csharp]view plaincopy 
   
 using UnityEngine;  
 using System.Collections;  
 using System.Collections.Generic;  
   
 public class SZUIAtlasMakerRuntime {  
   
     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;  
   
     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;  
     }  
   
     /// <summary>  
     /// Used to sort the sprites by pixels used  
     /// </summary>  
       
     static int Compare (SpriteEntry a, SpriteEntry b)  
     {  
         // A is null b is not b is greater so put it at the front of the list  
         if (a == null && b != null) return 1;  
           
         // A is not null b is null a is greater so put it at the front of the list  
         if (a != null && b == null) return -1;  
           
         // Get the total pixels used for each sprite  
         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;  
     }  
   
     /// <summary>  
     /// Pack all of the specified sprites into a single texture, updating the outer and inner rects of the sprites as needed.  
     /// </summary>  
       
     static bool PackTextures (Texture2D tex, List<SpriteEntry> 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);  
               
             // Make sure that we don't shrink the textures  
             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<Texture> textures = new List<Texture>();  
             textures.Add(tex);  
             List<SpriteEntry> sprites = CreateSprites(textures);  
             ExtractSprites(atlas, sprites);  
             UpdateAtlas(atlas, sprites);  
         }  
     }  
       
     /// <summary>  
     /// Update the sprite atlas, keeping only the sprites that are on the specified list.  
     /// </summary>  
       
     static public void UpdateAtlas (UIAtlas atlas, List<SpriteEntry> sprites)  
     {  
         if (sprites.Count > 0)  
         {  
             // Combine all sprites into a single texture and save it  
             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();  
     }  
   
     /// <summary>  
     /// Add a new sprite to the atlas, given the texture it's coming from and the packed rect within the atlas.  
     /// </summary>  
       
     static public UISpriteData AddSprite (List<UISpriteData> 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;  
     }  
   
     /// <summary>  
     /// Create a list of sprites using the specified list of textures.  
     /// </summary>  
     ///   
     static public List<SpriteEntry> CreateSprites (List<Texture> textures)  
     {  
         List<SpriteEntry> list = new List<SpriteEntry>();  
           
         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;  
     }  
   
     /// <summary>  
     /// Release all temporary textures created for the sprites.  
     /// </summary>  
       
     static public void ReleaseSprites (List<SpriteEntry> sprites)  
     {  
         foreach (SpriteEntry se in sprites)  
         {  
             if (se.temporaryTexture)  
             {  
                 NGUITools.Destroy(se.tex);  
                 se.tex = null;  
             }  
         }  
         Resources.UnloadUnusedAssets();  
     }  
       
     /// <summary>  
     /// Replace the sprites within the atlas.  
     /// </summary>  
       
     static public void ReplaceSprites (UIAtlas atlas, List<SpriteEntry> sprites)  
     {  
         // Get the list of sprites we'll be updating  
         List<UISpriteData> spriteList = atlas.spriteList;  
         List<UISpriteData> kept = new List<UISpriteData>();  
           
         // 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();  
     }  
   
     /// <summary>  
     /// Extract the specified sprite from the atlas.  
     /// </summary>  
     ///   
     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;  
     }  
       
     /// <summary>  
     /// Extract the specified sprite from the atlas texture.  
     /// </summary>  
       
     static SpriteEntry ExtractSprite (UISpriteData es, Texture2D tex)  
     {  
         return (tex != null) ? ExtractSprite(es, tex.GetPixels32(), tex.width, tex.height) : null;  
     }  
       
     /// <summary>  
     /// Extract the specified sprite from the atlas texture.  
     /// </summary>  
       
     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;  
     }  
       
     /// <summary>  
     /// Extract sprites from the atlas, adding them to the list.  
     /// </summary>  
       
     static public void ExtractSprites (UIAtlas atlas, List<SpriteEntry> finalSprites)  
     {  
         Texture2D tex = atlas.texture as Texture2D;  
           
         if (tex != null)  
         {  
             Color32[] pixels = null;  
             int width = tex.width;  
             int height = tex.height;  
             List<UISpriteData> 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<SpriteEntry> 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 class UITexturePacker  
     {  
         // sz modify  
         public static bool forceSquareAtlas = true;  
         public int binWidth = 0;  
         public int binHeight = 0;  
         public bool allowRotations;  
           
         public List<Rect> usedRectangles = new List<Rect>();  
         public List<Rect> freeRectangles = new List<Rect>();  
           
         public enum FreeRectChoiceHeuristic  
         {  
             RectBestShortSideFit, //< -BSSF: Positions the rectangle against the short side of a free rectangle into which it fits the best.  
             RectBestLongSideFit, //< -BLSF: Positions the rectangle against the long side of a free rectangle into which it fits the best.  
             RectBestAreaFit, //< -BAF: Positions the rectangle into the smallest free rect into which it fits.  
             RectBottomLeftRule, //< -BL: Does the Tetris placement.  
             RectContactPointRule //< -CP: Choosest the placement where the rectangle touches other rects as much as possible.  
         };  
           
         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;  
         }  
           
         public Rect Insert (int width, int height, FreeRectChoiceHeuristic method)  
         {  
             Rect newNode = new Rect();  
             int score1 = 0; // Unused in this function. We don't need to know the score after finding the position.  
             int score2 = 0;  
             switch (method)  
             {  
             case FreeRectChoiceHeuristic.RectBestShortSideFit: newNode = FindPositionForNewNodeBestShortSideFit(width, height, ref score1, ref score2); break;  
             case FreeRectChoiceHeuristic.RectBottomLeftRule: newNode = FindPositionForNewNodeBottomLeft(width, height, ref score1, ref score2); break;  
             case FreeRectChoiceHeuristic.RectContactPointRule: newNode = FindPositionForNewNodeContactPoint(width, height, ref score1); break;  
             case FreeRectChoiceHeuristic.RectBestLongSideFit: newNode = FindPositionForNewNodeBestLongSideFit(width, height, ref score2, ref score1); break;  
             case FreeRectChoiceHeuristic.RectBestAreaFit: newNode = FindPositionForNewNodeBestAreaFit(width, height, ref score1, ref score2); break;  
             }  
               
             if (newNode.height == 0)  
                 return newNode;  
               
             int numRectanglesToProcess = freeRectangles.Count;  
             for (int i = 0; i < numRectanglesToProcess; ++i)  
             {  
                 if (SplitFreeNode(freeRectangles[i], ref newNode))  
                 {  
                     freeRectangles.RemoveAt(i);  
                     --i;  
                     --numRectanglesToProcess;  
                 }  
             }  
               
             PruneFreeList();  
               
             usedRectangles.Add(newNode);  
             return newNode;  
         }  
           
         public void Insert (List<Rect> rects, List<Rect> dst, FreeRectChoiceHeuristic method)  
         {  
             dst.Clear();  
               
             while (rects.Count > 0)  
             {  
                 int bestScore1 = int.MaxValue;  
                 int bestScore2 = int.MaxValue;  
                 int bestRectIndex = -1;  
                 Rect bestNode = new Rect();  
                   
                 for (int i = 0; i < rects.Count; ++i)  
                 {  
                     int score1 = 0;  
                     int score2 = 0;  
                     Rect newNode = ScoreRect((int)rects[i].width, (int)rects[i].height, method, ref score1, ref score2);  
                       
                     if (score1 < bestScore1 || (score1 == bestScore1 && score2 < bestScore2))  
                     {  
                         bestScore1 = score1;  
                         bestScore2 = score2;  
                         bestNode = newNode;  
                         bestRectIndex = i;  
                     }  
                 }  
                   
                 if (bestRectIndex == -1)  
                     return;  
                   
                 PlaceRect(bestNode);  
                 rects.RemoveAt(bestRectIndex);  
             }  
         }  
           
         void PlaceRect (Rect node)  
         {  
             int numRectanglesToProcess = freeRectangles.Count;  
             for (int i = 0; i < numRectanglesToProcess; ++i)  
             {  
                 if (SplitFreeNode(freeRectangles[i], ref node))  
                 {  
                     freeRectangles.RemoveAt(i);  
                     --i;  
                     --numRectanglesToProcess;  
                 }  
             }  
               
             PruneFreeList();  
               
             usedRectangles.Add(node);  
         }  
           
         Rect ScoreRect (int width, int height, FreeRectChoiceHeuristic method, ref int score1, ref int score2)  
         {  
             Rect newNode = new Rect();  
             score1 = int.MaxValue;  
             score2 = int.MaxValue;  
             switch (method)  
             {  
             case FreeRectChoiceHeuristic.RectBestShortSideFit: newNode = FindPositionForNewNodeBestShortSideFit(width, height, ref score1, ref score2); break;  
             case FreeRectChoiceHeuristic.RectBottomLeftRule: newNode = FindPositionForNewNodeBottomLeft(width, height, ref score1, ref score2); break;  
             case FreeRectChoiceHeuristic.RectContactPointRule: newNode = FindPositionForNewNodeContactPoint(width, height, ref score1);  
                 score1 = -score1; // Reverse since we are minimizing, but for contact point score bigger is better.  
                 break;  
             case FreeRectChoiceHeuristic.RectBestLongSideFit: newNode = FindPositionForNewNodeBestLongSideFit(width, height, ref score2, ref score1); break;  
             case FreeRectChoiceHeuristic.RectBestAreaFit: newNode = FindPositionForNewNodeBestAreaFit(width, height, ref score1, ref score2); break;  
             }  
               
             // Cannot fit the current rectangle.  
             if (newNode.height == 0)  
             {  
                 score1 = int.MaxValue;  
                 score2 = int.MaxValue;  
             }  
               
             return newNode;  
         }  
           
         /// Computes the ratio of used surface area.  
         public float Occupancy ()  
         {  
             ulong usedSurfaceArea = 0;  
             for (int i = 0; i < usedRectangles.Count; ++i)  
                 usedSurfaceArea += (uint)usedRectangles[i].width * (uint)usedRectangles[i].height;  
               
             return (float)usedSurfaceArea / (binWidth * binHeight);  
         }  
           
         Rect FindPositionForNewNodeBottomLeft (int width, int height, ref int bestY, ref int bestX)  
         {  
             Rect bestNode = new Rect();  
             //memset(bestNode, 0, sizeof(Rect));  
               
             bestY = int.MaxValue;  
               
             for (int i = 0; i < freeRectangles.Count; ++i)  
             {  
                 // Try to place the rectangle in upright (non-flipped) orientation.  
                 if (freeRectangles[i].width >= width && freeRectangles[i].height >= height)  
                 {  
                     int topSideY = (int)freeRectangles[i].y + height;  
                     if (topSideY < bestY || (topSideY == bestY && freeRectangles[i].x < bestX))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = width;  
                         bestNode.height = height;  
                         bestY = topSideY;  
                         bestX = (int)freeRectangles[i].x;  
                     }  
                 }  
                 if (allowRotations && freeRectangles[i].width >= height && freeRectangles[i].height >= width)  
                 {  
                     int topSideY = (int)freeRectangles[i].y + width;  
                     if (topSideY < bestY || (topSideY == bestY && freeRectangles[i].x < bestX))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = height;  
                         bestNode.height = width;  
                         bestY = topSideY;  
                         bestX = (int)freeRectangles[i].x;  
                     }  
                 }  
             }  
             return bestNode;  
         }  
           
         Rect FindPositionForNewNodeBestShortSideFit (int width, int height, ref int bestShortSideFit, ref int bestLongSideFit)  
         {  
             Rect bestNode = new Rect();  
             //memset(&bestNode, 0, sizeof(Rect));  
               
             bestShortSideFit = int.MaxValue;  
               
             for (int i = 0; i < freeRectangles.Count; ++i)  
             {  
                 // Try to place the rectangle in upright (non-flipped) orientation.  
                 if (freeRectangles[i].width >= width && freeRectangles[i].height >= height)  
                 {  
                     int leftoverHoriz = Mathf.Abs((int)freeRectangles[i].width - width);  
                     int leftoverVert = Mathf.Abs((int)freeRectangles[i].height - height);  
                     int shortSideFit = Mathf.Min(leftoverHoriz, leftoverVert);  
                     int longSideFit = Mathf.Max(leftoverHoriz, leftoverVert);  
                       
                     if (shortSideFit < bestShortSideFit || (shortSideFit == bestShortSideFit && longSideFit < bestLongSideFit))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = width;  
                         bestNode.height = height;  
                         bestShortSideFit = shortSideFit;  
                         bestLongSideFit = longSideFit;  
                     }  
                 }  
                   
                 if (allowRotations && freeRectangles[i].width >= height && freeRectangles[i].height >= width)  
                 {  
                     int flippedLeftoverHoriz = Mathf.Abs((int)freeRectangles[i].width - height);  
                     int flippedLeftoverVert = Mathf.Abs((int)freeRectangles[i].height - width);  
                     int flippedShortSideFit = Mathf.Min(flippedLeftoverHoriz, flippedLeftoverVert);  
                     int flippedLongSideFit = Mathf.Max(flippedLeftoverHoriz, flippedLeftoverVert);  
                       
                     if (flippedShortSideFit < bestShortSideFit || (flippedShortSideFit == bestShortSideFit && flippedLongSideFit < bestLongSideFit))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = height;  
                         bestNode.height = width;  
                         bestShortSideFit = flippedShortSideFit;  
                         bestLongSideFit = flippedLongSideFit;  
                     }  
                 }  
             }  
             return bestNode;  
         }  
           
         Rect FindPositionForNewNodeBestLongSideFit (int width, int height, ref int bestShortSideFit, ref int bestLongSideFit)  
         {  
             Rect bestNode = new Rect();  
             //memset(&bestNode, 0, sizeof(Rect));  
               
             bestLongSideFit = int.MaxValue;  
               
             for (int i = 0; i < freeRectangles.Count; ++i)  
             {  
                 // Try to place the rectangle in upright (non-flipped) orientation.  
                 if (freeRectangles[i].width >= width && freeRectangles[i].height >= height)  
                 {  
                     int leftoverHoriz = Mathf.Abs((int)freeRectangles[i].width - width);  
                     int leftoverVert = Mathf.Abs((int)freeRectangles[i].height - height);  
                     int shortSideFit = Mathf.Min(leftoverHoriz, leftoverVert);  
                     int longSideFit = Mathf.Max(leftoverHoriz, leftoverVert);  
                       
                     if (longSideFit < bestLongSideFit || (longSideFit == bestLongSideFit && shortSideFit < bestShortSideFit))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = width;  
                         bestNode.height = height;  
                         bestShortSideFit = shortSideFit;  
                         bestLongSideFit = longSideFit;  
                     }  
                 }  
                   
                 if (allowRotations && freeRectangles[i].width >= height && freeRectangles[i].height >= width)  
                 {  
                     int leftoverHoriz = Mathf.Abs((int)freeRectangles[i].width - height);  
                     int leftoverVert = Mathf.Abs((int)freeRectangles[i].height - width);  
                     int shortSideFit = Mathf.Min(leftoverHoriz, leftoverVert);  
                     int longSideFit = Mathf.Max(leftoverHoriz, leftoverVert);  
                       
                     if (longSideFit < bestLongSideFit || (longSideFit == bestLongSideFit && shortSideFit < bestShortSideFit))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = height;  
                         bestNode.height = width;  
                         bestShortSideFit = shortSideFit;  
                         bestLongSideFit = longSideFit;  
                     }  
                 }  
             }  
             return bestNode;  
         }  
           
         Rect FindPositionForNewNodeBestAreaFit (int width, int height, ref int bestAreaFit, ref int bestShortSideFit)  
         {  
             Rect bestNode = new Rect();  
             //memset(&bestNode, 0, sizeof(Rect));  
               
             bestAreaFit = int.MaxValue;  
               
             for (int i = 0; i < freeRectangles.Count; ++i)  
             {  
                 int areaFit = (int)freeRectangles[i].width * (int)freeRectangles[i].height - width * height;  
                   
                 // Try to place the rectangle in upright (non-flipped) orientation.  
                 if (freeRectangles[i].width >= width && freeRectangles[i].height >= height)  
                 {  
                     int leftoverHoriz = Mathf.Abs((int)freeRectangles[i].width - width);  
                     int leftoverVert = Mathf.Abs((int)freeRectangles[i].height - height);  
                     int shortSideFit = Mathf.Min(leftoverHoriz, leftoverVert);  
                       
                     if (areaFit < bestAreaFit || (areaFit == bestAreaFit && shortSideFit < bestShortSideFit))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = width;  
                         bestNode.height = height;  
                         bestShortSideFit = shortSideFit;  
                         bestAreaFit = areaFit;  
                     }  
                 }  
                   
                 if (allowRotations && freeRectangles[i].width >= height && freeRectangles[i].height >= width)  
                 {  
                     int leftoverHoriz = Mathf.Abs((int)freeRectangles[i].width - height);  
                     int leftoverVert = Mathf.Abs((int)freeRectangles[i].height - width);  
                     int shortSideFit = Mathf.Min(leftoverHoriz, leftoverVert);  
                       
                     if (areaFit < bestAreaFit || (areaFit == bestAreaFit && shortSideFit < bestShortSideFit))  
                     {  
                         bestNode.x = freeRectangles[i].x;  
                         bestNode.y = freeRectangles[i].y;  
                         bestNode.width = height;  
                         bestNode.height = width;  
                         bestShortSideFit = shortSideFit;  
                         bestAreaFit = areaFit;  
                     }  
                 }  
             }  
             return bestNode;  
         }  
           
         /// Returns 0 if the two intervals i1 and i2 are disjoint, or the length of their overlap otherwise.  
         int CommonIntervalLength (int i1start, int i1end, int i2start, int i2end)  
         {  
             if (i1end < i2start || i2end < i1start)  
                 return 0;  
             return Mathf.Min(i1end, i2end) - Mathf.Max(i1start, i2start);  
         }  
           
         int ContactPointScoreNode (int x, int y, int width, int height)  
         {  
             int score = 0;  
               
             if (x == 0 || x + width == binWidth)  
                 score += height;  
             if (y == 0 || y + height == binHeight)  
                 score += width;  
               
             for (int i = 0; i < usedRectangles.Count; ++i)  
             {  
                 if (usedRectangles[i].x == x + width || usedRectangles[i].x + usedRectangles[i].width == x)  
                     score += CommonIntervalLength((int)usedRectangles[i].y, (int)usedRectangles[i].y + (int)usedRectangles[i].height, y, y + height);  
                 if (usedRectangles[i].y == y + height || usedRectangles[i].y + usedRectangles[i].height == y)  
                     score += CommonIntervalLength((int)usedRectangles[i].x, (int)usedRectangles[i].x + (int)usedRectangles[i].width, x, x + width);  
             }  
             return score;  
         }  
           
         Rect FindPositionForNewNodeContactPoint (int width, int height, ref int bestContactScore)  
         {  
             Rect bestNode = new Rect();  
             //memset(&bestNode, 0, sizeof(Rect));  
               
             bestContactScore = -1;  
               
             for (int i = 0; i < freeRectangles.Count; ++i)  
             {  
                 // Try to place the rectangle in upright (non-flipped) orientation.  
                 if (freeRectangles[i].width >= width && freeRectangles[i].height >= height)  
                 {  
                     int score = ContactPointScoreNode((int)freeRectangles[i].x, (int)freeRectangles[i].y, width, height);  
                     if (score > bestContactScore)  
                     {  
                         bestNode.x = (int)freeRectangles[i].x;  
                         bestNode.y = (int)freeRectangles[i].y;  
                         bestNode.width = width;  
                         bestNode.height = height;  
                         bestContactScore = score;  
                     }  
                 }  
                 if (allowRotations && freeRectangles[i].width >= height && freeRectangles[i].height >= width)  
                 {  
                     int score = ContactPointScoreNode((int)freeRectangles[i].x, (int)freeRectangles[i].y, height, width);  
                     if (score > bestContactScore)  
                     {  
                         bestNode.x = (int)freeRectangles[i].x;  
                         bestNode.y = (int)freeRectangles[i].y;  
                         bestNode.width = height;  
                         bestNode.height = width;  
                         bestContactScore = score;  
                     }  
                 }  
             }  
             return bestNode;  
         }  
           
         bool SplitFreeNode (Rect freeNode, ref Rect usedNode)  
         {  
             // Test with SAT if the rectangles even intersect.  
             if (usedNode.x >= freeNode.x + freeNode.width || usedNode.x + usedNode.width <= freeNode.x ||  
                 usedNode.y >= freeNode.y + freeNode.height || usedNode.y + usedNode.height <= freeNode.y)  
                 return false;  
               
             if (usedNode.x < freeNode.x + freeNode.width && usedNode.x + usedNode.width > freeNode.x)  
             {  
                 // New node at the top side of the used node.  
                 if (usedNode.y > freeNode.y && usedNode.y < freeNode.y + freeNode.height)  
                 {  
                     Rect newNode = freeNode;  
                     newNode.height = usedNode.y - newNode.y;  
                     freeRectangles.Add(newNode);  
                 }  
                   
                 // New node at the bottom side of the used node.  
                 if (usedNode.y + usedNode.height < freeNode.y + freeNode.height)  
                 {  
                     Rect newNode = freeNode;  
                     newNode.y = usedNode.y + usedNode.height;  
                     newNode.height = freeNode.y + freeNode.height - (usedNode.y + usedNode.height);  
                     freeRectangles.Add(newNode);  
                 }  
             }  
               
             if (usedNode.y < freeNode.y + freeNode.height && usedNode.y + usedNode.height > freeNode.y)  
             {  
                 // New node at the left side of the used node.  
                 if (usedNode.x > freeNode.x && usedNode.x < freeNode.x + freeNode.width)  
                 {  
                     Rect newNode = freeNode;  
                     newNode.width = usedNode.x - newNode.x;  
                     freeRectangles.Add(newNode);  
                 }  
                   
                 // New node at the right side of the used node.  
                 if (usedNode.x + usedNode.width < freeNode.x + freeNode.width)  
                 {  
                     Rect newNode = freeNode;  
                     newNode.x = usedNode.x + usedNode.width;  
                     newNode.width = freeNode.x + freeNode.width - (usedNode.x + usedNode.width);  
                     freeRectangles.Add(newNode);  
                 }  
             }  
               
             return true;  
         }  
           
         void PruneFreeList ()  
         {  
             for (int i = 0; i < freeRectangles.Count; ++i)  
                 for (int j = i + 1; j < freeRectangles.Count; ++j)  
             {  
                 if (IsContainedIn(freeRectangles[i], freeRectangles[j]))  
                 {  
                     freeRectangles.RemoveAt(i);  
                     --i;  
                     break;  
                 }  
                 if (IsContainedIn(freeRectangles[j], freeRectangles[i]))  
                 {  
                     freeRectangles.RemoveAt(j);  
                     --j;  
                 }  
             }  
         }  
           
         bool IsContainedIn (Rect a, Rect b)  
         {  
             return a.x >= b.x && a.y >= b.y  
                 && a.x + a.width <= b.x + b.width  
                     && a.y + a.height <= b.y + b.height;  
         }  
     }  
   
 }  

一片

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【Unity3D】【NGUI】Atlas的动态创建

1、参见SZUIAtlasMakerRuntimeTest设置相应的值以上值需要提前设置好2、没有检查是否atlas能够正确创建，自己可以改，加入返回值3、代码都是在NGUI里面拷贝出来的，只是进行改动，没有新代码4、适用与那种从网上下图片，之后还不想用UITexture的人，但是还是建议用UITexture如果drawcall不是问题的话5、自己以后更新按我的方式改改就可以6
复制链接

扫一扫