ruby-glfw 0.9

data/glfw-src/lib/fullscreen.c

@@ -0,0 +1,95 @@
+//========================================================================
+// GLFW - An OpenGL framework
+// File:        fullscreen.c
+// Platform:    Any
+// API version: 2.6
+// WWW:         http://glfw.sourceforge.net
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Camilla Berglund
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//************************************************************************
+//****                    GLFW user functions                         ****
+//************************************************************************
+
+//========================================================================
+// glfwGetVideoModes() - Get a list of available video modes
+//========================================================================
+
+GLFWAPI int GLFWAPIENTRY glfwGetVideoModes( GLFWvidmode *list,
+    int maxcount )
+{
+    int         count, i, swap, res1, res2, depth1, depth2;
+    GLFWvidmode vm;
+
+    if( !_glfwInitialized || maxcount <= 0 || list == (GLFWvidmode*) 0 )
+    {
+        return 0;
+    }
+
+    // Get list of video modes
+    count = _glfwPlatformGetVideoModes( list, maxcount );
+
+    // Sort list (bubble sort)
+    do
+    {
+        swap = 0;
+        for( i = 0; i < count-1; ++ i )
+        {
+            res1   = list[i].Width*list[i].Height;
+            depth1 = list[i].RedBits+list[i].GreenBits+list[i].BlueBits;
+            res2   = list[i+1].Width*list[i+1].Height;
+            depth2 = list[i+1].RedBits+list[i+1].GreenBits+
+                     list[i+1].BlueBits;
+            if( (depth2<depth1) || ((depth2==depth1) && (res2<res1)) )
+            {
+                vm = list[i];
+                list[i] = list[i+1];
+                list[i+1] = vm;
+                swap = 1;
+            }
+        }
+    }
+    while( swap );
+
+    return count;
+}
+
+
+//========================================================================
+// glfwGetDesktopMode() - Get the desktop video mode
+//========================================================================
+
+GLFWAPI void GLFWAPIENTRY glfwGetDesktopMode( GLFWvidmode *mode )
+{
+    if( !_glfwInitialized || mode == (GLFWvidmode*) 0 )
+    {
+        return;
+    }
+
+    _glfwPlatformGetDesktopMode( mode );
+}
+

data/glfw-src/lib/glext.c

@@ -0,0 +1,201 @@
+//========================================================================
+// GLFW - An OpenGL framework
+// File:        glext.c
+// Platform:    Any
+// API version: 2.6
+// WWW:         http://glfw.sourceforge.net
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Camilla Berglund
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//************************************************************************
+//****                  GLFW internal functions                       ****
+//************************************************************************
+
+//========================================================================
+// _glfwStringInExtensionString() - Check if a string can be found in an
+// OpenGL extension string
+//========================================================================
+
+int _glfwStringInExtensionString( const char *string,
+    const GLubyte *extensions )
+{
+    const GLubyte *start;
+    GLubyte *where, *terminator;
+
+    // It takes a bit of care to be fool-proof about parsing the
+    // OpenGL extensions string. Don't be fooled by sub-strings,
+    // etc.
+    start = extensions;
+    while( 1 )
+    {
+        where = (GLubyte *) strstr( (const char *) start, string );
+        if( !where )
+        {
+            return GL_FALSE;
+        }
+        terminator = where + strlen( string );
+        if( where == start || *(where - 1) == ' ' )
+        {
+            if( *terminator == ' ' || *terminator == '\0' )
+            {
+                break;
+            }
+        }
+        start = terminator;
+    }
+
+    return GL_TRUE;
+}
+
+
+
+//************************************************************************
+//****                    GLFW user functions                         ****
+//************************************************************************
+
+//========================================================================
+// glfwExtensionSupported() - Check if an OpenGL extension is available
+// at runtime
+//========================================================================
+
+GLFWAPI int GLFWAPIENTRY glfwExtensionSupported( const char *extension )
+{
+    const GLubyte *extensions;
+    GLubyte       *where;
+
+    // Is GLFW initialized?
+    if( !_glfwInitialized || !_glfwWin.Opened )
+    {
+        return GL_FALSE;
+    }
+
+    // Extension names should not have spaces
+    where = (GLubyte *) strchr( extension, ' ' );
+    if( where || *extension == '\0' )
+    {
+        return GL_FALSE;
+    }
+
+    // Check if extension is in the standard OpenGL extensions string
+    extensions = (GLubyte *) glGetString( GL_EXTENSIONS );
+    if( extensions != NULL )
+    {
+        if( _glfwStringInExtensionString( extension, extensions ) )
+        {
+            return GL_TRUE;
+        }
+    }
+
+    // Additional platform specific extension checking (e.g. WGL)
+    if( _glfwPlatformExtensionSupported( extension ) )
+    {
+        return GL_TRUE;
+    }
+
+    return GL_FALSE;
+}
+
+
+//========================================================================
+// glfwGetProcAddress() - Get the function pointer to an OpenGL function.
+// This function can be used to get access to extended OpenGL functions.
+//========================================================================
+
+GLFWAPI void * GLFWAPIENTRY glfwGetProcAddress( const char *procname )
+{
+    // Is GLFW initialized?
+    if( !_glfwInitialized || !_glfwWin.Opened )
+    {
+        return NULL;
+    }
+
+    return _glfwPlatformGetProcAddress( procname );
+}
+
+
+//========================================================================
+// glfwGetGLVersion() - Get OpenGL version
+//========================================================================
+
+GLFWAPI void GLFWAPIENTRY glfwGetGLVersion( int *major, int *minor,
+    int *rev )
+{
+    GLuint _major, _minor = 0, _rev = 0;
+    const GLubyte *version;
+    GLubyte *ptr;
+
+    // Is GLFW initialized?
+    if( !_glfwInitialized || !_glfwWin.Opened )
+    {
+        return;
+    }
+
+    // Get OpenGL version string
+    version = glGetString( GL_VERSION );
+    if( !version )
+    {
+        return;
+    }
+
+    // Parse string
+    ptr = (GLubyte*) version;
+    for( _major = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )
+    {
+        _major = 10*_major + (*ptr - '0');
+    }
+    if( *ptr == '.' )
+    {
+        ptr ++;
+        for( _minor = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )
+        {
+            _minor = 10*_minor + (*ptr - '0');
+        }
+        if( *ptr == '.' )
+        {
+            ptr ++;
+            for( _rev = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )
+            {
+                _rev = 10*_rev + (*ptr - '0');
+            }
+        }
+    }
+
+    // Return parsed values
+    if( major != NULL )
+    {
+        *major = _major;
+    }
+    if( minor != NULL )
+    {
+        *minor = _minor;
+    }
+    if( rev != NULL )
+    {
+        *rev = _rev;
+    }
+}
+

data/glfw-src/lib/image.c

@@ -0,0 +1,629 @@
+//========================================================================
+// GLFW - An OpenGL framework
+// File:        image.c
+// Platform:    Any
+// API version: 2.6
+// WWW:         http://glfw.sourceforge.net
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Camilla Berglund
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+//========================================================================
+// Description:
+//
+// This module acts as an interface for different image file formats (the
+// image file format is detected automatically).
+//
+// By default the loaded image is rescaled (using bilinear interpolation)
+// to the next higher 2^N x 2^M resolution, unless it has a valid
+// 2^N x 2^M resolution. The interpolation is quite slow, even if the
+// routine has been optimized for speed (a 200x200 RGB image is scaled to
+// 256x256 in ~30 ms on a P3-500).
+//
+// Paletted images are converted to RGB/RGBA images.
+//
+// A convenience function is also included (glfwLoadTexture2D), which
+// loads a texture image from a file directly to OpenGL texture memory,
+// with an option to generate all mipmap levels. GL_SGIS_generate_mipmap
+// is used whenever available, which should give an optimal mipmap
+// generation speed (possibly performed in hardware). A software fallback
+// method is included when GL_SGIS_generate_mipmap is not supported (it
+// generates all mipmaps of a 256x256 RGB texture in ~3 ms on a P3-500).
+//
+//========================================================================
+
+
+#include "internal.h"
+
+
+// We want to support automatic mipmap generation
+#ifndef GL_SGIS_generate_mipmap
+ #define GL_GENERATE_MIPMAP_SGIS       0x8191
+ #define GL_GENERATE_MIPMAP_HINT_SGIS  0x8192
+ #define GL_SGIS_generate_mipmap    1
+#endif // GL_SGIS_generate_mipmap
+
+
+//************************************************************************
+//****                  GLFW internal functions                       ****
+//************************************************************************
+
+//========================================================================
+// _glfwUpsampleImage() - Upsample image, from size w1 x h1 to w2 x h2
+//========================================================================
+
+static void _glfwUpsampleImage( unsigned char *src, unsigned char *dst,
+    int w1, int h1, int w2, int h2, int bpp )
+{
+    int m, n, k, x, y, col8;
+    float dx, dy, xstep, ystep, col, col1, col2;
+    unsigned char *src1, *src2, *src3, *src4;
+
+    // Calculate scaling factor
+    xstep = (float)(w1-1) / (float)(w2-1);
+    ystep = (float)(h1-1) / (float)(h2-1);
+
+    // Copy source data to destination data with bilinear interpolation
+    // Note: The rather strange look of this routine is a direct result of
+    // my attempts at optimizing it. Improvements are welcome!
+    dy = 0.0f;
+    y = 0;
+    for( n = 0; n < h2; n ++ )
+    {
+        dx = 0.0f;
+        src1 = &src[ y*w1*bpp ];
+        src3 = y < (h1-1) ? src1 + w1*bpp : src1;
+        src2 = src1 + bpp;
+        src4 = src3 + bpp;
+        x = 0;
+        for( m = 0; m < w2; m ++ )
+        {
+            for( k = 0; k < bpp; k ++ )
+            {
+                col1 = *src1 ++;
+                col2 = *src2 ++;
+                col = col1 + (col2 - col1) * dx;
+                col1 = *src3 ++;
+                col2 = *src4 ++;
+                col2 = col1 + (col2 - col1) * dx;
+                col += (col2 - col) * dy;
+                col8 = (int) (col + 0.5);
+                if( col8 >= 256 ) col8 = 255;
+                *dst++ = (unsigned char) col8;
+            }
+            dx += xstep;
+            if( dx >= 1.0f )
+            {
+                x ++;
+                dx -= 1.0f;
+                if( x >= (w1-1) )
+                {
+                    src2 = src1;
+                    src4 = src3;
+                }
+            }
+            else
+            {
+                src1 -= bpp;
+                src2 -= bpp;
+                src3 -= bpp;
+                src4 -= bpp;
+            }
+        }
+        dy += ystep;
+        if( dy >= 1.0f )
+        {
+            y ++;
+            dy -= 1.0f;
+        }
+    }
+}
+
+
+//========================================================================
+// _glfwHalveImage() - Build the next mip-map level
+//========================================================================
+
+static int _glfwHalveImage( GLubyte *src, int *width, int *height,
+    int components )
+{
+    int     halfwidth, halfheight, m, n, k, idx1, idx2;
+    GLubyte *dst;
+
+    // Last level?
+    if( *width <= 1 && *height <= 1 )
+    {
+        return GL_FALSE;
+    }
+
+    // Calculate new width and height (handle 1D case)
+    halfwidth  = *width > 1 ? *width / 2 : 1;
+    halfheight = *height > 1 ? *height / 2 : 1;
+
+    // Downsample image with a simple box-filter
+    dst = src;
+    if( *width == 1 || *height == 1 )
+    {
+        // 1D case
+        for( m = 0; m < halfwidth+halfheight-1; m ++ )
+        {
+            for( k = 0; k < components; k ++ )
+            {
+                *dst ++ = (GLubyte) (((int)*src +
+                                      (int)src[components] + 1) >> 1);
+                src ++;
+            }
+            src += components;
+        }
+    }
+    else
+    {
+        // 2D case
+        idx1 = *width*components;
+        idx2 = (*width+1)*components;
+        for( m = 0; m < halfheight; m ++ )
+        {
+            for( n = 0; n < halfwidth; n ++ )
+            {
+                for( k = 0; k < components; k ++ )
+                {
+                    *dst ++ = (GLubyte) (((int)*src +
+                                          (int)src[components] +
+                                          (int)src[idx1] +
+                                          (int)src[idx2] + 2) >> 2);
+                    src ++;
+                }
+                src += components;
+            }
+            src += components * (*width);
+        }
+    }
+
+    // Return new width and height
+    *width = halfwidth;
+    *height = halfheight;
+
+    return GL_TRUE;
+}
+
+
+//========================================================================
+// _glfwRescaleImage() - Rescales an image into power-of-two dimensions
+//========================================================================
+
+static int _glfwRescaleImage( GLFWimage* image )
+{
+    int     width, height, log2, newsize;
+    unsigned char *data;
+
+    // Calculate next larger 2^N width
+    for( log2 = 0, width = image->Width; width > 1; width >>= 1, log2 ++ )
+      ;
+    width  = (int) 1 << log2;
+    if( width < image->Width )
+    {
+	width <<= 1;
+    }
+
+    // Calculate next larger 2^M height
+    for( log2 = 0, height = image->Height; height > 1; height >>= 1, log2 ++ )
+      ;
+    height = (int) 1 << log2;
+    if( height < image->Height )
+    {
+	height <<= 1;
+    }
+
+    // Do we really need to rescale?
+    if( width != image->Width || height != image->Height )
+    {
+        // Allocate memory for new (upsampled) image data
+        newsize = width * height * image->BytesPerPixel;
+        data = (unsigned char *) malloc( newsize );
+        if( data == NULL )
+        {
+            free( image->Data );
+            return GL_FALSE;
+        }
+
+        // Copy old image data to new image data with interpolation
+        _glfwUpsampleImage( image->Data, data, image->Width, image->Height,
+                            width, height, image->BytesPerPixel );
+
+        // Free memory for old image data (not needed anymore)
+        free( image->Data );
+
+        // Set pointer to new image data, and set new image dimensions
+        image->Data   = data;
+        image->Width  = width;
+        image->Height = height;
+    }
+
+    return GL_TRUE;
+}
+
+
+//************************************************************************
+//****                    GLFW user functions                         ****
+//************************************************************************
+
+//========================================================================
+// glfwReadImage() - Read an image from a named file
+//========================================================================
+
+GLFWAPI int GLFWAPIENTRY glfwReadImage( const char *name, GLFWimage *img,
+    int flags )
+{
+    _GLFWstream stream;
+
+    // Is GLFW initialized?
+    if( !_glfwInitialized )
+    {
+        return GL_FALSE;
+    }
+
+    // Start with an empty image descriptor
+    img->Width         = 0;
+    img->Height        = 0;
+    img->BytesPerPixel = 0;
+    img->Data          = NULL;
+
+    // Open file
+    if( !_glfwOpenFileStream( &stream, name, "rb" ) )
+    {
+        return GL_FALSE;
+    }
+
+    // We only support TGA files at the moment
+    if( !_glfwReadTGA( &stream, img, flags ) )
+    {
+	_glfwCloseStream( &stream );
+        return GL_FALSE;
+    }
+
+    // Close stream
+    _glfwCloseStream( &stream );
+
+    // Should we rescale the image to closest 2^N x 2^M resolution?
+    if( !(flags & GLFW_NO_RESCALE_BIT) )
+    {
+	if( !_glfwRescaleImage( img ) )
+	{
+	    return GL_FALSE;
+	}
+    }
+
+    // Interpret BytesPerPixel as an OpenGL format
+    switch( img->BytesPerPixel )
+    {
+        default:
+        case 1:
+            if( flags & GLFW_ALPHA_MAP_BIT )
+            {
+                img->Format = GL_ALPHA;
+            }
+            else
+            {
+                img->Format = GL_LUMINANCE;
+            }
+            break;
+        case 3:
+            img->Format = GL_RGB;
+            break;
+        case 4:
+            img->Format = GL_RGBA;
+            break;
+    }
+
+    return GL_TRUE;
+}
+
+
+//========================================================================
+// glfwReadMemoryImage() - Read an image file from a memory buffer
+//========================================================================
+
+GLFWAPI int  GLFWAPIENTRY glfwReadMemoryImage( const void *data, long size, GLFWimage *img, int flags )
+{
+    _GLFWstream stream;
+
+    // Is GLFW initialized?
+    if( !_glfwInitialized )
+    {
+        return GL_FALSE;
+    }
+
+    // Start with an empty image descriptor
+    img->Width         = 0;
+    img->Height        = 0;
+    img->BytesPerPixel = 0;
+    img->Data          = NULL;
+
+    // Open buffer
+    if( !_glfwOpenBufferStream( &stream, (void*) data, size ) )
+    {
+        return GL_FALSE;
+    }
+
+    // We only support TGA files at the moment
+    if( !_glfwReadTGA( &stream, img, flags ) )
+    {
+	_glfwCloseStream( &stream );
+        return GL_FALSE;
+    }
+
+    // Close stream
+    _glfwCloseStream( &stream );
+
+    // Should we rescale the image to closest 2^N x 2^M resolution?
+    if( !(flags & GLFW_NO_RESCALE_BIT) )
+    {
+	if( !_glfwRescaleImage( img ) )
+	{
+	    return GL_FALSE;
+	}
+    }
+
+    // Interpret BytesPerPixel as an OpenGL format
+    switch( img->BytesPerPixel )
+    {
+        default:
+        case 1:
+            if( flags & GLFW_ALPHA_MAP_BIT )
+            {
+                img->Format = GL_ALPHA;
+            }
+            else
+            {
+                img->Format = GL_LUMINANCE;
+            }
+            break;
+        case 3:
+            img->Format = GL_RGB;
+            break;
+        case 4:
+            img->Format = GL_RGBA;
+            break;
+    }
+
+    return GL_TRUE;
+}
+
+
+//========================================================================
+// glfwFreeImage() - Free allocated memory for an image
+//========================================================================
+
+GLFWAPI void GLFWAPIENTRY glfwFreeImage( GLFWimage *img )
+{
+    // Is GLFW initialized?
+    if( !_glfwInitialized )
+    {
+        return;
+    }
+
+    // Free memory
+    if( img->Data != NULL )
+    {
+        free( img->Data );
+        img->Data = NULL;
+    }
+
+    // Clear all fields
+    img->Width         = 0;
+    img->Height        = 0;
+    img->Format        = 0;
+    img->BytesPerPixel = 0;
+}
+
+
+//========================================================================
+// glfwLoadTexture2D() - Read an image from a file, and upload it to
+// texture memory
+//========================================================================
+
+GLFWAPI int GLFWAPIENTRY glfwLoadTexture2D( const char *name, int flags )
+{
+    GLFWimage img;
+
+    // Is GLFW initialized?
+    if( !_glfwInitialized || !_glfwWin.Opened )
+    {
+        return GL_FALSE;
+    }
+
+    // Force rescaling if necessary
+    if( !_glfwWin.Has_GL_ARB_texture_non_power_of_two )
+    {
+      flags &= (~GLFW_NO_RESCALE_BIT);
+    }
+
+    // Read image from file
+    if( !glfwReadImage( name, &img, flags ) )
+    {
+        return GL_FALSE;
+    }
+
+    if( !glfwLoadTextureImage2D( &img, flags ) )
+    {
+	return GL_FALSE;
+    }
+
+    // Data buffer is not needed anymore
+    glfwFreeImage( &img );
+
+    return GL_TRUE;
+}
+
+
+//========================================================================
+// glfwLoadMemoryTexture2D() - Read an image from a buffer, and upload it to
+// texture memory
+//========================================================================
+
+GLFWAPI int  GLFWAPIENTRY glfwLoadMemoryTexture2D( const void *data, long size, int flags )
+{
+    GLFWimage img;
+
+    // Is GLFW initialized?
+    if( !_glfwInitialized || !_glfwWin.Opened )
+    {
+        return GL_FALSE;
+    }
+
+    // Force rescaling if necessary
+    if( !_glfwWin.Has_GL_ARB_texture_non_power_of_two )
+    {
+      flags &= (~GLFW_NO_RESCALE_BIT);
+    }
+
+    // Read image from file
+    if( !glfwReadMemoryImage( data, size, &img, flags ) )
+    {
+        return GL_FALSE;
+    }
+
+    if( !glfwLoadTextureImage2D( &img, flags ) )
+    {
+	return GL_FALSE;
+    }
+
+    // Data buffer is not needed anymore
+    glfwFreeImage( &img );
+
+    return GL_TRUE;
+}
+
+
+//========================================================================
+// glfwLoadTextureImage2D() - Upload an image object to texture memory
+//========================================================================
+
+GLFWAPI int  GLFWAPIENTRY glfwLoadTextureImage2D( GLFWimage *img, int flags )
+{
+    GLint   UnpackAlignment, GenMipMap;
+    int     level, format, AutoGen, newsize, n;
+    unsigned char *data, *dataptr;
+
+    // Is GLFW initialized?
+    if( !_glfwInitialized || !_glfwWin.Opened )
+    {
+        return GL_FALSE;
+    }
+
+    // TODO: Use GL_MAX_TEXTURE_SIZE or GL_PROXY_TEXTURE_2D to determine
+    //       whether the image size is valid.
+    // NOTE: May require box filter downsampling routine.
+
+    // Do we need to convert the alpha map to RGBA format (OpenGL 1.0)?
+    if( (_glfwWin.GLVerMajor == 1) && (_glfwWin.GLVerMinor == 0) &&
+        (img->Format == GL_ALPHA) )
+    {
+        // We go to RGBA representation instead
+        img->BytesPerPixel = 4;
+
+        // Allocate memory for new RGBA image data
+        newsize = img->Width * img->Height * img->BytesPerPixel;
+        data = (unsigned char *) malloc( newsize );
+        if( data == NULL )
+        {
+            free( img->Data );
+            return GL_FALSE;
+        }
+
+        // Convert Alpha map to RGBA
+        dataptr = data;
+        for( n = 0; n < (img->Width*img->Height); ++ n )
+        {
+            *dataptr ++ = 255;
+            *dataptr ++ = 255;
+            *dataptr ++ = 255;
+            *dataptr ++ = img->Data[n];
+        }
+
+        // Free memory for old image data (not needed anymore)
+        free( img->Data );
+
+        // Set pointer to new image data
+        img->Data = data;
+    }
+
+    // Set unpack alignment to one byte
+    glGetIntegerv( GL_UNPACK_ALIGNMENT, &UnpackAlignment );
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+
+    // Should we use automatic mipmap generation?
+    AutoGen = ( flags & GLFW_BUILD_MIPMAPS_BIT ) &&
+              _glfwWin.Has_GL_SGIS_generate_mipmap;
+
+    // Enable automatic mipmap generation
+    if( AutoGen )
+    {
+        glGetTexParameteriv( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,
+            &GenMipMap );
+        glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,
+            GL_TRUE );
+    }
+
+    // Format specification is different for OpenGL 1.0
+    if( _glfwWin.GLVerMajor == 1 && _glfwWin.GLVerMinor == 0 )
+    {
+        format = img->BytesPerPixel;
+    }
+    else
+    {
+        format = img->Format;
+    }
+
+    // Upload to texture memeory
+    level = 0;
+    do
+    {
+        // Upload this mipmap level
+        glTexImage2D( GL_TEXTURE_2D, level, format,
+            img->Width, img->Height, 0, format,
+            GL_UNSIGNED_BYTE, (void*) img->Data );
+
+        // Build next mipmap level manually, if required
+        if( ( flags & GLFW_BUILD_MIPMAPS_BIT ) && !AutoGen )
+        {
+            level = _glfwHalveImage( img->Data, &img->Width,
+                        &img->Height, img->BytesPerPixel ) ?
+                    level + 1 : 0;
+        }
+    }
+    while( level != 0 );
+
+    // Restore old automatic mipmap generation state
+    if( AutoGen )
+    {
+        glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,
+            GenMipMap );
+    }
+
+    // Restore old unpack alignment
+    glPixelStorei( GL_UNPACK_ALIGNMENT, UnpackAlignment );
+
+    return GL_TRUE;
+}
+