src/video/glsdl/SDL_glsdl.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/*
 * glSDL "SDL-over-OpenGL" video driver implemented by
 * David Olofson <david@olofson.net> and
 * Stephane Marchesin <stephane.marchesin@wanadoo.fr>
 */
#include <math.h>

#include "SDL.h"
#include "SDL_error.h"
#include "SDL_video.h"
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"

#include "SDL_glsdl.h"

#undef	DEBUG_GLSDL
#undef	DEBUG_GLSDL_CHOP
#define	FAKE_MAXTEXSIZE	256
#undef GLSDL_GRAPHICAL_DEBUG

/* Initialization/Query functions */

/* Hardware surface functions */
static int glSDL_SetColors(_THIS, int firstcolor, int ncolors,
                           SDL_Color * colors);
static int glSDL_AllocHWSurface(_THIS, SDL_Surface * surface);
static int glSDL_LockHWSurface(_THIS, SDL_Surface * surface);
static int glSDL_FlipHWSurface(_THIS, SDL_Surface * surface);
static void glSDL_UnlockHWSurface(_THIS, SDL_Surface * surface);
static void glSDL_FreeHWSurface(_THIS, SDL_Surface * surface);
static int glSDL_FillHWRect(_THIS, SDL_Surface * dst, SDL_Rect * rect,
                            Uint32 color);
static int glSDL_CheckHWBlit(_THIS, SDL_Surface * src, SDL_Surface * dst);
static int glSDL_SetHWColorKey(_THIS, SDL_Surface * surface, Uint32 key);
static int glSDL_SetHWAlpha(_THIS, SDL_Surface * surface, Uint8 alpha);
static int glSDL_VideoInit(_THIS, SDL_PixelFormat * vformat);
static SDL_Rect **glSDL_ListModes(_THIS, SDL_PixelFormat * format,
                                  Uint32 flags);
static void glSDL_VideoQuit(_THIS);
static void glSDL_UpdateRects(_THIS, int numrects, SDL_Rect * rects);
static SDL_Surface *glSDL_SetVideoMode(_THIS, SDL_Surface * current,
                                       int width, int height, int bpp,
                                       Uint32 flags);

#define	IS_GLSDL_SURFACE(s)	((s) && glSDL_GetTexInfo(s))

#define	LOGIC_W(s)	( IS_GLSDL_SURFACE(this,s) ? TEXINFO(s)->lw : (s)->w )
#define	LOGIC_H(s)	( IS_GLSDL_SURFACE(this,s) ? TEXINFO(s)->lh : (s)->h )

#define	GLSDL_NOTEX	(~0)

/*
 * Special version for glSDL, which ignores the fake SDL_HWSURFACE
 * flags, so we don't have SDL calling us back whenever we want to
 * do some internal blitting...
 */
static void
glSDL_SoftBlit(SDL_Surface * src, SDL_Rect * srcrect,
               SDL_Surface * dst, SDL_Rect * dstrect)
{
    SDL_BlitInfo info;

    if (srcrect)
        if (!srcrect->w || !srcrect->h)
            return;

    /* Check to make sure the blit mapping is valid */
    if ((src->map->dst != dst) ||
        (src->map->dst->format_version != src->map->format_version))
        if (SDL_MapSurface(src, dst) < 0)
            return;

    /* Set up the blit information */
    if (srcrect) {
        info.s_pixels = (Uint8 *) src->pixels +
            (Uint16) srcrect->y * src->pitch +
            (Uint16) srcrect->x * src->format->BytesPerPixel;
        info.s_width = srcrect->w;
        info.s_height = srcrect->h;
    } else {
        info.s_pixels = (Uint8 *) src->pixels;
        info.s_width = src->w;
        info.s_height = src->h;
    }
    info.s_skip = src->pitch - info.s_width * src->format->BytesPerPixel;
    if (dstrect) {
        info.d_pixels = (Uint8 *) dst->pixels +
            (Uint16) dstrect->y * dst->pitch +
            (Uint16) dstrect->x * dst->format->BytesPerPixel;
        /*
         * NOTE: SDL_SoftBlit() uses the 'dstrect' for this!
         *       This version is more like SDL_BlitSurface().
         */
        info.d_width = srcrect->w;
        info.d_height = srcrect->h;
    } else {
        info.d_pixels = (Uint8 *) dst->pixels;
        info.d_width = dst->w;
        info.d_height = dst->h;
    }
    info.d_skip = dst->pitch - info.d_width * dst->format->BytesPerPixel;
    info.aux_data = src->map->sw_data->aux_data;
    info.src = src->format;
    info.table = src->map->table;
    info.dst = dst->format;

    src->map->sw_data->blit(&info);
}


/* 
 * Another special version. Doesn't lock/unlock, and doesn't mess
 * with flags and stuff. It just converts the surface, period.
 * Does not convert into palletized formats.
 */
static SDL_Surface *
glSDL_ConvertSurface(SDL_Surface * surface,
                     SDL_PixelFormat * format, Uint32 flags)
{
    SDL_Surface *convert;
    Uint32 colorkey = 0;
    Uint8 alpha = 0;
    Uint32 surface_flags;
    SDL_Rect bounds;

    /* Create a new surface with the desired format */
    convert = SDL_CreateRGBSurface(flags,
                                   surface->w, surface->h,
                                   format->BitsPerPixel, format->Rmask,
                                   format->Gmask, format->Bmask,
                                   format->Amask);
    if (convert == NULL) {
        return (NULL);
    }

    /* Save the original surface color key and alpha */
    surface_flags = surface->flags;
    if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
        /* Convert colourkeyed surfaces to RGBA if requested */
        if ((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY && format->Amask) {
            surface_flags &= ~SDL_SRCCOLORKEY;
        } else {
            colorkey = surface->format->colorkey;
            SDL_SetColorKey(surface, 0, 0);
        }
    }
    if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
        /* Copy over the alpha channel to RGBA if requested */
        if (format->Amask) {
            surface->flags &= ~SDL_SRCALPHA;
        } else {
            alpha = surface->format->alpha;
            SDL_SetAlpha(surface, 0, 0);
        }
    }

    /* Copy over the image data */
    bounds.x = 0;
    bounds.y = 0;
    bounds.w = surface->w;
    bounds.h = surface->h;
    glSDL_SoftBlit(surface, &bounds, convert, &bounds);

    /* Clean up the original surface, and update converted surface */
    if (convert != NULL) {
        SDL_SetClipRect(convert, &surface->clip_rect);
    }
    if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
        Uint32 cflags = surface_flags & (SDL_SRCCOLORKEY | SDL_RLEACCELOK);
        if (convert != NULL) {
            Uint8 keyR, keyG, keyB;

            SDL_GetRGB(colorkey, surface->format, &keyR, &keyG, &keyB);
            SDL_SetColorKey(convert, cflags | (flags & SDL_RLEACCELOK),
                            SDL_MapRGB(convert->format, keyR, keyG, keyB));
        }
        SDL_SetColorKey(surface, cflags, colorkey);
    }
    if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
        Uint32 aflags = surface_flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
        if (convert != NULL) {
            SDL_SetAlpha(convert, aflags | (flags & SDL_RLEACCELOK), alpha);
        }
        if (format->Amask) {
            surface->flags |= SDL_SRCALPHA;
        } else {
            SDL_SetAlpha(surface, aflags, alpha);
        }
    }

    /* We're ready to go! */
    return (convert);
}


/*----------------------------------------------------------
  Some OpenGL function wrappers
  ----------------------------------------------------------*/

static struct
{
    int do_blend;
    int do_texture;
    GLuint texture;
    GLenum sfactor, dfactor;
} glstate;

static void
glSDL_reset(void)
{
    glstate.do_blend = -1;
    glstate.do_blend = -1;
    glstate.texture = GLSDL_NOTEX;
    glstate.sfactor = 0xffffffff;
    glstate.dfactor = 0xffffffff;
}

static __inline__ void
glSDL_do_blend(_THIS, int on)
{
    if (glstate.do_blend == on)
        return;

    if (on)
        this->glEnable(GL_BLEND);
    else
        this->glDisable(GL_BLEND);
    glstate.do_blend = on;
}

static __inline__ void
glSDL_do_texture(_THIS, int on)
{
    if (glstate.do_texture == on)
        return;

    if (on)
        this->glEnable(GL_TEXTURE_2D);
    else
        this->glDisable(GL_TEXTURE_2D);
    glstate.do_texture = on;
}

static __inline__ void
glSDL_blendfunc(_THIS, GLenum sfactor, GLenum dfactor)
{
    if ((sfactor == glstate.sfactor) && (dfactor == glstate.dfactor))
        return;

    this->glBlendFunc(sfactor, dfactor);

    glstate.sfactor = sfactor;
    glstate.dfactor = dfactor;
}

static __inline__ void
glSDL_texture(_THIS, GLuint tx)
{
    if (tx == glstate.texture)
        return;

    this->glBindTexture(GL_TEXTURE_2D, tx);
    glstate.texture = tx;
}


/*----------------------------------------------------------
  glSDL specific data types
  ----------------------------------------------------------*/

typedef enum
{
    GLSDL_TM_SINGLE,
    GLSDL_TM_HORIZONTAL,
    GLSDL_TM_VERTICAL,
    GLSDL_TM_HUGE
} GLSDL_TileModes;


typedef struct private_hwdata
{
    /* Size of surface in logic screen pixels */
    int lw, lh;

    int textures;
    GLuint *texture;
    int texsize;                /* width/height of OpenGL texture */
    GLSDL_TileModes tilemode;
    int tilew, tileh;           /* At least one must equal texsize! */
    int tilespertex;
    SDL_Rect virt;              /* Total size of assembled surface */

    /* Area of surface to upload when/after unlocking */
    SDL_Rect invalid_area;

    int temporary;              /* Throw away after one use. */

    SDL_Surface *next;          /* The next Surface in our linked list of hardware surfaces ; == NULL if first surface */
    SDL_Surface *prev;          /* The prev Surface in our linked list of hardware surfaces ; == NULL if last surface */
} private_hwdata;

/* some function prototypes */
static void glSDL_Invalidate(SDL_Surface * surface, SDL_Rect * area);
static void glSDL_SetLogicSize(_THIS, SDL_Surface * surface, int w, int h);
static private_hwdata *glSDL_UploadSurface(_THIS, SDL_Surface * surface);
static private_hwdata *glSDL_GetTexInfo(SDL_Surface * surface);
static void glSDL_init_formats(_THIS);
static private_hwdata *glSDL_AddTexInfo(_THIS, SDL_Surface * surface);
static void glSDL_RemoveTexInfo(_THIS, SDL_Surface * surface);
static void glSDL_UnloadTexture(_THIS, private_hwdata * txi);
static int glSDL_BlitGL(_THIS, SDL_Surface * src,
                        SDL_Rect * srcrect, SDL_Rect * dstrect);

/* some variables */
static GLint maxtexsize = -1;
static SDL_PixelFormat *RGBfmt = NULL;
static SDL_PixelFormat *RGBAfmt = NULL;
static void *mirrorbuf = NULL;
/* the raw 888 opengl surface, hidden from the application */
SDL_Surface *OpenGL_Surface;

/* pointer to the beggining of the list used for memory allocation */
SDL_Surface *first = NULL;

#ifdef DEBUG_GLSDL
static __inline__ int
GLERET(const char *txt)
{
    fprintf(stderr, "glSDL ERROR: '%s'\n", txt);
    return -1;
}
static __inline__ void
GLERR(const char *txt)
{
    fprintf(stderr, "glSDL ERROR: '%s'\n", txt);
}
#else
#define	GLERET(x)	(-1)
#define	GLERR(x)
#endif

static SDL_VideoDevice underlying_device;
static int old_screen_flags;

/* 
 * List of video drivers known to support OpenGL 
 * The purpose of this is to make glSDL "portable" across
 * all video backends that support OpenGL
 */
static VideoBootStrap *opengl_bootstrap =
#if SDL_VIDEO_DRIVER_QUARTZ
    &QZ_bootstrap;
#elif SDL_VIDEO_DRIVER_X11
    &X11_bootstrap;
#elif SDL_VIDEO_DRIVER_WINDIB
    &WINDIB_bootstrap;
#elif SDL_VIDEO_DRIVER_BWINDOW
    &BWINDOW_bootstrap;
#elif SDL_VIDEO_DRIVER_TOOLBOX
    &TOOLBOX_bootstrap;
#elif SDL_VIDEO_DRIVER_CYBERGRAPHICS
    &CGX_bootstrap;
#elif SDL_VIDEO_DRIVER_PHOTON
    &ph_bootstrap;
#elif SDL_VIDEO_DRIVER_DC
    &DC_bootstrap;
#else
    NULL;
#endif

static int
glSDL_Available(void)
{
#ifdef DEBUG_GLSDL
    fprintf(stderr, "available\n");
#endif
    if (opengl_bootstrap == NULL)
        return 0;
    return (opengl_bootstrap->available());
}

static void
glSDL_DeleteDevice(SDL_VideoDevice * device)
{
    SDL_free(device->hidden);
    SDL_free(device);
}

/* Create a glSDL device */
static SDL_VideoDevice *
glSDL_CreateDevice(int devindex)
{
    SDL_VideoDevice *device;
#ifdef DEBUG_GLSDL
    fprintf(stderr, "entering createdevice\n");
#endif

    /* Create the device with the underlying driver */
    device = opengl_bootstrap->create(devindex);

    /* Save the video device contents for future use */
    SDL_memcpy(&underlying_device, device, sizeof(SDL_VideoDevice));

    /* Hook glSDL on the video device */
    device->VideoInit = glSDL_VideoInit;
    device->ListModes = glSDL_ListModes;
    device->VideoQuit = glSDL_VideoQuit;
    device->UpdateRects = glSDL_UpdateRects;
    device->FillHWRect = glSDL_FillHWRect;
    device->SetHWColorKey = glSDL_SetHWColorKey;
    device->SetHWAlpha = glSDL_SetHWAlpha;
    device->AllocHWSurface = glSDL_AllocHWSurface;
    device->LockHWSurface = glSDL_LockHWSurface;
    device->UnlockHWSurface = glSDL_UnlockHWSurface;
    device->FlipHWSurface = glSDL_FlipHWSurface;
    device->FreeHWSurface = glSDL_FreeHWSurface;
    device->CheckHWBlit = glSDL_CheckHWBlit;
    device->SetColors = glSDL_SetColors;
    device->SetVideoMode = glSDL_SetVideoMode;
    device->info.hw_available = 1;
    device->info.blit_hw = 1;
    device->info.blit_hw_CC = 1;
    device->info.blit_hw_A = 1;
    device->info.blit_sw = 1;
    device->info.blit_sw_CC = 1;
    device->info.blit_sw_A = 1;
    device->info.blit_fill = 1;

    /* These functions are not supported by glSDL, so we NULLify them */
    device->SetGamma = NULL;
    device->GetGamma = NULL;
    device->SetGammaRamp = NULL;
    device->GetGammaRamp = NULL;
    device->ToggleFullScreen = NULL;

    device->free = glSDL_DeleteDevice;

#ifdef DEBUG_GLSDL
    fprintf(stderr, "leaving createdevice\n");
#endif

    return device;
}

/* Our bootstraping structure */
VideoBootStrap glSDL_bootstrap = {
    "glSDL", "glSDL - SDL over OpenGL",
    glSDL_Available, glSDL_CreateDevice
};

static int
glSDL_VideoInit(_THIS, SDL_PixelFormat * vformat)
{
    int r;
    printf("glSDL videoinit\n");
#ifdef DEBUG_GLSDL
    fprintf(stderr, "videoinit\n");
#endif
    r = underlying_device.VideoInit(this, vformat);
    this->info.hw_available = 1;
    this->info.blit_hw = 1;
    this->info.blit_hw_CC = 1;
    this->info.blit_hw_A = 1;
    this->info.blit_sw = 1;
    this->info.blit_sw_CC = 1;
    this->info.blit_sw_A = 1;
    this->info.blit_fill = 1;

    return r;
}

SDL_Rect **
glSDL_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
{
    return ((SDL_Rect **) - 1);
}

static void
glSDL_VideoQuit(_THIS)
{
    SDL_Surface *scr;

    /* free all hwdata structures */
    while (first != NULL)
        glSDL_RemoveTexInfo(this, first);

    SDL_free(mirrorbuf);
    mirrorbuf = NULL;

    SDL_FreeFormat(RGBfmt);
    SDL_FreeFormat(RGBAfmt);
    RGBfmt = RGBAfmt = NULL;

    SDL_FreeFormat(this->displayformatalphapixel);
    this->displayformatalphapixel = NULL;

    SDL_FreeSurface(OpenGL_Surface);
    OpenGL_Surface = NULL;

    /* restore the flags to gracefully exit from fullscreen */
    this->screen->flags = old_screen_flags;

    /* keep the screen */
    scr = this->screen;

    /* we cleaned up our stuff, now restore the underlying video driver */
    SDL_memcpy(this, &underlying_device, sizeof(SDL_VideoDevice));

    this->screen = scr;

    /* call the underlying video driver's VideoQuit function */
    this->VideoQuit(this);
}

static SDL_Surface *
glSDL_SetVideoMode(_THIS, SDL_Surface * current, int width, int height,
                   int bpp, Uint32 flags)
{
    SDL_Surface *hooked_screen;
    int i;
    int flag_doublebuf = 0;

    if (opengl_bootstrap == NULL) {
        GLERR("No bootstrap for glSDL compiled in !\n");
        return NULL;
    }

    /* we don't have OpenGL */
    if ((flags & SDL_INTERNALOPENGL) == SDL_INTERNALOPENGL) {
        GLERR("OpenGL video modes are not supported by glSDL !\n");
        return (NULL);
    }

    /* 
     * Adjust the flags
     */
    flags &= ~SDL_HWPALETTE;
    flags |= SDL_INTERNALOPENGL;

    /* remember whether the user requested DOUBLEBUF */

    if (flags & SDL_DOUBLEBUF) {
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
        flag_doublebuf = 1;
    } else {
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0);
        flag_doublebuf = 0;
    }

    hooked_screen =
        underlying_device.SetVideoMode(this, current, width, height, 0,
                                       flags);

    if (!hooked_screen) {
        GLERR("Unable to open an OpenGL window !\n");
        return (NULL);
    }

    /* save the screen flags for restore time */
    old_screen_flags = hooked_screen->flags;

#ifdef DEBUG_GLSDL
    fprintf(stderr, "got %d bpp\n", bpp);
#endif

    /* setup the public surface format
     * glSDL always returns the bpp its asked
     */
    switch (bpp) {
    case 32:
        this->is_32bit = 1;
        this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                                            0x00FF0000,
                                            0x0000FF00, 0x000000FF, 0x00000000
#else
                                            0x0000FF00,
                                            0x00FF0000, 0xFF000000, 0x00000000
#endif
            );
        break;
    case 24:
        this->is_32bit = 0;
        this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                                            0x00FF0000,
                                            0x0000FF00, 0x000000FF, 0x00000000
#else
                                            0x0000FF00,
                                            0x00FF0000, 0xFF000000, 0x00000000
#endif
            );
        break;
    case 16:
        this->is_32bit = 0;
        this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                                            0x0000F800,
                                            0x000007E0, 0x0000001F, 0x00000000
#else
                                            0x0000001F,
                                            0x000007E0, 0x0000F800, 0x00000000
#endif
            );
        break;
    case 15:
        this->is_32bit = 0;
        this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                                            0x00007C00,
                                            0x000003E0, 0x0000001F, 0x00000000
#else
                                            0x0000001F,
                                            0x000003E0, 0x00007C00, 0x00000000
#endif
            );
        break;
    case 8:
    default:
        this->is_32bit = 0;
        this->screen =
            SDL_CreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0);
        /* give it a default palette if 8 bpp
         * note : SDL already takes care of the palette for 4 bits & 1 bit surfaces 
         */
/*			if (bpp==8)
			{
				this->screen->format->palette->ncolors=255;
				SDL_DitherColors(this->screen->format->palette->colors,bpp);
			}*/
        break;
    }

    /* also, we add SDL_HWSURFACE all the time, and let SDL create a shadow surface accordingly */
    this->screen->flags =
        hooked_screen->flags | SDL_HWSURFACE | SDL_INTERNALOPENGL;
    /* add SDL_DOUBLEBUF if it was requested */
    if (flag_doublebuf)
        this->screen->flags |= SDL_DOUBLEBUF;

    /* Tell SDL the alpha pixel format we'd like to have */
    this->displayformatalphapixel = SDL_AllocFormat(32,
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
                                                    0xFF000000,
                                                    0x00FF0000,
                                                    0x0000FF00, 0x000000FF
#else
                                                    0x000000FF,
                                                    0x0000FF00,
                                                    0x00FF0000, 0xFF000000
#endif
        );

    /* Now create the raw OpenGL surface */
    OpenGL_Surface = SDL_CreateRGBSurface(flags, width, height, 24,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                                          0x000000FF,
                                          0x0000FF00, 0x00FF0000, 0x00000000
#else
                                          0xFF000000,
                                          0x00FF0000, 0x0000FF00, 0x00000000
#endif
        );

    /* Here we have to setup OpenGL funcs ourselves */
#ifndef __QNXNTO__
#define SDL_PROC(ret,func,params) \
	do { \
		this->func = SDL_GL_GetProcAddress(#func); \
			if ( ! this->func ) { \
				SDL_SetError("Couldn't load GL function: %s\n", #func); \
					return(NULL); \
			} \
	} while ( 0 );
#else
#define SDL_PROC(ret,func,params) this->func=func;
#endif /* __QNXNTO__ */
#include "../SDL_glfuncs.h"
#undef SDL_PROC

    if (this->GL_MakeCurrent(this) < 0)
        return (NULL);
#define SDL_PROC(ret,func,params) \
	do { \
		this->func = SDL_GL_GetProcAddress(#func); \
			if ( ! this->func ) { \
				SDL_SetError("Couldn't load GL function: %s\n", #func); \
					return(NULL); \
			} \
	} while ( 0 );
#include "../SDL_glfuncs.h"
#undef SDL_PROC


#ifdef	FAKE_MAXTEXSIZE
    maxtexsize = FAKE_MAXTEXSIZE;
#else
    this->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);
#endif
#ifdef DEBUG_GLSDL
    fprintf(stderr, "glSDL: Max texture size: %d\n", maxtexsize);
#endif

    glSDL_init_formats(this);

    if (flag_doublebuf)
        this->glDrawBuffer(GL_BACK);
    else
        this->glDrawBuffer(GL_FRONT);

    this->glDisable(GL_DITHER);

    if (glSDL_AddTexInfo(this, this->screen) < 0) {
        GLERR("HookDevice() failed to add info to screen surface!");
        return NULL;
    }

    glSDL_SetLogicSize(this, this->screen, this->screen->w, this->screen->h);

    glSDL_do_texture(this, 0);
    glSDL_do_blend(this, 0);

    for (i = 0; i < 1 + flag_doublebuf; ++i) {
        this->glBegin(GL_TRIANGLE_FAN);
        this->glColor3ub(0, 0, 0);
        this->glVertex2i(0, 0);
        this->glVertex2i(this->screen->w, 0);
        this->glVertex2i(this->screen->w, this->screen->h);
        this->glVertex2i(0, this->screen->h);
        this->glEnd();
        if (!i)
            this->GL_SwapBuffers(this);
    }

    mirrorbuf = SDL_malloc(this->screen->h * this->screen->pitch);
    if (!mirrorbuf) {
        GLERR("HookDevice() failed to allocate temp buffer for mirroring!");
        return NULL;
    }

    return this->screen;
}

static int
glSDL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
{
    /* We don't need to fill this one */
    return 0;
}


#ifdef DEBUG_GLSDL
static void
glSDL_print_glerror(_THIS, int point)
{
    const char *err = "<unknown>";
    switch (this->glGetError()) {
    case GL_NO_ERROR:
        return;
    case GL_INVALID_ENUM:
        err = "GL_INVALID_ENUM";
        break;
    case GL_INVALID_VALUE:
        err = "GL_INVALID_VALUE";
        break;
    case GL_INVALID_OPERATION:
        err = "GL_INVALID_OPERATION";
        break;
    case GL_STACK_OVERFLOW:
        err = "GL_STACK_OVERFLOW";
        break;
    case GL_STACK_UNDERFLOW:
        err = "GL_STACK_UNDERFLOW";
        break;
    case GL_OUT_OF_MEMORY:
        err = "GL_OUT_OF_MEMORY";
    default:
        break;
    }
    fprintf(stderr, "OpenGL error \"%s\" at point %d.\n", err, point);
}
#endif

/* Get texinfo for a surface. */
static __inline__ private_hwdata *
glSDL_GetTexInfo(SDL_Surface * surface)
{
    if (!surface)
        return NULL;
    return surface->hwdata;
}


/* Allocate a "blank" texinfo for a suface. */
static private_hwdata *
glSDL_AllocTexInfo(SDL_Surface * surface)
{
    private_hwdata *txi;
    if (!surface)
        return NULL;

    txi = glSDL_GetTexInfo(surface);
    if (txi)
        return txi;             /* There already is one! --> */

    /* ...and hook a new texinfo struct up to it. */
    txi = (private_hwdata *) SDL_calloc(1, sizeof(private_hwdata));
    if (!txi) {
        GLERR("AllocTexInfo(): Failed allocating TexInfo struct!");
        return NULL;
    }
    txi->temporary = 1;
#ifdef DEBUG_GLSDL
    fprintf(stderr, "glSDL: Allocated TexInfo %p.\n", txi);
#endif
    return txi;
}


static void
glSDL_FreeTexInfo(_THIS, private_hwdata * txi)
{
    if (!txi)
        return;

    glSDL_UnloadTexture(this, txi);
    SDL_free(txi->texture);
    SDL_free(txi);
#ifdef DEBUG_GLSDL
    fprintf(stderr, "glSDL: Freed TexInfo %p.\n", txi);
#endif
}


/* Detach and free the texinfo of a surface. */
static void
glSDL_RemoveTexInfo(_THIS, SDL_Surface * surface)
{
    SDL_Surface *next, *prev;
    if (!glSDL_GetTexInfo(surface))
        return;

    /* maintain our doubly linked list */
    next = surface->hwdata->next;
    prev = surface->hwdata->prev;
    if (prev != NULL) {
        prev->hwdata->next = next;
    } else {
        first = next;
    }
    if (next != NULL) {
        next->hwdata->prev = prev;
    }

    glSDL_FreeTexInfo(this, surface->hwdata);
    surface->hwdata = NULL;
}


/*
 * Calculate chopping/tiling of a surface to
 * fit it into the smallest possible OpenGL
 * texture.
 */
static int
glSDL_CalcChop(private_hwdata * txi)
{
    int rows, vw, vh;
    int vertical = 0;
    int texsize;
    int lastw, lasth, minsize;

    vw = txi->virt.w;
    vh = txi->virt.h;

#ifdef DEBUG_GLSDL_CHOP
    fprintf(stderr, "w=%d, h=%d ", vw, vh);
#endif
    if (vh > vw) {
        int t = vw;
        vw = vh;
        vh = t;
        vertical = 1;
#ifdef DEBUG_GLSDL_CHOP
        fprintf(stderr, "(vertical) \t");
#endif
    }

    /*
     * Check whether this is a "huge" surface - at least one dimension
     * must be <= than the maximum texture size, or we'll have to chop
     * in both directions.
     */
#ifdef DEBUG_GLSDL
    if (maxtexsize < 0)
        return GLERET("glSDL_CalcChop() called before OpenGL init!");
#endif
    if (vh > maxtexsize) {
        /*
         * Very simple hack for now; we just tile
         * both ways with maximum size textures.
         */
        texsize = maxtexsize;

        txi->tilemode = GLSDL_TM_HUGE;
        txi->texsize = texsize;
        txi->tilew = texsize;
        txi->tileh = texsize;
        txi->tilespertex = 1;

        /* Calculate number of textures needed */
        txi->textures = (vw + texsize - 1) / texsize;
        txi->textures *= (vh + texsize - 1) / texsize;
        txi->texture = SDL_malloc(txi->textures * sizeof(int));
        SDL_memset(txi->texture, -1, txi->textures * sizeof(int));
#ifdef DEBUG_GLSDL
        fprintf(stderr, "two-way tiling; textures=%d\n", txi->textures);
#endif
        if (!txi->texture) {
            fprintf(stderr, "glSDL: INTERNAL ERROR: Failed to allocate"
                    " texture name table!\n");
            return -3;
        }
        return 0;
    }

    /* Calculate minimum size */
    rows = 1;
    lastw = vw;
    lasth = vh;
    minsize = lastw > lasth ? lastw : lasth;
    while (1) {
        int w, h, size;
        ++rows;
        w = vw / rows;
        h = rows * vh;
        size = w > h ? w : h;
        if (size >= minsize) {
            --rows;
            break;
        }
        lastw = w;
        lasth = h;
        minsize = size;
    }
    if (minsize > maxtexsize) {
        /* Handle multiple textures for very wide/tall surfaces. */
        minsize = maxtexsize;
        rows = (vw + minsize - 1) / minsize;
    }
#ifdef DEBUG_GLSDL_CHOP
    fprintf(stderr, "==> minsize=%d ", minsize);
    fprintf(stderr, "(rows=%d) \t", rows);
#endif

    /* Recalculate with nearest higher power-of-2 width. */
    for (texsize = 1; texsize < minsize; texsize <<= 1);
    txi->texsize = texsize;
    rows = (vw + texsize - 1) / texsize;
#ifdef DEBUG_GLSDL_CHOP
    fprintf(stderr, "==> texsize=%d (rows=%d) \t", texsize, rows);
#endif

    /* Calculate number of tiles per texture */
    txi->tilespertex = txi->texsize / vh;
#ifdef DEBUG_GLSDL_CHOP
    fprintf(stderr, "tilespertex=%d \t", txi->tilespertex);
#endif

    /* Calculate number of textures needed */
    txi->textures = (rows + txi->tilespertex - 1) / txi->tilespertex;
    txi->texture = (GLuint *) SDL_malloc(txi->textures * sizeof(GLuint));
    SDL_memset(txi->texture, GLSDL_NOTEX, txi->textures * sizeof(GLuint));
#ifdef DEBUG_GLSDL_CHOP
    fprintf(stderr, "textures=%d, ", txi->textures);
#endif
    if (!txi->texture)
        return GLERET("Failed to allocate texture name table!");

    /* Set up tile size. (Only one axis supported here!) */
    if (1 == rows) {
        txi->tilemode = GLSDL_TM_SINGLE;
        if (vertical) {
            txi->tilew = vh;
            txi->tileh = vw;
        } else {
            txi->tilew = vw;
            txi->tileh = vh;
        }
    } else if (vertical) {
        txi->tilemode = GLSDL_TM_VERTICAL;
        txi->tilew = vh;
        txi->tileh = texsize;
    } else {
        txi->tilemode = GLSDL_TM_HORIZONTAL;
        txi->tilew = texsize;
        txi->tileh = vh;
    }

#ifdef DEBUG_GLSDL_CHOP
    fprintf(stderr, "tilew=%d, tileh=%d\n", txi->tilew, txi->tileh);
#endif
    return 0;
}


/* Create a temporary TexInfo struct for an SDL_Surface */
static private_hwdata *
glSDL_CreateTempTexInfo(_THIS, SDL_Surface * surface)
{
    private_hwdata *txi;
    if (!surface) {
        GLERR("CreateTempTexInfo(); no surface!");
        return NULL;
    }
    if (IS_GLSDL_SURFACE(surface))
        return glSDL_GetTexInfo(surface);       /* Do nothing */

    txi = glSDL_AllocTexInfo(surface);
    if (!txi) {
        GLERR("CreateTempTexInfo(); Could not alloc TexInfo!");
        return NULL;
    }
    txi->virt.w = txi->lw = surface->w;
    txi->virt.h = txi->lh = surface->h;

    if (glSDL_CalcChop(txi) < 0) {
        glSDL_FreeTexInfo(this, txi);
        GLERR("CreateTempTexInfo(); CalcChop() failed!");
        return NULL;
    }

    return txi;
}

/* Add a glSDL_TexInfo struct to an SDL_Surface */
static private_hwdata *
glSDL_AddTexInfo(_THIS, SDL_Surface * surface)
{
    private_hwdata *txi = glSDL_CreateTempTexInfo(this, surface);
    if (!txi)
        return NULL;

    /* Connect the surface to the new TexInfo. */
    txi->temporary = 0;
    surface->hwdata = txi;

    /* add this new surface in front of the list of hw surfaces */
    txi->next = first;
    txi->prev = NULL;
    first = surface;
    if (txi->next != NULL) {
        txi->next->hwdata->prev = surface;
    }

    SDL_SetClipRect(surface, &txi->virt);
    return txi;
}


/* Create a surface of the prefered OpenGL RGB texture format */
/*static SDL_Surface *glSDL_CreateRGBSurface(int w, int h)
{
	SDL_Surface *s;
	Uint32 rmask, gmask, bmask;
	int bits = 24;
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
	rmask = 0x000000FF;
	gmask = 0x0000FF00;
	bmask = 0x00FF0000;
#else
	rmask = 0x00FF0000;
	gmask = 0x0000FF00;
	bmask = 0x000000FF;
#endif
	s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
			bits, rmask, gmask, bmask, 0);
	if(s)
		s->flags |= SDL_HWACCEL;

	return s;
}
*/

/* Create a surface of the prefered OpenGL RGBA texture format */
static SDL_Surface *
glSDL_CreateRGBASurface(int w, int h)
{
    SDL_Surface *s;
    Uint32 rmask, gmask, bmask, amask;
    int bits = 32;
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
    rmask = 0x000000FF;
    gmask = 0x0000FF00;
    bmask = 0x00FF0000;
    amask = 0xFF000000;
#else
    rmask = 0xFF000000;
    gmask = 0x00FF0000;
    bmask = 0x0000FF00;
    amask = 0x000000FF;
#endif
    s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
                             bits, rmask, gmask, bmask, amask);
    if (s)
        s->flags |= SDL_HWACCEL;

    return s;
}


static void
glSDL_init_formats(_THIS)
{
    RGBfmt = SDL_AllocFormat(24,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                             0x000000FF, 0x0000FF00, 0x00FF0000, 0);
#else
                             0x00FF0000, 0x0000FF00, 0x000000FF, 0);
#endif
    RGBAfmt = SDL_AllocFormat(32,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                              0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000);
#else
                              0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
#endif
}


static int
glSDL_FormatIsOk(SDL_Surface * surface)
{
    SDL_PixelFormat *pf;
    if (!surface)
        return 1;               /* Well, there ain't much we can do anyway... */

    pf = surface->format;

    /* Colorkeying requires an alpha channel! */
    if (surface->flags & SDL_SRCCOLORKEY)
        if (!pf->Amask)
            return 0;

    /* We need pitch == (width * BytesPerPixel) for glTex[Sub]Image2D() */
    if (surface->pitch != (surface->w * pf->BytesPerPixel))
        return 0;

    if (pf->Amask) {
        if (pf->BytesPerPixel != RGBAfmt->BytesPerPixel)
            return 0;
        if (pf->Rmask != RGBAfmt->Rmask)
            return 0;
        if (pf->Gmask != RGBAfmt->Gmask)
            return 0;
        if (pf->Bmask != RGBAfmt->Bmask)
            return 0;
        if (pf->Amask != RGBAfmt->Amask)
            return 0;
    } else {
        if (pf->BytesPerPixel != RGBfmt->BytesPerPixel)
            return 0;
        if (pf->Rmask != RGBfmt->Rmask)
            return 0;
        if (pf->Gmask != RGBfmt->Gmask)
            return 0;
        if (pf->Bmask != RGBfmt->Bmask)
            return 0;
    }
    return 1;
}

static void
glSDL_key2alpha(SDL_Surface * surface)
{
    int x, y;
    Uint32 ckey = surface->format->colorkey;

#ifdef DEBUG_GLSDL
    fprintf(stderr, "glSDL_key2alpha()\n");
#endif
    for (y = 0; y < surface->h; ++y) {
        Uint32 *px =
            (Uint32 *) ((char *) surface->pixels + y * surface->pitch);
        for (x = 0; x < surface->w; ++x)
            if (px[x] == ckey)
                px[x] = 0;
    }
}


/*----------------------------------------------------------
  SDL style API
  ----------------------------------------------------------*/

static int
glSDL_FlipHWSurface(_THIS, SDL_Surface * surface)
{
#ifdef GLSDL_GRAPHICAL_DEBUG
    this->glDisable(GL_TEXTURE_2D);
    this->glBegin(GL_LINE_LOOP);
    this->glColor4ub(0, 0, 255, 128);
    this->glVertex2i(0, 0);
    this->glVertex2i(surface->w, 0);
    this->glVertex2i(surface->w, surface->h);
    this->glVertex2i(0, surface->h);
    this->glEnd();
    this->glEnable(GL_TEXTURE_2D);
#endif
    if (this->screen->flags & SDL_DOUBLEBUF)
        this->GL_SwapBuffers(this);
    else
        this->glFinish();
    return 0;
}


static void
glSDL_UpdateRects(_THIS, int numrects, SDL_Rect * rects)
{
#ifdef GLSDL_GRAPHICAL_DEBUG
    int i;
    this->glDisable(GL_TEXTURE_2D);
    for (i = 0; i < numrects; i++) {
        this->glColor4ub(255, 0, 0, 128);
        this->glBegin(GL_LINE_LOOP);
        this->glVertex2i(rects[i].x, rects[i].y);
        this->glVertex2i(rects[i].x + rects[i].w, rects[i].y);
        this->glVertex2i(rects[i].x + rects[i].w, rects[i].y + rects[i].h);
        this->glVertex2i(rects[i].x, rects[i].y + rects[i].h);
        this->glEnd();
    }
    this->glEnable(GL_TEXTURE_2D);
#endif
    if (this->screen->flags & SDL_DOUBLEBUF)
        this->GL_SwapBuffers(this);
    else
        this->glFinish();
}


static int
glSDL_AllocHWSurface(_THIS, SDL_Surface * surface)
{
    surface->flags |= (SDL_HWSURFACE | SDL_HWACCEL);

    surface->pixels = SDL_malloc(surface->h * surface->pitch);
    if (surface->pixels == NULL) {
        SDL_FreeSurface(surface);
        SDL_OutOfMemory();
        return (-1);
    }
    SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
    return 0;
}


static void
glSDL_FreeHWSurface(_THIS, SDL_Surface * surface)
{
    if (!surface)
        return;
    glSDL_RemoveTexInfo(this, surface);
}


static int
glSDL_LockHWSurface(_THIS, SDL_Surface * surface)
{
    int y;

    if (!surface)
        return -1;

#ifdef DEBUG_GLSDL
    fprintf(stderr, "glSDL: Lock Surface.\n");
#endif

    if (SDL_VideoSurface == surface) {
        glSDL_Invalidate(surface, NULL);
        this->glPixelStorei(GL_UNPACK_ROW_LENGTH,
                            surface->pitch / surface->format->BytesPerPixel);
        this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
                           GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
        for (y = 0; y < OpenGL_Surface->h / 2; ++y) {
            void *upper = (Uint8 *) OpenGL_Surface->pixels +
                OpenGL_Surface->pitch * y;
            void *lower = (Uint8 *) OpenGL_Surface->pixels +
                OpenGL_Surface->pitch * (OpenGL_Surface->h - y - 1);
            SDL_memcpy(mirrorbuf, upper, OpenGL_Surface->pitch);
            SDL_memcpy(upper, lower, OpenGL_Surface->pitch);
            SDL_memcpy(lower, mirrorbuf, OpenGL_Surface->pitch);
        }
        /* the mapping has to be invalidated on 8bpp video surfaces in case of a hw palette change. 
         * Now if someone could tell me why this is not handled by SDL... */
        if (SDL_VideoSurface->format->BitsPerPixel == 8)
            SDL_InvalidateMap(OpenGL_Surface->map);

        /* convert this raw surface to the application-requested format 
         * FIXME this is sometimes overkill, we could use glPixelStore smartly
         * But this would be slow anyway :) */

        glSDL_SoftBlit(OpenGL_Surface, NULL, SDL_VideoSurface, NULL);
    } else
        glSDL_Invalidate(surface, NULL);

    return 0;
}


static void
glSDL_UnlockHWSurface(_THIS, SDL_Surface * surface)
{
    private_hwdata *txi;

    if (!surface)
        return;

    /* upload this surface ONLY if this is a glSDL surface
     * because sometimes (during displayformating for ex.) surfaces are unlocked that aren't glSDL
     */
    if (!IS_GLSDL_SURFACE(surface))
        return;

#ifdef DEBUG_GLSDL
    fprintf(stderr, "glSDL: Unlock Surface.\n");
#endif

    txi = glSDL_UploadSurface(this, surface);

    if (!txi) {
        GLERR("glSDL_UnlockHWSurface() failed to upload surface!");
        return;
    }
    if (txi->temporary) {
        GLERR
            ("Weirdness... glSDL_UnlockHWSurface() got a temporary TexInfo.");
        return;
    }
    if (surface == SDL_VideoSurface)
        glSDL_BlitGL(this, SDL_VideoSurface, NULL, NULL);
}


static int
glSDL_SetHWColorKey(_THIS, SDL_Surface * surface, Uint32 key)
{
    /*
     * If an application does this *after* SDL_DisplayFormat,
     * we're basically screwed, unless we want to do an
     * in-place surface conversion hack here.
     *
     * What we do is just kill the glSDL texinfo... No big
     * deal in most cases, as glSDL only converts once anyway,
     * *unless* you keep modifying the surface.
     */
    if (IS_GLSDL_SURFACE(surface))
        glSDL_RemoveTexInfo(this, surface);
    return 0;
}


static int
glSDL_SetHWAlpha(_THIS, SDL_Surface * surface, Uint8 alpha)
{
    /*
     * If an application does this *after* SDL_DisplayFormat,
     * we're basically screwed, unless we want to do an
     * in-place surface conversion hack here.
     *
     * What we do is just kill the glSDL texinfo... No big
     * deal in most cases, as glSDL only converts once anyway,
     * *unless* you keep modifying the surface.
     */
    if (IS_GLSDL_SURFACE(surface))
        glSDL_RemoveTexInfo(this, surface);
    return 0;
}

static SDL_bool
glSDL_SetClipRect(_THIS, SDL_Surface * surface, SDL_Rect * rect)
{
    SDL_bool res;
    if (!surface)
        return SDL_FALSE;

    res = SDL_SetClipRect(surface, rect);
    if (!res)
        return SDL_FALSE;

    rect = &surface->clip_rect;

    if (surface == SDL_VideoSurface) {
        SDL_Rect r;
        float xscale, yscale;
        private_hwdata *txi;

        r.x = rect->x;
        r.y = rect->y;
        r.w = rect->w;
        r.h = rect->h;
        SDL_SetClipRect(surface, rect);

        txi = glSDL_GetTexInfo(surface);
        if (!txi)
            return GLERET("SetClipRect(): Could not get TexInfo!");

        this->glViewport(rect->x,
                         surface->h - (rect->y + rect->h), rect->w, rect->h);
        /*
         * Note that this projection is upside down in
         * relation to the OpenGL coordinate system.
         */
        this->glMatrixMode(GL_PROJECTION);
        this->glLoadIdentity();
        xscale = (float) txi->lw / (float) surface->w;
        yscale = (float) txi->lh / (float) surface->h;
        this->glOrtho(xscale * (float) rect->x,
                      xscale * (float) (rect->w + rect->x),
                      yscale * (float) (rect->h + rect->y),
                      yscale * (float) rect->y, -1.0, 1.0);
        return SDL_TRUE;
    }
    return res;
}

static int
glSDL_BlitFromGL(_THIS, SDL_Rect * srcrect,
                 SDL_Surface * dst, SDL_Rect * dstrect)
{
    SDL_Rect sr, dr;

    /* In case the destination has an OpenGL texture... */
    glSDL_Invalidate(dst, dstrect);

    /* Abuse the fake screen buffer a little. */
    this->glPixelStorei(GL_UNPACK_ROW_LENGTH, SDL_VideoSurface->pitch /
                        SDL_VideoSurface->format->BytesPerPixel);
    if (srcrect)
        this->glReadPixels(srcrect->x,
                           OpenGL_Surface->h - (srcrect->y + srcrect->h - 1),
                           srcrect->w, srcrect->h, GL_RGB, GL_UNSIGNED_BYTE,
                           OpenGL_Surface->pixels);
    else
        this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
                           GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
    sr = *srcrect;
    dr = *dstrect;
    glSDL_SoftBlit(OpenGL_Surface, &sr, dst, &dr);
    return 0;
}

static __inline__ void
glSDL_BlitGL_single(_THIS, private_hwdata * txi,
                    float sx1, float sy1, SDL_Rect * dst, unsigned char alpha)
{
    float sx2, sy2, texscale;
    if (!txi->textures)
        return;
    if (-1 == txi->texture[0])
        return;
    glSDL_texture(this, txi->texture[0]);

    texscale = 1.0 / (float) txi->texsize;
    sx2 = (sx1 + (float) dst->w) * texscale;
    sy2 = (sy1 + (float) dst->h) * texscale;
    sx1 *= texscale;
    sy1 *= texscale;

#ifdef GLSDL_GRAPHICAL_DEBUG
    this->glDisable(GL_TEXTURE_2D);
    this->glBegin(GL_LINE_LOOP);
    this->glColor4ub(0, 255, 0, 128);
    this->glVertex2i(dst->x, dst->y);
    this->glVertex2i(dst->x + dst->w, dst->y);
    this->glVertex2i(dst->x + dst->w, dst->y + dst->h);
    this->glVertex2i(dst->x, dst->y + dst->h);
    this->glEnd();
    this->glEnable(GL_TEXTURE_2D);
#endif

    this->glBegin(GL_TRIANGLE_FAN);
    this->glColor4ub(255, 255, 255, alpha);
    this->glTexCoord2f(sx1, sy1);
    this->glVertex2i(dst->x, dst->y);
    this->glTexCoord2f(sx2, sy1);
    this->glVertex2i(dst->x + dst->w, dst->y);
    this->glTexCoord2f(sx2, sy2);
    this->glVertex2i(dst->x + dst->w, dst->y + dst->h);
    this->glTexCoord2f(sx1, sy2);
    this->glVertex2i(dst->x, dst->y + dst->h);
    this->glEnd();
}


static void
glSDL_BlitGL_htile(_THIS, private_hwdata * txi,
                   float sx1, float sy1, SDL_Rect * dst, unsigned char alpha)
{
    int tex;
    float tile, sx2, sy2, yo;
    float texscale = 1.0 / (float) txi->texsize;
    float tileh = (float) txi->tileh * texscale;
    sx2 = (sx1 + (float) dst->w) * texscale;
    sy2 = (sy1 + (float) dst->h) * texscale;
    sx1 *= texscale;
    sy1 *= texscale;
    tile = floor(sx1);
    tex = (int) tile / txi->tilespertex;
    yo = ((int) tile % txi->tilespertex) * tileh;

    if (tex >= txi->textures)
        return;
    if (-1 == txi->texture[tex])
        return;
    glSDL_texture(this, txi->texture[tex]);

    while (tile < sx2) {
        int tdx1 = dst->x;
        int tdx2 = dst->x + dst->w;
        float tsx1 = sx1 - tile;
        float tsx2 = sx2 - tile;

        /* Clip to current tile */
        if (tsx1 < 0.0) {
            tdx1 -= tsx1 * txi->texsize;
            tsx1 = 0.0;
        }
        if (tsx2 > 1.0) {
            tdx2 -= (tsx2 - 1.0) * txi->texsize;
            tsx2 = 1.0;
        }

        /* Maybe select next texture? */
        if (yo + tileh > 1.0) {
            ++tex;
            if (tex >= txi->textures)
                return;
            if (-1 == txi->texture[tex])
                return;
            glSDL_texture(this, txi->texture[tex]);
            yo = 0.0;
        }
#ifdef GLSDL_GRAPHICAL_DEBUG
        this->glDisable(GL_TEXTURE_2D);
        this->glBegin(GL_LINE_LOOP);
        this->glColor4ub(0, 255, 0, 128);
        this->glVertex2i(tdx1, dst->y);
        this->glVertex2i(tdx2, dst->y);
        this->glVertex2i(tdx2, dst->y + dst->h);
        this->glVertex2i(tdx1, dst->y + dst->h);
        this->glEnd();
        this->glEnable(GL_TEXTURE_2D);
#endif

        this->glBegin(GL_TRIANGLE_FAN);
        this->glColor4ub(255, 255, 255, alpha);
        this->glTexCoord2f(tsx1, yo + sy1);
        this->glVertex2i(tdx1, dst->y);
        this->glTexCoord2f(tsx2, yo + sy1);
        this->glVertex2i(tdx2, dst->y);
        this->glTexCoord2f(tsx2, yo + sy2);
        this->glVertex2i(tdx2, dst->y + dst->h);
        this->glTexCoord2f(tsx1, yo + sy2);
        this->glVertex2i(tdx1, dst->y + dst->h);
        this->glEnd();
        tile += 1.0;
        yo += tileh;
    }
}


static void
glSDL_BlitGL_vtile(_THIS, private_hwdata * txi,
                   float sx1, float sy1, SDL_Rect * dst, unsigned char alpha)
{
    int tex;
    float tile, sx2, sy2, xo;
    float texscale = 1.0 / (float) txi->texsize;
    float tilew = (float) txi->tilew * texscale;
    sx2 = (sx1 + (float) dst->w) * texscale;
    sy2 = (sy1 + (float) dst->h) * texscale;
    sx1 *= texscale;
    sy1 *= texscale;
    tile = floor(sy1);
    tex = (int) tile / txi->tilespertex;
    xo = ((int) tile % txi->tilespertex) * tilew;

    if (tex >= txi->textures)
        return;
    if (-1 == txi->texture[tex])
        return;
    glSDL_texture(this, txi->texture[tex]);

    while (tile < sy2) {
        int tdy1 = dst->y;
        int tdy2 = dst->y + dst->h;
        float tsy1 = sy1 - tile;
        float tsy2 = sy2 - tile;

        /* Clip to current tile */
        if (tsy1 < 0.0) {
            tdy1 -= tsy1 * txi->texsize;
            tsy1 = 0.0;
        }
        if (tsy2 > 1.0) {
            tdy2 -= (tsy2 - 1.0) * txi->texsize;
            tsy2 = 1.0;
        }

        /* Maybe select next texture? */
        if (xo + tilew > 1.0) {
            ++tex;
            if (tex >= txi->textures)
                return;
            if (-1 == txi->texture[tex])
                return;
            glSDL_texture(this, txi->texture[tex]);
            xo = 0.0;
        }
#ifdef GLSDL_GRAPHICAL_DEBUG
        this->glDisable(GL_TEXTURE_2D);
        this->glBegin(GL_LINE_LOOP);
        this->glColor4ub(0, 255, 0, 128);
        this->glVertex2i(dst->x, tdy1);
        this->glVertex2i(dst->x + dst->w, tdy1);
        this->glVertex2i(dst->x + dst->w, tdy2);
        this->glVertex2i(dst->x, tdy2);
        this->glEnd();
        this->glEnable(GL_TEXTURE_2D);
#endif

        this->glBegin(GL_TRIANGLE_FAN);
        this->glColor4ub(255, 255, 255, alpha);
        this->glTexCoord2f(xo + sx1, tsy1);
        this->glVertex2i(dst->x, tdy1);
        this->glTexCoord2f(xo + sx2, tsy1);
        this->glVertex2i(dst->x + dst->w, tdy1);
        this->glTexCoord2f(xo + sx2, tsy2);
        this->glVertex2i(dst->x + dst->w, tdy2);
        this->glTexCoord2f(xo + sx1, tsy2);
        this->glVertex2i(dst->x, tdy2);
        this->glEnd();

        tile += 1.0;
        xo += tilew;
    }
}


static void
glSDL_BlitGL_hvtile(_THIS, SDL_Surface * src, private_hwdata * txi,
                    float sx1, float sy1, SDL_Rect * dst, unsigned char alpha)
{
    int x, y, last_tex, tex;
    float sx2, sy2;
    float texscale = 1.0 / (float) txi->texsize;
    int tilesperrow = (src->w + txi->tilew - 1) / txi->tilew;
    sx2 = (sx1 + (float) dst->w) * texscale;
    sy2 = (sy1 + (float) dst->h) * texscale;
    sx1 *= texscale;
    sy1 *= texscale;

    last_tex = tex = floor(sy1) * tilesperrow + floor(sx1);
    if (tex >= txi->textures)
        return;
    if (-1 == txi->texture[tex])
        return;
    glSDL_texture(this, txi->texture[tex]);

    for (y = floor(sy1); y < sy2; ++y) {
        int tdy1 = dst->y;
        int tdy2 = dst->y + dst->h;
        float tsy1 = sy1 - y;
        float tsy2 = sy2 - y;

        /* Clip to current tile */
        if (tsy1 < 0.0) {
            tdy1 -= tsy1 * txi->texsize;
            tsy1 = 0.0;
        }
        if (tsy2 > 1.0) {
            tdy2 -= (tsy2 - 1.0) * txi->texsize;
            tsy2 = 1.0;
        }
        for (x = floor(sx1); x < sx2; ++x) {
            int tdx1 = dst->x;
            int tdx2 = dst->x + dst->w;
            float tsx1 = sx1 - x;
            float tsx2 = sx2 - x;

            /* Clip to current tile */
            if (tsx1 < 0.0) {
                tdx1 -= tsx1 * txi->texsize;
                tsx1 = 0.0;
            }
            if (tsx2 > 1.0) {
                tdx2 -= (tsx2 - 1.0) * txi->texsize;
                tsx2 = 1.0;
            }

            /* Select texture */
            tex = y * tilesperrow + x;
            if (tex != last_tex) {
                if (tex >= txi->textures)
                    return;
                if (-1 == txi->texture[tex])
                    return;
                glSDL_texture(this, txi->texture[tex]);
                last_tex = tex;
            }
#ifdef GLSDL_GRAPHICAL_DEBUG
            this->glDisable(GL_TEXTURE_2D);
            this->glBegin(GL_LINE_LOOP);
            this->glColor4ub(0, 255, 0, 128);
            this->glVertex2i(tdx1, tdy1);
            this->glVertex2i(tdx2, tdy1);
            this->glVertex2i(tdx2, tdy2);
            this->glVertex2i(tdx1, tdy2);
            this->glEnd();
            this->glEnable(GL_TEXTURE_2D);
#endif

            this->glBegin(GL_TRIANGLE_FAN);
            this->glColor4ub(255, 255, 255, alpha);
            this->glTexCoord2f(tsx1, tsy1);
            this->glVertex2i(tdx1, tdy1);
            this->glTexCoord2f(tsx2, tsy1);
            this->glVertex2i(tdx2, tdy1);
            this->glTexCoord2f(tsx2, tsy2);
            this->glVertex2i(tdx2, tdy2);
            this->glTexCoord2f(tsx1, tsy2);
            this->glVertex2i(tdx1, tdy2);
            this->glEnd();
        }
    }
}

/*
 * Calculate the actual blit rectangle and source offset
 * for a blit from a rectangle in a surface with specified
 * size to a surface with a cliprect.
 *
 * In:	rect	source rectangle
 *	w, h	source surface size
 *	(x, y)	destination coordinate
 *	clip	destination clip rectangle
 *
 * Out:	(x, y)	source top-left offset
 *	rect	destination rectangle
 *
 * Returns 1 if the result is visible, otherwise 0.
 */
static __inline__ int
blitclip(SDL_Rect * rect, int w, int h, int *x, int *y, SDL_Rect * clip)
{
    int sx1, sy1, sx2, sy2;
    int dx1, dy1, dx2, dy2;

    /* Get source and destination coordinates */
    sx1 = rect->x;
    sy1 = rect->y;
    sx2 = sx1 + rect->w;
    sy2 = sy1 + rect->h;
    dx1 = *x;
    dy1 = *y;

    /* Keep source rect inside source surface */
    if (sx1 < 0) {
        dx1 -= sx1;
        sx1 = 0;
    }
    if (sy1 < 0) {
        dy1 -= sy1;
        sy1 = 0;
    }
    if (sx2 > w)
        sx2 = w;
    if (sy2 > h)
        sy2 = h;

    /* Cull blits from void space */
    if (sx1 >= sx2 || sy1 >= sy2)
        return 0;

    /* Calculate destination lower-right */
    dx2 = dx1 + (sx2 - sx1);
    dy2 = dy1 + (sy2 - sy1);

    /* Clip to destination cliprect */
    if (dx1 < clip->x) {
        sx1 += clip->x - dx1;
        dx1 = clip->x;
    }
    if (dy1 < clip->y) {
        sy1 += clip->y - dy1;
        dy1 = clip->y;
    }
    if (dx2 > clip->x + clip->w)
        dx2 = clip->x + clip->w;
    if (dy2 > clip->y + clip->h)
        dy2 = clip->y + clip->h;

    /* Cull nop/off-screen blits */
    if (dx1 >= dx2 || dy1 >= dy2)
        return 0;

    *x = sx1;
    *y = sy1;
    rect->x = dx1;
    rect->y = dy1;
    rect->w = dx2 - dx1;
    rect->h = dy2 - dy1;
    return 1;
}

static int
glSDL_BlitGL(_THIS, SDL_Surface * src, SDL_Rect * srcrect, SDL_Rect * dstrect)
{
    private_hwdata *txi;
    float x1, y1;
    unsigned char alpha;
    SDL_Rect d;
    int x, y;
    SDL_Rect r;

    if (!src)
        return GLERET("BlitGL(): No src surface!");

    /* Get source and destination coordinates */
    if (srcrect)
        r = *srcrect;
    else {
        r.x = r.y = 0;
        r.w = src->w;
        r.h = src->h;
    }
    if (dstrect) {
        x = dstrect->x;
        y = dstrect->y;
    } else
        x = y = 0;

    /* Clip! */
    if (!blitclip(&r, src->w, src->h, &x, &y, &this->screen->clip_rect)) {
        if (dstrect)
            dstrect->w = dstrect->h = 0;
        return 0;
    }

    /* Write back the resulting cliprect */
    if (dstrect)
        *dstrect = r;

    /* Make sure we have a source with a valid texture */
    txi = glSDL_UploadSurface(this, src);
    if (!txi)
        return GLERET("BlitGL(): Could not get a TexInfo!");

    /* Set up blending */
    if (src->flags & (SDL_SRCALPHA | SDL_SRCCOLORKEY)) {
        glSDL_blendfunc(this, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glSDL_do_blend(this, 1);
    } else
        glSDL_do_blend(this, 0);

    /* Enable texturing */
    glSDL_do_texture(this, 1);

    /* Calculate texcoords */
    if (!srcrect)
        srcrect = &txi->virt;
    x1 = (float) srcrect->x;
    y1 = (float) srcrect->y;

    /* Calculate screen coords. */
    if (dstrect) {
        d.x = dstrect->x;
        d.y = dstrect->y;
        d.w = (int) (srcrect->w * (float) txi->lw / (float) txi->virt.w);
        d.h = (int) (srcrect->h * (float) txi->lh / (float) txi->virt.h);
    } else {
        d.x = 0;
        d.y = 0;
        d.w = (int) (srcrect->w * (float) txi->lw / (float) txi->virt.w);
        d.h = (int) (srcrect->h * (float) txi->lh / (float) txi->virt.h);
    }

    /*
     * Note that we actually *prevent* the use of "full surface alpha"
     * and alpha channel in combination - to stay SDL 2D compatible.
     */
    if ((src->flags & SDL_SRCALPHA) && (src->format->Amask))
        alpha = 255;
    else
        alpha = src->format->alpha;

    /* Render! */
    switch (txi->tilemode) {
    case GLSDL_TM_SINGLE:
        glSDL_BlitGL_single(this, txi, x1, y1, &d, alpha);
        break;
    case GLSDL_TM_HORIZONTAL:
        glSDL_BlitGL_htile(this, txi, x1, y1, &d, alpha);
        break;
    case GLSDL_TM_VERTICAL:
        glSDL_BlitGL_vtile(this, txi, x1, y1, &d, alpha);
        break;
    case GLSDL_TM_HUGE:
        glSDL_BlitGL_hvtile(this, src, txi, x1, y1, &d, alpha);
        break;
    }

    if (txi->temporary)
        glSDL_FreeTexInfo(this, txi);

    return 0;
}


static int
glSDL_HWAccelBlit(SDL_Surface * src, SDL_Rect * srcrect,
                  SDL_Surface * dst, SDL_Rect * dstrect)
{
    SDL_Surface *vs;

    if (!src)
        return GLERET("HWAccelBlit(): No src surface!");
    if (!dst)
        return GLERET("HWAccelBlit(): No dst surface!");

    /*
     * Figure out what to do:
     *      screen->screen:         glSDL_BlitFromGL() + glSDL_BlitGL()
     *      surface->screen:        glSDL_BlitGL()
     *      screen->surface:        glSDL_BlitFromGL()
     *      surface->surface:       glSDL_SoftBlit()
     */
    vs = SDL_VideoSurface;
    if (src == vs) {
        if (dst == vs) {
            /*
               FIXME: Try glCopyPixels() instead...
             */
            glSDL_BlitFromGL(current_video, srcrect, vs, dstrect);
            return glSDL_BlitGL(current_video, vs, srcrect, dstrect);
        } else {
            return glSDL_BlitFromGL(current_video, srcrect, dst, dstrect);
        }
    } else {
        if (dst == vs) {
            return glSDL_BlitGL(current_video, src, srcrect, dstrect);
        } else {
            glSDL_Invalidate(dst, dstrect);
            glSDL_SoftBlit(src, srcrect, dst, dstrect);
            return 0;
        }
    }
}


static int
glSDL_FillHWRect(_THIS, SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
{
    SDL_Surface *vs = SDL_VideoSurface;
    int dx1, dy1, dx2, dy2;
    Uint32 r, g, b;
    Uint8 br, bg, bb;

    /*
     * Some ugly reverse conversion for compatibility...
     * (We must do this before losing the dst pointer,
     * as the pixel formats of the screen and
     * SDL_VideoSurface may differ!)
     */

    if (dst->format->palette) {
        /* this a paletted color */
        SDL_GetRGB(color, dst->format, &br, &bg, &bb);
    } else {
        /* this a RGB color */
        r = color & dst->format->Rmask;
        r = r >> dst->format->Rshift;
        r = r << dst->format->Rloss;
        br = r;

        g = color & dst->format->Gmask;
        g = g >> dst->format->Gshift;
        g = g << dst->format->Gloss;
        bg = g;

        b = color & dst->format->Bmask;
        b = b >> dst->format->Bshift;
        b = b << dst->format->Bloss;
        bb = b;
    }

    if (vs != dst) {
        /* draw a rect offscreen */
        glSDL_Invalidate(dst, dstrect);
        /* software-fill the surface by faking it as a SW_SURFACE */
        dst->flags &= ~SDL_HWSURFACE;
        SDL_FillRect(dst, dstrect, color);
        dst->flags |= SDL_HWSURFACE;
    } else {
        /* draw a rect onscreen */
        glSDL_do_texture(this, 0);
        glSDL_do_blend(this, 0);

        dx1 = dstrect->x;
        dy1 = dstrect->y;
        dx2 = dx1 + dstrect->w;
        dy2 = dy1 + dstrect->h;

        this->glBegin(GL_TRIANGLE_FAN);
        this->glColor3ub(br, bg, bb);
        this->glVertex2i(dx1, dy1);
        this->glVertex2i(dx2, dy1);
        this->glVertex2i(dx2, dy2);
        this->glVertex2i(dx1, dy2);
        this->glEnd();
    }
    return 0;
}

static int
glSDL_CheckHWBlit(_THIS, SDL_Surface * src, SDL_Surface * dst)
{
    src->flags |= SDL_HWACCEL;
    src->map->hw_blit = glSDL_HWAccelBlit;
    return 1;
}


static SDL_Surface *
glSDL_DisplayFormat(SDL_Surface * surface)
{
    SDL_Surface *tmp;
    int use_rgba = (surface->flags & SDL_SRCCOLORKEY) ||
        ((surface->flags & SDL_SRCALPHA) && surface->format->Amask);
#ifdef DEBUG_GLSDL
    fprintf(stderr, "#### glSDL_DisplayFormat()\n");
#endif
    if (use_rgba)
        tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE);
    else
        tmp = glSDL_ConvertSurface(surface, RGBfmt, SDL_SWSURFACE);
    if (!tmp) {
        GLERR("glSDL_DisplayFormat() could not convert surface!");
        return NULL;
    }
    SDL_SetAlpha(tmp, 0, 0);

    if (surface->flags & SDL_SRCCOLORKEY) {
        /*
         * We drop colorkey data here, but we have to,
         * or we'll run into trouble when converting,
         * in particular from indexed color formats.
         */
        SDL_SetColorKey(tmp, SDL_SRCCOLORKEY, surface->format->colorkey);
        glSDL_key2alpha(tmp);
        SDL_SetColorKey(tmp, 0, 0);
    }

    return tmp;
}


static SDL_Surface *
glSDL_DisplayFormatAlpha(SDL_Surface * surface)
{
    SDL_Surface *s, *tmp;
    tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE);
#ifdef DEBUG_GLSDL
    fprintf(stderr, "#### glSDL_DisplayFormatAlpha()\n");
#endif
    if (!tmp)
        return NULL;

    SDL_SetAlpha(tmp, 0, 0);
    SDL_SetColorKey(tmp, 0, 0);
    s = glSDL_CreateRGBASurface(surface->w, surface->h);
    if (!s) {
        SDL_FreeSurface(tmp);
        return NULL;
    }
    glSDL_SoftBlit(tmp, NULL, s, NULL);
    SDL_FreeSurface(tmp);

    if (surface->flags & SDL_SRCCOLORKEY) {
        SDL_SetColorKey(s, SDL_SRCCOLORKEY, surface->format->colorkey);
        glSDL_key2alpha(s);
        SDL_SetColorKey(s, 0, 0);
    }

    if (surface->flags & SDL_SRCALPHA)
        SDL_SetAlpha(s, SDL_SRCALPHA, surface->format->alpha);
    return s;
}


/*----------------------------------------------------------
  glSDL specific API extensions
  ----------------------------------------------------------*/

static void
glSDL_Invalidate(SDL_Surface * surface, SDL_Rect * area)
{
    private_hwdata *txi;
    if (!surface)
        return;
    txi = glSDL_GetTexInfo(surface);
    if (!txi)
        return;
    if (!area) {
        txi->invalid_area.x = 0;
        txi->invalid_area.y = 0;
        txi->invalid_area.w = surface->w;
        txi->invalid_area.h = surface->h;
        return;
    }
    txi->invalid_area = *area;
}


static void
glSDL_SetLogicSize(_THIS, SDL_Surface * surface, int w, int h)
{
    SDL_Rect r;
    private_hwdata *txi;
    if (!IS_GLSDL_SURFACE(surface))
        return;

    txi = glSDL_GetTexInfo(surface);

    txi->lw = w;
    txi->lh = h;

    if (SDL_VideoSurface != surface)
        return;

    r.x = r.y = 0;
    r.w = w;
    r.h = h;
    glSDL_SetClipRect(this, surface, &r);

    this->glMatrixMode(GL_MODELVIEW);
    this->glLoadIdentity();
    this->glTranslated(0.0f, 0.0f, 0.0f);

    this->glDisable(GL_DEPTH_TEST);
    this->glDisable(GL_CULL_FACE);

    glSDL_reset();
}

static int
glSDL_InitTexture(_THIS, SDL_Surface * datasurf, private_hwdata * txi,
                  int tex)
{
    this->glGenTextures(1, (GLuint *) & txi->texture[tex]);
    this->glBindTexture(GL_TEXTURE_2D, txi->texture[tex]);
    glstate.texture = txi->texture[tex];
    this->glPixelStorei(GL_UNPACK_ROW_LENGTH, datasurf->pitch /
                        datasurf->format->BytesPerPixel);
    this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    this->glTexImage2D(GL_TEXTURE_2D, 0,
                       datasurf->format->Amask ? GL_RGBA8 : GL_RGB8,
                       txi->texsize, txi->texsize, 0,
                       datasurf->format->Amask ? GL_RGBA : GL_RGB,
                       GL_UNSIGNED_BYTE, NULL);
#ifdef DEBUG_GLSDL
    glSDL_print_glerror(this, 1);
#endif
    return 0;
}


/* Image tiled horizontally (wide surface), or not at all */
static int
glSDL_UploadHoriz(_THIS, SDL_Surface * datasurf, private_hwdata * txi)
{
    int bpp = datasurf->format->BytesPerPixel;
    int res;
    int tex = 0;
    int fromx = 0;
    int toy = txi->texsize;     /* To init first texture */
    while (1) {
        int thistw = datasurf->w - fromx;
        if (thistw > txi->tilew)
            thistw = txi->tilew;
        else if (thistw <= 0)
            break;
        if (toy + txi->tileh > txi->texsize) {
            toy = 0;
            res = glSDL_InitTexture(this, datasurf, txi, tex);
            if (res < 0)
                return res;
            ++tex;
        }
        this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, toy,
                              thistw, txi->tileh,
                              datasurf->format->Amask ? GL_RGBA : GL_RGB,
                              GL_UNSIGNED_BYTE,
                              (char *) datasurf->pixels + bpp * fromx);
#ifdef DEBUG_GLSDL
        glSDL_print_glerror(this, 2);
#endif
        fromx += txi->tilew;
        toy += txi->tileh;
    }
    return 0;
}


/* Image tiled vertically (tall surface) */
static int
glSDL_UploadVert(_THIS, SDL_Surface * datasurf, private_hwdata * txi)
{
    int res;
    int tex = 0;
    int fromy = 0;
    int tox = txi->texsize;     /* To init first texture */
    while (1) {
        int thisth = datasurf->h - fromy;
        if (thisth > txi->tileh)
            thisth = txi->tileh;
        else if (thisth <= 0)
            break;
        if (tox + txi->tilew > txi->texsize) {
            tox = 0;
            res = glSDL_InitTexture(this, datasurf, txi, tex);
            if (res < 0)
                return res;
            ++tex;
        }
        this->glTexSubImage2D(GL_TEXTURE_2D, 0, tox, 0,
                              txi->tilew, thisth,
                              datasurf->format->Amask ? GL_RGBA : GL_RGB,
                              GL_UNSIGNED_BYTE,
                              (char *) datasurf->pixels +
                              datasurf->pitch * fromy);
#ifdef DEBUG_GLSDL
        glSDL_print_glerror(this, 3);
#endif
        fromy += txi->tileh;
        tox += txi->tilew;
    }
    return 0;
}


/* Image tiled two-way (huge surface) */
static int
glSDL_UploadHuge(_THIS, SDL_Surface * datasurf, private_hwdata * txi)
{
    int bpp = datasurf->format->BytesPerPixel;
    int res;
    int tex = 0;
    int y = 0;
    while (y < datasurf->h) {
        int x;
        int thisth = datasurf->h - y;
        if (thisth > txi->tileh)
            thisth = txi->tileh;
        x = 0;
        while (x < datasurf->w) {
            int thistw = datasurf->w - x;
            if (thistw > txi->tilew)
                thistw = txi->tilew;
            res = glSDL_InitTexture(this, datasurf, txi, tex++);
            if (res < 0)
                return res;
            this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
                                  thistw, thisth,
                                  datasurf->format->
                                  Amask ? GL_RGBA : GL_RGB,
                                  GL_UNSIGNED_BYTE,
                                  (char *) datasurf->pixels +
                                  datasurf->pitch * y + bpp * x);
#ifdef DEBUG_GLSDL
            fprintf(stderr,
                    "glTexSubImage(x = %d, y = %d, w = %d, h = %d)\n", x,
                    y, thistw, thisth);
            glSDL_print_glerror(this, 4);
#endif
            x += txi->tilew;
        }
        y += txi->tileh;
    }
    return 0;
}


/* Upload all textures for a surface. */
static int
glSDL_UploadTextures(_THIS, SDL_Surface * datasurf, private_hwdata * txi)
{
    switch (txi->tilemode) {
    case GLSDL_TM_SINGLE:
    case GLSDL_TM_HORIZONTAL:
        glSDL_UploadHoriz(this, datasurf, txi);
        break;
    case GLSDL_TM_VERTICAL:
        glSDL_UploadVert(this, datasurf, txi);
        break;
    case GLSDL_TM_HUGE:
        glSDL_UploadHuge(this, datasurf, txi);
        break;
    }
    return 0;
}


/*
 * IMPORTANT:
 *	This function will try various ways of giving you
 *	a TexInfo, and will succeed most of the time.
 *
 *	However, the TexInfo returned may be temporary,
 *	(as opposed to connected to 'surface'). A temporary
 *	TexInfo must be used only once and then thrown away,
 *	since it means that glSDL cannot track changes in
 *	the pixel data of 'texture'.
 */
static private_hwdata *
glSDL_UploadSurface(_THIS, SDL_Surface * surface)
{
    int i;
    int converted = 0;
    private_hwdata *txi = glSDL_GetTexInfo(surface);

    if (IS_GLSDL_SURFACE(surface)) {
        /*
         * Ok, this is a glSDL surface, and it *might* be
         * in texture memory already. If so, it may need
         * an update.
         */
        if (txi->invalid_area.w) {
            glSDL_UnloadTexture(this, txi);
        } else {
            int missing = 0;
            if (txi->textures) {
                for (i = 0; i < txi->textures; ++i)
                    if (GLSDL_NOTEX == txi->texture[i]) {
                        missing = 1;
                        break;
                    }
                if (!missing)
                    return txi; /* They're already there! */
            }
        }
    } else {
        /*
         * Nope, this isn't (yet) a glSDL surface. Let's
         * try to either make it one, or set up a temporary
         * TexInfo for it, valid for only one blit.
         */
        if ((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
            txi = glSDL_AddTexInfo(this, surface);
            if (!txi) {
                GLERR("UploadSurface(): Could not add TexInfo!");
                return NULL;
            }
            surface->flags |= SDL_HWSURFACE;
            surface->flags |= SDL_HWACCEL;
        } else {
            /* 
             * FIXME
             * here if the surface is small enough, it's a good 
             * candidate for a blit using glDrawPixels instead 
             * of a texture blit
             */
            txi = glSDL_CreateTempTexInfo(this, surface);
            if (!txi) {
                GLERR("UploadSurface(): Could not create temp TexInfo!");
                return NULL;
            }
        }
    }

    if (txi->texsize > maxtexsize) {
        /* This surface wasn't tiled properly... */
        if (txi->temporary)
            glSDL_FreeTexInfo(this, txi);
        GLERR("UploadSurface(): Too large texture!");
        return NULL;
    }

    /*
     * Kludge: Convert if not of preferred RGB or RGBA format.
     *
     *      Conversion should only be done when *really* needed.
     *      That is, it should rarely have to be done with OpenGL
     *      1.2+.
     *
     *      Besides, any surface that's been SDL_DisplayFormat()ed
     *      should already be in the best known OpenGL format -
     *      preferably one that makes DMA w/o conversion possible.
     */
    if (!glSDL_FormatIsOk(surface)) {
#ifdef DEBUG_GLSDL
        fprintf(stderr, "glSDL: WARNING: On-the-fly conversion performed!\n");
#endif
        converted = 1;
        /* NOTE: We forget about the original surface here. */
        if (surface->format->Amask)
            surface = glSDL_DisplayFormatAlpha(surface);
        else
            surface = glSDL_DisplayFormat(surface);
        if (!surface) {
            GLERR("UploadSurface(): Could not convert surface!");
            if (txi->temporary)
                glSDL_FreeTexInfo(this, txi);
            return NULL;
        }
    }

    glSDL_UploadTextures(this, surface, txi);

    if (converted)
        SDL_FreeSurface(surface);

    return txi;
}


static void
glSDL_UnloadTexture(_THIS, private_hwdata * txi)
{
    int i;
    for (i = 0; i < txi->textures; ++i)
        if (txi->texture[i] != GLSDL_NOTEX)
            this->glDeleteTextures(1, &txi->texture[i]);
    SDL_memset(&txi->invalid_area, 0, sizeof(txi->invalid_area));
}

/* vi: set ts=4 sw=4 expandtab: */