class GLTextureManager
    {
         private static byte[, ,] convertImageFormat( Surface texMap )
        {
            //Represents the image in an RGBA format.  
            byte[,,] bits = new byte[texMap.Width,texMap.Height,4];
            //Represents the current pixel which is being converted to RGBA.
            int pixelPtrOffset = texMap.Pixels.ToInt32( );
            //Calculate the offset for bitwise ops w/pixel masks.
            int surfacePitchOffset = -4 + texMap.BytesPerPixel;
            //Various data of the surface, cached here to avoid repeated 
            //calls during the nested loops.
            short pitch = texMap.Pitch;
            //The raw value of the pixel data.
            int colorValue = 0;
            //Represents the color masks of the pixel.
            int rMask = texMap.RedMask;
            int gMask = texMap.GreenMask;
            int bMask = texMap.BlueMask;
            int aMask = texMap.Alpha; 
            //Represents the number of bytes per pixel.
            //Usually 1,2,3,4.  
            int bytesPerPixel = texMap.BytesPerPixel; 
            
            for( int x = 0; x < texMap.Width; x ++ )
                for ( int y = 0; y < texMap.Height; y++ )
                {
                    //Calculate the current pointer for this pixel.
                    //Note that pitch is the number of bytes per row,
                    //Thus y*pitch gets us the correct row and x*bpp 
                    //gets us the correct column.
                    colorValue = 
                        Marshal.ReadInt32( new IntPtr( pixelPtrOffset + y * pitch + x * bytesPerPixel ).ToInt32( ), surfacePitchOffset );
                    //Get the current pixel's color.
                    int of = pixelPtrOffset - ( pixelPtrOffset + y * pitch + x * bytesPerPixel ); 
                    //Format it into RGBA.
                    bits[x, y, RED_COMPONENT]   = (byte)( rMask & colorValue );
                    bits[x, y, GREEN_COMPONENT] = (byte)( gMask & colorValue );
                    bits[x, y, BLUE_COMPONENT]  = (byte)( bMask & colorValue );
                    bits[x, y, ALPHA_COMPONENT] = (byte)( aMask & colorValue );
                }
            //Return image data in RGBA format.
            return bits; 
        }

         private static Dictionary<String, int> textures = new Dictionary<string,int>();

         public static int getTextureID( String fileName )
         {
             if( textures.ContainsKey( fileName ) )
                 return textures[fileName];
             System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch( );
             watch.Start( );
             System.Console.Out.Write( "Loading: " + fileName + "\n" );
             //Only using an array b/c glGenTextures
             //Requires them. 
             int[] textureId = new int[1];
             Gl.glGenTextures( 1, textureId );
             Gl.glBindTexture( Gl.GL_TEXTURE_2D, textureId[0] );
             //Now that we have bound our texture, lets set it's properties.
             Gl.glTexParameteri( Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT );
             Gl.glTexParameteri( Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT );
             Gl.glTexParameteri( Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR );
             Gl.glTexParameteri( Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR );
             //Set the texture's behavior, GL_MODULATE=lighting & coloring, 
             //Change to GL_DECAL to get rid of that.
             Gl.glTexEnvf( Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_MODULATE );
             //Upload the actual texture to video memory.
             //The surface to be converted into the proper image format.
             Surface texMap = new Surface( fileName );
             byte[, ,] texData = convertImageFormat( texMap );
             
             Glu.gluBuild2DMipmaps( Gl.GL_TEXTURE_2D, Gl.GL_RGBA, texMap.Width,
                                    texMap.Height, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, texData );
             
             textures[fileName] = textureId[0];
             watch.Stop( );
             System.Console.Out.Write( watch.ElapsedMilliseconds + "\n");
             return textureId[0];
         }

        /// <summary>
        /// Location of the R component in the byte array.
        /// </summary>
        private const int RED_COMPONENT = 0;

        /// <summary>
        /// Location of the G component in the byte array.
        /// </summary>
        private const int GREEN_COMPONENT = 1;

        /// <summary>
        /// Location of the B component in the byte array.
        /// </summary>
        private const int BLUE_COMPONENT = 2;

        /// <summary>
        /// Location of the A component in the byte array.
        /// </summary>
        private const int ALPHA_COMPONENT = 3;
   }