static public byte[] SaveSpriteSheeetsToBytes(SpriteSheet[] spriteSheets)
{
MemoryStream ms = new MemoryStream();
BinaryWriter writer = new BinaryWriter(ms);
writer.Write((int)0xFAAF); //Header
writer.Write((int)1); //Version
writer.Write((int)spriteSheets.Length);
for (int i = 0; i < spriteSheets.Length; i++)
{
SpriteSheet spriteSheet = spriteSheets[i];
writer.Write((string)spriteSheet.Id);
writer.Write((int)spriteSheet.GetSpriteCount());
for (int j = 0; j < spriteSheet.GetSpriteCount(); j++)
{
SpriteDefinition sprite = spriteSheet.GetSpriteDefinition(j);
writer.Write((string)sprite.Id);
writer.Write((int)sprite.SizeX);
writer.Write((int)sprite.SizeY);
writer.Write((float)sprite.UV.x);
writer.Write((float)sprite.UV.y);
writer.Write((float)sprite.UV.width);
writer.Write((float)sprite.UV.height);
}
}
writer.Flush();
return(ms.ToArray());
}
protected override void OnInit()
{
if (!string.IsNullOrEmpty(spriteId))
{
sprite = panel.SpriteSheet.GetSpriteDefinition(spriteId);
}
else
{
sprite = null;
}
}
public void AddSprite(
SpriteDefinition sprite,
float x, float y,
float sizeX, float sizeY,
Color32 color)
{
AddQuad(x, y,
sizeX, sizeY,
sprite.UV.xMin, sprite.UV.yMax,
sprite.UV.xMax, sprite.UV.yMin,
color);
}
static public SpriteSheet[] LoadSpriteSheetsFromBytes(byte[] bytes)
{
MemoryStream ms = new MemoryStream(bytes);
BinaryReader reader = new BinaryReader(ms);
int header = reader.ReadInt32();
int version = reader.ReadInt32();
if (header != 0xFAAF || version != 1)
{
return(new SpriteSheet[0]);
}
int spriteSheetsCount = reader.ReadInt32();
SpriteSheet[] spriteSheets = new SpriteSheet[spriteSheetsCount];
for (int i = 0; i < spriteSheetsCount; i++)
{
string id = reader.ReadString();
int spriteCount = reader.ReadInt32();
SpriteDefinition[] sprites = new SpriteDefinition[spriteCount];
spriteSheets[i] = new SpriteSheet(id, sprites);
for (int j = 0; j < spriteCount; j++)
{
string spriteId = reader.ReadString();
int spriteSizeX = reader.ReadInt32();
int spriteSizeY = reader.ReadInt32();
float spriteUVx = reader.ReadSingle();
float spriteUVy = reader.ReadSingle();
float spriteUVwidth = reader.ReadSingle();
float spriteUVheight = reader.ReadSingle();
sprites[j] = new SpriteDefinition(spriteId, spriteSizeX, spriteSizeY, new Rect(spriteUVx, spriteUVy, spriteUVwidth, spriteUVheight), spriteSheets[i]);
}
}
return(spriteSheets);
}
protected override void DrawMesh()
{
float offsetX = 0;
float offsetY = 0;
spriteMesh.SetScale(scale);
for (int j = 0; j < spriteSheet.GetSpriteCount(); j++)
{
offsetX = 0;
for (int i = 0; i < spriteSheet.GetSpriteCount(); i++)
{
SpriteMeshEngine.SpriteDefinition sprite = spriteSheet.GetSpriteDefinition((i + j) % spriteSheet.GetSpriteCount());
spriteMesh.AddSprite(sprite, offsetX, offsetY, sprite.SizeX, sprite.SizeY, Color.white);
offsetX += sprite.SizeX;
}
offsetY += 70;
}
}
static public void UpdateSpritesheets()
{
Debug.Log("--- Starting spritesheet update ---");
string[] directories = Directory.GetDirectories("Assets/Spritesheets");
List <SpriteSheet> spriteSheets = new List <SpriteSheet>();
foreach (string directory in directories)
{
Debug.Log("Processing directory " + directory);
string[] files = Directory.GetFiles(directory);
List <Texture2D> spriteTextures = new List <Texture2D>();
List <string> spriteIds = new List <string>();
foreach (string file in files)
{
string extension = Path.GetExtension(file).ToUpperInvariant();
if (extension == ".JPG" || extension == ".PNG" || extension == ".TGA")
{
Texture2D texture = AssetDatabase.LoadAssetAtPath(file, typeof(Texture2D)) as Texture2D;
if (texture)
{
spriteTextures.Add(texture);
spriteIds.Add(Path.GetFileNameWithoutExtension(file));
}
}
}
if (spriteTextures.Count > 0)
{
Texture2D packedTexture = new Texture2D(1024, 1024);
Rect[] uvs = packedTexture.PackTextures(spriteTextures.ToArray(), 2);
byte[] packedTextureBytes = packedTexture.EncodeToPNG();
string spriteSheetId = Path.GetFileName(directory);
string packedTextureFilename = "Assets/Resources/Spritesheets/" + spriteSheetId + ".png";
File.WriteAllBytes(packedTextureFilename, packedTextureBytes);
SpriteMeshEngine.SpriteDefinition[] sprites = new SpriteMeshEngine.SpriteDefinition[spriteTextures.Count];
SpriteSheet spriteSheet = new SpriteSheet(spriteSheetId, sprites);
for (int i = 0; i < sprites.Length; i++)
{
sprites[i] = new SpriteMeshEngine.SpriteDefinition(spriteIds[i], spriteTextures[i].width, spriteTextures[i].height, uvs[i], spriteSheet);
}
spriteSheets.Add(spriteSheet);
Debug.Log(packedTextureFilename + " : Added " + sprites.Length + " Sprites");
}
}
File.WriteAllBytes("Assets/Resources/Spritesheets/definitions.bytes", SpriteSheetManager.SaveSpriteSheeetsToBytes(spriteSheets.ToArray()));
SpriteSheetManager.Clear();
Debug.Log("--- Finished spritesheet update ---");
AssetDatabase.Refresh();
Debug.Log("--- Generating Unity Sprites ---");
for (int i = 0; i < SpriteSheetManager.GetSpriteSheetCount(); i++)
{
SpriteSheet spriteSheet = SpriteSheetManager.GetSpriteSheet(i);
Texture2D spriteSheetTexture = spriteSheet.Texture;
string path = AssetDatabase.GetAssetPath(spriteSheetTexture);
TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
//Disable spritesheet and reimport, if we don't do this, Unity won't take any changes made to the spritesheet definition (BUG in unity?)
textureImporter.spriteImportMode = SpriteImportMode.None;
AssetDatabase.ImportAsset(path);
//Now calculate the new spritesheets
SpriteMetaData[] spriteMetaDatas = new SpriteMetaData[spriteSheet.GetSpriteCount()];
int textureWidth = spriteSheetTexture.width;
int textureHeight = spriteSheetTexture.height;
if ((textureWidth >= textureHeight) && textureWidth > textureImporter.maxTextureSize)
{
float scale = textureWidth / textureImporter.maxTextureSize;
textureWidth = textureImporter.maxTextureSize;
textureHeight = Mathf.RoundToInt(textureHeight / scale);
}
else if ((textureHeight >= textureWidth) && textureHeight > textureImporter.maxTextureSize)
{
float scale = textureHeight / textureImporter.maxTextureSize;
textureHeight = textureImporter.maxTextureSize;
textureWidth = Mathf.RoundToInt(textureWidth / scale);
}
for (int j = 0; j < spriteSheet.GetSpriteCount(); j++)
{
SpriteDefinition spriteDefinition = spriteSheet.GetSpriteDefinition(j);
SpriteMetaData metaData = new SpriteMetaData();
metaData.name = spriteDefinition.Id;
metaData.alignment = (int)SpriteAlignment.BottomLeft;
metaData.pivot = Vector2.zero;
metaData.rect = spriteDefinition.UV;
metaData.rect.x *= textureWidth;
metaData.rect.y *= textureHeight;
metaData.rect.width *= textureWidth;
metaData.rect.height *= textureHeight;
spriteMetaDatas[j] = metaData;
}
textureImporter.textureType = TextureImporterType.Sprite;
textureImporter.npotScale = TextureImporterNPOTScale.None;
textureImporter.alphaIsTransparency = true;
textureImporter.spriteImportMode = SpriteImportMode.Multiple;
textureImporter.spritePixelsToUnits = 1;
textureImporter.spritePackingTag = "";
textureImporter.spritePivot = Vector2.zero;
textureImporter.spritesheet = spriteMetaDatas;
AssetDatabase.ImportAsset(path);
}
Debug.Log("--- Finished generating Unity Sprites ---");
Debug.Log("--- Updating sprite cache ---");
GameObject spriteCachePrefab = Resources.Load <GameObject>("Spritesheets/SpriteCache");
List <SpriteCacheEntry> cacheEntries = new List <SpriteCacheEntry>();
if (spriteCachePrefab)
{
SpriteCache spriteCache = spriteCachePrefab.GetComponent <SpriteCache>();
for (int i = 0; i < SpriteSheetManager.GetSpriteSheetCount(); i++)
{
SpriteSheet spriteSheet = SpriteSheetManager.GetSpriteSheet(i);
Texture2D spriteSheetTexture = spriteSheet.Texture;
string path = AssetDatabase.GetAssetPath(spriteSheetTexture);
List <Sprite> sprites = new List <Sprite>();
foreach (Object obj in AssetDatabase.LoadAllAssetsAtPath(path))
{
if (obj is Sprite)
{
sprites.Add((Sprite)obj);
}
}
SpriteCacheEntry cacheEntry = new SpriteCacheEntry();
cacheEntry.spritesheetId = spriteSheet.Id;
cacheEntry.sprites = sprites.ToArray();
cacheEntries.Add(cacheEntry);
}
spriteCache.cacheEntries = cacheEntries.ToArray();
EditorUtility.SetDirty(spriteCache);
}
else
{
Debug.LogError("Sprite cache prefab not found!!!");
}
Debug.Log("--- Finished updating sprite cache ---");
}
public void UpdateSprite()
{
if (!spriteRenderer)
{
spriteRenderer = GetComponent <SpriteRenderer>();
}
if (string.IsNullOrEmpty(spriteSheetId))
{
spriteRenderer.enabled = false;
return;
}
if (string.IsNullOrEmpty(spriteId))
{
spriteRenderer.enabled = false;
return;
}
SpriteSheet spriteSheet = SpriteSheetManager.GetSpriteSheet(spriteSheetId);
if (spriteSheet == null)
{
spriteRenderer.enabled = false;
return;
}
SpriteMeshEngine.SpriteDefinition spriteDefinition = spriteSheet.GetSpriteDefinition(spriteId);
if (spriteDefinition == null)
{
spriteRenderer.enabled = false;
return;
}
spriteRenderer.sprite = spriteDefinition.Sprite;
spriteRenderer.enabled = true;
float sizeX = spriteDefinition.SizeX;
float sizeY = spriteDefinition.SizeY;
Vector3 localScale = transform.localScale;
if (maxWidth > 0 || maxHeight > 0)
{
float scaleX = 1.0f;
float scaleY = 1.0f;
if (maxWidth > 0)
{
scaleX = sizeX / maxWidth;
}
if (maxHeight > 0)
{
scaleY = sizeY / maxHeight;
}
float scale = Mathf.Max(scaleX, scaleY);
if (scale < 0.01f)
{
scale = 0.01f;
}
localScale = Vector3.one * (1.0f / scale);
transform.localScale = localScale;
}
if (verticalAlignment != GUIAlignVertical.None || horizontalAlignment != GUIAlignHorizontal.None)
{
float x = 0;
float y = 0;
switch (verticalAlignment)
{
case GUIAlignVertical.Bottom:
y = 0;
break;
case GUIAlignVertical.Center:
y = (-sizeY / 2.0f) * localScale.y;
break;
case GUIAlignVertical.Top:
y = -sizeY * localScale.y;
break;
}
switch (horizontalAlignment)
{
case GUIAlignHorizontal.Left:
x = 0;
break;
case GUIAlignHorizontal.Center:
x = (-sizeX / 2.0f) * localScale.x;
break;
case GUIAlignHorizontal.Right:
x = -sizeX * localScale.x;
break;
}
float localRotation = transform.localRotation.eulerAngles.z * Mathf.Deg2Rad;
float cosLocalRotation = Mathf.Cos(localRotation);
float sinLocalRotation = Mathf.Sin(localRotation);
transform.localPosition = new Vector3(
x * cosLocalRotation - y * sinLocalRotation,
x * sinLocalRotation + y * cosLocalRotation,
0);
}
}
