MercuryOGL.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryFiles.h"
#include "MercuryUtil.h"
#include "MercuryOGL.h"
#include "MercuryLog.h"
#include "MercuryINI.h"
#include "MercuryMath.h"
#include "MercuryPoly.h"
#include "ShaderComposer.h"

#include "MercuryInput.h"

#include "MercuryOGL_Ext.h"

#define BUFFER_OFFSET(i) ((char*)NULL + (i))

MercuryOGL::MercuryOGL()
:MercuryDisplay()
{
    m_shaderProgramID = -1;
}

MercuryOGL::~MercuryOGL()
{
}

bool MercuryOGL::Init(const MString& name, unsigned int width, unsigned int height, unsigned short bpp, bool fullscreen)
{
    if ( !MercuryDisplay::Init(name, width, height, bpp, fullscreen) )
        return false;

    //Only init after we have a window.
    InitOpenglApiExtensions();
    TestCapabilities();

    glShadeModel(GL_SMOOTH);
    glClearColor(0, 0, 0, 1);               // Black Background
    glClearDepth(1.0f);                                 // Depth Buffer Setup
    EnableGLState(MGLS_DEPTHTEST | MGLS_DEPTHWRITE);
    glDepthFunc(GL_LESS);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);

    glCullFace(GL_BACK);
    glEnable(GL_CULL_FACE); 
    glEnable(GL_NORMALIZE); 

    DisableGLState(MGLS_STENCILTEST);

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    EnableGLState(MGLS_BLEND);

    //Setup VSync
    if (m_capabilities.vsync)
        wglSwapIntervalEXT(PREFSMAN->GetValueB( "Rendering", "VSync", true, true ));        //VSYNC - currently always true.

    if (m_capabilities.pointsprite)
        glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, true  );

    glGetIntegerv(GL_MAX_LIGHTS, &m_maxLights);
    LOG.Info(ssprintf("Max number of lights: %d", m_maxLights));

    glGetIntegerv(GL_MAX_TEXTURE_UNITS, &m_maxTextures);
    LOG.Info(ssprintf("Max number of textures: %d", m_maxTextures));

    if (supportAnisotrophy)
    {
        glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &m_maxAnisotropy);
        LOG.Info(ssprintf("Max anisotrophy: %d", m_maxAnisotropy));
    }

    //2.0 gets
    glGetIntegerv(GL_MAX_DRAW_BUFFERS, &m_maxDrawBuffers);
    LOG.Info(ssprintf("Max number of draw buffers: %d", m_maxDrawBuffers));
    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &m_maxVertexAttributes);
    LOG.Info(ssprintf("Max number of vertex attributes: %d", m_maxVertexAttributes));
    glGetIntegerv(GL_MAX_TEXTURE_COORDS, &m_maxTextureCoordinates);
    LOG.Info(ssprintf("Max number of texture coords: %d", m_maxTextureCoordinates));
    glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &m_maxShaderVertUniformComponents);
    LOG.Info(ssprintf("Max number of vert uniform components: %d", m_maxShaderVertUniformComponents));
    glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &m_maxShaderFragUniformComponents);
    LOG.Info(ssprintf("Max number of frag uniform components: %d", m_maxShaderFragUniformComponents));
    MString glslver;
    const char* g = (char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
    if( g )
        glslver = g;
    else
        glslver = "NO GLSL Available.";
    LOG.Info("GLSL version: " + glslver);

    //If we don't have full GLSlang, don't even try to do pixel shaders
    if( !m_capabilities.glsl )
        DisableGLState(MGLS_SHADER);

    isRenderingToDynamicTexture = false;
    isRenderingToDynamicCubeMap = false;
    isLockRendering = false;

    MercuryGLState gls;
    gls.Enable(MGLS_ALL);
    SetStates(gls);

    return true;
}


void MercuryOGL::RendererInfo()
{
    LOG.Info(ssprintf("Vendor:%s", glGetString(GL_VENDOR)));
    LOG.Info(ssprintf("Render:%s", glGetString(GL_RENDERER)));
    LOG.Info(ssprintf("Version:%s", glGetString(GL_VERSION)));
    LOG.Info(ssprintf("Extensions:%s", glGetString(GL_EXTENSIONS)));
}

bool MercuryOGL::MakeWindow(const char* title, int width, int height, int bits, bool fullscreenflag)
{
    if (m_window == NULL)
    {
        LOG.Warn( "No window to create self in!" );
        return false;
    }

    if (!m_window->MakeRender(title, width, height, bits, fullscreenflag, RT_OGL))
    {
        LOG.Warn( "Failed to make Renderer" );
        m_window->DestroyWindowAndRender();
        return false;
    }

    MercuryDisplay::MakeWindow(title, width, height, bits, fullscreenflag);

    return true;
}

bool MercuryOGL::BeginFrame()
{
    glClear(GL_COLOR_BUFFER_BIT*GetGlobalState().GetState(MGLS_CLEARFRAME) | GL_DEPTH_BUFFER_BIT);
    return true;
}

bool MercuryOGL::EndFrame()
{
    ErrorCheck();
//  glFlush(); //Finish the scene before the swap
//  glFinish();  //For right now it would seem we actually need this prevent flicker
    m_window->SwapBuffers();
    ++m_framesDrawn;
    return true;
}

void MercuryOGL::DrawMesh(const MercuryMesh& mesh)
{
    static const int offset = sizeof(MercuryVertex);
    int tai = (glGetAttribLocationARB)?(m_shaderProgramID!=-1)?glGetAttribLocationARB( m_shaderProgramID, "tangent" ):-1:-1;
    int bai = (glGetAttribLocationARB)?(m_shaderProgramID!=-1)?glGetAttribLocationARB( m_shaderProgramID, "binormal" ):-1:-1; 
    float* VerticeArray = (float*)mesh.GetVerticePtr();
    float* TangentArray = mesh.HasTangents() && (tai>=0) ? (float*)mesh.GetTangentsPtr() : NULL;
    float* BinormalArray = mesh.HasBinormals() && (bai>=0) ? (float*)mesh.GetBinormalsPtr() : NULL;
    const MercuryMaterial* mat = mesh.GetMaterial();
    bool isVBOinited = (mesh.GetCore()!=NULL)?mesh.GetCore()->m_VBOinited:false;

    glBindBufferARB(GL_ARRAY_BUFFER_ARB, (unsigned int)mesh.GetVerticesVBO() * isVBOinited);

    if ( mat )
    {
        int texUnit = GL_TEXTURE0_ARB;
        for (unsigned int i = 0; i < mat->NumTextures(); ++i)
        {   
            glActiveTextureARBm(texUnit);
            glClientActiveTextureARBm(texUnit);
            if (isVBOinited)
                glTexCoordPointer(2, GL_FLOAT, offset, BUFFER_OFFSET(sizeof(float)*0));
            else
                glTexCoordPointer(2, GL_FLOAT, offset, VerticeArray);

            ++texUnit;
        }
    }

    if (isVBOinited)
    {
        glNormalPointer(GL_FLOAT, offset, BUFFER_OFFSET(sizeof(float)*2));
        glVertexPointer(3, GL_FLOAT, offset, BUFFER_OFFSET(sizeof(float)*5));
    }
    else
    {
        glNormalPointer(GL_FLOAT, offset, &VerticeArray[2]);
        glVertexPointer(3, GL_FLOAT, offset, &VerticeArray[5]);
    }

    if ( TangentArray )
    {
        glEnableVertexAttribArrayARB(tai);
        if (isVBOinited)
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, (unsigned int)mesh.GetTangentVBO());
        glVertexAttribPointerARB(tai, 3, GL_FLOAT, false, 0, isVBOinited?0:TangentArray);
    }

    if ( BinormalArray )
    {
        glEnableVertexAttribArrayARB(bai);
        if (isVBOinited)
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, (unsigned int)mesh.GetBinormalVBO());
        glVertexAttribPointerARB(bai, 3, GL_FLOAT, false, 0, isVBOinited?0:BinormalArray);
    }

    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mesh.GetIndicesVBO()*isVBOinited);

    unsigned int lightIndex = 0;
    int tmp = Next3Lights(m_usedLights, lightIndex);
    ProcessLightsInternal(m_usedLights, 3);

    glDrawElements( ConvertDrawType(mesh.GetDrawType()), mesh.NumIndices(), GL_UNSIGNED_INT, isVBOinited?0:mesh.GetIndicesPtr() );

    if (tmp > 0)
    {
        glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glEnable(GL_BLEND);
        glBlendFunc(GL_ONE, GL_ONE);
        glDepthFunc(GL_LEQUAL);
        float e[4];
        e[0] = e[1] = e[2] = e[3] = 0.0f;
        glMaterialfv( GL_FRONT, GL_EMISSION, e ); // XXX hack turn off emission on multiple passes
        while(tmp > 0)
        {
            tmp = Next3Lights(m_usedLights, lightIndex);
            ProcessLightsInternal(m_usedLights, 3);
            glDrawElements( ConvertDrawType(mesh.GetDrawType()), mesh.NumIndices(), GL_UNSIGNED_INT, isVBOinited?0:mesh.GetIndicesPtr() );
        }
        glPopAttrib();
    }

    m_verticesDrawn += mesh.NumIndices();

    if ( TangentArray )
        glDisableVertexAttribArrayARB(tai);

    if ( BinormalArray )
        glDisableVertexAttribArrayARB(bai);

    ErrorCheck();
}

void MercuryOGL::GenerateVBO(MercuryMesh& mesh)
{
    unsigned int buffers[4];
    unsigned int count = 2;

    if (mesh.HasTangents())
        ++count;
    if (mesh.HasBinormals())
        ++count;

    glGenBuffersARB(count, buffers);

    //vertices VBO
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffers[0]);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(MercuryVertex)*mesh.NumVertices(), mesh.GetVerticePtr(), GL_STATIC_DRAW_ARB);
    mesh.SetVerticesVBO((MVPtr)buffers[0]);

    //indices VBO
    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buffers[1]);
    glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(unsigned int)*mesh.NumIndices(), mesh.GetIndicesPtr(), GL_STATIC_DRAW_ARB);
    mesh.SetIndicesVBO((MVPtr)buffers[1]);

    //tangent VBO
    if (mesh.HasTangents())
    {
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffers[2]);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(MercuryPoint)*mesh.NumTangents(), mesh.GetTangentsPtr(), GL_STATIC_DRAW_ARB);
        mesh.SetTangentVBO((MVPtr)buffers[2]);
    }

    //binormal VBO
    if (mesh.HasBinormals())
    {
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffers[3]);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(MercuryPoint)*mesh.NumBinormals(), mesh.GetBinormalsPtr(), GL_STATIC_DRAW_ARB);
        mesh.SetBinormalVBO((MVPtr)buffers[3]);
    }

    glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}

void MercuryOGL::DestroyVBO(MercuryMesh& mesh)
{
    unsigned int v, t, b, i;
    v = (unsigned int)mesh.GetVerticesVBO();
    t = (unsigned int)mesh.GetTangentVBO();
    b = (unsigned int)mesh.GetBinormalVBO();
    i = (unsigned int)mesh.GetIndicesVBO();

    glDeleteBuffersARB(1, &v);
    mesh.SetVerticesVBO((MVPtr)NULL);

    if (mesh.HasTangents())
    {
        glDeleteBuffersARB(1, &t);
        mesh.SetTangentVBO((MVPtr)NULL);
    }

    if (mesh.HasBinormals())
    {
        glDeleteBuffersARB(1, &b);
        mesh.SetBinormalVBO((MVPtr)NULL);
    }

    glDeleteBuffersARB(1, &i);
    mesh.SetIndicesVBO((MVPtr)NULL);
}


int MercuryOGL::CompileShader(MString vertStr, MString fragStr)
{
    if( !GetGlobalState().GetState(MGLS_SHADER) )
        return -1;
    int programObj;
    int vertexShader;
    char *tmpString = NULL;
    int stringLength = 0;
    const char* vertexShaderStrings[1];
    const char* fragmentShaderStrings[1];
    GLint bVertCompiled;
    GLint bFragCompiled;
    GLint bLinked;

    //glShaderSourceARB requires **
    vertexShaderStrings[0] = vertStr.c_str();
    vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );
    glShaderSourceARB( vertexShader, 1, vertexShaderStrings, NULL );
    glCompileShaderARB( vertexShader );


    glGetObjectParameterivARB( vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled );
    glGetObjectParameterivARB( vertexShader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &stringLength );
    if ( stringLength > 1 )
    {
        tmpString = new char[stringLength];
        glGetInfoLogARB( vertexShader, stringLength, NULL, tmpString );
        LOG.Info( MString("SGLLang Vertex Shader Compile Log:") + tmpString );
        SAFE_DELETE( tmpString );
    }

    int fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
    fragmentShaderStrings[0] = (char*)fragStr.c_str();
    glShaderSourceARB( fragmentShader, 1, fragmentShaderStrings, NULL );
    glCompileShaderARB( fragmentShader );

    glGetObjectParameterivARB( fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled );
    glGetObjectParameterivARB( fragmentShader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &stringLength );
    if ( stringLength > 1 )
    {
        tmpString = new char[stringLength];
        glGetInfoLogARB( fragmentShader, stringLength, NULL, tmpString );
        LOG.Info(MString("SGLLang Fragment Shader Compile Log:") + tmpString);
        SAFE_DELETE( tmpString );
    }

    programObj = glCreateProgramObjectARB();
    glAttachObjectARB( programObj, vertexShader );
    glAttachObjectARB( programObj, fragmentShader );

    //
    // Link the program object and print out the info log...
    //
    glLinkProgramARB( programObj );
    glGetObjectParameterivARB( programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked );
    glGetObjectParameterivARB( programObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &stringLength );
    if ( stringLength > 1 )
    {
        tmpString = new char[stringLength];
        glGetInfoLogARB( programObj, stringLength, NULL, tmpString );
        LOG.Info(MString("SGLLang Linker Log:") + tmpString);
        SAFE_DELETE( tmpString );
    }

    return programObj;
}

void MercuryOGL::DestroyShaderProgram(int shaderID)
{
    int count = 0;
    unsigned int *objects = NULL;
    glGetObjectParameterivARB(shaderID, GL_OBJECT_ATTACHED_OBJECTS_ARB, &count);
    if (count > 0)
    {
        objects = new unsigned int[count];
        glGetAttachedObjectsARB(shaderID, count, NULL, objects);
        for (unsigned int i = 0; i < count; ++i)
        {
            glDetachObjectARB(shaderID, objects[i]);
            glDeleteObjectARB(objects[i]);
        }   
    }
    glDeleteObjectARB(shaderID);
    SAFE_DELETE(objects);
}

void MercuryOGL::CompileShader(unsigned int shaderDesc)
{
    if( GetGlobalState().GetState(MGLS_SHADER) == 0 )
        return;
    int programObj;
    MString vertStr;
    MString fragStr;

    vertStr = ComposeGLSLangVertexshader(shaderDesc).c_str();
    fragStr = ComposeGLSLangPixelshader (shaderDesc).c_str();

    programObj = CompileShader (vertStr, fragStr);

    m_shaderObjMap[shaderDesc].id = programObj;

    //-----------------
    m_shaderObjMap[shaderDesc].primaryTexture = glGetUniformLocationARB( programObj, "regTexSampler2D" );
}

void MercuryOGL::DrawParticleField(const MercuryParticleField* field)
{
//  bool lUseLight = m_useLights;
//  m_useLights = false;


    unsigned int lightIndex = 0;
    int tmp = Next3Lights(m_usedLights, lightIndex);
    ProcessLightsInternal(m_usedLights, 3);
    FOREACH_CONST_Object(field->m_objects, o)
    {
        SetMaterial( &o->pObject->GetFinalMaterial() );
        o->pObject->Draw();
    }
}

void MercuryOGL::SetMaterial(const MercuryMaterial* material)
{
    /*  Passing pointers to classes (or floats) into openGL is very flaky. Sometimes it
        will work just fine, other times it will not. Classes must be aligned to 16 for
        casting to function correctly. */

    if (!m_useMaterialColors)
        return;

    //This is good measure, in general for if the lighting is turned off
    glColor4fv( material->m_diffuse );

    glMaterialfv( GL_FRONT, GL_AMBIENT, material->m_ambient );
    glMaterialfv( GL_FRONT, GL_DIFFUSE, material->m_diffuse );
    glMaterialfv( GL_FRONT, GL_SPECULAR, material->m_specular );
    glMaterialfv( GL_FRONT, GL_EMISSION, material->m_emissive );

    glMaterialf( GL_FRONT, GL_SHININESS, material->m_shininess );
}

void MercuryOGL::SetUniformVariables( MercuryMaterial* material )
{
    //set shader variables
    if ( (m_shaderProgramID != -1) && m_currentState.GetState(MGLS_SHADER) )
    {
        int uniform_location;

        uniform_location = glGetUniformLocationARB(m_shaderProgramID, "eye");
        if ( uniform_location != -1 )
            glUniform3fARB(uniform_location, m_pLastCameraPos.x, m_pLastCameraPos.y, m_pLastCameraPos.z);

        uniform_location = glGetUniformLocationARB(m_shaderProgramID, "NumEnabledLights");
        if ( uniform_location != -1 )
            glUniform1iARB(uniform_location, m_NumEnabledLights);

        uniform_location = glGetUniformLocationARB(m_shaderProgramID, "zNear" );
        if ( uniform_location != -1 )
            glUniform1fARB(uniform_location, m_projection.m_frustumInfo.m_znear );

        uniform_location = glGetUniformLocationARB(m_shaderProgramID, "zFar" );
        if ( uniform_location != -1 )
            glUniform1fARB(uniform_location, m_projection.m_frustumInfo.m_zfar );

        for( unsigned i = 0; i < material->m_vUniformNames.size(); i++ )
        {
            PStack & psu = material->m_vUniformValues[i];
            if( psu.GetSize() == 0 )
                continue;
            uniform_location = glGetUniformLocationARB(m_shaderProgramID, material->m_vUniformNames[i] );
            if ( uniform_location != -1 )
            {
                if( psu[0].GetType() == PSElement::FLOAT )
                {
                    switch( psu.GetSize() )
                    {
                    case 1: glUniform1fARB(uniform_location, psu[0].GetValueF() ); break;
                    case 2: glUniform2fARB(uniform_location, psu[0].GetValueF(),psu[1].GetValueF() ); break;
                    case 3: glUniform3fARB(uniform_location, psu[0].GetValueF(),psu[1].GetValueF(),psu[2].GetValueF() ); break;
                    case 4: glUniform4fARB(uniform_location, psu[0].GetValueF(),psu[1].GetValueF(),psu[2].GetValueF(),psu[3].GetValueF() ); break;
                    }
                } else
                {
                    switch( psu.GetSize() )
                    {
                    case 1: glUniform1iARB(uniform_location, psu[0].GetValueI() ); break;
                    case 2: glUniform2iARB(uniform_location, psu[0].GetValueI(),psu[1].GetValueI() ); break;
                    case 3: glUniform3iARB(uniform_location, psu[0].GetValueI(),psu[1].GetValueI(),psu[2].GetValueI() ); break;
                    case 4: glUniform4iARB(uniform_location, psu[0].GetValueI(),psu[1].GetValueI(),psu[2].GetValueI(),psu[3].GetValueI() ); break;
                    }
                }
            }
        }
    }
}

void MercuryOGL::EnableShaders(MercuryMaterial* material)
{
    //Check to see if the material needs to be pixel shaded.
    int shaderID = material?material->GetShaderID():-1;
    if( !(m_currentState.GetState(MGLS_SHADER) && ( shaderID != -1 ))  )
    {
        BindShader(-1);
        return;
    }
    
    //Turn the pixelshader on
    BindShader(shaderID);
    SetUniformVariables( material );
}

void MercuryOGL::EnableTextures(MercuryMaterial* material)
{
    static int texUnit;
    static int texNum;
    static MercuryMatrix tfm;
    int sid = material?material->GetShaderID():-1;

    texUnit = GL_TEXTURE0_ARB;
    for (int i = 0; i < m_maxTextures; ++i)
    {       
        MercuryTexture* t;

        glActiveTextureARBm(texUnit);
        glClientActiveTextureARBm(texUnit);
        
        if (material!=NULL?(i < material->NumTextures()) && !m_disableTextures:false)
        {
            t =  material->EditTexture(i);
            const ImageAttrs& iA = t->GetImageAttributes();
            
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
            if (iA.m_cube)
                glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, iA.m_ID);
            else
                glBindTexture(GL_TEXTURE_2D, iA.m_ID);
        
            //Bind some GLSL variables to GL texel units
            // GL texel 0 will be Texel0, GL texel 1 will be Texel1, and so on in GLSL
            // fixed functionality textures don't need to be enabled or disabled with shaders
            if ( (sid != -1) && m_currentState.GetState(MGLS_SHADER))
            {
                int uniform_location = glGetUniformLocationARB(sid, ssprintf("Texel%d", i));
                glUniform1iARB(uniform_location, i);
            }
            else if ( t )
            {
                if (material->GetTexture(i)->GetMapping() != CUBE)
                    glEnable(GL_TEXTURE_2D);
                else
                    glEnable(GL_TEXTURE_CUBE_MAP_ARB);
            
                ProcessTexture(material->EditTexture(i));
            }
        
            if (t)
            {
                t->Prerender();
                tfm = t->GetFinalMatrix();
                tfm.Transpose();
                glMatrixMode( GL_TEXTURE );
                glLoadMatrixf( tfm.Ptr() );
                ++texUnit;
            }
        }
        else
        {
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
            glBindTexture(GL_TEXTURE_2D, 0);
            glDisable(GL_TEXTURE_2D);
            glDisable(GL_TEXTURE_CUBE_MAP_ARB);
        }
    }
}

void MercuryOGL::ProcessTexture(MercuryTexture* texture)
{
    const ImageAttrs& iA = texture->GetImageAttributes();
    const TextureAttrs& tA = texture->GetAttributes();

    //It might be a good idea to just make display take the type of mapping
    //and set whatever attibutes it wants.
    switch(tA.m_mapping)
    {
    case CUBE:
        glDisable(GL_TEXTURE_GEN_S);
        glDisable(GL_TEXTURE_GEN_T);
        glDisable(GL_TEXTURE_GEN_R);
        break;
    case SPHERE:
        glEnable(GL_TEXTURE_GEN_S);
        glEnable(GL_TEXTURE_GEN_T);
        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
        break;
    default:
        glDisable(GL_TEXTURE_GEN_S);
        glDisable(GL_TEXTURE_GEN_T);
        break;
    }

    if (tA.m_mapping != CUBE)
    {
        //Bitwise to figure out how to handle UV map modes
        if (tA.m_mapMode & 1) // 0001
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        else
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        if (tA.m_mapMode & 2) //0010
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        else
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        if (tA.m_magFilter == NEAREST)
            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
        else
            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    }
    else
    {
        //Bitwise to figure out how to handle UV map modes
        if (tA.m_mapMode & 1) // 0001
            glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_REPEAT);
        else
            glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        if (tA.m_mapMode & 2) //0010
            glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_REPEAT);
        else
            glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        if (tA.m_magFilter == NEAREST)
            glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
        else
            glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    }

    switch (tA.m_blendMode)
    {
    case BLEND:
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
        glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, texture->GetFinalMaterial().m_diffuse);
        break;
    case MODULATE:
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        break;
    case DECAL:
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        break;
    case REPLACE:
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        break;
    case ADD:
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
        break;
    case COMBINE:
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
        break;
    };
}

void MercuryOGL::DeleteTextures(int n, unsigned int* textureNames)
{
    //delete all hanging frame buffer objects BEFORE we kill the
    if (mercuryIsSupportFrameBufferObjectEXT)
    {
        unsigned int i;
        unsigned int j;

        for (i = 0; i < n; i++)
        {
            //if textureNames[i] is in the fboMap hash table
            if (m_fboMap.find(textureNames[i]) != m_fboMap.end())
            {
                //then delete the FBO for colorID
                //and delete the  RBO for depthID
                glDeleteFramebuffersEXT ( 1, &m_fboMap[textureNames[i]].colorID );
                glDeleteRenderbuffersEXT( 1, &m_fboMap[textureNames[i]].depthID );
            }

            //if textureNames[i] is in the fboMap hash table
            if (m_fboCubeMap.find(textureNames[i]) != m_fboCubeMap.end())
            {
                for (j = 0; j < 1; j++)
                {
                    //then delete the FBO for colorID
                    //and delete the  RBO for depthID
                    glDeleteFramebuffersEXT ( 1, &m_fboCubeMap[textureNames[i]].colorID[j] );
                    glDeleteRenderbuffersEXT( 1, &m_fboCubeMap[textureNames[i]].depthID[j] );
                }
            }
        }
    }

    glDeleteTextures(n, textureNames);
}

void MercuryOGL::CreateCache(RawImageData* data, unsigned int& ID)
{
    CreateCache(data, ID, true);
}

void MercuryOGL::CreateCache(RawImageData* data, unsigned int& ID, bool isMipmap)
{
    glGenTextures(1, &ID);                  // Create The Texture

    // Typical Texture Generation Using Data From The Bitmap
    glBindTexture(GL_TEXTURE_2D, ID);
    LoadImageData(data, isMipmap);
}

void MercuryOGL::LoadImageData(RawImageData* data, bool isMipmap)
{
    RawImageData* rdata1 = data;
    RawImageData* rdata2 = NULL;
    // Generate The Texture
    unsigned int i = 0; 

    //For now, cube maps use linear filtering
    if (data->attrs.m_cube)
        isMipmap = false;

    //Mipmaps use this little loop for mipmaps
    if (isMipmap)
    {
        while (true)
        {
            switch (data->attrs.m_ColorByteType)
            {
            case RGB:
                glTexImage2D(GL_TEXTURE_2D, i, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data);
                break;
            case RGBA:
                glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                            0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data);
                break;
            case LUMINANCE_ALPHA:
                glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                            0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data);
                break;
            default:
        //      LOG.Warn(texture->GetPath() + " has and invalid color byte type.");
                break;
            }
            
            rdata2 = new RawImageData;

            if ((rdata1->attrs.m_height > 1) || (rdata1->attrs.m_width > 1))
                CaclulateDiv2Texture(*rdata1, *rdata2);
            else
                break;

            if (rdata1 != data)
                SAFE_DELETE(rdata1);

            rdata1 = rdata2;
            rdata2 = NULL;
            ++i;
        }

        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);   // Linear Filtering

        if (supportAnisotrophy)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                    PREFSMAN->GetValueI("Rendering", "Anisotrophy", 1, true));

        SAFE_DELETE(rdata1);
    }
    else
    {
        if (!data->attrs.m_cube)
        {
            //non mipmaps don't have mipmaps
            switch (data->attrs.m_ColorByteType)
            {
            case RGB:
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data);
                break;
            case RGBA:
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                            0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data);
                break;
            case LUMINANCE_ALPHA:
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                            0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data);
                break;
            default:
        //      LOG.Warn(texture->GetPath() + " has and invalid color byte type.");
                break;
            }

            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
        }
        else
        {
            unsigned int faceLength = data->attrs.m_width * data->attrs.m_height * ColorBytesToSize(data->attrs.m_ColorByteType);
//          faceLength = 0;

            printf ("pdata = %lu\nfaceLength = %lu\nwidth = %lu\nheight = %lu\ncolorbytes = %lu\n", rdata1->data, faceLength, data->attrs.m_width, data->attrs.m_height, (unsigned int)(ColorBytesToSize(data->attrs.m_ColorByteType)));

            //non mipmaps don't have mipmaps
            switch (data->attrs.m_ColorByteType)
            {
            case RGB:
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data + faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data + 2*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data + 3*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data + 4*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0, GL_RGB, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGB, GL_UNSIGNED_BYTE, rdata1->data + 5*faceLength);
                break;
            case RGBA:
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data + faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data + 2*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data + 3*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data + 4*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_RGBA, GL_UNSIGNED_BYTE, rdata1->data + 5*faceLength);
                break;
            case LUMINANCE_ALPHA:
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data + faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data + 2*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data + 3*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data + 4*faceLength);
                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0, GL_RGBA, rdata1->attrs.m_width, rdata1->attrs.m_height,
                    0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, rdata1->data + 5*faceLength);
                break;
            default:
        //      LOG.Warn(TEXTURE->GetPath() + " has and invalid color byte type.");
                break;
            }

            glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB,GL_TEXTURE_MIN_FILTER,GL_LINEAR);   // Linear Filtering
        }
    }
}

void MercuryOGL::ProcessLightsInternal( const MercuryLight* light[3], unsigned int count )
{
    static Attenuation atten; //Attenuation Type
    static unsigned int AT;
    static float fLightPos[4];
    static unsigned int LID;
    static MercuryMatrix tmpView;

    m_NumEnabledLights = 0;
    LID = GL_LIGHT0;

    if (m_currentState.GetState(MGLS_LIGHTING))
    {
        //Use a transposed viewstack (from LookAt) to set static lights
        tmpView = m_view;
        tmpView.Transpose();
        glMatrixMode( GL_MODELVIEW );
        glPushMatrix();
        glLoadMatrixf( tmpView.Ptr() );

        for (unsigned int i = 0; i < count; ++i)
        {
            if (!light[i])
            {
                glDisable(LID);
                continue;
            }

            const MercuryMaterial& m = light[i]->GetFinalMaterial();

            light[i]->GetPosition().ConvertToVector3(fLightPos);
            fLightPos[3] = (float)light[i]->GetLightType();

            //If a light is not static, load it into the global space
            if (!light[i]->IsStatic())
            {
                glPushMatrix();
                glLoadIdentity();
            }

            glLightfv(LID, GL_POSITION, fLightPos);
            glLightfv(LID, GL_AMBIENT, m.m_ambient);
            glLightfv(LID, GL_DIFFUSE, m.m_diffuse);
            glLightfv(LID, GL_SPECULAR, m.m_specular);

            //OpenGL does do multiple attenuations per light
            for (unsigned int j = 0; j < 3; ++j)
            {
                atten = light[i]->GetAttenuation((Attenuation::Type)j);
                switch (atten.type)
                {
                case Attenuation::CONSTANT:
                    AT = GL_CONSTANT_ATTENUATION;
                    break;
                case Attenuation::LINEAR:
                    AT = GL_LINEAR_ATTENUATION;
                    break;
                case Attenuation::QUADRATIC:
                    AT = GL_QUADRATIC_ATTENUATION;
                    break;
                }
                glLightf(LID, AT, atten.value);
            }
            glEnable(LID);
            ++m_NumEnabledLights;

            if (!light[i]->IsStatic())
                glPopMatrix();

            ++LID;
        }

        glPopMatrix();
    }

    if (m_shaderProgramID != -1)
    {
        int uniform_location = glGetUniformLocationARB(m_shaderProgramID, "NumEnabledLights");
        if ( uniform_location != -1 )
            glUniform1iARB(uniform_location, m_NumEnabledLights);
    }
}

void MercuryOGL::ErrorCheck()
{
    static int error;
    while ((error = glGetError()) != GL_NO_ERROR)
        if( error != 1282 ) //Light warning; don't worry about it. (remove this when debugging lights)
            LOG.Warn(ssprintf("OGL Error: %d", error));
}

void MercuryOGL::ReadFrameBuffer(RawImageData& image)
{
    image.attrs.m_ColorByteType = RGB;
    image.attrs.m_dpi_x = 72;
    image.attrs.m_dpi_y = 72;
    image.attrs.m_height = m_window->GetHeight();
    image.attrs.m_width = m_window->GetWidth();
    image.data = new unsigned char[image.attrs.m_height * image.attrs.m_width * 3];
    glReadPixels(0,0, image.attrs.m_width, image.attrs.m_height, GL_RGB, GL_UNSIGNED_BYTE, image.data);
}

void MercuryOGL::SendMatrixData(const MercuryMatrix& m)
{
    static MercuryMatrix modelView;

    modelView = m_view * m;
    modelView.Transpose();

    glMatrixMode( GL_MODELVIEW );
    glLoadMatrixf( modelView.Ptr() );
}

void MercuryOGL::SendProjectionMatrixData()
{
    static MercuryMatrix projection;

    projection = GetProjection();
    projection.Transpose();

    glMatrixMode( GL_PROJECTION );
    glLoadMatrixf( projection.Ptr() );
};


int MercuryOGL::ConvertDrawType(DRAWTYPES drawtype)
{
    switch(drawtype)
    {
    case MGL_TRIANGLE:
        return GL_TRIANGLES;
    case MGL_QUAD:
        return GL_QUADS;
    case MGL_POINT:
        return GL_POINT;
    default:
        ASSERT(drawtype != MGL_INVALID);
    };
    //will never get here
    return -1;
}

void MercuryOGL::StencilOp(STENCILOPS fail, STENCILOPS zfail, STENCILOPS zpass)
{
    glStencilOp( ConvertStencilOp(fail),
                ConvertStencilOp(zfail),
                ConvertStencilOp(zpass) );
}

int MercuryOGL::ConvertStencilOp(STENCILOPS op) const
{
    switch (op)
    {
    case SO_KEEP:
        return GL_KEEP;
    case S0_ZERO:
        return GL_ZERO;
    case S0_REPLACE:
        return GL_REPLACE;
    case SO_INCR:
        return GL_INCR;
    case SO_DECR:
        return GL_DECR;
    case SO_INVERT:
        return GL_INVERT;
    }
    return 0; //never get here
}

void MercuryOGL::CullBackface(bool toggle)
{
    if (toggle)
        glCullFace(GL_BACK);
    else
        glCullFace(GL_FRONT);
}

void MercuryOGL::StencilFunc(TFUNCT func, int ref, unsigned int zref)
{
    glStencilFunc(ConvertTestFunction(func), ref, zref);
}

int MercuryOGL::ConvertTestFunction(TFUNCT funct) const
{
    switch(funct)
    {
    case TF_NEVER:
        return GL_NEVER;
    case TF_LESS:
        return GL_LESS;
    case TF_LEQUAL:
        return GL_LEQUAL;
    case TF_GREATER:
        return GL_GREATER;
    case TF_GEQUAL:
        return GL_GEQUAL;
    case TF_EQUAL:
        return GL_EQUAL;
    case TF_NOTEQUAL:
        return GL_NOTEQUAL;
    case TF_ALWAYS:
        return GL_ALWAYS;
    }
    return 0; //never get here
}

void MercuryOGL::DefineClippingPlanes(const MVector<MQuaternion>& planes)
{
    static int max;
    static int glcplane;
    static double plane[4];
    static const MVector<MQuaternion>* lastPlaneConfig = NULL;

    //save time if we constantly set to the same thing
    if (lastPlaneConfig == &planes)
        return;

    lastPlaneConfig = &planes;
    max = planes.size();
    glcplane = GL_CLIP_PLANE0;

    //if there are no clipping planes, leave as it
    //tries to inherit from parent settings
    if (max <= 0)
        return;

    for (int i = 0; i < 6; ++i)
    {
        if (i < max)
        {
            plane[0] = planes[i].w;
            plane[1] = planes[i].x;
            plane[2] = planes[i].y;
            plane[3] = planes[i].z;
            glEnable(glcplane);
            glClipPlane(glcplane, plane);
        }
        else
        {
            glDisable(glcplane);
        }
        ++glcplane;
    }
}

void MercuryOGL::RenderTranslucentObject()
{
    PushGLState();
    glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDepthMask(false);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    while (!m_translucentObjects.empty())
    {
        m_translucentObjects.front().obj->CustomRender();
        m_translucentObjects.pop_front();
    }
    glPopAttrib();
    PopGLState();
}

void MercuryOGL::TestCapabilities()
{
    m_capabilities.glsl = glCreateProgramObjectARB && glDeleteObjectARB && glUseProgramObjectARB &&
                            glCreateShaderObjectARB && glShaderSourceARB && glCompileShaderARB &&
                            glGetObjectParameterivARB && glAttachObjectARB && glGetInfoLogARB &&
                            glGetInfoLogARB && glLinkProgramARB && glLinkProgramARB && 
                            glGetUniformLocationARB && glUniform4fARB && glUniform1iARB;

    m_capabilities.multittexture = glMultiTexCoord1fARBm && glMultiTexCoord2fARBm && glMultiTexCoord3fARBm &&
        glMultiTexCoord4fARBm && glActiveTextureARBm && glClientActiveTextureARBm;
    ASSERT(m_capabilities.multittexture);

    m_capabilities.pointsprite = glPointParameterfARB && glPointParameterfvARB;

    m_capabilities.vbo = glBindBufferARB && glGenBuffersARB && glBufferDataARB;

    m_capabilities.vsync = wglSwapIntervalEXT != 0;
}

void MercuryOGL::RenderText(const MercuryText& text)
{
    MercuryPoint v;
    int tid = text.GetGlyphData()->textureData.GetID();
//  const MVector<MercuryTextChar*> chars = text.GetCharacters();
    unsigned int size = text.NumCharacters();

    glPushAttrib(GL_ENABLE_BIT | GL_TEXTURE_BIT);

    glActiveTextureARBm(GL_TEXTURE0_ARB);
    glClientActiveTextureARBm(GL_TEXTURE0_ARB);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, tid );

    //Turn off any coordinate generation
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_T);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    glMatrixMode( GL_TEXTURE );
    glPushMatrix();
    glLoadIdentity();
//  glMatrixMode( GL_MODELVIEW );

    glBegin(GL_QUADS);
    for( unsigned int i = 0; i < size; ++i )
    {
        const MercuryTextChar& c = *text.GetCharacter(i);

        glTexCoord2fv( c.vertices[0].m_uv );
        v.x = c.vertices[0].x + c.position.x;
        v.y = c.vertices[0].y + c.position.y;
        v.z = c.vertices[0].z + c.position.z;
        glVertex3fv( v );

        glTexCoord2fv( c.vertices[1].m_uv );
        v.x = c.vertices[1].x + c.position.x;
        v.y = c.vertices[1].y + c.position.y;
        v.z = c.vertices[1].z + c.position.z;
        glVertex3fv( v );

        glTexCoord2fv( c.vertices[2].m_uv );
        v.x = c.vertices[2].x + c.position.x;
        v.y = c.vertices[2].y + c.position.y;
        v.z = c.vertices[2].z + c.position.z;
        glVertex3fv( v );

        glTexCoord2fv( c.vertices[3].m_uv );
        v.x = c.vertices[3].x + c.position.x;
        v.y = c.vertices[3].y + c.position.y;
        v.z = c.vertices[3].z + c.position.z;
        glVertex3fv( v );
    }
    glEnd();
    glPopMatrix();
    glPopAttrib();

//  glMatrixMode( GL_TEXTURE );
//  glDisable(GL_TEXTURE_2D);
}

void MercuryOGL::DrawSprite(const MercuryMesh& sprite)
{
    glBegin(GL_QUADS);
    glTexCoord2fv( sprite[0].m_uv );
    glNormal3fv(sprite[0].GetNormal());
    glVertex3fv( &(sprite[0].x) );

    glTexCoord2fv( sprite[1].m_uv );
    glNormal3fv(sprite[1].GetNormal());
    glVertex3fv( &(sprite[1].x) );

    glTexCoord2fv( sprite[2].m_uv );
    glNormal3fv(sprite[2].GetNormal());
    glVertex3fv( &(sprite[2].x) );

    glTexCoord2fv( sprite[3].m_uv );
    glNormal3fv(sprite[3].GetNormal());
    glVertex3fv( &(sprite[3].x) );
    glEnd();
    m_verticesDrawn += 4;
}

MercuryGLState MercuryOGL::SetStates(MercuryGLState states)
{
    MercuryGLState changedState = MercuryDisplay::SetStates(states);
    unsigned long changed = changedState.GetStates();

    if (!changed)
        return changedState;

    unsigned long current = m_currentState.GetStates();

    if (changed&MGLS_DEPTHWRITE)
        glDepthMask(current&MGLS_DEPTHWRITE);

    if (changed&MGLS_DEPTHTEST)
    {
        if(current&MGLS_DEPTHTEST)
            glEnable(GL_DEPTH_TEST);
        else
            glDisable(GL_DEPTH_TEST);
    }

    if (changed&MGLS_COLORWRITE)
    {
        bool cm = current&MGLS_COLORWRITE;
        glColorMask(cm, cm, cm, cm); //All the documentation says these are boolean values not floats
    }

    if (changed&MGLS_ALPHATEST)
    {
        if(current&MGLS_ALPHATEST)
            glEnable(GL_ALPHA_TEST);
        else
            glDisable(GL_ALPHA_TEST);
    }

    if (changed&MGLS_BLEND)
    {
        if (current&MGLS_BLEND)
            glEnable(GL_BLEND);
        else
            glDisable(GL_BLEND);
    }

    if (changed&MGLS_VERTEXARRAY)
    {
        if (current&MGLS_VERTEXARRAY)
            glEnableClientState(GL_VERTEX_ARRAY);
        else
            glDisableClientState(GL_VERTEX_ARRAY);
    }

    if (changed&MGLS_NORMALARRAY)
    {
        if (current&MGLS_NORMALARRAY)
            glEnableClientState(GL_NORMAL_ARRAY);
        else
            glDisableClientState(GL_NORMAL_ARRAY);
    }

    if (changed&MGLS_UVARRAY)
    {
    }

    if (changed&MGLS_TEXTURING)
    {
    }

    if (changed&MGLS_LIGHTING)
    {
        if (current&MGLS_LIGHTING)
            glEnable(GL_LIGHTING);
        else
            glDisable(GL_LIGHTING);
    }

    if (changed&MGLS_STENCILTEST)
    {
        if (current&MGLS_STENCILTEST)
            glEnable(GL_STENCIL_TEST);
        else
            glDisable(GL_STENCIL_TEST);
    }

    if (changed&MGLS_SHADER)
        if ( !m_currentState.GetState(MGLS_SHADER) )
            BindShader(-1);

    return changedState;
}

void MercuryOGL::BindShader(int shaderID)
{
    if (m_shaderProgramID != shaderID)
    {
        if (shaderID == -1)
            glUseProgramObjectARB(0);
        else
            glUseProgramObjectARB(shaderID);
    }
    m_shaderProgramID = shaderID;
}

/* 
 * Copyright (c) 2005-2006 Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by