C:/Documents and Settings/mtauraso/Desktop/proj3/projectX/glfuncs.cpp

Go to the documentation of this file.

#include "glfuncs.h"
#include <iostream>

using namespace std;

glfuncs* glfuncs::_instance = NULL;

glfuncs::glfuncs()
{
        init_glfuncs();
        base = buildFont();
}

glfuncs* glfuncs::instance()
{
        if(!_instance)
                _instance = new glfuncs();
        return _instance;
}

void* glfuncs::get_funcaddr(const char* p)
{
        void* f=SDL_GL_GetProcAddress(p);
        if (f)
        {
                return f;
        }
        else
        {
                printf("Unable to get function pointer for %s\n",p);
                exit(1);
        }
}

void glfuncs::init_glfuncs()
{
        glBegin=(void(APIENTRY*)(GLenum))get_funcaddr("glBegin");
        glEnd=(void(APIENTRY*)())get_funcaddr("glEnd");
        glVertex3f=(void(APIENTRY*)(GLfloat, GLfloat, GLfloat))get_funcaddr("glVertex3f");
        glClearColor=(void(APIENTRY*)(GLfloat, GLfloat, GLfloat, GLfloat))get_funcaddr("glClearColor");
        glClear=(void(APIENTRY*)(GLbitfield))get_funcaddr("glClear");
        glDisable=(void(APIENTRY*)(GLenum))get_funcaddr("glDisable");
        glEnable=(void(APIENTRY*)(GLenum))get_funcaddr("glEnable");
        glColor4ub=(void(APIENTRY*)(GLubyte,GLubyte,GLubyte,GLubyte))get_funcaddr("glColor4ub");
        glPointSize=(void(APIENTRY*)(GLfloat))get_funcaddr("glPointSize");
        glHint=(void(APIENTRY*)(GLenum,GLenum))get_funcaddr("glHint");
        glBlendFunc=(void(APIENTRY*)(GLenum,GLenum))get_funcaddr("glBlendFunc");
        glMatrixMode=(void(APIENTRY*)(GLenum))get_funcaddr("glMatrixMode");
        glLoadIdentity=(void(APIENTRY*)())get_funcaddr("glLoadIdentity");
        glOrtho=(void(APIENTRY*)(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble))get_funcaddr("glOrtho");
        glRotatef=(void(APIENTRY*)(GLfloat,GLfloat,GLfloat,GLfloat))get_funcaddr("glRotatef");
        glViewport=(void(APIENTRY*)(GLint,GLint,GLsizei,GLsizei))get_funcaddr("glViewport");
        glFogf=(void(APIENTRY*)(GLenum,GLfloat))get_funcaddr("glFogf");
        glGenTextures=(void(APIENTRY*)(GLsizei,GLuint*))get_funcaddr("glGenTextures");
        glBindTexture=(void(APIENTRY*)(GLenum,GLuint))get_funcaddr("glBindTexture");
        glTexParameteri=(void(APIENTRY*)(GLenum,GLenum,GLint))get_funcaddr("glTexParameteri");
        glTexImage2D=(void(APIENTRY*)(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const GLvoid *))get_funcaddr("glTexImage2D");
        glColor3f=(void(APIENTRY*)(GLfloat,GLfloat,GLfloat))get_funcaddr("glColor3f");
        glVertex2f=(void(APIENTRY*)(GLfloat,GLfloat))get_funcaddr("glVertex2f");
        glTexCoord2f=(void(APIENTRY*)(GLfloat,GLfloat))get_funcaddr("glTexCoord2f");
        glTexEnvf=(void(APIENTRY*)(GLenum,GLenum,GLfloat))get_funcaddr("glTexEnvf");
        glColor4f=(void(APIENTRY*)(GLfloat,GLfloat,GLfloat,GLfloat))get_funcaddr("glColor4f");
        glDepthMask=(void(APIENTRY*)(GLboolean))get_funcaddr("glDepthMask");
        glClearDepth=(void(APIENTRY*)(GLclampd))get_funcaddr("glClearDepth");
        glDepthFunc=(void(APIENTRY*)(GLenum))get_funcaddr("glDepthFunc");
        glShadeModel=(void(APIENTRY*)(GLenum))get_funcaddr("glShadeModel");
        glFinish=(void(APIENTRY*)())get_funcaddr("glFinish");

        glGenLists=(GLuint(APIENTRY*)(GLsizei))get_funcaddr("glGenLists");
        glDeleteLists=(void(APIENTRY*)(GLuint,GLsizei))get_funcaddr("glDeleteLists");
        glPopAttrib=(void(APIENTRY*)())get_funcaddr("glPopAttrib");
        glCallLists=(void(APIENTRY*)(GLsizei,GLenum,const GLvoid*))get_funcaddr("glCallLists");
        glListBase=(void(APIENTRY*)(GLuint))get_funcaddr("glListBase");
        glPushAttrib=(void(APIENTRY*)(GLbitfield))get_funcaddr("glPushAttrib");

        glRasterPos2f=(void(APIENTRY*)(GLfloat,GLfloat))get_funcaddr("glRasterPos2f");
        glGetBooleanv=(void(APIENTRY*)(GLenum, GLboolean *))get_funcaddr("glGetBooleanv");

        wglUseFontBitmapsA=(void(APIENTRY*)(HDC,long,long,long))get_funcaddr("wglUseFontBitmapsA");
}

/* Quick utility function for texture creation */
int glfuncs::power_of_two(int input)
{
    int value = 1;

    while ( value < input ) {
        value <<= 1;
    }
    return value;
}

GLuint glfuncs::SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
{
    GLuint texture;
    int w, h;
    SDL_Surface *image;
    SDL_Rect area;
    Uint32 saved_flags;
    Uint8  saved_alpha;

    /* Use the surface width and height expanded to powers of 2 */
    w = power_of_two(surface->w);
    h = power_of_two(surface->h);
    texcoord[0] = 0.0f;         /* Min X */
    texcoord[1] = 0.0f;         /* Min Y */
    texcoord[2] = (GLfloat)surface->w / w;  /* Max X */
    texcoord[3] = (GLfloat)surface->h / h;  /* Max Y */

    image = SDL_CreateRGBSurface(
            SDL_SWSURFACE,
            w, h,
            32,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
            0x000000FF,
            0x0000FF00,
            0x00FF0000,
            0xFF000000
#else
            0xFF000000,
            0x00FF0000,
            0x0000FF00,
            0x000000FF
#endif
               );
    if ( image == NULL ) {
        return 0;
    }

    /* Save the alpha blending attributes */
    saved_flags = surface->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
    saved_alpha = surface->format->alpha;
    if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
        SDL_SetAlpha(surface, 0, 0);
    }

    /* Copy the surface into the GL texture image */
    area.x = 0;
    area.y = 0;
    area.w = surface->w;
    area.h = surface->h;
    SDL_BlitSurface(surface, &area, image, &area);

    /* Restore the alpha blending attributes */
    if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
        SDL_SetAlpha(surface, saved_flags, saved_alpha);
    }

    /* Create an OpenGL texture for the image */
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D,
             0,
             GL_RGBA,
             w, h,
             0,
             GL_RGBA,
             GL_UNSIGNED_BYTE,
             image->pixels);
    SDL_FreeSurface(image); /* No longer needed */

    return texture;
}

SDL_Surface *glfuncs::load_image( std::string filename ) 
{ 
        //The image that's loaded 
        SDL_Surface* loadedImage = NULL; 
        
        //The optimized image that will be used 
        SDL_Surface* optimizedImage = NULL; 
        
        //Load the image using SDL_image 
        loadedImage = IMG_Load( filename.c_str() ); 
        
        //If the image loaded 
        if( loadedImage != NULL ) 
        { 
                //Create an optimized image 
                optimizedImage = SDL_DisplayFormatAlpha( loadedImage ); 
                //Free the old image 
                SDL_FreeSurface( loadedImage ); 
        } 
        
        //Return the optimized image 
        return optimizedImage; 
}

/* Taken from SDL Tutorial Lesson 13
 * http://lazyfooproductions.com/SDL_tutorials/lesson13/index.php
 * 
 * Highly modified
 */

bool glfuncs::intersect(SDL_Rect &A, SDL_Rect &B, int* x , int* y)
{
        return intersectX(A,B,x) && intersectY(A,B,y);
}

bool glfuncs::intersectX(SDL_Rect &A, SDL_Rect &B, int* x)
{
        bool returnme;
        //The sides of the rectangles
    int leftA, leftB;
    int rightA, rightB;
        
        //Calculate the sides of rect A
    leftA = A.x;
    rightA = A.x + A.w;

        //Calculate the sides of rect B
    leftB = B.x;
    rightB = B.x + B.w;

        //If any of the sides from A are outside of B
    if( rightA <= leftB || leftA >= rightB )
                returnme = false;
        else 
                returnme = true;

        if(x != NULL)
        {
                int centerAx = A.x + A.w/2;
                int centerBx = B.x + B.w/2;

                // this corresponds to the direction 
                // b must be moved
                bool left;

                if(returnme)
                        left = (centerAx >= centerBx);
                else
                        left = (centerAx <= centerBx);
                
                //this is the amount b needs to be moved
                *x = min(abs(leftB-rightA),abs(leftA-rightB));
                
                // make sure the sign is right
                if(left)
                        *x = -(*x);
        }
        return returnme;

}
bool glfuncs::intersectY(SDL_Rect &A, SDL_Rect &B, int* y)
{
        bool returnme;
        //The sides of the rectangles
        int topA, topB;
    int bottomA, bottomB;

        //Calculate the sides of rect A
        topA = A.y;
    bottomA = A.y + A.h;
        
    //Calculate the sides of rect B
    topB = B.y;
    bottomB = B.y + B.h;


        //If any of the sides from A are outside of B
    if( bottomA <= topB || topA >= bottomB )
                returnme = false;
        else 
                returnme = true;

        if(y != NULL)
        {
                
                int centerAy = A.y + A.h/2;
                int centerBy = B.y + B.h/2;

                // this corresponds to the direction
                // b must be moved
                bool up;
                
                if(returnme)
                        up = (centerAy >= centerBy);
                else
                        up = (centerAy <= centerBy);

                //this is the amount b needs to be moved
                *y = min(abs(bottomB-topA),abs(bottomA-topB));
                
                // make sure the sign is right
                if(up)
                        *y = -(*y);

                
        }

        

        return returnme;
}

/* Taken from http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=13 */
GLuint glfuncs::buildFont(GLvoid)                                                               // Build Our Bitmap Font
{
        SDL_SysWMinfo info;
        SDL_VERSION(&info.version);
        SDL_GetWMInfo(&info);

        HWND hWnd = info.window;

        HDC hDC = GetDC(hWnd); 

        HFONT   font;                                                                           // Windows Font ID
        HFONT   oldfont;                                                                        // Used For Good House Keeping

        GLuint base = glGenLists(96);                           // Storage For 96 Characters

        font = CreateFont(      -24,                                                    // Height Of Font
                                                0,                                                              // Width Of Font
                                                0,                                                              // Angle Of Escapement
                                                0,                                                              // Orientation Angle
                                                FW_BOLD,                                                // Font Weight
                                                FALSE,                                                  // Italic
                                                FALSE,                                                  // Underline
                                                FALSE,                                                  // Strikeout
                                                ANSI_CHARSET,                                   // Character Set Identifier
                                                OUT_TT_PRECIS,                                  // Output Precision
                                                CLIP_DEFAULT_PRECIS,                    // Clipping Precision
                                                ANTIALIASED_QUALITY,                    // Output Quality
                                                FF_DONTCARE|DEFAULT_PITCH,              // Family And Pitch
                                                "Courier New");                                 // Font Name

        oldfont = (HFONT)SelectObject(hDC, font);           // Selects The Font We Want
        wglUseFontBitmaps(hDC, 32, 96, base);                           // Builds 96 Characters Starting At Character 32
        SelectObject(hDC, oldfont);                                                     // Selects The Font We Want
        DeleteObject(font);                                                                     // Delete The Font

        return base;
}

/* Taken from http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=13 */
GLvoid glfuncs::killFont()                                                                      // Delete The Font List
{
        glDeleteLists(base, 96);                                                        // Delete All 96 Characters
}

/* Taken from http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=13 */
GLvoid glfuncs::glPrint(std::string text)                                       // Custom GL "Print" Routine
{                                                       // Holds Our String

        if (text == "")                                                                 // If There's No Text
                return;                                                                                 // Do Nothing

        glPushAttrib(GL_LIST_BIT);                                                      // Pushes The Display List Bits
        glListBase(base - 32);                                                          // Sets The Base Character to 32
        glCallLists(strlen(text.c_str()), GL_UNSIGNED_BYTE, text.c_str());      // Draws The Display List Text
        glPopAttrib();                                                                          // Pops The Display List Bits
}


int glfuncs::loadTexture(std::string filename, GLfloat coords[4], SDL_Rect & rect)
{
        SDL_Surface *surface = load_image(filename);
        rect.x = 0;
    rect.y = 0;
    rect.w = surface->w;
    rect.h = surface->h;
        int texture = SDL_GL_LoadTexture(surface,coords);
        SDL_FreeSurface(surface);
        return texture;
}

---