SB.cpp

#include "MLSpriteBatch.h"

using MLRenderer::MLSpriteBatch;


MLSpriteBatch::MLSpriteBatch(int buffersize) : m_BufferSize(buffersize), m_spriteSize((sizeof(MLBatchItem::Vertex) * 4))
{
    m_shader = new MLShader();
    //load the default sprite batch shaders
    m_shader->LoadShaderFile("shaders/SBatch.vert", GL_VERTEX_SHADER);
    m_shader->LoadShaderFile("shaders/SBatch.frag", GL_FRAGMENT_SHADER);
    //lock the shader in place to add the attributes and link
    m_shader->lock();
    {
        m_shader->bindAtt(MLRenderer::ML_ATT_VERTEXPOS, "VertexPosition");
        m_shader->bindAtt(MLRenderer::ML_ATT_TEXTURE0,  "TextureCoord");
        m_shader->LinkShaders();
    }
    m_shader->unlock(); //unlock the shader
    m_beginCall = false;
    MLError::ErrorHandler::ML_Printf(ML_SpriteBatch, "Creating batch with max %i sprites\n", ML_MAX_SPRITES);

    //initalise the batcher
    Initalise();

    MLError::ErrorHandler::ML_Printf(ML_SpriteBatch, "Created Sprite Batch\n");
}


MLSpriteBatch::MLSpriteBatch(MLShader* inShader, int buffersize) : m_shader(inShader), m_BufferSize(buffersize), m_spriteSize((sizeof(MLBatchItem::Vertex) * 4))
{
    m_beginCall = false;
    Initalise();
}

MLSpriteBatch::~MLSpriteBatch(void)
{
    Release(this);
}

void MLSpriteBatch::release()
{

}

void MLSpriteBatch::releaseShader()
{
    if (m_shader)
        delete m_shader;
}

void MLSpriteBatch::Initalise()
{

    m_BufferOffset = 0;

    glGenBuffers(1, &m_VertBuffer);

    glBindBuffer(GL_ARRAY_BUFFER, m_VertBuffer);
    glBufferData(GL_ARRAY_BUFFER, m_BufferSize, NULL,  GL_STREAM_DRAW);

    //enable the vertex attributes for the VAO in this case vertex pos and texture are needed
    glEnableVertexAttribArray((GLuint)MLRenderer::ML_ATT_VERTEXPOS);  // Vertex position
    glEnableVertexAttribArray((GLuint)MLRenderer::ML_ATT_TEXTURE0); //vertex texture coord

    //set the vertex attribute pointers
    glBindBuffer(GL_ARRAY_BUFFER, m_VertBuffer);
    glVertexAttribPointer(MLRenderer::ML_ATT_VERTEXPOS, 3, GL_FLOAT, GL_FALSE, sizeof(MLBatchItem::Vertex), (GLubyte *)NULL );

    //glBindBuffer(GL_ARRAY_BUFFER, m_UVBuffer);
    glVertexAttribPointer(MLRenderer::ML_ATT_TEXTURE0, 2, GL_FLOAT, GL_FALSE, sizeof(MLBatchItem::Vertex), (GLubyte*)sizeof(Vector3f));

    //unbind buffers
    //glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    //set the total sprite count to 0
    totalSpriteCount = 0;

}

void MLSpriteBatch::setShader(MLShader* inShader)
{
    m_shader = inShader;
}

void MLSpriteBatch::Begin(bool Alpha)
{
    //simple check for alpha. This is pre-set to true
    if (Alpha)
    {
        glEnable (GL_BLEND);
    }
    else
        glDisable(GL_BLEND);

    //set the begincall to true so now end can be called without error
    m_beginCall = true;
}

void MLSpriteBatch::Draw(MLSprite* Sprite)
{
    //check to see if the sprite is enabled or not
    if (!Sprite->getEnabled())
        return;

    bool NewBatch = false;

    //a pointer for a batch item
    MLBatchItem::batchInfo* tmpBatch;

    //iterate through the batched items and see if the texture has been called before
    BatchMap::iterator it = m_BatchItems.find(Sprite->getTexture());
    if (it != m_BatchItems.end()) //if it has then set the pointer to that batch
        tmpBatch = m_BatchItems[Sprite->getTexture()];
    else // otherwise create a new batch
    {
        tmpBatch = new MLBatchItem::batchInfo();
        tmpBatch->spriteCount = 0;
        NewBatch = true;
    }

    //create the points of the source rectangle
    Vector3f topLeft        = Vector3f(Sprite->getPos().x, Sprite->getPos().y , 0.0f);
    Vector3f topRight       = Vector3f((Sprite->getPos().x + Sprite->getSize().x), Sprite->getPos().y, 0.0f);
    Vector3f bottmLeft      = Vector3f(Sprite->getPos().x, (Sprite->getPos().y + Sprite->getSize().y), 0.0f);
    Vector3f bottomRight    = Vector3f((Sprite->getPos().x + Sprite->getSize().x), (Sprite->getPos().y + Sprite->getSize().y), 0.0f);

    //add the points to the batch
    tmpBatch->addPoint(topLeft, Vector2f(0.0f, 1.0f));
    tmpBatch->addPoint(topRight, Vector2f(1.0f, 1.0f));
    tmpBatch->addPoint(bottomRight, Vector2f(1.0f, 0.0f));
    tmpBatch->addPoint(bottmLeft, Vector2f(0.0f, 0.0f));

    //increase the batch sprite and total sprite count
    tmpBatch->spriteCount++;
    totalSpriteCount++;

    //if it was a new batch created add it to the map
    if (NewBatch)
        m_BatchItems[Sprite->getTexture()] = tmpBatch;

    //if the max sprite count is reached then render them all out
    if (tmpBatch->spriteCount >= ML_MAX_SPRITES)
        Render();

}

void MLSpriteBatch::Draw(GLuint Texture, Vector2f Pos, Vector2f Size)
{

    bool NewBatch = false;

    MLBatchItem::batchInfo* tmpBatch;

    BatchMap::iterator it = m_BatchItems.find(Texture);
    if (it != m_BatchItems.end())
        tmpBatch = m_BatchItems[Texture];
    else
    {
        tmpBatch = new MLBatchItem::batchInfo();
        tmpBatch->spriteCount = 0;
        NewBatch = true;
    }

    Vector3f topLeft        = Vector3f(Pos.x, Pos.y , 0.0f);
    Vector3f topRight       = Vector3f((Pos.x + Size.x), Pos.y, 0.0f);
    Vector3f bottmLeft      = Vector3f(Pos.x, (Pos.y + Size.y), 0.0f);
    Vector3f bottomRight    = Vector3f((Pos.x + Size.x), (Pos.y + Size.y), 0.0f);

    tmpBatch->addPoint(topLeft, Vector2f(0.0f, 1.0f));
    tmpBatch->addPoint(topRight, Vector2f(1.0f, 1.0f));
    tmpBatch->addPoint(bottomRight, Vector2f(1.0f, 0.0f));
    tmpBatch->addPoint(bottmLeft, Vector2f(0.0f, 0.0f));

    tmpBatch->spriteCount++;

    if (NewBatch)
        m_BatchItems[Texture] = tmpBatch;
}

void MLSpriteBatch::End()
{
    //If begin has not been called then there is an error
    if (!m_beginCall)
    {
        MLError::ErrorHandler::printError("Begin must be called before end");
        return;
    }
    //if the sprite count is greater than 0 the something will need to be rendered still
    if (totalSpriteCount > 0)
        Render();

    m_BufferOffset = 0;
    //clear the batch after done just in case
    m_BatchItems.clear();
}

void MLSpriteBatch::Render()
{
    //lock the shader
    m_shader->lock();
    //apply the uniforms
    m_shader->addUniform("inMVP", (MLRenderer::MLCoreGL::getOrtho()));
    m_shader->addUniform("Tex1", 0);

    glBindBuffer(GL_ARRAY_BUFFER, m_VertBuffer);
    //start iterating through the batchs
    BatchMap::iterator it = m_BatchItems.begin();
    for(; it != m_BatchItems.end(); it++)
    {
        //create a pointer to the current batch
        MLBatchItem::batchInfo* currentBatch = it->second;

        //bind the current texture
        glBindTexture(GL_TEXTURE_2D, it->first);

        if (m_BufferOffset +  (currentBatch->spriteCount * m_spriteSize) >= m_BufferSize)
        {
            glBufferData(GL_ARRAY_BUFFER, m_BufferSize, NULL, GL_STREAM_DRAW);
            m_BufferOffset = 0;
        }

        GLbitfield access = (GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
        void* mappedData = glMapBufferRange(GL_ARRAY_BUFFER, m_BufferOffset, m_BufferOffset +  (currentBatch->spriteCount  * m_spriteSize), access);

        if (mappedData)
        {
            memcpy(mappedData, it->second->Verts, (currentBatch->spriteCount * m_spriteSize));
            glUnmapBuffer(GL_ARRAY_BUFFER);
            m_BufferOffset += (currentBatch->spriteCount * m_spriteSize);
            //draw using the indicies and vert count set when the batch was created
            glDrawArrays(GL_QUADS, 0, currentBatch->pointcount);

        }
        //unbind the texture
        glBindTexture(GL_TEXTURE_2D, 0);
        //delete the batch
        delete it->second;
    }
    //unbind the buffer
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    //unlock the shader
    m_shader->unlock();
    //set the total sprite count to 0
    totalSpriteCount = 0;
    //clear the batchs
    m_BatchItems.clear();
}