Mercurial > sdl-ios-xcode
changeset 1658:e49147870aac SDL-1.3
glSDL support
line wrap: on
line diff
--- a/Makefile.dc Fri Apr 28 16:55:41 2006 +0000 +++ b/Makefile.dc Mon May 01 06:58:33 2006 +0000 @@ -55,6 +55,7 @@ src/video/dummy/SDL_nullevents.c \ src/video/dummy/SDL_nullmouse.c \ src/video/dummy/SDL_nullvideo.c \ + src/video/glsdl/SDL_glsdl.c \ src/video/SDL_blit.c \ src/video/SDL_blit_0.c \ src/video/SDL_blit_1.c \
--- a/configure.in Fri Apr 28 16:55:41 2006 +0000 +++ b/configure.in Mon May 01 06:58:33 2006 +0000 @@ -1459,6 +1459,20 @@ fi } +dnl Find glSDL +CheckglSDL() +{ + AC_ARG_ENABLE(video-glsdl, +[ --enable-video-glsdl use glSDL video driver [default=yes]], + , enable_video_glsdl=yes) + AC_MSG_CHECKING(for glSDL support) + AC_MSG_RESULT($video_opengl) + if test x$video_opengl = xyes -a x$enable_video_glsdl = xyes; then + AC_DEFINE(SDL_VIDEO_DRIVER_GLSDL) + SOURCES="$SOURCES $srcdir/src/video/glsdl/*.c" + fi +} + dnl Check for Mesa offscreen rendering CheckAtariOSMesa() { @@ -2080,6 +2094,7 @@ CheckQtopia CheckPicoGUI CheckOpenGLX11 + CheckglSDL CheckInputEvents CheckTslib CheckUSBHID @@ -2178,6 +2193,7 @@ CheckPHOTON CheckX11 CheckOpenGLX11 + CheckglSDL CheckPTHREAD # Set up files for the audio library if test x$enable_audio = xyes; then @@ -2215,6 +2231,7 @@ CheckDummyAudio CheckWIN32 CheckWIN32GL + CheckglSDL CheckDIRECTX CheckNASM # Set up files for the audio library @@ -2279,6 +2296,7 @@ CheckNASM CheckBWINDOW CheckBeGL + CheckglSDL # Set up files for the audio library if test x$enable_audio = xyes; then AC_DEFINE(SDL_AUDIO_DRIVER_BAUDIO) @@ -2356,6 +2374,7 @@ CheckX11 CheckMacGL CheckOpenGLX11 + CheckglSDL CheckPTHREAD CheckAltivec @@ -2417,6 +2436,7 @@ CheckAtariAudio CheckAtariLdg CheckAtariOSMesa + CheckglSDL CheckPTH # Set up files for the audio library if test x$enable_threads = xyes -a x$enable_pth = xyes; then
--- a/include/SDL_config.h.in Fri Apr 28 16:55:41 2006 +0000 +++ b/include/SDL_config.h.in Mon May 01 06:58:33 2006 +0000 @@ -262,6 +262,7 @@ #undef SDL_VIDEO_DRIVER_GAPI #undef SDL_VIDEO_DRIVER_GEM #undef SDL_VIDEO_DRIVER_GGI +#undef SDL_VIDEO_DRIVER_GLSDL #undef SDL_VIDEO_DRIVER_IPOD #undef SDL_VIDEO_DRIVER_NANOX #undef SDL_VIDEO_DRIVER_OS2FS
--- a/include/SDL_config_amiga.h Fri Apr 28 16:55:41 2006 +0000 +++ b/include/SDL_config_amiga.h Mon May 01 06:58:33 2006 +0000 @@ -73,6 +73,7 @@ /* Enable various video drivers */ #define SDL_VIDEO_DRIVER_CYBERGRAPHICS 1 #define SDL_VIDEO_DRIVER_DUMMY 1 +#define SDL_VIDEO_DRIVER_GLSDL 1 /* Enable OpenGL support */ #define SDL_VIDEO_OPENGL 1
--- a/include/SDL_config_dreamcast.h Fri Apr 28 16:55:41 2006 +0000 +++ b/include/SDL_config_dreamcast.h Mon May 01 06:58:33 2006 +0000 @@ -102,5 +102,6 @@ /* Enable various video drivers */ #define SDL_VIDEO_DRIVER_DC 1 #define SDL_VIDEO_DRIVER_DUMMY 1 +#define SDL_VIDEO_DRIVER_GLSDL 1 #endif /* _SDL_config_dreamcast_h */
--- a/include/SDL_config_macos.h Fri Apr 28 16:55:41 2006 +0000 +++ b/include/SDL_config_macos.h Mon May 01 06:58:33 2006 +0000 @@ -90,6 +90,7 @@ /* Enable various video drivers */ #define SDL_VIDEO_DRIVER_DUMMY 1 #define SDL_VIDEO_DRIVER_DRAWSPROCKET 1 +#define SDL_VIDEO_DRIVER_GLSDL 1 #define SDL_VIDEO_DRIVER_TOOLBOX 1 /* Enable OpenGL support */
--- a/include/SDL_config_macosx.h Fri Apr 28 16:55:41 2006 +0000 +++ b/include/SDL_config_macosx.h Mon May 01 06:58:33 2006 +0000 @@ -116,6 +116,7 @@ /* Enable various video drivers */ #define SDL_VIDEO_DRIVER_DUMMY 1 +#define SDL_VIDEO_DRIVER_GLSDL 1 #define SDL_VIDEO_DRIVER_QUARTZ 1 /* Enable OpenGL support */
--- a/include/SDL_config_win32.h Fri Apr 28 16:55:41 2006 +0000 +++ b/include/SDL_config_win32.h Mon May 01 06:58:33 2006 +0000 @@ -155,6 +155,9 @@ #define SDL_VIDEO_DRIVER_DDRAW 1 #endif #define SDL_VIDEO_DRIVER_DUMMY 1 +#ifndef _WIN32_WCE +#define SDL_VIDEO_DRIVER_GLSDL 1 +#endif #define SDL_VIDEO_DRIVER_WINDIB 1 /* Enable OpenGL support */
--- a/include/SDL_video.h Fri Apr 28 16:55:41 2006 +0000 +++ b/include/SDL_video.h Mon May 01 06:58:33 2006 +0000 @@ -124,7 +124,7 @@ #define SDL_DOUBLEBUF 0x40000000 /* Set up double-buffered video mode */ #define SDL_FULLSCREEN 0x80000000 /* Surface is a full screen display */ #define SDL_OPENGL 0x00000002 /* Create an OpenGL rendering context */ -#define SDL_OPENGLBLIT_OBSOLETE 0x0000000A /* Obsolete, do not use! */ +#define SDL_INTERNALOPENGL 0x00000008 /* SDL uses OpenGL internally for this window */ #define SDL_RESIZABLE 0x00000010 /* This video mode may be resized */ #define SDL_NOFRAME 0x00000020 /* No window caption or edge frame */ /* Used internally (read-only) */
--- a/src/video/SDL_blit.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/SDL_blit.c Mon May 01 06:58:33 2006 +0000 @@ -281,7 +281,7 @@ video->CheckHWBlit(this, surface, surface->map->dst); } } - + /* Get the blit function index, based on surface mode */ /* { 0 = nothing, 1 = colorkey, 2 = alpha, 3 = colorkey+alpha } */ blit_index = 0;
--- a/src/video/SDL_glfuncs.h Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/SDL_glfuncs.h Mon May 01 06:58:33 2006 +0000 @@ -30,7 +30,7 @@ SDL_PROC_UNUSED(void,glColor3iv,(const GLint*)) SDL_PROC_UNUSED(void,glColor3s,(GLshort,GLshort,GLshort)) SDL_PROC_UNUSED(void,glColor3sv,(const GLshort*)) -SDL_PROC_UNUSED(void,glColor3ub,(GLubyte,GLubyte,GLubyte)) +SDL_PROC(void,glColor3ub,(GLubyte,GLubyte,GLubyte)) SDL_PROC_UNUSED(void,glColor3ubv,(const GLubyte*)) SDL_PROC_UNUSED(void,glColor3ui,(GLuint,GLuint,GLuint)) SDL_PROC_UNUSED(void,glColor3uiv,(const GLuint*)) @@ -46,7 +46,7 @@ SDL_PROC_UNUSED(void,glColor4iv,(const GLint*)) SDL_PROC_UNUSED(void,glColor4s,(GLshort,GLshort,GLshort,GLshort)) SDL_PROC_UNUSED(void,glColor4sv,(const GLshort*)) -SDL_PROC_UNUSED(void,glColor4ub,(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)) +SDL_PROC(void,glColor4ub,(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)) SDL_PROC_UNUSED(void,glColor4ubv,(const GLubyte *v)) SDL_PROC_UNUSED(void,glColor4ui,(GLuint red, GLuint green, GLuint blue, GLuint alpha)) SDL_PROC_UNUSED(void,glColor4uiv,(const GLuint *v)) @@ -62,14 +62,14 @@ SDL_PROC_UNUSED(void,glCopyTexSubImage2D,(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)) SDL_PROC_UNUSED(void,glCullFace,(GLenum mode)) SDL_PROC_UNUSED(void,glDeleteLists,(GLuint list, GLsizei range)) -SDL_PROC_UNUSED(void,glDeleteTextures,(GLsizei n, const GLuint *textures)) +SDL_PROC(void,glDeleteTextures,(GLsizei n, const GLuint *textures)) SDL_PROC_UNUSED(void,glDepthFunc,(GLenum func)) SDL_PROC_UNUSED(void,glDepthMask,(GLboolean flag)) SDL_PROC_UNUSED(void,glDepthRange,(GLclampd zNear, GLclampd zFar)) SDL_PROC(void,glDisable,(GLenum cap)) SDL_PROC_UNUSED(void,glDisableClientState,(GLenum array)) SDL_PROC_UNUSED(void,glDrawArrays,(GLenum mode, GLint first, GLsizei count)) -SDL_PROC_UNUSED(void,glDrawBuffer,(GLenum mode)) +SDL_PROC(void,glDrawBuffer,(GLenum mode)) SDL_PROC_UNUSED(void,glDrawElements,(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)) SDL_PROC_UNUSED(void,glDrawPixels,(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)) SDL_PROC_UNUSED(void,glEdgeFlag,(GLboolean flag)) @@ -92,7 +92,7 @@ SDL_PROC_UNUSED(void,glEvalPoint1,(GLint i)) SDL_PROC_UNUSED(void,glEvalPoint2,(GLint i, GLint j)) SDL_PROC_UNUSED(void,glFeedbackBuffer,(GLsizei size, GLenum type, GLfloat *buffer)) -SDL_PROC_UNUSED(void,glFinish,(void)) +SDL_PROC(void,glFinish,(void)) SDL_PROC(void,glFlush,(void)) SDL_PROC_UNUSED(void,glFogf,(GLenum pname, GLfloat param)) SDL_PROC_UNUSED(void,glFogfv,(GLenum pname, const GLfloat *params)) @@ -105,9 +105,9 @@ SDL_PROC_UNUSED(void,glGetBooleanv,(GLenum pname, GLboolean *params)) SDL_PROC_UNUSED(void,glGetClipPlane,(GLenum plane, GLdouble *equation)) SDL_PROC_UNUSED(void,glGetDoublev,(GLenum pname, GLdouble *params)) -SDL_PROC_UNUSED(GLenum,glGetError,(void)) +SDL_PROC(GLenum,glGetError,(void)) SDL_PROC_UNUSED(void,glGetFloatv,(GLenum pname, GLfloat *params)) -SDL_PROC_UNUSED(void,glGetIntegerv,(GLenum pname, GLint *params)) +SDL_PROC(void,glGetIntegerv,(GLenum pname, GLint *params)) SDL_PROC_UNUSED(void,glGetLightfv,(GLenum light, GLenum pname, GLfloat *params)) SDL_PROC_UNUSED(void,glGetLightiv,(GLenum light, GLenum pname, GLint *params)) SDL_PROC_UNUSED(void,glGetMapdv,(GLenum target, GLenum query, GLdouble *v)) @@ -240,7 +240,7 @@ SDL_PROC_UNUSED(void,glRasterPos4s,(GLshort x, GLshort y, GLshort z, GLshort w)) SDL_PROC_UNUSED(void,glRasterPos4sv,(const GLshort *v)) SDL_PROC_UNUSED(void,glReadBuffer,(GLenum mode)) -SDL_PROC_UNUSED(void,glReadPixels,(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)) +SDL_PROC(void,glReadPixels,(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)) SDL_PROC_UNUSED(void,glRectd,(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)) SDL_PROC_UNUSED(void,glRectdv,(const GLdouble *v1, const GLdouble *v2)) SDL_PROC_UNUSED(void,glRectf,(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)) @@ -311,7 +311,7 @@ SDL_PROC_UNUSED(void,glTexParameteriv,(GLenum target, GLenum pname, const GLint *params)) SDL_PROC_UNUSED(void,glTexSubImage1D,(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)) SDL_PROC(void,glTexSubImage2D,(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)) -SDL_PROC_UNUSED(void,glTranslated,(GLdouble x, GLdouble y, GLdouble z)) +SDL_PROC(void,glTranslated,(GLdouble x, GLdouble y, GLdouble z)) SDL_PROC_UNUSED(void,glTranslatef,(GLfloat x, GLfloat y, GLfloat z)) SDL_PROC_UNUSED(void,glVertex2d,(GLdouble x, GLdouble y)) SDL_PROC_UNUSED(void,glVertex2dv,(const GLdouble *v))
--- a/src/video/SDL_sysvideo.h Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/SDL_sysvideo.h Mon May 01 06:58:33 2006 +0000 @@ -119,7 +119,7 @@ /* The pixel format used when SDL_CreateRGBSurface creates SDL_HWSURFACEs with alpha */ SDL_PixelFormat* displayformatalphapixel; - + /* Allocates a surface in video memory */ int (*AllocHWSurface)(_THIS, SDL_Surface *surface); @@ -407,6 +407,9 @@ #if SDL_VIDEO_DRIVER_DUMMY extern VideoBootStrap DUMMY_bootstrap; #endif +#if SDL_VIDEO_DRIVER_GLSDL +extern VideoBootStrap glSDL_bootstrap; +#endif /* This is the current video device */ extern SDL_VideoDevice *current_video;
--- a/src/video/SDL_video.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/SDL_video.c Mon May 01 06:58:33 2006 +0000 @@ -123,6 +123,9 @@ #if SDL_VIDEO_DRIVER_DUMMY &DUMMY_bootstrap, #endif +#if SDL_VIDEO_DRIVER_GLSDL + &glSDL_bootstrap, +#endif NULL }; @@ -575,12 +578,6 @@ int is_opengl; SDL_GrabMode saved_grab; - /* Handle obsolete flags */ - if ( (flags & SDL_OPENGLBLIT_OBSOLETE) == SDL_OPENGLBLIT_OBSOLETE ) { - SDL_SetError("SDL_OPENGLBLIT is no longer supported"); - return(NULL); - } - /* Start up the video driver, if necessary.. WARNING: This is the only function protected this way! */ @@ -613,8 +610,12 @@ } /* Check the requested flags */ - /* There's no palette in > 8 bits-per-pixel mode */ + if ( flags & SDL_INTERNALOPENGL ) { + SDL_SetError("SDL_INTERNALOPENGL is for internal use only"); + return(NULL); + } if ( video_bpp > 8 ) { + /* There's no palette in > 8 bits-per-pixel mode */ flags &= ~SDL_HWPALETTE; } #if 0 @@ -632,6 +633,8 @@ if ( is_opengl ) { /* These flags are for 2D video modes only */ flags &= ~(SDL_HWSURFACE|SDL_DOUBLEBUF); + /* This flag tells the backends to treat the surface accordingly */ + flags |= SDL_INTERNALOPENGL; } /* Reset the keyboard here so event callbacks can run */ @@ -674,7 +677,7 @@ #endif /* Sam - If we asked for OpenGL mode, and didn't get it, fail */ - if ( is_opengl && !(mode->flags & SDL_OPENGL) ) { + if ( is_opengl && !(mode->flags & SDL_INTERNALOPENGL) ) { mode = NULL; SDL_SetError("OpenGL not available"); } @@ -752,7 +755,7 @@ #if SDL_VIDEO_OPENGL /* Load GL symbols (before MakeCurrent, where we need glGetString). */ - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { #if defined(__QNXNTO__) && (_NTO_VERSION < 630) #define __SDL_NOGETPROCADDR__ @@ -779,7 +782,7 @@ #endif /* SDL_VIDEO_OPENGL */ /* If we're running OpenGL, make the context current */ - if ( (video->screen->flags & SDL_OPENGL) && + if ( (video->screen->flags & SDL_INTERNALOPENGL) && video->GL_MakeCurrent ) { if ( video->GL_MakeCurrent(this) < 0 ) { return(NULL); @@ -1431,7 +1434,7 @@ SDL_VideoDevice *video = current_video; SDL_VideoDevice *this = current_video; - if ( video->screen->flags & SDL_OPENGL ) { + if ( video->screen->flags & SDL_INTERNALOPENGL ) { video->GL_SwapBuffers(this); } else { SDL_SetError("OpenGL video mode has not been set");
--- a/src/video/bwindow/SDL_BWin.h Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/bwindow/SDL_BWin.h Mon May 01 06:58:33 2006 +0000 @@ -219,7 +219,7 @@ retval = 0; Lock(); - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { #if SDL_VIDEO_OPENGL if ( SDL_GLView == NULL ) { SDL_GLView = new BGLView(Bounds(), "SDL GLView",
--- a/src/video/bwindow/SDL_sysvideo.cc Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/bwindow/SDL_sysvideo.cc Mon May 01 06:58:33 2006 +0000 @@ -525,7 +525,7 @@ current->flags |= SDL_NOFRAME; SDL_Win->SetLook(B_NO_BORDER_WINDOW_LOOK); } else { - if ( (flags & SDL_RESIZABLE) && !(flags & SDL_OPENGL) ) { + if ( (flags & SDL_RESIZABLE) && !(flags & SDL_INTERNALOPENGL) ) { current->flags |= SDL_RESIZABLE; /* We don't want opaque resizing (TM). :-) */ SDL_Win->SetFlags(B_OUTLINE_RESIZE); @@ -534,8 +534,8 @@ } } - if ( flags & SDL_OPENGL ) { - current->flags |= SDL_OPENGL; + if ( flags & SDL_INTERNALOPENGL ) { + current->flags |= SDL_INTERNALOPENGL; current->pitch = 0; current->pixels = NULL; _this->UpdateRects = NULL;
--- a/src/video/cybergfx/SDL_cgximage.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/cybergfx/SDL_cgximage.c Mon May 01 06:58:33 2006 +0000 @@ -135,7 +135,7 @@ CGX_DestroyImage(this, screen); - if ( flags & SDL_OPENGL ) { /* No image when using GL */ + if ( flags & SDL_INTERNALOPENGL ) { /* No image when using GL */ retval = 0; } else { retval = CGX_SetupImage(this, screen);
--- a/src/video/cybergfx/SDL_cgxvideo.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/cybergfx/SDL_cgxvideo.c Mon May 01 06:58:33 2006 +0000 @@ -598,7 +598,7 @@ /* Clean up OpenGL */ if ( screen ) { - screen->flags &= ~SDL_OPENGL; + screen->flags &= ~SDL_INTERNALOPENGL; } if ( screen && (screen->flags & SDL_FULLSCREEN) ) { @@ -687,7 +687,7 @@ /* questo l'ho spostato nell'apertura dello schermo, in quanto su Amiga le finestre hanno il pixel mode degli schermi. */ - /*if ( flags & SDL_OPENGL ) { + /*if ( flags & SDL_INTERNALOPENGL ) { SDL_SetError("OpenGL not supported by the Amiga SDL!"); return -1; } @@ -800,7 +800,7 @@ { /* Create GimmeZeroZero window when OpenGL is used */ unsigned long gzz = FALSE; - if( flags & SDL_OPENGL ) { + if( flags & SDL_INTERNALOPENGL ) { gzz = TRUE; } @@ -840,7 +840,7 @@ /* Set our colormaps when not setting a GL mode */ /* - if ( ! (flags & SDL_OPENGL) ) { + if ( ! (flags & SDL_INTERNALOPENGL) ) { XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); } */ @@ -861,18 +861,18 @@ CGX_ResizeImage(this, screen, flags); /* Make OpenGL Context if needed*/ - if(flags & SDL_OPENGL) { + if(flags & SDL_INTERNALOPENGL) { if(this->gl_data->gl_active == 0) { if(CGX_GL_Init(this) < 0) return -1; else - screen->flags |= SDL_OPENGL; + screen->flags |= SDL_INTERNALOPENGL; } else { if(CGX_GL_Update(this) < 0) return -1; else - screen->flags |= SDL_OPENGL; + screen->flags |= SDL_INTERNALOPENGL; } } } @@ -1066,7 +1066,7 @@ /* Set up the X11 window */ saved_flags = current->flags; - if (SDL_Window && (saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL) + if (SDL_Window && (saved_flags&SDL_INTERNALOPENGL) == (flags&SDL_INTERNALOPENGL) && bpp == current->format->BitsPerPixel && !needcreate) { if (CGX_ResizeWindow(this, current, width, height, flags) < 0) { current = NULL; @@ -1082,7 +1082,7 @@ #if 0 /* Set up the new mode framebuffer */ if ( ((current->w != width) || (current->h != height)) || - ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) { + ((saved_flags&SDL_INTERNALOPENGL) != (flags&SDL_INTERNALOPENGL)) ) { current->w = width; current->h = height; current->pitch = SDL_CalculatePitch(current);
--- a/src/video/dc/SDL_dcvideo.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/dc/SDL_dcvideo.c Mon May 01 06:58:33 2006 +0000 @@ -167,7 +167,7 @@ case 16: return &vid_modes; case 32: - if (!(flags & SDL_OPENGL)) + if (!(flags & SDL_INTERNALOPENGL)) return &vid_modes; default: return NULL; @@ -220,7 +220,7 @@ Gmask = 0x0000ff00; Bmask = 0x000000ff; #if SDL_VIDEO_OPENGL - if (!(flags & SDL_OPENGL)) + if (!(flags & SDL_INTERNALOPENGL)) #endif break; default: @@ -252,9 +252,9 @@ current->pixels = vram_s; #if SDL_VIDEO_OPENGL - if (flags & SDL_OPENGL) { + if (flags & SDL_INTERNALOPENGL) { this->gl_config.driver_loaded = 1; - current->flags = SDL_FULLSCREEN | SDL_OPENGL; + current->flags = SDL_FULLSCREEN | SDL_INTERNALOPENGL; current->pixels = NULL; pvr_inited = 1; pvr_init(¶ms);
--- a/src/video/gem/SDL_gemvideo.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/gem/SDL_gemvideo.c Mon May 01 06:58:33 2006 +0000 @@ -804,14 +804,14 @@ } #if SDL_VIDEO_OPENGL - if (flags & SDL_OPENGL) { + if (flags & SDL_INTERNALOPENGL) { if (!SDL_AtariGL_Init(this, current)) { GEM_FreeBuffers(this); SDL_SetError("Can not create OpenGL context"); return NULL; } - modeflags |= SDL_OPENGL; + modeflags |= SDL_INTERNALOPENGL; } #endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/video/glsdl/SDL_glsdl.c Mon May 01 06:58:33 2006 +0000 @@ -0,0 +1,2573 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2006 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +/* + * glSDL "SDL-over-OpenGL" video driver implemented by + * David Olofson <david@olofson.net> and + * Stephane Marchesin <stephane.marchesin@wanadoo.fr> + */ +#include <math.h> + +#include "SDL.h" +#include "SDL_error.h" +#include "SDL_video.h" +#include "SDL_mouse.h" +#include "../SDL_sysvideo.h" +#include "../SDL_pixels_c.h" + +#include "SDL_glsdl.h" + +#undef DEBUG_GLSDL +#undef DEBUG_GLSDL_CHOP +#define FAKE_MAXTEXSIZE 256 +#undef GLSDL_GRAPHICAL_DEBUG + +/* Initialization/Query functions */ + +/* Hardware surface functions */ +static int glSDL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); +static int glSDL_AllocHWSurface(_THIS, SDL_Surface *surface); +static int glSDL_LockHWSurface(_THIS, SDL_Surface *surface); +static int glSDL_FlipHWSurface(_THIS, SDL_Surface *surface); +static void glSDL_UnlockHWSurface(_THIS, SDL_Surface *surface); +static void glSDL_FreeHWSurface(_THIS, SDL_Surface *surface); +static int glSDL_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color); +static int glSDL_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst); +static int glSDL_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key); +static int glSDL_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha); +static int glSDL_VideoInit(_THIS, SDL_PixelFormat *vformat); +static SDL_Rect **glSDL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); +static void glSDL_VideoQuit(_THIS); +static void glSDL_UpdateRects(_THIS, int numrects, SDL_Rect *rects); +static SDL_Surface* glSDL_SetVideoMode(_THIS, SDL_Surface *current,int width, int height, int bpp, Uint32 flags); + +#define IS_GLSDL_SURFACE(s) ((s) && glSDL_GetTexInfo(s)) + +#define LOGIC_W(s) ( IS_GLSDL_SURFACE(this,s) ? TEXINFO(s)->lw : (s)->w ) +#define LOGIC_H(s) ( IS_GLSDL_SURFACE(this,s) ? TEXINFO(s)->lh : (s)->h ) + +#define GLSDL_NOTEX (~0) + +/* + * Special version for glSDL, which ignores the fake SDL_HWSURFACE + * flags, so we don't have SDL calling us back whenever we want to + * do some internal blitting... + */ +static void glSDL_SoftBlit(SDL_Surface *src, SDL_Rect *srcrect, + SDL_Surface *dst, SDL_Rect *dstrect) +{ + SDL_BlitInfo info; + + if(srcrect) + if(!srcrect->w || !srcrect->h) + return; + + /* Check to make sure the blit mapping is valid */ + if ( (src->map->dst != dst) || + (src->map->dst->format_version != + src->map->format_version) ) + if ( SDL_MapSurface(src, dst) < 0 ) + return; + + /* Set up the blit information */ + if(srcrect) + { + info.s_pixels = (Uint8 *) src->pixels + + (Uint16) srcrect->y * src->pitch + + (Uint16) srcrect->x * src->format->BytesPerPixel; + info.s_width = srcrect->w; + info.s_height = srcrect->h; + } + else + { + info.s_pixels = (Uint8 *) src->pixels; + info.s_width = src->w; + info.s_height = src->h; + } + info.s_skip = src->pitch - info.s_width * src->format->BytesPerPixel; + if(dstrect) + { + info.d_pixels = (Uint8 *) dst->pixels + + (Uint16) dstrect->y * dst->pitch + + (Uint16) dstrect->x * dst->format->BytesPerPixel; + /* + * NOTE: SDL_SoftBlit() uses the 'dstrect' for this! + * This version is more like SDL_BlitSurface(). + */ + info.d_width = srcrect->w; + info.d_height = srcrect->h; + } + else + { + info.d_pixels = (Uint8 *) dst->pixels; + info.d_width = dst->w; + info.d_height = dst->h; + } + info.d_skip = dst->pitch - info.d_width * dst->format->BytesPerPixel; + info.aux_data = src->map->sw_data->aux_data; + info.src = src->format; + info.table = src->map->table; + info.dst = dst->format; + + src->map->sw_data->blit(&info); +} + + +/* + * Another special version. Doesn't lock/unlock, and doesn't mess + * with flags and stuff. It just converts the surface, period. + * Does not convert into palletized formats. + */ +static SDL_Surface *glSDL_ConvertSurface (SDL_Surface *surface, + SDL_PixelFormat *format, Uint32 flags) +{ + SDL_Surface *convert; + Uint32 colorkey = 0; + Uint8 alpha = 0; + Uint32 surface_flags; + SDL_Rect bounds; + + /* Create a new surface with the desired format */ + convert = SDL_CreateRGBSurface(flags, + surface->w, surface->h, format->BitsPerPixel, + format->Rmask, format->Gmask, format->Bmask, format->Amask); + if ( convert == NULL ) { + return(NULL); + } + + /* Save the original surface color key and alpha */ + surface_flags = surface->flags; + if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { + /* Convert colourkeyed surfaces to RGBA if requested */ + if((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY + && format->Amask) { + surface_flags &= ~SDL_SRCCOLORKEY; + } else { + colorkey = surface->format->colorkey; + SDL_SetColorKey(surface, 0, 0); + } + } + if ( (surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { + /* Copy over the alpha channel to RGBA if requested */ + if ( format->Amask ) { + surface->flags &= ~SDL_SRCALPHA; + } else { + alpha = surface->format->alpha; + SDL_SetAlpha(surface, 0, 0); + } + } + + /* Copy over the image data */ + bounds.x = 0; + bounds.y = 0; + bounds.w = surface->w; + bounds.h = surface->h; + glSDL_SoftBlit(surface, &bounds, convert, &bounds); + + /* Clean up the original surface, and update converted surface */ + if ( convert != NULL ) { + SDL_SetClipRect(convert, &surface->clip_rect); + } + if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { + Uint32 cflags = surface_flags&(SDL_SRCCOLORKEY|SDL_RLEACCELOK); + if ( convert != NULL ) { + Uint8 keyR, keyG, keyB; + + SDL_GetRGB(colorkey,surface->format,&keyR,&keyG,&keyB); + SDL_SetColorKey(convert, cflags|(flags&SDL_RLEACCELOK), + SDL_MapRGB(convert->format, keyR, keyG, keyB)); + } + SDL_SetColorKey(surface, cflags, colorkey); + } + if ( (surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { + Uint32 aflags = surface_flags&(SDL_SRCALPHA|SDL_RLEACCELOK); + if ( convert != NULL ) { + SDL_SetAlpha(convert, aflags|(flags&SDL_RLEACCELOK), + alpha); + } + if ( format->Amask ) { + surface->flags |= SDL_SRCALPHA; + } else { + SDL_SetAlpha(surface, aflags, alpha); + } + } + + /* We're ready to go! */ + return(convert); +} + + +/*---------------------------------------------------------- + Some OpenGL function wrappers + ----------------------------------------------------------*/ + +static struct +{ + int do_blend; + int do_texture; + GLuint texture; + GLenum sfactor, dfactor; +} glstate; + +static void glSDL_reset(void) +{ + glstate.do_blend = -1; + glstate.do_blend = -1; + glstate.texture = GLSDL_NOTEX; + glstate.sfactor = 0xffffffff; + glstate.dfactor = 0xffffffff; +} + +static __inline__ void glSDL_do_blend(_THIS, int on) +{ + if(glstate.do_blend == on) + return; + + if(on) + this->glEnable(GL_BLEND); + else + this->glDisable(GL_BLEND); + glstate.do_blend = on; +} + +static __inline__ void glSDL_do_texture(_THIS, int on) +{ + if(glstate.do_texture == on) + return; + + if(on) + this->glEnable(GL_TEXTURE_2D); + else + this->glDisable(GL_TEXTURE_2D); + glstate.do_texture = on; +} + +static __inline__ void glSDL_blendfunc(_THIS, GLenum sfactor, GLenum dfactor) +{ + if((sfactor == glstate.sfactor) && (dfactor == glstate.dfactor)) + return; + + this->glBlendFunc(sfactor, dfactor); + + glstate.sfactor = sfactor; + glstate.dfactor = dfactor; +} + +static __inline__ void glSDL_texture(_THIS, GLuint tx) +{ + if(tx == glstate.texture) + return; + + this->glBindTexture(GL_TEXTURE_2D, tx); + glstate.texture = tx; +} + + + + +/*---------------------------------------------------------- + glSDL specific data types + ----------------------------------------------------------*/ + +typedef enum +{ + GLSDL_TM_SINGLE, + GLSDL_TM_HORIZONTAL, + GLSDL_TM_VERTICAL, + GLSDL_TM_HUGE +} GLSDL_TileModes; + + +typedef struct private_hwdata +{ + /* Size of surface in logic screen pixels */ + int lw, lh; + + int textures; + GLuint *texture; + int texsize; /* width/height of OpenGL texture */ + GLSDL_TileModes tilemode; + int tilew, tileh; /* At least one must equal texsize! */ + int tilespertex; + SDL_Rect virt; /* Total size of assembled surface */ + + /* Area of surface to upload when/after unlocking */ + SDL_Rect invalid_area; + + int temporary; /* Throw away after one use. */ + + SDL_Surface* next; /* The next Surface in our linked list of hardware surfaces ; == NULL if first surface */ + SDL_Surface* prev; /* The prev Surface in our linked list of hardware surfaces ; == NULL if last surface */ +} private_hwdata; + +/* some function prototypes */ +static void glSDL_Invalidate(SDL_Surface *surface, SDL_Rect *area); +static void glSDL_SetLogicSize(_THIS, SDL_Surface *surface, int w, int h); +static private_hwdata *glSDL_UploadSurface(_THIS, SDL_Surface *surface); +static private_hwdata *glSDL_GetTexInfo(SDL_Surface *surface); +static void glSDL_init_formats(_THIS); +static private_hwdata *glSDL_AddTexInfo(_THIS, SDL_Surface *surface); +static void glSDL_RemoveTexInfo(_THIS, SDL_Surface *surface); +static void glSDL_UnloadTexture(_THIS, private_hwdata *txi); +static int glSDL_BlitGL(_THIS, SDL_Surface *src, + SDL_Rect *srcrect, SDL_Rect *dstrect); + +/* some variables */ +static GLint maxtexsize = -1; +static SDL_PixelFormat *RGBfmt = NULL; +static SDL_PixelFormat *RGBAfmt = NULL; +static void *mirrorbuf = NULL; +/* the raw 888 opengl surface, hidden from the application */ +SDL_Surface* OpenGL_Surface; + +/* pointer to the beggining of the list used for memory allocation */ +SDL_Surface* first = NULL; + +#ifdef DEBUG_GLSDL +static __inline__ int GLERET(const char *txt) +{ + fprintf(stderr, "glSDL ERROR: '%s'\n", txt); + return -1; +} +static __inline__ void GLERR(const char *txt) +{ + fprintf(stderr, "glSDL ERROR: '%s'\n", txt); +} +#else +#define GLERET(x) (-1) +#define GLERR(x) +#endif + +static SDL_VideoDevice underlying_device; +static int old_screen_flags; + +/* + * List of video drivers known to support OpenGL + * The purpose of this is to make glSDL "portable" across + * all video backends that support OpenGL + */ +static VideoBootStrap *opengl_bootstrap = +#if SDL_VIDEO_DRIVER_QUARTZ + &QZ_bootstrap; +#elif SDL_VIDEO_DRIVER_X11 + &X11_bootstrap; +#elif SDL_VIDEO_DRIVER_WINDIB + &WINDIB_bootstrap; +#elif SDL_VIDEO_DRIVER_BWINDOW + &BWINDOW_bootstrap; +#elif SDL_VIDEO_DRIVER_TOOLBOX + &TOOLBOX_bootstrap; +#elif SDL_VIDEO_DRIVER_CYBERGRAPHICS + &CGX_bootstrap; +#elif SDL_VIDEO_DRIVER_PHOTON + &ph_bootstrap; +#elif SDL_VIDEO_DRIVER_DC + &DC_bootstrap; +#else + NULL; +#endif + +static int glSDL_Available(void) +{ +#ifdef DEBUG_GLSDL + fprintf(stderr,"available\n"); +#endif + if (opengl_bootstrap==NULL) + return 0; + return (opengl_bootstrap->available()); +} + +static void glSDL_DeleteDevice(SDL_VideoDevice *device) +{ + SDL_free(device->hidden); + SDL_free(device); +} + +/* Create a glSDL device */ +static SDL_VideoDevice* glSDL_CreateDevice(int devindex) +{ + SDL_VideoDevice *device; +#ifdef DEBUG_GLSDL + fprintf(stderr,"entering createdevice\n"); +#endif + + /* Create the device with the underlying driver */ + device = opengl_bootstrap->create(devindex); + + /* Save the video device contents for future use */ + SDL_memcpy(&underlying_device,device,sizeof(SDL_VideoDevice)); + + /* Hook glSDL on the video device */ + device->VideoInit = glSDL_VideoInit; + device->ListModes = glSDL_ListModes; + device->VideoQuit = glSDL_VideoQuit; + device->UpdateRects = glSDL_UpdateRects; + device->FillHWRect = glSDL_FillHWRect; + device->SetHWColorKey = glSDL_SetHWColorKey; + device->SetHWAlpha = glSDL_SetHWAlpha; + device->AllocHWSurface = glSDL_AllocHWSurface; + device->LockHWSurface = glSDL_LockHWSurface; + device->UnlockHWSurface = glSDL_UnlockHWSurface; + device->FlipHWSurface = glSDL_FlipHWSurface; + device->FreeHWSurface = glSDL_FreeHWSurface; + device->CheckHWBlit = glSDL_CheckHWBlit; + device->SetColors = glSDL_SetColors; + device->SetVideoMode = glSDL_SetVideoMode; + device->info.hw_available=1; + device->info.blit_hw=1; + device->info.blit_hw_CC=1; + device->info.blit_hw_A=1; + device->info.blit_sw=1; + device->info.blit_sw_CC=1; + device->info.blit_sw_A=1; + device->info.blit_fill=1; + + /* These functions are not supported by glSDL, so we NULLify them */ + device->SetGamma = NULL; + device->GetGamma = NULL; + device->SetGammaRamp = NULL; + device->GetGammaRamp = NULL; + device->ToggleFullScreen = NULL; + + device->free = glSDL_DeleteDevice; + +#ifdef DEBUG_GLSDL + fprintf(stderr,"leaving createdevice\n"); +#endif + + return device; +} + +/* Our bootstraping structure */ +VideoBootStrap glSDL_bootstrap = { + "glSDL", "glSDL - SDL over OpenGL", + glSDL_Available, glSDL_CreateDevice +}; + +static int glSDL_VideoInit(_THIS, SDL_PixelFormat *vformat) +{ + int r; + printf("glSDL videoinit\n"); +#ifdef DEBUG_GLSDL + fprintf(stderr,"videoinit\n"); +#endif + r=underlying_device.VideoInit(this,vformat); + this->info.hw_available=1; + this->info.blit_hw=1; + this->info.blit_hw_CC=1; + this->info.blit_hw_A=1; + this->info.blit_sw=1; + this->info.blit_sw_CC=1; + this->info.blit_sw_A=1; + this->info.blit_fill=1; + + return r; +} + +SDL_Rect **glSDL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) +{ + return((SDL_Rect **)-1); +} + +static void glSDL_VideoQuit(_THIS) +{ + SDL_Surface* scr; + + /* free all hwdata structures */ + while(first!=NULL) + glSDL_RemoveTexInfo(this, first); + + SDL_free(mirrorbuf); + mirrorbuf = NULL; + + SDL_FreeFormat(RGBfmt); + SDL_FreeFormat(RGBAfmt); + RGBfmt = RGBAfmt = NULL; + + SDL_FreeFormat(this->displayformatalphapixel); + this->displayformatalphapixel = NULL; + + SDL_FreeSurface(OpenGL_Surface); + OpenGL_Surface = NULL; + + /* restore the flags to gracefully exit from fullscreen */ + this->screen->flags = old_screen_flags; + + /* keep the screen */ + scr=this->screen; + + /* we cleaned up our stuff, now restore the underlying video driver */ + SDL_memcpy(this,&underlying_device,sizeof(SDL_VideoDevice)); + + this->screen=scr; + + /* call the underlying video driver's VideoQuit function */ + this->VideoQuit(this); +} + +static SDL_Surface* glSDL_SetVideoMode(_THIS, SDL_Surface *current,int width, int height, int bpp, Uint32 flags) +{ + SDL_Surface* hooked_screen; + int i; + int flag_doublebuf=0; + + if (opengl_bootstrap==NULL) + { + GLERR("No bootstrap for glSDL compiled in !\n"); + return NULL; + } + + /* we don't have OpenGL */ + if ((flags&SDL_INTERNALOPENGL)==SDL_INTERNALOPENGL) + { + GLERR("OpenGL video modes are not supported by glSDL !\n"); + return(NULL); + } + + /* + * Adjust the flags + */ + flags &= ~SDL_HWPALETTE; + flags |= SDL_INTERNALOPENGL; + + /* remember whether the user requested DOUBLEBUF */ + + if (flags&SDL_DOUBLEBUF) + { + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1); + flag_doublebuf=1; + } + else + { + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,0); + flag_doublebuf=0; + } + + hooked_screen = underlying_device.SetVideoMode(this,current,width,height,0,flags); + + if (!hooked_screen) + { + GLERR("Unable to open an OpenGL window !\n"); + return(NULL); + } + + /* save the screen flags for restore time */ + old_screen_flags = hooked_screen->flags; + +#ifdef DEBUG_GLSDL + fprintf(stderr,"got %d bpp\n",bpp); +#endif + + /* setup the public surface format + * glSDL always returns the bpp its asked + */ + switch(bpp) + { + case 32: + this->is_32bit = 1; + this->screen = SDL_CreateRGBSurface(flags, width, height, bpp, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x00FF0000, + 0x0000FF00, + 0x000000FF, + 0x00000000 +#else + 0x0000FF00, + 0x00FF0000, + 0xFF000000, + 0x00000000 +#endif + ); + break; + case 24: + this->is_32bit = 0; + this->screen = SDL_CreateRGBSurface(flags, width, height, bpp, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x00FF0000, + 0x0000FF00, + 0x000000FF, + 0x00000000 +#else + 0x0000FF00, + 0x00FF0000, + 0xFF000000, + 0x00000000 +#endif + ); + break; + case 16: + this->is_32bit = 0; + this->screen = SDL_CreateRGBSurface(flags, width, height, bpp, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x0000F800, + 0x000007E0, + 0x0000001F, + 0x00000000 +#else + 0x0000001F, + 0x000007E0, + 0x0000F800, + 0x00000000 +#endif + ); + break; + case 15: + this->is_32bit = 0; + this->screen = SDL_CreateRGBSurface(flags, width, height, bpp, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x00007C00, + 0x000003E0, + 0x0000001F, + 0x00000000 +#else + 0x0000001F, + 0x000003E0, + 0x00007C00, + 0x00000000 +#endif + ); + break; + case 8: + default: + this->is_32bit = 0; + this->screen = SDL_CreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0); + /* give it a default palette if 8 bpp + * note : SDL already takes care of the palette for 4 bits & 1 bit surfaces + */ +/* if (bpp==8) + { + this->screen->format->palette->ncolors=255; + SDL_DitherColors(this->screen->format->palette->colors,bpp); + }*/ + break; + } + + /* also, we add SDL_HWSURFACE all the time, and let SDL create a shadow surface accordingly */ + this->screen->flags = hooked_screen->flags | SDL_HWSURFACE | SDL_INTERNALOPENGL; + /* add SDL_DOUBLEBUF if it was requested */ + if (flag_doublebuf) + this->screen->flags|=SDL_DOUBLEBUF; + + /* Tell SDL the alpha pixel format we'd like to have */ + this->displayformatalphapixel = SDL_AllocFormat(32, +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + 0x000000FF +#else + 0x000000FF, + 0x0000FF00, + 0x00FF0000, + 0xFF000000 +#endif + ); + + /* Now create the raw OpenGL surface */ + OpenGL_Surface = SDL_CreateRGBSurface(flags, width, height, 24, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x000000FF, + 0x0000FF00, + 0x00FF0000, + 0x00000000 +#else + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + 0x00000000 +#endif + ); + + /* Here we have to setup OpenGL funcs ourselves */ +#ifndef __QNXNTO__ +#define SDL_PROC(ret,func,params) \ + do { \ + this->func = SDL_GL_GetProcAddress(#func); \ + if ( ! this->func ) { \ + SDL_SetError("Couldn't load GL function: %s\n", #func); \ + return(NULL); \ + } \ + } while ( 0 ); +#else +#define SDL_PROC(ret,func,params) this->func=func; +#endif /* __QNXNTO__ */ +#include "../SDL_glfuncs.h" +#undef SDL_PROC + + if ( this->GL_MakeCurrent(this) < 0 ) + return(NULL); +#define SDL_PROC(ret,func,params) \ + do { \ + this->func = SDL_GL_GetProcAddress(#func); \ + if ( ! this->func ) { \ + SDL_SetError("Couldn't load GL function: %s\n", #func); \ + return(NULL); \ + } \ + } while ( 0 ); +#include "../SDL_glfuncs.h" +#undef SDL_PROC + + +#ifdef FAKE_MAXTEXSIZE + maxtexsize = FAKE_MAXTEXSIZE; +#else + this->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize); +#endif +#ifdef DEBUG_GLSDL + fprintf(stderr, "glSDL: Max texture size: %d\n", maxtexsize); +#endif + + glSDL_init_formats(this); + + if (flag_doublebuf) + this->glDrawBuffer(GL_BACK); + else + this->glDrawBuffer(GL_FRONT); + + this->glDisable(GL_DITHER); + + if(glSDL_AddTexInfo(this, this->screen) < 0) + { + GLERR("HookDevice() failed to add info to screen surface!"); + return NULL; + } + + glSDL_SetLogicSize(this, this->screen, + this->screen->w, this->screen->h); + + glSDL_do_texture(this, 0); + glSDL_do_blend(this, 0); + + for(i = 0; i < 1+flag_doublebuf; ++i) + { + this->glBegin(GL_TRIANGLE_FAN); + this->glColor3ub(0, 0, 0); + this->glVertex2i(0, 0); + this->glVertex2i(this->screen->w, 0); + this->glVertex2i(this->screen->w, this->screen->h); + this->glVertex2i(0, this->screen->h); + this->glEnd(); + if(!i) + this->GL_SwapBuffers(this); + } + + mirrorbuf = SDL_malloc(this->screen->h * this->screen->pitch); + if(!mirrorbuf) + { + GLERR("HookDevice() failed to allocate temp buffer for mirroring!"); + return NULL; + } + + return this->screen; +} + +static int glSDL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) +{ + /* We don't need to fill this one */ + return 0; +} + + +#ifdef DEBUG_GLSDL +static void glSDL_print_glerror(_THIS, int point) +{ + const char *err = "<unknown>"; + switch(this->glGetError()) + { + case GL_NO_ERROR: + return; + case GL_INVALID_ENUM: + err = "GL_INVALID_ENUM"; + break; + case GL_INVALID_VALUE: + err = "GL_INVALID_VALUE"; + break; + case GL_INVALID_OPERATION: + err = "GL_INVALID_OPERATION"; + break; + case GL_STACK_OVERFLOW: + err = "GL_STACK_OVERFLOW"; + break; + case GL_STACK_UNDERFLOW: + err = "GL_STACK_UNDERFLOW"; + break; + case GL_OUT_OF_MEMORY: + err = "GL_OUT_OF_MEMORY"; + default: + break; + } + fprintf(stderr,"OpenGL error \"%s\" at point %d.\n", err, point); +} +#endif + +/* Get texinfo for a surface. */ +static __inline__ private_hwdata *glSDL_GetTexInfo(SDL_Surface *surface) +{ + if(!surface) + return NULL; + return surface->hwdata; +} + + +/* Allocate a "blank" texinfo for a suface. */ +static private_hwdata *glSDL_AllocTexInfo(SDL_Surface *surface) +{ + private_hwdata *txi; + if(!surface) + return NULL; + + txi = glSDL_GetTexInfo(surface); + if(txi) + return txi; /* There already is one! --> */ + + /* ...and hook a new texinfo struct up to it. */ + txi = (private_hwdata *)SDL_calloc(1, sizeof(private_hwdata)); + if(!txi) + { + GLERR("AllocTexInfo(): Failed allocating TexInfo struct!"); + return NULL; + } + txi->temporary = 1; +#ifdef DEBUG_GLSDL + fprintf(stderr, "glSDL: Allocated TexInfo %p.\n", txi); +#endif + return txi; +} + + +static void glSDL_FreeTexInfo(_THIS, private_hwdata *txi) +{ + if(!txi) + return; + + glSDL_UnloadTexture(this, txi); + SDL_free(txi->texture); + SDL_free(txi); +#ifdef DEBUG_GLSDL + fprintf(stderr, "glSDL: Freed TexInfo %p.\n", txi); +#endif +} + + +/* Detach and free the texinfo of a surface. */ +static void glSDL_RemoveTexInfo(_THIS, SDL_Surface *surface) +{ + SDL_Surface *next,*prev; + if(!glSDL_GetTexInfo(surface)) + return; + + /* maintain our doubly linked list */ + next=surface->hwdata->next; + prev=surface->hwdata->prev; + if (prev!=NULL) + { + prev->hwdata->next = next; + } + else + { + first = next; + } + if (next!=NULL) + { + next->hwdata->prev = prev; + } + + glSDL_FreeTexInfo(this, surface->hwdata); + surface->hwdata = NULL; +} + + +/* + * Calculate chopping/tiling of a surface to + * fit it into the smallest possible OpenGL + * texture. + */ +static int glSDL_CalcChop(private_hwdata *txi) +{ + int rows, vw, vh; + int vertical = 0; + int texsize; + int lastw, lasth, minsize; + + vw = txi->virt.w; + vh = txi->virt.h; + +#ifdef DEBUG_GLSDL_CHOP + fprintf(stderr, "w=%d, h=%d ", vw, vh); +#endif + if(vh > vw) + { + int t = vw; + vw = vh; + vh = t; + vertical = 1; +#ifdef DEBUG_GLSDL_CHOP + fprintf(stderr, "(vertical) \t"); +#endif + } + + /* + * Check whether this is a "huge" surface - at least one dimension + * must be <= than the maximum texture size, or we'll have to chop + * in both directions. + */ +#ifdef DEBUG_GLSDL + if(maxtexsize < 0) + return GLERET("glSDL_CalcChop() called before OpenGL init!"); +#endif + if(vh > maxtexsize) + { + /* + * Very simple hack for now; we just tile + * both ways with maximum size textures. + */ + texsize = maxtexsize; + + txi->tilemode = GLSDL_TM_HUGE; + txi->texsize = texsize; + txi->tilew = texsize; + txi->tileh = texsize; + txi->tilespertex = 1; + + /* Calculate number of textures needed */ + txi->textures = (vw + texsize - 1) / texsize; + txi->textures *= (vh + texsize - 1) / texsize; + txi->texture = SDL_malloc(txi->textures * sizeof(int)); + SDL_memset(txi->texture, -1, txi->textures * sizeof(int)); +#ifdef DEBUG_GLSDL + fprintf(stderr, "two-way tiling; textures=%d\n", txi->textures); +#endif + if(!txi->texture) + { + fprintf(stderr, "glSDL: INTERNAL ERROR: Failed to allocate" + " texture name table!\n"); + return -3; + } + return 0; + } + + /* Calculate minimum size */ + rows = 1; + lastw = vw; + lasth = vh; + minsize = lastw > lasth ? lastw : lasth; + while(1) + { + int w, h, size; + ++rows; + w = vw / rows; + h = rows * vh; + size = w > h ? w : h; + if(size >= minsize) + { + --rows; + break; + } + lastw = w; + lasth = h; + minsize = size; + } + if(minsize > maxtexsize) + { + /* Handle multiple textures for very wide/tall surfaces. */ + minsize = maxtexsize; + rows = (vw + minsize-1) / minsize; + } +#ifdef DEBUG_GLSDL_CHOP + fprintf(stderr, "==> minsize=%d ", minsize); + fprintf(stderr, "(rows=%d) \t", rows); +#endif + + /* Recalculate with nearest higher power-of-2 width. */ + for(texsize = 1; texsize < minsize; texsize <<= 1) + ; + txi->texsize = texsize; + rows = (vw + texsize-1) / texsize; +#ifdef DEBUG_GLSDL_CHOP + fprintf(stderr, "==> texsize=%d (rows=%d) \t", texsize, rows); +#endif + + /* Calculate number of tiles per texture */ + txi->tilespertex = txi->texsize / vh; +#ifdef DEBUG_GLSDL_CHOP + fprintf(stderr, "tilespertex=%d \t", txi->tilespertex); +#endif + + /* Calculate number of textures needed */ + txi->textures = (rows + txi->tilespertex-1) / txi->tilespertex; + txi->texture = (GLuint *)SDL_malloc(txi->textures * sizeof(GLuint)); + SDL_memset(txi->texture, GLSDL_NOTEX, txi->textures * sizeof(GLuint)); +#ifdef DEBUG_GLSDL_CHOP + fprintf(stderr, "textures=%d, ", txi->textures); +#endif + if(!txi->texture) + return GLERET("Failed to allocate texture name table!"); + + /* Set up tile size. (Only one axis supported here!) */ + if(1 == rows) + { + txi->tilemode = GLSDL_TM_SINGLE; + if(vertical) + { + txi->tilew = vh; + txi->tileh = vw; + } + else + { + txi->tilew = vw; + txi->tileh = vh; + } + } + else if(vertical) + { + txi->tilemode = GLSDL_TM_VERTICAL; + txi->tilew = vh; + txi->tileh = texsize; + } + else + { + txi->tilemode = GLSDL_TM_HORIZONTAL; + txi->tilew = texsize; + txi->tileh = vh; + } + +#ifdef DEBUG_GLSDL_CHOP + fprintf(stderr, "tilew=%d, tileh=%d\n", txi->tilew, txi->tileh); +#endif + return 0; +} + + +/* Create a temporary TexInfo struct for an SDL_Surface */ +static private_hwdata *glSDL_CreateTempTexInfo(_THIS, SDL_Surface *surface) +{ + private_hwdata *txi; + if(!surface) + { + GLERR("CreateTempTexInfo(); no surface!"); + return NULL; + } + if(IS_GLSDL_SURFACE(surface)) + return glSDL_GetTexInfo(surface); /* Do nothing */ + + txi = glSDL_AllocTexInfo(surface); + if(!txi) + { + GLERR("CreateTempTexInfo(); Could not alloc TexInfo!"); + return NULL; + } + txi->virt.w = txi->lw = surface->w; + txi->virt.h = txi->lh = surface->h; + + if(glSDL_CalcChop(txi) < 0) + { + glSDL_FreeTexInfo(this, txi); + GLERR("CreateTempTexInfo(); CalcChop() failed!"); + return NULL; + } + + return txi; +} + +/* Add a glSDL_TexInfo struct to an SDL_Surface */ +static private_hwdata *glSDL_AddTexInfo(_THIS, SDL_Surface *surface) +{ + private_hwdata *txi = glSDL_CreateTempTexInfo(this, surface); + if(!txi) + return NULL; + + /* Connect the surface to the new TexInfo. */ + txi->temporary = 0; + surface->hwdata = txi; + + /* add this new surface in front of the list of hw surfaces */ + txi->next = first; + txi->prev = NULL; + first = surface; + if (txi->next!=NULL) + { + txi->next->hwdata->prev=surface; + } + + SDL_SetClipRect(surface, &txi->virt); + return txi; +} + + +/* Create a surface of the prefered OpenGL RGB texture format */ +/*static SDL_Surface *glSDL_CreateRGBSurface(int w, int h) +{ + SDL_Surface *s; + Uint32 rmask, gmask, bmask; + int bits = 24; +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + rmask = 0x000000FF; + gmask = 0x0000FF00; + bmask = 0x00FF0000; +#else + rmask = 0x00FF0000; + gmask = 0x0000FF00; + bmask = 0x000000FF; +#endif + s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, + bits, rmask, gmask, bmask, 0); + if(s) + s->flags |= SDL_HWACCEL; + + return s; +} +*/ + +/* Create a surface of the prefered OpenGL RGBA texture format */ +static SDL_Surface *glSDL_CreateRGBASurface(int w, int h) +{ + SDL_Surface *s; + Uint32 rmask, gmask, bmask, amask; + int bits = 32; +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + rmask = 0x000000FF; + gmask = 0x0000FF00; + bmask = 0x00FF0000; + amask = 0xFF000000; +#else + rmask = 0xFF000000; + gmask = 0x00FF0000; + bmask = 0x0000FF00; + amask = 0x000000FF; +#endif + s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, + bits, rmask, gmask, bmask, amask); + if(s) + s->flags |= SDL_HWACCEL; + + return s; +} + + +static void glSDL_init_formats(_THIS) +{ + RGBfmt = SDL_AllocFormat(24, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x000000FF, + 0x0000FF00, + 0x00FF0000, + 0); +#else + 0x00FF0000, + 0x0000FF00, + 0x000000FF, + 0); +#endif + RGBAfmt = SDL_AllocFormat(32, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x000000FF, + 0x0000FF00, + 0x00FF0000, + 0xFF000000); +#else + 0xFF000000, + 0x00FF0000, + 0x0000FF00, + 0x000000FF); +#endif +} + + +static int glSDL_FormatIsOk(SDL_Surface *surface) +{ + SDL_PixelFormat *pf; + if(!surface) + return 1; /* Well, there ain't much we can do anyway... */ + + pf = surface->format; + + /* Colorkeying requires an alpha channel! */ + if(surface->flags & SDL_SRCCOLORKEY) + if(!pf->Amask) + return 0; + + /* We need pitch == (width * BytesPerPixel) for glTex[Sub]Image2D() */ + if(surface->pitch != (surface->w * pf->BytesPerPixel)) + return 0; + + if(pf->Amask) + { + if(pf->BytesPerPixel != RGBAfmt->BytesPerPixel) + return 0; + if(pf->Rmask != RGBAfmt->Rmask) + return 0; + if(pf->Gmask != RGBAfmt->Gmask) + return 0; + if(pf->Bmask != RGBAfmt->Bmask) + return 0; + if(pf->Amask != RGBAfmt->Amask) + return 0; + } + else + { + if(pf->BytesPerPixel != RGBfmt->BytesPerPixel) + return 0; + if(pf->Rmask != RGBfmt->Rmask) + return 0; + if(pf->Gmask != RGBfmt->Gmask) + return 0; + if(pf->Bmask != RGBfmt->Bmask) + return 0; + } + return 1; +} + +static void glSDL_key2alpha(SDL_Surface *surface) +{ + int x, y; + Uint32 ckey = surface->format->colorkey; + +#ifdef DEBUG_GLSDL + fprintf(stderr,"glSDL_key2alpha()\n"); +#endif + for(y = 0; y < surface->h; ++y) + { + Uint32 *px = (Uint32 *)((char *)surface->pixels + y*surface->pitch); + for(x = 0; x < surface->w; ++x) + if(px[x] == ckey) + px[x] = 0; + } +} + + + +/*---------------------------------------------------------- + SDL style API + ----------------------------------------------------------*/ + +static int glSDL_FlipHWSurface(_THIS, SDL_Surface *surface) +{ +#ifdef GLSDL_GRAPHICAL_DEBUG + this->glDisable(GL_TEXTURE_2D); + this->glBegin(GL_LINE_LOOP); + this->glColor4ub(0, 0, 255, 128); + this->glVertex2i(0,0); + this->glVertex2i(surface->w,0); + this->glVertex2i(surface->w,surface->h); + this->glVertex2i(0,surface->h); + this->glEnd(); + this->glEnable(GL_TEXTURE_2D); +#endif + if (this->screen->flags&SDL_DOUBLEBUF) + this->GL_SwapBuffers(this); + else + this->glFinish(); + return 0; +} + + +static void glSDL_UpdateRects(_THIS, int numrects, SDL_Rect *rects) +{ +#ifdef GLSDL_GRAPHICAL_DEBUG + int i; + this->glDisable(GL_TEXTURE_2D); + for(i=0;i<numrects;i++) + { + this->glColor4ub(255, 0, 0, 128); + this->glBegin(GL_LINE_LOOP); + this->glVertex2i(rects[i].x,rects[i].y); + this->glVertex2i(rects[i].x+rects[i].w,rects[i].y); + this->glVertex2i(rects[i].x+rects[i].w,rects[i].y+rects[i].h); + this->glVertex2i(rects[i].x,rects[i].y+rects[i].h); + this->glEnd(); + } + this->glEnable(GL_TEXTURE_2D); +#endif + if (this->screen->flags&SDL_DOUBLEBUF) + this->GL_SwapBuffers(this); + else + this->glFinish(); +} + + +static int glSDL_AllocHWSurface(_THIS, SDL_Surface *surface) +{ + surface->flags |= (SDL_HWSURFACE|SDL_HWACCEL); + + surface->pixels = SDL_malloc(surface->h*surface->pitch); + if ( surface->pixels == NULL ) { + SDL_FreeSurface(surface); + SDL_OutOfMemory(); + return(-1); + } + SDL_memset(surface->pixels, 0, surface->h*surface->pitch); + return 0; +} + + +static void glSDL_FreeHWSurface(_THIS, SDL_Surface *surface) +{ + if(!surface) + return; + glSDL_RemoveTexInfo(this, surface); +} + + +static int glSDL_LockHWSurface(_THIS, SDL_Surface *surface) +{ + int y; + + if(!surface) + return -1; + +#ifdef DEBUG_GLSDL + fprintf(stderr, "glSDL: Lock Surface.\n"); +#endif + + if(SDL_VideoSurface == surface) + { + glSDL_Invalidate(surface, NULL); + this->glPixelStorei(GL_UNPACK_ROW_LENGTH, + surface->pitch / + surface->format->BytesPerPixel); + this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h, + GL_RGB, + GL_UNSIGNED_BYTE, + OpenGL_Surface->pixels); + for(y = 0; y < OpenGL_Surface->h / 2; ++y) + { + void *upper = (Uint8 *)OpenGL_Surface->pixels + + OpenGL_Surface->pitch * y; + void *lower = (Uint8 *)OpenGL_Surface->pixels + + OpenGL_Surface->pitch * (OpenGL_Surface->h - y - 1); + SDL_memcpy(mirrorbuf, upper, OpenGL_Surface->pitch); + SDL_memcpy(upper, lower, OpenGL_Surface->pitch); + SDL_memcpy(lower, mirrorbuf, OpenGL_Surface->pitch); + } + /* the mapping has to be invalidated on 8bpp video surfaces in case of a hw palette change. + * Now if someone could tell me why this is not handled by SDL... */ + if (SDL_VideoSurface->format->BitsPerPixel==8) + SDL_InvalidateMap(OpenGL_Surface->map); + + /* convert this raw surface to the application-requested format + * FIXME this is sometimes overkill, we could use glPixelStore smartly + * But this would be slow anyway :) */ + + glSDL_SoftBlit(OpenGL_Surface, NULL, SDL_VideoSurface, NULL); + } + else + glSDL_Invalidate(surface, NULL); + + return 0; +} + + +static void glSDL_UnlockHWSurface(_THIS, SDL_Surface *surface) +{ + private_hwdata *txi; + + if(!surface) + return; + + /* upload this surface ONLY if this is a glSDL surface + * because sometimes (during displayformating for ex.) surfaces are unlocked that aren't glSDL + */ + if(!IS_GLSDL_SURFACE(surface)) + return; + +#ifdef DEBUG_GLSDL + fprintf(stderr, "glSDL: Unlock Surface.\n"); +#endif + + txi = glSDL_UploadSurface(this, surface); + + if(!txi) + { + GLERR("glSDL_UnlockHWSurface() failed to upload surface!"); + return; + } + if(txi->temporary) + { + GLERR("Weirdness... glSDL_UnlockHWSurface() got a temporary TexInfo."); + return; + } + if(surface == SDL_VideoSurface) + glSDL_BlitGL(this, SDL_VideoSurface, NULL, NULL); +} + + +static int glSDL_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) +{ + /* + * If an application does this *after* SDL_DisplayFormat, + * we're basically screwed, unless we want to do an + * in-place surface conversion hack here. + * + * What we do is just kill the glSDL texinfo... No big + * deal in most cases, as glSDL only converts once anyway, + * *unless* you keep modifying the surface. + */ + if(IS_GLSDL_SURFACE(surface)) + glSDL_RemoveTexInfo(this, surface); + return 0; +} + + +static int glSDL_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha) +{ + /* + * If an application does this *after* SDL_DisplayFormat, + * we're basically screwed, unless we want to do an + * in-place surface conversion hack here. + * + * What we do is just kill the glSDL texinfo... No big + * deal in most cases, as glSDL only converts once anyway, + * *unless* you keep modifying the surface. + */ + if(IS_GLSDL_SURFACE(surface)) + glSDL_RemoveTexInfo(this, surface); + return 0; +} + +static SDL_bool glSDL_SetClipRect(_THIS, SDL_Surface *surface, SDL_Rect *rect) +{ + SDL_bool res; + if(!surface) + return SDL_FALSE; + + res = SDL_SetClipRect(surface, rect); + if(!res) + return SDL_FALSE; + + rect = &surface->clip_rect; + + if(surface == SDL_VideoSurface) + { + SDL_Rect r; + float xscale, yscale; + private_hwdata *txi; + + r.x = rect->x; + r.y = rect->y; + r.w = rect->w; + r.h = rect->h; + SDL_SetClipRect(surface, rect); + + txi = glSDL_GetTexInfo(surface); + if(!txi) + return GLERET("SetClipRect(): Could not get TexInfo!"); + + this->glViewport(rect->x, + surface->h - (rect->y + rect->h), + rect->w, + rect->h); + /* + * Note that this projection is upside down in + * relation to the OpenGL coordinate system. + */ + this->glMatrixMode(GL_PROJECTION); + this->glLoadIdentity(); + xscale = (float)txi->lw / (float)surface->w; + yscale = (float)txi->lh / (float)surface->h; + this->glOrtho( xscale*(float)rect->x, + xscale*(float)(rect->w+rect->x), + yscale*(float)(rect->h+rect->y), + yscale*(float)rect->y, + -1.0, 1.0); + return SDL_TRUE; + } + return res; +} + +static int glSDL_BlitFromGL(_THIS, SDL_Rect *srcrect, + SDL_Surface *dst, SDL_Rect *dstrect) +{ + SDL_Rect sr, dr; + + /* In case the destination has an OpenGL texture... */ + glSDL_Invalidate(dst, dstrect); + + /* Abuse the fake screen buffer a little. */ + this->glPixelStorei(GL_UNPACK_ROW_LENGTH, SDL_VideoSurface->pitch / + SDL_VideoSurface->format->BytesPerPixel); + if(srcrect) + this->glReadPixels(srcrect->x, OpenGL_Surface->h - (srcrect->y + srcrect->h - 1), + srcrect->w, srcrect->h, + GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels); + else + this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h, + GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels); + sr = *srcrect; + dr = *dstrect; + glSDL_SoftBlit(OpenGL_Surface, &sr, dst, &dr); + return 0; +} + +static __inline__ void glSDL_BlitGL_single(_THIS, private_hwdata *txi, + float sx1, float sy1, SDL_Rect *dst, unsigned char alpha) +{ + float sx2, sy2, texscale; + if(!txi->textures) + return; + if(-1 == txi->texture[0]) + return; + glSDL_texture(this, txi->texture[0]); + + texscale = 1.0 / (float)txi->texsize; + sx2 = (sx1 + (float)dst->w) * texscale; + sy2 = (sy1 + (float)dst->h) * texscale; + sx1 *= texscale; + sy1 *= texscale; + +#ifdef GLSDL_GRAPHICAL_DEBUG + this->glDisable(GL_TEXTURE_2D); + this->glBegin(GL_LINE_LOOP); + this->glColor4ub(0, 255, 0, 128); + this->glVertex2i(dst->x, dst->y); + this->glVertex2i(dst->x + dst->w, dst->y); + this->glVertex2i(dst->x + dst->w, dst->y + dst->h); + this->glVertex2i(dst->x, dst->y + dst->h); + this->glEnd(); + this->glEnable(GL_TEXTURE_2D); +#endif + + this->glBegin(GL_TRIANGLE_FAN); + this->glColor4ub(255, 255, 255, alpha); + this->glTexCoord2f(sx1, sy1); + this->glVertex2i(dst->x, dst->y); + this->glTexCoord2f(sx2, sy1); + this->glVertex2i(dst->x + dst->w, dst->y); + this->glTexCoord2f(sx2, sy2); + this->glVertex2i(dst->x + dst->w, dst->y + dst->h); + this->glTexCoord2f(sx1, sy2); + this->glVertex2i(dst->x, dst->y + dst->h); + this->glEnd(); +} + + +static void glSDL_BlitGL_htile(_THIS, private_hwdata *txi, + float sx1, float sy1, SDL_Rect *dst, unsigned char alpha) +{ + int tex; + float tile, sx2, sy2, yo; + float texscale = 1.0 / (float)txi->texsize; + float tileh = (float)txi->tileh * texscale; + sx2 = (sx1 + (float)dst->w) * texscale; + sy2 = (sy1 + (float)dst->h) * texscale; + sx1 *= texscale; + sy1 *= texscale; + tile = floor(sx1); + tex = (int)tile / txi->tilespertex; + yo = ((int)tile % txi->tilespertex) * tileh; + + if(tex >= txi->textures) + return; + if(-1 == txi->texture[tex]) + return; + glSDL_texture(this, txi->texture[tex]); + + while(tile < sx2) + { + int tdx1 = dst->x; + int tdx2 = dst->x + dst->w; + float tsx1 = sx1 - tile; + float tsx2 = sx2 - tile; + + /* Clip to current tile */ + if(tsx1 < 0.0) + { + tdx1 -= tsx1 * txi->texsize; + tsx1 = 0.0; + } + if(tsx2 > 1.0) + { + tdx2 -= (tsx2 - 1.0) * txi->texsize; + tsx2 = 1.0; + } + + /* Maybe select next texture? */ + if(yo + tileh > 1.0) + { + ++tex; + if(tex >= txi->textures) + return; + if(-1 == txi->texture[tex]) + return; + glSDL_texture(this, txi->texture[tex]); + yo = 0.0; + } + +#ifdef GLSDL_GRAPHICAL_DEBUG + this->glDisable(GL_TEXTURE_2D); + this->glBegin(GL_LINE_LOOP); + this->glColor4ub(0, 255, 0, 128); + this->glVertex2i(tdx1, dst->y); + this->glVertex2i(tdx2, dst->y); + this->glVertex2i(tdx2, dst->y + dst->h); + this->glVertex2i(tdx1, dst->y + dst->h); + this->glEnd(); + this->glEnable(GL_TEXTURE_2D); +#endif + + this->glBegin(GL_TRIANGLE_FAN); + this->glColor4ub(255, 255, 255, alpha); + this->glTexCoord2f(tsx1, yo + sy1); + this->glVertex2i(tdx1, dst->y); + this->glTexCoord2f(tsx2, yo + sy1); + this->glVertex2i(tdx2, dst->y); + this->glTexCoord2f(tsx2, yo + sy2); + this->glVertex2i(tdx2, dst->y + dst->h); + this->glTexCoord2f(tsx1, yo + sy2); + this->glVertex2i(tdx1, dst->y + dst->h); + this->glEnd(); + tile += 1.0; + yo += tileh; + } +} + + +static void glSDL_BlitGL_vtile(_THIS, private_hwdata *txi, + float sx1, float sy1, SDL_Rect *dst, unsigned char alpha) +{ + int tex; + float tile, sx2, sy2, xo; + float texscale = 1.0 / (float)txi->texsize; + float tilew = (float)txi->tilew * texscale; + sx2 = (sx1 + (float)dst->w) * texscale; + sy2 = (sy1 + (float)dst->h) * texscale; + sx1 *= texscale; + sy1 *= texscale; + tile = floor(sy1); + tex = (int)tile / txi->tilespertex; + xo = ((int)tile % txi->tilespertex) * tilew; + + if(tex >= txi->textures) + return; + if(-1 == txi->texture[tex]) + return; + glSDL_texture(this, txi->texture[tex]); + + while(tile < sy2) + { + int tdy1 = dst->y; + int tdy2 = dst->y + dst->h; + float tsy1 = sy1 - tile; + float tsy2 = sy2 - tile; + + /* Clip to current tile */ + if(tsy1 < 0.0) + { + tdy1 -= tsy1 * txi->texsize; + tsy1 = 0.0; + } + if(tsy2 > 1.0) + { + tdy2 -= (tsy2 - 1.0) * txi->texsize; + tsy2 = 1.0; + } + + /* Maybe select next texture? */ + if(xo + tilew > 1.0) + { + ++tex; + if(tex >= txi->textures) + return; + if(-1 == txi->texture[tex]) + return; + glSDL_texture(this, txi->texture[tex]); + xo = 0.0; + } + +#ifdef GLSDL_GRAPHICAL_DEBUG + this->glDisable(GL_TEXTURE_2D); + this->glBegin(GL_LINE_LOOP); + this->glColor4ub(0, 255, 0, 128); + this->glVertex2i(dst->x, tdy1); + this->glVertex2i(dst->x + dst->w, tdy1); + this->glVertex2i(dst->x + dst->w, tdy2); + this->glVertex2i(dst->x, tdy2); + this->glEnd(); + this->glEnable(GL_TEXTURE_2D); +#endif + + this->glBegin(GL_TRIANGLE_FAN); + this->glColor4ub(255, 255, 255, alpha); + this->glTexCoord2f(xo + sx1, tsy1); + this->glVertex2i(dst->x, tdy1); + this->glTexCoord2f(xo + sx2, tsy1); + this->glVertex2i(dst->x + dst->w, tdy1); + this->glTexCoord2f(xo + sx2, tsy2); + this->glVertex2i(dst->x + dst->w, tdy2); + this->glTexCoord2f(xo + sx1, tsy2); + this->glVertex2i(dst->x, tdy2); + this->glEnd(); + + tile += 1.0; + xo += tilew; + } +} + + +static void glSDL_BlitGL_hvtile(_THIS, SDL_Surface *src, private_hwdata *txi, + float sx1, float sy1, SDL_Rect *dst, unsigned char alpha) +{ + int x, y, last_tex, tex; + float sx2, sy2; + float texscale = 1.0 / (float)txi->texsize; + int tilesperrow = (src->w + txi->tilew - 1) / txi->tilew; + sx2 = (sx1 + (float)dst->w) * texscale; + sy2 = (sy1 + (float)dst->h) * texscale; + sx1 *= texscale; + sy1 *= texscale; + + last_tex = tex = floor(sy1) * tilesperrow + floor(sx1); + if(tex >= txi->textures) + return; + if(-1 == txi->texture[tex]) + return; + glSDL_texture(this, txi->texture[tex]); + + for(y = floor(sy1); y < sy2; ++y) + { + int tdy1 = dst->y; + int tdy2 = dst->y + dst->h; + float tsy1 = sy1 - y; + float tsy2 = sy2 - y; + + /* Clip to current tile */ + if(tsy1 < 0.0) + { + tdy1 -= tsy1 * txi->texsize; + tsy1 = 0.0; + } + if(tsy2 > 1.0) + { + tdy2 -= (tsy2 - 1.0) * txi->texsize; + tsy2 = 1.0; + } + for(x = floor(sx1); x < sx2; ++x) + { + int tdx1 = dst->x; + int tdx2 = dst->x + dst->w; + float tsx1 = sx1 - x; + float tsx2 = sx2 - x; + + /* Clip to current tile */ + if(tsx1 < 0.0) + { + tdx1 -= tsx1 * txi->texsize; + tsx1 = 0.0; + } + if(tsx2 > 1.0) + { + tdx2 -= (tsx2 - 1.0) * txi->texsize; + tsx2 = 1.0; + } + + /* Select texture */ + tex = y * tilesperrow + x; + if(tex != last_tex) + { + if(tex >= txi->textures) + return; + if(-1 == txi->texture[tex]) + return; + glSDL_texture(this, txi->texture[tex]); + last_tex = tex; + } + +#ifdef GLSDL_GRAPHICAL_DEBUG + this->glDisable(GL_TEXTURE_2D); + this->glBegin(GL_LINE_LOOP); + this->glColor4ub(0, 255, 0, 128); + this->glVertex2i(tdx1, tdy1); + this->glVertex2i(tdx2, tdy1); + this->glVertex2i(tdx2, tdy2); + this->glVertex2i(tdx1, tdy2); + this->glEnd(); + this->glEnable(GL_TEXTURE_2D); +#endif + + this->glBegin(GL_TRIANGLE_FAN); + this->glColor4ub(255, 255, 255, alpha); + this->glTexCoord2f(tsx1, tsy1); + this->glVertex2i(tdx1, tdy1); + this->glTexCoord2f(tsx2, tsy1); + this->glVertex2i(tdx2, tdy1); + this->glTexCoord2f(tsx2, tsy2); + this->glVertex2i(tdx2, tdy2); + this->glTexCoord2f(tsx1, tsy2); + this->glVertex2i(tdx1, tdy2); + this->glEnd(); + } + } +} + +/* + * Calculate the actual blit rectangle and source offset + * for a blit from a rectangle in a surface with specified + * size to a surface with a cliprect. + * + * In: rect source rectangle + * w, h source surface size + * (x, y) destination coordinate + * clip destination clip rectangle + * + * Out: (x, y) source top-left offset + * rect destination rectangle + * + * Returns 1 if the result is visible, otherwise 0. + */ +static __inline__ int blitclip(SDL_Rect *rect, int w, int h, + int *x, int *y, SDL_Rect *clip) +{ + int sx1, sy1, sx2, sy2; + int dx1, dy1, dx2, dy2; + + /* Get source and destination coordinates */ + sx1 = rect->x; + sy1 = rect->y; + sx2 = sx1 + rect->w; + sy2 = sy1 + rect->h; + dx1 = *x; + dy1 = *y; + + /* Keep source rect inside source surface */ + if(sx1 < 0) + { + dx1 -= sx1; + sx1 = 0; + } + if(sy1 < 0) + { + dy1 -= sy1; + sy1 = 0; + } + if(sx2 > w) + sx2 = w; + if(sy2 > h) + sy2 = h; + + /* Cull blits from void space */ + if(sx1 >= sx2 || sy1 >= sy2) + return 0; + + /* Calculate destination lower-right */ + dx2 = dx1 + (sx2 - sx1); + dy2 = dy1 + (sy2 - sy1); + + /* Clip to destination cliprect */ + if(dx1 < clip->x) + { + sx1 += clip->x - dx1; + dx1 = clip->x; + } + if(dy1 < clip->y) + { + sy1 += clip->y - dy1; + dy1 = clip->y; + } + if(dx2 > clip->x + clip->w) + dx2 = clip->x + clip->w; + if(dy2 > clip->y + clip->h) + dy2 = clip->y + clip->h; + + /* Cull nop/off-screen blits */ + if(dx1 >= dx2 || dy1 >= dy2) + return 0; + + *x = sx1; + *y = sy1; + rect->x = dx1; + rect->y = dy1; + rect->w = dx2 - dx1; + rect->h = dy2 - dy1; + return 1; +} + +static int glSDL_BlitGL(_THIS, SDL_Surface *src, + SDL_Rect *srcrect, SDL_Rect *dstrect) +{ + private_hwdata *txi; + float x1, y1; + unsigned char alpha; + SDL_Rect d; + int x, y; + SDL_Rect r; + + if(!src) + return GLERET("BlitGL(): No src surface!"); + + /* Get source and destination coordinates */ + if(srcrect) + r = *srcrect; + else + { + r.x = r.y = 0; + r.w = src->w; + r.h = src->h; + } + if(dstrect) + { + x = dstrect->x; + y = dstrect->y; + } + else + x = y = 0; + + /* Clip! */ + if(!blitclip(&r, src->w, src->h, &x, &y, &this->screen->clip_rect)) + { + if(dstrect) + dstrect->w = dstrect->h = 0; + return 0; + } + + /* Write back the resulting cliprect */ + if(dstrect) + *dstrect = r; + + /* Make sure we have a source with a valid texture */ + txi = glSDL_UploadSurface(this, src); + if(!txi) + return GLERET("BlitGL(): Could not get a TexInfo!"); + + /* Set up blending */ + if(src->flags & (SDL_SRCALPHA | SDL_SRCCOLORKEY)) + { + glSDL_blendfunc(this, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glSDL_do_blend(this, 1); + } + else + glSDL_do_blend(this, 0); + + /* Enable texturing */ + glSDL_do_texture(this, 1); + + /* Calculate texcoords */ + if(!srcrect) + srcrect = &txi->virt; + x1 = (float)srcrect->x; + y1 = (float)srcrect->y; + + /* Calculate screen coords. */ + if(dstrect) + { + d.x = dstrect->x; + d.y = dstrect->y; + d.w = (int)(srcrect->w * (float)txi->lw / (float)txi->virt.w); + d.h = (int)(srcrect->h * (float)txi->lh / (float)txi->virt.h); + } + else + { + d.x = 0; + d.y = 0; + d.w = (int)(srcrect->w * (float)txi->lw / (float)txi->virt.w); + d.h = (int)(srcrect->h * (float)txi->lh / (float)txi->virt.h); + } + + /* + * Note that we actually *prevent* the use of "full surface alpha" + * and alpha channel in combination - to stay SDL 2D compatible. + */ + if ((src->flags & SDL_SRCALPHA)&&(src->format->Amask)) + alpha = 255; + else + alpha = src->format->alpha; + + /* Render! */ + switch(txi->tilemode) + { + case GLSDL_TM_SINGLE: + glSDL_BlitGL_single(this, txi, x1, y1, + &d, + alpha); + break; + case GLSDL_TM_HORIZONTAL: + glSDL_BlitGL_htile(this, txi, x1, y1, + &d, + alpha); + break; + case GLSDL_TM_VERTICAL: + glSDL_BlitGL_vtile(this, txi, x1, y1, + &d, + alpha); + break; + case GLSDL_TM_HUGE: + glSDL_BlitGL_hvtile(this, src, txi, x1, y1, + &d, + alpha); + break; + } + + if(txi->temporary) + glSDL_FreeTexInfo(this, txi); + + return 0; +} + + +static int glSDL_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, + SDL_Surface *dst, SDL_Rect *dstrect) +{ + SDL_Surface *vs; + + if(!src) + return GLERET("HWAccelBlit(): No src surface!"); + if(!dst) + return GLERET("HWAccelBlit(): No dst surface!"); + + /* + * Figure out what to do: + * screen->screen: glSDL_BlitFromGL() + glSDL_BlitGL() + * surface->screen: glSDL_BlitGL() + * screen->surface: glSDL_BlitFromGL() + * surface->surface: glSDL_SoftBlit() + */ + vs = SDL_VideoSurface; + if(src == vs) + { + if(dst == vs) + { + /* +FIXME: Try glCopyPixels() instead... + */ + glSDL_BlitFromGL(current_video, srcrect, vs, dstrect); + return glSDL_BlitGL(current_video, vs, + srcrect, dstrect); + } + else + { + return glSDL_BlitFromGL(current_video, srcrect, + dst, dstrect); + } + } + else + { + if(dst == vs) + { + return glSDL_BlitGL(current_video, src, + srcrect, dstrect); + } + else + { + glSDL_Invalidate(dst, dstrect); + glSDL_SoftBlit(src, srcrect, dst, dstrect); + return 0; + } + } +} + + +static int glSDL_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color) +{ + SDL_Surface *vs = SDL_VideoSurface; + int dx1, dy1, dx2, dy2; + Uint32 r, g, b; + Uint8 br,bg,bb; + + /* + * Some ugly reverse conversion for compatibility... + * (We must do this before losing the dst pointer, + * as the pixel formats of the screen and + * SDL_VideoSurface may differ!) + */ + + if (dst->format->palette) + { + /* this a paletted color */ + SDL_GetRGB(color,dst->format,&br,&bg,&bb); + } + else + { + /* this a RGB color */ + r = color & dst->format->Rmask; + r = r >> dst->format->Rshift; + r = r << dst->format->Rloss; + br = r; + + g = color & dst->format->Gmask; + g = g >> dst->format->Gshift; + g = g << dst->format->Gloss; + bg = g; + + b = color & dst->format->Bmask; + b = b >> dst->format->Bshift; + b = b << dst->format->Bloss; + bb = b; + } + + if(vs != dst) + { + /* draw a rect offscreen */ + glSDL_Invalidate(dst, dstrect); + /* software-fill the surface by faking it as a SW_SURFACE */ + dst->flags&=~SDL_HWSURFACE; + SDL_FillRect(dst,dstrect,color); + dst->flags|=SDL_HWSURFACE; + } + else + { + /* draw a rect onscreen */ + glSDL_do_texture(this, 0); + glSDL_do_blend(this, 0); + + dx1 = dstrect->x; + dy1 = dstrect->y; + dx2 = dx1 + dstrect->w; + dy2 = dy1 + dstrect->h; + + this->glBegin(GL_TRIANGLE_FAN); + this->glColor3ub(br, bg, bb); + this->glVertex2i(dx1, dy1); + this->glVertex2i(dx2, dy1); + this->glVertex2i(dx2, dy2); + this->glVertex2i(dx1, dy2); + this->glEnd(); + } + return 0; +} + +static int glSDL_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst) +{ + src->flags |= SDL_HWACCEL; + src->map->hw_blit = glSDL_HWAccelBlit; + return 1; +} + + +static SDL_Surface *glSDL_DisplayFormat(SDL_Surface *surface) +{ + SDL_Surface *tmp; + int use_rgba = (surface->flags & SDL_SRCCOLORKEY) || + ((surface->flags & SDL_SRCALPHA) && + surface->format->Amask); +#ifdef DEBUG_GLSDL + fprintf(stderr,"#### glSDL_DisplayFormat()\n"); +#endif + if(use_rgba) + tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE); + else + tmp = glSDL_ConvertSurface(surface, RGBfmt, SDL_SWSURFACE); + if(!tmp) + { + GLERR("glSDL_DisplayFormat() could not convert surface!"); + return NULL; + } + SDL_SetAlpha(tmp, 0, 0); + + if(surface->flags & SDL_SRCCOLORKEY) + { + /* + * We drop colorkey data here, but we have to, + * or we'll run into trouble when converting, + * in particular from indexed color formats. + */ + SDL_SetColorKey(tmp, SDL_SRCCOLORKEY, + surface->format->colorkey); + glSDL_key2alpha(tmp); + SDL_SetColorKey(tmp, 0, 0); + } + + return tmp; +} + + +static SDL_Surface *glSDL_DisplayFormatAlpha(SDL_Surface *surface) +{ + SDL_Surface *s, *tmp; + tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE); +#ifdef DEBUG_GLSDL + fprintf(stderr,"#### glSDL_DisplayFormatAlpha()\n"); +#endif + if(!tmp) + return NULL; + + SDL_SetAlpha(tmp, 0, 0); + SDL_SetColorKey(tmp, 0, 0); + s = glSDL_CreateRGBASurface(surface->w, surface->h); + if(!s) + { + SDL_FreeSurface(tmp); + return NULL; + } + glSDL_SoftBlit(tmp, NULL, s, NULL); + SDL_FreeSurface(tmp); + + if(surface->flags & SDL_SRCCOLORKEY) + { + SDL_SetColorKey(s, SDL_SRCCOLORKEY, + surface->format->colorkey); + glSDL_key2alpha(s); + SDL_SetColorKey(s, 0, 0); + } + + if(surface->flags & SDL_SRCALPHA) + SDL_SetAlpha(s, SDL_SRCALPHA, + surface->format->alpha); + return s; +} + + +/*---------------------------------------------------------- + glSDL specific API extensions + ----------------------------------------------------------*/ + +static void glSDL_Invalidate(SDL_Surface *surface, SDL_Rect *area) +{ + private_hwdata *txi; + if(!surface) + return; + txi = glSDL_GetTexInfo(surface); + if(!txi) + return; + if(!area) + { + txi->invalid_area.x = 0; + txi->invalid_area.y = 0; + txi->invalid_area.w = surface->w; + txi->invalid_area.h = surface->h; + return; + } + txi->invalid_area = *area; +} + + +static void glSDL_SetLogicSize(_THIS, SDL_Surface *surface, int w, int h) +{ + SDL_Rect r; + private_hwdata *txi; + if(!IS_GLSDL_SURFACE(surface)) + return; + + txi = glSDL_GetTexInfo(surface); + + txi->lw = w; + txi->lh = h; + + if(SDL_VideoSurface != surface) + return; + + r.x = r.y = 0; + r.w = w; + r.h = h; + glSDL_SetClipRect(this, surface, &r); + + this->glMatrixMode(GL_MODELVIEW); + this->glLoadIdentity(); + this->glTranslated(0.0f, 0.0f, 0.0f); + + this->glDisable(GL_DEPTH_TEST); + this->glDisable(GL_CULL_FACE); + + glSDL_reset(); +} + +static int glSDL_InitTexture(_THIS, SDL_Surface *datasurf, private_hwdata *txi, int tex) +{ + this->glGenTextures(1, (GLuint *)&txi->texture[tex]); + this->glBindTexture(GL_TEXTURE_2D, txi->texture[tex]); + glstate.texture = txi->texture[tex]; + this->glPixelStorei(GL_UNPACK_ROW_LENGTH, datasurf->pitch / + datasurf->format->BytesPerPixel); + this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + this->glTexImage2D(GL_TEXTURE_2D, 0, + datasurf->format->Amask ? GL_RGBA8 : GL_RGB8, + txi->texsize, txi->texsize, 0, + datasurf->format->Amask ? GL_RGBA : GL_RGB, + GL_UNSIGNED_BYTE, NULL); +#ifdef DEBUG_GLSDL + glSDL_print_glerror(this, 1); +#endif + return 0; +} + + +/* Image tiled horizontally (wide surface), or not at all */ +static int glSDL_UploadHoriz(_THIS, SDL_Surface *datasurf, private_hwdata *txi) +{ + int bpp = datasurf->format->BytesPerPixel; + int res; + int tex = 0; + int fromx = 0; + int toy = txi->texsize; /* To init first texture */ + while(1) + { + int thistw = datasurf->w - fromx; + if(thistw > txi->tilew) + thistw = txi->tilew; + else if(thistw <= 0) + break; + if(toy + txi->tileh > txi->texsize) + { + toy = 0; + res = glSDL_InitTexture(this, datasurf, txi, tex); + if(res < 0) + return res; + ++tex; + } + this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, toy, + thistw, txi->tileh, + datasurf->format->Amask ? GL_RGBA : GL_RGB, + GL_UNSIGNED_BYTE, + (char *)datasurf->pixels + bpp * fromx); +#ifdef DEBUG_GLSDL + glSDL_print_glerror(this, 2); +#endif + fromx += txi->tilew; + toy += txi->tileh; + } + return 0; +} + + +/* Image tiled vertically (tall surface) */ +static int glSDL_UploadVert(_THIS, SDL_Surface *datasurf, private_hwdata *txi) +{ + int res; + int tex = 0; + int fromy = 0; + int tox = txi->texsize; /* To init first texture */ + while(1) + { + int thisth = datasurf->h - fromy; + if(thisth > txi->tileh) + thisth = txi->tileh; + else if(thisth <= 0) + break; + if(tox + txi->tilew > txi->texsize) + { + tox = 0; + res = glSDL_InitTexture(this, datasurf, txi, tex); + if(res < 0) + return res; + ++tex; + } + this->glTexSubImage2D(GL_TEXTURE_2D, 0, tox, 0, + txi->tilew, thisth, + datasurf->format->Amask ? GL_RGBA : GL_RGB, + GL_UNSIGNED_BYTE, + (char *)datasurf->pixels + datasurf->pitch * fromy); +#ifdef DEBUG_GLSDL + glSDL_print_glerror(this, 3); +#endif + fromy += txi->tileh; + tox += txi->tilew; + } + return 0; +} + + +/* Image tiled two-way (huge surface) */ +static int glSDL_UploadHuge(_THIS, SDL_Surface *datasurf, private_hwdata *txi) +{ + int bpp = datasurf->format->BytesPerPixel; + int res; + int tex = 0; + int y = 0; + while(y < datasurf->h) + { + int x; + int thisth = datasurf->h - y; + if(thisth > txi->tileh) + thisth = txi->tileh; + x = 0; + while(x < datasurf->w) + { + int thistw = datasurf->w - x; + if(thistw > txi->tilew) + thistw = txi->tilew; + res = glSDL_InitTexture(this, datasurf, txi, tex++); + if(res < 0) + return res; + this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, + thistw, thisth, + datasurf->format->Amask ? GL_RGBA : GL_RGB, + GL_UNSIGNED_BYTE, + (char *)datasurf->pixels + + datasurf->pitch * y + bpp * x); +#ifdef DEBUG_GLSDL + fprintf(stderr,"glTexSubImage(x = %d, y = %d, w = %d, h = %d)\n", + x, y, thistw, thisth); + glSDL_print_glerror(this, 4); +#endif + x += txi->tilew; + } + y += txi->tileh; + } + return 0; +} + + +/* Upload all textures for a surface. */ +static int glSDL_UploadTextures(_THIS, SDL_Surface *datasurf, private_hwdata *txi) +{ + switch(txi->tilemode) + { + case GLSDL_TM_SINGLE: + case GLSDL_TM_HORIZONTAL: + glSDL_UploadHoriz(this, datasurf, txi); + break; + case GLSDL_TM_VERTICAL: + glSDL_UploadVert(this, datasurf, txi); + break; + case GLSDL_TM_HUGE: + glSDL_UploadHuge(this, datasurf, txi); + break; + } + return 0; +} + + +/* + * IMPORTANT: + * This function will try various ways of giving you + * a TexInfo, and will succeed most of the time. + * + * However, the TexInfo returned may be temporary, + * (as opposed to connected to 'surface'). A temporary + * TexInfo must be used only once and then thrown away, + * since it means that glSDL cannot track changes in + * the pixel data of 'texture'. + */ +static private_hwdata *glSDL_UploadSurface(_THIS, SDL_Surface *surface) +{ + int i; + int converted = 0; + private_hwdata *txi = glSDL_GetTexInfo(surface); + + if(IS_GLSDL_SURFACE(surface)) + { + /* + * Ok, this is a glSDL surface, and it *might* be + * in texture memory already. If so, it may need + * an update. + */ + if(txi->invalid_area.w) + { + glSDL_UnloadTexture(this, txi); + } + else + { + int missing = 0; + if(txi->textures) + { + for(i = 0; i < txi->textures; ++i) + if(GLSDL_NOTEX == txi->texture[i]) + { + missing = 1; + break; + } + if(!missing) + return txi; /* They're already there! */ + } + } + } + else + { + /* + * Nope, this isn't (yet) a glSDL surface. Let's + * try to either make it one, or set up a temporary + * TexInfo for it, valid for only one blit. + */ + if( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) + { + txi = glSDL_AddTexInfo(this, surface); + if(!txi) + { + GLERR("UploadSurface(): Could not add TexInfo!"); + return NULL; + } + surface->flags |= SDL_HWSURFACE; + surface->flags |= SDL_HWACCEL; + } + else + { + /* + * FIXME + * here if the surface is small enough, it's a good + * candidate for a blit using glDrawPixels instead + * of a texture blit + */ + txi = glSDL_CreateTempTexInfo(this, surface); + if(!txi) + { + GLERR("UploadSurface(): Could not create temp TexInfo!"); + return NULL; + } + } + } + + if(txi->texsize > maxtexsize) + { + /* This surface wasn't tiled properly... */ + if(txi->temporary) + glSDL_FreeTexInfo(this, txi); + GLERR("UploadSurface(): Too large texture!"); + return NULL; + } + + /* + * Kludge: Convert if not of preferred RGB or RGBA format. + * + * Conversion should only be done when *really* needed. + * That is, it should rarely have to be done with OpenGL + * 1.2+. + * + * Besides, any surface that's been SDL_DisplayFormat()ed + * should already be in the best known OpenGL format - + * preferably one that makes DMA w/o conversion possible. + */ + if(!glSDL_FormatIsOk(surface)) + { +#ifdef DEBUG_GLSDL + fprintf(stderr, "glSDL: WARNING: On-the-fly conversion performed!\n"); +#endif + converted = 1; + /* NOTE: We forget about the original surface here. */ + if(surface->format->Amask) + surface = glSDL_DisplayFormatAlpha(surface); + else + surface = glSDL_DisplayFormat(surface); + if(!surface) + { + GLERR("UploadSurface(): Could not convert surface!"); + if(txi->temporary) + glSDL_FreeTexInfo(this, txi); + return NULL; + } + } + + glSDL_UploadTextures(this, surface, txi); + + if(converted) + SDL_FreeSurface(surface); + + return txi; +} + + +static void glSDL_UnloadTexture(_THIS, private_hwdata *txi) +{ + int i; + for(i = 0; i < txi->textures; ++i) + if(txi->texture[i] != GLSDL_NOTEX) + this->glDeleteTextures(1, &txi->texture[i]); + SDL_memset(&txi->invalid_area, 0, sizeof(txi->invalid_area)); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/video/glsdl/SDL_glsdl.h Mon May 01 06:58:33 2006 +0000 @@ -0,0 +1,38 @@ +/* + 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> + */ + +#ifndef _SDL_gl_h +#define _SDL_gl_h + +#include "../SDL_sysvideo.h" + +/* Hidden "this" pointer for the video functions */ +#define _THIS SDL_VideoDevice *this + +#endif /* _SDL_gl_h */
--- a/src/video/maccommon/SDL_macevents.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/maccommon/SDL_macevents.c Mon May 01 06:58:33 2006 +0000 @@ -382,7 +382,7 @@ case updateEvt: { BeginUpdate(SDL_Window); #if SDL_VIDEO_OPENGL - if (SDL_VideoSurface->flags & SDL_OPENGL) + if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) SDL_GL_SwapBuffers(); else #endif
--- a/src/video/macdsp/SDL_dspvideo.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/macdsp/SDL_dspvideo.c Mon May 01 06:58:33 2006 +0000 @@ -722,7 +722,7 @@ { - if ( current->flags & SDL_OPENGL ) { + if ( current->flags & SDL_INTERNALOPENGL ) { Mac_GL_Quit (this); } @@ -918,14 +918,14 @@ } - if ( (current->flags & SDL_HWSURFACE) || (current->flags & SDL_OPENGL) ) + if ( (current->flags & SDL_HWSURFACE) || (current->flags & SDL_INTERNALOPENGL) ) DSpContext_SetVBLProc (dsp_context, DSp_VBLProc, NULL); #endif if (bpp == 8) current->flags |= SDL_HWPALETTE; - if (flags & SDL_OPENGL) { + if (flags & SDL_INTERNALOPENGL) { Rect rect; RGBColor rgb = { 0.0, 0.0, 0.0 }; @@ -960,7 +960,7 @@ return NULL; } - current->flags |= SDL_OPENGL; + current->flags |= SDL_INTERNALOPENGL; } return current;
--- a/src/video/macrom/SDL_romvideo.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/macrom/SDL_romvideo.c Mon May 01 06:58:33 2006 +0000 @@ -583,9 +583,9 @@ SelectWindow(SDL_Window); /* Handle OpenGL support */ - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { if ( Mac_GL_Init(this) == 0 ) { - current->flags |= SDL_OPENGL; + current->flags |= SDL_INTERNALOPENGL; } else { current = NULL; }
--- a/src/video/photon/SDL_ph_image.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/photon/SDL_ph_image.c Mon May 01 06:58:33 2006 +0000 @@ -315,7 +315,7 @@ if (ph_SetupOpenGLContext(this, screen->w, screen->h, screen->format->BitsPerPixel, screen->flags)!=0) { - screen->flags &= ~SDL_OPENGL; + screen->flags &= ~SDL_INTERNALOPENGL; return -1; } @@ -328,7 +328,7 @@ { #if SDL_VIDEO_OPENGL - if ((screen->flags & SDL_OPENGL)==SDL_OPENGL) + if (screen->flags & SDL_INTERNALOPENGL) { if (oglctx) { @@ -486,7 +486,7 @@ ph_DestroyImage(this, screen); #if SDL_VIDEO_OPENGL - if ((flags & SDL_OPENGL)==SDL_OPENGL) + if (flags & SDL_INTERNALOPENGL) { setupresult=ph_SetupOpenGLImage(this, screen); }
--- a/src/video/photon/SDL_ph_modes.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/photon/SDL_ph_modes.c Mon May 01 06:58:33 2006 +0000 @@ -309,7 +309,7 @@ if (this->screen) { - if ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL) + if (this->screen->flags & SDL_INTERNALOPENGL) { #if !SDL_VIDEO_OPENGL || (_NTO_VERSION < 630) return 0; /* 6.3.0 */ @@ -345,7 +345,7 @@ if (currently_fullscreen) { - if ((this->screen) && ((this->screen->flags & SDL_OPENGL)==SDL_OPENGL)) + if ((this->screen) && (this->screen->flags & SDL_INTERNALOPENGL)) { #if !SDL_VIDEO_OPENGL || (_NTO_VERSION < 630) return 0;
--- a/src/video/photon/SDL_ph_mouse.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/photon/SDL_ph_mouse.c Mon May 01 06:58:33 2006 +0000 @@ -126,10 +126,10 @@ } /* looks like photon can't draw mouse cursor in direct mode */ - if ((this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) + if (this->screen->flags & SDL_FULLSCREEN) { /* disable the fake mouse in the fullscreen OpenGL mode */ - if ((this->screen->flags & SDL_OPENGL) == SDL_OPENGL) + if (this->screen->flags & SDL_INTERNALOPENGL) { cursor=NULL; }
--- a/src/video/photon/SDL_ph_video.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/photon/SDL_ph_video.c Mon May 01 06:58:33 2006 +0000 @@ -475,12 +475,12 @@ return NULL; } - if ((current->flags & SDL_OPENGL)==SDL_OPENGL) + if (current->flags & SDL_INTERNALOPENGL) { #if !SDL_VIDEO_OPENGL /* if no built-in OpenGL support */ SDL_SetError("ph_SetVideoMode(): no OpenGL support, you need to recompile SDL.\n"); - current->flags &= ~SDL_OPENGL; + current->flags &= ~SDL_INTERNALOPENGL; return NULL; #endif /* SDL_VIDEO_OPENGL */ }
--- a/src/video/qtopia/SDL_sysvideo.cc Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/qtopia/SDL_sysvideo.cc Mon May 01 06:58:33 2006 +0000 @@ -296,7 +296,7 @@ } else { SDL_SetError("Unsupported resolution, %dx%d\n", width, height); } - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { SDL_SetError("OpenGL not supported"); return(NULL); }
--- a/src/video/quartz/SDL_QuartzVideo.m Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/quartz/SDL_QuartzVideo.m Mon May 01 06:58:33 2006 +0000 @@ -379,7 +379,7 @@ Release the OpenGL context Do this first to avoid trash on the display before fade */ - if ( mode_flags & SDL_OPENGL ) { + if ( mode_flags & SDL_INTERNALOPENGL ) { QZ_TearDownOpenGL (this); CGLSetFullScreen (NULL); @@ -406,7 +406,7 @@ window_view = nil; /* Release the OpenGL context */ - if ( mode_flags & SDL_OPENGL ) + if ( mode_flags & SDL_INTERNALOPENGL ) QZ_TearDownOpenGL (this); } @@ -512,7 +512,7 @@ current->flags |= SDL_HWPALETTE; /* Setup OpenGL for a fullscreen context */ - if (flags & SDL_OPENGL) { + if (flags & SDL_INTERNALOPENGL) { CGLError err; CGLContextObj ctx; @@ -535,7 +535,7 @@ [ gl_context flushBuffer ]; - current->flags |= SDL_OPENGL; + current->flags |= SDL_INTERNALOPENGL; } /* If we don't hide menu bar, it will get events and interrupt the program */ @@ -609,8 +609,8 @@ QZ_UnsetVideoMode (this, TRUE); } else if ( ((mode_flags ^ flags) & (SDL_NOFRAME|SDL_RESIZABLE)) || - (mode_flags & SDL_OPENGL) || - (flags & SDL_OPENGL) ) { + (mode_flags & SDL_INTERNALOPENGL) || + (flags & SDL_INTERNALOPENGL) ) { QZ_UnsetVideoMode (this, TRUE); } } @@ -708,7 +708,7 @@ } /* For OpenGL, we bind the context to a subview */ - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { if ( ! QZ_SetupOpenGL (this, *bpp, flags) ) { if (fade_token != kCGDisplayFadeReservationInvalidToken) { @@ -725,7 +725,7 @@ [ window_view release ]; [ gl_context makeCurrentContext]; [ qz_window makeKeyAndOrderFront:nil ]; - current->flags |= SDL_OPENGL; + current->flags |= SDL_INTERNALOPENGL; } /* For 2D, we set the subview to an NSQuickDrawView */ else {
--- a/src/video/quartz/SDL_QuartzWM.m Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/quartz/SDL_QuartzWM.m Mon May 01 06:58:33 2006 +0000 @@ -147,7 +147,7 @@ *p = [ window_view convertPoint:*p toView: nil ]; /* We need a workaround in OpenGL mode */ - if ( SDL_VideoSurface->flags & SDL_OPENGL ) { + if ( SDL_VideoSurface->flags & SDL_INTERNALOPENGL ) { p->y = [window_view frame].size.height - p->y; } } @@ -165,7 +165,7 @@ *p = [ window_view convertPoint:*p fromView: nil ]; /* We need a workaround in OpenGL mode */ - if ( SDL_VideoSurface != NULL && (SDL_VideoSurface->flags & SDL_OPENGL) ) { + if ( SDL_VideoSurface != NULL && (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) ) { p->y = [window_view frame].size.height - p->y; } }
--- a/src/video/quartz/SDL_QuartzWindow.m Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/quartz/SDL_QuartzWindow.m Mon May 01 06:58:33 2006 +0000 @@ -55,7 +55,7 @@ /* we override these methods to fix the miniaturize animation/dock icon bug */ - (void)miniaturize:(id)sender { - if (SDL_VideoSurface->flags & SDL_OPENGL) { + if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) { /* Future: Grab framebuffer and put into NSImage @@ -86,7 +86,7 @@ SDL_VideoDevice *this = (SDL_VideoDevice*)current_video; /* make sure pixels are fully opaque */ - if (! ( SDL_VideoSurface->flags & SDL_OPENGL ) ) + if (! ( SDL_VideoSurface->flags & SDL_INTERNALOPENGL ) ) QZ_SetPortAlphaOpaque (); /* save current visible SDL surface */ @@ -126,7 +126,7 @@ SDL_PrivateResize (newViewFrame.size.width, newViewFrame.size.height); /* If not OpenGL, we have to update the pixels and pitch */ - if ( ! ( SDL_VideoSurface->flags & SDL_OPENGL ) ) { + if ( ! ( SDL_VideoSurface->flags & SDL_INTERNALOPENGL ) ) { CGrafPtr thePort = [ window_view qdPort ]; LockPortBits ( thePort ); @@ -164,7 +164,7 @@ if ( this ) { /* make sure pixels are fully opaque */ - if (! ( SDL_VideoSurface->flags & SDL_OPENGL ) ) + if (! ( SDL_VideoSurface->flags & SDL_INTERNALOPENGL ) ) QZ_SetPortAlphaOpaque (); /* save current visible SDL surface */
--- a/src/video/wincommon/SDL_lowvideo.h Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/wincommon/SDL_lowvideo.h Mon May 01 06:58:33 2006 +0000 @@ -51,17 +51,17 @@ #define WINDIB_FULLSCREEN() \ ( \ SDL_VideoSurface && \ - ((SDL_VideoSurface->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) && \ - (((SDL_VideoSurface->flags & SDL_OPENGL ) == SDL_OPENGL ) || \ - ((SDL_strcmp(this->name, "windib") == 0) || \ - (SDL_strcmp(this->name, "gapi") == 0))) \ + (SDL_VideoSurface->flags & SDL_FULLSCREEN) && \ + ((SDL_VideoSurface->flags & SDL_INTERNALOPENGL) || \ + ((SDL_strcmp(this->name, "windib") == 0) || \ + (SDL_strcmp(this->name, "gapi") == 0))) \ ) #define DDRAW_FULLSCREEN() \ ( \ SDL_VideoSurface && \ - ((SDL_VideoSurface->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) && \ - ((SDL_VideoSurface->flags & SDL_OPENGL ) != SDL_OPENGL ) && \ - (SDL_strcmp(this->name, "directx") == 0) \ + (SDL_VideoSurface->flags & SDL_FULLSCREEN) && \ + (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) && \ + (SDL_strcmp(this->name, "directx") == 0) \ ) #define DINPUT_FULLSCREEN() DDRAW_FULLSCREEN()
--- a/src/video/wincommon/SDL_sysevents.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/wincommon/SDL_sysevents.c Mon May 01 06:58:33 2006 +0000 @@ -684,7 +684,7 @@ hdc = BeginPaint(SDL_Window, &ps); if ( current_video->screen && - !(current_video->screen->flags & SDL_OPENGL) ) { + !(current_video->screen->flags & SDL_INTERNALOPENGL) ) { WIN_WinPAINT(current_video, hdc); } EndPaint(SDL_Window, &ps);
--- a/src/video/windib/SDL_dibvideo.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/windib/SDL_dibvideo.c Mon May 01 06:58:33 2006 +0000 @@ -484,7 +484,7 @@ Uint32 Rmask, Gmask, Bmask; /* Clean up any GL context that may be hanging around */ - if ( current->flags & SDL_OPENGL ) { + if ( current->flags & SDL_INTERNALOPENGL ) { WIN_GL_ShutDown(this); } SDL_resizing = 1; @@ -686,7 +686,7 @@ if ( screen_bmp != NULL ) { DeleteObject(screen_bmp); } - if ( ! (flags & SDL_OPENGL) ) { + if ( ! (flags & SDL_INTERNALOPENGL) ) { BOOL is16bitmode = (video->format->BytesPerPixel == 2); /* Suss out the bitmap info header */ @@ -814,11 +814,11 @@ SDL_resizing = 0; /* Set up for OpenGL */ - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { if ( WIN_GL_SetupWindow(this) < 0 ) { return(NULL); } - video->flags |= SDL_OPENGL; + video->flags |= SDL_INTERNALOPENGL; } /* JC 14 Mar 2006 @@ -1035,7 +1035,7 @@ ShowWindow(SDL_Window, SW_HIDE); } #endif - if ( this->screen->flags & SDL_OPENGL ) { + if ( this->screen->flags & SDL_INTERNALOPENGL ) { WIN_GL_ShutDown(this); } this->screen->pixels = NULL;
--- a/src/video/windx5/SDL_dx5events.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/windx5/SDL_dx5events.c Mon May 01 06:58:33 2006 +0000 @@ -299,7 +299,7 @@ } /* If we are in windowed mode, Windows is taking care of the mouse */ - if ( (SDL_PublicSurface->flags & SDL_OPENGL) || + if ( (SDL_PublicSurface->flags & SDL_INTERNALOPENGL) || !(SDL_PublicSurface->flags & SDL_FULLSCREEN) ) { return; }
--- a/src/video/windx5/SDL_dx5video.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/windx5/SDL_dx5video.c Mon May 01 06:58:33 2006 +0000 @@ -1031,19 +1031,19 @@ #ifndef NO_CHANGEDISPLAYSETTINGS /* Unset any previous OpenGL fullscreen mode */ - if ( (current->flags & (SDL_OPENGL|SDL_FULLSCREEN)) == - (SDL_OPENGL|SDL_FULLSCREEN) ) { + if ( (current->flags & (SDL_INTERNALOPENGL|SDL_FULLSCREEN)) == + (SDL_INTERNALOPENGL|SDL_FULLSCREEN) ) { ChangeDisplaySettings(NULL, 0); } #endif /* Clean up any GL context that may be hanging around */ - if ( current->flags & SDL_OPENGL ) { + if ( current->flags & SDL_INTERNALOPENGL ) { WIN_GL_ShutDown(this); } /* If we are setting a GL mode, use GDI, not DirectX (yuck) */ - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { Uint32 Rmask, Gmask, Bmask; /* Recalculate the bitmasks if necessary */ @@ -1215,7 +1215,7 @@ if ( WIN_GL_SetupWindow(this) < 0 ) { return(NULL); } - video->flags |= SDL_OPENGL; + video->flags |= SDL_INTERNALOPENGL; return(video); } @@ -2361,13 +2361,13 @@ /* If we're fullscreen GL, we need to reset the display */ if ( this->screen != NULL ) { #ifndef NO_CHANGEDISPLAYSETTINGS - if ( (this->screen->flags & (SDL_OPENGL|SDL_FULLSCREEN)) == - (SDL_OPENGL|SDL_FULLSCREEN) ) { + if ( (this->screen->flags & (SDL_INTERNALOPENGL|SDL_FULLSCREEN)) == + (SDL_INTERNALOPENGL|SDL_FULLSCREEN) ) { ChangeDisplaySettings(NULL, 0); ShowWindow(SDL_Window, SW_HIDE); } #endif - if ( this->screen->flags & SDL_OPENGL ) { + if ( this->screen->flags & SDL_INTERNALOPENGL ) { WIN_GL_ShutDown(this); } }
--- a/src/video/x11/SDL_x11events.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/x11/SDL_x11events.c Mon May 01 06:58:33 2006 +0000 @@ -562,7 +562,7 @@ } } else { /* OpenGL windows need to know about the change */ - if ( SDL_VideoSurface->flags & SDL_OPENGL ) { + if ( SDL_VideoSurface->flags & SDL_INTERNALOPENGL ) { SDL_PrivateExpose(); } }
--- a/src/video/x11/SDL_x11image.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/x11/SDL_x11image.c Mon May 01 06:58:33 2006 +0000 @@ -185,7 +185,7 @@ int retval; X11_DestroyImage(this, screen); - if ( flags & SDL_OPENGL ) { /* No image when using GL */ + if ( flags & SDL_INTERNALOPENGL ) { /* No image when using GL */ retval = 0; } else { retval = X11_SetupImage(this, screen);
--- a/src/video/x11/SDL_x11modes.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/x11/SDL_x11modes.c Mon May 01 06:58:33 2006 +0000 @@ -914,7 +914,7 @@ /* We may need to refresh the screen at this point (no backing store) We also don't get an event, which is why we explicitly refresh. */ if ( this->screen ) { - if ( this->screen->flags & SDL_OPENGL ) { + if ( this->screen->flags & SDL_INTERNALOPENGL ) { SDL_PrivateExpose(); } else { X11_RefreshDisplay(this); @@ -976,7 +976,7 @@ /* We may need to refresh the screen at this point (no backing store) We also don't get an event, which is why we explicitly refresh. */ if ( this->screen ) { - if ( this->screen->flags & SDL_OPENGL ) { + if ( this->screen->flags & SDL_INTERNALOPENGL ) { SDL_PrivateExpose(); } else { X11_RefreshDisplay(this);
--- a/src/video/x11/SDL_x11video.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/x11/SDL_x11video.c Mon May 01 06:58:33 2006 +0000 @@ -585,7 +585,7 @@ { /* Clean up OpenGL */ if ( screen ) { - screen->flags &= ~SDL_OPENGL; + screen->flags &= ~SDL_INTERNALOPENGL; } X11_GL_Shutdown(this); @@ -791,7 +791,7 @@ } /* find out which visual we are going to use */ - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { XVisualInfo *vi; vi = X11_GL_GetVisual(this); @@ -904,7 +904,7 @@ /* Create (or use) the X11 display window */ if ( !SDL_windowid ) { - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { if ( X11_GL_CreateWindow(this, w, h) < 0 ) { return(-1); } @@ -927,11 +927,11 @@ | PointerMotionMask | ExposureMask )); } /* Create the graphics context here, once we have a window */ - if ( flags & SDL_OPENGL ) { + if ( flags & SDL_INTERNALOPENGL ) { if ( X11_GL_CreateContext(this) < 0 ) { return(-1); } else { - screen->flags |= SDL_OPENGL; + screen->flags |= SDL_INTERNALOPENGL; } } else { XGCValues gcv; @@ -946,7 +946,7 @@ } /* Set our colormaps when not setting a GL mode */ - if ( ! (flags & SDL_OPENGL) ) { + if ( ! (flags & SDL_INTERNALOPENGL) ) { XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); if( !SDL_windowid ) { XSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap); @@ -1063,7 +1063,7 @@ /* Set up the X11 window */ saved_flags = current->flags; - if ( (SDL_Window) && ((saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL)) + if ( (SDL_Window) && ((saved_flags&SDL_INTERNALOPENGL) == (flags&SDL_INTERNALOPENGL)) && (bpp == current->format->BitsPerPixel) && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) { if (X11_ResizeWindow(this, current, width, height, flags) < 0) { @@ -1079,7 +1079,7 @@ /* Set up the new mode framebuffer */ if ( ((current->w != width) || (current->h != height)) || - ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) { + ((saved_flags&SDL_INTERNALOPENGL) != (flags&SDL_INTERNALOPENGL)) ) { current->w = width; current->h = height; current->pitch = SDL_CalculatePitch(current);
--- a/src/video/xbios/SDL_xbios.c Fri Apr 28 16:55:41 2006 +0000 +++ b/src/video/xbios/SDL_xbios.c Mon May 01 06:58:33 2006 +0000 @@ -574,7 +574,7 @@ XBIOS_screens[0]=(void *) (( (long) XBIOS_screensmem[0]+256) & 0xFFFFFF00UL); #if SDL_VIDEO_OPENGL - if (flags & SDL_OPENGL) { + if (flags & SDL_INTERNALOPENGL) { if (this->gl_config.double_buffer) { flags |= SDL_DOUBLEBUF; } @@ -618,14 +618,14 @@ XBIOS_fbnum = 0; #if SDL_VIDEO_OPENGL - if (flags & SDL_OPENGL) { + if (flags & SDL_INTERNALOPENGL) { if (!SDL_AtariGL_Init(this, current)) { XBIOS_FreeBuffers(this); SDL_SetError("Can not create OpenGL context"); return NULL; } - modeflags |= SDL_OPENGL; + modeflags |= SDL_INTERNALOPENGL; } #endif
--- a/test/testblitspeed.c Fri Apr 28 16:55:41 2006 +0000 +++ b/test/testblitspeed.c Mon May 01 06:58:33 2006 +0000 @@ -116,7 +116,6 @@ append_sdl_surface_flag(surface, f, sizeof (f), SDL_DOUBLEBUF); append_sdl_surface_flag(surface, f, sizeof (f), SDL_FULLSCREEN); append_sdl_surface_flag(surface, f, sizeof (f), SDL_OPENGL); - append_sdl_surface_flag(surface, f, sizeof (f), SDL_OPENGLBLIT); append_sdl_surface_flag(surface, f, sizeof (f), SDL_RESIZABLE); append_sdl_surface_flag(surface, f, sizeof (f), SDL_NOFRAME); append_sdl_surface_flag(surface, f, sizeof (f), SDL_HWACCEL);