static SpriteMetaData[] CreateSpriteSheetForTextureBogdan(Texture2D texture, SpriteSlicingOptions slicingOptions)
{
Rect[] gridRects = InternalSpriteUtility.GenerateGridSpriteRectangles(texture, Vector2.zero,
slicingOptions.CellSize, Vector2.zero);
string path = AssetDatabase.GetAssetPath(texture);
var importer = AssetImporter.GetAtPath(path) as TextureImporter;
var spriteSheet = importer.spritesheet ?? new SpriteMetaData[gridRects.Length];
// Add new sprite meta data to the end for all the newly parsed grid rects?
if (importer.spritesheet != null)
spriteSheet = spriteSheet.Concat(new SpriteMetaData[Mathf.Max(0, gridRects.Length - importer.spritesheet.Length)]).ToArray();
for (var i = 0; i < spriteSheet.Length; i++)
{
bool sliceExists = importer.spritesheet != null && i < importer.spritesheet.Length;
bool changePivot = !sliceExists || slicingOptions.OverridePivot;
spriteSheet[i] = new SpriteMetaData
{
alignment = changePivot ? (int) slicingOptions.Pivot: spriteSheet[i].alignment,
pivot = changePivot ? slicingOptions.CustomPivot : spriteSheet[i].pivot,
name = sliceExists ? spriteSheet[i].name : texture.name + "_" + i,
rect = gridRects[i]
};
}
if (slicingOptions.Frames > 0)
spriteSheet = spriteSheet.Take((int) slicingOptions.Frames).ToArray();
return spriteSheet;
}
void ConfigureSpriteAtlas(Texture2D texture, Rect[] uvs)
{
string path = AssetDatabase.GetAssetPath(texture);
TextureImporter texImporter = AssetImporter.GetAtPath(path) as TextureImporter;
TextureImporterSettings texImporterSettings = new TextureImporterSettings();
texImporter.textureType = TextureImporterType.Sprite;
texImporter.spriteImportMode = SpriteImportMode.Multiple;
// texImporterSettings.readable = true;
SpriteMetaData[] spritesheetMeta = new SpriteMetaData[uvs.Length];
for(int i = 0; i < uvs.Length; i++)
{
SpriteMetaData currentMeta = new SpriteMetaData();
Rect currentRect = uvs[i];
currentRect.x *= texture.width;
currentRect.width *= texture.width;
currentRect.y *= texture.height;
currentRect.height *= texture.height;
currentMeta.rect = currentRect;
currentMeta.name = textures[i].name;
currentMeta.alignment = (int)SpriteAlignment.Center;
currentMeta.pivot = new Vector2(currentRect.width / 2, currentRect.height / 2);
spritesheetMeta[i] = currentMeta;
}
texImporter.spritesheet = spritesheetMeta;
texImporter.spritePixelsToUnits = 1000f;
texImporter.ReadTextureSettings(texImporterSettings);
texImporter.SetTextureSettings(texImporterSettings);
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
AssetDatabase.Refresh();
}
private static void CreateSpriteSheetAtlasSliced() {
List<Texture2D> textures = new List<Texture2D> ();
Object[] selectedObjects = Selection.objects;
foreach (Object obj in selectedObjects) {
if(obj is Texture2D){
TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(obj));
if (importer != null) {
importer.textureType= TextureImporterType.Advanced;
importer.npotScale= TextureImporterNPOTScale.None;
importer.mipmapEnabled=false;
importer.isReadable=true;
AssetDatabase.ImportAsset (AssetDatabase.GetAssetPath(obj));
AssetDatabase.Refresh();
}
textures.Add(obj as Texture2D);
}
}
textures.Sort ((x, y) => string.Compare(x.name, y.name));
string path=AssetDatabase.GetAssetPath(textures[0]);
path=path.Remove(path.LastIndexOf('/'));
Texture2D atlas = new Texture2D(4096, 4096, TextureFormat.ARGB32, false);
Color[] colors=new Color[4096*4096];
for(int i=0; i< colors.Length;i++){
colors[i]=Color.clear;
}
atlas.SetPixels(colors);
atlas.Apply();
Rect[] rects=atlas.PackTextures(textures.ToArray(), 0,false);
byte[] bytes = atlas.EncodeToPNG();
System.IO.File.WriteAllBytes(path+ "/spritesheet.png", bytes);
AssetDatabase.Refresh();
TextureImporter tempImporter = (TextureImporter)AssetImporter.GetAtPath(path+"/spritesheet.png");
if (tempImporter != null) {
tempImporter.textureType = TextureImporterType.Sprite;
tempImporter.spriteImportMode=SpriteImportMode.Multiple;
tempImporter.maxTextureSize=4096;
int count=textures.Count;
SpriteMetaData[] meta= new SpriteMetaData[count];
for(int i=0; i< count;i++){
meta[i].name=i.ToString();
meta[i].alignment = (int)SpriteAlignment.Center;
meta[i].pivot=Vector2.zero;
meta[i].rect = rects[i];
}
tempImporter.spritesheet=meta;
AssetDatabase.ImportAsset (path+"/spritesheet.png");
AssetDatabase.Refresh();
}
}
static void SetSpriteNames()
{
Texture2D myTexture = (Texture2D)AssetDatabase.LoadAssetAtPath<Texture2D>("Assets/Sprites/MyTexture.png");
TextAsset xml = (TextAsset) AssetDatabase.LoadAssetAtPath<TextAsset>("Assets/Sprites/MyTexture.xml");
XmlDocument document = new XmlDocument();
document.LoadXml (xml.ToString());
string path = AssetDatabase.GetAssetPath(myTexture);
TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter;
ti.isReadable = true;
List<SpriteMetaData> newData = new List<SpriteMetaData>();
int SliceWidth = 16;
int SliceHeight = 16;
for (int i = 0; i < document.ChildNodes[0].ChildNodes.Count; i++) {
string name = document.ChildNodes[0].ChildNodes [i].Attributes [0].Value;
int x = int.Parse( document.ChildNodes[0].ChildNodes [i].Attributes [1].Value);
int y = int.Parse( document.ChildNodes[0].ChildNodes [i].Attributes [2].Value);
int w = int.Parse( document.ChildNodes[0].ChildNodes [i].Attributes [3].Value);
int h = int.Parse( document.ChildNodes[0].ChildNodes [i].Attributes [4].Value);
print (string.Format ("{0}, {1}, {2}, {3}, {4} ", name, x, y, w, h));
SpriteMetaData smd = new SpriteMetaData();
smd.pivot = new Vector2(0.5f, 0.5f);
smd.alignment = 9;
smd.name = name.Split('.')[0];
smd.rect = new Rect(x,myTexture.height - y -h, w, h);
if (smd.rect.height > 90) {
smd.border = Vector4.one * (100f / 3f);
}
newData.Add(smd);
}
// for (int i = 0; i < myTexture.width; i += SliceWidth)
// {
// for(int j = myTexture.height; j > 0; j -= SliceHeight)
// {
// SpriteMetaData smd = new SpriteMetaData();
// smd.pivot = new Vector2(0.5f, 0.5f);
// smd.alignment = 9;
// smd.name = (myTexture.height - j)/SliceHeight + ", " + i/SliceWidth;
// smd.rect = new Rect(i, j-SliceHeight, SliceWidth, SliceHeight);
//
// newData.Add(smd);
// }
// }
ti.spritesheet = newData.ToArray();
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
}
static void Slice()
{
//Load in the texture from the project folder.
Texture2D myTex = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/Resources/snow-expansion.png", typeof(Texture2D));
//Holds the path to the file.
string path = AssetDatabase.GetAssetPath(myTex);
//Lets you modify texture files.
TextureImporter ti = TextureImporter.GetAtPath(path) as TextureImporter;
//Do a check to see if its in multiple mode
//if(ti.spriteImportMode == SpriteImportMode.Multiple)
//{
// ti.spriteImportMode = SpriteImportMode.Single;
// AssetDatabase
//}
//Holds the inner sprite data
List<SpriteMetaData> newData = new List<SpriteMetaData>();
//How big you want the sprice to slice.
int sliceWidth = 16;
int sliceHeight = 16;
Debug.Log(ti.assetPath);
//For every sliceWidth cut a new one.
for(int i = 0; i < myTex.width; i += sliceWidth)
{
for(int j = myTex.height; j > 0; j -= sliceHeight)
{
//Create a new inner sprite
SpriteMetaData smd = new SpriteMetaData();
//Set the pivot to the center.
smd.pivot = new Vector2(0.5f, 0.5f);
//9 = custom alignment, 0 = center.
smd.alignment = 9;
smd.name = (myTex.height - j) / sliceHeight + ", " + i / sliceWidth;
smd.rect = new Rect(i, j - sliceHeight, sliceWidth, sliceHeight);
newData.Add(smd);
}
}
SpriteMetaData[] tempSpriteSheet = newData.ToArray();
Debug.Log(tempSpriteSheet.Length);
//set the sprite sheet to the list we just created.
ti.spritesheet = tempSpriteSheet;
ti.spriteImportMode = SpriteImportMode.Multiple;
ti.SaveAndReimport();
AssetDatabase.ImportAsset(path, ImportAssetOptions.Default);
}
private static SpriteMetaData GetMetaDataInSingleMode(string name, TextureImporter textureImporter)
{
SpriteMetaData spriteMetaData = new SpriteMetaData();
spriteMetaData.border = textureImporter.spriteBorder;
spriteMetaData.name = name;
spriteMetaData.pivot = textureImporter.spritePivot;
spriteMetaData.rect = new Rect(0.0f, 0.0f, 1f, 1f);
TextureImporterSettings dest = new TextureImporterSettings();
textureImporter.ReadTextureSettings(dest);
spriteMetaData.alignment = dest.spriteAlignment;
return spriteMetaData;
}
static SpriteMetaData JsonToSpriteMetadata(string spriteName, int height, Dictionary<string, object> frame)
{
SpriteMetaData meta = new SpriteMetaData ();
int x = int.Parse (frame ["x"].ToString ());
int y = int.Parse (frame ["y"].ToString ());
int w = int.Parse (frame ["w"].ToString ());
int h = int.Parse (frame ["h"].ToString ());
meta.name = spriteName;
meta.rect = new Rect (x, height - (y + h), w, h);
meta.pivot = new Vector2 (0.5f, 0.5f);
return meta;
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
List<string> updatedAssets = new List<string>(importedAssets);
updatedAssets.AddRange(movedAssets);
foreach (string assetPath in updatedAssets)
{
if (!assetPath.EndsWith(".xml"))
continue;
TextureAtlas atlas;
try
{
atlas = Utility.DeserializeXml<TextureAtlas>(assetPath);
}
catch (Exception e)
{
continue;
}
SpriteMetaData[] spritesheet = new SpriteMetaData[atlas.sprites.Count];
for (int i = 0; i < spritesheet.Length; i++)
{
Sprite sprite = atlas.sprites[i];
spritesheet[i].name = sprite.name;
spritesheet[i].rect = new Rect(sprite.x, atlas.height - sprite.height - sprite.y, sprite.width, sprite.height);
}
string imagePath = Path.GetDirectoryName(assetPath) + "/" + atlas.imagePath;
spriteMetaDataDictionary[imagePath] = spritesheet;
imagePathDictionary[assetPath] = imagePath;
AssetDatabase.ImportAsset(imagePath, ImportAssetOptions.ForceUpdate);
}
List<string> removedAssets = new List<string>(deletedAssets);
removedAssets.AddRange(movedFromAssetPaths);
foreach (string assetPath in removedAssets)
{
if (!assetPath.EndsWith(".xml"))
continue;
string imagePath;
if (!imagePathDictionary.TryGetValue(assetPath, out imagePath))
continue;
spriteMetaDataDictionary.Remove(imagePath);
imagePathDictionary.Remove(assetPath);
}
}
static SpriteMetaData[] CreateSpriteSheetForTextureSliceAll(Texture2D texture, SpriteSlicingOptions slicingOptions)
{
List<SpriteMetaData> sprites = new List<SpriteMetaData> ();
Rect[] gridRects = GetAllSliceRectsForTexture (texture, slicingOptions.CellSize);
for (int i = 0; i < gridRects.Length; i++) {
SpriteMetaData spriteMetaData = new SpriteMetaData ();
spriteMetaData.rect = gridRects[i];
spriteMetaData.alignment = (int) slicingOptions.Pivot;
spriteMetaData.pivot = slicingOptions.CustomPivot;
spriteMetaData.name = texture.name + "_" + i;
sprites.Add (spriteMetaData);
}
return sprites.ToArray ();
}
void CompareFirstAndLastRects(SpriteMetaData[] spritesheetA, SpriteMetaData[] spritesheetB)
{
var firstRect = spritesheetA[0].rect;
var lastRect = spritesheetA[spritesheetA.Length -1].rect;
var firstSlicedRect = spritesheetB[0].rect;
var lastSlicedRect = spritesheetB[spritesheetB.Length -1].rect;
Assert.AreEqual (firstRect, firstSlicedRect,
"First sprite rect does not match expected. ExpectedRect: " + firstRect,
" Actual rect:" + firstSlicedRect);
Assert.AreEqual (lastRect, lastSlicedRect,
"Last sprite rect does not match expected. ExpectedRect: " + lastRect,
" Actual rect:" + lastSlicedRect);
}
public static void SaveTex(Texture2D source, Texture2D newImage)
{
var bytes = newImage.EncodeToPNG();
string source_path = UnityEditor.AssetDatabase.GetAssetPath(source);
string path = //System.IO.Path.GetFileNameWithoutExtension(path);
UnityEditor.AssetDatabase.GenerateUniqueAssetPath(source_path);
System.IO.File.WriteAllBytes(path, bytes);
UnityEditor.AssetDatabase.Refresh();
//---
string copyFromPath = UnityEditor.AssetDatabase.GetAssetPath(source);
UnityEditor.TextureImporter ti1 = UnityEditor.AssetImporter.GetAtPath(copyFromPath) as UnityEditor.TextureImporter;
if (ti1.spriteImportMode == UnityEditor.SpriteImportMode.Multiple)
{
bool previousReadable = ti1.isReadable;
ti1.isReadable = true;
string copyToPath = path;
UnityEditor.TextureImporter ti2 = UnityEditor.AssetImporter.GetAtPath(copyToPath) as UnityEditor.TextureImporter;
ti2.isReadable = true;
ti2.spriteImportMode = UnityEditor.SpriteImportMode.Multiple;
ti2.spritePixelsPerUnit = ti1.spritePixelsPerUnit;
string previousName = System.IO.Path.GetFileNameWithoutExtension(source_path);
string newName = System.IO.Path.GetFileNameWithoutExtension(path);
List <UnityEditor.SpriteMetaData> newData = new List <UnityEditor.SpriteMetaData>();
for (int i = 0; i < ti1.spritesheet.Length; i++)
{
UnityEditor.SpriteMetaData d = ti1.spritesheet[i];
d.name = d.name.Replace(previousName, newName);
newData.Add(d);
}
ti2.spritesheet = newData.ToArray();
ti1.isReadable = previousReadable;
ti2.isReadable = previousReadable;
UnityEditor.AssetDatabase.ImportAsset(copyToPath, UnityEditor.ImportAssetOptions.ForceUpdate);
}
//---
Texture2D newFile = AssetDatabase.LoadAssetAtPath <Texture2D>(path);
EditorGUIUtility.PingObject(newFile);
Debug.Log("[Color Swapper] Saved at " + path, newFile);
}
void GenerateTxtSpriteSheet()
{
var path = AssetDatabase.GetAssetPath(texture);
var importer = (TextureImporter) TextureImporter.GetAtPath(path);
var doc = xmlTexture.text;
var sprites = doc.Split(new string[]{System.Environment.NewLine},System.StringSplitOptions.RemoveEmptyEntries);
var spriteSheet = new List<SpriteMetaData>();
foreach(var s in sprites)
{
SpriteMetaData meta = new SpriteMetaData();
var split = s.Split(new char[]{'='});
meta.name = split[0].Trim();
split = split[1].Trim().Split(new char[]{' '}, System.StringSplitOptions.RemoveEmptyEntries);
float width = float.Parse(split[2]);
float height = float.Parse(split[3]);
float x = float.Parse(split[0]);
float y = float.Parse(split[1]);
y = texture.height - y - height;
meta.pivot = new Vector2(0.5f, 0.5f);
meta.rect = new Rect(x,y,width,height);
spriteSheet.Add(meta);
}
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = spriteSheet.ToArray();
EditorUtility.SetDirty(importer);
AssetDatabase.ImportAsset(path);
AssetDatabase.Refresh();
EditorGUIUtility.PingObject(AssetDatabase.LoadAssetAtPath(path, typeof(Object)));
}
static List<SpriteMetaData> GetSpriteMetaDatas(string path, string text, int totalHeight)
{
List<SpriteMetaData> sprites = new List<SpriteMetaData>();
var sliceName = "slice";
var arrayTxt = text.Split(',');
var pngIndex = 0;
foreach (var txt in arrayTxt)
{
var arrayPoint = txt.Split(' ');
int x = int.Parse(arrayPoint[arrayPoint.Length - 2]);
int y = int.Parse(arrayPoint[arrayPoint.Length - 1].TrimEnd('.'));
pngIndex++;
var pngName = sliceName + pngIndex.ToString().PadLeft(2, '0') + ".png";
var pngPath = path + "/" + pngName;
TextureImporter importer = AssetImporter.GetAtPath(pngPath) as TextureImporter;
if (importer != null)
{
object[] args = new object[2] { 0, 0 };
MethodInfo mi = typeof(TextureImporter).GetMethod("GetWidthAndHeight", BindingFlags.NonPublic | BindingFlags.Instance);
mi.Invoke(importer, args);
var width = (int)args[0];
var height = (int)args[1];
SpriteMetaData smd = new SpriteMetaData();
smd.rect = new Rect(x, totalHeight - y - height, width, height);
smd.alignment = 0;
smd.name = pngName.Remove(pngName.Length - 4);
smd.pivot = new Vector2(0.5f, 0.5f);
sprites.Add(smd);
AssetDatabase.DeleteAsset(pngPath);
}
}
return sprites;
}
/// <summary>
/// 更新Sprite对应的Meta文件
/// </summary>
/// <param name="importer"></param>
/// <param name="file"></param>
void UpdateSpriteMetaData(TextureImporter importer, string file)
{
if (importer.textureType == TextureImporterType.Advanced)
{
importer.textureType = TextureImporterType.Sprite;
}
importer.maxTextureSize = 4096;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.textureFormat = TextureImporterFormat.RGBA32;
//在路径中找到Plist文件，解析出SpriteData信息
List<SpriteData> sdList = PListFile.Parse(file);
List<SpriteMetaData> metaDataList = new List<SpriteMetaData>();
for (int i = 0; i < sdList.Count; i++)
{
SpriteMetaData smd = new SpriteMetaData();
smd.name = sdList[i].name;
float x = sdList[i].x;
float y = sdList[i].y;
float w = sdList[i].width;
float h = sdList[i].height;
smd.rect = new UnityEngine.Rect(x, y, w, h);
smd.pivot = new UnityEngine.Vector2(0, 0);
smd.alignment = (int)UnityEngine.SpriteAlignment.Center;
metaDataList.Add(smd);
}
//将格式化后的数据送给Engine
importer.spritesheet = metaDataList.ToArray();
}
public static SpriteMetaData[] getSpriteMetadata(SpineAtlas spineAtlas, Vector2 atlasImageSize)
{
SpriteMetaData[] result = new SpriteMetaData[spineAtlas.sprites.Count];
SpineSprite spineSprite;
for (int i = 0; i < result.Length; i++) {
spineSprite = spineAtlas.sprites[i];
result[i] = new SpriteMetaData();
result[i].name = spineSprite.name;
result[i].rect = getRectFromSpineSprite(spineSprite, atlasImageSize);
if (spineSprite.orig != spineSprite.size){
result[i].alignment = (int) SpriteAlignment.Custom;
result[i].pivot = getPivotFromSpineSprite(spineSprite);
}
}
return result;
}
private void ImportSpriteSheetIntoAnimation( Texture2D spriteSheet, int animIdx = -1)
{
string assetPath = AssetDatabase.GetAssetPath(spriteSheet);
if (string.IsNullOrEmpty(assetPath)) return;
TextureImporter spriteSheetImporter = (TextureImporter)TextureImporter.GetAtPath(assetPath);
int characterNb;
int charRowLength;
int charColumnLength;
int charFramesCount = m_target.DirectionsPerAnim * m_target.FramesPerAnim;
int columns = 0, rows = 0;
if (spriteSheetImporter.textureType != TextureImporterType.Sprite
|| spriteSheetImporter.spriteImportMode != SpriteImportMode.Multiple
|| spriteSheetImporter.spritesheet.Length == 0
|| spriteSheetImporter.spritesheet.Length % charFramesCount != 0)
{
Rect[] rects = InternalSpriteUtility.GenerateAutomaticSpriteRectangles(spriteSheet, 4, 0);
if ( rects.Length > 0 && rects.Length % charFramesCount == 0)
{
for (; columns < rects.Length; ++columns)
{
//NOTE: the order of slicing in GenerateAutomaticSpriteRectangles is from bottom to top, not from top to bottom like Sprite Editor Slicing
if (rects[columns].yMin >= rects[0].yMax)
{
rows = rects.Length / columns;
break;
}
}
}
else
{
columns = m_target.FramesPerAnim;
rows = m_target.DirectionsPerAnim;
}
charRowLength = Mathf.Max(1, columns / m_target.FramesPerAnim);
charColumnLength = Mathf.Max(1, rows / m_target.FramesPerAnim);
characterNb = charRowLength * charColumnLength;
int spriteCount = charFramesCount * characterNb;
SpriteMetaData[] aSpriteMetaData = spriteSheetImporter.spritesheet;
if (spriteSheetImporter.spritesheet.Length != spriteCount || spriteSheetImporter.spriteImportMode != SpriteImportMode.Multiple)
{
aSpriteMetaData = new SpriteMetaData[spriteCount];
spriteSheetImporter.textureType = TextureImporterType.Sprite;
spriteSheetImporter.spriteImportMode = SpriteImportMode.Multiple;
spriteSheetImporter.filterMode = FilterMode.Point;
spriteSheetImporter.mipmapEnabled = false;
spriteSheetImporter.textureFormat = TextureImporterFormat.AutomaticTruecolor;
Rect spriteRect = new Rect(0, 0, spriteSheet.width / (m_target.FramesPerAnim * charRowLength), spriteSheet.height / (m_target.DirectionsPerAnim * charColumnLength));
for (int gy = 0, spriteIdx = 0; gy < rows; ++gy)
{
for (int gx = 0; gx < columns; ++gx, ++spriteIdx)
{
spriteRect.position = new Vector2(gx * spriteRect.width, spriteSheet.height - (1 + gy) * spriteRect.height);
SpriteMetaData spriteMetaData = new SpriteMetaData();
//int characterIdx = (gy / m_target.DirectionNb) * charRowLength + (gx / m_target.FramesPerAnim);
//NOTE: the sprites are sorted alphabetically, so spriteIdx should be in the first place after the name and nothing else
spriteMetaData.name = spriteSheet.name + "_" + spriteIdx; // + (characterNb > 1 ? ("_" + characterIdx) : "") + "_" + gy + "_" + gx;
spriteMetaData.rect = spriteRect;
aSpriteMetaData[spriteIdx] = spriteMetaData;
}
}
spriteSheetImporter.spritesheet = aSpriteMetaData;
AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate);
}
}
UpdateAligmentAndPivot(spriteSheet);
List<Sprite> sprites = new List<Sprite>(AssetDatabase.LoadAllAssetsAtPath(assetPath).OfType<Sprite>().ToArray());
//sort them properly using the last number
sprites = sprites.OrderBy(s => int.Parse(s.name.Substring(s.name.LastIndexOf("_") + 1))).ToList();
for (; columns < sprites.Count; ++columns)
{
if (sprites[columns].rect.yMax <= sprites[0].rect.yMin)
{
rows = sprites.Count / columns;
break;
}
}
if (columns * rows != sprites.Count || columns % m_target.FramesPerAnim != 0 || rows % m_target.DirectionsPerAnim != 0)
{
Debug.LogError("Something was wrong with the sprite sheet. Try slicing it again using the Sprite Editor using grid settings or set the Sprite Mode to single and try again.");
return;
}
List<Sprite> sortedSprites = new List<Sprite>();
charRowLength = Mathf.Max(1, columns / m_target.FramesPerAnim);
charColumnLength = Mathf.Max(1, rows / m_target.FramesPerAnim);
for(int charY = 0; charY < charColumnLength; ++charY)
{
for(int charX = 0; charX < charRowLength; ++charX)
{
for(int c = 0; c < m_target.DirectionsPerAnim; ++c)
{
for(int r = 0; r < m_target.FramesPerAnim; ++r)
{
int gx = charX * m_target.FramesPerAnim + r;
int gy = charY * m_target.DirectionsPerAnim + c;
sortedSprites.Add(sprites[gy * columns + gx]);
}
}
}
}
characterNb = sortedSprites.Count / charFramesCount;
if (animIdx >= 0)
{
ImportSpriteSheetIntoAnimation(spriteSheet, sortedSprites.Take(charFramesCount).ToArray(), animIdx, spriteSheet.name);
}
else
{
for (int characterIdx = 0; characterIdx < characterNb; ++characterIdx)
{
Sprite[] characterSprites = sortedSprites.Skip(characterIdx * charFramesCount).Take(charFramesCount).ToArray();
string charName = spriteSheet.name + (characterNb > 1? ("_" + characterIdx) : "");
ImportSpriteSheetIntoAnimation(spriteSheet, characterSprites, m_target.GetAnimList().FindIndex(x => x.name == charName), charName);
}
}
}
private void splitUpSmartMaterial()
{
if (tile.m_smartMaterialSource != null)
{
//get provided material
var assetPath = AssetDatabase.GetAssetPath(tile.m_smartMaterialSource);
TextureImporter ti = AssetImporter.GetAtPath(assetPath) as TextureImporter;
ti.isReadable = true;
var cellWidth = tile.m_smartMaterialSource.texture.width / 12.0f;
var cellHeight = tile.m_smartMaterialSource.texture.height / 6.0f;
var spriteWidth = cellWidth * 2;
var spriteHeight = cellHeight * 2;
//build new ones
List <SpriteMetaData> newSprites = new List <SpriteMetaData>();
foreach (var smartRule in allSmartRules)
{
var thisSprite = new SpriteMetaData();
thisSprite.alignment = (int)SpriteAlignment.Center;
thisSprite.name = smartRule.name;
var x = smartRule.bottomLeftIndex % 12 - 1;
var y = smartRule.bottomLeftIndex / 12;
thisSprite.rect = new Rect(
x * cellWidth,
y * cellHeight,
spriteWidth,
spriteHeight
);
newSprites.Add(thisSprite);
}
//update new sprite slice
ti.spriteImportMode = SpriteImportMode.Multiple;
ti.spritesheet = newSprites.ToArray();
EditorUtility.SetDirty(ti);
ti.SaveAndReimport();
//fetch new sprites
var generatedSprites = AssetDatabase.LoadAllAssetsAtPath(assetPath)
.OfType <Sprite>().ToList();
//build rule tiles
tile.m_TilingRules = new List <RuleTile.TilingRule>();
foreach (var rule in allSmartRules)
{
var newRule = new RuleTile.TilingRule();
rule.neighborRules.CopyTo(newRule.m_Neighbors, 0);
newRule.m_Sprites = new[] { generatedSprites.Find(x => x.name == rule.name) };
tile.m_TilingRules.Add(newRule);
}
//need to do this or you can't see the tiles in the pallette
tile.m_DefaultSprite = generatedSprites.Find(x => x.name == "default");
//editor update
MakeReorderableList();
SaveTile();
}
}
void OnPreprocessTexture()
{
if(Path.GetExtension(assetPath) == ".png")
{
// If the asset is a png file, look for a matching xml file
string atlasPath = Path.ChangeExtension(assetPath, ".xml");
if(File.Exists(atlasPath))
{
TextureImporter importer = assetImporter as TextureImporter;
// if we're not in sprite mode, nothing to do here
if(importer.textureType != TextureImporterType.Sprite)
return;
XDocument xmlDocument = XDocument.Load(atlasPath);
// attempt to verify that we're really looking at a TexturePacker atlas
if(xmlDocument.Root.Name.LocalName != "TextureAtlas")
return;
int imageHeight = int.Parse(xmlDocument.Root.Attribute("height").Value, CultureInfo.InvariantCulture);
var sprites = xmlDocument.Descendants("sprite");
importer.spriteImportMode = SpriteImportMode.Multiple;
List<SpriteMetaData> metaData = new List<SpriteMetaData>();
foreach(var sprite in sprites)
{
string n = sprite.Attribute("n").Value;
int x = int.Parse(sprite.Attribute("x").Value, CultureInfo.InvariantCulture);
int y = int.Parse(sprite.Attribute("y").Value, CultureInfo.InvariantCulture);
int w = int.Parse(sprite.Attribute("w").Value, CultureInfo.InvariantCulture);
int h = int.Parse(sprite.Attribute("h").Value, CultureInfo.InvariantCulture);
int oX = (sprite.Attribute("oX") == null) ? 0 : int.Parse(sprite.Attribute("oX").Value, CultureInfo.InvariantCulture);
int oY = (sprite.Attribute("oY") == null) ? 0 : int.Parse(sprite.Attribute("oY").Value, CultureInfo.InvariantCulture);
int oW = (sprite.Attribute("oW") == null) ? w : int.Parse(sprite.Attribute("oW").Value, CultureInfo.InvariantCulture);
int oH = (sprite.Attribute("oH") == null) ? h : int.Parse(sprite.Attribute("oH").Value, CultureInfo.InvariantCulture);
bool r = sprite.Attribute("r") != null;
bool trim = (sprite.Attribute("oX") != null) ||
(sprite.Attribute("oY") != null) ||
(sprite.Attribute("oW") != null) ||
(sprite.Attribute("oH") != null);
if(r)
Debug.LogWarning("Rotated TexturePacker Sprites are not currently supported. File: " + assetPath + " Sprite: " + n);
SpriteMetaData spriteMetaData = new SpriteMetaData();
spriteMetaData = new SpriteMetaData();
// According to Unity docs, Center = 0, Custom = 9
spriteMetaData.alignment = trim ? 9 : 0;
spriteMetaData.name = n;
spriteMetaData.pivot = new Vector2(((oW / 2.0f) - (oX)) / (float)w, 1.0f - ((oH / 2.0f) - (oY)) / (float)h);
spriteMetaData.rect = new Rect(x, imageHeight - y - h, w, h);
metaData.Add(spriteMetaData);
}
if(importer.spritesheet == null || importer.spritesheet.Length == 0)
{
importer.spritesheet = metaData.ToArray();
}
else
{
// merge importer.spritesheet and metaData
// We don't want to change the indices of existing sprites
List<SpriteMetaData> spriteData = new List<SpriteMetaData>();
int deletedCount = 0;
SpriteMetaData deletedData = new SpriteMetaData();
deletedData.name = "DELETED_SPRITE";
deletedData.rect = new Rect(0, 0, 1, 1);
// Add all of the data that matches the existing data
foreach(var sprite in importer.spritesheet)
{
int index = metaData.FindIndex(p => p.name == sprite.name);
if(index != -1)
{
spriteData.Add(metaData[index]);
SpriteMetaData temp = metaData[index];
temp.name = "IGNORE_USED_SPRITE_DATA";
metaData[index] = temp;
}
else
{
spriteData.Add(deletedData);
deletedCount++;
}
}
// Add all of the new data
foreach(var sprite in metaData)
{
if(sprite.name == "IGNORE_USED_SPRITE_DATA")
continue;
if(deletedCount > 0)
{
deletedCount--;
int index = spriteData.FindIndex(p => p.name == "DELETED_SPRITE");
spriteData[index] = sprite;
}
else
{
spriteData.Add(sprite);
}
}
// Rename any remaning deleted entries to DELETED_SPRITE_#
if(deletedCount > 0)
{
for(int i=0; i<deletedCount; i++)
{
int index = spriteData.FindIndex(p => p.name == "DELETED_SPRITE");
SpriteMetaData temp = spriteData[index];
temp.name = "DELETED_SPRITE_" + i;
spriteData[index] = temp;
}
}
// Calling ClearPlatformTextureSettings to stop the texture importer
// from holding on the a cached version of importer.spritesheet.
// This is a workaround, and might be the wrong thing to do.
importer.ClearPlatformTextureSettings("Standalone");
importer.spritesheet = spriteData.ToArray();
}
}
}
}
public void CreateTexture(SpriteStudioCellMap cellMap)
{
string destFileName = texturesDirectory + "/" + cellMap.imagePath;
File.Copy (sourceDirectory + "/" + cellMap.imagePath, destFileName, true);
AssetDatabase.ImportAsset (destFileName);
TextureImporter importer = TextureImporter.GetAtPath (destFileName) as TextureImporter;
if (importer != null) {
importer.textureType = TextureImporterType.Advanced;
importer.maxTextureSize = 4096;
importer.textureFormat = TextureImporterFormat.AutomaticTruecolor;
importer.isReadable = false;
importer.filterMode = FilterMode.Bilinear;
importer.npotScale = TextureImporterNPOTScale.None;
importer.wrapMode = TextureWrapMode.Clamp;
importer.mipmapEnabled = false;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritePixelsPerUnit = 1;
List<SpriteMetaData> spritesheet = new List<SpriteMetaData> ();
Vector2 pixelSize = GetVector2 (cellMap.pixelSize);
foreach (SpriteStudioCellMapCell cell in cellMap.cells) {
SpriteMetaData metaData = new SpriteMetaData ();
metaData.alignment = (int)SpriteAlignment.Custom;
metaData.name = cell.name;
Vector2 size = GetVector2 (cell.size);
Vector2 pos = GetVector2 (cell.pos);
Vector2 pivot = GetVector2 (cell.pivot);
metaData.rect = new Rect (pos.x, pixelSize.y - pos.y - size.y, size.x, size.y);
metaData.pivot = new Vector2 (pivot.x + 0.5f, pivot.y + 0.5f);
spritesheet.Add (metaData);
}
importer.spritesheet = spritesheet.ToArray ();
AssetDatabase.ImportAsset (destFileName);
AssetDatabase.SaveAssets ();
AssetDatabase.Refresh ();
}
}
public SpriteMetaData BuildBasicSprite(float scale, Color32 defaultColor)
{
SpriteMetaData smd = new SpriteMetaData();
Rect rect;
if(!rotated){
rect = this.frame;
}
else
{
rect = new Rect(frame.x,frame.y,frame.height,frame.width);
}
/* Look if frame is outside from texture */
if( (frame.x + frame.width) > atlasSize.x || (frame.y + frame.height) > atlasSize.y ||
(frame.x < 0 || frame.y < 0))
{
Debug.Log(this.name + " is outside from texture! Sprite is ignored!");
smd.name = "IGNORE_SPRITE";
return smd;
}
//calculate Height
/* Example: Texture: 1000 Width x 500 height
* Sprite.Recht(0,0,100,100) --> Sprite is on the bottom left
*/
rect.y = atlasSize.y - frame.y - rect.height;
smd.rect = rect;
smd.alignment = 1;
smd.name = name;
smd.pivot = this.frame.center;
return smd;
}
static void updateSpriteMetaData(TextureImporter importer, string pathToData)
{
importer.textureType = TextureImporterType.Sprite;
importer.maxTextureSize = 4096;
importer.spriteImportMode = SpriteImportMode.Multiple;
List<SpriteMetaData> metaData = new List<SpriteMetaData> ();
foreach (string row in File.ReadAllLines(pathToData)) {
if (string.IsNullOrEmpty (row) || row.StartsWith ("#"))
continue; // comment lines start with #
string [] cols = row.Split (';');
if (cols.Length != 7)
return; // format error
SpriteMetaData smd = new SpriteMetaData ();
smd.name = cols [0];
float x = float.Parse (cols [1]);
float y = float.Parse (cols [2]);
float w = float.Parse (cols [3]);
float h = float.Parse (cols [4]);
float px = float.Parse (cols [5]);
float py = float.Parse (cols [6]);
smd.rect = new UnityEngine.Rect (x, y, w, h);
smd.pivot = new UnityEngine.Vector2 (px, py);
if (px == 0 && py == 0)
smd.alignment = (int)UnityEngine.SpriteAlignment.BottomLeft;
else if (px == 0.5 && py == 0)
smd.alignment = (int)UnityEngine.SpriteAlignment.BottomCenter;
else if (px == 1 && py == 0)
smd.alignment = (int)UnityEngine.SpriteAlignment.BottomRight;
else if (px == 0 && py == 0.5)
smd.alignment = (int)UnityEngine.SpriteAlignment.LeftCenter;
else if (px == 0.5 && py == 0.5)
smd.alignment = (int)UnityEngine.SpriteAlignment.Center;
else if (px == 1 && py == 0.5)
smd.alignment = (int)UnityEngine.SpriteAlignment.RightCenter;
else if (px == 0 && py == 1)
smd.alignment = (int)UnityEngine.SpriteAlignment.TopLeft;
else if (px == 0.5 && py == 1)
smd.alignment = (int)UnityEngine.SpriteAlignment.TopCenter;
else if (px == 1 && py == 1)
smd.alignment = (int)UnityEngine.SpriteAlignment.TopRight;
else
smd.alignment = (int)UnityEngine.SpriteAlignment.Custom;
metaData.Add (smd);
}
if (metaData.Count == 0)
return;
if (importer.spritesheet == null || importer.spritesheet.Length == 0) {
// replace a blank spritesheet
importer.spritesheet = metaData.ToArray ();
} else {
// merge into an existing spritesheet
Dictionary<string,SpriteMetaData> importedSprites = new Dictionary<string, SpriteMetaData> ();
foreach (var smd in metaData) {
importedSprites [smd.name] = smd;
}
// track what has been merged
HashSet<string> merged = new HashSet<string> ();
List<SpriteMetaData> existingSprites = new List<SpriteMetaData> (importer.spritesheet);
// default struct to replace deleted sprites
SpriteMetaData deletedSMD = new SpriteMetaData ();
deletedSMD.rect = new UnityEngine.Rect (0, 0, 1, 1);
// maintain indices
for (int i = 0; i < existingSprites.Count; ++i) {
if (importedSprites.ContainsKey (existingSprites [i].name)) {
existingSprites [i] = importedSprites [existingSprites [i].name];
merged.Add (existingSprites [i].name);
} else if (existingSprites [i].name.StartsWith ("DELETED_")) {
string origName = existingSprites [i].name.Remove (0, 8);
if (importedSprites.ContainsKey (origName)) {
existingSprites [i] = importedSprites [origName];
merged.Add (origName);
}
} else {
deletedSMD.name = "DELETED_" + existingSprites [i].name;
existingSprites [i] = deletedSMD;
}
}
// anything not merged is appended
foreach (var smd in metaData) {
if (!merged.Contains (smd.name)) {
existingSprites.Add (smd);
}
}
importer.spritesheet = existingSprites.ToArray ();
}
}
/// <summary>
/// Gets the spritesheet meta data for the specified name.
/// </summary>
/// <returns>The spritesheet meta.</returns>
/// <param name="collection">Collection.</param>
/// <param name="name">Name.</param>
private static SpriteMetaData GetSpritesheetMeta(SpriteMetaData[] collection, string name)
{
for (int i = 0; i < collection.Length; i++)
{
if (collection[i].name == name)
return collection[i];
}
return new SpriteMetaData();
}
/// <summary>
/// Imports and configures atlas texture.
/// </summary>
/// <returns><c>true</c>, if import and configure atlas texture was successful, <c>false</c> otherwise.</returns>
/// <param name="targetTexture">Target texture.</param>
/// <param name="sourceTexture">Source texture.</param>
/// <param name="uvs">Uvs.</param>
/// <param name="names">Names.</param>
/// <param name="defaultPivot">Default pivot.</param>
/// <param name="defaultCustomPivot">Default custom pivot.</param>
public static bool ImportAndConfigureAtlasTexture(Texture2D targetTexture, Texture2D sourceTexture, Rect[] uvs, SPSpriteImportData[] spritesImportData)
{
// Get the asset path
string assetPath = SPTools.GetAssetPath(targetTexture);
if (string.IsNullOrEmpty(assetPath))
{
Debug.LogError("Sprite Packer failed to Import and Configure the atlas texture, reason: Could not resolve asset path.");
return false;
}
// Clear the read-only flag in texture file attributes
if (!SPTools.RemoveReadOnlyFlag(assetPath))
{
Debug.LogError("Sprite Packer failed to Import and Configure the atlas texture, reason: Could not remove the readonly flag from the asset.");
return false;
}
// Write the source texture data to the asset
byte[] bytes = sourceTexture.EncodeToPNG();
System.IO.File.WriteAllBytes(assetPath, bytes);
bytes = null;
// Get the asset texture importer
TextureImporter texImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
if (texImporter == null)
{
Debug.LogError("Sprite Packer failed to Import and Configure the atlas texture, reason: Could not get the texture importer for the asset.");
return false;
}
// Get the asset texture importer settings
TextureImporterSettings texImporterSettings = new TextureImporterSettings();
// Apply sprite type
texImporter.textureType = TextureImporterType.Sprite;
texImporter.spriteImportMode = SpriteImportMode.Multiple;
// Configure the spritesheet meta data
SpriteMetaData[] spritesheetMeta = new SpriteMetaData[uvs.Length];
for (int i = 0; i < uvs.Length; i++)
{
if (SPTools.HasSpritesheetMeta(texImporter.spritesheet, spritesImportData[i].name))
{
SpriteMetaData currentMeta = SPTools.GetSpritesheetMeta(texImporter.spritesheet, spritesImportData[i].name);
Rect currentRect = uvs[i];
currentRect.x *= sourceTexture.width;
currentRect.width *= sourceTexture.width;
currentRect.y *= sourceTexture.height;
currentRect.height *= sourceTexture.height;
currentMeta.rect = currentRect;
spritesheetMeta[i] = currentMeta;
}
else
{
SpriteMetaData currentMeta = new SpriteMetaData();
Rect currentRect = uvs[i];
currentRect.x *= sourceTexture.width;
currentRect.width *= sourceTexture.width;
currentRect.y *= sourceTexture.height;
currentRect.height *= sourceTexture.height;
currentMeta.rect = currentRect;
currentMeta.name = spritesImportData[i].name;
currentMeta.alignment = (int)spritesImportData[i].alignment;
currentMeta.pivot = spritesImportData[i].pivot;
currentMeta.border = spritesImportData[i].border;
spritesheetMeta[i] = currentMeta;
}
}
texImporter.spritesheet = spritesheetMeta;
// Read the texture importer settings
texImporter.ReadTextureSettings(texImporterSettings);
// Disable Read/Write
texImporterSettings.readable = false;
// Re-set the texture importer settings
texImporter.SetTextureSettings(texImporterSettings);
// Save and Reimport the asset
AssetDatabase.SaveAssets();
SPTools.DoAssetReimport(assetPath, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
// Return success
return true;
}
void OnGUI()
{
int i, j;
ResetManager();//Remakes game objects require to operate.
e = Event.current; //Gets current event (mouse move, repaint, keyboard press, etc)
if(renameId != -1 && (e.keyCode == KeyCode.Return || e.keyCode == KeyCode.KeypadEnter))
{
renameId = -1;
}
if(cmTileSets == null) //Check to make certain there is actually a tileset in the resources/tileset folder.
{
EditorGUILayout.LabelField("No tilesets found. Retrying.");
OnEnable();
}else{
string[] names = new string[cmTileSets.Length]; //Gets the name of the tilesets into a useable list
for(i = 0; i < cmTileSets.Length; i++)
{
try
{
names[i] = cmTileSets[i].name;
}
catch(System.Exception ex)
{
Debug.Log ("There was an error getting the names of the files. We'll try to reload the tilesets. If this continues to show, please close the script and try remimporting and check your images.");
Debug.Log ("Full system error: " + ex.Message);
OnEnable();
}
}
//Mode variable to swith between major features.
string[] mode = {"Tile Painter", "Help Video"};//, "Pad Tileset"};// Pad tileset not finished yet, removed to allow for earlier release. You can try it out if you want, but is has issues with larger images and places tiles in the wrong order.
curMode = GUILayout.Toolbar(curMode, mode);
if(curMode == 0)
{
//If in standard paint mode, display the proper gui elements for the user to use.
EditorGUILayout.BeginHorizontal();
int tmpInt = EditorGUILayout.Popup("Tileset", cmSelectedTileSet, names);
if(GUILayout.Button("Reload"))
{
OnEnable();
}
EditorGUILayout.EndHorizontal();
string[] tools = {"Paint", "Erase", "Box Paint"};
//curTool = EditorGUILayout.Popup("Tool", curTool, tools);
EditorGUILayout.BeginHorizontal(GUILayout.Width(position.width));
//Causes an error on editor load if the window is visible.
//This seems to be a problem with how the gui is drawn the first
//loop of the script. It only happens the once, and I can't figure
//out why. I've been trying for literally weeks and still can't
//find an answer. This is the only known bug, but it doesn't
//stop the functionality of the script in any way, and only serves
//as an annoying message on unity load or this script being
//recompiled. Sorry for this bug. I am looking for a way to remove
//this error, but I really am stummped as to why it's happening
//and I just can not find an answer online.
EditorGUILayout.LabelField("Tool",GUILayout.Width(50));
GUILayout.FlexibleSpace();
curTool = GUILayout.Toolbar(curTool, tools);
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Paint With Collider",GUILayout.Width(150));
makeCollider = EditorGUILayout.Toggle(makeCollider);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Highlight Current Layer",GUILayout.Width(150));
highlightLayer = EditorGUILayout.Toggle(highlightLayer, GUILayout.Width(25));
highlightColor = EditorGUILayout.ColorField(highlightColor);
EditorGUILayout.EndHorizontal();
if(tmpInt != cmSelectedTileSet) //Forces selection of first tileset if none are selected.
{
LoadTileset(tmpInt);
}
cmSelectedTileSet = tmpInt; //sets the selected tileset value
i = 0;
int columnCount = Mathf.RoundToInt((position.width)/38)-2; //figures out how many columns are required for the tileset
j = 0;
int current = 0;
tileScrollPosition = EditorGUILayout.BeginScrollView(tileScrollPosition,false,true,GUILayout.Width(position.width));
//creates scrollbox area for tiles inside of the current tileset.
GUILayout.BeginHorizontal(); //Initializing first row
for(int q = 0; q < cmSprites.Length; q++)
{
Sprite child = cmSprites[q];
//for every tile inside the currently selected tileset, add a tile
try
{
if(child.texture.name == names[cmSelectedTileSet] && child.name != names[cmSelectedTileSet])
{
//if it's the tiles inside the image, not the entire image
Rect newRect = new Rect(
child.rect.x/child.texture.width,
child.rect.y/child.texture.height,
child.rect.width/child.texture.width,
child.rect.height/child.texture.height
);//gets the x and y position in pixels of where the image is. Used later for display.
if(GUILayout.Button("", GUILayout.Width(34), GUILayout.Height(34)))
{
//draw a clickable button
if (cmSelectedTile != null && !e.control)
{
//empty the selected tile list if control isn't held. Allows multiselect of tiles.
cmSelectedTile.Clear();
cmCurSprite.Clear();
}
cmSelectedTile.Add(current); //Adds clicked on tile to list of selected tiles.
cmCurSprite.Add(cmCurSprites[current]);
}
GUI.DrawTextureWithTexCoords(new Rect(5+(j*38), 4+(i*37), 32, 32), child.texture, newRect ,true); //draws tile base on pixels gotten at the beginning of the loop
if(cmSelectedTile != null && cmSelectedTile.Contains(current))
{
//if the current tile is inside of the list of selected tiles, draw a highlight indicator over the button.
if(cmSelectedColor == null)
{
cmSelectedColor = new Texture2D(1,1);
cmSelectedColor.alphaIsTransparency = true;
cmSelectedColor.filterMode = FilterMode.Point;
cmSelectedColor.SetPixel(0,0, new Color(.5f,.5f,1f,.5f));
cmSelectedColor.Apply();
}
GUI.DrawTexture(new Rect(5+(j*38), 4+(i*37), 32, 32), cmSelectedColor,ScaleMode.ScaleToFit,true);
}
if(j < columnCount)
{
j++;
}else{
// if we have enough columns to fill the scroll area, reset the column count and start a new line of buttons
j = 0;
i++;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
current++;
}
}catch(System.Exception ex){
if(ex.Message.StartsWith("IndexOutOfRangeException"))
{
Debug.Log("Tileset index was out of bounds, reloading and trying again.");
OnEnable();
return;
}
}
}
GUILayout.EndHorizontal(); //finish the drawing of tiles
EditorGUILayout.EndScrollView();
//Display all of the layers. May be put into a foldout for if there are too many layers. Haven't decided yet.
GUILayout.Label("Layers:");
if(GUILayout.Button("Add Layer"))
{
AddLayer();
}
String[] minusPlus = {"-", "+", "x", "r"};
ResetLayers();
layers = ResortLayers(layers);//Sort the layers based on their sorting order instead of name
int destroyFlag = -1;
for(i = 0; i < layers.Count; i++)
{
//iterates through layers and displays gui for options.
EditorGUILayout.BeginHorizontal();
RectOffset tmpPadding = GUI.skin.button.padding;
GUI.skin.button.padding = new RectOffset(3,3,3,3);
if(layers[i].gameObject.activeSelf)
{
if(GUILayout.Button(texVisible,GUILayout.Width(15), GUILayout.Height(15)))
{
layers[i].gameObject.SetActive(false);
}
}else{
if(GUILayout.Button(texHidden,GUILayout.Width(15), GUILayout.Height(15)))
{
layers[i].gameObject.SetActive(true);
}
}
GUI.skin.button.padding = tmpPadding;
if(i == selectedLayer)
{
//if selected layer, draw checked checkbox to show it's selected
if(i != renameId)
{
EditorGUILayout.ToggleLeft(layers[i].name + " - " + layers[i].GetComponent<SpriteRenderer>().sortingOrder,true);
}else{
layers[i].name = EditorGUILayout.TextField(layers[i].name);
}
}else{
//if not the selected layer, and is clicked, set it as the selected layer
if(i != renameId)
{
if(EditorGUILayout.ToggleLeft(layers[i].name + " - " + layers[i].GetComponent<SpriteRenderer>().sortingOrder,false))
{
selectedLayer = i;
}
}else{
layers[i].name = EditorGUILayout.TextField(layers[i].name);
}
}
//sets pressed value to -1 if nothing is pressed.
int pressed = GUILayout.Toolbar(-1, minusPlus);
switch(pressed)
{
case 0:
if(i > 0)
{
//moves layer and all tiles in it to move away from the camera, and moves the layer above it toward the camera.
layers[i-1].GetComponent<SpriteRenderer>().sortingOrder += 1;
int upLayer = layers[i-1].GetComponent<SpriteRenderer>().sortingOrder;
foreach(SpriteRenderer sr in layers[i-1].GetComponentsInChildren<SpriteRenderer>())
{
sr.sortingOrder = upLayer;
}
//layers[i].GetComponent<SpriteRenderer>().sortingOrder -= 1;
int downLayer = layers[i].GetComponent<SpriteRenderer>().sortingOrder -= 1;
foreach(SpriteRenderer sr in layers[i].GetComponentsInChildren<SpriteRenderer>())
{
sr.sortingOrder = downLayer;
}
selectedLayer = i-1;
}
layers = ResortLayers(layers);
break;
case 1:
if(i < layers.Count-1)
{
//moves layer and all tiles in it to move toward the camera, and moves the layer above it away from the camera.
layers[i+1].GetComponent<SpriteRenderer>().sortingOrder -= 1;
int upLayer = layers[i+1].GetComponent<SpriteRenderer>().sortingOrder;
foreach(SpriteRenderer sr in layers[i+1].GetComponentsInChildren<SpriteRenderer>())
{
sr.sortingOrder = upLayer;
}
//layers[i].GetComponent<SpriteRenderer>().sortingOrder += 1;
int downLayer = layers[i].GetComponent<SpriteRenderer>().sortingOrder += 1;
foreach(SpriteRenderer sr in layers[i].GetComponentsInChildren<SpriteRenderer>())
{
sr.sortingOrder = downLayer;
}
selectedLayer = i+1;
}
layers = ResortLayers(layers);
break;
case 2:
//deletes the layer game object, which also deletes all the children
destroyFlag = i;
break;
case 3:
if(renameId == -1)
{
renameId = i;
}else{
renameId = -1;
}
break;
default:
//do nothing if a button wasn't pressed (required or I get errors T_T)
break;
}
EditorGUILayout.EndHorizontal(); //end the layer gui
}
if(selectedLayer <= layers.Count-1 && selectedLayer > 0)
{
//double check to make certain a layer of some sort is selected and is in valid range
curLayer = layers[selectedLayer].gameObject;
}
if(selectedLayer <= layers.Count-1 && layers[selectedLayer] != null)
{
ResetHighlight(layers[selectedLayer].gameObject, highlightLayer);
curLayer = layers[selectedLayer].gameObject;
}else{
if(layers.Count-1 > 0 && layers[selectedLayer] != null)
{
curLayer = layers[selectedLayer].gameObject;
}else{
}
}
if(destroyFlag != -1)
{
DestroyImmediate(layers[destroyFlag].gameObject);
return; //Breaks method to not have errors down the line. Forces reload of tilesets to keep inside the bounds of the array.
}
destroyFlag = -1;
}else if(curMode == 1){
curMode = 0;
Application.OpenURL("https://www.youtube.com/watch?v=mxy9HdNM-is");
return;
}else if(curMode == 2){
int tmpInt = EditorGUILayout.Popup("Tileset", cmSelectedTileSet, names);
if(tmpInt != cmSelectedTileSet) //Forces selection of first tileset if none are selected.
{
LoadTileset(tmpInt);
}
cmSelectedTileSet = tmpInt; //sets the selected tileset value
GUILayout.BeginHorizontal();
GUILayout.Label("Grid Size X", GUILayout.Width(200));
gridSizeX = EditorGUILayout.IntField(gridSizeX);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Grid Size Y", GUILayout.Width(200));
gridSizeY = EditorGUILayout.IntField(gridSizeY);
GUILayout.EndHorizontal();
/*GUILayout.BeginHorizontal();
GUILayout.Label("Pad Size X", GUILayout.Width(200));
padSizeX = EditorGUILayout.IntField(padSizeX);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Pad Size Y", GUILayout.Width(200));
padSizeY = EditorGUILayout.IntField(padSizeY);
GUILayout.EndHorizontal();*/
if(GUILayout.Button("Generate New Texture"))
{
List<Rect> listOfNewSlices = new List<Rect>();
Texture2D curTileSet = Resources.Load<Texture2D>("Tilesets/" + cmTileSets[cmSelectedTileSet].name);//cmTileSets[cmSelectedTileSet];
int newWidth = (int)(curTileSet.width+(padSizeX*2*(curTileSet.width/gridSizeX)));
int newHeight = (int)(curTileSet.height+(((curTileSet.height/gridSizeY))*(padSizeY*2)));
Texture2D newTileSet = new Texture2D(newWidth,newHeight);
Debug.Log("Generated new tile image with a size of " + newTileSet.width + ", " + newTileSet.height);
// Debug.Log("Tilecount: " + (int)(curTileSet.width/gridSizeX) + ", " + (int)(curTileSet.height/gridSizeY));
for(j = 0; j < (int)(curTileSet.width/gridSizeX); j++)
{
for(i = 0 ; i < (int)(curTileSet.height/gridSizeY); i++)
{
//Copies old image tiles to new image with padding.
try{
newTileSet.SetPixels(
((j*gridSizeX)+(j*padSizeX*2))+padSizeX,
((i*gridSizeY)+(i*padSizeY*2))+padSizeY,
gridSizeX,
gridSizeY,
curTileSet.GetPixels(
j*gridSizeX,
i*gridSizeY,
gridSizeX,
gridSizeY));
Debug.Log(i*32);
//LeftSide
/*newTileSet.SetPixels(
(j*gridSizeX)+(j*padSizeX*2)+padSizeX-1,
(i*gridSizeY)+(i*padSizeY*2),
1,
gridSizeY,
curTileSet.GetPixels(
j*gridSizeX,
i*gridSizeY,
1,
gridSizeY));
//RightSide
newTileSet.SetPixels(
(j*gridSizeX)+(j*padSizeX*2)+padSizeX + gridSizeX,
(i*gridSizeY)+(i*padSizeY*2),
1,
gridSizeY,
curTileSet.GetPixels(
(j*gridSizeX)+gridSizeX-1,
i*gridSizeY,
1,
gridSizeY));
//BottomSide
newTileSet.SetPixels(
(j*gridSizeX)+(j*padSizeX*2)+padSizeX,
(i*gridSizeY)+(i*padSizeY*2)-1,
gridSizeX,
1,
curTileSet.GetPixels(
j*gridSizeX,
i*gridSizeY,
gridSizeX,
1));
//TopSide
newTileSet.SetPixels(
(j*gridSizeX)+(j*padSizeX*2)+padSizeX,
(i*gridSizeY)+(i*padSizeY*2)+gridSizeY,
gridSizeX,
1,
curTileSet.GetPixels(
(j*gridSizeX),
(i*gridSizeY)+gridSizeY-1,
gridSizeX,
1));*/
listOfNewSlices.Add(new Rect(
((i*gridSizeY)+(i*padSizeY*2))+padSizeY,
((j*gridSizeX)+(j*padSizeX*2))+padSizeX,
gridSizeX,
gridSizeY));
//Debug.Log("Drawing tile " + i + ", " + j + " at " + ((i*padSizeX)+(i*gridSizeX)) + ", " + ((j*padSizeY)+(j*gridSizeY)) + " from " + i*gridSizeX + ", " + j*gridSizeY);
}catch(System.Exception ex)
{
Debug.Log("ERROR: " + ex.Message);
if(0==0)
{
}
}
}
}
newTileSet.Apply();
//listOfNewSlices.Add(new Rect(0,newTileSet.height-gridSizeX,100,100));
Debug.Log("Image generation completed, generating slices.");
/*FileStream fs = new FileStream(Application.dataPath + "/Resources/Tilesets/" + curTileSet.name + "_padded.png", FileMode.Append);
BinaryWriter bw = new BinaryWriter(fs);
bw.Write(newTileSet.EncodeToPNG());
bw.Close();
fs.Close();*/
//AssetDatabase.CreateAsset(newTileSet.EncodeToPNG(), "Assets/Resources/Tilesets/" + curTileSet.name + "_padded.png");
bool isWriting = true;
while(isWriting)
{
File.WriteAllBytes(Application.dataPath + "/Resources/Tilesets/" + curTileSet.name + "_padded.png", newTileSet.EncodeToPNG());
isWriting = false;
}
AssetDatabase.Refresh();
TextureImporter ti = new TextureImporter();
ti = (TextureImporter)AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(Resources.Load<Texture>("Tilesets/" + curTileSet.name + "_padded")));
TextureImporterType type = new TextureImporterType();
type = TextureImporterType.Sprite;
ti.textureType = type;
ti.spritePixelsPerUnit = gridSizeX;
ti.spriteImportMode = SpriteImportMode.Multiple;
ti.filterMode = FilterMode.Point;
List<SpriteMetaData> spriteData = new List<SpriteMetaData>();//[listOfNewSlices.Count+1];
//listOfNewSlices.Reverse();
for(i = 0; i < listOfNewSlices.Count; i++)
{
float alpha = 0;
foreach(Color pixel in newTileSet.GetPixels((int)listOfNewSlices[i].x, (int)listOfNewSlices[i].y, (int)listOfNewSlices[i].width, (int)listOfNewSlices[i].height))
{
alpha += pixel.a;
}
if(alpha > 0)
{
listOfNewSlices[i] = new Rect(listOfNewSlices[i].x, listOfNewSlices[i].y, listOfNewSlices[i].width, listOfNewSlices[i].height);
SpriteMetaData tmpSpriteData = new SpriteMetaData();
tmpSpriteData.rect = listOfNewSlices[i];
tmpSpriteData.name = curTileSet.name + "_padded_" + i;// ti.spritesheet.GetLength(0);
tmpSpriteData.alignment = 0;
tmpSpriteData.pivot = new Vector2(gridSizeX/2,gridSizeY/2);
spriteData.Add(tmpSpriteData);
}else{
listOfNewSlices.RemoveAt(i);
//spriteData.RemoveAt(i);
i--;
}
}
ti.spritesheet = spriteData.ToArray();
Debug.Log("Finished generating new padded tileset. Pausing thread to update file.");
System.Threading.Thread.Sleep(4000);//Added to allow for saving and reimporting image in unity. Required to run without error.
OnEnable();
}
if(GUILayout.Button("Regenerate to Original File"))
{
}
}
}
}
void PackTextures(string outPath, string name, Texture2D[] texs, bool removeEmpty)
{
if (null == texs || 0 == texs.Length)
return;
if (! Directory.Exists(outPath))
Directory.CreateDirectory(outPath);
Rect[] solidRect = null;
Texture2D[] newTexs = removeEmpty ? CreateSprites(texs, out solidRect).ToArray() : texs;
if (!removeEmpty)
{
solidRect = new Rect[newTexs.Length];
for (int i = 0; i < solidRect.Length; ++i)
solidRect[i] = Rect.MinMaxRect(0, 0, newTexs[i].width, newTexs[i].height);
}
// 生成新的texture
Texture2D atlas = new Texture2D(TEXTURE_SIZE, TEXTURE_SIZE, TextureFormat.ARGB32, false);
Rect[] rects = atlas.PackTextures(newTexs, SPRITE_PADDING, TEXTURE_SIZE);
if (null == rects)
// 打包失败
return;
int width = atlas.width;
int height = atlas.height;
// 生成spriteMetaData
List<SpriteMetaData> lsMeta = new List<SpriteMetaData>();
for (int i = 0; i < rects.Length; i++)
{
SpriteMetaData data = new SpriteMetaData();
data.alignment = 0; // center
data.border = Vector4.zero;
data.name = newTexs[i].name;
// data.pivot = Vector2.zero;
float x = (texs[i].width / 2 - solidRect[i].xMin);
float y = (texs[i].height / 2 - solidRect[i].yMax);
data.alignment = (int)SpriteAlignment.Custom;
data.pivot = new Vector2(Mathf.Abs(x) / newTexs[i].width, Mathf.Abs(y) / newTexs[i].height);
data.rect = new Rect(rects[i].x * width,
rects[i].y * height,
rects[i].width * width,
rects[i].height * height);
lsMeta.Add(data);
}
// 写入文件
byte[] bytes = atlas.EncodeToPNG();
if (null == bytes)
return;
string texName = outPath + "/" + name + "Atlas.png";
File.WriteAllBytes(texName, bytes);
// 修改spritesheet
AssetDatabase.Refresh();
TextureImporter ti = (TextureImporter) TextureImporter.GetAtPath(texName);
ti.maxTextureSize = TEXTURE_SIZE;
ti.textureFormat = TextureImporterFormat.AutomaticTruecolor;
ti.textureType = TextureImporterType.Sprite;
ti.spriteImportMode = SpriteImportMode.Multiple;
ti.spritesheet = ApplySpriteSheet(lsMeta.ToArray(), ti.spritesheet);
ti.textureFormat = TextureImporterFormat.AutomaticTruecolor;
AssetDatabase.ImportAsset(texName);
}
/// <summary>
/// Determines if the specified name has spritesheet meta data.
/// </summary>
/// <returns><c>true</c> if has spritesheet meta the specified collection name; otherwise, <c>false</c>.</returns>
/// <param name="collection">Collection.</param>
/// <param name="name">Name.</param>
private static bool HasSpritesheetMeta(SpriteMetaData[] collection, string name)
{
for (int i = 0; i < collection.Length; i++)
{
if (collection[i].name == name)
return true;
}
return false;
}
// 保存原来的配置中记录的border和pivot信息
private SpriteMetaData[] ApplySpriteSheet(SpriteMetaData[] lsMeta, SpriteMetaData[] old)
{
for (int i = 0; i < lsMeta.Length; i++)
{
string name = lsMeta[i].name;
for (int j = 0; j < old.Length; j++)
{
if (name == old[j].name)
{
lsMeta[i].border = old[j].border;
// lsMeta[i].pivot = old[j].pivot;
break;
}
}
}
return lsMeta;
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (Event.current.type == EventType.Repaint)
{
background.Draw(r, false, false, false, false);
}
Texture texture = base.target as Texture;
if (!(texture == null))
{
RenderTexture renderTexture = texture as RenderTexture;
if (renderTexture != null)
{
if (!SystemInfo.SupportsRenderTextureFormat(renderTexture.format))
{
return;
}
renderTexture.Create();
}
if (this.IsCubemap())
{
this.m_CubemapPreview.OnPreviewGUI(texture, r, background);
}
else
{
int num = Mathf.Max(texture.width, 1);
int num2 = Mathf.Max(texture.height, 1);
float mipLevelForRendering = this.GetMipLevelForRendering();
float num3 = Mathf.Min(Mathf.Min(r.width / (float)num, r.height / (float)num2), 1f);
Rect rect = new Rect(r.x, r.y, (float)num * num3, (float)num2 * num3);
PreviewGUI.BeginScrollView(r, this.m_Pos, rect, "PreHorizontalScrollbar", "PreHorizontalScrollbarThumb");
float mipMapBias = texture.mipMapBias;
TextureUtil.SetMipMapBiasNoDirty(texture, mipLevelForRendering - this.Log2((float)num / rect.width));
FilterMode filterMode = texture.filterMode;
TextureUtil.SetFilterModeNoDirty(texture, FilterMode.Point);
if (this.m_ShowAlpha)
{
EditorGUI.DrawTextureAlpha(rect, texture);
}
else
{
Texture2D texture2D = texture as Texture2D;
if (texture2D != null && texture2D.alphaIsTransparency)
{
EditorGUI.DrawTextureTransparent(rect, texture);
}
else
{
EditorGUI.DrawPreviewTexture(rect, texture);
}
}
if (rect.width > 32f && rect.height > 32f)
{
string assetPath = AssetDatabase.GetAssetPath(texture);
TextureImporter textureImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
SpriteMetaData[] array = (!(textureImporter != null)) ? null : textureImporter.spritesheet;
if (array != null && textureImporter.spriteImportMode == SpriteImportMode.Multiple)
{
Rect rect2 = default(Rect);
Rect rect3 = default(Rect);
GUI.CalculateScaledTextureRects(rect, ScaleMode.StretchToFill, (float)texture.width / (float)texture.height, ref rect2, ref rect3);
int width = texture.width;
int height = texture.height;
textureImporter.GetWidthAndHeight(ref width, ref height);
float num4 = (float)texture.width / (float)width;
HandleUtility.ApplyWireMaterial();
GL.PushMatrix();
GL.MultMatrix(Handles.matrix);
GL.Begin(1);
GL.Color(new Color(1f, 1f, 1f, 0.5f));
SpriteMetaData[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
SpriteMetaData spriteMetaData = array2[i];
Rect rect4 = spriteMetaData.rect;
this.DrawRect(new Rect
{
xMin = rect2.xMin + rect2.width * (rect4.xMin / (float)texture.width * num4),
xMax = rect2.xMin + rect2.width * (rect4.xMax / (float)texture.width * num4),
yMin = rect2.yMin + rect2.height * (1f - rect4.yMin / (float)texture.height * num4),
yMax = rect2.yMin + rect2.height * (1f - rect4.yMax / (float)texture.height * num4)
});
}
GL.End();
GL.PopMatrix();
}
}
TextureUtil.SetMipMapBiasNoDirty(texture, mipMapBias);
TextureUtil.SetFilterModeNoDirty(texture, filterMode);
this.m_Pos = PreviewGUI.EndScrollView();
if (mipLevelForRendering != 0f)
{
EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 20f), "Mip " + mipLevelForRendering);
}
}
}
}
static void updateSpriteMetaData(TextureImporter importer, string pathToData)
{
if (importer.textureType != TextureImporterType.Advanced) {
importer.textureType = TextureImporterType.Sprite;
}
importer.maxTextureSize = 4096;
importer.spriteImportMode = SpriteImportMode.Multiple;
string[] dataFileContent = File.ReadAllLines(pathToData);
int format = 30302;
foreach (string row in dataFileContent)
{
if (row.StartsWith(":format=")) {
format = int.Parse(row.Remove(0,8));
}
}
if (format != 30302) {
EditorUtility.DisplayDialog("Please update TexturePacker Importer", "Your TexturePacker Importer is too old, \nplease load a new version from the asset store!", "Ok");
return;
}
Dictionary<string, SpriteMetaData> existingSprites = new Dictionary<string, SpriteMetaData>();
foreach (SpriteMetaData sprite in importer.spritesheet)
{
existingSprites.Add(sprite.name, sprite);
}
List<SpriteMetaData> metaData = new List<SpriteMetaData> ();
foreach (string row in dataFileContent) {
if (string.IsNullOrEmpty (row) || row.StartsWith ("#") || row.StartsWith (":"))
continue; // comment lines start with #, additional atlas properties with :
string [] cols = row.Split (';');
if (cols.Length < 7)
return; // format error
SpriteMetaData smd = new SpriteMetaData ();
smd.name = cols [0].Replace ("/", "-"); // unity has problems with "/" in sprite names...
float x = float.Parse (cols [1]);
float y = float.Parse (cols [2]);
float w = float.Parse (cols [3]);
float h = float.Parse (cols [4]);
float px = float.Parse (cols [5]);
float py = float.Parse (cols [6]);
smd.rect = new UnityEngine.Rect (x, y, w, h);
if (existingSprites.ContainsKey(smd.name))
{
SpriteMetaData sprite = existingSprites[smd.name];
smd.pivot = sprite.pivot;
smd.alignment = sprite.alignment;
#if !UNITY_4_3 // border attribute was introduced with 4.5 (versions <4.3 are not supported at all)
smd.border = sprite.border;
#endif
}
if (importPivotPoints || !existingSprites.ContainsKey(smd.name))
{
smd.pivot = new UnityEngine.Vector2 (px, py);
if (px == 0 && py == 0)
smd.alignment = (int)UnityEngine.SpriteAlignment.BottomLeft;
else if (px == 0.5 && py == 0)
smd.alignment = (int)UnityEngine.SpriteAlignment.BottomCenter;
else if (px == 1 && py == 0)
smd.alignment = (int)UnityEngine.SpriteAlignment.BottomRight;
else if (px == 0 && py == 0.5)
smd.alignment = (int)UnityEngine.SpriteAlignment.LeftCenter;
else if (px == 0.5 && py == 0.5)
smd.alignment = (int)UnityEngine.SpriteAlignment.Center;
else if (px == 1 && py == 0.5)
smd.alignment = (int)UnityEngine.SpriteAlignment.RightCenter;
else if (px == 0 && py == 1)
smd.alignment = (int)UnityEngine.SpriteAlignment.TopLeft;
else if (px == 0.5 && py == 1)
smd.alignment = (int)UnityEngine.SpriteAlignment.TopCenter;
else if (px == 1 && py == 1)
smd.alignment = (int)UnityEngine.SpriteAlignment.TopRight;
else
smd.alignment = (int)UnityEngine.SpriteAlignment.Custom;
}
metaData.Add (smd);
}
importer.spritesheet = metaData.ToArray();
}
private void PerformSlice()
{
XmlDocument document = new XmlDocument();
document.LoadXml(xmlAsset.text);
XmlElement root = document.DocumentElement;
if (root.Name == "TextureAtlas") {
bool failed = false;
Texture2D texture = AssetDatabase.LoadMainAssetAtPath(importer.assetPath) as Texture2D;
int textureHeight = texture.height;
List<SpriteMetaData> metaDataList = new List<SpriteMetaData>();
foreach (XmlNode childNode in root.ChildNodes)
{
if (childNode.Name == "SubTexture") {
try {
int width = Convert.ToInt32(childNode.Attributes["width"].Value);
int height = Convert.ToInt32(childNode.Attributes["height"].Value);
int x = Convert.ToInt32(childNode.Attributes["x"].Value);
int y = textureHeight - (height + Convert.ToInt32(childNode.Attributes["y"].Value));
SpriteMetaData spriteMetaData = new SpriteMetaData
{
alignment = (int)spriteAlignment,
border = new Vector4(),
name = childNode.Attributes["name"].Value,
pivot = GetPivotValue(spriteAlignment, customOffset),
rect = new Rect(x, y, width, height)
};
metaDataList.Add(spriteMetaData);
}
catch (Exception exception) {
failed = true;
Debug.LogException(exception);
}
}
else
{
Debug.LogError("Child nodes should be named 'SubTexture' !");
failed = true;
}
}
if (!failed) {
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = metaDataList.ToArray();
EditorUtility.SetDirty(importer);
try
{
AssetDatabase.StartAssetEditing();
AssetDatabase.ImportAsset(importer.assetPath);
}
finally
{
AssetDatabase.StopAssetEditing();
Close();
}
}
}
else
{
Debug.LogError("XML needs to have a 'TextureAtlas' root node!");
}
}
public SpriteMetaData[] GetSpriteSheet(SpriteAlignment spriteAlignment, float customX, float customY)
{
SpriteMetaData[] metaData = new SpriteMetaData[frames.Count];
for (int i = 0; i < frames.Count; i++)
{
AsepriteFrame frame = frames[i];
SpriteMetaData sprite = new SpriteMetaData();
// sprite alignment
sprite.alignment = (int)spriteAlignment;
if (spriteAlignment == SpriteAlignment.Custom)
{
sprite.pivot.x = customX;
sprite.pivot.y = customY;
}
sprite.name = frame.filename.Replace(".ase","");
sprite.rect = new Rect(frame.x, frame.y, frame.width, frame.height);
metaData[i] = sprite;
}
return metaData;
}
static List<SpriteMetaData> MaintainSpriteOrder(string path, List<SpriteMetaData> sprites, string imageName)
{
sprites = new List<SpriteMetaData>(sprites); // Work on a copy, method shouldn't have side-effects
List<SpriteMetaData> orderedSprites = new List<SpriteMetaData>();
Object[] existing = AssetDatabase.LoadAllAssetsAtPath(path);
for (int i = 0; i < existing.Length; ++i)
{
Sprite existingSprite = existing[i] as Sprite;
if (null != existingSprite)
{
int pickedIndex = FindSpriteFromListByName(sprites, existingSprite.name);
if (-1 != pickedIndex)
{
orderedSprites.Add(sprites[pickedIndex]);
sprites.RemoveAt(pickedIndex);
}
else
{
if (existingSprite.name != imageName) // Make sure not to add the spritesheet image itself
{
SpriteMetaData placeholder = new SpriteMetaData();
placeholder.name = existingSprite.name;
orderedSprites.Add(placeholder);
Debug.LogWarning(existingSprite.name + " removed from spritesheet. Adding blank placeholder.");
}
}
}
else
{
if (null == existing[i] as Texture2D)
Debug.LogWarning("Unexpected type " + existing[i]);
}
}
orderedSprites.AddRange(sprites);
return orderedSprites;
}
void Slice()
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(_xmlAsset.text);
XmlElement root = xmlDoc.DocumentElement;
if(root.Name == "TextureAtlas")
{
bool failed = false;
Texture2D texture = AssetDatabase.LoadMainAssetAtPath(_textureImporter.assetPath) as Texture2D;
int textureHeight = texture.height;
List<SpriteMetaData> metaDatas = new List<SpriteMetaData>();
foreach(XmlNode node in root.ChildNodes)
{
if(node.Name == "SubTexture")
{
try
{
int w = Convert.ToInt32(node.Attributes["width"].Value);
int h = Convert.ToInt32(node.Attributes["height"].Value);
int x = Convert.ToInt32(node.Attributes["x"].Value);
int y = textureHeight - (h + Convert.ToInt32(node.Attributes["y"].Value));
SpriteMetaData smd = new SpriteMetaData()
{
alignment = (int)_alignment,
border = new Vector4(),
name = node.Attributes["name"].Value,
pivot = GetPivotValue(_alignment, _customOffset),
rect = new Rect(x, y, w, h)
};
metaDatas.Add(smd);
}
catch(Exception ex)
{
failed = true;
Debug.LogException(ex);
}
}
else
{
failed = true;
Debug.LogError("[XMLSpriteSlicer] XML format is invalid. Not found 'SubTexture' tag");
}
}
if (!failed)
{
_textureImporter.spriteImportMode = SpriteImportMode.Multiple;
_textureImporter.spritesheet = metaDatas.ToArray();
EditorUtility.SetDirty(_textureImporter);
try
{
AssetDatabase.StartAssetEditing();
AssetDatabase.ImportAsset(_textureImporter.assetPath);
}
finally
{
AssetDatabase.StopAssetEditing();
Close();
}
}
}
else
{
Debug.LogError("[XMLSpriteSlicer] XML format is invalid. Not found 'TextureAtlas' tag");
}
}
