/*

SDL - Simple DirectMedia Layer

Copyright (C) 1997-2006 Sam Lantinga

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

*/

#include "SDL_config.h"

/*

* glSDL "SDL-over-OpenGL" video driver implemented by

* David Olofson <david@olofson.net> and

* Stephane Marchesin <stephane.marchesin@wanadoo.fr>

*/

#include <math.h>

#include "SDL.h"

#include "SDL_error.h"

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "../SDL_sysvideo.h"

#include "../SDL_pixels_c.h"

#include "SDL_glsdl.h"

#undef DEBUG_GLSDL

#undef DEBUG_GLSDL_CHOP

#define FAKE_MAXTEXSIZE 256

#undef GLSDL_GRAPHICAL_DEBUG

/* Initialization/Query functions */

/* Hardware surface functions */

static int glSDL_SetColors (_THIS, int firstcolor, int ncolors,

SDL_Color * colors);

static int glSDL_AllocHWSurface (_THIS, SDL_Surface * surface);

static int glSDL_LockHWSurface (_THIS, SDL_Surface * surface);

static int glSDL_FlipHWSurface (_THIS, SDL_Surface * surface);

static void glSDL_UnlockHWSurface (_THIS, SDL_Surface * surface);

static void glSDL_FreeHWSurface (_THIS, SDL_Surface * surface);

static int glSDL_FillHWRect (_THIS, SDL_Surface * dst, SDL_Rect * rect,

Uint32 color);

static int glSDL_CheckHWBlit (_THIS, SDL_Surface * src, SDL_Surface * dst);

static int glSDL_SetHWColorKey (_THIS, SDL_Surface * surface, Uint32 key);

static int glSDL_SetHWAlpha (_THIS, SDL_Surface * surface, Uint8 alpha);

static int glSDL_VideoInit (_THIS, SDL_PixelFormat * vformat);

static SDL_Rect **glSDL_ListModes (_THIS, SDL_PixelFormat * format,

Uint32 flags);

static void glSDL_VideoQuit (_THIS);

static void glSDL_UpdateRects (_THIS, int numrects, SDL_Rect * rects);

static SDL_Surface *glSDL_SetVideoMode (_THIS, SDL_Surface * current,

int width, int height, int bpp,

Uint32 flags);

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

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

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

#define GLSDL_NOTEX (~0)

/*

* Special version for glSDL, which ignores the fake SDL_HWSURFACE

* flags, so we don't have SDL calling us back whenever we want to

* do some internal blitting...

*/

static void

glSDL_SoftBlit (SDL_Surface * src, SDL_Rect * srcrect,

SDL_Surface * dst, SDL_Rect * dstrect)

SDL_BlitInfo info;

if (srcrect)

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

return;

/* Check to make sure the blit mapping is valid */

if ((src->map->dst != dst) ||

(src->map->dst->format_version != src->map->format_version))

if (SDL_MapSurface (src, dst) < 0)

return;

/* Set up the blit information */

if (srcrect) {

info.s_pixels = (Uint8 *) src->pixels +

(Uint16) srcrect->y * src->pitch +

(Uint16) srcrect->x * src->format->BytesPerPixel;

info.s_width = srcrect->w;

info.s_height = srcrect->h;

} else {

info.s_pixels = (Uint8 *) src->pixels;

info.s_width = src->w;

info.s_height = src->h;

}

info.s_skip = src->pitch - info.s_width * src->format->BytesPerPixel;

if (dstrect) {

info.d_pixels = (Uint8 *) dst->pixels +

(Uint16) dstrect->y * dst->pitch +

(Uint16) dstrect->x * dst->format->BytesPerPixel;

/*

* NOTE: SDL_SoftBlit() uses the 'dstrect' for this!

* This version is more like SDL_BlitSurface().

*/

info.d_width = srcrect->w;

info.d_height = srcrect->h;

} else {

info.d_pixels = (Uint8 *) dst->pixels;

info.d_width = dst->w;

info.d_height = dst->h;

}

info.d_skip = dst->pitch - info.d_width * dst->format->BytesPerPixel;

info.aux_data = src->map->sw_data->aux_data;

info.src = src->format;

info.table = src->map->table;

info.dst = dst->format;

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

}

/*

* Another special version. Doesn't lock/unlock, and doesn't mess

* with flags and stuff. It just converts the surface, period.

* Does not convert into palletized formats.

*/

static SDL_Surface *

glSDL_ConvertSurface (SDL_Surface * surface,

SDL_PixelFormat * format, Uint32 flags)

SDL_Surface *convert;

Uint32 colorkey = 0;

Uint8 alpha = 0;

Uint32 surface_flags;

SDL_Rect bounds;

/* Create a new surface with the desired format */

convert = SDL_CreateRGBSurface (flags,

surface->w, surface->h,

format->BitsPerPixel, format->Rmask,

format->Gmask, format->Bmask,

format->Amask);

if (convert == NULL) {

return (NULL);

}

/* Save the original surface color key and alpha */

surface_flags = surface->flags;

if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {

/* Convert colourkeyed surfaces to RGBA if requested */

if ((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY && format->Amask) {

surface_flags &= ~SDL_SRCCOLORKEY;

} else {

colorkey = surface->format->colorkey;

SDL_SetColorKey (surface, 0, 0);

}

}

if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {

/* Copy over the alpha channel to RGBA if requested */

if (format->Amask) {

surface->flags &= ~SDL_SRCALPHA;

} else {

alpha = surface->format->alpha;

SDL_SetAlpha (surface, 0, 0);

}

}

/* Copy over the image data */

bounds.x = 0;

bounds.y = 0;

bounds.w = surface->w;

bounds.h = surface->h;

glSDL_SoftBlit (surface, &bounds, convert, &bounds);

/* Clean up the original surface, and update converted surface */

if (convert != NULL) {

SDL_SetClipRect (convert, &surface->clip_rect);

}

if ((surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {

Uint32 cflags = surface_flags & (SDL_SRCCOLORKEY | SDL_RLEACCELOK);

if (convert != NULL) {

Uint8 keyR, keyG, keyB;

SDL_GetRGB (colorkey, surface->format, &keyR, &keyG, &keyB);

SDL_SetColorKey (convert, cflags | (flags & SDL_RLEACCELOK),

SDL_MapRGB (convert->format, keyR, keyG, keyB));

}

SDL_SetColorKey (surface, cflags, colorkey);

}

if ((surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA) {

Uint32 aflags = surface_flags & (SDL_SRCALPHA | SDL_RLEACCELOK);

if (convert != NULL) {

SDL_SetAlpha (convert, aflags | (flags & SDL_RLEACCELOK), alpha);

}

if (format->Amask) {

surface->flags |= SDL_SRCALPHA;

} else {

SDL_SetAlpha (surface, aflags, alpha);

}

}

/* We're ready to go! */

return (convert);

}

/*----------------------------------------------------------

Some OpenGL function wrappers

----------------------------------------------------------*/

static struct

{

int do_blend;

int do_texture;

GLuint texture;

GLenum sfactor, dfactor;

} glstate;

static void

glSDL_reset (void)

glstate.do_blend = -1;

glstate.do_blend = -1;

glstate.texture = GLSDL_NOTEX;

glstate.sfactor = 0xffffffff;

glstate.dfactor = 0xffffffff;

}

static __inline__ void

glSDL_do_blend (_THIS, int on)

if (glstate.do_blend == on)

return;

if (on)

this->glEnable (GL_BLEND);

else

this->glDisable (GL_BLEND);

glstate.do_blend = on;

}

static __inline__ void

glSDL_do_texture (_THIS, int on)

if (glstate.do_texture == on)

return;

if (on)

this->glEnable (GL_TEXTURE_2D);

else

this->glDisable (GL_TEXTURE_2D);

glstate.do_texture = on;

}

static __inline__ void

glSDL_blendfunc (_THIS, GLenum sfactor, GLenum dfactor)

if ((sfactor == glstate.sfactor) && (dfactor == glstate.dfactor))

return;

glstate.sfactor = sfactor;

glstate.dfactor = dfactor;

}

static __inline__ void

glSDL_texture (_THIS, GLuint tx)

if (tx == glstate.texture)

return;

this->glBindTexture (GL_TEXTURE_2D, tx);

glstate.texture = tx;

}

/*----------------------------------------------------------

glSDL specific data types

----------------------------------------------------------*/

typedef enum

{

GLSDL_TM_SINGLE,

GLSDL_TM_HORIZONTAL,

GLSDL_TM_VERTICAL,

GLSDL_TM_HUGE

} GLSDL_TileModes;

typedef struct private_hwdata

{

/* Size of surface in logic screen pixels */

int lw, lh;

int textures;

GLuint *texture;

int texsize; /* width/height of OpenGL texture */

GLSDL_TileModes tilemode;

int tilew, tileh; /* At least one must equal texsize! */

int tilespertex;

SDL_Rect virt; /* Total size of assembled surface */

/* Area of surface to upload when/after unlocking */

SDL_Rect invalid_area;

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

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

} private_hwdata;

/* some function prototypes */

static void glSDL_Invalidate (SDL_Surface * surface, SDL_Rect * area);

static void glSDL_SetLogicSize (_THIS, SDL_Surface * surface, int w, int h);

static private_hwdata *glSDL_UploadSurface (_THIS, SDL_Surface * surface);

static private_hwdata *glSDL_GetTexInfo (SDL_Surface * surface);

static void glSDL_init_formats (_THIS);

static private_hwdata *glSDL_AddTexInfo (_THIS, SDL_Surface * surface);

static void glSDL_RemoveTexInfo (_THIS, SDL_Surface * surface);

static void glSDL_UnloadTexture (_THIS, private_hwdata * txi);

static int glSDL_BlitGL (_THIS, SDL_Surface * src,

SDL_Rect * srcrect, SDL_Rect * dstrect);

/* some variables */

static GLint maxtexsize = -1;

static SDL_PixelFormat *RGBfmt = NULL;

static SDL_PixelFormat *RGBAfmt = NULL;

static void *mirrorbuf = NULL;

/* the raw 888 opengl surface, hidden from the application */

/* pointer to the beggining of the list used for memory allocation */

#ifdef DEBUG_GLSDL

static __inline__ int

GLERET (const char *txt)

fprintf (stderr, "glSDL ERROR: '%s'\n", txt);

return -1;

static __inline__ void

GLERR (const char *txt)

}

#else

#define GLERET(x) (-1)

#define GLERR(x)

#endif

static SDL_VideoDevice underlying_device;

static int old_screen_flags;

/*

* List of video drivers known to support OpenGL

* The purpose of this is to make glSDL "portable" across

* all video backends that support OpenGL

*/

static VideoBootStrap *opengl_bootstrap =

#if SDL_VIDEO_DRIVER_QUARTZ

#endif

static int

glSDL_Available (void)

{

#ifdef DEBUG_GLSDL

if (opengl_bootstrap == NULL)

return 0;

return (opengl_bootstrap->available ());

}

static void

glSDL_DeleteDevice (SDL_VideoDevice * device)

SDL_free (device->hidden);

SDL_free (device);

}

/* Create a glSDL device */

static SDL_VideoDevice *

glSDL_CreateDevice (int devindex)

#endif

/* Create the device with the underlying driver */

device = opengl_bootstrap->create (devindex);

/* Save the video device contents for future use */

SDL_memcpy (&underlying_device, device, sizeof (SDL_VideoDevice));

/* Hook glSDL on the video device */

device->VideoInit = glSDL_VideoInit;

device->ListModes = glSDL_ListModes;

device->VideoQuit = glSDL_VideoQuit;

device->UpdateRects = glSDL_UpdateRects;

device->FillHWRect = glSDL_FillHWRect;

device->SetHWColorKey = glSDL_SetHWColorKey;

device->SetHWAlpha = glSDL_SetHWAlpha;

device->AllocHWSurface = glSDL_AllocHWSurface;

device->LockHWSurface = glSDL_LockHWSurface;

device->UnlockHWSurface = glSDL_UnlockHWSurface;

device->FlipHWSurface = glSDL_FlipHWSurface;

device->FreeHWSurface = glSDL_FreeHWSurface;

device->CheckHWBlit = glSDL_CheckHWBlit;

device->SetColors = glSDL_SetColors;

device->SetVideoMode = glSDL_SetVideoMode;

device->info.hw_available = 1;

device->info.blit_hw = 1;

device->info.blit_hw_CC = 1;

device->info.blit_hw_A = 1;

device->info.blit_sw = 1;

device->info.blit_sw_CC = 1;

device->info.blit_sw_A = 1;

device->info.blit_fill = 1;

/* These functions are not supported by glSDL, so we NULLify them */

device->SetGamma = NULL;

device->GetGamma = NULL;

device->SetGammaRamp = NULL;

device->GetGammaRamp = NULL;

device->ToggleFullScreen = NULL;

device->free = glSDL_DeleteDevice;

#ifdef DEBUG_GLSDL

#endif

}

/* Our bootstraping structure */

VideoBootStrap glSDL_bootstrap = {

"glSDL", "glSDL - SDL over OpenGL",

glSDL_Available, glSDL_CreateDevice

};

static int

glSDL_VideoInit (_THIS, SDL_PixelFormat * vformat)

int r;

printf ("glSDL videoinit\n");

r = underlying_device.VideoInit (this, vformat);

this->info.hw_available = 1;

this->info.blit_hw = 1;

this->info.blit_hw_CC = 1;

this->info.blit_hw_A = 1;

this->info.blit_sw = 1;

this->info.blit_sw_CC = 1;

this->info.blit_sw_A = 1;

this->info.blit_fill = 1;

return r;

}

SDL_Rect **

glSDL_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags)

}

static void

glSDL_VideoQuit (_THIS)

SDL_Surface *scr;

/* free all hwdata structures */

while (first != NULL)

glSDL_RemoveTexInfo (this, first);

SDL_free (mirrorbuf);

mirrorbuf = NULL;

SDL_FreeFormat (RGBfmt);

SDL_FreeFormat (RGBAfmt);

RGBfmt = RGBAfmt = NULL;

SDL_FreeFormat (this->displayformatalphapixel);

this->displayformatalphapixel = NULL;

SDL_FreeSurface (OpenGL_Surface);

OpenGL_Surface = NULL;

/* restore the flags to gracefully exit from fullscreen */

this->screen->flags = old_screen_flags;

/* keep the screen */

scr = this->screen;

/* we cleaned up our stuff, now restore the underlying video driver */

SDL_memcpy (this, &underlying_device, sizeof (SDL_VideoDevice));

this->screen = scr;

/* call the underlying video driver's VideoQuit function */

this->VideoQuit (this);

}

static SDL_Surface *

glSDL_SetVideoMode (_THIS, SDL_Surface * current, int width, int height,

int bpp, Uint32 flags)

SDL_Surface *hooked_screen;

int i;

int flag_doublebuf = 0;

if (opengl_bootstrap == NULL) {

GLERR ("No bootstrap for glSDL compiled in !\n");

return NULL;

}

/* we don't have OpenGL */

if ((flags & SDL_INTERNALOPENGL) == SDL_INTERNALOPENGL) {

GLERR ("OpenGL video modes are not supported by glSDL !\n");

return (NULL);

}

/*

* Adjust the flags

*/

flags &= ~SDL_HWPALETTE;

flags |= SDL_INTERNALOPENGL;

/* remember whether the user requested DOUBLEBUF */

if (flags & SDL_DOUBLEBUF) {

SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);

flag_doublebuf = 1;

} else {

SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 0);

flag_doublebuf = 0;

}

hooked_screen =

underlying_device.SetVideoMode (this, current, width, height, 0,

flags);

if (!hooked_screen) {

GLERR ("Unable to open an OpenGL window !\n");

return (NULL);

}

/* save the screen flags for restore time */

old_screen_flags = hooked_screen->flags;

#ifdef DEBUG_GLSDL

#endif

/* setup the public surface format

* glSDL always returns the bpp its asked

*/

switch (bpp) {

case 32:

this->is_32bit = 1;

this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,

0x00FF0000,

0x0000FF00,

0x000000FF, 0x00000000

0x0000FF00,

0x00FF0000,

0xFF000000, 0x00000000

);

break;

case 24:

this->is_32bit = 0;

this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,

0x00FF0000,

0x0000FF00,

0x000000FF, 0x00000000

0x0000FF00,

0x00FF0000,

0xFF000000, 0x00000000

);

break;

case 16:

this->is_32bit = 0;

this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,

0x0000F800,

0x000007E0,

0x0000001F, 0x00000000

0x0000001F,

0x000007E0,

0x0000F800, 0x00000000

);

break;

case 15:

this->is_32bit = 0;

this->screen = SDL_CreateRGBSurface (flags, width, height, bpp,

0x00007C00,

0x000003E0,

0x0000001F, 0x00000000

0x0000001F,

0x000003E0,

0x00007C00, 0x00000000

);

break;

case 8:

default:

this->is_32bit = 0;

this->screen =

SDL_CreateRGBSurface (flags, width, height, bpp, 0, 0, 0, 0);

/* give it a default palette if 8 bpp

* note : SDL already takes care of the palette for 4 bits & 1 bit surfaces

*/

/* if (bpp==8)

{

this->screen->format->palette->ncolors=255;

SDL_DitherColors(this->screen->format->palette->colors,bpp);

}*/

break;

}

/* also, we add SDL_HWSURFACE all the time, and let SDL create a shadow surface accordingly */

this->screen->flags =

hooked_screen->flags | SDL_HWSURFACE | SDL_INTERNALOPENGL;

/* add SDL_DOUBLEBUF if it was requested */

if (flag_doublebuf)

this->screen->flags |= SDL_DOUBLEBUF;

/* Tell SDL the alpha pixel format we'd like to have */

this->displayformatalphapixel = SDL_AllocFormat (32,

0xFF000000,

0x00FF0000,

0x0000FF00, 0x000000FF

0x000000FF,

0x0000FF00,

0x00FF0000, 0xFF000000

/* Now create the raw OpenGL surface */

OpenGL_Surface = SDL_CreateRGBSurface (flags, width, height, 24,

0x000000FF,

0x0000FF00, 0x00FF0000, 0x00000000

0xFF000000,

0x00FF0000, 0x0000FF00, 0x00000000

#ifndef __QNXNTO__

#define SDL_PROC(ret,func,params) \

do { \

this->func = SDL_GL_GetProcAddress(#func); \

if ( ! this->func ) { \

SDL_SetError("Couldn't load GL function: %s\n", #func); \

return(NULL); \

} \

} while ( 0 );

#else

#define SDL_PROC(ret,func,params) this->func=func;

#endif /* __QNXNTO__ */

#include "../SDL_glfuncs.h"

if (this->GL_MakeCurrent (this) < 0)

return (NULL);

#define SDL_PROC(ret,func,params) \

do { \

this->func = SDL_GL_GetProcAddress(#func); \

if ( ! this->func ) { \

SDL_SetError("Couldn't load GL function: %s\n", #func); \

return(NULL); \

} \

} while ( 0 );

#include "../SDL_glfuncs.h"

#ifdef FAKE_MAXTEXSIZE

#endif

#ifdef DEBUG_GLSDL

#endif

glSDL_init_formats (this);

if (flag_doublebuf)

this->glDrawBuffer (GL_BACK);

else

this->glDrawBuffer (GL_FRONT);

this->glDisable (GL_DITHER);

if (glSDL_AddTexInfo (this, this->screen) < 0) {

GLERR ("HookDevice() failed to add info to screen surface!");

return NULL;

}

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

glSDL_do_texture (this, 0);

glSDL_do_blend (this, 0);

for (i = 0; i < 1 + flag_doublebuf; ++i) {

this->glBegin (GL_TRIANGLE_FAN);

this->glColor3ub (0, 0, 0);

this->glVertex2i (0, 0);

this->glVertex2i (this->screen->w, 0);

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

this->glVertex2i (0, this->screen->h);

this->glEnd ();

if (!i)

this->GL_SwapBuffers (this);

}

mirrorbuf = SDL_malloc (this->screen->h * this->screen->pitch);

if (!mirrorbuf) {

GLERR ("HookDevice() failed to allocate temp buffer for mirroring!");

return NULL;

}

return this->screen;

}

static int

glSDL_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)

/* We don't need to fill this one */

return 0;

}

#ifdef DEBUG_GLSDL

static void

glSDL_print_glerror (_THIS, int point)

const char *err = "<unknown>";

switch (this->glGetError ()) {

case GL_NO_ERROR:

return;

case GL_INVALID_ENUM:

err = "GL_INVALID_ENUM";

break;

case GL_INVALID_VALUE:

err = "GL_INVALID_VALUE";

break;

case GL_INVALID_OPERATION:

err = "GL_INVALID_OPERATION";

break;

case GL_STACK_OVERFLOW:

err = "GL_STACK_OVERFLOW";

break;

case GL_STACK_UNDERFLOW:

err = "GL_STACK_UNDERFLOW";

break;

case GL_OUT_OF_MEMORY:

err = "GL_OUT_OF_MEMORY";

default:

break;

}

fprintf (stderr, "OpenGL error \"%s\" at point %d.\n", err, point);

}

#endif

/* Get texinfo for a surface. */

static __inline__ private_hwdata *

glSDL_GetTexInfo (SDL_Surface * surface)

if (!surface)

return NULL;

return surface->hwdata;

}

/* Allocate a "blank" texinfo for a suface. */

static private_hwdata *

glSDL_AllocTexInfo (SDL_Surface * surface)