Пример #1
0
        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());
        }
Пример #2
0
 protected override void OnInit()
 {
     if (!string.IsNullOrEmpty(spriteId))
     {
         sprite = panel.SpriteSheet.GetSpriteDefinition(spriteId);
     }
     else
     {
         sprite = null;
     }
 }
Пример #3
0
 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);
 }
Пример #4
0
        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);
        }
Пример #5
0
    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;
        }
    }
Пример #6
0
    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 ---");
    }
Пример #7
0
    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);
        }
    }