SpriteBatch.h

/*   ██╗  ██╗  █████╗  ████████╗  █████╗  ███╗   ██╗  █████╗ 
     ██║ ██╔╝ ██╔══██╗ ╚══██╔══╝ ██╔══██╗ ████╗  ██║ ██╔══██╗
     █████╔╝  ███████║    ██║    ███████║ ██╔██╗ ██║ ███████║
     ██╔═██╗  ██╔══██║    ██║    ██╔══██║ ██║╚██╗██║ ██╔══██║
     ██║  ██╗ ██║  ██║    ██║    ██║  ██║ ██║ ╚████║ ██║  ██║
     ╚═╝  ╚═╝ ╚═╝  ╚═╝/\  ╚═╝    ╚═╝  ╚═╝ ╚═╝  ╚═══╝ ╚═╝  ╚═╝
   /vvvvvvvvvvvvvvvvvvv \=========================================,
   `^^^^^^^^^^^^^^^^^^^ /---------------------------------------"
        Katana Engine \/ © 2012 - Shuriken Studios LLC              */

#pragma once

namespace KatanaEngine
{
    enum class TextAlign
    {
        LEFT,           
        CENTER,         
        RIGHT           
    };

    enum class SpriteSortMode
    {
        BACK_TO_FRONT,  
        DEFERRED,       
        FRONT_TO_BACK,  
        IMMEDIATE,      
        TEXTURE         
    };

    enum class BlendState
    {
        ALPHA,          
        ADDITIVE        
    };

    class SpriteBatch
    {

    public:

        SpriteBatch() { m_isStarted = false; }
        ~SpriteBatch() { }

        void Begin(const SpriteSortMode sortMode = SpriteSortMode::DEFERRED,
            const BlendState blendState = BlendState::ALPHA,
            ALLEGRO_TRANSFORM *pTransformation = NULL);

        void End(/*bool test = false*/);

        void DrawString(const Font *pFont, std::string *text, const Vector2 position,
            const Color color = Color::White, const TextAlign alignment = TextAlign::LEFT,
            const float drawDepth = 0);

        void Draw(const Texture *pTexture, const Vector2 position, const Region region,
            const Color color = Color::White, const Vector2 origin = Vector2::Zero, 
            const Vector2 scale = Vector2::One, const float rotation = 0, 
            const float drawDepth = 0);

        void Draw(const Texture *pTexture, const Vector2 position,
            const Color color = Color::White, const Vector2 origin = Vector2::Zero,
            const Vector2 scale = Vector2::One, const float rotation = 0,
            const float drawDepth = 0);

        void Draw(Animation *pAnimation, const Vector2 position,
            const Color color = Color::White, const Vector2 origin = Vector2::Zero,
            const Vector2 scale = Vector2::One, const float rotation = 0,
            float drawDepth = 0);

        void GetBatchSettings(SpriteSortMode &sortMode, BlendState &blendState, ALLEGRO_TRANSFORM *pTransformation);


    private:

        struct Drawable
        {
            bool isBitmap;
            ALLEGRO_COLOR color;
            int x, y;
            float depth;

            union
            {
                struct
                {
                    ALLEGRO_FONT *pFont;
                    std::string *text;
                    TextAlign align;
                };

                struct
                {
                    ALLEGRO_BITMAP *pBitmap;
                    float rotation;
                    int cx, cy;
                    int sx, sy, sw, sh;
                    float scx, scy;
                    unsigned short id;
                };

            } Union;

            bool operator<(const Drawable& other) const
            {
                return (depth < other.depth);
            }
        };

        struct CompareBackToFront
        {
            bool operator()(const Drawable* l, const Drawable* r) { return (*l < *r); }
        };

        struct CompareFrontToBack
        {
            bool operator()(const Drawable* l, const Drawable* r) { return (*r < *l); }
        };

        std::vector<Drawable *> m_drawables;
        std::vector<Drawable *> m_inactiveDrawables;
        std::vector<Drawable *>::iterator m_it;

        unsigned short m_lastID;

        SpriteSortMode m_sortMode;

        BlendState m_blendState;

        ALLEGRO_TRANSFORM *m_pTransformation;

        bool m_isStarted;

        void DrawBitmap(Drawable *drawable);
        void DrawFont(Drawable *drawable);

    };
}