CPPGPGPU Library - Reference (Doxygen)

---

Main Page | General Use | Reference | Examples Info | Get/Download CPPGPGPU | SF.net Page

---

OGLParts.cpp

Go to the documentation of this file.

#include "OGLParts.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <string>
using namespace std;

GLuint imTypes[6] = { GL_LUMINANCE8, GL_RGB, GL_RGBA, GL_RGBA16F_ARB, GL_RGBA32F_ARB, 0 };

//For things that require GL_RGBA when dealing with floating point data; usually when dealing with verticies or host data.
GLuint imXTypes[6] ={ GL_LUMINANCE, GL_RGB, GL_RGBA, GL_RGBA, GL_RGBA, 0 };
GLuint byTypes[6] = { GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE, GL_FLOAT, GL_FLOAT, 0 };

int OpenPPM( const char * sPPMName, unsigned char ** buffer, int * width, int * height );

void DestroyShaderProgram( GLhandleARB iProgramID )
{
    GLhandleARB *objects = NULL;
    GLint i, count = -1;

    if( !iProgramID )
        return;

    //If we can't destroy the object, then don't try.
    glGetObjectParameterivARB(iProgramID, GL_OBJECT_ATTACHED_OBJECTS_ARB, &count);

    //Iterate through all children.
    if (count > 0)
    {
        objects = (GLhandleARB *)malloc(count*sizeof(GLhandleARB));
        glGetAttachedObjectsARB(iProgramID, count, NULL, objects);
    }
    else
        return;

    for ( i = 0; i < count; ++i)
    {
        glDetachObjectARB(iProgramID, objects[i]);
    }

    glDeleteObjectARB(iProgramID);
    free( objects );
    return;
}

Shader::Shader()
{
    iProgramID = (GLhandleARB)NULL; 
    vertexShader = (GLhandleARB)NULL;
    fragmentShader = (GLhandleARB)NULL;
    geometryShader = (GLhandleARB)NULL;
    iTimeCode[0] = 0;
    iTimeCode[1] = 0;
    iTimeCode[2] = 0;
    bIsGLSLAsm = 0;
//  sOldFilename = ""; 
}

Shader::~Shader()
{
    DestroyShaderProgram( iProgramID );
}

void Shader::CheckForNewer( const char * sShaderName )
{
    unsigned long iCurTimes[3];
    GetTimeCodes( iCurTimes, sShaderName );
    if( iCurTimes[0] != iTimeCode[0] || iCurTimes[1] != iTimeCode[1] || iCurTimes[2] != iTimeCode[2] )
    {
        DestroyShaderProgram( iProgramID );
        LoadShader( sShaderName );
    }
}

void Shader::GetTimeCodes( unsigned long * iOut, const char * sShaderName  )
{
    struct stat sb;
    stat( (string(sShaderName)+".vert").c_str(), &sb );
    iOut[0] = sb.st_mtime;
    stat( (string(sShaderName)+".frag").c_str(), &sb );
    iOut[1] = sb.st_mtime;
    stat( (string(sShaderName)+".geom").c_str(), &sb );
    iOut[2] = sb.st_mtime;
}

bool Shader::LoadShader( const char * sShaderName )
{
    GetTimeCodes( iTimeCode, sShaderName );
    string s1 = sShaderName, s2 = sShaderName, s3 = sShaderName;
    FILE * f1;
    FILE * f2;
    FILE * f3; //geometry
    char * Buffer;
    int i;

    s1 += ".frag";
    s2 += ".vert";
    s3 += ".geom";
    f1 = fopen( (char*)s1.c_str(), "rb" );
    f2 = fopen( (char*)s2.c_str(), "rb" );
    f3 = fopen( (char*)s3.c_str(), "rb" );
    if( f1 == 0 || f2 == 0 )
    {
        if( !f1 )
            printf( "Could not open %s.\n", (char*)s1.c_str() );
        if( !f2 )
            printf( "Could not open %s.\n", (char*)s2.c_str() );
        return false;
    }
    if( f1 )
    {
        fseek( f1, 0, SEEK_END );
        i = ftell( f1 );
        fseek( f1, 0, SEEK_SET );
        Buffer = (char*)malloc( i+1 );
        fread( Buffer, 1, i, f1 );
        fclose( f1 );
        printf( "Compiling: %s\n", s1.c_str() );
        Buffer[i] = '\0';
        if( !LoadShaderFrag( Buffer ) )
        {
            free( Buffer );
            if( f2 )
                fclose( f2 );
            if( f3 )
                fclose( f3 );
            printf( "Reporting failed shaderload. Not linking.\n" );
            return false;
        }
        free( Buffer );
    }
    if( f2 )
    {
        fseek( f2, 0, SEEK_END );
        i = ftell( f2 );
        fseek( f2, 0, SEEK_SET );
        Buffer = (char*)malloc( i+1 );
        fread( Buffer, 1, i, f2 );
        fclose( f2 );
        Buffer[i] = '\0';
        printf( "Compiling: %s\n", s2.c_str() );
        if( !LoadShaderVert( Buffer ) )
        {
            if( f3 )
                fclose( f3 );
            free( Buffer );
            printf( "Reporting failed shaderload. Not linking.\n" );
            return false;
        }
        free( Buffer );
    }
    if( f3 )
    {
        fseek( f3, 0, SEEK_END );
        i = ftell( f3 );
        fseek( f3, 0, SEEK_SET );
        Buffer = (char*)malloc( i+1 );
        fread( Buffer, 1, i, f3 );
        fclose( f3 );
        Buffer[i] = '\0';
        printf( "Compiling: %s\n", s3.c_str() );
        if( !LoadShaderGeom( Buffer ) )
        {
            free( Buffer );
            printf( "Reporting failed shaderload. Not linking.\n" );
            return false;
        }
        free( Buffer );
    }
    return LinkShaders();
}

bool Shader::LoadShaderFrag( const char * sShaderCode )
{
    if( strlen( sShaderCode ) < 5 )
        return false;

    if( strncmp( sShaderCode, "!!ARB", 5 ) == 0 )
    {
        glGenProgramsARB( 1, &fragmentProgram );
        glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, fragmentProgram );
        glProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(sShaderCode), (GLubyte*)sShaderCode );
        if (glGetError() != GL_NO_ERROR)
        {
            puts( "ERROR Compiling ASM Fragment Shader Error follows:" );
            puts( (char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB) );
            return false;
        }
        bIsGLSLAsm = 1;
    }
    else
    {
        GLint bFragCompiled;
        GLint stringLength;
        fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
        glShaderSourceARB( fragmentShader, 1, &sShaderCode, NULL );
        glCompileShaderARB( fragmentShader );
    
        glGetObjectParameterivARB( fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled );
        glGetObjectParameterivARB( fragmentShader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &stringLength );
        if ( stringLength > 1 )
        {
            char * tmpstr = (char*)malloc( stringLength + 1 );
            glGetInfoLogARB( fragmentShader, stringLength, NULL, tmpstr );
            puts( "ERROR Compiling Fragment Shader Error follows:" );
            puts( tmpstr );
            free( tmpstr );
            return false;
        }
    }
    return true;
}

bool Shader::LoadShaderVert( const char * sShaderCode )
{
    if( strlen( sShaderCode ) < 5 )
        return false;

    if( strncmp( sShaderCode, "!!ARB", 5 ) == 0 )
    {
        glGenProgramsARB( 1, &vertexProgram );
        glBindProgramARB( GL_VERTEX_PROGRAM_ARB, vertexProgram );
        glProgramStringARB( GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(sShaderCode), (GLubyte*)sShaderCode );
        if (glGetError() != GL_NO_ERROR)
        {
            puts( "ERROR Compiling ASM Fragment Shader Error follows:" );
            puts( (char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB) );
            return false;
        }
        bIsGLSLAsm = 1;
    }
    else
    {
        GLint bVertCompiled;
        GLint stringLength;
        //Create a new vertex shader
        vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );
        //Bind the shader to the text, setting that to be its source.
        glShaderSourceARB( vertexShader, 1, &sShaderCode, NULL );
        //Compile the shader
        glCompileShaderARB( vertexShader );
        //Did the shader compile?  Were there any errors?
        glGetObjectParameterivARB( vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled );
        glGetObjectParameterivARB( vertexShader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &stringLength );
        if( stringLength > 1 )
        {
            char * tmpstr = (char*)malloc( stringLength + 1 );
            glGetInfoLogARB( vertexShader, stringLength, NULL, tmpstr );
            puts( "ERROR Compiling Vertex Shader Error follows:" );
            puts( tmpstr );
            free( tmpstr );
            return false;
        }
    }
    return true;
}

bool Shader::LoadShaderGeom( const char * sShaderCode )
{
    if( strlen( sShaderCode ) < 5 )
        return false;

    if( strncmp( sShaderCode, "!!ARB", 5 ) == 0 )
    {
        puts( "ERROR: ASM geometry shaders are not supported." );
        return false;
    }
    else
    {
        GLint bGeomCompiled;
        GLint stringLength;
        //Create a new geometry shader
        geometryShader = glCreateShaderObjectARB( GL_GEOMETRY_SHADER_EXT );
        //Bind the shader to the text, setting that to be its source.
        glShaderSourceARB( geometryShader, 1, &sShaderCode, NULL );
        //Compile the shader
        glCompileShaderARB( geometryShader );
        //Did the shader compile?  Were there any errors?
        glGetObjectParameterivARB( geometryShader, GL_OBJECT_COMPILE_STATUS_ARB, &bGeomCompiled );
        glGetObjectParameterivARB( geometryShader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &stringLength );
        if( stringLength > 1 || bGeomCompiled == 0 )
        {
            char * tmpstr = (char*)malloc( stringLength + 1 );
            glGetInfoLogARB( geometryShader, stringLength, NULL, tmpstr );
            puts( "ERROR Compiling Geometry Shader Error follows:" );
            puts( tmpstr );
            free( tmpstr );
            return false;
        }
    }
    return true;
}

bool Shader::LinkShaders()
{
    if( bIsGLSLAsm )
    {
        return true;
    }
    else
    {
        GLint bLinked;
        GLint stringLength;
        //Create the actual shader prgoram
        iProgramID = glCreateProgramObjectARB();
        //Attach the fragment/vertex shader to it.
        if( vertexShader )
            glAttachObjectARB( iProgramID, vertexShader );
        if( fragmentShader )
            glAttachObjectARB( iProgramID, fragmentShader );
        if( geometryShader )
            glAttachObjectARB( iProgramID, geometryShader );
        //Attempt to link the shader
        glLinkProgramARB( iProgramID );

        //If we're using a geometry shader, we have to do a little extra.
        if( geometryShader )
        {
            glProgramParameteriEXT( iProgramID, GL_GEOMETRY_INPUT_TYPE_EXT, GL_TRIANGLES );
            glProgramParameteriEXT( iProgramID, GL_GEOMETRY_OUTPUT_TYPE_EXT, GL_TRIANGLE_STRIP );

            int ierror, i;
            GLint imaxvert;
            glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&imaxvert);
            if( (ierror = glGetError()) != 0 )
            {
                puts( "ERROR: You cannot load a geometry shader when there are still errors left in OpenGL." );
                puts( "Please track down the error remaining by using glGetError() to cordon off your code." );
                printf( "The last error received was: %d\n", ierror );
            }
            for( i = 1; i < imaxvert; i++ )
            {
                glProgramParameteriEXT(iProgramID,GL_GEOMETRY_VERTICES_OUT_EXT,imaxvert/i);
                if( glGetError() == 0 )
                    break;
            }
            printf( "Geometry Shader loaded with a total of %d max verticies.  Because there are %d max vertices, and %d preceived components per vert.\n", imaxvert/i, imaxvert, i );
        }


        //See if there were any errors.
        glGetObjectParameterivARB( iProgramID, GL_OBJECT_LINK_STATUS_ARB, &bLinked );
        glGetObjectParameterivARB( iProgramID, GL_OBJECT_INFO_LOG_LENGTH_ARB, &stringLength );

        if ( stringLength > 1 || bLinked == 0 )
        {
            char * tmpstr = (char*)malloc( stringLength + 1 );
            glGetInfoLogARB( iProgramID, stringLength, NULL, tmpstr );
            puts( "ERROR linking shaders. Error follows:" );
            puts( tmpstr );
            free( tmpstr );
            return false;
        }
        return true;
    }
}

bool Shader::ActivateShader( vector< string > &vsAllSamplerLocs, vector< string > &vsUniformFloats, vector < float > & vfUniformFloats )
{
    unsigned i;

    if( bIsGLSLAsm )
    {
        glEnable( GL_VERTEX_PROGRAM_ARB );
        glBindProgramARB( GL_VERTEX_PROGRAM_ARB, vertexProgram);
        glEnable( GL_FRAGMENT_PROGRAM_ARB );
        glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, fragmentProgram);

        for( i = 0; i < vfUniformFloats.size(); ++i )
        {
            glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, i, vfUniformFloats[i],0,0,0 );
            glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, i, vfUniformFloats[i],0,0,0 );
        }
    }
    else
    {
        glUseProgramObjectARB( iProgramID );
    
        for( i = 0; i < vsAllSamplerLocs.size(); ++i )
        {
            int iTexPosID = glGetUniformLocationARB( iProgramID, vsAllSamplerLocs[i].c_str() );
            if( iTexPosID > -1 )
                glUniform1iARB( iTexPosID, i );
        }
    
        for( i = 0; i < vsUniformFloats.size(); ++i )
        {
            int iTexPosID = glGetUniformLocationARB( iProgramID, vsUniformFloats[i].c_str() );
            if( iTexPosID > -1 )
                glUniform1fARB( iTexPosID, vfUniformFloats[i] );
        }   
    }
    return true;
}

bool Shader::ActivateShader( vector< string > &vsAllSamplerLocs)
{
    unsigned i;

    glUseProgramObjectARB( iProgramID );

    for( i = 0; i < vsAllSamplerLocs.size(); ++i )
    {
        int iTexPosID = glGetUniformLocationARB( iProgramID, vsAllSamplerLocs[i].c_str() );
        if( iTexPosID > -1 )
            glUniform1iARB( iTexPosID, i );
    }

    return true;
}

bool Shader::DeactivateShader()
{
    glUseProgramObjectARB( 0 );
    return true;
}

Texture::~Texture()
{
    if( (int)iTexture == -1 )
        return;
    glDeleteTextures( 1, &iTexture );
}

bool Texture::StripFromScreen( int x, int y, int width, int height )
{
    glActiveTextureARB( GL_TEXTURE0_ARB );
    glBindTexture( GL_TEXTURE_2D, iTexture );
    glEnable( GL_TEXTURE_2D );

    glCopyTexImage2D( GL_TEXTURE_2D, 0, imXTypes[mtt], x, y, width, height, 0);

    glDisable( GL_TEXTURE_2D );
        glBindTexture( GL_TEXTURE_2D, 0 );
    return true;
}

bool Texture::MakeDynamicTexture( int iWidth, int iHeight, TextureType tt )
{
    mtt = tt;
    mWidth = iWidth;
    mHeight = iHeight;

    if( (int)iTexture == -1 )
        glGenTextures( 1, &iTexture );
    if( (int)iTexture == -1 )
        return false;

    glBindTexture( GL_TEXTURE_2D, iTexture );
    glCopyTexImage2D( GL_TEXTURE_2D, 0, imTypes[tt], 0, 0, iWidth, iHeight, 0 );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glBindTexture( GL_TEXTURE_2D, 0 );
    return true;
}

bool Texture::LoadTextureFile( const char * sFileName )
{
    unsigned char * Buffer;
    if( (int)iTexture == -1 )
        glGenTextures( 1, &iTexture );
    if( (int)iTexture == -1 )
    {
        puts( "Texture failed to generate" );
        return false;
    }
    if( !OpenPPM( sFileName, &Buffer, &mWidth, &mHeight ) )
    {
        puts( "PPM Failed to open" );
        return false;
    }
    mtt = TTRGB;

    glBindTexture( GL_TEXTURE_2D, iTexture );
    glTexImage2D( GL_TEXTURE_2D, 0, imTypes[mtt], mWidth, mHeight, 0, imTypes[mtt], byTypes[mtt], Buffer );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glBindTexture( GL_TEXTURE_2D, 0 );
    free( Buffer );
    return true;
}

bool Texture::LoadTexture( char * sRawData, int iWidth, int iHeight, TextureType tt )
{
    if( (int)iTexture == -1 )
        glGenTextures( 1, &iTexture );
    if( (int)iTexture == -1 )
        return false;

    mtt = tt;
    mWidth = iWidth;
    mHeight = iHeight;

    glBindTexture( GL_TEXTURE_2D, iTexture );
    glTexImage2D( GL_TEXTURE_2D, 0, imTypes[mtt], mWidth, mHeight, 0, imXTypes[mtt], byTypes[mtt], sRawData );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glBindTexture( GL_TEXTURE_2D, 0 );
    return true;
}

void Texture::ChangeFilter( bool bNearest )
{
    glBindTexture( GL_TEXTURE_2D, iTexture );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (bNearest)?GL_NEAREST:GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (bNearest)?GL_NEAREST:GL_LINEAR );
    glBindTexture( GL_TEXTURE_2D, 0 );
}

bool Texture::ActivateTexture( int iPlace )
{
    glActiveTextureARB( GL_TEXTURE0_ARB + iPlace );
    glBindTexture( GL_TEXTURE_2D, iTexture );
    glEnable( GL_TEXTURE_2D );
    return true;
}

bool Texture::DeactivateTexture( int iPlace )
{
    glActiveTextureARB( GL_TEXTURE0_ARB + iPlace );
    glDisable( GL_TEXTURE_2D );
    return true;
}

RFBuffer::RFBuffer()
{
    mWidth = 0; mHeight = 0; mtt = TTGRAYSCALE;
    iRenderbuffer = 0;
    iOutputBuffer = 0;
}

RFBuffer::~RFBuffer()
{
    if( iRenderbuffer != 0 )
    {
        glDeleteRenderbuffersEXT( 1, &iRenderbuffer );
        glDeleteFramebuffersEXT( 1, &iOutputBuffer );
    }
}

bool RFBuffer::Setup( bool bUseDepthBuffer )
{
    m_bUseDepthBuffer = bUseDepthBuffer;
    if( m_bUseDepthBuffer )
        glGenRenderbuffersEXT( 1, &iRenderbuffer );
    glGenFramebuffersEXT( 1, &iOutputBuffer );
    return true;
}

bool RFBuffer::ConfigureAndStart( int iWidth, int iHeight, int iTextures, Texture * TexturesToAttach, bool bClear )
{
    const GLenum buffers[8] = {   GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT,
            GL_COLOR_ATTACHMENT3_EXT, GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT,
            GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT };
    mWidth = iWidth; mHeight = iHeight;
    if( m_bUseDepthBuffer )
    {
        glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, iRenderbuffer );
        glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, mWidth, mHeight );
    }
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, iOutputBuffer );
    for( int i = 0; i < iTextures; i++ )
        glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + i, 
            GL_TEXTURE_2D, TexturesToAttach[i].GetTexHandle(), 0 );
    if( m_bUseDepthBuffer  )
        glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, 
            GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, iRenderbuffer );

    //Added by Peter Bessman to verify nonexecution of the following code.
    #ifdef _WIN32
    if (glDrawBuffersARB)
    #endif
        glDrawBuffersARB( iTextures, buffers );
    glViewport( 0, 0, mWidth, mHeight );

    //Check to see if there were any errors with the framebuffer
    switch( (GLenum)glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) )
    {
        case GL_FRAMEBUFFER_COMPLETE_EXT: break;  //GOOD!
        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
            printf("OpenGL Framebuffer error: GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\n");
            return false;
        case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
            printf("OpenGL Framebuffer error: GL_FRAMEBUFFER_UNSUPPORTED_EXT\n");
            return false;
        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
            printf("OpenGL Framebuffer error: GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\n");
            return false;
        case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
            printf("OpenGL Framebuffer error: GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\n");
            return false;
        case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
            printf("OpenGL Framebuffer error: GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\n");
            return false;
        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
            printf("OpenGL Framebuffer error: GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n");
            return false;
        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
            printf("OpenGL Framebuffer error: GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\n");
            return false;
        default:
            printf("UNKNWON error with OpenGL Framebuffer\n");
            return false;
    }

    if( bClear )
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    return true;
}

bool RFBuffer::End( int iRegVPX, int iRegVPY )
{
    for( unsigned i = 0; i < 8; i++ )
    {
        glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + i, 
            GL_TEXTURE_2D, 0, 0 );

        glActiveTextureARB( GL_TEXTURE0_ARB + i );
        glDisable( GL_TEXTURE_2D );
    }
    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
    glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, 0 );
    glViewport( 0, 0, iRegVPX, iRegVPY );
    return true;
}

VertexData::~VertexData()
{
    if( iVertexData == 0 )
        return;
    glDeleteBuffersARB( 1, &iVertexData );
}

void VertexData::Init( float * Verts, int iNumVerts, int iStride )
{
    mStride = iStride;
    glGenBuffersARB( 1, &iVertexData );
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, iVertexData  );
    if( !Verts )
        glBufferDataARB( GL_ARRAY_BUFFER_ARB, iNumVerts * iStride * sizeof( float ), 0, GL_STREAM_COPY );
    else
        UpdateData( Verts, iNumVerts, iStride );
}

void VertexData::UpdateData( float * Verts, int iNumVerts, int iStride )
{
    mStride = iStride;
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, iVertexData  );
    glBufferDataARB( GL_ARRAY_BUFFER_ARB, iNumVerts * iStride * sizeof( float ), Verts, GL_STATIC_DRAW_ARB );
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
}

void VertexData::StripFromFrameBuffer( int iWidth, int iHeight, TextureType tt )
{
    glBindBufferARB( GL_PIXEL_PACK_BUFFER_ARB, iVertexData );

    glReadPixels( 0, 0, iWidth, iHeight, imXTypes[tt], byTypes[tt], 0 );
    glBindBufferARB( GL_PIXEL_PACK_BUFFER_ARB, 0 );
}

IndexData::~IndexData()
{   
}

void IndexData::Init( int * Indices, int iNumIndices )
{
    mIndexData = (GLuint*)Indices; mIndexCount = iNumIndices;
}

int FileReadLine( FILE * f, char * line, int iBufferSize )
{
        int iPlace = 0;

        //Read the first character.
        char cCh = fgetc( f );

        //If we have a newline, or a windows-type newline, quit.
        while( cCh != '\n' && cCh != '\r' && !feof( f ))
        {
                line[iPlace] = cCh;
                iPlace++;
                if( iPlace >= iBufferSize )
                        return 0;
                cCh = fgetc( f );
        }
        //If it's a windows-type newline (\r\n) then, throw away the true \n.
        if( cCh == '\r' )
                fgetc( f );

        line[iPlace] = '\0';

        return iPlace;
}


//
//NOTE: I have no IDEA at ALL if this is being parsed right, I just exported some PPM's from GIMP
//      and this thing seems to load them all ok. (DO NOT TRUST THIS CODE TO BE RELIABLE)
//
int OpenPPM( const char * sPPMName, unsigned char ** buffer, int * width, int * height )
{
        unsigned char Magic[2];
        char line[512];
        int maxval;
        int totalsize;

        *width = 0;
        *height = 0;

        FILE * f = fopen( sPPMName, "rb" );
        if( !f )
        {
                printf( "Could not open specified ppm, %s.\n", sPPMName );
                return 0;
        }

        fread( &Magic[0], 2, 1, f );
        if( Magic[0] != 'P' || Magic[1] != '6' )
        {
                fclose( f );
                printf( "The PPM: %s does not contain the P6 magic word.\n", sPPMName );
                return 0;
        }

        FileReadLine( f, line, 512 );

        //No idea if this part is right, I'd expect it to be wrong.  It just happens to work with gimp.
        while( FileReadLine( f, line, 512 ) && !feof( f ))
                if( sscanf( line, "%d %d", width, height ) == 2 )
                        break;

        while( FileReadLine( f, line, 512 ) && !feof( f ))
                if( sscanf( line, "%d", &maxval ) == 1 )
                        break;

        if( *width <= 0 || *width >= 8192 || *height <=0 || *height >= 8192 )
        {
                fclose( f );
                printf( "Invalid image size set for PPM: %s.  (Or PPM Read Failed.)\n", sPPMName );
                return 0;
        }

        if( maxval != 255 )
        {
                fclose( f );
                printf( "Unsupported color-byte type for PPM: %s\n", sPPMName );
                return 0;
        }

        totalsize = 3 * (*height) * (*width);
        *buffer = (unsigned char*)malloc( totalsize );
        fread( *buffer, totalsize, 1, f );
        fclose( f );
        return totalsize;
}

void DrawSquare()
{
    glBegin( GL_QUADS );
    glTexCoord2f( 0.0f, 0.0f );
    glVertex3f( -1.0f, -1.0f, 0.0f );
    glTexCoord2f( 0.0f, 1.0f );
    glVertex3f( -1.0f, 1.0f, 0.0f );
    glTexCoord2f( 1.0f, 1.0f );
    glVertex3f( 1.0f, 1.0f, 0.0f );
    glTexCoord2f( 1.0f, 0.0f );
    glVertex3f( 1.0f, -1.0f, 0.0f );
    glEnd();
}


void DrawGeometry( VertexData ** vd, string * vsVertexNames, int iNumVertexDatas, IndexData * id, Shader * sShader )
{
    int i;
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, vd[0]->iVertexData );
    glVertexPointer( vd[0]->mStride, GL_FLOAT, 0, 0 );

    if( sShader )
        for( i = 1; i < iNumVertexDatas; ++i )
        {
            int iTexPosID = glGetAttribLocationARB( sShader->GetProgramID(), vsVertexNames[i].c_str() );
            glBindBufferARB( GL_ARRAY_BUFFER_ARB, vd[i]->iVertexData );
            glEnableVertexAttribArrayARB( iTexPosID );
            glVertexAttribPointerARB( iTexPosID, vd[i]->mStride, GL_FLOAT, 0, 0, 0 );
        }


    glEnableClientState( GL_VERTEX_ARRAY );
    glDrawElements( GL_POINTS, id->mIndexCount, GL_UNSIGNED_INT, id->mIndexData );
    glDisableClientState( GL_VERTEX_ARRAY );
}

void DrawGeometrySolid( VertexData ** vd, string * vsVertexNames, int iNumVertexDatas, IndexData * id, Shader * sShader, int facecount )
{
    int i;
    glBindBufferARB( GL_ARRAY_BUFFER_ARB, vd[0]->iVertexData );
    glVertexPointer( vd[0]->mStride, GL_FLOAT, 0, 0 );

    if( sShader )
        for( i = 1; i < iNumVertexDatas; ++i )
        {
            int iTexPosID = glGetAttribLocationARB( sShader->GetProgramID(), vsVertexNames[i].c_str() );
            glBindBufferARB( GL_ARRAY_BUFFER_ARB, vd[i]->iVertexData );
            glEnableVertexAttribArrayARB( iTexPosID );
            glVertexAttribPointerARB( iTexPosID, vd[i]->mStride, GL_FLOAT, 0, 0, 0 );
        }


    glEnableClientState( GL_VERTEX_ARRAY );
    glDrawElements( GL_TRIANGLES, facecount, GL_UNSIGNED_INT, id->mIndexData );
    glDisableClientState( GL_VERTEX_ARRAY );
}

void SetupForDataRun()
{
    glDisable( GL_LIGHTING );
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
}

void PopFromDataRun()
{
    glMatrixMode( GL_PROJECTION );
    glPopMatrix();
    glMatrixMode( GL_MODELVIEW );
    glPopMatrix();
}

void StripDataFromBuffer( int ix, int iy, int iwidth, int iheight, TextureType tt, char * buffer )
{
    glReadPixels( ix, iy, iwidth, iheight, imXTypes[tt], byTypes[tt], buffer );
}

/*
Copyright (c) 2005, 2006, 2007 Charles Lohr, David Chapman, Joshua Allen

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

---

© 2005-2007 Charles Lohr, Joshua Allen, David Chapman, Andrew Lohr. All material including documentation under the MIT/X11 license.