sdl-ios-xcode: src/video/glsdl/SDL

comparison src/video/glsdl/SDL_glsdl.c @ 1662:782fd950bd46 SDL-1.3

Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.

author	Sam Lantinga <slouken@libsdl.org>
date	Sun, 28 May 2006 13:04:16 +0000
parents	e49147870aac
children	4da1ee79c9af

comparison

equal deleted inserted replaced

-:281d3f4870e5
+:782fd950bd46
 #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_SetColors (_THIS, int firstcolor, int ncolors,
-static int glSDL_AllocHWSurface(_THIS, SDL_Surface *surface);
+SDL_Color * colors);
-static int glSDL_LockHWSurface(_THIS, SDL_Surface *surface);
+static int glSDL_AllocHWSurface (_THIS, SDL_Surface * surface);
-static int glSDL_FlipHWSurface(_THIS, SDL_Surface *surface);
+static int glSDL_LockHWSurface (_THIS, SDL_Surface * surface);
-static void glSDL_UnlockHWSurface(_THIS, SDL_Surface *surface);
+static int glSDL_FlipHWSurface (_THIS, SDL_Surface * surface);
-static void glSDL_FreeHWSurface(_THIS, SDL_Surface *surface);
+static void glSDL_UnlockHWSurface (_THIS, SDL_Surface * surface);
-static int glSDL_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);
+static void glSDL_FreeHWSurface (_THIS, SDL_Surface * surface);
-static int glSDL_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst);
+static int glSDL_FillHWRect (_THIS, SDL_Surface * dst, SDL_Rect * rect,
-static int glSDL_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key);
+Uint32 color);
-static int glSDL_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha);
+static int glSDL_CheckHWBlit (_THIS, SDL_Surface * src, SDL_Surface * dst);
-static int glSDL_VideoInit(_THIS, SDL_PixelFormat *vformat);
+static int glSDL_SetHWColorKey (_THIS, SDL_Surface * surface, Uint32 key);
-static SDL_Rect **glSDL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
+static int glSDL_SetHWAlpha (_THIS, SDL_Surface * surface, Uint8 alpha);
-static void glSDL_VideoQuit(_THIS);
+static int glSDL_VideoInit (_THIS, SDL_PixelFormat * vformat);
-static void glSDL_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
+static SDL_Rect **glSDL_ListModes (_THIS, SDL_PixelFormat * format,
-static SDL_Surface* glSDL_SetVideoMode(_THIS, SDL_Surface *current,int width, int height, int bpp, Uint32 flags);
+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 )
 /*
 * 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,
+static void
-		SDL_Surface *dst, SDL_Rect *dstrect)
+glSDL_SoftBlit (SDL_Surface * src, SDL_Rect * srcrect,
-{
+SDL_Surface * dst, SDL_Rect * dstrect)
-	SDL_BlitInfo info;
+{
+SDL_BlitInfo info;
-	if(srcrect)
-		if(!srcrect->w || !srcrect->h)
+if (srcrect)
-			return;
+if (!srcrect->w || !srcrect->h)
+return;
-	/* Check to make sure the blit mapping is valid */
-	if ( (src->map->dst != dst) ||
+/* Check to make sure the blit mapping is valid */
-			(src->map->dst->format_version !=
+if ((src->map->dst != dst) ||
-			 src->map->format_version) )
+(src->map->dst->format_version != src->map->format_version))
-		if ( SDL_MapSurface(src, dst) < 0 )
+if (SDL_MapSurface (src, dst) < 0)
-			return;
+return;
-	/* Set up the blit information */
+/* Set up the blit information */
-	if(srcrect)
+if (srcrect) {
-	{
+info.s_pixels = (Uint8 *) src->pixels +
-		info.s_pixels = (Uint8 *) src->pixels +
+(Uint16) srcrect->y * src->pitch +
-			(Uint16) srcrect->y * src->pitch +
+(Uint16) srcrect->x * src->format->BytesPerPixel;
-			(Uint16) srcrect->x * src->format->BytesPerPixel;
+info.s_width = srcrect->w;
-		info.s_width = srcrect->w;
+info.s_height = srcrect->h;
-		info.s_height = srcrect->h;
+} else {
-	}
+info.s_pixels = (Uint8 *) src->pixels;
-	else
+info.s_width = src->w;
-	{
+info.s_height = src->h;
-		info.s_pixels = (Uint8 *) src->pixels;
+}
-		info.s_width = src->w;
+info.s_skip = src->pitch - info.s_width * src->format->BytesPerPixel;
-		info.s_height = src->h;
+if (dstrect) {
-	}
+info.d_pixels = (Uint8 *) dst->pixels +
-	info.s_skip = src->pitch - info.s_width * src->format->BytesPerPixel;
+(Uint16) dstrect->y * dst->pitch +
-	if(dstrect)
+(Uint16) dstrect->x * dst->format->BytesPerPixel;
-	{
+/*
-		info.d_pixels = (Uint8 *) dst->pixels +
+* NOTE: SDL_SoftBlit() uses the 'dstrect' for this!
-			(Uint16) dstrect->y * dst->pitch +
+*       This version is more like SDL_BlitSurface().
-			(Uint16) dstrect->x * dst->format->BytesPerPixel;
+*/
-		/*
+info.d_width = srcrect->w;
-		 * NOTE: SDL_SoftBlit() uses the 'dstrect' for this!
+info.d_height = srcrect->h;
-		 *       This version is more like SDL_BlitSurface().
+} else {
-		 */
+info.d_pixels = (Uint8 *) dst->pixels;
-		info.d_width = srcrect->w;
+info.d_width = dst->w;
-		info.d_height = srcrect->h;
+info.d_height = dst->h;
-	}
+}
-	else
+info.d_skip = dst->pitch - info.d_width * dst->format->BytesPerPixel;
-	{
+info.aux_data = src->map->sw_data->aux_data;
-		info.d_pixels = (Uint8 *) dst->pixels;
+info.src = src->format;
-		info.d_width = dst->w;
+info.table = src->map->table;
-		info.d_height = dst->h;
+info.dst = dst->format;
-	}
-	info.d_skip = dst->pitch - info.d_width * dst->format->BytesPerPixel;
+src->map->sw_data->blit (&info);
-	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,
+static SDL_Surface *
-		SDL_PixelFormat *format, Uint32 flags)
+glSDL_ConvertSurface (SDL_Surface * surface,
-{
+SDL_PixelFormat * format, Uint32 flags)
-	SDL_Surface *convert;
+{
-	Uint32 colorkey = 0;
+SDL_Surface *convert;
-	Uint8 alpha = 0;
+Uint32 colorkey = 0;
-	Uint32 surface_flags;
+Uint8 alpha = 0;
-	SDL_Rect bounds;
+Uint32 surface_flags;
+SDL_Rect bounds;
-	/* Create a new surface with the desired format */
-	convert = SDL_CreateRGBSurface(flags,
+/* Create a new surface with the desired format */
-			surface->w, surface->h, format->BitsPerPixel,
+convert = SDL_CreateRGBSurface (flags,
-			format->Rmask, format->Gmask, format->Bmask, format->Amask);
+surface->w, surface->h,
-	if ( convert == NULL ) {
+format->BitsPerPixel, format->Rmask,
-		return(NULL);
+format->Gmask, format->Bmask,
-	}
+format->Amask);
+if (convert == NULL) {
-	/* Save the original surface color key and alpha */
+return (NULL);
-	surface_flags = surface->flags;
+}
-	if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
-		/* Convert colourkeyed surfaces to RGBA if requested */
+/* Save the original surface color key and alpha */
-		if((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY
+surface_flags = surface->flags;
-				&& format->Amask) {
+if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
-			surface_flags &= ~SDL_SRCCOLORKEY;
+/* Convert colourkeyed surfaces to RGBA if requested */
-		} else {
+if ((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY && format->Amask) {
-			colorkey = surface->format->colorkey;
+surface_flags &= ~SDL_SRCCOLORKEY;
-			SDL_SetColorKey(surface, 0, 0);
+} 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 ) {
+if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
-			surface->flags &= ~SDL_SRCALPHA;
+/* Copy over the alpha channel to RGBA if requested */
-		} else {
+if (format->Amask) {
-			alpha = surface->format->alpha;
+surface->flags &= ~SDL_SRCALPHA;
-			SDL_SetAlpha(surface, 0, 0);
+} else {
-		}
+alpha = surface->format->alpha;
-	}
+SDL_SetAlpha (surface, 0, 0);
+}
-	/* Copy over the image data */
+}
-	bounds.x = 0;
-	bounds.y = 0;
+/* Copy over the image data */
-	bounds.w = surface->w;
+bounds.x = 0;
-	bounds.h = surface->h;
+bounds.y = 0;
-	glSDL_SoftBlit(surface, &bounds, convert, &bounds);
+bounds.w = surface->w;
+bounds.h = surface->h;
-	/* Clean up the original surface, and update converted surface */
+glSDL_SoftBlit (surface, &bounds, convert, &bounds);
-	if ( convert != NULL ) {
-		SDL_SetClipRect(convert, &surface->clip_rect);
+/* Clean up the original surface, and update converted surface */
-	}
+if (convert != NULL) {
-	if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
+SDL_SetClipRect (convert, &surface->clip_rect);
-		Uint32 cflags = surface_flags&(SDL_SRCCOLORKEY|SDL_RLEACCELOK);
+}
-		if ( convert != NULL ) {
+if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
-			Uint8 keyR, keyG, keyB;
+Uint32 cflags = surface_flags & (SDL_SRCCOLORKEY | SDL_RLEACCELOK);
+if (convert != NULL) {
-			SDL_GetRGB(colorkey,surface->format,&keyR,&keyG,&keyB);
+Uint8 keyR, keyG, keyB;
-			SDL_SetColorKey(convert, cflags|(flags&SDL_RLEACCELOK),
-					SDL_MapRGB(convert->format, keyR, keyG, keyB));
+SDL_GetRGB (colorkey, surface->format, &keyR, &keyG, &keyB);
-		}
+SDL_SetColorKey (convert, cflags | (flags & SDL_RLEACCELOK),
-		SDL_SetColorKey(surface, cflags, colorkey);
+SDL_MapRGB (convert->format, keyR, keyG, keyB));
-	}
+}
-	if ( (surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
+SDL_SetColorKey (surface, cflags, colorkey);
-		Uint32 aflags = surface_flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
+}
-		if ( convert != NULL ) {
+if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
-			SDL_SetAlpha(convert, aflags|(flags&SDL_RLEACCELOK),
+Uint32 aflags = surface_flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
-					alpha);
+if (convert != NULL) {
-		}
+SDL_SetAlpha (convert, aflags | (flags & SDL_RLEACCELOK), alpha);
-		if ( format->Amask ) {
+}
-			surface->flags |= SDL_SRCALPHA;
+if (format->Amask) {
-		} else {
+surface->flags |= SDL_SRCALPHA;
-			SDL_SetAlpha(surface, aflags, alpha);
+} else {
-		}
+SDL_SetAlpha (surface, aflags, alpha);
-	}
+}
+}
-	/* We're ready to go! */
-	return(convert);
+/* We're ready to go! */
+return (convert);
 }
 /*----------------------------------------------------------
 Some OpenGL function wrappers
 ----------------------------------------------------------*/
 static struct
 {
-	int	do_blend;
+int do_blend;
-	int	do_texture;
+int do_texture;
-	GLuint	texture;
+GLuint texture;
-	GLenum	sfactor, dfactor;
+GLenum sfactor, dfactor;
 } glstate;
-static void glSDL_reset(void)
+static void
-{
+glSDL_reset (void)
-	glstate.do_blend = -1;
+{
-	glstate.do_blend = -1;
+glstate.do_blend = -1;
-	glstate.texture = GLSDL_NOTEX;
+glstate.do_blend = -1;
-	glstate.sfactor = 0xffffffff;
+glstate.texture = GLSDL_NOTEX;
-	glstate.dfactor = 0xffffffff;
+glstate.sfactor = 0xffffffff;
-}
+glstate.dfactor = 0xffffffff;
+}
-static __inline__ void glSDL_do_blend(_THIS, int on)
-{
+static __inline__ void
-	if(glstate.do_blend == on)
+glSDL_do_blend (_THIS, int on)
-		return;
+{
+if (glstate.do_blend == on)
-	if(on)
+return;
-		this->glEnable(GL_BLEND);
-	else
+if (on)
-		this->glDisable(GL_BLEND);
+this->glEnable (GL_BLEND);
-	glstate.do_blend = on;
+else
-}
+this->glDisable (GL_BLEND);
+glstate.do_blend = on;
-static __inline__ void glSDL_do_texture(_THIS, int on)
+}
-{
-	if(glstate.do_texture == on)
+static __inline__ void
-		return;
+glSDL_do_texture (_THIS, int on)
+{
-	if(on)
+if (glstate.do_texture == on)
-		this->glEnable(GL_TEXTURE_2D);
+return;
-	else
-		this->glDisable(GL_TEXTURE_2D);
+if (on)
-	glstate.do_texture = on;
+this->glEnable (GL_TEXTURE_2D);
-}
+else
+this->glDisable (GL_TEXTURE_2D);
-static __inline__ void glSDL_blendfunc(_THIS, GLenum sfactor, GLenum dfactor)
+glstate.do_texture = on;
-{
+}
-	if((sfactor == glstate.sfactor) && (dfactor == glstate.dfactor))
-		return;
+static __inline__ void
+glSDL_blendfunc (_THIS, GLenum sfactor, GLenum dfactor)
-	this->glBlendFunc(sfactor, dfactor);
+{
+if ((sfactor == glstate.sfactor) && (dfactor == glstate.dfactor))
-	glstate.sfactor = sfactor;
+return;
-	glstate.dfactor = dfactor;
-}
+this->glBlendFunc (sfactor, dfactor);
-static __inline__ void glSDL_texture(_THIS, GLuint tx)
+glstate.sfactor = sfactor;
-{
+glstate.dfactor = dfactor;
-	if(tx == glstate.texture)
+}
-		return;
+static __inline__ void
-	this->glBindTexture(GL_TEXTURE_2D, tx);
+glSDL_texture (_THIS, GLuint tx)
-	glstate.texture = 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_SINGLE,
-	GLSDL_TM_HORIZONTAL,
+GLSDL_TM_HORIZONTAL,
-	GLSDL_TM_VERTICAL,
+GLSDL_TM_VERTICAL,
-	GLSDL_TM_HUGE
+GLSDL_TM_HUGE
 } GLSDL_TileModes;
 typedef struct private_hwdata
 {
-	/* Size of surface in logic screen pixels */
+/* Size of surface in logic screen pixels */
-	int		lw, lh;
+int lw, lh;
-	int		textures;
+int textures;
-	GLuint		*texture;
+GLuint *texture;
-	int		texsize;	/* width/height of OpenGL texture */
+int texsize;                /* width/height of OpenGL texture */
-	GLSDL_TileModes	tilemode;
+GLSDL_TileModes tilemode;
-	int		tilew, tileh;	/* At least one must equal texsize! */
+int tilew, tileh;           /* At least one must equal texsize! */
-	int		tilespertex;
+int tilespertex;
-	SDL_Rect	virt;		/* Total size of assembled surface */
+SDL_Rect virt;              /* Total size of assembled surface */
-	/* Area of surface to upload when/after unlocking */
+/* Area of surface to upload when/after unlocking */
-	SDL_Rect	invalid_area;
+SDL_Rect invalid_area;
-	int		temporary;	/* Throw away after one use. */
+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 *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 */
+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_Invalidate (SDL_Surface * surface, SDL_Rect * area);
-static void glSDL_SetLogicSize(_THIS, SDL_Surface *surface, int w, int h);
+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_UploadSurface (_THIS, SDL_Surface * surface);
-static private_hwdata *glSDL_GetTexInfo(SDL_Surface *surface);
+static private_hwdata *glSDL_GetTexInfo (SDL_Surface * surface);
-static void glSDL_init_formats(_THIS);
+static void glSDL_init_formats (_THIS);
-static private_hwdata *glSDL_AddTexInfo(_THIS, SDL_Surface *surface);
+static private_hwdata *glSDL_AddTexInfo (_THIS, SDL_Surface * surface);
-static void glSDL_RemoveTexInfo(_THIS, SDL_Surface *surface);
+static void glSDL_RemoveTexInfo (_THIS, SDL_Surface * surface);
-static void glSDL_UnloadTexture(_THIS, private_hwdata *txi);
+static void glSDL_UnloadTexture (_THIS, private_hwdata * txi);
-static int glSDL_BlitGL(_THIS, SDL_Surface *src,
+static int glSDL_BlitGL (_THIS, SDL_Surface * src,
-		SDL_Rect *srcrect, SDL_Rect *dstrect);
+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;
+SDL_Surface *OpenGL_Surface;
 /* pointer to the beggining of the list used for memory allocation */
-SDL_Surface* first = NULL;
+SDL_Surface *first = NULL;
 #ifdef DEBUG_GLSDL
-static __inline__ int GLERET(const char *txt)
+static __inline__ int
-{
+GLERET (const char *txt)
-	fprintf(stderr, "glSDL ERROR: '%s'\n", txt);
+{
-	return -1;
+fprintf (stderr, "glSDL ERROR: '%s'\n", txt);
-}
+return -1;
-static __inline__ void GLERR(const char *txt)
+}
-{
+static __inline__ void
-	fprintf(stderr, "glSDL ERROR: '%s'\n", txt);
+GLERR (const char *txt)
+{
+fprintf (stderr, "glSDL ERROR: '%s'\n", txt);
 }
 #else
 #define	GLERET(x)	(-1)
 #define	GLERR(x)
 #endif
 * 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;
+&QZ_bootstrap;
 #elif SDL_VIDEO_DRIVER_X11
-	&X11_bootstrap;
+&X11_bootstrap;
 #elif SDL_VIDEO_DRIVER_WINDIB
-	&WINDIB_bootstrap;
+&WINDIB_bootstrap;
 #elif SDL_VIDEO_DRIVER_BWINDOW
-	&BWINDOW_bootstrap;
+&BWINDOW_bootstrap;
 #elif SDL_VIDEO_DRIVER_TOOLBOX
-	&TOOLBOX_bootstrap;
+&TOOLBOX_bootstrap;
 #elif SDL_VIDEO_DRIVER_CYBERGRAPHICS
-	&CGX_bootstrap;
+&CGX_bootstrap;
 #elif SDL_VIDEO_DRIVER_PHOTON
-	&ph_bootstrap;
+&ph_bootstrap;
 #elif SDL_VIDEO_DRIVER_DC
-	&DC_bootstrap;
+&DC_bootstrap;
 #else
-	NULL;
+NULL;
 #endif
-static int glSDL_Available(void)
+static int
+glSDL_Available (void)
 {
 #ifdef DEBUG_GLSDL
-	fprintf(stderr,"available\n");
+fprintf (stderr, "available\n");
 #endif
-	if (opengl_bootstrap==NULL)
+if (opengl_bootstrap == NULL)
-		return 0;
+return 0;
-	return (opengl_bootstrap->available());
+return (opengl_bootstrap->available ());
 }
-static void glSDL_DeleteDevice(SDL_VideoDevice *device)
+static void
-{
+glSDL_DeleteDevice (SDL_VideoDevice * device)
-	SDL_free(device->hidden);
+{
-	SDL_free(device);
+SDL_free (device->hidden);
+SDL_free (device);
 }
 /* Create a glSDL device */
-static SDL_VideoDevice* glSDL_CreateDevice(int devindex)
+static SDL_VideoDevice *
-{
+glSDL_CreateDevice (int devindex)
-	SDL_VideoDevice *device;
+{
+SDL_VideoDevice *device;
 #ifdef DEBUG_GLSDL
-	fprintf(stderr,"entering createdevice\n");
+fprintf (stderr, "entering createdevice\n");
 #endif
-	/* Create the device with the underlying driver */
+/* Create the device with the underlying driver */
-	device = opengl_bootstrap->create(devindex);
+device = opengl_bootstrap->create (devindex);
-	/* Save the video device contents for future use */
+/* Save the video device contents for future use */
-	SDL_memcpy(&underlying_device,device,sizeof(SDL_VideoDevice));
+SDL_memcpy (&underlying_device, device, sizeof (SDL_VideoDevice));
-	/* Hook glSDL on the video device */
+/* Hook glSDL on the video device */
-	device->VideoInit = glSDL_VideoInit;
+device->VideoInit = glSDL_VideoInit;
-	device->ListModes = glSDL_ListModes;
+device->ListModes = glSDL_ListModes;
-	device->VideoQuit = glSDL_VideoQuit;
+device->VideoQuit = glSDL_VideoQuit;
-	device->UpdateRects = glSDL_UpdateRects;
+device->UpdateRects = glSDL_UpdateRects;
-	device->FillHWRect = glSDL_FillHWRect;
+device->FillHWRect = glSDL_FillHWRect;
-	device->SetHWColorKey = glSDL_SetHWColorKey;
+device->SetHWColorKey = glSDL_SetHWColorKey;
-	device->SetHWAlpha = glSDL_SetHWAlpha;
+device->SetHWAlpha = glSDL_SetHWAlpha;
-	device->AllocHWSurface = glSDL_AllocHWSurface;
+device->AllocHWSurface = glSDL_AllocHWSurface;
-	device->LockHWSurface = glSDL_LockHWSurface;
+device->LockHWSurface = glSDL_LockHWSurface;
-	device->UnlockHWSurface = glSDL_UnlockHWSurface;
+device->UnlockHWSurface = glSDL_UnlockHWSurface;
-	device->FlipHWSurface = glSDL_FlipHWSurface;
+device->FlipHWSurface = glSDL_FlipHWSurface;
-	device->FreeHWSurface = glSDL_FreeHWSurface;
+device->FreeHWSurface = glSDL_FreeHWSurface;
-	device->CheckHWBlit = glSDL_CheckHWBlit;
+device->CheckHWBlit = glSDL_CheckHWBlit;
-	device->SetColors = glSDL_SetColors;
+device->SetColors = glSDL_SetColors;
-	device->SetVideoMode = glSDL_SetVideoMode;
+device->SetVideoMode = glSDL_SetVideoMode;
-	device->info.hw_available=1;
+device->info.hw_available = 1;
-	device->info.blit_hw=1;
+device->info.blit_hw = 1;
-	device->info.blit_hw_CC=1;
+device->info.blit_hw_CC = 1;
-	device->info.blit_hw_A=1;
+device->info.blit_hw_A = 1;
-	device->info.blit_sw=1;
+device->info.blit_sw = 1;
-	device->info.blit_sw_CC=1;
+device->info.blit_sw_CC = 1;
-	device->info.blit_sw_A=1;
+device->info.blit_sw_A = 1;
-	device->info.blit_fill=1;
+device->info.blit_fill = 1;
-	/* These functions are not supported by glSDL, so we NULLify them */
+/* These functions are not supported by glSDL, so we NULLify them */
-	device->SetGamma = NULL;
+device->SetGamma = NULL;
-	device->GetGamma = NULL;
+device->GetGamma = NULL;
-	device->SetGammaRamp = NULL;
+device->SetGammaRamp = NULL;
-	device->GetGammaRamp = NULL;
+device->GetGammaRamp = NULL;
-	device->ToggleFullScreen = NULL;
+device->ToggleFullScreen = NULL;
-	device->free = glSDL_DeleteDevice;
+device->free = glSDL_DeleteDevice;
 #ifdef DEBUG_GLSDL
-	fprintf(stderr,"leaving createdevice\n");
+fprintf (stderr, "leaving createdevice\n");
 #endif
-	return device;
+return device;
 }
 /* Our bootstraping structure */
 VideoBootStrap glSDL_bootstrap = {
-	"glSDL", "glSDL - SDL over OpenGL",
+"glSDL", "glSDL - SDL over OpenGL",
-	glSDL_Available, glSDL_CreateDevice
+glSDL_Available, glSDL_CreateDevice
 };
-static int glSDL_VideoInit(_THIS, SDL_PixelFormat *vformat)
+static int
-{
+glSDL_VideoInit (_THIS, SDL_PixelFormat * vformat)
-	int r;
+{
-	printf("glSDL videoinit\n");
+int r;
+printf ("glSDL videoinit\n");
 #ifdef DEBUG_GLSDL
-	fprintf(stderr,"videoinit\n");
+fprintf (stderr, "videoinit\n");
 #endif
-	r=underlying_device.VideoInit(this,vformat);
+r = underlying_device.VideoInit (this, vformat);
-	this->info.hw_available=1;
+this->info.hw_available = 1;
-	this->info.blit_hw=1;
+this->info.blit_hw = 1;
-	this->info.blit_hw_CC=1;
+this->info.blit_hw_CC = 1;
-	this->info.blit_hw_A=1;
+this->info.blit_hw_A = 1;
-	this->info.blit_sw=1;
+this->info.blit_sw = 1;
-	this->info.blit_sw_CC=1;
+this->info.blit_sw_CC = 1;
-	this->info.blit_sw_A=1;
+this->info.blit_sw_A = 1;
-	this->info.blit_fill=1;
+this->info.blit_fill = 1;
-	return r;
+return r;
 }
-SDL_Rect **glSDL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
+SDL_Rect **
-{
+glSDL_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags)
-	return((SDL_Rect **)-1);
+{
-}
+return ((SDL_Rect **) - 1);
+}
-static void glSDL_VideoQuit(_THIS)
-{
+static void
-	SDL_Surface* scr;
+glSDL_VideoQuit (_THIS)
+{
-	/* free all hwdata structures */
+SDL_Surface *scr;
-	while(first!=NULL)
-		glSDL_RemoveTexInfo(this, first);
+/* free all hwdata structures */
+while (first != NULL)
-	SDL_free(mirrorbuf);
+glSDL_RemoveTexInfo (this, first);
-	mirrorbuf = NULL;
+SDL_free (mirrorbuf);
-	SDL_FreeFormat(RGBfmt);
+mirrorbuf = NULL;
-	SDL_FreeFormat(RGBAfmt);
-	RGBfmt = RGBAfmt = NULL;
+SDL_FreeFormat (RGBfmt);
+SDL_FreeFormat (RGBAfmt);
-	SDL_FreeFormat(this->displayformatalphapixel);
+RGBfmt = RGBAfmt = NULL;
-	this->displayformatalphapixel = NULL;
+SDL_FreeFormat (this->displayformatalphapixel);
-	SDL_FreeSurface(OpenGL_Surface);
+this->displayformatalphapixel = NULL;
-	OpenGL_Surface = NULL;
+SDL_FreeSurface (OpenGL_Surface);
-	/* restore the flags to gracefully exit from fullscreen */
+OpenGL_Surface = NULL;
-	this->screen->flags = old_screen_flags;
+/* restore the flags to gracefully exit from fullscreen */
-	/* keep the screen */
+this->screen->flags = old_screen_flags;
-	scr=this->screen;
+/* keep the screen */
-	/* we cleaned up our stuff, now restore the underlying video driver */
+scr = this->screen;
-	SDL_memcpy(this,&underlying_device,sizeof(SDL_VideoDevice));
+/* we cleaned up our stuff, now restore the underlying video driver */
-	this->screen=scr;
+SDL_memcpy (this, &underlying_device, sizeof (SDL_VideoDevice));
-	/* call the underlying video driver's VideoQuit function */
+this->screen = scr;
-	this->VideoQuit(this);
-}
+/* 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;
+static SDL_Surface *
-	int i;
+glSDL_SetVideoMode (_THIS, SDL_Surface * current, int width, int height,
-	int flag_doublebuf=0;
+int bpp, Uint32 flags)
+{
-	if (opengl_bootstrap==NULL)
+SDL_Surface *hooked_screen;
-	{
+int i;
-		GLERR("No bootstrap for glSDL compiled in !\n");
+int flag_doublebuf = 0;
-		return NULL;
-	}
+if (opengl_bootstrap == NULL) {
+GLERR ("No bootstrap for glSDL compiled in !\n");
-	/* we don't have OpenGL */
+return NULL;
-	if ((flags&SDL_INTERNALOPENGL)==SDL_INTERNALOPENGL)
+}
-	{
-		GLERR("OpenGL video modes are not supported by glSDL !\n");
+/* we don't have OpenGL */
-		return(NULL);
+if ((flags & SDL_INTERNALOPENGL) == SDL_INTERNALOPENGL) {
-	}
+GLERR ("OpenGL video modes are not supported by glSDL !\n");
+return (NULL);
-	/*
+}
-	 * Adjust the flags
-	 */
+/*
-	flags &= ~SDL_HWPALETTE;
+* Adjust the flags
-	flags |= SDL_INTERNALOPENGL;
+*/
+flags &= ~SDL_HWPALETTE;
-	/* remember whether the user requested DOUBLEBUF */
+flags |= SDL_INTERNALOPENGL;
-	if (flags&SDL_DOUBLEBUF)
+/* remember whether the user requested DOUBLEBUF */
-	{
-		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
+if (flags & SDL_DOUBLEBUF) {
-		flag_doublebuf=1;
+SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
-	}
+flag_doublebuf = 1;
-	else
+} else {
-	{
+SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 0);
-		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,0);
+flag_doublebuf = 0;
-		flag_doublebuf=0;
+}
-	}
+hooked_screen =
-	hooked_screen = underlying_device.SetVideoMode(this,current,width,height,0,flags);
+underlying_device.SetVideoMode (this, current, width, height, 0,
+flags);
-	if (!hooked_screen)
-	{
+if (!hooked_screen) {
-		GLERR("Unable to open an OpenGL window !\n");
+GLERR ("Unable to open an OpenGL window !\n");
-		return(NULL);
+return (NULL);
-	}
+}
-	/* save the screen flags for restore time */
+/* save the screen flags for restore time */
-	old_screen_flags = hooked_screen->flags;
+old_screen_flags = hooked_screen->flags;
 #ifdef DEBUG_GLSDL
-	fprintf(stderr,"got %d bpp\n",bpp);
+fprintf (stderr, "got %d bpp\n", bpp);
 #endif
-	/* setup the public surface format
+/* setup the public surface format
-	 * glSDL always returns the bpp its asked
+* glSDL always returns the bpp its asked
-	 */
+*/
-	switch(bpp)
+switch (bpp) {
-	{
+case 32:
-		case 32:
+this->is_32bit = 1;
-			this->is_32bit = 1;
+this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,
-			this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-					0x00FF0000,
+0x00FF0000,
-					0x0000FF00,
+0x0000FF00,
-					0x000000FF,
+0x000000FF, 0x00000000
-					0x00000000
 #else
-					0x0000FF00,
+0x0000FF00,
-					0x00FF0000,
+0x00FF0000,
-					0xFF000000,
+0xFF000000, 0x00000000
-					0x00000000
+#endif
-#endif
+);
-					);
+break;
-			break;
+case 24:
-		case 24:
+this->is_32bit = 0;
-			this->is_32bit = 0;
+this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,
-			this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-					0x00FF0000,
+0x00FF0000,
-					0x0000FF00,
+0x0000FF00,
-					0x000000FF,
+0x000000FF, 0x00000000
-					0x00000000
 #else
-					0x0000FF00,
+0x0000FF00,
-					0x00FF0000,
+0x00FF0000,
-					0xFF000000,
+0xFF000000, 0x00000000
-					0x00000000
+#endif
-#endif
+);
-					);
+break;
-			break;
+case 16:
-		case 16:
+this->is_32bit = 0;
-			this->is_32bit = 0;
+this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,
-			this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-					0x0000F800,
+0x0000F800,
-					0x000007E0,
+0x000007E0,
-					0x0000001F,
+0x0000001F, 0x00000000
-					0x00000000
 #else
-					0x0000001F,
+0x0000001F,
-					0x000007E0,
+0x000007E0,
-					0x0000F800,
+0x0000F800, 0x00000000
-					0x00000000
+#endif
-#endif
+);
-					);
+break;
-			break;
+case 15:
-		case 15:
+this->is_32bit = 0;
-			this->is_32bit = 0;
+this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,
-			this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-					0x00007C00,
+0x00007C00,
-					0x000003E0,
+0x000003E0,
-					0x0000001F,
+0x0000001F, 0x00000000
-					0x00000000
 #else
-					0x0000001F,
+0x0000001F,
-					0x000003E0,
+0x000003E0,
-					0x00007C00,
+0x00007C00, 0x00000000
-					0x00000000
+#endif
-#endif
+);
-					);
+break;
-			break;
+case 8:
-		case 8:
+default:
-		default:
+this->is_32bit = 0;
-			this->is_32bit = 0;
+this->screen =
-			this->screen = SDL_CreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0);
+SDL_CreateRGBSurface (flags, width, height, bpp, 0, 0, 0, 0);
-			/* give it a default palette if 8 bpp
+/* give it a default palette if 8 bpp
-			 * note : SDL already takes care of the palette for 4 bits & 1 bit surfaces
+* 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;
+break;
-	}
+}
-	/* also, we add SDL_HWSURFACE all the time, and let SDL create a shadow surface accordingly */
+/* 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;
+this->screen->flags =
-	/* add SDL_DOUBLEBUF if it was requested */
+hooked_screen->flags | SDL_HWSURFACE | SDL_INTERNALOPENGL;
-	if (flag_doublebuf)
+/* add SDL_DOUBLEBUF if it was requested */
-		this->screen->flags|=SDL_DOUBLEBUF;
+if (flag_doublebuf)
+this->screen->flags |= SDL_DOUBLEBUF;
-	/* Tell SDL the alpha pixel format we'd like to have */
-	this->displayformatalphapixel = SDL_AllocFormat(32,
+/* Tell SDL the alpha pixel format we'd like to have */
+this->displayformatalphapixel = SDL_AllocFormat (32,
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-			0xFF000000,
+0xFF000000,
-			0x00FF0000,
+0x00FF0000,
-			0x0000FF00,
+0x0000FF00, 0x000000FF
-			0x000000FF
 #else
-			0x000000FF,
+0x000000FF,
-			0x0000FF00,
+0x0000FF00,
-			0x00FF0000,
+0x00FF0000, 0xFF000000
-			0xFF000000
+#endif
-#endif
+);
-			);
+/* Now create the raw OpenGL surface */
-	/* Now create the raw OpenGL surface */
+OpenGL_Surface = SDL_CreateRGBSurface (flags, width, height, 24,
-	OpenGL_Surface = SDL_CreateRGBSurface(flags, width, height, 24,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-			0x000000FF,
+0x000000FF,
-			0x0000FF00,
+0x0000FF00, 0x00FF0000, 0x00000000
-			0x00FF0000,
-			0x00000000
 #else
-			0xFF000000,
+0xFF000000,
-			0x00FF0000,
+0x00FF0000, 0x0000FF00, 0x00000000
-			0x0000FF00,
+#endif
-			0x00000000
+);
-#endif
-			);
+/* Here we have to setup OpenGL funcs ourselves */
-	/* 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 ) { \
 	} 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 )
+if (this->GL_MakeCurrent (this) < 0)
-		return(NULL);
+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;
+maxtexsize = FAKE_MAXTEXSIZE;
 #else
-	this->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);
+this->glGetIntegerv (GL_MAX_TEXTURE_SIZE, &maxtexsize);
 #endif
 #ifdef DEBUG_GLSDL
-	fprintf(stderr, "glSDL: Max texture size: %d\n", maxtexsize);
+fprintf (stderr, "glSDL: Max texture size: %d\n", maxtexsize);
 #endif
-	glSDL_init_formats(this);
+glSDL_init_formats (this);
-	if (flag_doublebuf)
+if (flag_doublebuf)
-		this->glDrawBuffer(GL_BACK);
+this->glDrawBuffer (GL_BACK);
-	else
+else
-		this->glDrawBuffer(GL_FRONT);
+this->glDrawBuffer (GL_FRONT);
-	this->glDisable(GL_DITHER);
+this->glDisable (GL_DITHER);
-	if(glSDL_AddTexInfo(this, this->screen) < 0)
+if (glSDL_AddTexInfo (this, this->screen) < 0) {
-	{
+GLERR ("HookDevice() failed to add info to screen surface!");
-		GLERR("HookDevice() failed to add info to screen surface!");
+return NULL;
-		return NULL;
+}
-	}
+glSDL_SetLogicSize (this, this->screen, this->screen->w, this->screen->h);
-	glSDL_SetLogicSize(this, this->screen,
-			this->screen->w, this->screen->h);
+glSDL_do_texture (this, 0);
+glSDL_do_blend (this, 0);
-	glSDL_do_texture(this, 0);
-	glSDL_do_blend(this, 0);
+for (i = 0; i < 1 + flag_doublebuf; ++i) {
+this->glBegin (GL_TRIANGLE_FAN);
-	for(i = 0; i < 1+flag_doublebuf; ++i)
+this->glColor3ub (0, 0, 0);
-	{
+this->glVertex2i (0, 0);
-		this->glBegin(GL_TRIANGLE_FAN);
+this->glVertex2i (this->screen->w, 0);
-		this->glColor3ub(0, 0, 0);
+this->glVertex2i (this->screen->w, this->screen->h);
-		this->glVertex2i(0, 0);
+this->glVertex2i (0, this->screen->h);
-		this->glVertex2i(this->screen->w, 0);
+this->glEnd ();
-		this->glVertex2i(this->screen->w, this->screen->h);
+if (!i)
-		this->glVertex2i(0, this->screen->h);
+this->GL_SwapBuffers (this);
-		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!");
-	mirrorbuf = SDL_malloc(this->screen->h * this->screen->pitch);
+return NULL;
-	if(!mirrorbuf)
+}
-	{
-		GLERR("HookDevice() failed to allocate temp buffer for mirroring!");
+return this->screen;
-		return NULL;
+}
-	}
+static int
-	return this->screen;
+glSDL_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
-}
+{
+/* We don't need to fill this one */
-static int glSDL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+return 0;
-{
-	/* We don't need to fill this one */
-	return 0;
 }
 #ifdef DEBUG_GLSDL
-static void glSDL_print_glerror(_THIS, int point)
+static void
-{
+glSDL_print_glerror (_THIS, int point)
-	const char *err = "<unknown>";
+{
-	switch(this->glGetError())
+const char *err = "<unknown>";
-	{
+switch (this->glGetError ()) {
-		case GL_NO_ERROR:
+case GL_NO_ERROR:
-			return;
+return;
-		case GL_INVALID_ENUM:
+case GL_INVALID_ENUM:
-			err = "GL_INVALID_ENUM";
+err = "GL_INVALID_ENUM";
-			break;
+break;
-		case GL_INVALID_VALUE:
+case GL_INVALID_VALUE:
-			err = "GL_INVALID_VALUE";
+err = "GL_INVALID_VALUE";
-			break;
+break;
-		case GL_INVALID_OPERATION:
+case GL_INVALID_OPERATION:
-			err = "GL_INVALID_OPERATION";
+err = "GL_INVALID_OPERATION";
-			break;
+break;
-		case GL_STACK_OVERFLOW:
+case GL_STACK_OVERFLOW:
-			err = "GL_STACK_OVERFLOW";
+err = "GL_STACK_OVERFLOW";
-			break;
+break;
-		case GL_STACK_UNDERFLOW:
+case GL_STACK_UNDERFLOW:
-			err = "GL_STACK_UNDERFLOW";
+err = "GL_STACK_UNDERFLOW";
-			break;
+break;
-		case GL_OUT_OF_MEMORY:
+case GL_OUT_OF_MEMORY:
-			err = "GL_OUT_OF_MEMORY";
+err = "GL_OUT_OF_MEMORY";
-		default:
+default:
-			break;
+break;
-	}
+}
-	fprintf(stderr,"OpenGL error \"%s\" at point %d.\n", err, point);
+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)
+static __inline__ private_hwdata *
-{
+glSDL_GetTexInfo (SDL_Surface * surface)
-	if(!surface)
+{
-		return NULL;
+if (!surface)
-	return surface->hwdata;
+return NULL;
+return surface->hwdata;
 }
 /* Allocate a "blank" texinfo for a suface. */
-static private_hwdata *glSDL_AllocTexInfo(SDL_Surface *surface)
+static private_hwdata *
-{
+glSDL_AllocTexInfo (SDL_Surface * surface)
-	private_hwdata *txi;
+{
-	if(!surface)
+private_hwdata *txi;
-		return NULL;
+if (!surface)
+return NULL;
-	txi = glSDL_GetTexInfo(surface);
-	if(txi)
+txi = glSDL_GetTexInfo (surface);
-		return txi;		/* There already is one! --> */
+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));
+/* ...and hook a new texinfo struct up to it. */
-	if(!txi)
+txi = (private_hwdata *) SDL_calloc (1, sizeof (private_hwdata));
-	{
+if (!txi) {
-		GLERR("AllocTexInfo(): Failed allocating TexInfo struct!");
+GLERR ("AllocTexInfo(): Failed allocating TexInfo struct!");
-		return NULL;
+return NULL;
-	}
+}
-	txi->temporary = 1;
+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);
+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)
+static void
-{
+glSDL_RemoveTexInfo (_THIS, SDL_Surface * surface)
-	SDL_Surface *next,*prev;
+{
-	if(!glSDL_GetTexInfo(surface))
+SDL_Surface *next, *prev;
-		return;
+if (!glSDL_GetTexInfo (surface))
+return;
-	/* maintain our doubly linked list */
-	next=surface->hwdata->next;
+/* maintain our doubly linked list */
-	prev=surface->hwdata->prev;
+next = surface->hwdata->next;
-	if (prev!=NULL)
+prev = surface->hwdata->prev;
-	{
+if (prev != NULL) {
-		prev->hwdata->next = next;
+prev->hwdata->next = next;
-	}
+} else {
-	else
+first = next;
-	{
+}
-		first = next;
+if (next != NULL) {
-	}
+next->hwdata->prev = prev;
-	if (next!=NULL)
+}
-	{
-		next->hwdata->prev = prev;
+glSDL_FreeTexInfo (this, surface->hwdata);
-	}
+surface->hwdata = NULL;
-	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)
+static int
-{
+glSDL_CalcChop (private_hwdata * txi)
-	int rows, vw, vh;
+{
-	int vertical = 0;
+int rows, vw, vh;
-	int texsize;
+int vertical = 0;
-	int lastw, lasth, minsize;
+int texsize;
+int lastw, lasth, minsize;
-	vw = txi->virt.w;
-	vh = txi->virt.h;
+vw = txi->virt.w;
+vh = txi->virt.h;
 #ifdef DEBUG_GLSDL_CHOP
-	fprintf(stderr, "w=%d, h=%d ", vw, vh);
+fprintf (stderr, "w=%d, h=%d ", vw, vh);
 #endif
-	if(vh > vw)
+if (vh > vw) {
-	{
+int t = vw;
-		int t = vw;
+vw = vh;
-		vw = vh;
+vh = t;
-		vh = t;
+vertical = 1;
-		vertical = 1;
 #ifdef DEBUG_GLSDL_CHOP
-		fprintf(stderr, "(vertical) \t");
+fprintf (stderr, "(vertical) \t");
 #endif
-	}
+}
-	/*
+/*
-	 * Check whether this is a "huge" surface - at least one dimension
+* Check whether this is a "huge" surface - at least one dimension
-	 * must be <= than the maximum texture size, or we'll have to chop
+* must be <= than the maximum texture size, or we'll have to chop
-	 * in both directions.
+* in both directions.
-	 */
+*/
 #ifdef DEBUG_GLSDL
-	if(maxtexsize < 0)
+if (maxtexsize < 0)
-		return GLERET("glSDL_CalcChop() called before OpenGL init!");
+return GLERET ("glSDL_CalcChop() called before OpenGL init!");
 #endif
-	if(vh > maxtexsize)
+if (vh > maxtexsize) {
-	{
+/*
-		/*
+* Very simple hack for now; we just tile
-		 * Very simple hack for now; we just tile
+* both ways with maximum size textures.
-		 * both ways with maximum size textures.
+*/
-		 */
+texsize = maxtexsize;
-		texsize = maxtexsize;
+txi->tilemode = GLSDL_TM_HUGE;
-		txi->tilemode = GLSDL_TM_HUGE;
+txi->texsize = texsize;
-		txi->texsize = texsize;
+txi->tilew = texsize;
-		txi->tilew = texsize;
+txi->tileh = texsize;
-		txi->tileh = texsize;
+txi->tilespertex = 1;
-		txi->tilespertex = 1;
+/* Calculate number of textures needed */
-		/* Calculate number of textures needed */
+txi->textures = (vw + texsize - 1) / texsize;
-		txi->textures = (vw + texsize - 1) / texsize;
+txi->textures *= (vh + texsize - 1) / texsize;
-		txi->textures *= (vh + texsize - 1) / texsize;
+txi->texture = SDL_malloc (txi->textures * sizeof (int));
-		txi->texture = SDL_malloc(txi->textures * sizeof(int));
+SDL_memset (txi->texture, -1, txi->textures * sizeof (int));
-		SDL_memset(txi->texture, -1, txi->textures * sizeof(int));
+#ifdef DEBUG_GLSDL
-#ifdef DEBUG_GLSDL
+fprintf (stderr, "two-way tiling; textures=%d\n", txi->textures);
-		fprintf(stderr, "two-way tiling; textures=%d\n", txi->textures);
+#endif
-#endif
+if (!txi->texture) {
-		if(!txi->texture)
+fprintf (stderr, "glSDL: INTERNAL ERROR: Failed to allocate"
-		{
+" texture name table!\n");
-			fprintf(stderr, "glSDL: INTERNAL ERROR: Failed to allocate"
+return -3;
-					" texture name table!\n");
+}
-			return -3;
+return 0;
-		}
+}
-		return 0;
-	}
+/* Calculate minimum size */
+rows = 1;
-	/* Calculate minimum size */
+lastw = vw;
-	rows = 1;
+lasth = vh;
-	lastw = vw;
+minsize = lastw > lasth ? lastw : lasth;
-	lasth = vh;
+while (1) {
-	minsize = lastw > lasth ? lastw : lasth;
+int w, h, size;
-	while(1)
+++rows;
-	{
+w = vw / rows;
-		int w, h, size;
+h = rows * vh;
-		++rows;
+size = w > h ? w : h;
-		w = vw / rows;
+if (size >= minsize) {
-		h = rows * vh;
+--rows;
-		size = w > h ? w : h;
+break;
-		if(size >= minsize)
+}
-		{
+lastw = w;
-			--rows;
+lasth = h;
-			break;
+minsize = size;
-		}
+}
-		lastw = w;
+if (minsize > maxtexsize) {
-		lasth = h;
+/* Handle multiple textures for very wide/tall surfaces. */
-		minsize = size;
+minsize = maxtexsize;
-	}
+rows = (vw + minsize - 1) / minsize;
-	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, "==> minsize=%d ", minsize);
-	fprintf(stderr, "(rows=%d) \t", rows);
+fprintf (stderr, "(rows=%d) \t", rows);
 #endif
-	/* Recalculate with nearest higher power-of-2 width. */
+/* Recalculate with nearest higher power-of-2 width. */
-	for(texsize = 1; texsize < minsize; texsize <<= 1)
+for (texsize = 1; texsize < minsize; texsize <<= 1);
-		;
+txi->texsize = texsize;
-	txi->texsize = texsize;
+rows = (vw + texsize - 1) / texsize;
-	rows = (vw + texsize-1) / texsize;
 #ifdef DEBUG_GLSDL_CHOP
-	fprintf(stderr, "==> texsize=%d (rows=%d) \t", texsize, rows);
+fprintf (stderr, "==> texsize=%d (rows=%d) \t", texsize, rows);
 #endif
-	/* Calculate number of tiles per texture */
+/* Calculate number of tiles per texture */
-	txi->tilespertex = txi->texsize / vh;
+txi->tilespertex = txi->texsize / vh;
 #ifdef DEBUG_GLSDL_CHOP
-	fprintf(stderr, "tilespertex=%d \t", txi->tilespertex);
+fprintf (stderr, "tilespertex=%d \t", txi->tilespertex);
 #endif
-	/* Calculate number of textures needed */
+/* Calculate number of textures needed */
-	txi->textures = (rows + txi->tilespertex-1) / txi->tilespertex;
+txi->textures = (rows + txi->tilespertex - 1) / txi->tilespertex;
-	txi->texture = (GLuint *)SDL_malloc(txi->textures * sizeof(GLuint));
+txi->texture = (GLuint *) SDL_malloc (txi->textures * sizeof (GLuint));
-	SDL_memset(txi->texture, GLSDL_NOTEX, txi->textures * sizeof(GLuint));
+SDL_memset (txi->texture, GLSDL_NOTEX, txi->textures * sizeof (GLuint));
 #ifdef DEBUG_GLSDL_CHOP
-	fprintf(stderr, "textures=%d, ", txi->textures);
+fprintf (stderr, "textures=%d, ", txi->textures);
 #endif
-	if(!txi->texture)
+if (!txi->texture)
-		return GLERET("Failed to allocate texture name table!");
+return GLERET ("Failed to allocate texture name table!");
-	/* Set up tile size. (Only one axis supported here!) */
+/* Set up tile size. (Only one axis supported here!) */
-	if(1 == rows)
+if (1 == rows) {
-	{
+txi->tilemode = GLSDL_TM_SINGLE;
-		txi->tilemode = GLSDL_TM_SINGLE;
+if (vertical) {
-		if(vertical)
+txi->tilew = vh;
-		{
+txi->tileh = vw;
-			txi->tilew = vh;
+} else {
-			txi->tileh = vw;
+txi->tilew = vw;
-		}
+txi->tileh = vh;
-		else
+}
-		{
+} else if (vertical) {
-			txi->tilew = vw;
+txi->tilemode = GLSDL_TM_VERTICAL;
-			txi->tileh = vh;
+txi->tilew = vh;
-		}
+txi->tileh = texsize;
-	}
+} else {
-	else if(vertical)
+txi->tilemode = GLSDL_TM_HORIZONTAL;
-	{
+txi->tilew = texsize;
-		txi->tilemode = GLSDL_TM_VERTICAL;
+txi->tileh = vh;
-		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);
+fprintf (stderr, "tilew=%d, tileh=%d\n", txi->tilew, txi->tileh);
 #endif
-	return 0;
+return 0;
 }
 /* Create a temporary TexInfo struct for an SDL_Surface */
-static private_hwdata *glSDL_CreateTempTexInfo(_THIS, SDL_Surface *surface)
+static private_hwdata *
-{
+glSDL_CreateTempTexInfo (_THIS, SDL_Surface * surface)
-	private_hwdata *txi;
+{
-	if(!surface)
+private_hwdata *txi;
-	{
+if (!surface) {
-		GLERR("CreateTempTexInfo(); no surface!");
+GLERR ("CreateTempTexInfo(); no surface!");
-		return NULL;
+return NULL;
-	}
+}
-	if(IS_GLSDL_SURFACE(surface))
+if (IS_GLSDL_SURFACE (surface))
-		return glSDL_GetTexInfo(surface);	/* Do nothing */
+return glSDL_GetTexInfo (surface);      /* Do nothing */
-	txi = glSDL_AllocTexInfo(surface);
+txi = glSDL_AllocTexInfo (surface);
-	if(!txi)
+if (!txi) {
-	{
+GLERR ("CreateTempTexInfo(); Could not alloc TexInfo!");
-		GLERR("CreateTempTexInfo(); Could not alloc TexInfo!");
+return NULL;
-		return NULL;
+}
-	}
+txi->virt.w = txi->lw = surface->w;
-	txi->virt.w = txi->lw = surface->w;
+txi->virt.h = txi->lh = surface->h;
-	txi->virt.h = txi->lh = surface->h;
+if (glSDL_CalcChop (txi) < 0) {
-	if(glSDL_CalcChop(txi) < 0)
+glSDL_FreeTexInfo (this, txi);
-	{
+GLERR ("CreateTempTexInfo(); CalcChop() failed!");
-		glSDL_FreeTexInfo(this, txi);
+return NULL;
-		GLERR("CreateTempTexInfo(); CalcChop() failed!");
+}
-		return NULL;
-	}
+return txi;
-	return txi;
 }
 /* Add a glSDL_TexInfo struct to an SDL_Surface */
-static private_hwdata *glSDL_AddTexInfo(_THIS, SDL_Surface *surface)
+static private_hwdata *
-{
+glSDL_AddTexInfo (_THIS, SDL_Surface * surface)
-	private_hwdata *txi = glSDL_CreateTempTexInfo(this, surface);
+{
-	if(!txi)
+private_hwdata *txi = glSDL_CreateTempTexInfo (this, surface);
-		return NULL;
+if (!txi)
+return NULL;
-	/* Connect the surface to the new TexInfo. */
-	txi->temporary = 0;
+/* Connect the surface to the new TexInfo. */
-	surface->hwdata = txi;
+txi->temporary = 0;
+surface->hwdata = txi;
-	/* add this new surface in front of the list of hw surfaces */
-	txi->next = first;
+/* add this new surface in front of the list of hw surfaces */
-	txi->prev = NULL;
+txi->next = first;
-	first = surface;
+txi->prev = NULL;
-	if (txi->next!=NULL)
+first = surface;
-	{
+if (txi->next != NULL) {
-		txi->next->hwdata->prev=surface;
+txi->next->hwdata->prev = surface;
-	}
+}
-	SDL_SetClipRect(surface, &txi->virt);
+SDL_SetClipRect (surface, &txi->virt);
-	return txi;
+return txi;
 }
 /* Create a surface of the prefered OpenGL RGB texture format */
 /*static SDL_Surface *glSDL_CreateRGBSurface(int w, int h)
 	return s;
 }
 */
 /* Create a surface of the prefered OpenGL RGBA texture format */
-static SDL_Surface *glSDL_CreateRGBASurface(int w, int h)
+static SDL_Surface *
-{
+glSDL_CreateRGBASurface (int w, int h)
-	SDL_Surface *s;
+{
-	Uint32 rmask, gmask, bmask, amask;
+SDL_Surface *s;
-	int bits = 32;
+Uint32 rmask, gmask, bmask, amask;
+int bits = 32;
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-	rmask = 0x000000FF;
+rmask = 0x000000FF;
-	gmask = 0x0000FF00;
+gmask = 0x0000FF00;
-	bmask = 0x00FF0000;
+bmask = 0x00FF0000;
-	amask = 0xFF000000;
+amask = 0xFF000000;
 #else
-	rmask = 0xFF000000;
+rmask = 0xFF000000;
-	gmask = 0x00FF0000;
+gmask = 0x00FF0000;
-	bmask = 0x0000FF00;
+bmask = 0x0000FF00;
-	amask = 0x000000FF;
+amask = 0x000000FF;
 #endif
-	s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
+s = SDL_CreateRGBSurface (SDL_SWSURFACE, w, h,
-			bits, rmask, gmask, bmask, amask);
+bits, rmask, gmask, bmask, amask);
-	if(s)
+if (s)
-		s->flags |= SDL_HWACCEL;
+s->flags |= SDL_HWACCEL;
-	return s;
+return s;
 }
-static void glSDL_init_formats(_THIS)
+static void
-{
+glSDL_init_formats (_THIS)
-	RGBfmt = SDL_AllocFormat(24,
+{
+RGBfmt = SDL_AllocFormat (24,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-			0x000000FF,
+0x000000FF, 0x0000FF00, 0x00FF0000, 0);
-			0x0000FF00,
-			0x00FF0000,
-			0);
 #else
-			0x00FF0000,
+0x00FF0000, 0x0000FF00, 0x000000FF, 0);
-			0x0000FF00,
+#endif
-			0x000000FF,
+RGBAfmt = SDL_AllocFormat (32,
-			0);
-#endif
-	RGBAfmt = SDL_AllocFormat(32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-			0x000000FF,
+0x000000FF,
-			0x0000FF00,
+0x0000FF00, 0x00FF0000, 0xFF000000);
-			0x00FF0000,
-			0xFF000000);
 #else
-			0xFF000000,
+0xFF000000,
-			0x00FF0000,
+0x00FF0000, 0x0000FF00, 0x000000FF);
-			0x0000FF00,
+#endif
-			0x000000FF);
+}
-#endif
-}
+static int
+glSDL_FormatIsOk (SDL_Surface * surface)
-static int glSDL_FormatIsOk(SDL_Surface *surface)
+{
-{
+SDL_PixelFormat *pf;
-	SDL_PixelFormat *pf;
+if (!surface)
-	if(!surface)
+return 1;               /* Well, there ain't much we can do anyway... */
-		return 1;	/* Well, there ain't much we can do anyway... */
+pf = surface->format;
-	pf = surface->format;
+/* Colorkeying requires an alpha channel! */
-	/* Colorkeying requires an alpha channel! */
+if (surface->flags & SDL_SRCCOLORKEY)
-	if(surface->flags & SDL_SRCCOLORKEY)
+if (!pf->Amask)
-		if(!pf->Amask)
+return 0;
-			return 0;
+/* We need pitch == (width * BytesPerPixel) for glTex[Sub]Image2D() */
-	/* We need pitch == (width * BytesPerPixel) for glTex[Sub]Image2D() */
+if (surface->pitch != (surface->w * pf->BytesPerPixel))
-	if(surface->pitch != (surface->w * pf->BytesPerPixel))
+return 0;
-		return 0;
+if (pf->Amask) {
-	if(pf->Amask)
+if (pf->BytesPerPixel != RGBAfmt->BytesPerPixel)
-	{
+return 0;
-		if(pf->BytesPerPixel != RGBAfmt->BytesPerPixel)
+if (pf->Rmask != RGBAfmt->Rmask)
-			return 0;
+return 0;
-		if(pf->Rmask != RGBAfmt->Rmask)
+if (pf->Gmask != RGBAfmt->Gmask)
-			return 0;
+return 0;
-		if(pf->Gmask != RGBAfmt->Gmask)
+if (pf->Bmask != RGBAfmt->Bmask)
-			return 0;
+return 0;
-		if(pf->Bmask != RGBAfmt->Bmask)
+if (pf->Amask != RGBAfmt->Amask)
-			return 0;
+return 0;
-		if(pf->Amask != RGBAfmt->Amask)
+} else {
-			return 0;
+if (pf->BytesPerPixel != RGBfmt->BytesPerPixel)
-	}
+return 0;
-	else
+if (pf->Rmask != RGBfmt->Rmask)
-	{
+return 0;
-		if(pf->BytesPerPixel != RGBfmt->BytesPerPixel)
+if (pf->Gmask != RGBfmt->Gmask)
-			return 0;
+return 0;
-		if(pf->Rmask != RGBfmt->Rmask)
+if (pf->Bmask != RGBfmt->Bmask)
-			return 0;
+return 0;
-		if(pf->Gmask != RGBfmt->Gmask)
+}
-			return 0;
+return 1;
-		if(pf->Bmask != RGBfmt->Bmask)
+}
-			return 0;
-	}
+static void
-	return 1;
+glSDL_key2alpha (SDL_Surface * surface)
-}
+{
+int x, y;
-static void glSDL_key2alpha(SDL_Surface *surface)
+Uint32 ckey = surface->format->colorkey;
-{
-	int x, y;
-	Uint32 ckey = surface->format->colorkey;
 #ifdef DEBUG_GLSDL
-	fprintf(stderr,"glSDL_key2alpha()\n");
+fprintf (stderr, "glSDL_key2alpha()\n");
 #endif
-	for(y = 0; y < surface->h; ++y)
+for (y = 0; y < surface->h; ++y) {
-	{
+Uint32 *px =
-		Uint32 *px = (Uint32 *)((char *)surface->pixels + y*surface->pitch);
+(Uint32 *) ((char *) surface->pixels + y * surface->pitch);
-		for(x = 0; x < surface->w; ++x)
+for (x = 0; x < surface->w; ++x)
-			if(px[x] == ckey)
+if (px[x] == ckey)
-				px[x] = 0;
+px[x] = 0;
-	}
+}
 }
 /*----------------------------------------------------------
 SDL style API
 ----------------------------------------------------------*/
-static int glSDL_FlipHWSurface(_THIS, SDL_Surface *surface)
+static int
+glSDL_FlipHWSurface (_THIS, SDL_Surface * surface)
 {
 #ifdef GLSDL_GRAPHICAL_DEBUG
-	this->glDisable(GL_TEXTURE_2D);
+this->glDisable (GL_TEXTURE_2D);
-	this->glBegin(GL_LINE_LOOP);
+this->glBegin (GL_LINE_LOOP);
-	this->glColor4ub(0, 0, 255, 128);
+this->glColor4ub (0, 0, 255, 128);
-	this->glVertex2i(0,0);
+this->glVertex2i (0, 0);
-	this->glVertex2i(surface->w,0);
+this->glVertex2i (surface->w, 0);
-	this->glVertex2i(surface->w,surface->h);
+this->glVertex2i (surface->w, surface->h);
-	this->glVertex2i(0,surface->h);
+this->glVertex2i (0, surface->h);
-	this->glEnd();
+this->glEnd ();
-	this->glEnable(GL_TEXTURE_2D);
+this->glEnable (GL_TEXTURE_2D);
 #endif
-	if (this->screen->flags&SDL_DOUBLEBUF)
+if (this->screen->flags & SDL_DOUBLEBUF)
-		this->GL_SwapBuffers(this);
+this->GL_SwapBuffers (this);
-	else
+else
-		this->glFinish();
+this->glFinish ();
-	return 0;
+return 0;
 }
-static void glSDL_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
+static void
+glSDL_UpdateRects (_THIS, int numrects, SDL_Rect * rects)
 {
 #ifdef GLSDL_GRAPHICAL_DEBUG
-	int i;
+int i;
-	this->glDisable(GL_TEXTURE_2D);
+this->glDisable (GL_TEXTURE_2D);
-	for(i=0;i<numrects;i++)
+for (i = 0; i < numrects; i++) {
-	{
+this->glColor4ub (255, 0, 0, 128);
-		this->glColor4ub(255, 0, 0, 128);
+this->glBegin (GL_LINE_LOOP);
-		this->glBegin(GL_LINE_LOOP);
+this->glVertex2i (rects[i].x, rects[i].y);
-		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);
+this->glVertex2i (rects[i].x + rects[i].w, rects[i].y + rects[i].h);
-		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->glVertex2i(rects[i].x,rects[i].y+rects[i].h);
+this->glEnd ();
-		this->glEnd();
+}
-	}
+this->glEnable (GL_TEXTURE_2D);
-	this->glEnable(GL_TEXTURE_2D);
+#endif
-#endif
+if (this->screen->flags & SDL_DOUBLEBUF)
-	if (this->screen->flags&SDL_DOUBLEBUF)
+this->GL_SwapBuffers (this);
-		this->GL_SwapBuffers(this);
+else
-	else
+this->glFinish ();
-		this->glFinish();
+}
-}
+static int
-static int glSDL_AllocHWSurface(_THIS, SDL_Surface *surface)
+glSDL_AllocHWSurface (_THIS, SDL_Surface * surface)
 {
-	surface->flags |= (SDL_HWSURFACE|SDL_HWACCEL);
+surface->flags |= (SDL_HWSURFACE | SDL_HWACCEL);
-	surface->pixels = SDL_malloc(surface->h*surface->pitch);
+surface->pixels = SDL_malloc (surface->h * surface->pitch);
-	if ( surface->pixels == NULL ) {
+if (surface->pixels == NULL) {
-		SDL_FreeSurface(surface);
+SDL_FreeSurface (surface);
-		SDL_OutOfMemory();
+SDL_OutOfMemory ();
-		return(-1);
+return (-1);
-	}
+}
-	SDL_memset(surface->pixels, 0, surface->h*surface->pitch);
+SDL_memset (surface->pixels, 0, surface->h * surface->pitch);
-	return 0;
+return 0;
 }
-static void glSDL_FreeHWSurface(_THIS, SDL_Surface *surface)
+static void
-{
+glSDL_FreeHWSurface (_THIS, SDL_Surface * surface)
-	if(!surface)
+{
-		return;
+if (!surface)
-	glSDL_RemoveTexInfo(this, surface);
+return;
-}
+glSDL_RemoveTexInfo (this, surface);
+}
-static int glSDL_LockHWSurface(_THIS, SDL_Surface *surface)
-{
+static int
-	int y;
+glSDL_LockHWSurface (_THIS, SDL_Surface * surface)
+{
-	if(!surface)
+int y;
-		return -1;
+if (!surface)
-#ifdef DEBUG_GLSDL
+return -1;
-	fprintf(stderr, "glSDL: Lock Surface.\n");
-#endif
+#ifdef DEBUG_GLSDL
+fprintf (stderr, "glSDL: Lock Surface.\n");
-	if(SDL_VideoSurface == surface)
+#endif
-	{
-		glSDL_Invalidate(surface, NULL);
+if (SDL_VideoSurface == surface) {
-		this->glPixelStorei(GL_UNPACK_ROW_LENGTH,
+glSDL_Invalidate (surface, NULL);
-				surface->pitch /
+this->glPixelStorei (GL_UNPACK_ROW_LENGTH,
-				surface->format->BytesPerPixel);
+surface->pitch / surface->format->BytesPerPixel);
-		this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
+this->glReadPixels (0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
-				GL_RGB,
+GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
-				GL_UNSIGNED_BYTE,
+for (y = 0; y < OpenGL_Surface->h / 2; ++y) {
-				OpenGL_Surface->pixels);
+void *upper = (Uint8 *) OpenGL_Surface->pixels +
-		for(y = 0; y < OpenGL_Surface->h / 2; ++y)
+OpenGL_Surface->pitch * y;
-		{
+void *lower = (Uint8 *) OpenGL_Surface->pixels +
-			void *upper = (Uint8 *)OpenGL_Surface->pixels +
+OpenGL_Surface->pitch * (OpenGL_Surface->h - y - 1);
-				OpenGL_Surface->pitch * y;
+SDL_memcpy (mirrorbuf, upper, OpenGL_Surface->pitch);
-			void *lower = (Uint8 *)OpenGL_Surface->pixels +
+SDL_memcpy (upper, lower, OpenGL_Surface->pitch);
-				OpenGL_Surface->pitch * (OpenGL_Surface->h - y - 1);
+SDL_memcpy (lower, mirrorbuf, OpenGL_Surface->pitch);
-			SDL_memcpy(mirrorbuf, upper, OpenGL_Surface->pitch);
+}
-			SDL_memcpy(upper, lower, OpenGL_Surface->pitch);
+/* the mapping has to be invalidated on 8bpp video surfaces in case of a hw palette change.
-			SDL_memcpy(lower, mirrorbuf, OpenGL_Surface->pitch);
+* Now if someone could tell me why this is not handled by SDL... */
-		}
+if (SDL_VideoSurface->format->BitsPerPixel == 8)
-		/* the mapping has to be invalidated on 8bpp video surfaces in case of a hw palette change.
+SDL_InvalidateMap (OpenGL_Surface->map);
-		 * Now if someone could tell me why this is not handled by SDL... */
-		if (SDL_VideoSurface->format->BitsPerPixel==8)
+/* convert this raw surface to the application-requested format
-			SDL_InvalidateMap(OpenGL_Surface->map);
+* FIXME this is sometimes overkill, we could use glPixelStore smartly
+* But this would be slow anyway :) */
-		/* convert this raw surface to the application-requested format
-		 * FIXME this is sometimes overkill, we could use glPixelStore smartly
+glSDL_SoftBlit (OpenGL_Surface, NULL, SDL_VideoSurface, NULL);
-		 * But this would be slow anyway :) */
+} else
+glSDL_Invalidate (surface, NULL);
-		glSDL_SoftBlit(OpenGL_Surface, NULL, SDL_VideoSurface, NULL);
-	}
+return 0;
-	else
+}
-		glSDL_Invalidate(surface, NULL);
-	return 0;
+static void
-}
+glSDL_UnlockHWSurface (_THIS, SDL_Surface * surface)
+{
+private_hwdata *txi;
-static void glSDL_UnlockHWSurface(_THIS, SDL_Surface *surface)
-{
+if (!surface)
-	private_hwdata *txi;
+return;
-	if(!surface)
+/* upload this surface ONLY if this is a glSDL surface
-		return;
+* because sometimes (during displayformating for ex.) surfaces are unlocked that aren't glSDL
+*/
-	/* upload this surface ONLY if this is a glSDL surface
+if (!IS_GLSDL_SURFACE (surface))
-	 * because sometimes (during displayformating for ex.) surfaces are unlocked that aren't glSDL
+return;
-	 */
-	if(!IS_GLSDL_SURFACE(surface))
+#ifdef DEBUG_GLSDL
-		return;
+fprintf (stderr, "glSDL: Unlock Surface.\n");
+#endif
-#ifdef DEBUG_GLSDL
-	fprintf(stderr, "glSDL: Unlock Surface.\n");
+txi = glSDL_UploadSurface (this, surface);
-#endif
+if (!txi) {
-	txi = glSDL_UploadSurface(this, surface);
+GLERR ("glSDL_UnlockHWSurface() failed to upload surface!");
+return;
-	if(!txi)
+}
-	{
+if (txi->temporary) {
-		GLERR("glSDL_UnlockHWSurface() failed to upload surface!");
+GLERR
-		return;
+("Weirdness... glSDL_UnlockHWSurface() got a temporary TexInfo.");
-	}
+return;
-	if(txi->temporary)
+}
-	{
+if (surface == SDL_VideoSurface)
-		GLERR("Weirdness... glSDL_UnlockHWSurface() got a temporary TexInfo.");
+glSDL_BlitGL (this, SDL_VideoSurface, NULL, NULL);
-		return;
+}
-	}
-	if(surface == SDL_VideoSurface)
-		glSDL_BlitGL(this, SDL_VideoSurface, NULL, NULL);
+static int
-}
+glSDL_SetHWColorKey (_THIS, SDL_Surface * surface, Uint32 key)
+{
+/*
-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.
-	 * If an application does this *after* SDL_DisplayFormat,
+*
-	 * we're basically screwed, unless we want to do an
+* What we do is just kill the glSDL texinfo... No big
-	 * in-place surface conversion hack here.
+* deal in most cases, as glSDL only converts once anyway,
-	 *
+* *unless* you keep modifying the surface.
-	 * What we do is just kill the glSDL texinfo... No big
+*/
-	 * deal in most cases, as glSDL only converts once anyway,
+if (IS_GLSDL_SURFACE (surface))
-	 * *unless* you keep modifying the surface.
+glSDL_RemoveTexInfo (this, surface);
-	 */
+return 0;
-	if(IS_GLSDL_SURFACE(surface))
+}
-		glSDL_RemoveTexInfo(this, surface);
-	return 0;
-}
+static int
+glSDL_SetHWAlpha (_THIS, SDL_Surface * surface, Uint8 alpha)
+{
-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
-	 * If an application does this *after* SDL_DisplayFormat,
+* in-place surface conversion hack here.
-	 * 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,
-	 * What we do is just kill the glSDL texinfo... No big
+* *unless* you keep modifying the surface.
-	 * 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);
-	if(IS_GLSDL_SURFACE(surface))
+return 0;
-		glSDL_RemoveTexInfo(this, surface);
+}
-	return 0;
-}
+static SDL_bool
+glSDL_SetClipRect (_THIS, SDL_Surface * surface, SDL_Rect * rect)
-static SDL_bool glSDL_SetClipRect(_THIS, SDL_Surface *surface, SDL_Rect *rect)
+{
-{
+SDL_bool res;
-	SDL_bool res;
+if (!surface)
-	if(!surface)
+return SDL_FALSE;
-		return SDL_FALSE;
+res = SDL_SetClipRect (surface, rect);
-	res = SDL_SetClipRect(surface, rect);
+if (!res)
-	if(!res)
+return SDL_FALSE;
-		return SDL_FALSE;
+rect = &surface->clip_rect;
-	rect = &surface->clip_rect;
+if (surface == SDL_VideoSurface) {
-	if(surface == SDL_VideoSurface)
+SDL_Rect r;
-	{
+float xscale, yscale;
-		SDL_Rect r;
+private_hwdata *txi;
-		float xscale, yscale;
-		private_hwdata *txi;
+r.x = rect->x;
+r.y = rect->y;
-		r.x = rect->x;
+r.w = rect->w;
-		r.y = rect->y;
+r.h = rect->h;
-		r.w = rect->w;
+SDL_SetClipRect (surface, rect);
-		r.h = rect->h;
-		SDL_SetClipRect(surface, rect);
+txi = glSDL_GetTexInfo (surface);
+if (!txi)
-		txi = glSDL_GetTexInfo(surface);
+return GLERET ("SetClipRect(): Could not get TexInfo!");
-		if(!txi)
-			return GLERET("SetClipRect(): Could not get TexInfo!");
+this->glViewport (rect->x,
+surface->h - (rect->y + rect->h), rect->w, rect->h);
-		this->glViewport(rect->x,
+/*
-				surface->h - (rect->y + rect->h),
+* Note that this projection is upside down in
-				rect->w,
+* relation to the OpenGL coordinate system.
-				rect->h);
+*/
-		/*
+this->glMatrixMode (GL_PROJECTION);
-		 * Note that this projection is upside down in
+this->glLoadIdentity ();
-		 * relation to the OpenGL coordinate system.
+xscale = (float) txi->lw / (float) surface->w;
-		 */
+yscale = (float) txi->lh / (float) surface->h;
-		this->glMatrixMode(GL_PROJECTION);
+this->glOrtho (xscale * (float) rect->x,
-		this->glLoadIdentity();
+xscale * (float) (rect->w + rect->x),
-		xscale = (float)txi->lw / (float)surface->w;
+yscale * (float) (rect->h + rect->y),
-		yscale = (float)txi->lh / (float)surface->h;
+yscale * (float) rect->y, -1.0, 1.0);
-		this->glOrtho(	xscale*(float)rect->x,
+return SDL_TRUE;
-				xscale*(float)(rect->w+rect->x),
+}
-				yscale*(float)(rect->h+rect->y),
+return res;
-				yscale*(float)rect->y,
+}
-				-1.0, 1.0);
-		return SDL_TRUE;
+static int
-	}
+glSDL_BlitFromGL (_THIS, SDL_Rect * srcrect,
-	return res;
+SDL_Surface * dst, SDL_Rect * dstrect)
-}
+{
+SDL_Rect sr, dr;
-static int glSDL_BlitFromGL(_THIS, SDL_Rect *srcrect,
-		SDL_Surface *dst, SDL_Rect *dstrect)
+/* In case the destination has an OpenGL texture... */
-{
+glSDL_Invalidate (dst, dstrect);
-	SDL_Rect sr, dr;
+/* Abuse the fake screen buffer a little. */
-	/* In case the destination has an OpenGL texture... */
+this->glPixelStorei (GL_UNPACK_ROW_LENGTH, SDL_VideoSurface->pitch /
-	glSDL_Invalidate(dst, dstrect);
+SDL_VideoSurface->format->BytesPerPixel);
+if (srcrect)
-	/* Abuse the fake screen buffer a little. */
+this->glReadPixels (srcrect->x,
-	this->glPixelStorei(GL_UNPACK_ROW_LENGTH, SDL_VideoSurface->pitch /
+OpenGL_Surface->h - (srcrect->y + srcrect->h - 1),
-			SDL_VideoSurface->format->BytesPerPixel);
+srcrect->w, srcrect->h, GL_RGB, GL_UNSIGNED_BYTE,
-	if(srcrect)
+OpenGL_Surface->pixels);
-		this->glReadPixels(srcrect->x, OpenGL_Surface->h - (srcrect->y + srcrect->h - 1),
+else
-				srcrect->w, srcrect->h,
+this->glReadPixels (0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
-				GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
+GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
-	else
+sr = *srcrect;
-		this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
+dr = *dstrect;
-				GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
+glSDL_SoftBlit (OpenGL_Surface, &sr, dst, &dr);
-	sr = *srcrect;
+return 0;
-	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,
-static __inline__ void glSDL_BlitGL_single(_THIS, private_hwdata *txi,
+unsigned char alpha)
-		float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
+{
-{
+float sx2, sy2, texscale;
-	float sx2, sy2, texscale;
+if (!txi->textures)
-	if(!txi->textures)
+return;
-		return;
+if (-1 == txi->texture[0])
-	if(-1 == txi->texture[0])
+return;
-		return;
+glSDL_texture (this, txi->texture[0]);
-	glSDL_texture(this, txi->texture[0]);
+texscale = 1.0 / (float) txi->texsize;
-	texscale = 1.0 / (float)txi->texsize;
+sx2 = (sx1 + (float) dst->w) * texscale;
-	sx2 = (sx1 + (float)dst->w) * texscale;
+sy2 = (sy1 + (float) dst->h) * texscale;
-	sy2 = (sy1 + (float)dst->h) * texscale;
+sx1 *= texscale;
-	sx1 *= texscale;
+sy1 *= texscale;
-	sy1 *= texscale;
 #ifdef GLSDL_GRAPHICAL_DEBUG
-	this->glDisable(GL_TEXTURE_2D);
+this->glDisable (GL_TEXTURE_2D);
-	this->glBegin(GL_LINE_LOOP);
+this->glBegin (GL_LINE_LOOP);
-	this->glColor4ub(0, 255, 0, 128);
+this->glColor4ub (0, 255, 0, 128);
-	this->glVertex2i(dst->x, dst->y);
+this->glVertex2i (dst->x, dst->y);
-	this->glVertex2i(dst->x + dst->w, 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->w, dst->y + dst->h);
-	this->glVertex2i(dst->x, dst->y + dst->h);
+this->glVertex2i (dst->x, dst->y + dst->h);
-	this->glEnd();
+this->glEnd ();
-	this->glEnable(GL_TEXTURE_2D);
+this->glEnable (GL_TEXTURE_2D);
 #endif
-	this->glBegin(GL_TRIANGLE_FAN);
+this->glBegin (GL_TRIANGLE_FAN);
-	this->glColor4ub(255, 255, 255, alpha);
+this->glColor4ub (255, 255, 255, alpha);
-	this->glTexCoord2f(sx1, sy1);
+this->glTexCoord2f (sx1, sy1);
-	this->glVertex2i(dst->x, dst->y);
+this->glVertex2i (dst->x, dst->y);
-	this->glTexCoord2f(sx2, sy1);
+this->glTexCoord2f (sx2, sy1);
-	this->glVertex2i(dst->x + dst->w, dst->y);
+this->glVertex2i (dst->x + dst->w, dst->y);
-	this->glTexCoord2f(sx2, sy2);
+this->glTexCoord2f (sx2, sy2);
-	this->glVertex2i(dst->x + dst->w, dst->y + dst->h);
+this->glVertex2i (dst->x + dst->w, dst->y + dst->h);
-	this->glTexCoord2f(sx1, sy2);
+this->glTexCoord2f (sx1, sy2);
-	this->glVertex2i(dst->x, dst->y + dst->h);
+this->glVertex2i (dst->x, dst->y + dst->h);
-	this->glEnd();
+this->glEnd ();
 }
-static void glSDL_BlitGL_htile(_THIS, private_hwdata *txi,
+static void
-		float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
+glSDL_BlitGL_htile (_THIS, private_hwdata * txi,
-{
+float sx1, float sy1, SDL_Rect * dst, unsigned char alpha)
-	int tex;
+{
-	float tile, sx2, sy2, yo;
+int tex;
-	float texscale = 1.0 / (float)txi->texsize;
+float tile, sx2, sy2, yo;
-	float tileh = (float)txi->tileh * texscale;
+float texscale = 1.0 / (float) txi->texsize;
-	sx2 = (sx1 + (float)dst->w) * texscale;
+float tileh = (float) txi->tileh * texscale;
-	sy2 = (sy1 + (float)dst->h) * texscale;
+sx2 = (sx1 + (float) dst->w) * texscale;
-	sx1 *= texscale;
+sy2 = (sy1 + (float) dst->h) * texscale;
-	sy1 *= texscale;
+sx1 *= texscale;
-	tile = floor(sx1);
+sy1 *= texscale;
-	tex = (int)tile / txi->tilespertex;
+tile = floor (sx1);
-	yo = ((int)tile % txi->tilespertex) * tileh;
+tex = (int) tile / txi->tilespertex;
+yo = ((int) tile % txi->tilespertex) * tileh;
-	if(tex >= txi->textures)
-		return;
+if (tex >= txi->textures)
-	if(-1 == txi->texture[tex])
+return;
-		return;
+if (-1 == txi->texture[tex])
-	glSDL_texture(this, txi->texture[tex]);
+return;
+glSDL_texture (this, txi->texture[tex]);
-	while(tile < sx2)
-	{
+while (tile < sx2) {
-		int tdx1 = dst->x;
+int tdx1 = dst->x;
-		int tdx2 = dst->x + dst->w;
+int tdx2 = dst->x + dst->w;
-		float tsx1 = sx1 - tile;
+float tsx1 = sx1 - tile;
-		float tsx2 = sx2 - tile;
+float tsx2 = sx2 - tile;
-		/* Clip to current tile */
+/* Clip to current tile */
-		if(tsx1 < 0.0)
+if (tsx1 < 0.0) {
-		{
+tdx1 -= tsx1 * txi->texsize;
-			tdx1 -= tsx1 * txi->texsize;
+tsx1 = 0.0;
-			tsx1 = 0.0;
+}
-		}
+if (tsx2 > 1.0) {
-		if(tsx2 > 1.0)
+tdx2 -= (tsx2 - 1.0) * txi->texsize;
-		{
+tsx2 = 1.0;
-			tdx2 -= (tsx2 - 1.0) * txi->texsize;
+}
-			tsx2 = 1.0;
-		}
+/* Maybe select next texture? */
+if (yo + tileh > 1.0) {
-		/* Maybe select next texture? */
+++tex;
-		if(yo + tileh > 1.0)
+if (tex >= txi->textures)
-		{
+return;
-			++tex;
+if (-1 == txi->texture[tex])
-			if(tex >= txi->textures)
+return;
-				return;
+glSDL_texture (this, txi->texture[tex]);
-			if(-1 == txi->texture[tex])
+yo = 0.0;
-				return;
+}
-			glSDL_texture(this, txi->texture[tex]);
-			yo = 0.0;
-		}
 #ifdef GLSDL_GRAPHICAL_DEBUG
-		this->glDisable(GL_TEXTURE_2D);
+this->glDisable (GL_TEXTURE_2D);
-		this->glBegin(GL_LINE_LOOP);
+this->glBegin (GL_LINE_LOOP);
-		this->glColor4ub(0, 255, 0, 128);
+this->glColor4ub (0, 255, 0, 128);
-		this->glVertex2i(tdx1, dst->y);
+this->glVertex2i (tdx1, dst->y);
-		this->glVertex2i(tdx2, dst->y);
+this->glVertex2i (tdx2, dst->y);
-		this->glVertex2i(tdx2, dst->y + dst->h);
+this->glVertex2i (tdx2, dst->y + dst->h);
-		this->glVertex2i(tdx1, dst->y + dst->h);
+this->glVertex2i (tdx1, dst->y + dst->h);
-		this->glEnd();
+this->glEnd ();
-		this->glEnable(GL_TEXTURE_2D);
+this->glEnable (GL_TEXTURE_2D);
 #endif
-		this->glBegin(GL_TRIANGLE_FAN);
+this->glBegin (GL_TRIANGLE_FAN);
-		this->glColor4ub(255, 255, 255, alpha);
+this->glColor4ub (255, 255, 255, alpha);
-		this->glTexCoord2f(tsx1, yo + sy1);
+this->glTexCoord2f (tsx1, yo + sy1);
-		this->glVertex2i(tdx1, dst->y);
+this->glVertex2i (tdx1, dst->y);
-		this->glTexCoord2f(tsx2, yo + sy1);
+this->glTexCoord2f (tsx2, yo + sy1);
-		this->glVertex2i(tdx2, dst->y);
+this->glVertex2i (tdx2, dst->y);
-		this->glTexCoord2f(tsx2, yo + sy2);
+this->glTexCoord2f (tsx2, yo + sy2);
-		this->glVertex2i(tdx2, dst->y + dst->h);
+this->glVertex2i (tdx2, dst->y + dst->h);
-		this->glTexCoord2f(tsx1, yo + sy2);
+this->glTexCoord2f (tsx1, yo + sy2);
-		this->glVertex2i(tdx1, dst->y + dst->h);
+this->glVertex2i (tdx1, dst->y + dst->h);
-		this->glEnd();
+this->glEnd ();
-		tile += 1.0;
+tile += 1.0;
-		yo += tileh;
+yo += tileh;
-	}
+}
 }
-static void glSDL_BlitGL_vtile(_THIS, private_hwdata *txi,
+static void
-		float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
+glSDL_BlitGL_vtile (_THIS, private_hwdata * txi,
-{
+float sx1, float sy1, SDL_Rect * dst, unsigned char alpha)
-	int tex;
+{
-	float tile, sx2, sy2, xo;
+int tex;
-	float texscale = 1.0 / (float)txi->texsize;
+float tile, sx2, sy2, xo;
-	float tilew = (float)txi->tilew * texscale;
+float texscale = 1.0 / (float) txi->texsize;
-	sx2 = (sx1 + (float)dst->w) * texscale;
+float tilew = (float) txi->tilew * texscale;
-	sy2 = (sy1 + (float)dst->h) * texscale;
+sx2 = (sx1 + (float) dst->w) * texscale;
-	sx1 *= texscale;
+sy2 = (sy1 + (float) dst->h) * texscale;
-	sy1 *= texscale;
+sx1 *= texscale;
-	tile = floor(sy1);
+sy1 *= texscale;
-	tex = (int)tile / txi->tilespertex;
+tile = floor (sy1);
-	xo = ((int)tile % txi->tilespertex) * tilew;
+tex = (int) tile / txi->tilespertex;
+xo = ((int) tile % txi->tilespertex) * tilew;
-	if(tex >= txi->textures)
-		return;
+if (tex >= txi->textures)
-	if(-1 == txi->texture[tex])
+return;
-		return;
+if (-1 == txi->texture[tex])
-	glSDL_texture(this, txi->texture[tex]);
+return;
+glSDL_texture (this, txi->texture[tex]);
-	while(tile < sy2)
-	{
+while (tile < sy2) {
-		int tdy1 = dst->y;
+int tdy1 = dst->y;
-		int tdy2 = dst->y + dst->h;
+int tdy2 = dst->y + dst->h;
-		float tsy1 = sy1 - tile;
+float tsy1 = sy1 - tile;
-		float tsy2 = sy2 - tile;
+float tsy2 = sy2 - tile;
-		/* Clip to current tile */
+/* Clip to current tile */
-		if(tsy1 < 0.0)
+if (tsy1 < 0.0) {
-		{
+tdy1 -= tsy1 * txi->texsize;
-			tdy1 -= tsy1 * txi->texsize;
+tsy1 = 0.0;
-			tsy1 = 0.0;
+}
-		}
+if (tsy2 > 1.0) {
-		if(tsy2 > 1.0)
+tdy2 -= (tsy2 - 1.0) * txi->texsize;
-		{
+tsy2 = 1.0;
-			tdy2 -= (tsy2 - 1.0) * txi->texsize;
+}
-			tsy2 = 1.0;
-		}
+/* Maybe select next texture? */
+if (xo + tilew > 1.0) {
-		/* Maybe select next texture? */
+++tex;
-		if(xo + tilew > 1.0)
+if (tex >= txi->textures)
-		{
+return;
-			++tex;
+if (-1 == txi->texture[tex])
-			if(tex >= txi->textures)
+return;
-				return;
+glSDL_texture (this, txi->texture[tex]);
-			if(-1 == txi->texture[tex])
+xo = 0.0;
-				return;
+}
-			glSDL_texture(this, txi->texture[tex]);
-			xo = 0.0;
-		}
 #ifdef GLSDL_GRAPHICAL_DEBUG
-		this->glDisable(GL_TEXTURE_2D);
+this->glDisable (GL_TEXTURE_2D);
-		this->glBegin(GL_LINE_LOOP);
+this->glBegin (GL_LINE_LOOP);
-		this->glColor4ub(0, 255, 0, 128);
+this->glColor4ub (0, 255, 0, 128);
-		this->glVertex2i(dst->x, tdy1);
+this->glVertex2i (dst->x, tdy1);
-		this->glVertex2i(dst->x + dst->w, tdy1);
+this->glVertex2i (dst->x + dst->w, tdy1);
-		this->glVertex2i(dst->x + dst->w, tdy2);
+this->glVertex2i (dst->x + dst->w, tdy2);
-		this->glVertex2i(dst->x, tdy2);
+this->glVertex2i (dst->x, tdy2);
-		this->glEnd();
+this->glEnd ();
-		this->glEnable(GL_TEXTURE_2D);
+this->glEnable (GL_TEXTURE_2D);
 #endif
-		this->glBegin(GL_TRIANGLE_FAN);
+this->glBegin (GL_TRIANGLE_FAN);
-		this->glColor4ub(255, 255, 255, alpha);
+this->glColor4ub (255, 255, 255, alpha);
-		this->glTexCoord2f(xo + sx1, tsy1);
+this->glTexCoord2f (xo + sx1, tsy1);
-		this->glVertex2i(dst->x, tdy1);
+this->glVertex2i (dst->x, tdy1);
-		this->glTexCoord2f(xo + sx2, tsy1);
+this->glTexCoord2f (xo + sx2, tsy1);
-		this->glVertex2i(dst->x + dst->w, tdy1);
+this->glVertex2i (dst->x + dst->w, tdy1);
-		this->glTexCoord2f(xo + sx2, tsy2);
+this->glTexCoord2f (xo + sx2, tsy2);
-		this->glVertex2i(dst->x + dst->w, tdy2);
+this->glVertex2i (dst->x + dst->w, tdy2);
-		this->glTexCoord2f(xo + sx1, tsy2);
+this->glTexCoord2f (xo + sx1, tsy2);
-		this->glVertex2i(dst->x, tdy2);
+this->glVertex2i (dst->x, tdy2);
-		this->glEnd();
+this->glEnd ();
-		tile += 1.0;
+tile += 1.0;
-		xo += tilew;
+xo += tilew;
-	}
+}
 }
-static void glSDL_BlitGL_hvtile(_THIS, SDL_Surface *src, private_hwdata *txi,
+static void
-		float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
+glSDL_BlitGL_hvtile (_THIS, SDL_Surface * src, private_hwdata * txi,
-{
+float sx1, float sy1, SDL_Rect * dst,
-	int x, y, last_tex, tex;
+unsigned char alpha)
-	float sx2, sy2;
+{
-	float texscale = 1.0 / (float)txi->texsize;
+int x, y, last_tex, tex;
-	int tilesperrow = (src->w + txi->tilew - 1) / txi->tilew;
+float sx2, sy2;
-	sx2 = (sx1 + (float)dst->w) * texscale;
+float texscale = 1.0 / (float) txi->texsize;
-	sy2 = (sy1 + (float)dst->h) * texscale;
+int tilesperrow = (src->w + txi->tilew - 1) / txi->tilew;
-	sx1 *= texscale;
+sx2 = (sx1 + (float) dst->w) * texscale;
-	sy1 *= texscale;
+sy2 = (sy1 + (float) dst->h) * texscale;
+sx1 *= texscale;
-	last_tex = tex = floor(sy1) * tilesperrow + floor(sx1);
+sy1 *= texscale;
-	if(tex >= txi->textures)
-		return;
+last_tex = tex = floor (sy1) * tilesperrow + floor (sx1);
-	if(-1 == txi->texture[tex])
+if (tex >= txi->textures)
-		return;
+return;
-	glSDL_texture(this, txi->texture[tex]);
+if (-1 == txi->texture[tex])
+return;
-	for(y = floor(sy1); y < sy2; ++y)
+glSDL_texture (this, txi->texture[tex]);
-	{
-		int tdy1 = dst->y;
+for (y = floor (sy1); y < sy2; ++y) {
-		int tdy2 = dst->y + dst->h;
+int tdy1 = dst->y;
-		float tsy1 = sy1 - y;
+int tdy2 = dst->y + dst->h;
-		float tsy2 = sy2 - y;
+float tsy1 = sy1 - y;
+float tsy2 = sy2 - y;
-		/* Clip to current tile */
-		if(tsy1 < 0.0)
+/* Clip to current tile */
-		{
+if (tsy1 < 0.0) {
-			tdy1 -= tsy1 * txi->texsize;
+tdy1 -= tsy1 * txi->texsize;
-			tsy1 = 0.0;
+tsy1 = 0.0;
-		}
+}
-		if(tsy2 > 1.0)
+if (tsy2 > 1.0) {
-		{
+tdy2 -= (tsy2 - 1.0) * txi->texsize;
-			tdy2 -= (tsy2 - 1.0) * txi->texsize;
+tsy2 = 1.0;
-			tsy2 = 1.0;
+}
-		}
+for (x = floor (sx1); x < sx2; ++x) {
-		for(x = floor(sx1); x < sx2; ++x)
+int tdx1 = dst->x;
-		{
+int tdx2 = dst->x + dst->w;
-			int tdx1 = dst->x;
+float tsx1 = sx1 - x;
-			int tdx2 = dst->x + dst->w;
+float tsx2 = sx2 - x;
-			float tsx1 = sx1 - x;
-			float tsx2 = sx2 - x;
+/* Clip to current tile */
+if (tsx1 < 0.0) {
-			/* Clip to current tile */
+tdx1 -= tsx1 * txi->texsize;
-			if(tsx1 < 0.0)
+tsx1 = 0.0;
-			{
+}
-				tdx1 -= tsx1 * txi->texsize;
+if (tsx2 > 1.0) {
-				tsx1 = 0.0;
+tdx2 -= (tsx2 - 1.0) * txi->texsize;
-			}
+tsx2 = 1.0;
-			if(tsx2 > 1.0)
+}
-			{
-				tdx2 -= (tsx2 - 1.0) * txi->texsize;
+/* Select texture */
-				tsx2 = 1.0;
+tex = y * tilesperrow + x;
-			}
+if (tex != last_tex) {
+if (tex >= txi->textures)
-			/* Select texture */
+return;
-			tex = y * tilesperrow + x;
+if (-1 == txi->texture[tex])
-			if(tex != last_tex)
+return;
-			{
+glSDL_texture (this, txi->texture[tex]);
-				if(tex >= txi->textures)
+last_tex = tex;
-					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->glDisable (GL_TEXTURE_2D);
-			this->glBegin(GL_LINE_LOOP);
+this->glBegin (GL_LINE_LOOP);
-			this->glColor4ub(0, 255, 0, 128);
+this->glColor4ub (0, 255, 0, 128);
-			this->glVertex2i(tdx1, tdy1);
+this->glVertex2i (tdx1, tdy1);
-			this->glVertex2i(tdx2, tdy1);
+this->glVertex2i (tdx2, tdy1);
-			this->glVertex2i(tdx2, tdy2);
+this->glVertex2i (tdx2, tdy2);
-			this->glVertex2i(tdx1, tdy2);
+this->glVertex2i (tdx1, tdy2);
-			this->glEnd();
+this->glEnd ();
-			this->glEnable(GL_TEXTURE_2D);
+this->glEnable (GL_TEXTURE_2D);
 #endif
-			this->glBegin(GL_TRIANGLE_FAN);
+this->glBegin (GL_TRIANGLE_FAN);
-			this->glColor4ub(255, 255, 255, alpha);
+this->glColor4ub (255, 255, 255, alpha);
-			this->glTexCoord2f(tsx1, tsy1);
+this->glTexCoord2f (tsx1, tsy1);
-			this->glVertex2i(tdx1, tdy1);
+this->glVertex2i (tdx1, tdy1);
-			this->glTexCoord2f(tsx2, tsy1);
+this->glTexCoord2f (tsx2, tsy1);
-			this->glVertex2i(tdx2, tdy1);
+this->glVertex2i (tdx2, tdy1);
-			this->glTexCoord2f(tsx2, tsy2);
+this->glTexCoord2f (tsx2, tsy2);
-			this->glVertex2i(tdx2, tdy2);
+this->glVertex2i (tdx2, tdy2);
-			this->glTexCoord2f(tsx1, tsy2);
+this->glTexCoord2f (tsx1, tsy2);
-			this->glVertex2i(tdx1, tdy2);
+this->glVertex2i (tdx1, tdy2);
-			this->glEnd();
+this->glEnd ();
-		}
+}
-	}
+}
 }
 /*
 * Calculate the actual blit rectangle and source offset
 * for a blit from a rectangle in a surface with specified
 * 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,
+static __inline__ int
-		int *x, int *y, SDL_Rect *clip)
+blitclip (SDL_Rect * rect, int w, int h, int *x, int *y, SDL_Rect * clip)
 {
-	int sx1, sy1, sx2, sy2;
+int sx1, sy1, sx2, sy2;
-	int dx1, dy1, dx2, dy2;
+int dx1, dy1, dx2, dy2;
-	/* Get source and destination coordinates */
+/* Get source and destination coordinates */
-	sx1 = rect->x;
+sx1 = rect->x;
-	sy1 = rect->y;
+sy1 = rect->y;
-	sx2 = sx1 + rect->w;
+sx2 = sx1 + rect->w;
-	sy2 = sy1 + rect->h;
+sy2 = sy1 + rect->h;
-	dx1 = *x;
+dx1 = *x;
-	dy1 = *y;
+dy1 = *y;
-	/* Keep source rect inside source surface */
+/* Keep source rect inside source surface */
-	if(sx1 < 0)
+if (sx1 < 0) {
-	{
+dx1 -= sx1;
-		dx1 -= sx1;
+sx1 = 0;
-		sx1 = 0;
+}
-	}
+if (sy1 < 0) {
-	if(sy1 < 0)
+dy1 -= sy1;
-	{
+sy1 = 0;
-		dy1 -= sy1;
+}
-		sy1 = 0;
+if (sx2 > w)
-	}
+sx2 = w;
-	if(sx2 > w)
+if (sy2 > h)
-		sx2 = w;
+sy2 = h;
-	if(sy2 > h)
-		sy2 = h;
+/* Cull blits from void space */
+if (sx1 >= sx2 || sy1 >= sy2)
-	/* Cull blits from void space */
+return 0;
-	if(sx1 >= sx2 || sy1 >= sy2)
-		return 0;
+/* Calculate destination lower-right */
+dx2 = dx1 + (sx2 - sx1);
-	/* Calculate destination lower-right */
+dy2 = dy1 + (sy2 - sy1);
-	dx2 = dx1 + (sx2 - sx1);
-	dy2 = dy1 + (sy2 - sy1);
+/* Clip to destination cliprect */
+if (dx1 < clip->x) {
-	/* Clip to destination cliprect */
+sx1 += clip->x - dx1;
-	if(dx1 < clip->x)
+dx1 = clip->x;
-	{
+}
-		sx1 += clip->x - dx1;
+if (dy1 < clip->y) {
-		dx1 = clip->x;
+sy1 += clip->y - dy1;
-	}
+dy1 = clip->y;
-	if(dy1 < clip->y)
+}
-	{
+if (dx2 > clip->x + clip->w)
-		sy1 += clip->y - dy1;
+dx2 = clip->x + clip->w;
-		dy1 = clip->y;
+if (dy2 > clip->y + clip->h)
-	}
+dy2 = clip->y + clip->h;
-	if(dx2 > clip->x + clip->w)
-		dx2 = clip->x + clip->w;
+/* Cull nop/off-screen blits */
-	if(dy2 > clip->y + clip->h)
+if (dx1 >= dx2 || dy1 >= dy2)
-		dy2 = clip->y + clip->h;
+return 0;
-	/* Cull nop/off-screen blits */
+*x = sx1;
-	if(dx1 >= dx2 || dy1 >= dy2)
+*y = sy1;
-		return 0;
+rect->x = dx1;
+rect->y = dy1;
-	*x = sx1;
+rect->w = dx2 - dx1;
-	*y = sy1;
+rect->h = dy2 - dy1;
-	rect->x = dx1;
+return 1;
-	rect->y = dy1;
+}
-	rect->w = dx2 - dx1;
-	rect->h = dy2 - dy1;
+static int
-	return 1;
+glSDL_BlitGL (_THIS, SDL_Surface * src,
-}
+SDL_Rect * srcrect, SDL_Rect * dstrect)
+{
-static int glSDL_BlitGL(_THIS, SDL_Surface *src,
+private_hwdata *txi;
-		SDL_Rect *srcrect, SDL_Rect *dstrect)
+float x1, y1;
-{
+unsigned char alpha;
-	private_hwdata *txi;
+SDL_Rect d;
-	float x1, y1;
+int x, y;
-	unsigned char alpha;
+SDL_Rect r;
-	SDL_Rect d;
-	int x, y;
+if (!src)
-	SDL_Rect r;
+return GLERET ("BlitGL(): No src surface!");
-	if(!src)
+/* Get source and destination coordinates */
-		return GLERET("BlitGL(): No src surface!");
+if (srcrect)
+r = *srcrect;
-	/* Get source and destination coordinates */
+else {
-	if(srcrect)
+r.x = r.y = 0;
-		r = *srcrect;
+r.w = src->w;
-	else
+r.h = src->h;
-	{
+}
-		r.x = r.y = 0;
+if (dstrect) {
-		r.w = src->w;
+x = dstrect->x;
-		r.h = src->h;
+y = dstrect->y;
-	}
+} else
-	if(dstrect)
+x = y = 0;
-	{
-		x = dstrect->x;
+/* Clip! */
-		y = dstrect->y;
+if (!blitclip (&r, src->w, src->h, &x, &y, &this->screen->clip_rect)) {
-	}
+if (dstrect)
-	else
+dstrect->w = dstrect->h = 0;
-		x = y = 0;
+return 0;
+}
-	/* Clip! */
-	if(!blitclip(&r, src->w, src->h, &x, &y, &this->screen->clip_rect))
+/* Write back the resulting cliprect */
-	{
+if (dstrect)
-		if(dstrect)
+*dstrect = r;
-			dstrect->w = dstrect->h = 0;
-		return 0;
+/* Make sure we have a source with a valid texture */
-	}
+txi = glSDL_UploadSurface (this, src);
+if (!txi)
-	/* Write back the resulting cliprect */
+return GLERET ("BlitGL(): Could not get a TexInfo!");
-	if(dstrect)
-		*dstrect = r;
+/* Set up blending */
+if (src->flags & (SDL_SRCALPHA | SDL_SRCCOLORKEY)) {
-	/* Make sure we have a source with a valid texture */
+glSDL_blendfunc (this, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	txi = glSDL_UploadSurface(this, src);
+glSDL_do_blend (this, 1);
-	if(!txi)
+} else
-		return GLERET("BlitGL(): Could not get a TexInfo!");
+glSDL_do_blend (this, 0);
-	/* Set up blending */
+/* Enable texturing */
-	if(src->flags & (SDL_SRCALPHA | SDL_SRCCOLORKEY))
+glSDL_do_texture (this, 1);
-	{
-		glSDL_blendfunc(this, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+/* Calculate texcoords */
-		glSDL_do_blend(this, 1);
+if (!srcrect)
-	}
+srcrect = &txi->virt;
-	else
+x1 = (float) srcrect->x;
-		glSDL_do_blend(this, 0);
+y1 = (float) srcrect->y;
-	/* Enable texturing */
+/* Calculate screen coords. */
-	glSDL_do_texture(this, 1);
+if (dstrect) {
+d.x = dstrect->x;
-	/* Calculate texcoords */
+d.y = dstrect->y;
-	if(!srcrect)
+d.w = (int) (srcrect->w * (float) txi->lw / (float) txi->virt.w);
-		srcrect = &txi->virt;
+d.h = (int) (srcrect->h * (float) txi->lh / (float) txi->virt.h);
-	x1 = (float)srcrect->x;
+} else {
-	y1 = (float)srcrect->y;
+d.x = 0;
+d.y = 0;
-	/* Calculate screen coords. */
+d.w = (int) (srcrect->w * (float) txi->lw / (float) txi->virt.w);
-	if(dstrect)
+d.h = (int) (srcrect->h * (float) txi->lh / (float) txi->virt.h);
-	{
+}
-		d.x = dstrect->x;
-		d.y = dstrect->y;
+/*
-		d.w = (int)(srcrect->w * (float)txi->lw / (float)txi->virt.w);
+* Note that we actually *prevent* the use of "full surface alpha"
-		d.h = (int)(srcrect->h * (float)txi->lh / (float)txi->virt.h);
+* and alpha channel in combination - to stay SDL 2D compatible.
-	}
+*/
-	else
+if ((src->flags & SDL_SRCALPHA) && (src->format->Amask))
-	{
+alpha = 255;
-		d.x = 0;
+else
-		d.y = 0;
+alpha = src->format->alpha;
-		d.w = (int)(srcrect->w * (float)txi->lw / (float)txi->virt.w);
-		d.h = (int)(srcrect->h * (float)txi->lh / (float)txi->virt.h);
+/* Render! */
-	}
+switch (txi->tilemode) {
+case GLSDL_TM_SINGLE:
-	/*
+glSDL_BlitGL_single (this, txi, x1, y1, &d, alpha);
-	 * Note that we actually *prevent* the use of "full surface alpha"
+break;
-	 * and alpha channel in combination - to stay SDL 2D compatible.
+case GLSDL_TM_HORIZONTAL:
-	 */
+glSDL_BlitGL_htile (this, txi, x1, y1, &d, alpha);
-	if ((src->flags & SDL_SRCALPHA)&&(src->format->Amask))
+break;
-		alpha = 255;
+case GLSDL_TM_VERTICAL:
-	else
+glSDL_BlitGL_vtile (this, txi, x1, y1, &d, alpha);
-		alpha = src->format->alpha;
+break;
+case GLSDL_TM_HUGE:
-	/* Render! */
+glSDL_BlitGL_hvtile (this, src, txi, x1, y1, &d, alpha);
-	switch(txi->tilemode)
+break;
-	{
+}
-		case GLSDL_TM_SINGLE:
-			glSDL_BlitGL_single(this, txi, x1, y1,
+if (txi->temporary)
-					&d,
+glSDL_FreeTexInfo (this, txi);
-					alpha);
-			break;
+return 0;
-		case GLSDL_TM_HORIZONTAL:
+}
-			glSDL_BlitGL_htile(this, txi, x1, y1,
-					&d,
-					alpha);
+static int
-			break;
+glSDL_HWAccelBlit (SDL_Surface * src, SDL_Rect * srcrect,
-		case GLSDL_TM_VERTICAL:
+SDL_Surface * dst, SDL_Rect * dstrect)
-			glSDL_BlitGL_vtile(this, txi, x1, y1,
+{
-					&d,
+SDL_Surface *vs;
-					alpha);
-			break;
+if (!src)
-		case GLSDL_TM_HUGE:
+return GLERET ("HWAccelBlit(): No src surface!");
-			glSDL_BlitGL_hvtile(this, src, txi, x1, y1,
+if (!dst)
-					&d,
+return GLERET ("HWAccelBlit(): No dst surface!");
-					alpha);
-			break;
+/*
-	}
+* Figure out what to do:
+*      screen->screen:         glSDL_BlitFromGL() + glSDL_BlitGL()
-	if(txi->temporary)
+*      surface->screen:        glSDL_BlitGL()
-		glSDL_FreeTexInfo(this, txi);
+*      screen->surface:        glSDL_BlitFromGL()
+*      surface->surface:       glSDL_SoftBlit()
-	return 0;
+*/
-}
+vs = SDL_VideoSurface;
+if (src == vs) {
+if (dst == vs) {
-static int glSDL_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
+/*
-		SDL_Surface *dst, SDL_Rect *dstrect)
+FIXME: Try glCopyPixels() instead...
-{
+*/
-	SDL_Surface *vs;
+glSDL_BlitFromGL (current_video, srcrect, vs, dstrect);
+return glSDL_BlitGL (current_video, vs, srcrect, dstrect);
-	if(!src)
+} else {
-		return GLERET("HWAccelBlit(): No src surface!");
+return glSDL_BlitFromGL (current_video, srcrect, dst, dstrect);
-	if(!dst)
+}
-		return GLERET("HWAccelBlit(): No dst surface!");
+} else {
+if (dst == vs) {
-	/*
+return glSDL_BlitGL (current_video, src, srcrect, dstrect);
-	 * Figure out what to do:
+} else {
-	 *      screen->screen:         glSDL_BlitFromGL() + glSDL_BlitGL()
+glSDL_Invalidate (dst, dstrect);
-	 *      surface->screen:        glSDL_BlitGL()
+glSDL_SoftBlit (src, srcrect, dst, dstrect);
-	 *      screen->surface:        glSDL_BlitFromGL()
+return 0;
-	 *      surface->surface:       glSDL_SoftBlit()
+}
-	 */
+}
-	vs = SDL_VideoSurface;
+}
-	if(src == vs)
-	{
-		if(dst == vs)
+static int
-		{
+glSDL_FillHWRect (_THIS, SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
-			/*
+{
-FIXME: Try glCopyPixels() instead...
+SDL_Surface *vs = SDL_VideoSurface;
-			 */
+int dx1, dy1, dx2, dy2;
-			glSDL_BlitFromGL(current_video, srcrect, vs, dstrect);
+Uint32 r, g, b;
-			return glSDL_BlitGL(current_video, vs,
+Uint8 br, bg, bb;
-					srcrect, dstrect);
-		}
+/*
-		else
+* Some ugly reverse conversion for compatibility...
-		{
+* (We must do this before losing the dst pointer,
-			return glSDL_BlitFromGL(current_video, srcrect,
+* as the pixel formats of the screen and
-					dst, dstrect);
+* SDL_VideoSurface may differ!)
-		}
+*/
-	}
-	else
+if (dst->format->palette) {
-	{
+/* this a paletted color */
-		if(dst == vs)
+SDL_GetRGB (color, dst->format, &br, &bg, &bb);
-		{
+} else {
-			return glSDL_BlitGL(current_video, src,
+/* this a RGB color */
-					srcrect, dstrect);
+r = color & dst->format->Rmask;
-		}
+r = r >> dst->format->Rshift;
-		else
+r = r << dst->format->Rloss;
-		{
+br = r;
-			glSDL_Invalidate(dst, dstrect);
-			glSDL_SoftBlit(src, srcrect, dst, dstrect);
+g = color & dst->format->Gmask;
-			return 0;
+g = g >> dst->format->Gshift;
-		}
+g = g << dst->format->Gloss;
-	}
+bg = g;
-}
+b = color & dst->format->Bmask;
+b = b >> dst->format->Bshift;
-static int glSDL_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
+b = b << dst->format->Bloss;
-{
+bb = b;
-	SDL_Surface *vs = SDL_VideoSurface;
+}
-	int dx1, dy1, dx2, dy2;
-	Uint32 r, g, b;
+if (vs != dst) {
-	Uint8 br,bg,bb;
+/* draw a rect offscreen */
+glSDL_Invalidate (dst, dstrect);
-	/*
+/* software-fill the surface by faking it as a SW_SURFACE */
-	 * Some ugly reverse conversion for compatibility...
+dst->flags &= ~SDL_HWSURFACE;
-	 * (We must do this before losing the dst pointer,
+SDL_FillRect (dst, dstrect, color);
-	 * as the pixel formats of the screen and
+dst->flags |= SDL_HWSURFACE;
-	 * SDL_VideoSurface may differ!)
+} else {
-	 */
+/* draw a rect onscreen */
+glSDL_do_texture (this, 0);
-	if (dst->format->palette)
+glSDL_do_blend (this, 0);
-	{
-		/* this a paletted color */
+dx1 = dstrect->x;
-		SDL_GetRGB(color,dst->format,&br,&bg,&bb);
+dy1 = dstrect->y;
-	}
+dx2 = dx1 + dstrect->w;
-	else
+dy2 = dy1 + dstrect->h;
-	{
-		/* this a RGB color */
+this->glBegin (GL_TRIANGLE_FAN);
-		r = color & dst->format->Rmask;
+this->glColor3ub (br, bg, bb);
-		r = r >> dst->format->Rshift;
+this->glVertex2i (dx1, dy1);
-		r = r << dst->format->Rloss;
+this->glVertex2i (dx2, dy1);
-		br = r;
+this->glVertex2i (dx2, dy2);
+this->glVertex2i (dx1, dy2);
-		g = color & dst->format->Gmask;
+this->glEnd ();
-		g = g >> dst->format->Gshift;
+}
-		g = g << dst->format->Gloss;
+return 0;
-		bg = g;
+}
-		b = color & dst->format->Bmask;
+static int
-		b = b >> dst->format->Bshift;
+glSDL_CheckHWBlit (_THIS, SDL_Surface * src, SDL_Surface * dst)
-		b = b << dst->format->Bloss;
+{
-		bb = b;
+src->flags |= SDL_HWACCEL;
-	}
+src->map->hw_blit = glSDL_HWAccelBlit;
+return 1;
-	if(vs != dst)
+}
-	{
-		/* draw a rect offscreen */
-		glSDL_Invalidate(dst, dstrect);
+static SDL_Surface *
-		/* software-fill the surface by faking it as a SW_SURFACE */
+glSDL_DisplayFormat (SDL_Surface * surface)
-		dst->flags&=~SDL_HWSURFACE;
+{
-		SDL_FillRect(dst,dstrect,color);
+SDL_Surface *tmp;
-		dst->flags|=SDL_HWSURFACE;
+int use_rgba = (surface->flags & SDL_SRCCOLORKEY) ||
-	}
+((surface->flags & SDL_SRCALPHA) && surface->format->Amask);
-	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");
+fprintf (stderr, "#### glSDL_DisplayFormat()\n");
 #endif
-	if(use_rgba)
+if (use_rgba)
-		tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE);
+tmp = glSDL_ConvertSurface (surface, RGBAfmt, SDL_SWSURFACE);
-	else
+else
-		tmp = glSDL_ConvertSurface(surface, RGBfmt, SDL_SWSURFACE);
+tmp = glSDL_ConvertSurface (surface, RGBfmt, SDL_SWSURFACE);
-	if(!tmp)
+if (!tmp) {
-	{
+GLERR ("glSDL_DisplayFormat() could not convert surface!");
-		GLERR("glSDL_DisplayFormat() could not convert surface!");
+return NULL;
-		return NULL;
+}
-	}
+SDL_SetAlpha (tmp, 0, 0);
-	SDL_SetAlpha(tmp, 0, 0);
+if (surface->flags & SDL_SRCCOLORKEY) {
-	if(surface->flags & SDL_SRCCOLORKEY)
+/*
-	{
+* We drop colorkey data here, but we have to,
-		/*
+* or we'll run into trouble when converting,
-		 * We drop colorkey data here, but we have to,
+* in particular from indexed color formats.
-		 * 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, SDL_SRCCOLORKEY,
+SDL_SetColorKey (tmp, 0, 0);
-				surface->format->colorkey);
+}
-		glSDL_key2alpha(tmp);
-		SDL_SetColorKey(tmp, 0, 0);
+return tmp;
-	}
+}
-	return tmp;
-}
+static SDL_Surface *
+glSDL_DisplayFormatAlpha (SDL_Surface * surface)
+{
-static SDL_Surface *glSDL_DisplayFormatAlpha(SDL_Surface *surface)
+SDL_Surface *s, *tmp;
-{
+tmp = glSDL_ConvertSurface (surface, RGBAfmt, SDL_SWSURFACE);
-	SDL_Surface *s, *tmp;
-	tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE);
 #ifdef DEBUG_GLSDL
-	fprintf(stderr,"#### glSDL_DisplayFormatAlpha()\n");
+fprintf (stderr, "#### glSDL_DisplayFormatAlpha()\n");
 #endif
-	if(!tmp)
+if (!tmp)
-		return NULL;
+return NULL;
-	SDL_SetAlpha(tmp, 0, 0);
+SDL_SetAlpha (tmp, 0, 0);
-	SDL_SetColorKey(tmp, 0, 0);
+SDL_SetColorKey (tmp, 0, 0);
-	s = glSDL_CreateRGBASurface(surface->w, surface->h);
+s = glSDL_CreateRGBASurface (surface->w, surface->h);
-	if(!s)
+if (!s) {
-	{
+SDL_FreeSurface (tmp);
-		SDL_FreeSurface(tmp);
+return NULL;
-		return NULL;
+}
-	}
+glSDL_SoftBlit (tmp, NULL, s, NULL);
-	glSDL_SoftBlit(tmp, NULL, s, NULL);
+SDL_FreeSurface (tmp);
-	SDL_FreeSurface(tmp);
+if (surface->flags & SDL_SRCCOLORKEY) {
-	if(surface->flags & SDL_SRCCOLORKEY)
+SDL_SetColorKey (s, SDL_SRCCOLORKEY, surface->format->colorkey);
-	{
+glSDL_key2alpha (s);
-		SDL_SetColorKey(s, SDL_SRCCOLORKEY,
+SDL_SetColorKey (s, 0, 0);
-				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;
-	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)
+static void
-{
+glSDL_Invalidate (SDL_Surface * surface, SDL_Rect * area)
-	private_hwdata *txi;
+{
-	if(!surface)
+private_hwdata *txi;
-		return;
+if (!surface)
-	txi = glSDL_GetTexInfo(surface);
+return;
-	if(!txi)
+txi = glSDL_GetTexInfo (surface);
-		return;
+if (!txi)
-	if(!area)
+return;
-	{
+if (!area) {
-		txi->invalid_area.x = 0;
+txi->invalid_area.x = 0;
-		txi->invalid_area.y = 0;
+txi->invalid_area.y = 0;
-		txi->invalid_area.w = surface->w;
+txi->invalid_area.w = surface->w;
-		txi->invalid_area.h = surface->h;
+txi->invalid_area.h = surface->h;
-		return;
+return;
-	}
+}
-	txi->invalid_area = *area;
+txi->invalid_area = *area;
 }
-static void glSDL_SetLogicSize(_THIS, SDL_Surface *surface, int w, int h)
+static void
-{
+glSDL_SetLogicSize (_THIS, SDL_Surface * surface, int w, int h)
-	SDL_Rect r;
+{
-	private_hwdata *txi;
+SDL_Rect r;
-	if(!IS_GLSDL_SURFACE(surface))
+private_hwdata *txi;
-		return;
+if (!IS_GLSDL_SURFACE (surface))
+return;
-	txi = glSDL_GetTexInfo(surface);
+txi = glSDL_GetTexInfo (surface);
-	txi->lw = w;
-	txi->lh = h;
+txi->lw = w;
+txi->lh = h;
-	if(SDL_VideoSurface != surface)
-		return;
+if (SDL_VideoSurface != surface)
+return;
-	r.x = r.y = 0;
-	r.w = w;
+r.x = r.y = 0;
-	r.h = h;
+r.w = w;
-	glSDL_SetClipRect(this, surface, &r);
+r.h = h;
+glSDL_SetClipRect (this, surface, &r);
-	this->glMatrixMode(GL_MODELVIEW);
-	this->glLoadIdentity();
+this->glMatrixMode (GL_MODELVIEW);
-	this->glTranslated(0.0f, 0.0f, 0.0f);
+this->glLoadIdentity ();
+this->glTranslated (0.0f, 0.0f, 0.0f);
-	this->glDisable(GL_DEPTH_TEST);
-	this->glDisable(GL_CULL_FACE);
+this->glDisable (GL_DEPTH_TEST);
+this->glDisable (GL_CULL_FACE);
-	glSDL_reset();
-}
+glSDL_reset ();
+}
-static int glSDL_InitTexture(_THIS, SDL_Surface *datasurf, private_hwdata *txi, int tex)
-{
+static int
-	this->glGenTextures(1, (GLuint *)&txi->texture[tex]);
+glSDL_InitTexture (_THIS, SDL_Surface * datasurf, private_hwdata * txi,
-	this->glBindTexture(GL_TEXTURE_2D, txi->texture[tex]);
+int tex)
-	glstate.texture = txi->texture[tex];
+{
-	this->glPixelStorei(GL_UNPACK_ROW_LENGTH, datasurf->pitch /
+this->glGenTextures (1, (GLuint *) & txi->texture[tex]);
-			datasurf->format->BytesPerPixel);
+this->glBindTexture (GL_TEXTURE_2D, txi->texture[tex]);
-	this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+glstate.texture = txi->texture[tex];
-	this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+this->glPixelStorei (GL_UNPACK_ROW_LENGTH, datasurf->pitch /
-	this->glTexImage2D(GL_TEXTURE_2D, 0,
+datasurf->format->BytesPerPixel);
-			datasurf->format->Amask ? GL_RGBA8 : GL_RGB8,
+this->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-			txi->texsize, txi->texsize, 0,
+this->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-			datasurf->format->Amask ? GL_RGBA : GL_RGB,
+this->glTexImage2D (GL_TEXTURE_2D, 0,
-			GL_UNSIGNED_BYTE, NULL);
+datasurf->format->Amask ? GL_RGBA8 : GL_RGB8,
-#ifdef DEBUG_GLSDL
+txi->texsize, txi->texsize, 0,
-	glSDL_print_glerror(this, 1);
+datasurf->format->Amask ? GL_RGBA : GL_RGB,
-#endif
+GL_UNSIGNED_BYTE, NULL);
-	return 0;
+#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)
+static int
-{
+glSDL_UploadHoriz (_THIS, SDL_Surface * datasurf, private_hwdata * txi)
-	int bpp = datasurf->format->BytesPerPixel;
+{
-	int res;
+int bpp = datasurf->format->BytesPerPixel;
-	int tex = 0;
+int res;
-	int fromx = 0;
+int tex = 0;
-	int toy = txi->texsize;	/* To init first texture */
+int fromx = 0;
-	while(1)
+int toy = txi->texsize;     /* To init first texture */
-	{
+while (1) {
-		int thistw = datasurf->w - fromx;
+int thistw = datasurf->w - fromx;
-		if(thistw > txi->tilew)
+if (thistw > txi->tilew)
-			thistw = txi->tilew;
+thistw = txi->tilew;
-		else if(thistw <= 0)
+else if (thistw <= 0)
-			break;
+break;
-		if(toy + txi->tileh > txi->texsize)
+if (toy + txi->tileh > txi->texsize) {
-		{
+toy = 0;
-			toy = 0;
+res = glSDL_InitTexture (this, datasurf, txi, tex);
-			res = glSDL_InitTexture(this, datasurf, txi, tex);
+if (res < 0)
-			if(res < 0)
+return res;
-				return res;
+++tex;
-			++tex;
+}
-		}
+this->glTexSubImage2D (GL_TEXTURE_2D, 0, 0, toy,
-		this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, toy,
+thistw, txi->tileh,
-				thistw, txi->tileh,
+datasurf->format->Amask ? GL_RGBA : GL_RGB,
-				datasurf->format->Amask ? GL_RGBA : GL_RGB,
+GL_UNSIGNED_BYTE,
-				GL_UNSIGNED_BYTE,
+(char *) datasurf->pixels + bpp * fromx);
-				(char *)datasurf->pixels + bpp * fromx);
+#ifdef DEBUG_GLSDL
-#ifdef DEBUG_GLSDL
+glSDL_print_glerror (this, 2);
-		glSDL_print_glerror(this, 2);
+#endif
-#endif
+fromx += txi->tilew;
-		fromx += txi->tilew;
+toy += txi->tileh;
-		toy += txi->tileh;
+}
-	}
+return 0;
-	return 0;
 }
 /* Image tiled vertically (tall surface) */
-static int glSDL_UploadVert(_THIS, SDL_Surface *datasurf, private_hwdata *txi)
+static int
-{
+glSDL_UploadVert (_THIS, SDL_Surface * datasurf, private_hwdata * txi)
-	int res;
+{
-	int tex = 0;
+int res;
-	int fromy = 0;
+int tex = 0;
-	int tox = txi->texsize;	/* To init first texture */
+int fromy = 0;
-	while(1)
+int tox = txi->texsize;     /* To init first texture */
-	{
+while (1) {
-		int thisth = datasurf->h - fromy;
+int thisth = datasurf->h - fromy;
-		if(thisth > txi->tileh)
+if (thisth > txi->tileh)
-			thisth = txi->tileh;
+thisth = txi->tileh;
-		else if(thisth <= 0)
+else if (thisth <= 0)
-			break;
+break;
-		if(tox + txi->tilew > txi->texsize)
+if (tox + txi->tilew > txi->texsize) {
-		{
+tox = 0;
-			tox = 0;
+res = glSDL_InitTexture (this, datasurf, txi, tex);
-			res = glSDL_InitTexture(this, datasurf, txi, tex);
+if (res < 0)
-			if(res < 0)
+return res;
-				return res;
+++tex;
-			++tex;
+}
-		}
+this->glTexSubImage2D (GL_TEXTURE_2D, 0, tox, 0,
-		this->glTexSubImage2D(GL_TEXTURE_2D, 0, tox, 0,
+txi->tilew, thisth,
-				txi->tilew, thisth,
+datasurf->format->Amask ? GL_RGBA : GL_RGB,
-				datasurf->format->Amask ? GL_RGBA : GL_RGB,
+GL_UNSIGNED_BYTE,
-				GL_UNSIGNED_BYTE,
+(char *) datasurf->pixels +
-				(char *)datasurf->pixels + datasurf->pitch * fromy);
+datasurf->pitch * fromy);
 #ifdef DEBUG_GLSDL
-		glSDL_print_glerror(this, 3);
+glSDL_print_glerror (this, 3);
 #endif
-		fromy += txi->tileh;
+fromy += txi->tileh;
-		tox += txi->tilew;
+tox += txi->tilew;
-	}
+}
-	return 0;
+return 0;
 }
 /* Image tiled two-way (huge surface) */
-static int glSDL_UploadHuge(_THIS, SDL_Surface *datasurf, private_hwdata *txi)
+static int
-{
+glSDL_UploadHuge (_THIS, SDL_Surface * datasurf, private_hwdata * txi)
-	int bpp = datasurf->format->BytesPerPixel;
+{
-	int res;
+int bpp = datasurf->format->BytesPerPixel;
-	int tex = 0;
+int res;
-	int y = 0;
+int tex = 0;
-	while(y < datasurf->h)
+int y = 0;
-	{
+while (y < datasurf->h) {
-		int x;
+int x;
-		int thisth = datasurf->h - y;
+int thisth = datasurf->h - y;
-		if(thisth > txi->tileh)
+if (thisth > txi->tileh)
-			thisth = txi->tileh;
+thisth = txi->tileh;
-		x = 0;
+x = 0;
-		while(x < datasurf->w)
+while (x < datasurf->w) {
-		{
+int thistw = datasurf->w - x;
-			int thistw = datasurf->w - x;
+if (thistw > txi->tilew)
-			if(thistw > txi->tilew)
+thistw = txi->tilew;
-				thistw = txi->tilew;
+res = glSDL_InitTexture (this, datasurf, txi, tex++);
-			res = glSDL_InitTexture(this, datasurf, txi, tex++);
+if (res < 0)
-			if(res < 0)
+return res;
-				return res;
+this->glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
-			this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
+thistw, thisth,
-					thistw, thisth,
+datasurf->format->
-					datasurf->format->Amask ? GL_RGBA : GL_RGB,
+Amask ? GL_RGBA : GL_RGB,
-					GL_UNSIGNED_BYTE,
+GL_UNSIGNED_BYTE,
-					(char *)datasurf->pixels +
+(char *) datasurf->pixels +
-					datasurf->pitch * y + bpp * x);
+datasurf->pitch * y + bpp * x);
 #ifdef DEBUG_GLSDL
-			fprintf(stderr,"glTexSubImage(x = %d, y = %d, w = %d, h = %d)\n",
+fprintf (stderr,
-					x, y, thistw, thisth);
+"glTexSubImage(x = %d, y = %d, w = %d, h = %d)\n", x,
-			glSDL_print_glerror(this, 4);
+y, thistw, thisth);
-#endif
+glSDL_print_glerror (this, 4);
-			x += txi->tilew;
+#endif
-		}
+x += txi->tilew;
-		y += txi->tileh;
+}
-	}
+y += txi->tileh;
-	return 0;
+}
+return 0;
 }
 /* Upload all textures for a surface. */
-static int glSDL_UploadTextures(_THIS, SDL_Surface *datasurf, private_hwdata *txi)
+static int
-{
+glSDL_UploadTextures (_THIS, SDL_Surface * datasurf, private_hwdata * txi)
-	switch(txi->tilemode)
+{
-	{
+switch (txi->tilemode) {
-	  case GLSDL_TM_SINGLE:
+case GLSDL_TM_SINGLE:
-	  case GLSDL_TM_HORIZONTAL:
+case GLSDL_TM_HORIZONTAL:
-		glSDL_UploadHoriz(this, datasurf, txi);
+glSDL_UploadHoriz (this, datasurf, txi);
-		break;
+break;
-	  case GLSDL_TM_VERTICAL:
+case GLSDL_TM_VERTICAL:
-		glSDL_UploadVert(this, datasurf, txi);
+glSDL_UploadVert (this, datasurf, txi);
-		break;
+break;
-	  case GLSDL_TM_HUGE:
+case GLSDL_TM_HUGE:
-		glSDL_UploadHuge(this, datasurf, txi);
+glSDL_UploadHuge (this, datasurf, txi);
-		break;
+break;
-	}
+}
-	return 0;
+return 0;
 }
 /*
 * IMPORTANT:
 *	(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)
+static private_hwdata *
-{
+glSDL_UploadSurface (_THIS, SDL_Surface * surface)
-	int i;
+{
-	int converted = 0;
+int i;
-	private_hwdata *txi = glSDL_GetTexInfo(surface);
+int converted = 0;
+private_hwdata *txi = glSDL_GetTexInfo (surface);
-	if(IS_GLSDL_SURFACE(surface))
-	{
+if (IS_GLSDL_SURFACE (surface)) {
-		/*
+/*
-		 * Ok, this is a glSDL surface, and it *might* be
+* Ok, this is a glSDL surface, and it *might* be
-		 * in texture memory already. If so, it may need
+* in texture memory already. If so, it may need
-		 * an update.
+* an update.
-		 */
+*/
-		if(txi->invalid_area.w)
+if (txi->invalid_area.w) {
-		{
+glSDL_UnloadTexture (this, txi);
-			glSDL_UnloadTexture(this, txi);
+} else {
-		}
+int missing = 0;
-		else
+if (txi->textures) {
-		{
+for (i = 0; i < txi->textures; ++i)
-			int missing = 0;
+if (GLSDL_NOTEX == txi->texture[i]) {
-			if(txi->textures)
+missing = 1;
-			{
+break;
-				for(i = 0; i < txi->textures; ++i)
+}
-					if(GLSDL_NOTEX == txi->texture[i])
+if (!missing)
-					{
+return txi; /* They're already there! */
-						missing = 1;
+}
-						break;
+}
-					}
+} else {
-				if(!missing)
+/*
-					return txi;	/* They're already there! */
+* 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.
-	}
+*/
-	else
+if ((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
-	{
+txi = glSDL_AddTexInfo (this, surface);
-		/*
+if (!txi) {
-		 * Nope, this isn't (yet) a glSDL surface. Let's
+GLERR ("UploadSurface(): Could not add TexInfo!");
-		 * try to either make it one, or set up a temporary
+return NULL;
-		 * TexInfo for it, valid for only one blit.
+}
-		 */
+surface->flags |= SDL_HWSURFACE;
-		if( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE )
+surface->flags |= SDL_HWACCEL;
-		{
+} else {
-			txi = glSDL_AddTexInfo(this, surface);
+/*
-			if(!txi)
+* FIXME
-			{
+* here if the surface is small enough, it's a good
-				GLERR("UploadSurface(): Could not add TexInfo!");
+* candidate for a blit using glDrawPixels instead
-				return NULL;
+* of a texture blit
-			}
+*/
-			surface->flags |= SDL_HWSURFACE;
+txi = glSDL_CreateTempTexInfo (this, surface);
-			surface->flags |= SDL_HWACCEL;
+if (!txi) {
-		}
+GLERR ("UploadSurface(): Could not create temp TexInfo!");
-		else
+return NULL;
-		{
+}
-			/*
+}
-			 * FIXME
+}
-			 * here if the surface is small enough, it's a good
-			 * candidate for a blit using glDrawPixels instead
+if (txi->texsize > maxtexsize) {
-			 * of a texture blit
+/* This surface wasn't tiled properly... */
-			 */
+if (txi->temporary)
-			txi = glSDL_CreateTempTexInfo(this, surface);
+glSDL_FreeTexInfo (this, txi);
-			if(!txi)
+GLERR ("UploadSurface(): Too large texture!");
-			{
+return NULL;
-				GLERR("UploadSurface(): Could not create temp TexInfo!");
+}
-				return NULL;
-			}
+/*
-		}
+* Kludge: Convert if not of preferred RGB or RGBA format.
-	}
+*
+*      Conversion should only be done when *really* needed.
-	if(txi->texsize > maxtexsize)
+*      That is, it should rarely have to be done with OpenGL
-	{
+*      1.2+.
-		/* This surface wasn't tiled properly... */
+*
-		if(txi->temporary)
+*      Besides, any surface that's been SDL_DisplayFormat()ed
-			glSDL_FreeTexInfo(this, txi);
+*      should already be in the best known OpenGL format -
-		GLERR("UploadSurface(): Too large texture!");
+*      preferably one that makes DMA w/o conversion possible.
-		return NULL;
+*/
-	}
+if (!glSDL_FormatIsOk (surface)) {
+#ifdef DEBUG_GLSDL
-	/*
+fprintf (stderr,
-	 * Kludge: Convert if not of preferred RGB or RGBA format.
+"glSDL: WARNING: On-the-fly conversion performed!\n");
-	 *
+#endif
-	 *	Conversion should only be done when *really* needed.
+converted = 1;
-	 *	That is, it should rarely have to be done with OpenGL
+/* NOTE: We forget about the original surface here. */
-	 *	1.2+.
+if (surface->format->Amask)
-	 *
+surface = glSDL_DisplayFormatAlpha (surface);
-	 *	Besides, any surface that's been SDL_DisplayFormat()ed
+else
-	 *	should already be in the best known OpenGL format -
+surface = glSDL_DisplayFormat (surface);
-	 *	preferably one that makes DMA w/o conversion possible.
+if (!surface) {
-	 */
+GLERR ("UploadSurface(): Could not convert surface!");
-	if(!glSDL_FormatIsOk(surface))
+if (txi->temporary)
-	{
+glSDL_FreeTexInfo (this, txi);
-#ifdef DEBUG_GLSDL
+return NULL;
-		fprintf(stderr, "glSDL: WARNING: On-the-fly conversion performed!\n");
+}
-#endif
+}
-		converted = 1;
-		/* NOTE: We forget about the original surface here. */
+glSDL_UploadTextures (this, surface, txi);
-		if(surface->format->Amask)
-			surface = glSDL_DisplayFormatAlpha(surface);
+if (converted)
-		else
+SDL_FreeSurface (surface);
-			surface = glSDL_DisplayFormat(surface);
-		if(!surface)
+return txi;
-		{
+}
-			GLERR("UploadSurface(): Could not convert surface!");
-			if(txi->temporary)
-				glSDL_FreeTexInfo(this, txi);
+static void
-			return NULL;
+glSDL_UnloadTexture (_THIS, private_hwdata * txi)
-		}
+{
-	}
+int i;
+for (i = 0; i < txi->textures; ++i)
-	glSDL_UploadTextures(this, surface, txi);
+if (txi->texture[i] != GLSDL_NOTEX)
+this->glDeleteTextures (1, &txi->texture[i]);
-	if(converted)
+SDL_memset (&txi->invalid_area, 0, sizeof (txi->invalid_area));
-		SDL_FreeSurface(surface);
+}
-	return txi;
+/* vi: set ts=4 sw=4 expandtab: */
-}
-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));
-}

Mercurial > sdl-ios-xcode

comparison src/video/glsdl/SDL_glsdl.c @ 1662:782fd950bd46 SDL-1.3