1290 lines
38 KiB
C#
1290 lines
38 KiB
C#
//----------------------------------------------
|
||
// NGUI: Next-Gen UI kit
|
||
// Copyright © 2011-2015 Tasharen Entertainment
|
||
//----------------------------------------------
|
||
|
||
using UnityEngine;
|
||
using UnityEditor;
|
||
using System.Collections.Generic;
|
||
|
||
/// <summary>
|
||
/// Atlas maker lets you create atlases from a bunch of small textures. It's an alternative to using the external Texture Packer.
|
||
/// </summary>
|
||
using System.Collections;
|
||
using System.IO;
|
||
|
||
public class UIAtlasMaker : EditorWindow
|
||
{
|
||
|
||
#region //add by chenbin
|
||
|
||
bool isShowBorrowModeDesc = false;
|
||
bool isBorrowMode = false;
|
||
//add by chenbin
|
||
int runTimes = 0;
|
||
|
||
#endregion
|
||
|
||
static public UIAtlasMaker instance;
|
||
|
||
public class SpriteEntry : UISpriteData
|
||
{
|
||
// Sprite texture -- original texture or a temporary texture
|
||
public Texture2D tex;
|
||
|
||
// Temporary game object -- used to prevent Unity from unloading the texture
|
||
public GameObject tempGO;
|
||
|
||
// Temporary material -- same usage as the temporary game object
|
||
public Material tempMat;
|
||
|
||
// Whether the texture is temporary and should be deleted
|
||
public bool temporaryTexture = false;
|
||
|
||
/// <summary>
|
||
/// HACK: Prevent Unity from unloading temporary textures.
|
||
/// Discovered by "alexkring": http://www.tasharen.com/forum/index.php?topic=3079.45
|
||
/// </summary>
|
||
|
||
public void SetTexture(Color32[] newPixels, int newWidth, int newHeight)
|
||
{
|
||
Release();
|
||
|
||
temporaryTexture = true;
|
||
|
||
tex = new Texture2D(newWidth, newHeight);
|
||
tex.name = name;
|
||
tex.SetPixels32(newPixels);
|
||
tex.Apply();
|
||
|
||
tempMat = new Material(NGUISettings.atlas.spriteMaterial);
|
||
tempMat.hideFlags = HideFlags.HideAndDontSave;
|
||
tempMat.SetTexture("_MainTex", tex);
|
||
|
||
tempGO = EditorUtility.CreateGameObjectWithHideFlags(name, HideFlags.HideAndDontSave, typeof(MeshRenderer));
|
||
tempGO.GetComponent<MeshRenderer>().sharedMaterial = tempMat;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Release temporary resources.
|
||
/// </summary>
|
||
|
||
public void Release()
|
||
{
|
||
if (temporaryTexture) {
|
||
Object.DestroyImmediate(tempGO);
|
||
Object.DestroyImmediate(tempMat);
|
||
Object.DestroyImmediate(tex);
|
||
|
||
tempGO = null;
|
||
tempMat = null;
|
||
tex = null;
|
||
temporaryTexture = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
Vector2 mScroll = Vector2.zero;
|
||
List<string> mDelNames = new List<string>();
|
||
UIAtlas mLastAtlas;
|
||
|
||
void OnEnable()
|
||
{
|
||
instance = this;
|
||
}
|
||
|
||
void OnDisable()
|
||
{
|
||
instance = null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Atlas selection callback.
|
||
/// </summary>
|
||
|
||
void OnSelectAtlas(Object obj)
|
||
{
|
||
runTimes = 0; //add by chenbin
|
||
if (NGUISettings.atlas != obj) {
|
||
NGUISettings.atlas = obj as UIAtlas;
|
||
Repaint();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Refresh the window on selection.
|
||
/// </summary>
|
||
|
||
void OnSelectionChange()
|
||
{
|
||
mDelNames.Clear();
|
||
Repaint();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Helper function that retrieves the list of currently selected textures.
|
||
/// </summary>
|
||
|
||
List<Texture> GetSelectedTextures()
|
||
{
|
||
List<Texture> textures = new List<Texture>();
|
||
|
||
if (Selection.objects != null && Selection.objects.Length > 0) {
|
||
Object[] objects = EditorUtility.CollectDependencies(Selection.objects);
|
||
|
||
foreach (Object o in objects) {
|
||
Texture tex = o as Texture;
|
||
if (tex == null || tex.name == "Font Texture")
|
||
continue;
|
||
if (NGUISettings.atlas == null || NGUISettings.atlas.texture != tex)
|
||
textures.Add(tex);
|
||
}
|
||
}
|
||
return textures;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Load the specified list of textures as Texture2Ds, fixing their import properties as necessary.
|
||
/// </summary>
|
||
|
||
static List<Texture2D> LoadTextures(List<Texture> textures)
|
||
{
|
||
List<Texture2D> list = new List<Texture2D>();
|
||
|
||
foreach (Texture tex in textures) {
|
||
Texture2D t2 = NGUIEditorTools.ImportTexture(tex, true, false, true);
|
||
if (t2 != null)
|
||
list.Add(t2);
|
||
}
|
||
return list;
|
||
}
|
||
|
||
/// <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 || UNITY_IOS
|
||
maxSize = Mathf.Min(maxSize, NGUISettings.allow4096 ? 4096 : 2048);
|
||
#endif
|
||
if (NGUISettings.unityPacking) {
|
||
for (int i = 0; i < sprites.Count; ++i)
|
||
textures [i] = sprites [i].tex;
|
||
rects = tex.PackTextures(textures, NGUISettings.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, NGUISettings.atlasPadding, maxSize);
|
||
}
|
||
|
||
for (int i = 0; i < sprites.Count; ++i) {
|
||
Rect rect = NGUIMath.ConvertToPixels(rects [i], tex.width, tex.height, true);
|
||
|
||
// Apparently Unity can take the liberty of destroying temporary textures without any warning
|
||
if (textures [i] == null)
|
||
return false;
|
||
|
||
// 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;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Helper function that creates a single sprite list from both the atlas's sprites as well as selected textures.
|
||
/// Dictionary value meaning:
|
||
/// 0 = No change
|
||
/// 1 = Update
|
||
/// 2 = Add
|
||
/// </summary>
|
||
|
||
Dictionary<string, int> GetSpriteList(List<Texture> textures)
|
||
{
|
||
Dictionary<string, int> spriteList = new Dictionary<string, int>();
|
||
|
||
// If we have textures to work with, include them as well
|
||
if (textures.Count > 0) {
|
||
List<string> texNames = new List<string>();
|
||
// foreach (Texture tex in textures) texNames.Add(tex.name); // delete by chenbin
|
||
#region add by chenbin
|
||
foreach (Texture tex in textures) {
|
||
if (NGUISettings.atlas != null && NGUISettings.atlas.isBorrowSpriteMode) {
|
||
texNames.Add(getTextureName(tex));//add by chenbin
|
||
} else {
|
||
if(NGUISettings.addFolder2SpriteName) {
|
||
texNames.Add(getTextureName(tex));
|
||
} else {
|
||
texNames.Add(tex.name);
|
||
}
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
texNames.Sort();
|
||
foreach (string tex in texNames) {
|
||
if (string.IsNullOrEmpty(tex))
|
||
continue;//add by chenbin
|
||
// spriteList.Add(tex, 2);
|
||
if (spriteList.ContainsKey(tex))
|
||
spriteList [tex] = 1;
|
||
else
|
||
spriteList.Add(tex, 2);
|
||
}
|
||
}
|
||
|
||
if (NGUISettings.atlas != null) {
|
||
BetterList<string> spriteNames = NGUISettings.atlas.GetListOfSprites();
|
||
foreach (string sp in spriteNames) {
|
||
if (spriteList.ContainsKey(sp))
|
||
spriteList [sp] = 1;
|
||
else
|
||
spriteList.Add(sp, 0);
|
||
}
|
||
}
|
||
return spriteList;
|
||
}
|
||
|
||
/// <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 = NGUIEditorTools.ImportTexture(tex, true, false, true);
|
||
if (oldTex == null)
|
||
oldTex = tex as Texture2D;
|
||
if (oldTex == null)
|
||
continue;
|
||
|
||
// If we aren't doing trimming, just use the texture as-is
|
||
if (!NGUISettings.atlasTrimming && !NGUISettings.atlasPMA) {
|
||
SpriteEntry sprite = new SpriteEntry();
|
||
sprite.SetRect(0, 0, oldTex.width, oldTex.height);
|
||
sprite.tex = oldTex;
|
||
#region modify chenbin
|
||
if (NGUISettings.addFolder2SpriteName) {
|
||
sprite.name = getTextureName (oldTex);
|
||
} else {
|
||
sprite.name = oldTex.name;
|
||
}
|
||
#endregion
|
||
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 (NGUISettings.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 (!NGUISettings.atlasPMA && (newWidth == oldWidth && newHeight == oldHeight)) {
|
||
sprite.tex = oldTex;
|
||
// sprite.name = oldTex.name;
|
||
#region modify chenbin
|
||
if (NGUISettings.addFolder2SpriteName) {
|
||
sprite.name = getTextureName (oldTex);
|
||
} else {
|
||
sprite.name = oldTex.name;
|
||
}
|
||
#endregion
|
||
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 (NGUISettings.atlasPMA)
|
||
newPixels [newIndex] = NGUITools.ApplyPMA(pixels [oldIndex]);
|
||
else
|
||
newPixels [newIndex] = pixels [oldIndex];
|
||
}
|
||
}
|
||
|
||
// Create a new texture
|
||
// sprite.name = oldTex.name;
|
||
#region modify chenbin
|
||
if (NGUISettings.addFolder2SpriteName) {
|
||
sprite.name = getTextureName (oldTex);
|
||
} else {
|
||
sprite.name = oldTex.name;
|
||
}
|
||
#endregion
|
||
sprite.SetTexture(newPixels, newWidth, newHeight);
|
||
|
||
// 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)
|
||
se.Release();
|
||
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>
|
||
/// Duplicate the specified sprite.
|
||
/// </summary>
|
||
|
||
static public string DuplicateSprite(UIAtlas atlas, string spriteName) // modify by chenbin
|
||
{
|
||
if ((atlas == null || atlas.texture == null) && !atlas.isBorrowSpriteMode)
|
||
return null; // modify by chenbin
|
||
UISpriteData sd = atlas.GetSprite(spriteName);
|
||
if (sd == null)
|
||
return null;
|
||
|
||
#region add by chenbin
|
||
if (atlas.isBorrowSpriteMode) {
|
||
UISpriteData s = new UISpriteData();
|
||
s.name = sd.name + " (Copy)";
|
||
;
|
||
s.path = sd.path;
|
||
s.x = 0;
|
||
s.y = 0;
|
||
s.width = sd.width;
|
||
s.height = sd.height;
|
||
NGUISettings.atlas.spriteList.Add(s);
|
||
NGUISettings.atlas.spriteMap [s.name] = NGUISettings.atlas.spriteList.Count - 1;
|
||
atlas.MarkAsChanged();
|
||
return s.name;
|
||
} else {
|
||
#endregion
|
||
Texture2D tex = NGUIEditorTools.ImportTexture(atlas.texture, true, true, false);
|
||
SpriteEntry se = ExtractSprite(sd, tex);
|
||
|
||
if (se != null) {
|
||
se.name = se.name + " (Copy)";
|
||
|
||
List<UIAtlasMaker.SpriteEntry> sprites = new List<UIAtlasMaker.SpriteEntry>();
|
||
UIAtlasMaker.ExtractSprites(atlas, sprites);
|
||
sprites.Add(se);
|
||
UIAtlasMaker.UpdateAtlas(atlas, sprites);
|
||
se.Release();
|
||
} else
|
||
NGUIEditorTools.ImportTexture(atlas.texture, false, false, !atlas.premultipliedAlpha);
|
||
return se.name;
|
||
}
|
||
}
|
||
|
||
/// <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 = NGUIEditorTools.ImportTexture(atlas.texture, true, true, false);
|
||
SpriteEntry se = ExtractSprite(sd, tex);
|
||
NGUIEditorTools.ImportTexture(atlas.texture, false, false, !atlas.premultipliedAlpha);
|
||
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.SetTexture(newPixels, newWidth, newHeight);
|
||
return sprite;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Extract sprites from the atlas, adding them to the list.
|
||
/// </summary>
|
||
|
||
static public void ExtractSprites(UIAtlas atlas, List<SpriteEntry> finalSprites)
|
||
{
|
||
ShowProgress(0f);
|
||
|
||
// Make the atlas texture readable
|
||
Texture2D tex = NGUIEditorTools.ImportTexture(atlas.texture, true, true, false);
|
||
|
||
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) {
|
||
ShowProgress((index++) / count);
|
||
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
|
||
// The atlas no longer needs to be readable
|
||
NGUIEditorTools.ImportTexture(atlas.texture, false, false, !atlas.premultipliedAlpha);
|
||
ShowProgress(1f);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Combine all sprites into a single texture and save it to disk.
|
||
/// </summary>
|
||
|
||
static public bool UpdateTexture(UIAtlas atlas, List<SpriteEntry> sprites)
|
||
{
|
||
// 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)) {
|
||
Debug.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);
|
||
}
|
||
|
||
// 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)
|
||
Debug.LogError("Failed to load the created atlas saved as " + newPath);
|
||
else
|
||
atlas.spriteMaterial.mainTexture = tex;
|
||
ReleaseSprites(sprites);
|
||
|
||
AssetDatabase.SaveAssets();
|
||
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
|
||
}
|
||
return true;
|
||
} else {
|
||
if (!newTexture)
|
||
NGUIEditorTools.ImportTexture(oldPath, false, true, !atlas.premultipliedAlpha);
|
||
|
||
//Debug.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", "OK");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Show a progress bar.
|
||
/// </summary>
|
||
|
||
static public void ShowProgress(float val)
|
||
{
|
||
EditorUtility.DisplayProgressBar("Updating", "Updating the atlas, please wait...", val);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Add the specified texture to the atlas, or update an existing one.
|
||
/// </summary>
|
||
|
||
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>
|
||
/// Add the specified texture to the atlas, or update an existing one.
|
||
/// </summary>
|
||
|
||
static public void AddOrUpdate(UIAtlas atlas, SpriteEntry se)
|
||
{
|
||
if (atlas != null && se != null) {
|
||
List<SpriteEntry> sprites = new List<SpriteEntry>();
|
||
sprites.Add(se);
|
||
ExtractSprites(atlas, sprites);
|
||
UpdateAtlas(atlas, sprites);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Update the sprites within the texture atlas, preserving the sprites that have not been selected.
|
||
/// </summary>
|
||
|
||
void UpdateAtlas(List<Texture> textures, bool keepSprites)
|
||
{
|
||
// Create a list of sprites using the collected textures
|
||
List<SpriteEntry> sprites = CreateSprites(textures);
|
||
|
||
if (sprites.Count > 0) {
|
||
// Extract sprites from the atlas, filling in the missing pieces
|
||
if (keepSprites)
|
||
ExtractSprites(NGUISettings.atlas, sprites);
|
||
|
||
// NOTE: It doesn't seem to be possible to undo writing to disk, and there also seems to be no way of
|
||
// detecting an Undo event. Without either of these it's not possible to restore the texture saved to disk,
|
||
// so the undo process doesn't work right. Because of this I'd rather disable it altogether until a solution is found.
|
||
|
||
// The ability to undo this action is always useful
|
||
//NGUIEditorTools.RegisterUndo("Update Atlas", UISettings.atlas, UISettings.atlas.texture, UISettings.atlas.material);
|
||
|
||
// Update the atlas
|
||
UpdateAtlas(NGUISettings.atlas, sprites);
|
||
} else if (!keepSprites) {
|
||
UpdateAtlas(NGUISettings.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);
|
||
EditorUtility.ClearProgressBar();
|
||
return;
|
||
} else {
|
||
atlas.spriteList.Clear();
|
||
string path = NGUIEditorTools.GetSaveableTexturePath(atlas);
|
||
atlas.spriteMaterial.mainTexture = null;
|
||
if (!string.IsNullOrEmpty(path))
|
||
AssetDatabase.DeleteAsset(path);
|
||
}
|
||
|
||
atlas.MarkAsChanged();
|
||
Selection.activeGameObject = (NGUISettings.atlas != null) ? NGUISettings.atlas.gameObject : null;
|
||
EditorUtility.ClearProgressBar();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Draw the UI for this tool.
|
||
/// </summary>
|
||
|
||
void OnGUI()
|
||
{
|
||
if (mLastAtlas != NGUISettings.atlas)
|
||
mLastAtlas = NGUISettings.atlas;
|
||
|
||
bool update = false;
|
||
bool replace = false;
|
||
|
||
NGUIEditorTools.SetLabelWidth(84f);
|
||
GUILayout.Space(3f);
|
||
|
||
NGUIEditorTools.DrawHeader("Input", true);
|
||
NGUIEditorTools.BeginContents(false);
|
||
|
||
GUILayout.BeginHorizontal();
|
||
{
|
||
ComponentSelector.Draw<UIAtlas>("Atlas", NGUISettings.atlas, OnSelectAtlas, true, GUILayout.MinWidth(80f));
|
||
|
||
EditorGUI.BeginDisabledGroup(NGUISettings.atlas == null);
|
||
if (GUILayout.Button("New", GUILayout.Width(40f)))
|
||
NGUISettings.atlas = null;
|
||
EditorGUI.EndDisabledGroup();
|
||
}
|
||
GUILayout.EndHorizontal();
|
||
|
||
#region //add by chenbin
|
||
if (isBorrowMode) {
|
||
GUI.color = Color.green;
|
||
}
|
||
if (GUILayout.Button("说明")) {
|
||
isShowBorrowModeDesc = !isShowBorrowModeDesc;
|
||
}
|
||
if (isShowBorrowModeDesc) {
|
||
GUILayout.Label("勾选isBorrowSpriteMode时，表明该atlas是空atlas，\n" +
|
||
"当有sprit对象来borrow时，atlas会根据名字从\n" +
|
||
"设置的路径中去取得图片资源。\n" +
|
||
//"其中资源必须在Resources/下，\n" +
|
||
"另外atlas必须要引用一个material，\n" +
|
||
"就算引用的是个空material也行。\n");
|
||
}
|
||
if (mLastAtlas != null && runTimes == 0) {
|
||
runTimes++;
|
||
isBorrowMode = mLastAtlas.isBorrowSpriteMode;
|
||
// isUserUnity3DType = mLastAtlas.useUnity3DType;
|
||
}
|
||
if (mLastAtlas != null) {
|
||
mLastAtlas.isBorrowSpriteMode = EditorGUILayout.Toggle("isBorrowSpriteMode", mLastAtlas.isBorrowSpriteMode);
|
||
if (isBorrowMode != mLastAtlas.isBorrowSpriteMode) {
|
||
isBorrowMode = mLastAtlas.isBorrowSpriteMode;
|
||
UnityEditor.EditorUtility.SetDirty(NGUISettings.atlas.gameObject);
|
||
}
|
||
// if (mLastAtlas.isBorrowSpriteMode) {
|
||
// mLastAtlas.useUnity3DType = EditorGUILayout.Toggle ("useUnity3DType", mLastAtlas.useUnity3DType);
|
||
// if (isUserUnity3DType != mLastAtlas.useUnity3DType) {
|
||
// isUserUnity3DType = mLastAtlas.useUnity3DType;
|
||
// UnityEditor.EditorUtility.SetDirty (NGUISettings.atlas.gameObject);
|
||
// }
|
||
// }
|
||
}
|
||
GUI.color = Color.white;
|
||
#endregion //end ======add by chenbin
|
||
|
||
List<Texture> textures = GetSelectedTextures();
|
||
|
||
if (NGUISettings.atlas != null) {
|
||
Material mat = NGUISettings.atlas.spriteMaterial;
|
||
Texture tex = NGUISettings.atlas.texture;
|
||
|
||
// Material information
|
||
GUILayout.BeginHorizontal();
|
||
{
|
||
if (mat != null) {
|
||
if (GUILayout.Button("Material", GUILayout.Width(76f)))
|
||
Selection.activeObject = mat;
|
||
GUILayout.Label(" " + mat.name);
|
||
} else {
|
||
GUI.color = Color.grey;
|
||
GUILayout.Button("Material", GUILayout.Width(76f));
|
||
GUI.color = Color.white;
|
||
GUILayout.Label(" N/A");
|
||
}
|
||
}
|
||
GUILayout.EndHorizontal();
|
||
|
||
// Texture atlas information
|
||
GUILayout.BeginHorizontal();
|
||
{
|
||
if (tex != null) {
|
||
if (GUILayout.Button("Texture", GUILayout.Width(76f)))
|
||
Selection.activeObject = tex;
|
||
GUILayout.Label(" " + tex.width + "x" + tex.height);
|
||
} else {
|
||
GUI.color = Color.grey;
|
||
GUILayout.Button("Texture", GUILayout.Width(76f));
|
||
GUI.color = Color.white;
|
||
GUILayout.Label(" N/A");
|
||
}
|
||
}
|
||
GUILayout.EndHorizontal();
|
||
}
|
||
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.atlasPadding = Mathf.Clamp(EditorGUILayout.IntField("Padding", NGUISettings.atlasPadding, GUILayout.Width(100f)), 0, 8);
|
||
GUILayout.Label((NGUISettings.atlasPadding == 1 ? "pixel" : "pixels") + " between sprites");
|
||
GUILayout.EndHorizontal();
|
||
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.atlasTrimming = EditorGUILayout.Toggle("Trim Alpha", NGUISettings.atlasTrimming, GUILayout.Width(100f));
|
||
GUILayout.Label("Remove empty space");
|
||
GUILayout.EndHorizontal();
|
||
|
||
bool fixedShader = false;
|
||
|
||
if (NGUISettings.atlas != null) {
|
||
Material mat = NGUISettings.atlas.spriteMaterial;
|
||
|
||
if (mat != null) {
|
||
Shader shader = mat.shader;
|
||
|
||
if (shader != null) {
|
||
if (shader.name == "Unlit/Transparent Colored") {
|
||
NGUISettings.atlasPMA = false;
|
||
fixedShader = true;
|
||
} else if (shader.name == "Unlit/Premultiplied Colored") {
|
||
NGUISettings.atlasPMA = true;
|
||
fixedShader = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!fixedShader) {
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.atlasPMA = EditorGUILayout.Toggle("PMA Shader", NGUISettings.atlasPMA, GUILayout.Width(100f));
|
||
GUILayout.Label("Pre-multiplied alpha", GUILayout.MinWidth(70f));
|
||
GUILayout.EndHorizontal();
|
||
}
|
||
|
||
//GUILayout.BeginHorizontal();
|
||
//NGUISettings.keepPadding = EditorGUILayout.Toggle("Keep Padding", NGUISettings.keepPadding, GUILayout.Width(100f));
|
||
//GUILayout.Label("or replace with trimmed pixels", GUILayout.MinWidth(70f));
|
||
//GUILayout.EndHorizontal();
|
||
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.unityPacking = EditorGUILayout.Toggle("Unity Packer", NGUISettings.unityPacking, GUILayout.Width(100f));
|
||
GUILayout.Label("or custom packer", GUILayout.MinWidth(70f));
|
||
GUILayout.EndHorizontal();
|
||
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.trueColorAtlas = EditorGUILayout.Toggle("Truecolor", NGUISettings.trueColorAtlas, GUILayout.Width(100f));
|
||
GUILayout.Label("force ARGB32 textures", GUILayout.MinWidth(70f));
|
||
GUILayout.EndHorizontal();
|
||
|
||
if (!NGUISettings.unityPacking) {
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.forceSquareAtlas = EditorGUILayout.Toggle("Force Square", NGUISettings.forceSquareAtlas, GUILayout.Width(100f));
|
||
GUILayout.Label("if on, forces a square atlas texture", GUILayout.MinWidth(70f));
|
||
GUILayout.EndHorizontal();
|
||
}
|
||
|
||
#if UNITY_IPHONE || UNITY_ANDROID || UNITY_IOS
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.allow4096 = EditorGUILayout.Toggle("4096x4096", NGUISettings.allow4096, GUILayout.Width(100f));
|
||
GUILayout.Label("if off, limit atlases to 2048x2048");
|
||
GUILayout.EndHorizontal();
|
||
#endif
|
||
|
||
#region add by chenbin
|
||
GUILayout.BeginHorizontal();
|
||
NGUISettings.addFolder2SpriteName = EditorGUILayout.Toggle("Folder add SpriteName", NGUISettings.addFolder2SpriteName, GUILayout.Width(100f));
|
||
GUILayout.Label("Add folder name to SpriteName");
|
||
GUILayout.EndHorizontal();
|
||
#endregion
|
||
|
||
NGUIEditorTools.EndContents();
|
||
|
||
if (NGUISettings.atlas != null) {
|
||
GUILayout.BeginHorizontal();
|
||
GUILayout.Space(20f);
|
||
|
||
if (textures.Count > 0) {
|
||
update = GUILayout.Button("Add/Update");
|
||
} else if (GUILayout.Button("View Sprites")) {
|
||
SpriteSelector.ShowSelected();
|
||
}
|
||
|
||
GUILayout.Space(20f);
|
||
GUILayout.EndHorizontal();
|
||
} else {
|
||
EditorGUILayout.HelpBox("You can create a new atlas by selecting one or more textures in the Project View window, then clicking \"Create\".", MessageType.Info);
|
||
|
||
EditorGUI.BeginDisabledGroup(textures.Count == 0);
|
||
GUILayout.BeginHorizontal();
|
||
GUILayout.Space(20f);
|
||
bool create = GUILayout.Button("Create");
|
||
GUILayout.Space(20f);
|
||
GUILayout.EndHorizontal();
|
||
EditorGUI.EndDisabledGroup();
|
||
|
||
if (create) {
|
||
string path = EditorUtility.SaveFilePanelInProject("Save As",
|
||
"New Atlas.prefab", "prefab", "Save atlas as...", NGUISettings.currentPath);
|
||
|
||
if (!string.IsNullOrEmpty(path)) {
|
||
NGUISettings.currentPath = System.IO.Path.GetDirectoryName(path);
|
||
GameObject go = AssetDatabase.LoadAssetAtPath(path, typeof(GameObject)) as GameObject;
|
||
string matPath = path.Replace(".prefab", ".mat");
|
||
replace = true;
|
||
|
||
// Try to load the material
|
||
Material mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
|
||
|
||
// If the material doesn't exist, create it
|
||
if (mat == null) {
|
||
Shader shader = Shader.Find(NGUISettings.atlasPMA ? "Unlit/Premultiplied Colored" : "Unlit/Transparent Colored");
|
||
mat = new Material(shader);
|
||
|
||
// Save the material
|
||
AssetDatabase.CreateAsset(mat, matPath);
|
||
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
|
||
|
||
// Load the material so it's usable
|
||
mat = AssetDatabase.LoadAssetAtPath(matPath, typeof(Material)) as Material;
|
||
}
|
||
|
||
// Create a new prefab for the atlas
|
||
Object prefab = (go != null) ? go : PrefabUtility.CreateEmptyPrefab(path);
|
||
|
||
// Create a new game object for the atlas
|
||
string atlasName = path.Replace(".prefab", "");
|
||
atlasName = atlasName.Substring(path.LastIndexOfAny(new char[] { '/', '\\' }) + 1);
|
||
go = new GameObject(atlasName);
|
||
go.AddComponent<UIAtlas>().spriteMaterial = mat;
|
||
|
||
// Update the prefab
|
||
PrefabUtility.ReplacePrefab(go, prefab);
|
||
DestroyImmediate(go);
|
||
AssetDatabase.SaveAssets();
|
||
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
|
||
|
||
// Select the atlas
|
||
go = AssetDatabase.LoadAssetAtPath(path, typeof(GameObject)) as GameObject;
|
||
NGUISettings.atlas = go.GetComponent<UIAtlas>();
|
||
Selection.activeGameObject = go;
|
||
}
|
||
}
|
||
}
|
||
|
||
string selection = null;
|
||
Dictionary<string, int> spriteList = GetSpriteList(textures);
|
||
|
||
if (spriteList.Count > 0) {
|
||
NGUIEditorTools.DrawHeader("Sprites", true);
|
||
{
|
||
GUILayout.BeginHorizontal();
|
||
GUILayout.Space(3f);
|
||
GUILayout.BeginVertical();
|
||
|
||
mScroll = GUILayout.BeginScrollView(mScroll);
|
||
|
||
bool delete = false;
|
||
int index = 0;
|
||
foreach (KeyValuePair<string, int> iter in spriteList) {
|
||
++index;
|
||
|
||
GUILayout.Space(-1f);
|
||
bool highlight = (UIAtlasInspector.instance != null) && (NGUISettings.selectedSprite == iter.Key);
|
||
GUI.backgroundColor = highlight ? Color.white : new Color(0.8f, 0.8f, 0.8f);
|
||
GUILayout.BeginHorizontal(NGUIEditorTools.textArea, GUILayout.MinHeight(20f));
|
||
GUI.backgroundColor = Color.white;
|
||
GUILayout.Label(index.ToString(), GUILayout.Width(24f));
|
||
|
||
if (GUILayout.Button(iter.Key, "TextField", GUILayout.Height(20f)))
|
||
selection = iter.Key;
|
||
|
||
if (iter.Value == 2) {
|
||
GUI.color = Color.green;
|
||
GUILayout.Label("Add", GUILayout.Width(27f));
|
||
GUI.color = Color.white;
|
||
} else if (iter.Value == 1) {
|
||
GUI.color = Color.cyan;
|
||
GUILayout.Label("Update", GUILayout.Width(45f));
|
||
GUI.color = Color.white;
|
||
} else {
|
||
if (mDelNames.Contains(iter.Key)) {
|
||
GUI.backgroundColor = Color.red;
|
||
|
||
if (GUILayout.Button("Delete", GUILayout.Width(60f))) {
|
||
delete = true;
|
||
}
|
||
GUI.backgroundColor = Color.green;
|
||
if (GUILayout.Button("X", GUILayout.Width(22f))) {
|
||
mDelNames.Remove(iter.Key);
|
||
delete = false;
|
||
}
|
||
GUI.backgroundColor = Color.white;
|
||
} else {
|
||
// If we have not yet selected a sprite for deletion, show a small "X" button
|
||
if (GUILayout.Button("X", GUILayout.Width(22f)))
|
||
mDelNames.Add(iter.Key);
|
||
}
|
||
}
|
||
GUILayout.EndHorizontal();
|
||
}
|
||
GUILayout.EndScrollView();
|
||
GUILayout.EndVertical();
|
||
GUILayout.Space(3f);
|
||
GUILayout.EndHorizontal();
|
||
|
||
// If this sprite was marked for deletion, remove it from the atlas
|
||
if (delete) {
|
||
List<SpriteEntry> sprites = new List<SpriteEntry>();
|
||
|
||
if (!NGUISettings.atlas.isBorrowSpriteMode) {//add by chenbin
|
||
ExtractSprites(NGUISettings.atlas, sprites);
|
||
|
||
for (int i = sprites.Count; i > 0;) {
|
||
SpriteEntry ent = sprites [--i];
|
||
if (mDelNames.Contains(ent.name))
|
||
sprites.RemoveAt(i);
|
||
}
|
||
UpdateAtlas(NGUISettings.atlas, sprites);
|
||
mDelNames.Clear();
|
||
NGUIEditorTools.RepaintSprites();
|
||
|
||
#region add by chenbin
|
||
} else {
|
||
List<UISpriteData> list = NGUISettings.atlas.spriteList;
|
||
foreach (string n in mDelNames) {
|
||
foreach (UISpriteData s in list) {
|
||
if (s.name == n) {
|
||
list.Remove(s);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
NGUISettings.atlas.spriteMap.Clear();
|
||
for (int i = 0; i < NGUISettings.atlas.spriteList.Count; i++) {
|
||
UISpriteData tmpsp = NGUISettings.atlas.spriteList [i];
|
||
NGUISettings.atlas.spriteMap [tmpsp.name] = i;
|
||
}
|
||
UnityEditor.EditorUtility.SetDirty(NGUISettings.atlas.gameObject);
|
||
}
|
||
#endregion
|
||
} else if (update) {
|
||
if (!isBorrowMode) { //modify by chenbin
|
||
UpdateAtlas(textures, true);
|
||
} else {
|
||
UpdateAtlas_BorrowMode(textures); //add by chenbin
|
||
}
|
||
} else if (replace)
|
||
UpdateAtlas(textures, false);
|
||
|
||
if (NGUISettings.atlas != null && !string.IsNullOrEmpty(selection)) {
|
||
NGUIEditorTools.SelectSprite(selection);
|
||
} else if (update || replace) {
|
||
NGUIEditorTools.UpgradeTexturesToSprites(NGUISettings.atlas);
|
||
NGUIEditorTools.RepaintSprites();
|
||
}
|
||
}
|
||
}
|
||
|
||
if (NGUISettings.atlas != null && textures.Count == 0)
|
||
EditorGUILayout.HelpBox("You can reveal more options by selecting one or more textures in the Project View window.", MessageType.Info);
|
||
|
||
// Uncomment this line if you want to be able to force-sort the atlas
|
||
//if (NGUISettings.atlas != null && GUILayout.Button("Sort Alphabetically")) NGUISettings.atlas.SortAlphabetically();
|
||
}
|
||
|
||
|
||
#region //add by chenbin
|
||
|
||
//add by chenbin
|
||
void UpdateAtlas_BorrowMode(List<Texture> textures)
|
||
{
|
||
UpdateAtlas_BorrowMode(NGUISettings.atlas, textures);
|
||
}
|
||
|
||
public static void UpdateAtlas_BorrowMode(UIAtlas atlas, List<Texture> textures)
|
||
{
|
||
if (atlas == null || textures.Count == 0) {
|
||
return;
|
||
}
|
||
|
||
bool isHadOld = false;
|
||
foreach (Texture tex in textures) {
|
||
isHadOld = false;
|
||
|
||
//chang textures type
|
||
string path = AssetDatabase.GetAssetPath(tex);
|
||
TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
|
||
textureImporter.textureType = TextureImporterType.GUI;
|
||
textureImporter.mipmapEnabled = false;
|
||
textureImporter.wrapMode = TextureWrapMode.Clamp;
|
||
textureImporter.alphaIsTransparency = true;
|
||
textureImporter.npotScale = TextureImporterNPOTScale.None;
|
||
textureImporter.filterMode = FilterMode.Trilinear; //改成这种模式好像更省内存
|
||
AssetDatabase.ImportAsset(path);
|
||
|
||
path = getTexturePath(tex);
|
||
if (path == null)
|
||
continue;
|
||
|
||
string newName = getTextureName(tex);
|
||
foreach (DictionaryEntry item in atlas.spriteMap) {
|
||
if (newName == (string)(item.Key)) {
|
||
UISpriteData sp = atlas.spriteList [(int)(item.Value)];
|
||
sp.path = path;
|
||
// sp.outer = new Rect (0, 0, tex.width, tex.height);
|
||
//sp.inner = new Rect (0, 0, 0, 0);
|
||
sp.x = 0;
|
||
sp.y = 0;
|
||
sp.width = tex.width;
|
||
sp.height = tex.height;
|
||
isHadOld = true;
|
||
break;
|
||
}
|
||
}
|
||
if (isHadOld) {
|
||
continue;
|
||
}
|
||
UISpriteData s = new UISpriteData();
|
||
s.name = newName;
|
||
s.path = path;
|
||
// s.outer = new Rect (0, 0, tex.width, tex.height);
|
||
// s.inner = new Rect (0, 0, 0, 0);
|
||
s.x = 0;
|
||
s.y = 0;
|
||
s.width = tex.width;
|
||
s.height = tex.height;
|
||
atlas.spriteList.Add(s);
|
||
atlas.spriteMap [newName] = atlas.spriteList.Count - 1;
|
||
}
|
||
//UISettings.atlas.MarkAsDirty ();
|
||
|
||
textures.Clear();
|
||
Resources.UnloadUnusedAssets();
|
||
UnityEditor.EditorUtility.SetDirty(atlas.gameObject);
|
||
}
|
||
|
||
public static string getTexturePath(Texture tex)
|
||
{
|
||
if (tex == null) {
|
||
Debug.LogError("getTexturePath: tex == null");
|
||
return "";
|
||
}
|
||
string tmpPath = AssetDatabase.GetAssetPath(tex.GetInstanceID());
|
||
tmpPath = filter(tmpPath);
|
||
Debug.Log(tmpPath);
|
||
return tmpPath;
|
||
}
|
||
|
||
public static string getTextureName(Texture tex)
|
||
{
|
||
if (tex == null) {
|
||
Debug.LogError("getTexturePath: tex == null");
|
||
return "";
|
||
}
|
||
string tmpPath = AssetDatabase.GetAssetPath(tex.GetInstanceID());
|
||
tmpPath = Path.GetDirectoryName(tmpPath);
|
||
tmpPath = Path.GetFileName(tmpPath);
|
||
return tmpPath + "_" + tex.name;
|
||
}
|
||
|
||
static string filter(string path)
|
||
{
|
||
ArrayList replaces = new ArrayList();
|
||
string basePath = Application.dataPath;
|
||
replaces.Add(basePath + "/StreamingAssets/");
|
||
replaces.Add(basePath + "/Resources/");
|
||
replaces.Add(basePath);
|
||
replaces.Add("Assets/");
|
||
|
||
string str = "";
|
||
for (int i = 0; i < replaces.Count; i++) {
|
||
str = replaces [i].ToString();
|
||
path = path.Replace(str, "");
|
||
}
|
||
return path;
|
||
}
|
||
|
||
|
||
#endregion
|
||
}
|