ecglrenderer.cpp

#include "ecglrenderer.h"

#include "GL/glew.h"

#include "glshaderprogram.h"
#include "cjblog.h"

void ECGLRenderer::preLoop()
{
    m_stateManager = new GLStateManager();
    m_stateManager->init();

    IECRenderer::preLoop();
}

void ECGLRenderer::shutdown()
{
    if (m_stateManager)
    {
        delete m_stateManager;
        m_stateManager = NULL;
    }

    IECRenderer::shutdown();
}

void ECGLRenderer::clearBuffers(CJB_UINT32 buffers)
{
    GLuint clearBuffers = 0;

    clearBuffers |= (clearBuffers & CJB_COLOR_BUFFER) ? 0 : GL_COLOR_BUFFER_BIT;
    clearBuffers |= (clearBuffers & CJB_DEPTH_BUFFER) ? 0 : GL_DEPTH_BUFFER_BIT;
    clearBuffers |= (clearBuffers & CJB_STENCIL_BUFFER) ? 0 : GL_STENCIL_BUFFER_BIT;

    glClear(clearBuffers);
}

void ECGLRenderer::setClearColor(float red, float green, float blue, float alpha)
{
    glClearColor(red,green,blue,alpha);
}

ITexture* ECGLRenderer::createTextureWithImage(const char* imageFile)
{
    GLTexture* newTexture = new GLTexture(imageFile);

    return newTexture;
}

void ECGLRenderer::bindTexture(ITexture* texture)
{
    glBindTexture(GL_TEXTURE_2D,((GLTexture*)texture)->getTextureID());
}

IShaderProgram* ECGLRenderer::createShaderProgram(const char* vertexShader, const char* fragmentShader)
{
    GLShaderProgram* ret = new GLShaderProgram(vertexShader,fragmentShader);

    if (ret == NULL)
    {
        CJBLOG_WARNING("Failed to create shader program with %s %s\n",vertexShader, fragmentShader);
        return NULL;
    }

    return ret;
}

void ECGLRenderer::deleteShaderProgram(IShaderProgram* program)
{
    glDeleteProgram(((GLShaderProgram*)program)->getProgramID());
}

void ECGLRenderer::useShaderProgram(IShaderProgram* program)
{
    glUseProgram(((GLShaderProgram*)program)->getProgramID());
}

IVertexBufferObject* ECGLRenderer::generateVBO()
{
    GLVertexBufferObject* newVBO = new GLVertexBufferObject;
    glGenBuffers(1,&newVBO->bufferID);
    return newVBO;
}

IVertexArrayObject* ECGLRenderer::generateVAO()
{
    GLVertexArrayObject* newVAO = new GLVertexArrayObject;
    glGenVertexArrays(1,&newVAO->arrayID);
    return newVAO;
}

void ECGLRenderer::bindVBO(CJB_UINT32 bufferType, IVertexBufferObject* pVBO)
{
    if (bufferType == VBO_ARRAY)
        glBindBuffer(GL_ARRAY_BUFFER,((GLVertexBufferObject*)pVBO)->bufferID);
    else
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,((GLVertexBufferObject*)pVBO)->bufferID);
}

void ECGLRenderer::bindVAO(IVertexArrayObject* pVAO)
{
    glBindVertexArray(((GLVertexArrayObject*)pVAO)->arrayID);
}

void ECGLRenderer::deleteVBO(IVertexBufferObject*& pVBO)
{
    glDeleteBuffers(1,&((GLVertexBufferObject*)pVBO)->bufferID);
    delete pVBO;
    pVBO = NULL;
}

void ECGLRenderer::deleteVAO(IVertexArrayObject*& pVAO)
{
    glDeleteVertexArrays(1,&((GLVertexArrayObject*)pVAO)->arrayID);
    delete pVAO;
    pVAO = NULL;
}

void ECGLRenderer::setBufferData(CJB_UINT32 target,size_t size, void* data, CJB_UINT32 usage)
{
    CJB_UINT32 glTarget = (target == VBO_ARRAY) ? GL_ARRAY_BUFFER : GL_ELEMENT_ARRAY_BUFFER;
    CJB_UINT32 glUsage = (usage == VBO_STATIC_DRAW) ? GL_STATIC_DRAW : GL_DYNAMIC_DRAW;

    glBufferData(glTarget,size,data,glUsage);
}

void ECGLRenderer::enableVertexAttributeArray(CJB_UINT32 attributeIndex)
{
    glEnableVertexAttribArray(attributeIndex);
}

void ECGLRenderer::setVertexAttributePointer(CJB_UINT32 attributeIndex, CJB_UINT32 size, CJB_UINT32 type, bool isNormalized, size_t stride, void* pointer)
{
    glVertexAttribPointer(attributeIndex,size,convertTypeToGLType(type),isNormalized,stride,pointer);
}

CJB_UINT32 ECGLRenderer::convertTypeToGLType(CJB_UINT32 elementType)
{
    switch(elementType)
    {
    case ET_FLOAT:
        return GL_FLOAT;
    case ET_USHORT:
        return GL_UNSIGNED_SHORT;
    case ET_UINT32:
        return GL_UNSIGNED_INT;
    }
}

void ECGLRenderer::unbindVBO(CJB_UINT32 bufferType)
{
    CJB_UINT32 glTarget = (bufferType == VBO_ARRAY) ? GL_ARRAY_BUFFER : GL_ELEMENT_ARRAY_BUFFER;
    glBindBuffer(glTarget,0);
}

void ECGLRenderer::unbindVAO()
{
    glBindVertexArray(0);
}

void ECGLRenderer::drawElements(CJB_UINT32 mode, size_t triCount, CJB_UINT32 type, void* INDICES )
{
    CJB_UINT32 glMode = (mode == DRAW_MODE_TRIANGLES) ? GL_TRIANGLES : GL_TRIANGLE_STRIP;

    glDrawElements(glMode,triCount*3,convertTypeToGLType(type),INDICES);
}