]> Shamusworld >> Repos - virtualjaguar/blobdiff - src/sdlemu_opengl.c
Added overlay texture for resolution indepence for the GUI (preliminary)
[virtualjaguar] / src / sdlemu_opengl.c
index c6cddd365b2d76a5c6e0ef233512b50729c5fc12..4037bd7feb0bf50ff68284c40d9230b9ac623e9e 100644 (file)
@@ -28,7 +28,7 @@
 
     Version 1.0.002 - 6-10-2004
 
-    - Cleaned up a lot of code and removed non functional and absolete code;
+    - Cleaned up a lot of code and removed non functional and obsolete code;
     - Removed sdlemu_resize_texture function because of double code;
     - Removed the texture creation from the sdlemu_init_opengl;
     - Added sdlemu_create_texture function to replace the sdlemu_resize_texture function
@@ -47,6 +47,13 @@ static GLfloat      texcoord[4];
 static unsigned int glFilter;
 static unsigned int texturebpp  = 0; // 16, 24 or 32 bpp
 
+static SDL_Surface * overlay = 0;
+static GLuint overlayID = 0;
+static GLfloat overlayCoord[4];
+void sdlemu_create_overlay(SDL_Surface * dst, int src_bpp);
+
+static int showOverlay = 0;
+
 static inline int power_of_two(int input)
 {
        int value = 1;
@@ -59,7 +66,6 @@ static inline int power_of_two(int input)
 
 void sdlemu_init_opengl(SDL_Surface * src, SDL_Surface * dst, int texturetype, int filter, int src_bpp)
 {
-
        printf("\nOpenGL driver information :\n");
        printf("\n");
        printf("Vendor:             %s\n", glGetString(GL_VENDOR));
@@ -80,15 +86,16 @@ void sdlemu_init_opengl(SDL_Surface * src, SDL_Surface * dst, int texturetype, i
        glFilter = filter;
 
        // Let us create the texture information :
-       sdlemu_create_texture( src, dst, filter , src_bpp);
+       sdlemu_create_texture(src, dst, filter, src_bpp);
 
+       sdlemu_create_overlay(dst, src_bpp);
 }
 
 void sdlemu_draw_texture(SDL_Surface * dst, SDL_Surface * src, int texturetype)
 {
 /*
-    This is needed when we want to render OpenGL textures with the Alpha mask set.
-    Be warned! This only works with the bpp of texture en *src set to 32.
+       This is needed when we want to render OpenGL textures with the Alpha mask set.
+       Be warned! This only works with the bpp of texture en *src set to 32.
 */
 #ifdef WANT_OPENGL_ALPHA
        Uint32 saved_flags;                
@@ -111,50 +118,88 @@ void sdlemu_draw_texture(SDL_Surface * dst, SDL_Surface * src, int texturetype)
 #else
        SDL_BlitSurface(src, NULL, texture, NULL);
 #endif
-
+//     SDL_BlitSurface(src, NULL, overlay, NULL);
+/*Uint32 * pix = (Uint32 *)overlay->pixels;
+Uint32 y,x;
+for(y=10; y<200; y++)
+for(x=30; x<250; x++)
+pix[x+(y*1024)] = 0x800000FF;//*/
+
+glBlendFunc(GL_ONE, GL_ZERO);
+glBindTexture(GL_TEXTURE_2D, texid);
        // Texturemap complete texture to surface so we have free scaling 
        // and antialiasing
-    switch ( texturebpp )
-    {
-    case 16:
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->w, texture->h,
-                       GL_RGB, GL_UNSIGNED_SHORT_5_6_5, texture->pixels);
-        break;
-    case 24:
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->w, texture->h,
-                       GL_RGB, GL_UNSIGNED_BYTE, texture->pixels);
-        break;
-    case 32:
-    default:
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->w, texture->h,
-                       GL_RGBA, GL_UNSIGNED_BYTE, texture->pixels);
-        break;
-    }     
-       
+       switch (texturebpp)
+       {
+       case 16:
+               glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->w, texture->h,
+                       GL_RGB, GL_UNSIGNED_SHORT_5_6_5, texture->pixels);
+               break;
+       case 24:
+               glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->w, texture->h,
+                       GL_RGB, GL_UNSIGNED_BYTE, texture->pixels);
+               break;
+       case 32:
+       default:
+               glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture->w, texture->h,
+                       GL_RGBA, GL_UNSIGNED_BYTE, texture->pixels);
+               break;
+       }     
+
        // Render the texture to the screen using OpenGL!
        switch (texturetype)
        {
        case 1:
-        glBegin(GL_QUADS);
-                glTexCoord2f(texcoord[0], texcoord[1]);
-                glVertex2f(0, 0);
-                glTexCoord2f(texcoord[2], texcoord[1]);
-                glVertex2f(dst->w , 0);
-                glTexCoord2f(texcoord[2], texcoord[3]);
-                glVertex2f(dst->w , dst->h );
-                glTexCoord2f(texcoord[0], texcoord[3]);
-                glVertex2f(0, dst->h );
-        glEnd();      
+               glBegin(GL_QUADS);
+                       glTexCoord2f(texcoord[0], texcoord[1]);
+                       glVertex2f(0, 0);
+                       glTexCoord2f(texcoord[2], texcoord[1]);
+                       glVertex2f(dst->w, 0);
+                       glTexCoord2f(texcoord[2], texcoord[3]);
+                       glVertex2f(dst->w, dst->h);
+                       glTexCoord2f(texcoord[0], texcoord[3]);
+                       glVertex2f(0, dst->h);
+               glEnd();
 
        default:
                glBegin(GL_TRIANGLE_STRIP);
-                               glTexCoord2f(texcoord[0], texcoord[1]); glVertex3i(0, 0, 0);
-                               glTexCoord2f(texcoord[2], texcoord[1]); glVertex3i(dst->w, 0, 0);
-                               glTexCoord2f(texcoord[0], texcoord[3]); glVertex3i(0, dst->h, 0);
-                               glTexCoord2f(texcoord[2], texcoord[3]); glVertex3i(dst->w, dst->h, 0);
+                       glTexCoord2f(texcoord[0], texcoord[1]); glVertex3i(0, 0, 0);
+                       glTexCoord2f(texcoord[2], texcoord[1]); glVertex3i(dst->w, 0, 0);
+                       glTexCoord2f(texcoord[0], texcoord[3]); glVertex3i(0, dst->h, 0);
+                       glTexCoord2f(texcoord[2], texcoord[3]); glVertex3i(dst->w, dst->h, 0);
+               glEnd();
+       }//*/
+
+       if (showOverlay)
+       {
+               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+               glBindTexture(GL_TEXTURE_2D, overlayID);
+               glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, overlay->w, overlay->h, GL_RGBA, GL_UNSIGNED_BYTE, overlay->pixels);
+               glBegin(GL_QUADS);
+                       glTexCoord2f(overlayCoord[0], overlayCoord[1]);
+                       glVertex2f(0, 0);
+                       glTexCoord2f(overlayCoord[2], overlayCoord[1]);
+                       glVertex2f(dst->w, 0);
+                       glTexCoord2f(overlayCoord[2], overlayCoord[3]);
+                       glVertex2f(dst->w, dst->h);
+                       glTexCoord2f(overlayCoord[0], overlayCoord[3]);
+                       glVertex2f(0, dst->h);
                glEnd();
        }
-       
+
+//Do some OpenGL stuff here...
+//Doesn't work...
+/*unsigned long int map[25] = {
+       0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+       0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+       0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+       0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+       0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
+};
+glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+glRasterPos2i(10, 10);
+glDrawPixels(5, 5, GL_RGBA, GL_UNSIGNED_INT, map);//*/
+
 //  glFlush();
        SDL_GL_SwapBuffers();    
 //     glFinish();
@@ -165,6 +210,158 @@ void sdlemu_close_opengl(void)
 {
        if (texture)
                SDL_FreeSurface(texture);
+
+       if (overlay)
+               SDL_FreeSurface(overlay);
+}
+
+void sdlemu_create_overlay(SDL_Surface * dst, int src_bpp)
+{
+    // Local variables.
+       Uint32 rmask, gmask, bmask, amask; // Needed for creating RGBA masks.
+
+       // Delete old texture (if allocated). Useful when there is a screen resize.
+       if (overlay)
+               SDL_FreeSurface(overlay);
+
+       // Texture width/height should be power of 2 of the SDL_Surface *src when using OpenGL.
+       // So, find the largest power of two that will contain both the width and height
+       int w = power_of_two(dst->w);
+       int h = power_of_two(dst->h);
+       
+       printf("OpenGL - Overlay size : %d x %d\n", w, h);
+       
+       // Setting bpp based upon src_bpp.
+       int bpp = src_bpp;
+       
+       // We allow the developer to set its own texture bpp. But if the value is NULL or
+       // not equal to 16, 24 or 32, we make the texturebpp the same as the BPP from src.
+       if (bpp == 16 || bpp == 24 || bpp == 32)
+               texturebpp = bpp;
+       else
+               texturebpp = dst->format->BitsPerPixel;
+
+       printf("OpenGL - Overlay depth : %d bpp\n", texturebpp);
+
+       // Now were are going to create a SDL_Surface named texture. This will be our surface
+       // which will function as a buffer between the SDL_Surface *src and SDL_Surface *dst.
+       // This buffer is needed because we need to convert the SDL_Surface *src to an OpenGL
+       // texture with a depth of 16, 24 or 32 bpp, before we can blit the pixels to *dst
+       // using OpenGL.
+       // 
+       // NOTE: Seems the byte order here *is* important!
+       switch (texturebpp)
+       {
+       case 16: // *src has depth of 16 bpp
+/*
+       According to information on the SDL mailinglist and on internet, the following
+       rgba masks should be the ones to use. But somehow the screen gets f*cked up and
+       the RGB colours are incorrect (at least in Virtual Jaguar/SDL). 
+               
+       Compile with -DOPENGL_16BPP_CORRECT_RGBA to use this RGBA values.
+*/        
+#ifdef OPENGL_16BPP_CORRECT_RGBA     
+               rmask = 0x7C00;
+               gmask = 0x03E0;
+               bmask = 0x001F;
+               amask = 0x0000;
+#else
+               rmask = 0x0000;
+               gmask = 0x0000;
+               bmask = 0x0000;
+               amask = 0x0000;
+#endif
+               break;
+       case 24: // *src has depth of 24 bpp
+       #if SDL_BYTEORDER == SDL_BIG_ENDIAN
+               rmask = 0x00FF0000;
+               gmask = 0x0000FF00;
+               bmask = 0x000000FF;
+               amask = 0x00000000; // IMPORTANT! 24 bpp doesn't use Alpha (at least in our case).
+       #else
+               rmask = 0x000000FF;
+               gmask = 0x0000FF00;
+               bmask = 0x00FF0000;
+               amask = 0x00000000; // IMPORTANT! 24 bpp doesn't use Alpha (at least in our case).
+       #endif
+               break;
+       case 32: //*src has depth of 32 bpp
+       default: //which is also the default.
+       #if SDL_BYTEORDER == SDL_BIG_ENDIAN
+               rmask = 0xFF000000;
+               gmask = 0x00FF0000;
+               bmask = 0x0000FF00;
+               amask = 0x000000FF;
+       #else
+               rmask = 0x000000FF;
+               gmask = 0x0000FF00;
+               bmask = 0x00FF0000;
+               amask = 0xFF000000;
+       #endif
+               break;
+       }
+
+       // Creating SDL_Surface texture based upon the above settings.
+       overlay = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, texturebpp, rmask, gmask, bmask, amask);
+       
+       // Setting up the texture coordinates.
+       overlayCoord[0] = 0.0f;
+       overlayCoord[1] = 0.0f;
+       overlayCoord[2] = (GLfloat)(dst->w) / overlay->w;
+       overlayCoord[3] = (GLfloat)(dst->h) / overlay->h;
+
+       // create a RGB(A) texture for the texture surface
+       glGenTextures(1, &overlayID);
+       glBindTexture(GL_TEXTURE_2D, overlayID);
+       
+       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    
+       // Setting texture mode.
+       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+       // Generate the texture using the above information.
+       switch (texturebpp)
+       {
+       case 16:
+               // Normal 16bpp depth based textures consist out of GL_RGB5 and doesn't have support for Alpha channels.
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, overlay->w, overlay->h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+               break;
+       case 24:
+               // The 24bpp depth based textures consist out of GL_RGB8 and doesn't have support for Alpha channels.
+               //
+               // IMPORTANT : If you don't use Alpha. Use textures with a depth of 16bpp.
+               //             If you use Alpha. Use textures with a depth of 32bpp.
+               //             24bpp textures are SLOW and avoid them at all costs!        
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, overlay->w, overlay->h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+               break;
+       case 32:
+       default:
+               // The 32bpp depth based textures consist out of GL_RGBA8 and has support for Alpha channels.
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, overlay->w, overlay->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+               break;        
+       }    
+}    
+
+void * sdlemuGetOverlayPixels(void)
+{
+       return overlay->pixels;
+}
+
+Uint32 sdlemuGetOverlayWidthInPixels(void)
+{
+       return overlay->pitch / 4;
+}
+
+void sdlemuEnableOverlay(void)
+{
+       showOverlay = 1;
+}
+
+void sdlemuDisableOverlay(void)
+{
+       showOverlay = 0;
 }
 
 void sdlemu_create_texture(SDL_Surface * src, SDL_Surface * dst, int filter, int src_bpp)
@@ -173,15 +370,15 @@ void sdlemu_create_texture(SDL_Surface * src, SDL_Surface * dst, int filter, int
        int w , h;                         // w and h contain the width and height of the OpenGL texture.
        Uint32 rmask, gmask, bmask, amask; // Needed for creating RGBA masks.
        int bpp;
-       
-       // Delete old texture (if allocated). Usefull when there is a screen resize.
+
+       // Delete old texture (if allocated). Useful when there is a screen resize.
        if (texture)
                SDL_FreeSurface(texture);
-    // Texture width/height should be power of 2 of the SDL_Surface *src when using OpenGL.
+
+       // Texture width/height should be power of 2 of the SDL_Surface *src when using OpenGL.
        // So, find the largest power of two that will contain both the width and height
-    w = power_of_two(src->w);
-    h = power_of_two(src->h);
+       w = power_of_two(src->w);
+       h = power_of_two(src->h);
        
        printf("OpenGL - Texture size : %d x %d\n", w, h);
        
@@ -190,12 +387,12 @@ void sdlemu_create_texture(SDL_Surface * src, SDL_Surface * dst, int filter, int
        
        // We allow the developer to set its own texture bpp. But if the value is NULL or
        // not equal to 16, 24 or 32, we make the texturebpp the same as the BPP from src.
-       if ( (bpp != NULL) && ( (bpp == 16) || (bpp == 24) || (bpp == 32) ) )
-       texturebpp = bpp;
-    else
-       texturebpp = src->format->BitsPerPixel;
-    
-    printf("OpenGL - Texture depth : %d bpp\n", texturebpp);
+       if (bpp == 16 || bpp == 24 || bpp == 32)
+               texturebpp = bpp;
+       else
+               texturebpp = src->format->BitsPerPixel;
+
+       printf("OpenGL - Texture depth : %d bpp\n", texturebpp);
 
        // Now were are going to create a SDL_Surface named texture. This will be our surface
        // which will function as a buffer between the SDL_Surface *src and SDL_Surface *dst.
@@ -204,62 +401,56 @@ void sdlemu_create_texture(SDL_Surface * src, SDL_Surface * dst, int filter, int
        // using OpenGL.
        // 
        // NOTE: Seems the byte order here *is* important!
-       switch ( texturebpp )
+       switch (texturebpp)
        {
-    case 16: // *src has depth of 16 bpp
-
+       case 16: // *src has depth of 16 bpp
 /*
-        According to information on the SDL mailinglist and on internet, the following
-        rgba masks should be the ones to use. But somehow the screen gets f*cked up and
-        the RGB colours are incorrect (at least in Virtual Jaguar/SDL). 
-        
-        Compile with -DOPENGL_16BPP_CORRECT_RGBA to use this RGBA values.
+       According to information on the SDL mailinglist and on internet, the following
+       rgba masks should be the ones to use. But somehow the screen gets f*cked up and
+       the RGB colours are incorrect (at least in Virtual Jaguar/SDL). 
+
+       Compile with -DOPENGL_16BPP_CORRECT_RGBA to use this RGBA values.
 */        
-        
 #ifdef OPENGL_16BPP_CORRECT_RGBA     
-       
-        rmask = 0x7c00;
-       gmask = 0x03e0;
-       bmask = 0x001f;
-       amask = 0x0000;
-       
+               rmask = 0x7C00;
+               gmask = 0x03E0;
+               bmask = 0x001F;
+               amask = 0x0000;
 #else
-
-        rmask = 0x0000;
+               rmask = 0x0000;
                gmask = 0x0000;
                bmask = 0x0000;
                amask = 0x0000;
-               
 #endif
-        break;
-    case 24: // *src has depth of 24 bpp
-    #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-           rmask = 0x00ff0000;
-               gmask = 0x0000ff00;
-               bmask = 0x000000ff;
+               break;
+       case 24: // *src has depth of 24 bpp
+       #if SDL_BYTEORDER == SDL_BIG_ENDIAN
+               rmask = 0x00FF0000;
+               gmask = 0x0000FF00;
+               bmask = 0x000000FF;
                amask = 0x00000000; // IMPORTANT! 24 bpp doesn't use Alpha (at least in our case).
        #else
-           rmask = 0x000000ff;
-           gmask = 0x0000ff00;
-           bmask = 0x00ff0000;
-           amask = 0x00000000; // IMPORTANT! 24 bpp doesn't use Alpha (at least in our case).
-    #endif
-       break;
-    case 32: //*src has depth of 32 bpp
-    default: //which is also the default.
-    #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-           rmask = 0xff000000;
-               gmask = 0x00ff0000;
-               bmask = 0x0000ff00;
-               amask = 0x000000ff;
+               rmask = 0x000000FF;
+               gmask = 0x0000FF00;
+               bmask = 0x00FF0000;
+               amask = 0x00000000; // IMPORTANT! 24 bpp doesn't use Alpha (at least in our case).
+       #endif
+               break;
+       case 32: //*src has depth of 32 bpp
+       default: //which is also the default.
+       #if SDL_BYTEORDER == SDL_BIG_ENDIAN
+               rmask = 0xFF000000;
+               gmask = 0x00FF0000;
+               bmask = 0x0000FF00;
+               amask = 0x000000FF;
        #else
-           rmask = 0x000000ff;
-           gmask = 0x0000ff00;
-           bmask = 0x00ff0000;
-           amask = 0xff000000;
-    #endif
-        break;
-    }    
+               rmask = 0x000000FF;
+               gmask = 0x0000FF00;
+               bmask = 0x00FF0000;
+               amask = 0xFF000000;
+       #endif
+               break;
+       }
 
        // Creating SDL_Surface texture based upon the above settings.
        texture = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, texturebpp, rmask, gmask, bmask, amask);
@@ -269,14 +460,18 @@ void sdlemu_create_texture(SDL_Surface * src, SDL_Surface * dst, int filter, int
        glDisable(GL_LIGHTING);
        glDisable(GL_CULL_FACE);
        glDisable(GL_DEPTH_TEST);
-       glDisable(GL_BLEND);
+//     glDisable(GL_BLEND);
+       glEnable(GL_BLEND);
        glDisable(GL_NORMALIZE);
        glDisable(GL_ALPHA_TEST);
        glEnable(GL_TEXTURE_2D);
-       glBlendFunc (GL_SRC_ALPHA, GL_ONE);
+//     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+//     glBlendFunc(GL_ONE, GL_SRC_ALPHA);
+//This works, but in a wrong way...
+//     glBlendFunc(GL_ONE, GL_ONE);
 
-       // Definately needed for screen resolution larger then the *src.
-       // This way we can have automatic scaling fucntionality.
+       // Definitely needed for screen resolution larger then the *src.
+       // This way we can have automatic scaling functionality.
        glViewport(0, 0, dst->w, dst->h);
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
@@ -288,7 +483,7 @@ void sdlemu_create_texture(SDL_Surface * src, SDL_Surface * dst, int filter, int
 
        // Setting up the texture coordinates.
        texcoord[0] = 0.0f;
-    texcoord[1] = 0.0f;
+       texcoord[1] = 0.0f;
        texcoord[2] = (GLfloat)(src->w) / texture->w;
        texcoord[3] = (GLfloat)(src->h) / texture->h;
 
@@ -296,48 +491,46 @@ void sdlemu_create_texture(SDL_Surface * src, SDL_Surface * dst, int filter, int
        glGenTextures(1, &texid);
        glBindTexture(GL_TEXTURE_2D, texid);
        
-    // Srtting up the OpenGL Filters. These filters are important when we/you
-    // want to scale the texture. 
+       // Setting up the OpenGL Filters. These filters are important when we/you
+       // want to scale the texture. 
        if (filter)
        {
-       // Textures are rendered in best quality. 
-       printf("OpenGL filters: enabled\n");
-          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+               // Textures are rendered in best quality. 
+               printf("OpenGL filters: enabled\n");
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        }
        else
        {
-       // Textures are rendered in normal quality.
-       printf("OpenGL filters: disabled\n");
-          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    }
+               // Textures are rendered in normal quality.
+               printf("OpenGL filters: disabled\n");
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+       }
     
-    // Setting texture mode.
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-
-
-    // Genereate the texture using the above information.
-    switch ( texturebpp )
-    {
-    case 16:
-        // Normal 16bpp depth based textures consist out of GL_RGB5 and doesn't have support for Alpha channels.
-           glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, texture->w, texture->h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
-        break;
-    case 24:
-        // The 24bpp depth based textures consist out of GL_RGB8 and doesn't have support for Alpha channels.
-        //
-        // IMPORTANT : If you don't use Alpha. Use textures with a depth of 16bpp.
-        //             If you use Alpha. Use textures with a depth of 32bpp.
-        //             24bpp textures are SLOW and avoid them at all costst!        
-           glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, texture->w, texture->h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
-        break;
-    case 32:
-    default:
-        // The 32bpp depth based textures consist out of GL_RGBA8 and has support for Alpha channels.
-           glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texture->w, texture->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-        break;        
-    }    
+       // Setting texture mode.
+       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
+       // Generate the texture using the above information.
+       switch (texturebpp)
+       {
+       case 16:
+               // Normal 16bpp depth based textures consist out of GL_RGB5 and doesn't have support for Alpha channels.
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, texture->w, texture->h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+               break;
+       case 24:
+               // The 24bpp depth based textures consist out of GL_RGB8 and doesn't have support for Alpha channels.
+               //
+               // IMPORTANT : If you don't use Alpha. Use textures with a depth of 16bpp.
+               //             If you use Alpha. Use textures with a depth of 32bpp.
+               //             24bpp textures are SLOW and avoid them at all costs!        
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, texture->w, texture->h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+               break;
+       case 32:
+       default:
+               // The 32bpp depth based textures consist out of GL_RGBA8 and has support for Alpha channels.
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texture->w, texture->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+               break;        
+       }    
 }