private static UIAtlas SetAtlasInfo(GameObject go, AtlasConfig config, Material mat)
{
if (go == null || config == null || !config.IsUseful() || mat == null)
{
return(null);
}
TextAsset atlasTextAsset = AssetDatabase.LoadAssetAtPath <TextAsset>(config.AtlasTxtFilePath);
if (atlasTextAsset != null)
{
UIAtlas uiAtlas = go.GetComponent <UIAtlas>();
uiAtlas.spriteMaterial = mat;
if (uiAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(uiAtlas.texture, false, false, !uiAtlas.premultipliedAlpha);
}
uiAtlas.MarkAsChanged();
NGUIJson.LoadSpriteData(uiAtlas, atlasTextAsset);
uiAtlas.MarkAsChanged();
return(uiAtlas);
}
return(null);
}
/// <summary>
/// Parses the string json into a value
/// </summary>
/// <param name="json">A JSON string.</param>
/// <returns>An ArrayList, a Hashtable, a double, a string, null, true, or false</returns>
public static object jsonDecode(string json)
{
// save the string for debug information
NGUIJson.lastDecode = json;
if (json != null)
{
char[] charArray = json.ToCharArray();
int index = 0;
bool success = true;
object value = NGUIJson.parseValue(charArray, ref index, ref success);
if (success)
{
NGUIJson.lastErrorIndex = -1;
}
else
{
NGUIJson.lastErrorIndex = index;
}
return(value);
}
else
{
return(null);
}
}
/// <summary>
/// Converts a Hashtable / ArrayList / Dictionary(string,string) object into a JSON string
/// </summary>
/// <param name="json">A Hashtable / ArrayList</param>
/// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>
public static string jsonEncode(object json)
{
var builder = new StringBuilder(BUILDER_CAPACITY);
var success = NGUIJson.serializeValue(json, builder);
return(success ? builder.ToString() : null);
}
/// <summary>
/// 导出阻挡信息
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private bool ExportTile(string path)
{
var json = NGUIJson.jsonEncode(new Hashtable()
{
{ "tilexnum", Target.gridXNum },
{ "tileynum", Target.gridZNum },
{ "tiles", System.Array.ConvertAll(Target.grids, g => (uint)g) },
});
//Debug.Log(json);
File.WriteAllText(path, json, new System.Text.UTF8Encoding(false));
return(true);
}
public static UIAtlas SetAtlasInfo(GameObject go, string path, Material mat)
{
if (AssetDatabase.LoadAssetAtPath(path.Replace(".png", ".txt"), typeof(TextAsset)))
{
UIAtlas uiAtlas = go.GetComponent <UIAtlas>();
uiAtlas.spriteMaterial = mat;
TextAsset ta = AssetDatabase.LoadAssetAtPath(path.Replace(".png", ".txt"), typeof(TextAsset)) as TextAsset;
NGUIJson.LoadSpriteData(uiAtlas, ta);
uiAtlas.MarkAsChanged();
return(uiAtlas);
}
return(null);
}
protected static void RebuildSeperateRGBandAlphaNGUIAtlas(string assetPath)
{
try
{
EditorUtility.DisplayProgressBar("设置NGUI图集", string.Format("正在进行 {0}", assetPath), 1);
string pngFile = Path.ChangeExtension(assetPath, "png");
string prefabFile = Path.ChangeExtension(assetPath, "prefab");
string matFile = Path.ChangeExtension(assetPath, "mat");
GameObject prefabAsset = GEditorNGUILoader.LoadAtlasPrefab(prefabFile);
Material matAsset = GEditorNGUILoader.LoadETCMaterial(matFile);
if (matAsset == null || prefabAsset == null)
{
Debug.LogError(string.Format("AssetPath: {0} Material或者预制体为空", assetPath));
return;
}
UIAtlas uiAtlas = prefabAsset.GetComponent <UIAtlas>();
if (uiAtlas == null)
{
uiAtlas = prefabAsset.AddComponent <UIAtlas>();
}
// 配置图集参数
Texture2D _mainTex = GEditorNGUILoader.LoadTexture2D(pngFile.Replace(".png", "_RGB.png"));
Texture2D _alphaTex = GEditorNGUILoader.LoadTexture2D(pngFile.Replace(".png", "_Alpha.png"));
TextAsset dataAsset = AssetDatabase.LoadAssetAtPath <TextAsset>(assetPath) as TextAsset;
if (_mainTex == null || _alphaTex == null || dataAsset == null)
{
Debug.LogError(string.Format("AssetPath: {0} 图集所需图片或者配置文件不存在", assetPath));
return;
}
matAsset.SetTexture("_MainTex", _mainTex);
matAsset.SetTexture("_MainTex_A", _alphaTex);
uiAtlas.spriteMaterial = matAsset;
NGUIJson.LoadSpriteData(uiAtlas, dataAsset);
uiAtlas.MarkAsChanged();
EditorUtility.SetDirty(uiAtlas);
AssetDatabase.SaveAssets();
}
catch (System.Exception ex)
{
Debug.LogError("Error " + ex.ToString());
}
finally
{
EditorUtility.ClearProgressBar();
}
}
private static UIAtlas SetAtlasInfo(GameObject go, string path, Material mat)
{
#region 第二步：给对象添加组件、给材质球关联着色器及纹理同时关联tp产生的坐标信息文件
if (AssetDatabase.LoadAssetAtPath(path.Replace(".png", ".txt"), typeof(TextAsset)))
{
UIAtlas uiAtlas = go.GetComponent <UIAtlas>();
uiAtlas.spriteMaterial = mat;
//加载tp产生的记事本
TextAsset ta = AssetDatabase.LoadAssetAtPath(path.Replace(".png", ".txt"), typeof(TextAsset)) as TextAsset;
NGUIJson.LoadSpriteData(uiAtlas, ta);
uiAtlas.MarkAsChanged();
return(uiAtlas);
}
#endregion
return(null);
}
public static void ApplyTexturePackerSetting(UIAtlas atlas, TextAsset ta)
{
if (atlas == null || ta == null)
{
return;
}
// Ensure that this atlas has valid import settings
if (atlas.texture != null)
{
NGUIEditorTools.ImportTexture(atlas.texture, false, false, !atlas.premultipliedAlpha);
}
NGUIEditorTools.RegisterUndo("Import Sprites", atlas);
NGUIJson.LoadSpriteData(atlas, ta);
atlas.MarkAsChanged();
}
/// <summary>
/// 导出NPC摆放信息
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private bool ExportNpc(string path)
{
var host = Target.transform.parent;
var npc = host.GetComponentsInChildren <NpcEditor>();
var db = Table.Query <table.TableNpc>().ToDictionary(i => i.id);
var error = from i in npc let id = (uint)i.baseId where db.ContainsKey(id) == false select i;
if (error.Any())
{
Debug.LogError("NPC表格中找不到对应id的NPC：\n" + string.Join("\n", (from i in error select string.Format("{0}\t{1}", i.baseId, i.transform.GetPath())).ToArray()));
return(false);
}
var json = NGUIJson.jsonEncode(new Hashtable()
{
{ "npcs", System.Array.ConvertAll(npc, i =>
{
var grid = new MapGrid(i.transform.localPosition);
return(new Hashtable()
{
{ "id", i.baseId },
{ "name", string.IsNullOrEmpty(i.alias) ? db[(uint)i.baseId].name : i.alias },
{ "x", grid.x },
{ "y", grid.z },
{ "angle", (int)i.transform.localRotation.eulerAngles.y },
{ "relivetime", i.relivetime },
{ "rate", Mathf.Clamp(i.rate, 0, 100) },
});
}) },
});
//Debug.Log(json);
File.WriteAllText(path, json, new System.Text.UTF8Encoding(false));
return(true);
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
NGUIEditorTools.SetLabelWidth(80f);
mAtlas = target as UIAtlas;
UISpriteData sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
GUILayout.Space(6f);
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
GUILayout.BeginHorizontal();
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
NGUIEditorTools.DrawPadding();
GUILayout.EndHorizontal();
if (mType != after)
{
if (after == AtlasType.Normal)
{
mType = AtlasType.Normal;
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas, true);
GUILayout.Space(6f);
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
NGUITools.SetDirty(mAtlas);
}
return;
}
//GUILayout.Space(6f);
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
mAtlas.MarkAsChanged();
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsChanged();
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
}
}
if (mAtlas.spriteMaterial != null)
{
Color blueColor = new Color(0f, 0.7f, 1f, 1f);
Color greenColor = new Color(0.4f, 1f, 0f, 1f);
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
if (sprite == null)
{
sprite = mAtlas.spriteList[0];
}
}
if (sprite != null)
{
if (sprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
if (!NGUIEditorTools.DrawHeader("Sprite Details"))
{
return;
}
NGUIEditorTools.BeginContents();
GUILayout.Space(3f);
NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
GUILayout.Space(6f);
GUI.changed = false;
GUI.backgroundColor = greenColor;
NGUIEditorTools.IntVector sizeA = NGUIEditorTools.IntPair("Dimensions", "X", "Y", sprite.x, sprite.y);
NGUIEditorTools.IntVector sizeB = NGUIEditorTools.IntPair(null, "Width", "Height", sprite.width, sprite.height);
EditorGUILayout.Separator();
GUI.backgroundColor = blueColor;
NGUIEditorTools.IntVector borderA = NGUIEditorTools.IntPair("Border", "Left", "Right", sprite.borderLeft, sprite.borderRight);
NGUIEditorTools.IntVector borderB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.borderBottom, sprite.borderTop);
EditorGUILayout.Separator();
GUI.backgroundColor = Color.white;
NGUIEditorTools.IntVector padA = NGUIEditorTools.IntPair("Padding", "Left", "Right", sprite.paddingLeft, sprite.paddingRight);
NGUIEditorTools.IntVector padB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.paddingBottom, sprite.paddingTop);
if (GUI.changed)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.x = sizeA.x;
sprite.y = sizeA.y;
sprite.width = sizeB.x;
sprite.height = sizeB.y;
sprite.paddingLeft = padA.x;
sprite.paddingRight = padA.y;
sprite.paddingBottom = padB.x;
sprite.paddingTop = padB.y;
sprite.borderLeft = borderA.x;
sprite.borderRight = borderA.y;
sprite.borderBottom = borderB.x;
sprite.borderTop = borderB.y;
MarkSpriteAsDirty();
}
GUILayout.Space(3f);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Duplicate"))
{
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.DuplicateSprite(mAtlas, sprite.name);
if (se != null)
{
NGUISettings.selectedSprite = se.name;
}
}
if (GUILayout.Button("Save As..."))
{
#if UNITY_3_5
string path = EditorUtility.SaveFilePanel("Save As",
NGUISettings.currentPath, sprite.name + ".png", "png");
#else
string path = EditorUtility.SaveFilePanelInProject("Save As",
sprite.name + ".png", "png",
"Extract sprite into which file?", NGUISettings.currentPath);
#endif
if (!string.IsNullOrEmpty(path))
{
NGUISettings.currentPath = System.IO.Path.GetDirectoryName(path);
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.ExtractSprite(mAtlas, sprite.name);
if (se != null)
{
byte[] bytes = se.tex.EncodeToPNG();
File.WriteAllBytes(path, bytes);
AssetDatabase.ImportAsset(path);
if (se.temporaryTexture)
{
DestroyImmediate(se.tex);
}
}
}
}
GUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.DrawHeader("Modify"))
{
NGUIEditorTools.BeginContents();
EditorGUILayout.BeginHorizontal();
GUILayout.Space(20f);
EditorGUILayout.BeginVertical();
NGUISettings.backgroundColor = EditorGUILayout.ColorField("Background", NGUISettings.backgroundColor);
if (GUILayout.Button("Add a Shadow"))
{
AddShadow(sprite);
}
if (GUILayout.Button("Add a Soft Outline"))
{
AddOutline(sprite);
}
if (GUILayout.Button("Add a Transparent Border"))
{
AddTransparentBorder(sprite);
}
if (GUILayout.Button("Add a Clamped Border"))
{
AddClampedBorder(sprite);
}
if (GUILayout.Button("Add a Tiled Border"))
{
AddTiledBorder(sprite);
}
EditorGUI.BeginDisabledGroup(!sprite.hasBorder);
if (GUILayout.Button("Crop Border"))
{
CropBorder(sprite);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndVertical();
GUILayout.Space(20f);
EditorGUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.previousSelection != null)
{
GUILayout.Space(3f);
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
if (NGUIEditorTools.DrawHeader("Texture Optimization"))
{
NGUIEditorTools.BeginContents();
GUILayout.Space(3f);
EditorGUILayout.BeginHorizontal();
NGUIEditorTools.DrawPadding();
TextureCompressionQuality afterType = (TextureCompressionQuality)EditorGUILayout.EnumPopup("Quality Type", NGUIEditorTools.mTextureType);
NGUIEditorTools.DrawPadding();
if (afterType != NGUIEditorTools.mTextureType)
{
NGUIEditorTools.mTextureType = afterType;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
NGUIEditorTools.DrawPadding();
EditorGUILayout.BeginVertical();
EditorGUI.BeginDisabledGroup(mat.shader.name != "My Shaders/UITextureBinding");
if (GUILayout.Button("원본 사용"))
{
NGUIEditorTools.SetTextureOptimization(mAtlas, false);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
EditorGUI.BeginDisabledGroup(mat.shader.name != "Unlit/Transparent Colored");
if (GUILayout.Button("최적화 사용"))
{
NGUIEditorTools.SetTextureOptimization(mAtlas, true);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndVertical();
NGUIEditorTools.DrawPadding();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
NGUIEditorTools.DrawPadding();
EditorGUILayout.BeginVertical();
if (GUILayout.Button("전체 원본으로"))
{
string[] aAtlasFiles = Directory.GetFiles("Assets/Resources/Prefabs/UI_Data/UI_Atlas", "*.prefab", SearchOption.AllDirectories);
for (int i = 0; i < aAtlasFiles.Length; ++i)
{
EditorUtility.DisplayProgressBar("Texture Optimization", "Combine...", ((i + 1) / (float)aAtlasFiles.Length));
UIAtlas sourceAtlas = (UIAtlas)AssetDatabase.LoadAssetAtPath(aAtlasFiles[i], typeof(UIAtlas)) as UIAtlas;
NGUIEditorTools.SetTextureOptimization(sourceAtlas, false);
}
EditorUtility.ClearProgressBar();
}
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
if (GUILayout.Button("전체 최적화"))
{
string[] aAtlasFiles = Directory.GetFiles("Assets/Resources/Prefabs/UI_Data/UI_Atlas", "*.prefab", SearchOption.AllDirectories);
for (int i = 0; i < aAtlasFiles.Length; ++i)
{
EditorUtility.DisplayProgressBar("Texture Optimization", string.Format("Devide..."), ((i + 1) / (float)aAtlasFiles.Length));
UIAtlas sourceAtlas = (UIAtlas)AssetDatabase.LoadAssetAtPath(aAtlasFiles[i], typeof(UIAtlas)) as UIAtlas;
shaderTextureBinding = shaderTextureBinding == null?Shader.Find("My Shaders/UITextureBinding") : shaderTextureBinding;
sourceAtlas.spriteMaterial.shader = shaderTextureBinding;
NGUIEditorTools.CopyAndChangeTexture(sourceAtlas, true);
sourceAtlas = (UIAtlas)AssetDatabase.LoadAssetAtPath(aAtlasFiles[i], typeof(UIAtlas)) as UIAtlas;
NGUIEditorTools.CopyAndChangeTexture(sourceAtlas, false);
}
EditorUtility.ClearProgressBar();
}
EditorGUILayout.EndVertical();
NGUIEditorTools.DrawPadding();
EditorGUILayout.EndHorizontal();
EditorGUILayout.HelpBox("Quality Type : 텍스쳐의 Compression Quality (Best는 속도가 느리기 때문에 빌드할 때만 한다.)\n" +
"원본, 최적화 사용 : 해당 아틀라스의 텍스쳐를 원본, 최적화 상태로 변경한다.\n" +
"전체 원본, 전체 최적화 : UI_Atlas 폴더에 있는 모든 아틀라스를 일괄 원본, 최적화 상태로 변경한다.", MessageType.Info);
NGUIEditorTools.EndContents();
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
NGUIEditorTools.SetLabelWidth(80f);
mAtlas = target as UIAtlas;
UISpriteData sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
GUILayout.Space(6f);
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
GUILayout.BeginHorizontal();
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
NGUIEditorTools.DrawPadding();
GUILayout.EndHorizontal();
if (mType != after)
{
if (after == AtlasType.Normal)
{
mType = AtlasType.Normal;
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas, true);
GUILayout.Space(6f);
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
NGUITools.SetDirty(mAtlas);
}
return;
}
//GUILayout.Space(6f);
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
mAtlas.MarkAsChanged();
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsChanged();
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
}
}
if (mAtlas.spriteMaterial != null)
{
Color blueColor = new Color(0f, 0.7f, 1f, 1f);
Color greenColor = new Color(0.4f, 1f, 0f, 1f);
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
if (sprite == null)
{
sprite = mAtlas.spriteList[0];
}
}
if (sprite != null)
{
if (sprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
if (!NGUIEditorTools.DrawHeader("Sprite Details"))
{
return;
}
NGUIEditorTools.BeginContents();
GUILayout.Space(3f);
NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
GUILayout.Space(6f);
GUI.changed = false;
GUI.backgroundColor = greenColor;
NGUIEditorTools.IntVector sizeA = NGUIEditorTools.IntPair("Dimensions", "X", "Y", sprite.x, sprite.y);
NGUIEditorTools.IntVector sizeB = NGUIEditorTools.IntPair(null, "Width", "Height", sprite.width, sprite.height);
EditorGUILayout.Separator();
GUI.backgroundColor = blueColor;
NGUIEditorTools.IntVector borderA = NGUIEditorTools.IntPair("Border", "Left", "Right", sprite.borderLeft, sprite.borderRight);
NGUIEditorTools.IntVector borderB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.borderBottom, sprite.borderTop);
EditorGUILayout.Separator();
GUI.backgroundColor = Color.white;
NGUIEditorTools.IntVector padA = NGUIEditorTools.IntPair("Padding", "Left", "Right", sprite.paddingLeft, sprite.paddingRight);
NGUIEditorTools.IntVector padB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.paddingBottom, sprite.paddingTop);
if (GUI.changed)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.x = sizeA.x;
sprite.y = sizeA.y;
sprite.width = sizeB.x;
sprite.height = sizeB.y;
sprite.paddingLeft = padA.x;
sprite.paddingRight = padA.y;
sprite.paddingBottom = padB.x;
sprite.paddingTop = padB.y;
sprite.borderLeft = borderA.x;
sprite.borderRight = borderA.y;
sprite.borderBottom = borderB.x;
sprite.borderTop = borderB.y;
MarkSpriteAsDirty();
}
GUILayout.Space(3f);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Duplicate"))
{
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.DuplicateSprite(mAtlas, sprite.name);
if (se != null)
{
NGUISettings.selectedSprite = se.name;
}
}
if (GUILayout.Button("Save As..."))
{
string path = EditorUtility.SaveFilePanel("Save As",
NGUISettings.currentPath, sprite.name + ".png", "png");
if (!string.IsNullOrEmpty(path))
{
NGUISettings.currentPath = System.IO.Path.GetDirectoryName(path);
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.ExtractSprite(mAtlas, sprite.name);
if (se != null)
{
byte[] bytes = se.tex.EncodeToPNG();
File.WriteAllBytes(path, bytes);
AssetDatabase.ImportAsset(path);
if (se.temporaryTexture)
{
DestroyImmediate(se.tex);
}
}
}
}
if (GUILayout.Button("Save As All"))
{
string path = EditorUtility.SaveFolderPanel("Save As All",
NGUISettings.currentPath, "");
if (!string.IsNullOrEmpty(path))
{
var list = mAtlas.spriteList;
foreach (var uiSpriteData in list)
{
var spName = uiSpriteData.name;
NGUISettings.currentPath = path;
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.ExtractSprite(mAtlas, spName);
if (se != null)
{
var filePath = string.Format("{0}/{1}.png", path, spName);
byte[] bytes = se.tex.EncodeToPNG();
File.WriteAllBytes(filePath, bytes);
AssetDatabase.ImportAsset(filePath);
if (se.temporaryTexture)
{
DestroyImmediate(se.tex);
}
}
}
}
}
GUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.DrawHeader("Modify"))
{
NGUIEditorTools.BeginContents();
EditorGUILayout.BeginHorizontal();
GUILayout.Space(20f);
EditorGUILayout.BeginVertical();
NGUISettings.backgroundColor = EditorGUILayout.ColorField("Background", NGUISettings.backgroundColor);
if (GUILayout.Button("Add a Shadow"))
{
AddShadow(sprite);
}
if (GUILayout.Button("Add a Soft Outline"))
{
AddOutline(sprite);
}
if (GUILayout.Button("Add a Transparent Border"))
{
AddTransparentBorder(sprite);
}
if (GUILayout.Button("Add a Clamped Border"))
{
AddClampedBorder(sprite);
}
if (GUILayout.Button("Add a Tiled Border"))
{
AddTiledBorder(sprite);
}
EditorGUI.BeginDisabledGroup(!sprite.hasBorder);
if (GUILayout.Button("Crop Border"))
{
CropBorder(sprite);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndVertical();
GUILayout.Space(20f);
EditorGUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.previousSelection != null)
{
GUILayout.Space(3f);
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
mAtlas = target as UIAtlas;
NGUIEditorTools.DrawSeparator();
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement as UIAtlas;
}
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
if (mType != after)
{
if (after == AtlasType.Normal)
{
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement as UIAtlas, OnSelectAtlas);
NGUIEditorTools.DrawSeparator();
GUILayout.Label("You can have one atlas simply point to\n" +
"another one. This is useful if you want to be\n" +
"able to quickly replace the contents of one\n" +
"atlas with another one, for example for\n" +
"swapping an SD atlas with an HD one, or\n" +
"replacing an English atlas with a Chinese\n" +
"one. All the sprites referencing this atlas\n" +
"will update their references to the new one.");
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mAtlas);
}
return;
}
if (!mConfirmDelete)
{
NGUIEditorTools.DrawSeparator();
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
mAtlas.MarkAsDirty();
mConfirmDelete = false;
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (mSprite != null)
{
mSprite = mAtlas.GetSprite(mSprite.name);
}
mAtlas.MarkAsDirty();
}
UIAtlas.Coordinates coords = (UIAtlas.Coordinates)EditorGUILayout.EnumPopup("Coordinates", mAtlas.coordinates);
if (coords != mAtlas.coordinates)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.coordinates = coords;
mConfirmDelete = false;
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize);
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
mConfirmDelete = false;
}
}
}
if (mAtlas.spriteMaterial != null)
{
Color blue = new Color(0f, 0.7f, 1f, 1f);
Color green = new Color(0.4f, 1f, 0f, 1f);
if (mConfirmDelete)
{
if (mSprite != null)
{
// Show the confirmation dialog
NGUIEditorTools.DrawSeparator();
GUILayout.Label("Are you sure you want to delete '" + mSprite.name + "'?");
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Cancel"))
{
mConfirmDelete = false;
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete"))
{
NGUIEditorTools.RegisterUndo("Delete Sprite", mAtlas);
mAtlas.spriteList.Remove(mSprite);
mConfirmDelete = false;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
}
else
{
mConfirmDelete = false;
}
}
else
{
if (mSprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = EditorPrefs.GetString("NGUI Selected Sprite");
if (!string.IsNullOrEmpty(spriteName))
{
mSprite = mAtlas.GetSprite(spriteName);
}
if (mSprite == null)
{
mSprite = mAtlas.spriteList[0];
}
}
GUI.backgroundColor = Color.green;
GUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel("Add/Delete");
if (GUILayout.Button("New Sprite"))
{
NGUIEditorTools.RegisterUndo("Add Sprite", mAtlas);
UIAtlas.Sprite newSprite = new UIAtlas.Sprite();
if (mSprite != null)
{
newSprite.name = "Copy of " + mSprite.name;
newSprite.outer = mSprite.outer;
newSprite.inner = mSprite.inner;
}
else
{
newSprite.name = "New Sprite";
}
mAtlas.spriteList.Add(newSprite);
mSprite = newSprite;
}
// Show the delete button
GUI.backgroundColor = Color.red;
if (mSprite != null && GUILayout.Button("Delete", GUILayout.Width(55f)))
{
mConfirmDelete = true;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
if (!mConfirmDelete && mSprite != null)
{
NGUIEditorTools.DrawSeparator();
string spriteName = UISpriteInspector.SpriteField(mAtlas, mSprite.name);
if (spriteName != mSprite.name)
{
mSprite = mAtlas.GetSprite(spriteName);
EditorPrefs.SetString("NGUI Selected Sprite", spriteName);
}
if (mSprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
Rect inner = mSprite.inner;
Rect outer = mSprite.outer;
string name = EditorGUILayout.TextField("Edit Name", mSprite.name);
if (mSprite.name != name && !string.IsNullOrEmpty(name))
{
bool found = false;
foreach (UIAtlas.Sprite sp in mAtlas.spriteList)
{
if (sp.name == name)
{
found = true;
break;
}
}
if (!found)
{
NGUIEditorTools.RegisterUndo("Edit Sprite Name", mAtlas);
mSprite.name = name;
}
}
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
GUI.backgroundColor = green;
outer = NGUIEditorTools.IntRect("Dimensions", mSprite.outer);
Vector4 border = new Vector4(
mSprite.inner.xMin - mSprite.outer.xMin,
mSprite.inner.yMin - mSprite.outer.yMin,
mSprite.outer.xMax - mSprite.inner.xMax,
mSprite.outer.yMax - mSprite.inner.yMax);
GUI.backgroundColor = blue;
border = NGUIEditorTools.IntPadding("Border", border);
GUI.backgroundColor = Color.white;
inner.xMin = mSprite.outer.xMin + border.x;
inner.yMin = mSprite.outer.yMin + border.y;
inner.xMax = mSprite.outer.xMax - border.z;
inner.yMax = mSprite.outer.yMax - border.w;
}
else
{
// Draw the inner and outer rectangle dimensions
GUI.backgroundColor = green;
outer = EditorGUILayout.RectField("Outer Rect", mSprite.outer);
GUI.backgroundColor = blue;
inner = EditorGUILayout.RectField("Inner Rect", mSprite.inner);
GUI.backgroundColor = Color.white;
}
if (outer.xMax < outer.xMin)
{
outer.xMax = outer.xMin;
}
if (outer.yMax < outer.yMin)
{
outer.yMax = outer.yMin;
}
if (outer != mSprite.outer)
{
float x = outer.xMin - mSprite.outer.xMin;
float y = outer.yMin - mSprite.outer.yMin;
inner.x += x;
inner.y += y;
}
// Sanity checks to ensure that the inner rect is always inside the outer
inner.xMin = Mathf.Clamp(inner.xMin, outer.xMin, outer.xMax);
inner.xMax = Mathf.Clamp(inner.xMax, outer.xMin, outer.xMax);
inner.yMin = Mathf.Clamp(inner.yMin, outer.yMin, outer.yMax);
inner.yMax = Mathf.Clamp(inner.yMax, outer.yMin, outer.yMax);
EditorGUILayout.Separator();
// Padding is mainly meant to be used by the 'trimmed' feature of TexturePacker
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
int left = Mathf.RoundToInt(mSprite.paddingLeft * mSprite.outer.width);
int right = Mathf.RoundToInt(mSprite.paddingRight * mSprite.outer.width);
int top = Mathf.RoundToInt(mSprite.paddingTop * mSprite.outer.height);
int bottom = Mathf.RoundToInt(mSprite.paddingBottom * mSprite.outer.height);
NGUIEditorTools.IntVector a = NGUIEditorTools.IntPair("Padding", "Left", "Top", left, top);
NGUIEditorTools.IntVector b = NGUIEditorTools.IntPair(null, "Right", "Bottom", right, bottom);
if (a.x != left || a.y != top || b.x != right || b.y != bottom)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mSprite.paddingLeft = a.x / mSprite.outer.width;
mSprite.paddingTop = a.y / mSprite.outer.width;
mSprite.paddingRight = b.x / mSprite.outer.height;
mSprite.paddingBottom = b.y / mSprite.outer.height;
MarkSpriteAsDirty();
}
}
else
{
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected0 = outer;
Rect corrected1 = inner;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0);
corrected1 = NGUIMath.MakePixelPerfect(corrected1);
}
else
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0, tex.width, tex.height);
corrected1 = NGUIMath.MakePixelPerfect(corrected1, tex.width, tex.height);
}
if (corrected0 == mSprite.outer && corrected1 == mSprite.inner)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
outer = corrected0;
inner = corrected1;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
}
GUILayout.BeginHorizontal();
{
mView = (View)EditorGUILayout.EnumPopup("Show", mView);
GUILayout.Label("Shader", GUILayout.Width(45f));
if (mUseShader != EditorGUILayout.Toggle(mUseShader, GUILayout.Width(20f)))
{
mUseShader = !mUseShader;
if (mUseShader && mView == View.Sprite)
{
// TODO: Remove this when Unity fixes the bug with DrawPreviewTexture not being affected by BeginGroup
Debug.LogWarning("There is a bug in Unity that prevents the texture from getting clipped properly.\n" +
"Until it's fixed by Unity, your texture may spill onto the rest of the Unity's GUI while using this mode.");
}
}
}
GUILayout.EndHorizontal();
if (mSprite.outer != outer || mSprite.inner != inner)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mSprite.outer = outer;
mSprite.inner = inner;
mConfirmDelete = false;
MarkSpriteAsDirty();
}
Rect uv0 = outer;
Rect uv1 = inner;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
uv0 = NGUIMath.ConvertToTexCoords(uv0, tex.width, tex.height);
uv1 = NGUIMath.ConvertToTexCoords(uv1, tex.width, tex.height);
}
// Draw the atlas
EditorGUILayout.Separator();
Material m = mUseShader ? mAtlas.spriteMaterial : null;
Rect rect = (mView == View.Atlas) ? NGUIEditorTools.DrawAtlas(tex, m) : NGUIEditorTools.DrawSprite(tex, uv0, m);
// Draw the sprite outline
NGUIEditorTools.DrawOutline(rect, uv0, uv1);
EditorGUILayout.Separator();
}
}
}
}
}
private void OnGUI()
{
GUILayout.BeginVertical();
// 绘制作者信息
NIEditorUtility.DrawAuthorSummary();
GUILayout.Space(5);
if (GUILayout.Button("刷新", GUILayout.MaxWidth(70)))
{
Refresh();
return;
}
GUILayout.Space(5);
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
GUI.backgroundColor = new Color32(150, 200, 255, 255);
//未创建的在前，已创建的在后
dirList.Sort((string a, string b) =>
{
string aPath = a.Replace("Z_RES/Atlas/", "Assets/Art/Atlas/");
string bPath = b.Replace("Z_RES/Atlas/", "Assets/Art/Atlas/");
bool ae = Directory.Exists(aPath);
bool be = Directory.Exists(bPath);
if (ae && !be)
{
return(1);
}
else if (!ae && be)
{
return(-1);
}
else
{
//GetFileNameWithoutExtension得到没有扩充名(.txt)的文件名
//按首字母排序
string aN = Path.GetFileNameWithoutExtension(a);
string bN = Path.GetFileNameWithoutExtension(b);
return(aN[0] - bN[0]);
}
});
//文件夹列表
scrollPos = GUILayout.BeginScrollView(scrollPos, "AS TextArea", GUILayout.Width(480), GUILayout.Height(600));
for (int i = 0; i < dirList.Count; i++)
{
string atlasName = Path.GetFileNameWithoutExtension(dirList[i]);
GUILayout.BeginHorizontal();
GUILayout.Space(10f);
string resPath = dirList[i].Replace("Z_RES/Atlas/", "Assets/Art/Atlas/");
string buttonTxt = "";
bool isNew = false;
if (Directory.Exists(resPath))
{
buttonTxt = "更新";
}
else
{
buttonTxt = "创建";
isNew = true;
}
if (isNew)
{
GUI.color = Color.green;
}
//1.创建/更新按钮
if (GUILayout.Button(buttonTxt, GUILayout.Width(50), GUILayout.Height(20)))
{
MakeAtlas(atlasName);
}
if (isNew)
{
GUI.color = Color.white;
}
//2.文件夹名
GUILayout.Label(atlasName, EditorStyles.boldLabel);
//3.配置文件按钮
if (!isNew)
{
if (GUILayout.Button("配置", GUILayout.Width(70f), GUILayout.Height(20)))
{
if (File.Exists(ATLAS_PREFAB_PATH + atlasName + "Atlas" + ".prefab"))
{
UIAtlas atlas = Resources.Load <UIAtlas>("Atlas/" + atlasName + "Atlas");
string textPath = ATLAS_PATH + atlasName + ".txt";
textPath = GetProjectRelativePath(textPath);
TextAsset configuration = AssetDatabase.LoadAssetAtPath <TextAsset>(textPath);
NGUIJson.LoadSpriteData(atlas, configuration); //装载图集配置文件
atlas.MarkAsChanged();
PrefabUtility.RecordPrefabInstancePropertyModifications(atlas);
}
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10f);
}
GUILayout.EndScrollView();
GUI.backgroundColor = Color.white;
GUILayout.Space(10f);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
}
//resName:文件夹名字->Common
private void SetMeta(string resName)
{
string pngPath = ATLAS_PATH + resName + "/" + resName + ".png";
string alphaPath = ATLAS_PATH + resName + "/" + resName + "_alpha" + ".png";
string textPath = ATLAS_PATH + resName + "/" + resName + ".txt";
pngPath = GetProjectRelativePath(pngPath);
alphaPath = GetProjectRelativePath(alphaPath);
textPath = GetProjectRelativePath(textPath);
//设置图片属性
TextureImporter texImp = AssetImporter.GetAtPath(pngPath) as TextureImporter;
texImp.textureType = TextureImporterType.Default;
//texImp.generateCubemap = TextureImporterGenerateCubemap.None;
texImp.alphaIsTransparency = true;
texImp.mipmapEnabled = false;
texImp.filterMode = FilterMode.Bilinear;
texImp.maxTextureSize = 2048;
//texImp.textureFormat = TextureImporterFormat.RGBA32;
texImp.spriteImportMode = SpriteImportMode.None;
texImp.SaveAndReimport();
texImp = AssetImporter.GetAtPath(alphaPath) as TextureImporter;
texImp.textureType = TextureImporterType.Default;
//texImp.generateCubemap = TextureImporterGenerateCubemap.None;
texImp.alphaIsTransparency = false;
texImp.spriteImportMode = SpriteImportMode.None;
texImp.filterMode = FilterMode.Bilinear;
texImp.mipmapEnabled = false;
texImp.maxTextureSize = 2048;
//texImp.textureFormat = TextureImporterFormat.Alpha8;
texImp.SaveAndReimport();
if (!File.Exists(ATLAS_PREFAB_PATH + resName + "Atlas" + ".prefab"))
{
//创建一个材质球并且配置好
Shader shader = Shader.Find("MyShader/two_tex_ui 1");
Material mat = new Material(shader);
Texture texture = AssetDatabase.LoadAssetAtPath <Texture>(pngPath);
Texture alp_texture = AssetDatabase.LoadAssetAtPath <Texture>(alphaPath);
mat.name = resName;
mat.SetTexture("_MainTex", texture);
texture = AssetDatabase.LoadAssetAtPath <Texture>(alphaPath);
mat.SetTexture("_FlagTex", texture);
AssetDatabase.CreateAsset(mat, GetProjectRelativePath(ATLAS_PATH + resName + "/" + resName + ".mat"));
//创建一个预设体且配置好
GameObject obj = new GameObject();
UIAtlas atlas = obj.AddComponent <UIAtlas>();
obj.name = resName + "Atlas";
atlas.spriteMaterial = mat;
if (atlas.texture != null)
{
NGUIEditorTools.ImportTexture(atlas.texture, false, false, !atlas.premultipliedAlpha);
}
atlas.MarkAsChanged();
TextAsset ta = AssetDatabase.LoadAssetAtPath <TextAsset>(textPath);
NGUIJson.LoadSpriteData(atlas, ta);
atlas.MarkAsChanged();
PrefabUtility.CreatePrefab(ATLAS_PREFAB_PATH + obj.name + ".prefab", obj, ReplacePrefabOptions.ReplaceNameBased);
GameObject.DestroyImmediate(obj);
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeControls(80f);
mAtlas = target as UIAtlas;
UIAtlas.Sprite sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
NGUIEditorTools.DrawSeparator();
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
if (mType != after)
{
if (after == AtlasType.Normal)
{
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas);
NGUIEditorTools.DrawSeparator();
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mAtlas);
}
return;
}
if (!mConfirmDelete)
{
NGUIEditorTools.DrawSeparator();
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
mAtlas.MarkAsDirty();
mConfirmDelete = false;
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsDirty();
}
UIAtlas.Coordinates coords = (UIAtlas.Coordinates)EditorGUILayout.EnumPopup("Coordinates", mAtlas.coordinates);
if (coords != mAtlas.coordinates)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.coordinates = coords;
mConfirmDelete = false;
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
mConfirmDelete = false;
}
}
}
if (mAtlas.spriteMaterial != null)
{
Color blue = new Color(0f, 0.7f, 1f, 1f);
Color green = new Color(0.4f, 1f, 0f, 1f);
if (mConfirmDelete)
{
if (sprite != null)
{
// Show the confirmation dialog
NGUIEditorTools.DrawSeparator();
GUILayout.Label("Are you sure you want to delete '" + sprite.name + "'?");
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("Cancel"))
{
mConfirmDelete = false;
}
GUI.backgroundColor = Color.red;
if (GUILayout.Button("Delete"))
{
NGUIEditorTools.RegisterUndo("Delete Sprite", mAtlas);
mAtlas.spriteList.Remove(sprite);
mConfirmDelete = false;
}
GUI.backgroundColor = Color.white;
}
GUILayout.EndHorizontal();
}
else
{
mConfirmDelete = false;
}
}
else
{
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
if (sprite == null)
{
sprite = mAtlas.spriteList[0];
}
}
if (!mConfirmDelete && sprite != null)
{
NGUIEditorTools.DrawSeparator();
NGUIEditorTools.AdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
if (sprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
Rect inner = sprite.inner;
Rect outer = sprite.outer;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
GUI.backgroundColor = green;
outer = NGUIEditorTools.IntRect("Dimensions", sprite.outer);
Vector4 border = new Vector4(
sprite.inner.xMin - sprite.outer.xMin,
sprite.inner.yMin - sprite.outer.yMin,
sprite.outer.xMax - sprite.inner.xMax,
sprite.outer.yMax - sprite.inner.yMax);
GUI.backgroundColor = blue;
border = NGUIEditorTools.IntPadding("Border", border);
GUI.backgroundColor = Color.white;
inner.xMin = sprite.outer.xMin + border.x;
inner.yMin = sprite.outer.yMin + border.y;
inner.xMax = sprite.outer.xMax - border.z;
inner.yMax = sprite.outer.yMax - border.w;
}
else
{
// Draw the inner and outer rectangle dimensions
GUI.backgroundColor = green;
outer = EditorGUILayout.RectField("Outer Rect", sprite.outer);
GUI.backgroundColor = blue;
inner = EditorGUILayout.RectField("Inner Rect", sprite.inner);
GUI.backgroundColor = Color.white;
}
if (outer.xMax < outer.xMin)
{
outer.xMax = outer.xMin;
}
if (outer.yMax < outer.yMin)
{
outer.yMax = outer.yMin;
}
if (outer != sprite.outer)
{
float x = outer.xMin - sprite.outer.xMin;
float y = outer.yMin - sprite.outer.yMin;
inner.x += x;
inner.y += y;
}
// Sanity checks to ensure that the inner rect is always inside the outer
inner.xMin = Mathf.Clamp(inner.xMin, outer.xMin, outer.xMax);
inner.xMax = Mathf.Clamp(inner.xMax, outer.xMin, outer.xMax);
inner.yMin = Mathf.Clamp(inner.yMin, outer.yMin, outer.yMax);
inner.yMax = Mathf.Clamp(inner.yMax, outer.yMin, outer.yMax);
bool changed = false;
if (sprite.inner != inner || sprite.outer != outer)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.inner = inner;
sprite.outer = outer;
MarkSpriteAsDirty();
changed = true;
}
EditorGUILayout.Separator();
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
int left = Mathf.RoundToInt(sprite.paddingLeft * sprite.outer.width);
int right = Mathf.RoundToInt(sprite.paddingRight * sprite.outer.width);
int top = Mathf.RoundToInt(sprite.paddingTop * sprite.outer.height);
int bottom = Mathf.RoundToInt(sprite.paddingBottom * sprite.outer.height);
NGUIEditorTools.IntVector a = NGUIEditorTools.IntPair("Padding", "Left", "Top", left, top);
NGUIEditorTools.IntVector b = NGUIEditorTools.IntPair(null, "Right", "Bottom", right, bottom);
if (changed || a.x != left || a.y != top || b.x != right || b.y != bottom)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.paddingLeft = a.x / sprite.outer.width;
sprite.paddingTop = a.y / sprite.outer.height;
sprite.paddingRight = b.x / sprite.outer.width;
sprite.paddingBottom = b.y / sprite.outer.height;
MarkSpriteAsDirty();
}
}
else
{
// Create a button that can make the coordinates pixel-perfect on click
GUILayout.BeginHorizontal();
{
GUILayout.Label("Correction", GUILayout.Width(75f));
Rect corrected0 = outer;
Rect corrected1 = inner;
if (mAtlas.coordinates == UIAtlas.Coordinates.Pixels)
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0);
corrected1 = NGUIMath.MakePixelPerfect(corrected1);
}
else
{
corrected0 = NGUIMath.MakePixelPerfect(corrected0, tex.width, tex.height);
corrected1 = NGUIMath.MakePixelPerfect(corrected1, tex.width, tex.height);
}
if (corrected0 == sprite.outer && corrected1 == sprite.inner)
{
GUI.color = Color.grey;
GUILayout.Button("Make Pixel-Perfect");
GUI.color = Color.white;
}
else if (GUILayout.Button("Make Pixel-Perfect"))
{
outer = corrected0;
inner = corrected1;
GUI.changed = true;
}
}
GUILayout.EndHorizontal();
}
}
// This functionality is no longer used. It became obsolete when the Atlas Maker was added.
/*NGUIEditorTools.DrawSeparator();
*
* GUILayout.BeginHorizontal();
* {
* EditorGUILayout.PrefixLabel("Add/Delete");
*
* if (GUILayout.Button("Clone Sprite"))
* {
* NGUIEditorTools.RegisterUndo("Add Sprite", mAtlas);
* UIAtlas.Sprite newSprite = new UIAtlas.Sprite();
*
* if (sprite != null)
* {
* newSprite.name = "Copy of " + sprite.name;
* newSprite.outer = sprite.outer;
* newSprite.inner = sprite.inner;
* }
* else
* {
* newSprite.name = "New Sprite";
* }
*
* mAtlas.spriteList.Add(newSprite);
* sprite = newSprite;
* }
*
* // Show the delete button
* GUI.backgroundColor = Color.red;
*
* if (sprite != null && GUILayout.Button("Delete", GUILayout.Width(55f)))
* {
* mConfirmDelete = true;
* }
* GUI.backgroundColor = Color.white;
* }
* GUILayout.EndHorizontal();*/
if (NGUIEditorTools.previousSelection != null)
{
NGUIEditorTools.DrawSeparator();
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
NGUIEditorTools.SetLabelWidth(80f);
mAtlas = target as UIAtlas;
UISpriteData sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
GUILayout.Space(6f);
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
GUILayout.BeginHorizontal();
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (mType != after)
{
if (after == AtlasType.Normal)
{
mType = AtlasType.Normal;
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas, true);
GUILayout.Space(6f);
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
UnityEditor.EditorUtility.SetDirty(mAtlas);
}
return;
}
//GUILayout.Space(6f);
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
mAtlas.MarkAsDirty();
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsDirty();
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
}
}
if (mAtlas.spriteMaterial != null)
{
Color blue = new Color(0f, 0.7f, 1f, 1f);
Color green = new Color(0.4f, 1f, 0f, 1f);
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
if (sprite == null)
{
sprite = mAtlas.spriteList[0];
}
}
if (sprite != null)
{
if (sprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
if (!NGUIEditorTools.DrawHeader("Sprite Details"))
{
return;
}
NGUIEditorTools.BeginContents();
GUILayout.Space(3f);
NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
GUILayout.Space(6f);
GUI.changed = false;
GUI.backgroundColor = green;
NGUIEditorTools.IntVector sizeA = NGUIEditorTools.IntPair("Dimensions", "X", "Y", sprite.x, sprite.y);
NGUIEditorTools.IntVector sizeB = NGUIEditorTools.IntPair(null, "Width", "Height", sprite.width, sprite.height);
EditorGUILayout.Separator();
GUI.backgroundColor = blue;
NGUIEditorTools.IntVector borderA = NGUIEditorTools.IntPair("Border", "Left", "Right", sprite.borderLeft, sprite.borderRight);
NGUIEditorTools.IntVector borderB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.borderBottom, sprite.borderTop);
EditorGUILayout.Separator();
GUI.backgroundColor = Color.white;
NGUIEditorTools.IntVector padA = NGUIEditorTools.IntPair("Padding", "Left", "Right", sprite.paddingLeft, sprite.paddingRight);
NGUIEditorTools.IntVector padB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.paddingBottom, sprite.paddingTop);
if (GUI.changed)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.x = sizeA.x;
sprite.y = sizeA.y;
sprite.width = sizeB.x;
sprite.height = sizeB.y;
sprite.paddingLeft = padA.x;
sprite.paddingRight = padA.y;
sprite.paddingBottom = padB.x;
sprite.paddingTop = padB.y;
sprite.borderLeft = borderA.x;
sprite.borderRight = borderA.y;
sprite.borderBottom = borderB.x;
sprite.borderTop = borderB.y;
MarkSpriteAsDirty();
}
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.previousSelection != null)
{
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
}
}
}
/// <summary>
/// 配置NGUI图集,srcFullPath是txt和png文件所在目录,绝对路径.atlasAssetPath是图集的目录,以Assets开头的路径
/// </summary>
private static void SetupNGUIAtlas(string srcFullPath, string atlasAssetPath)
{
try
{
AssetDatabase.Refresh();
List <string> fileList = new List <string>();
findFiles(srcFullPath, ref fileList, ".png", false);
for (int i = 0; i < fileList.Count; ++i)
{
EditorUtility.DisplayProgressBar("设置NGUI图集", "正在进行" + getFileName(fileList[i]), i / (float)fileList.Count);
createDir(atlasAssetPath);
string assetNameNoSuffix = atlasAssetPath + "/" + getFileNameNoSuffix(fileList[i], true);
string prefabFile = assetNameNoSuffix + ".prefab";
string matFile = assetNameNoSuffix + ".mat";
string destPNGFile = assetNameNoSuffix + ".png";
// 拷贝png文件
copyFile(fileList[i], projectPathToFullPath(destPNGFile));
AssetDatabase.Refresh();
// 加载文件图集文件，如果不存则创建
GameObject prefabAsset = AssetDatabase.LoadMainAssetAtPath(prefabFile) as GameObject;
if (prefabAsset == null)
{
GameObject temp = new GameObject();
prefabAsset = PrefabUtility.CreatePrefab(prefabFile, temp);
GameObject.DestroyImmediate(temp);
}
UIAtlas uiAtlas = prefabAsset.GetComponent <UIAtlas>();
if (uiAtlas == null)
{
uiAtlas = prefabAsset.AddComponent <UIAtlas>();
}
// 创建材质文件
Material matAsset = AssetDatabase.LoadMainAssetAtPath(matFile) as Material;
if (matAsset == null)
{
matAsset = new Material(Shader.Find("NGUIDefault"));
AssetDatabase.CreateAsset(matAsset, matFile);
}
// 配置图集参数
string srcPNGFile = fullPathToProjectPath(fileList[i]);
string dataFile = getFileNameNoSuffix(srcPNGFile) + ".txt";
Texture2D pngAsset = GetAtlasTexture(destPNGFile);
TextAsset dataAsset = AssetDatabase.LoadMainAssetAtPath(dataFile) as TextAsset;
matAsset.SetTexture("_MainTex", pngAsset);
uiAtlas.spriteMaterial = matAsset;
NGUIJson.LoadSpriteData(uiAtlas, dataAsset);
uiAtlas.MarkAsChanged();
EditorUtility.SetDirty(uiAtlas);
}
}
catch (System.Exception ex)
{
Debug.LogError("Error " + ex.ToString());
}
finally
{
EditorUtility.ClearProgressBar();
}
AssetDatabase.Refresh();
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
NGUIEditorTools.SetLabelWidth(80f);
mAtlas = target as UIAtlas;
UISpriteData sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
GUILayout.Space(6f);
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
GUILayout.BeginHorizontal();
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
GUILayout.Space(18f);
GUILayout.EndHorizontal();
if (mType != after)
{
if (after == AtlasType.Normal)
{
mType = AtlasType.Normal;
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas, true);
GUILayout.Space(6f);
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
NGUITools.SetDirty(mAtlas);
}
return;
}
//GUILayout.Space(6f);
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
mAtlas.MarkAsChanged();
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsChanged();
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
}
if (NGUIEditorTools.DrawHeader("Scale Factor"))
{
NGUIEditorTools.BeginContents();
{
EditorGUILayout.HelpBox(
"If the image size(pixel size in photoshop) is not equal to texture size(pixel size in unity), you should set the scale factor to help NGUI to adjust uv.",
MessageType.Info, true
);
EditorGUILayout.HelpBox(
"You should click the the button below to recalculate scale factor for atlas when the atlas' texture is changed. For example, when you add sprite, remove sprite, set compressed format or change maxsize etc.",
MessageType.Warning, true
);
if (GUILayout.Button("Calculate Scale Factor Automatically"))
{
if (mAtlas.texture != null)
{
string path = AssetDatabase.GetAssetPath(mAtlas.texture);
string fullPath = Application.dataPath + path.Substring("Assets".Length);
if (File.Exists(fullPath))
{
MemoryStream memoryStream = null;
BinaryReader binaryReader = null;
try
{
byte[] bytes = File.ReadAllBytes(fullPath);
memoryStream = new MemoryStream(bytes);
binaryReader = new BinaryReader(memoryStream);
// Is PNG
if (binaryReader.ReadByte() == 0x89 && binaryReader.ReadByte() == 0x50 && binaryReader.ReadByte() == 0x4E &&
binaryReader.ReadByte() == 0x47 && binaryReader.ReadByte() == 0x0D && binaryReader.ReadByte() == 0x0A &&
binaryReader.ReadByte() == 0x1A && binaryReader.ReadByte() == 0x0A)
{
binaryReader.ReadUInt32();
binaryReader.ReadUInt32();
uint width = LittleEndianToBigEndian(binaryReader.ReadUInt32());
uint height = LittleEndianToBigEndian(binaryReader.ReadUInt32());
TextureImporter textureImporter = (TextureImporter)TextureImporter.GetAtPath(AssetDatabase.GetAssetPath(mAtlas.texture));
System.Action <string, UIAtlas.SCALE_PLATFORM, BuildTarget> processScale = delegate(string platformName, UIAtlas.SCALE_PLATFORM platformAtlasEnum, BuildTarget platformEnum)
{
if (mAtlas.scales == null || mAtlas.scales.Length != (int)UIAtlas.SCALE_PLATFORM.SIZE * 2)
{
mAtlas.scales = new float[(int)UIAtlas.SCALE_PLATFORM.SIZE * 2] {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
}
// TextureImportInstructions info = new TextureImportInstructions();
// textureImporter.ReadTextureImportInstructions(info, platformEnum);
int maxSize;
TextureImporterFormat format;
if (textureImporter.GetPlatformTextureSettings(platformName, out maxSize, out format))
{
float len = width > height ? width : height;
mAtlas.scales[(int)platformAtlasEnum * 2] = len / (float)width;
mAtlas.scales[(int)platformAtlasEnum * 2 + 1] = len / (float)height;
}
else
{
mAtlas.scales[(int)platformAtlasEnum * 2] = 1;
mAtlas.scales[(int)platformAtlasEnum * 2 + 1] = 1;
}
};
processScale("Web", UIAtlas.SCALE_PLATFORM.WEB, BuildTarget.WebPlayer);
processScale("Standalone", UIAtlas.SCALE_PLATFORM.STANDALONE, BuildTarget.StandaloneWindows);
processScale("iPhone", UIAtlas.SCALE_PLATFORM.IPHONE, BuildTarget.iOS);
processScale("Android", UIAtlas.SCALE_PLATFORM.ANDROID, BuildTarget.Android);
NGUITools.SetDirty(mAtlas);
}
}
catch (System.Exception exception)
{
Debug.LogError(exception.StackTrace);
UnityEditor.EditorUtility.DisplayDialog("Error", "Error:Set the scale factor mamually.", "ok");
}
finally
{
if (memoryStream != null)
{
memoryStream.Close();
memoryStream.Dispose();
memoryStream = null;
}
if (binaryReader != null)
{
binaryReader.Close();
binaryReader = null;
}
}
}
else
{
UnityEditor.EditorUtility.DisplayDialog("Alert", "File is not exists\n" + fullPath, "ok");
}
}
else
{
UnityEditor.EditorUtility.DisplayDialog("Alert", "Null Texture", "ok");
}
}
}
NGUIEditorTools.EndContents();
}
}
if (mAtlas.spriteMaterial != null)
{
Color blueColor = new Color(0f, 0.7f, 1f, 1f);
Color greenColor = new Color(0.4f, 1f, 0f, 1f);
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
if (sprite == null)
{
sprite = mAtlas.spriteList[0];
}
}
if (sprite != null)
{
if (sprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
if (!NGUIEditorTools.DrawHeader("Sprite Details"))
{
return;
}
NGUIEditorTools.BeginContents();
GUILayout.Space(3f);
NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
GUILayout.Space(6f);
GUI.changed = false;
GUI.backgroundColor = greenColor;
NGUIEditorTools.IntVector sizeA = NGUIEditorTools.IntPair("Dimensions", "X", "Y", sprite.x, sprite.y);
NGUIEditorTools.IntVector sizeB = NGUIEditorTools.IntPair(null, "Width", "Height", sprite.width, sprite.height);
EditorGUILayout.Separator();
GUI.backgroundColor = blueColor;
NGUIEditorTools.IntVector borderA = NGUIEditorTools.IntPair("Border", "Left", "Right", sprite.borderLeft, sprite.borderRight);
NGUIEditorTools.IntVector borderB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.borderBottom, sprite.borderTop);
EditorGUILayout.Separator();
GUI.backgroundColor = Color.white;
NGUIEditorTools.IntVector padA = NGUIEditorTools.IntPair("Padding", "Left", "Right", sprite.paddingLeft, sprite.paddingRight);
NGUIEditorTools.IntVector padB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.paddingBottom, sprite.paddingTop);
if (GUI.changed)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.x = sizeA.x;
sprite.y = sizeA.y;
sprite.width = sizeB.x;
sprite.height = sizeB.y;
sprite.paddingLeft = padA.x;
sprite.paddingRight = padA.y;
sprite.paddingBottom = padB.x;
sprite.paddingTop = padB.y;
sprite.borderLeft = borderA.x;
sprite.borderRight = borderA.y;
sprite.borderBottom = borderB.x;
sprite.borderTop = borderB.y;
MarkSpriteAsDirty();
}
GUILayout.Space(3f);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Duplicate"))
{
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.DuplicateSprite(mAtlas, sprite.name);
if (se != null)
{
NGUISettings.selectedSprite = se.name;
}
}
if (GUILayout.Button("Save As..."))
{
string path = EditorUtility.SaveFilePanelInProject("Save As", sprite.name + ".png", "png", "Extract sprite into which file?");
if (!string.IsNullOrEmpty(path))
{
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.ExtractSprite(mAtlas, sprite.name);
if (se != null)
{
byte[] bytes = se.tex.EncodeToPNG();
File.WriteAllBytes(path, bytes);
AssetDatabase.ImportAsset(path);
if (se.temporaryTexture)
{
DestroyImmediate(se.tex);
}
}
}
}
GUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.DrawHeader("Modify"))
{
NGUIEditorTools.BeginContents();
EditorGUILayout.BeginHorizontal();
GUILayout.Space(20f);
EditorGUILayout.BeginVertical();
NGUISettings.backgroundColor = EditorGUILayout.ColorField("Background", NGUISettings.backgroundColor);
if (GUILayout.Button("Add a Shadow"))
{
AddShadow(sprite);
}
if (GUILayout.Button("Add a Soft Outline"))
{
AddOutline(sprite);
}
if (GUILayout.Button("Add a Transparent Border"))
{
AddTransparentBorder(sprite);
}
if (GUILayout.Button("Add a Clamped Border"))
{
AddClampedBorder(sprite);
}
if (GUILayout.Button("Add a Tiled Border"))
{
AddTiledBorder(sprite);
}
EditorGUI.BeginDisabledGroup(!sprite.hasBorder);
if (GUILayout.Button("Crop Border"))
{
CropBorder(sprite);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndVertical();
GUILayout.Space(20f);
EditorGUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.previousSelection != null)
{
GUILayout.Space(3f);
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
NGUIEditorTools.SetLabelWidth(80f);
mAtlas = target as UIAtlas;
UISpriteData sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
GUILayout.Space(6f);
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
GUILayout.BeginHorizontal();
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
NGUIEditorTools.DrawPadding();
GUILayout.EndHorizontal();
if (mType != after)
{
if (after == AtlasType.Normal)
{
mType = AtlasType.Normal;
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw <UIAtlas>(mAtlas.replacement, OnSelectAtlas, true);
GUILayout.Space(6f);
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != mAtlas && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.replacement = mReplacement;
NGUITools.SetDirty(mAtlas);
}
return;
}
//GUILayout.Space(6f);
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
mAtlas.MarkAsChanged();
}
#region //add by chenbin
if (mAtlas.isBorrowSpriteMode)
{
GUI.color = Color.green;
}
else
{
GUI.color = Color.white;
}
GUILayout.Label("\n=== =========================================");
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 (mAtlas != null && runTimes == 0)
{
runTimes++;
isBorrowMode = mAtlas.isBorrowSpriteMode;
// isUserUnity3DType = mAtlas.useUnity3DType;
}
mAtlas.isBorrowSpriteMode = EditorGUILayout.Toggle("isBorrowSpriteMode", mAtlas.isBorrowSpriteMode);
if (isBorrowMode != mAtlas.isBorrowSpriteMode)
{
isBorrowMode = mAtlas.isBorrowSpriteMode;
UnityEditor.EditorUtility.SetDirty(mAtlas.gameObject);
}
// if (mAtlas.isBorrowSpriteMode) {
// mAtlas.useUnity3DType = EditorGUILayout.Toggle ("useUnity3DType", mAtlas.useUnity3DType);
// if (isUserUnity3DType != mAtlas.useUnity3DType) {
// isUserUnity3DType = mAtlas.useUnity3DType;
// UnityEditor.EditorUtility.SetDirty (NGUISettings.atlas.gameObject);
// }
// }
GUILayout.Label("============================================\n");
GUI.color = Color.white;
if (GUILayout.Button("Clean items if no png"))
{
if (EditorUtility.DisplayDialog("Alert", "Really ?", "Do it now!", "NO"))
{
UISpriteData item = null;
List <UISpriteData> list = new List <UISpriteData> ();
for (int i = 0; i < mAtlas.spriteList.Count; i++)
{
item = mAtlas.spriteList [i];
string path = Application.dataPath + "/" + item.path;
path = path.Replace("/upgradeRes/", "/upgradeRes4Dev/");
path = path.Replace("/upgradeRes4Publish/", "/upgradeRes4Dev/");
if (!File.Exists(path))
{
Debug.Log(path);
list.Add(item);
}
}
deleteSprites(list);
}
}
#endregion //end ======add by chenbin
if (mat != null || mAtlas.isBorrowSpriteMode) // modify by chenbin
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsChanged();
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
mAtlas.pixelSize = pixelSize;
}
}
if (mAtlas.spriteMaterial != null || mAtlas.isBorrowSpriteMode) //modify by chenbin
{
Color blueColor = new Color(0f, 0.7f, 1f, 1f);
Color greenColor = new Color(0.4f, 1f, 0f, 1f);
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
// if (sprite == null) sprite = mAtlas.spriteList[0]; // delete by chenbin
#region add by chenbin
if (sprite == null)
{
if (mAtlas.isBorrowSpriteMode)
{
sprite = mAtlas.spriteList [0];
spriteName = sprite.name;
sprite = mAtlas.borrowSpriteByname(spriteName, null);
}
else
{
sprite = mAtlas.spriteList [0];
}
}
#endregion
}
if (sprite != null)
{
if (sprite == null)
{
return;
}
// Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D; //delete by chenbin
#region add by chenbin
Texture2D tex = null;
if (mAtlas != null)
{
if (mAtlas.isBorrowSpriteMode)
{
if (sprite != null && sprite.material != null)
{
tex = sprite.material.mainTexture as Texture2D;
}
}
else
{
tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
}
}
#endregion
// if (tex != null) //modify by chenbin
if (tex != null || (mAtlas != null && mAtlas.isBorrowSpriteMode && sprite != null)) //modify by chenbin
{
if (!NGUIEditorTools.DrawHeader("Sprite Details"))
{
return;
}
NGUIEditorTools.BeginContents();
GUILayout.Space(3f);
NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
GUILayout.Space(6f);
GUI.changed = false;
GUI.backgroundColor = greenColor;
NGUIEditorTools.IntVector sizeA = NGUIEditorTools.IntPair("Dimensions", "X", "Y", sprite.x, sprite.y);
NGUIEditorTools.IntVector sizeB = NGUIEditorTools.IntPair(null, "Width", "Height", sprite.width, sprite.height);
EditorGUILayout.Separator();
GUI.backgroundColor = blueColor;
NGUIEditorTools.IntVector borderA = NGUIEditorTools.IntPair("Border", "Left", "Right", sprite.borderLeft, sprite.borderRight);
NGUIEditorTools.IntVector borderB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.borderBottom, sprite.borderTop);
EditorGUILayout.Separator();
GUI.backgroundColor = Color.white;
NGUIEditorTools.IntVector padA = NGUIEditorTools.IntPair("Padding", "Left", "Right", sprite.paddingLeft, sprite.paddingRight);
NGUIEditorTools.IntVector padB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.paddingBottom, sprite.paddingTop);
if (GUI.changed)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas);
sprite.x = sizeA.x;
sprite.y = sizeA.y;
sprite.width = sizeB.x;
sprite.height = sizeB.y;
sprite.paddingLeft = padA.x;
sprite.paddingRight = padA.y;
sprite.paddingBottom = padB.x;
sprite.paddingTop = padB.y;
sprite.borderLeft = borderA.x;
sprite.borderRight = borderA.y;
sprite.borderBottom = borderB.x;
sprite.borderTop = borderB.y;
MarkSpriteAsDirty();
}
GUILayout.Space(3f);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Duplicate"))
{
string newName = UIAtlasMaker.DuplicateSprite(mAtlas, sprite.name); // modify by chenbin
if (newName != null)
{
NGUISettings.selectedSprite = newName; // modify by chenbin
}
}
if (GUILayout.Button("Save As..."))
{
#if UNITY_3_5
string path = EditorUtility.SaveFilePanel("Save As",
NGUISettings.currentPath, sprite.name + ".png", "png");
#else
string path = EditorUtility.SaveFilePanelInProject("Save As",
sprite.name + ".png", "png",
"Extract sprite into which file?", NGUISettings.currentPath);
#endif
if (!string.IsNullOrEmpty(path))
{
NGUISettings.currentPath = System.IO.Path.GetDirectoryName(path);
UIAtlasMaker.SpriteEntry se = UIAtlasMaker.ExtractSprite(mAtlas, sprite.name);
if (se != null)
{
byte[] bytes = se.tex.EncodeToPNG();
File.WriteAllBytes(path, bytes);
AssetDatabase.ImportAsset(path);
if (se.temporaryTexture)
{
DestroyImmediate(se.tex);
}
}
}
}
GUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.DrawHeader("Modify"))
{
NGUIEditorTools.BeginContents();
EditorGUILayout.BeginHorizontal();
GUILayout.Space(20f);
EditorGUILayout.BeginVertical();
NGUISettings.backgroundColor = EditorGUILayout.ColorField("Background", NGUISettings.backgroundColor);
if (GUILayout.Button("Add a Shadow"))
{
AddShadow(sprite);
}
if (GUILayout.Button("Add a Soft Outline"))
{
AddOutline(sprite);
}
if (GUILayout.Button("Add a Transparent Border"))
{
AddTransparentBorder(sprite);
}
if (GUILayout.Button("Add a Clamped Border"))
{
AddClampedBorder(sprite);
}
if (GUILayout.Button("Add a Tiled Border"))
{
AddTiledBorder(sprite);
}
EditorGUI.BeginDisabledGroup(!sprite.hasBorder);
if (GUILayout.Button("Crop Border"))
{
CropBorder(sprite);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndVertical();
GUILayout.Space(20f);
EditorGUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.previousSelection != null)
{
GUILayout.Space(3f);
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
}
}
}
/// <summary>
/// Draw the inspector widget.
/// </summary>
public override void OnInspectorGUI()
{
NGUIEditorTools.SetLabelWidth(80f);
if (mAtlas == null)
{
EditorGUILayout.HelpBox("Invalid asset. Please re-create it.", MessageType.Error, true);
return;
}
UISpriteData sprite = (mAtlas != null) ? mAtlas.GetSprite(NGUISettings.selectedSprite) : null;
GUILayout.Space(6f);
if (mAtlas.replacement != null)
{
mType = AtlasType.Reference;
mReplacement = mAtlas.replacement;
}
GUILayout.BeginHorizontal();
AtlasType after = (AtlasType)EditorGUILayout.EnumPopup("Atlas Type", mType);
NGUIEditorTools.DrawPadding();
GUILayout.EndHorizontal();
if (mType != after)
{
if (after == AtlasType.Normal)
{
mType = AtlasType.Normal;
OnSelectAtlas(null);
}
else
{
mType = AtlasType.Reference;
}
}
if (mType == AtlasType.Reference)
{
ComponentSelector.Draw(mAtlas.replacement, OnSelectAtlas, true);
GUILayout.Space(6f);
EditorGUILayout.HelpBox("You can have one atlas simply point to " +
"another one. This is useful if you want to be " +
"able to quickly replace the contents of one " +
"atlas with another one, for example for " +
"swapping an SD atlas with an HD one, or " +
"replacing an English atlas with a Chinese " +
"one. All the sprites referencing this atlas " +
"will update their references to the new one.", MessageType.Info);
if (mReplacement != (mAtlas as INGUIAtlas) && mAtlas.replacement != mReplacement)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas as Object);
mAtlas.replacement = mReplacement;
NGUITools.SetDirty(mAtlas as Object);
}
return;
}
if (mAtlas is UIAtlas)
{
EditorGUILayout.HelpBox("Legacy atlas type should be upgraded in order to maintain compatibility with Unity 2018 and newer.", MessageType.Warning, true);
if (GUILayout.Button("Upgrade"))
{
var path = EditorUtility.SaveFilePanelInProject("Save As", (mAtlas as Object).name + ".asset", "asset", "Save atlas as...", NGUISettings.currentPath);
if (!string.IsNullOrEmpty(path))
{
NGUISettings.currentPath = System.IO.Path.GetDirectoryName(path);
var asset = ScriptableObject.CreateInstance <NGUIAtlas>();
asset.spriteList = mAtlas.spriteList;
asset.spriteMaterial = mAtlas.spriteMaterial;
var atlasName = path.Replace(".asset", "");
atlasName = atlasName.Substring(path.LastIndexOfAny(new char[] { '/', '\\' }) + 1);
asset.name = atlasName;
var existing = AssetDatabase.LoadMainAssetAtPath(path);
if (existing != null)
{
EditorUtility.CopySerialized(asset, existing);
}
else
{
AssetDatabase.CreateAsset(asset, path);
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
asset = AssetDatabase.LoadAssetAtPath <NGUIAtlas>(path);
NGUISettings.atlas = asset;
Selection.activeObject = NGUISettings.atlas as Object;
if (asset != null)
{
mAtlas.replacement = asset;
mAtlas.MarkAsChanged();
}
}
}
}
//GUILayout.Space(6f);
Material mat = EditorGUILayout.ObjectField("Material", mAtlas.spriteMaterial, typeof(Material), false) as Material;
if (mAtlas.spriteMaterial != mat)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas as Object);
mAtlas.spriteMaterial = mat;
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
mAtlas.MarkAsChanged();
}
if (mat != null)
{
TextAsset ta = EditorGUILayout.ObjectField("TP Import", null, typeof(TextAsset), false) as TextAsset;
if (ta != null)
{
// Ensure that this atlas has valid import settings
if (mAtlas.texture != null)
{
NGUIEditorTools.ImportTexture(mAtlas.texture, false, false, !mAtlas.premultipliedAlpha);
}
NGUIEditorTools.RegisterUndo("Import Sprites", mAtlas as Object);
NGUIJson.LoadSpriteData(mAtlas, ta);
if (sprite != null)
{
sprite = mAtlas.GetSprite(sprite.name);
}
mAtlas.MarkAsChanged();
}
float pixelSize = EditorGUILayout.FloatField("Pixel Size", mAtlas.pixelSize, GUILayout.Width(120f));
if (pixelSize != mAtlas.pixelSize)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas as Object);
mAtlas.pixelSize = pixelSize;
}
}
if (mAtlas.spriteMaterial != null)
{
Color blueColor = new Color(0f, 0.7f, 1f, 1f);
Color greenColor = new Color(0.4f, 1f, 0f, 1f);
if (sprite == null && mAtlas.spriteList.Count > 0)
{
string spriteName = NGUISettings.selectedSprite;
if (!string.IsNullOrEmpty(spriteName))
{
sprite = mAtlas.GetSprite(spriteName);
}
if (sprite == null)
{
sprite = mAtlas.spriteList[0];
}
}
if (sprite != null)
{
if (sprite == null)
{
return;
}
Texture2D tex = mAtlas.spriteMaterial.mainTexture as Texture2D;
if (tex != null)
{
if (!NGUIEditorTools.DrawHeader("Sprite Details"))
{
return;
}
NGUIEditorTools.BeginContents();
GUILayout.Space(3f);
NGUIEditorTools.DrawAdvancedSpriteField(mAtlas, sprite.name, SelectSprite, true);
GUILayout.Space(6f);
GUI.changed = false;
GUI.backgroundColor = greenColor;
NGUIEditorTools.IntVector sizeA = NGUIEditorTools.IntPair("Dimensions", "X", "Y", sprite.x, sprite.y);
NGUIEditorTools.IntVector sizeB = NGUIEditorTools.IntPair(null, "Width", "Height", sprite.width, sprite.height);
EditorGUILayout.Separator();
GUI.backgroundColor = blueColor;
NGUIEditorTools.IntVector borderA = NGUIEditorTools.IntPair("Border", "Left", "Right", sprite.borderLeft, sprite.borderRight);
NGUIEditorTools.IntVector borderB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.borderBottom, sprite.borderTop);
EditorGUILayout.Separator();
GUI.backgroundColor = Color.white;
NGUIEditorTools.IntVector padA = NGUIEditorTools.IntPair("Padding", "Left", "Right", sprite.paddingLeft, sprite.paddingRight);
NGUIEditorTools.IntVector padB = NGUIEditorTools.IntPair(null, "Bottom", "Top", sprite.paddingBottom, sprite.paddingTop);
if (GUI.changed)
{
NGUIEditorTools.RegisterUndo("Atlas Change", mAtlas as Object);
sprite.x = sizeA.x;
sprite.y = sizeA.y;
sprite.width = sizeB.x;
sprite.height = sizeB.y;
sprite.paddingLeft = padA.x;
sprite.paddingRight = padA.y;
sprite.paddingBottom = padB.x;
sprite.paddingTop = padB.y;
sprite.borderLeft = borderA.x;
sprite.borderRight = borderA.y;
sprite.borderBottom = borderB.x;
sprite.borderTop = borderB.y;
MarkSpriteAsDirty();
NGUITools.SetDirty(mAtlas as Object);
}
GUILayout.Space(3f);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Duplicate"))
{
var se = UIAtlasMaker.DuplicateSprite(mAtlas, sprite.name);
if (se != null)
{
NGUISettings.selectedSprite = se.name;
}
}
if (GUILayout.Button("Save As..."))
{
var path = EditorUtility.SaveFilePanel("Save As",
NGUISettings.currentPath, sprite.name + ".png", "png");
if (!string.IsNullOrEmpty(path))
{
NGUISettings.currentPath = System.IO.Path.GetDirectoryName(path);
var se = UIAtlasMaker.ExtractSprite(mAtlas, sprite.name);
if (se != null)
{
var bytes = se.tex.EncodeToPNG();
File.WriteAllBytes(path, bytes);
//AssetDatabase.ImportAsset(path);
if (se.temporaryTexture)
{
DestroyImmediate(se.tex);
}
}
}
}
GUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.DrawHeader("Modify"))
{
NGUIEditorTools.BeginContents();
EditorGUILayout.BeginHorizontal();
GUILayout.Space(20f);
EditorGUILayout.BeginVertical();
NGUISettings.backgroundColor = EditorGUILayout.ColorField("Background", NGUISettings.backgroundColor);
if (GUILayout.Button("Add a Shadow"))
{
AddShadow(sprite);
}
if (GUILayout.Button("Add a Soft Outline"))
{
AddOutline(sprite);
}
if (GUILayout.Button("Add a Transparent Border"))
{
AddTransparentBorder(sprite);
}
if (GUILayout.Button("Add a Clamped Border"))
{
AddClampedBorder(sprite);
}
if (GUILayout.Button("Add a Tiled Border"))
{
AddTiledBorder(sprite);
}
EditorGUI.BeginDisabledGroup(!sprite.hasBorder);
if (GUILayout.Button("Crop Border"))
{
CropBorder(sprite);
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndVertical();
GUILayout.Space(20f);
EditorGUILayout.EndHorizontal();
NGUIEditorTools.EndContents();
}
if (NGUIEditorTools.previousSelection != null)
{
GUILayout.Space(3f);
GUI.backgroundColor = Color.green;
if (GUILayout.Button("<< Return to " + NGUIEditorTools.previousSelection.name))
{
NGUIEditorTools.SelectPrevious();
}
GUI.backgroundColor = Color.white;
}
}
}
}