Mercurial > sdl-ios-xcode

comparison src/video/glsdl/SDL_glsdl.c @ 1658:e49147870aac SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
glSDL support
author Sam Lantinga <slouken@libsdl.org>
date Mon, 01 May 2006 06:58:33 +0000
parents
children 782fd950bd46
comparison
equal deleted inserted replaced
1657:5b0805ceb50f 1658:e49147870aac
1 /*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2006 Sam Lantinga
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19 Sam Lantinga
20 slouken@libsdl.org
21 */
22 #include "SDL_config.h"
23
24 /*
25 * glSDL "SDL-over-OpenGL" video driver implemented by
26 * David Olofson <david@olofson.net> and
27 * Stephane Marchesin <stephane.marchesin@wanadoo.fr>
28 */
29 #include <math.h>
30
31 #include "SDL.h"
32 #include "SDL_error.h"
33 #include "SDL_video.h"
34 #include "SDL_mouse.h"
35 #include "../SDL_sysvideo.h"
36 #include "../SDL_pixels_c.h"
37
38 #include "SDL_glsdl.h"
39
40 #undef DEBUG_GLSDL
41 #undef DEBUG_GLSDL_CHOP
42 #define FAKE_MAXTEXSIZE 256
43 #undef GLSDL_GRAPHICAL_DEBUG
44
45 /* Initialization/Query functions */
46
47 /* Hardware surface functions */
48 static int glSDL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
49 static int glSDL_AllocHWSurface(_THIS, SDL_Surface *surface);
50 static int glSDL_LockHWSurface(_THIS, SDL_Surface *surface);
51 static int glSDL_FlipHWSurface(_THIS, SDL_Surface *surface);
52 static void glSDL_UnlockHWSurface(_THIS, SDL_Surface *surface);
53 static void glSDL_FreeHWSurface(_THIS, SDL_Surface *surface);
54 static int glSDL_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);
55 static int glSDL_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst);
56 static int glSDL_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key);
57 static int glSDL_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha);
58 static int glSDL_VideoInit(_THIS, SDL_PixelFormat *vformat);
59 static SDL_Rect **glSDL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
60 static void glSDL_VideoQuit(_THIS);
61 static void glSDL_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
62 static SDL_Surface* glSDL_SetVideoMode(_THIS, SDL_Surface *current,int width, int height, int bpp, Uint32 flags);
63
64 #define IS_GLSDL_SURFACE(s) ((s) && glSDL_GetTexInfo(s))
65
66 #define LOGIC_W(s) ( IS_GLSDL_SURFACE(this,s) ? TEXINFO(s)->lw : (s)->w )
67 #define LOGIC_H(s) ( IS_GLSDL_SURFACE(this,s) ? TEXINFO(s)->lh : (s)->h )
68
69 #define GLSDL_NOTEX (~0)
70
71 /*
72 * Special version for glSDL, which ignores the fake SDL_HWSURFACE
73 * flags, so we don't have SDL calling us back whenever we want to
74 * do some internal blitting...
75 */
76 static void glSDL_SoftBlit(SDL_Surface *src, SDL_Rect *srcrect,
77 SDL_Surface *dst, SDL_Rect *dstrect)
78 {
79 SDL_BlitInfo info;
80
81 if(srcrect)
82 if(!srcrect->w || !srcrect->h)
83 return;
84
85 /* Check to make sure the blit mapping is valid */
86 if ( (src->map->dst != dst) ||
87 (src->map->dst->format_version !=
88 src->map->format_version) )
89 if ( SDL_MapSurface(src, dst) < 0 )
90 return;
91
92 /* Set up the blit information */
93 if(srcrect)
94 {
95 info.s_pixels = (Uint8 *) src->pixels +
96 (Uint16) srcrect->y * src->pitch +
97 (Uint16) srcrect->x * src->format->BytesPerPixel;
98 info.s_width = srcrect->w;
99 info.s_height = srcrect->h;
100 }
101 else
102 {
103 info.s_pixels = (Uint8 *) src->pixels;
104 info.s_width = src->w;
105 info.s_height = src->h;
106 }
107 info.s_skip = src->pitch - info.s_width * src->format->BytesPerPixel;
108 if(dstrect)
109 {
110 info.d_pixels = (Uint8 *) dst->pixels +
111 (Uint16) dstrect->y * dst->pitch +
112 (Uint16) dstrect->x * dst->format->BytesPerPixel;
113 /*
114 * NOTE: SDL_SoftBlit() uses the 'dstrect' for this!
115 * This version is more like SDL_BlitSurface().
116 */
117 info.d_width = srcrect->w;
118 info.d_height = srcrect->h;
119 }
120 else
121 {
122 info.d_pixels = (Uint8 *) dst->pixels;
123 info.d_width = dst->w;
124 info.d_height = dst->h;
125 }
126 info.d_skip = dst->pitch - info.d_width * dst->format->BytesPerPixel;
127 info.aux_data = src->map->sw_data->aux_data;
128 info.src = src->format;
129 info.table = src->map->table;
130 info.dst = dst->format;
131
132 src->map->sw_data->blit(&info);
133 }
134
135
136 /*
137 * Another special version. Doesn't lock/unlock, and doesn't mess
138 * with flags and stuff. It just converts the surface, period.
139 * Does not convert into palletized formats.
140 */
141 static SDL_Surface *glSDL_ConvertSurface (SDL_Surface *surface,
142 SDL_PixelFormat *format, Uint32 flags)
143 {
144 SDL_Surface *convert;
145 Uint32 colorkey = 0;
146 Uint8 alpha = 0;
147 Uint32 surface_flags;
148 SDL_Rect bounds;
149
150 /* Create a new surface with the desired format */
151 convert = SDL_CreateRGBSurface(flags,
152 surface->w, surface->h, format->BitsPerPixel,
153 format->Rmask, format->Gmask, format->Bmask, format->Amask);
154 if ( convert == NULL ) {
155 return(NULL);
156 }
157
158 /* Save the original surface color key and alpha */
159 surface_flags = surface->flags;
160 if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
161 /* Convert colourkeyed surfaces to RGBA if requested */
162 if((flags & SDL_SRCCOLORKEY) != SDL_SRCCOLORKEY
163 && format->Amask) {
164 surface_flags &= ~SDL_SRCCOLORKEY;
165 } else {
166 colorkey = surface->format->colorkey;
167 SDL_SetColorKey(surface, 0, 0);
168 }
169 }
170 if ( (surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
171 /* Copy over the alpha channel to RGBA if requested */
172 if ( format->Amask ) {
173 surface->flags &= ~SDL_SRCALPHA;
174 } else {
175 alpha = surface->format->alpha;
176 SDL_SetAlpha(surface, 0, 0);
177 }
178 }
179
180 /* Copy over the image data */
181 bounds.x = 0;
182 bounds.y = 0;
183 bounds.w = surface->w;
184 bounds.h = surface->h;
185 glSDL_SoftBlit(surface, &bounds, convert, &bounds);
186
187 /* Clean up the original surface, and update converted surface */
188 if ( convert != NULL ) {
189 SDL_SetClipRect(convert, &surface->clip_rect);
190 }
191 if ( (surface_flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
192 Uint32 cflags = surface_flags&(SDL_SRCCOLORKEY|SDL_RLEACCELOK);
193 if ( convert != NULL ) {
194 Uint8 keyR, keyG, keyB;
195
196 SDL_GetRGB(colorkey,surface->format,&keyR,&keyG,&keyB);
197 SDL_SetColorKey(convert, cflags|(flags&SDL_RLEACCELOK),
198 SDL_MapRGB(convert->format, keyR, keyG, keyB));
199 }
200 SDL_SetColorKey(surface, cflags, colorkey);
201 }
202 if ( (surface_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
203 Uint32 aflags = surface_flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
204 if ( convert != NULL ) {
205 SDL_SetAlpha(convert, aflags|(flags&SDL_RLEACCELOK),
206 alpha);
207 }
208 if ( format->Amask ) {
209 surface->flags |= SDL_SRCALPHA;
210 } else {
211 SDL_SetAlpha(surface, aflags, alpha);
212 }
213 }
214
215 /* We're ready to go! */
216 return(convert);
217 }
218
219
220 /*----------------------------------------------------------
221 Some OpenGL function wrappers
222 ----------------------------------------------------------*/
223
224 static struct
225 {
226 int do_blend;
227 int do_texture;
228 GLuint texture;
229 GLenum sfactor, dfactor;
230 } glstate;
231
232 static void glSDL_reset(void)
233 {
234 glstate.do_blend = -1;
235 glstate.do_blend = -1;
236 glstate.texture = GLSDL_NOTEX;
237 glstate.sfactor = 0xffffffff;
238 glstate.dfactor = 0xffffffff;
239 }
240
241 static __inline__ void glSDL_do_blend(_THIS, int on)
242 {
243 if(glstate.do_blend == on)
244 return;
245
246 if(on)
247 this->glEnable(GL_BLEND);
248 else
249 this->glDisable(GL_BLEND);
250 glstate.do_blend = on;
251 }
252
253 static __inline__ void glSDL_do_texture(_THIS, int on)
254 {
255 if(glstate.do_texture == on)
256 return;
257
258 if(on)
259 this->glEnable(GL_TEXTURE_2D);
260 else
261 this->glDisable(GL_TEXTURE_2D);
262 glstate.do_texture = on;
263 }
264
265 static __inline__ void glSDL_blendfunc(_THIS, GLenum sfactor, GLenum dfactor)
266 {
267 if((sfactor == glstate.sfactor) && (dfactor == glstate.dfactor))
268 return;
269
270 this->glBlendFunc(sfactor, dfactor);
271
272 glstate.sfactor = sfactor;
273 glstate.dfactor = dfactor;
274 }
275
276 static __inline__ void glSDL_texture(_THIS, GLuint tx)
277 {
278 if(tx == glstate.texture)
279 return;
280
281 this->glBindTexture(GL_TEXTURE_2D, tx);
282 glstate.texture = tx;
283 }
284
285
286
287
288 /*----------------------------------------------------------
289 glSDL specific data types
290 ----------------------------------------------------------*/
291
292 typedef enum
293 {
294 GLSDL_TM_SINGLE,
295 GLSDL_TM_HORIZONTAL,
296 GLSDL_TM_VERTICAL,
297 GLSDL_TM_HUGE
298 } GLSDL_TileModes;
299
300
301 typedef struct private_hwdata
302 {
303 /* Size of surface in logic screen pixels */
304 int lw, lh;
305
306 int textures;
307 GLuint *texture;
308 int texsize; /* width/height of OpenGL texture */
309 GLSDL_TileModes tilemode;
310 int tilew, tileh; /* At least one must equal texsize! */
311 int tilespertex;
312 SDL_Rect virt; /* Total size of assembled surface */
313
314 /* Area of surface to upload when/after unlocking */
315 SDL_Rect invalid_area;
316
317 int temporary; /* Throw away after one use. */
318
319 SDL_Surface* next; /* The next Surface in our linked list of hardware surfaces ; == NULL if first surface */
320 SDL_Surface* prev; /* The prev Surface in our linked list of hardware surfaces ; == NULL if last surface */
321 } private_hwdata;
322
323 /* some function prototypes */
324 static void glSDL_Invalidate(SDL_Surface *surface, SDL_Rect *area);
325 static void glSDL_SetLogicSize(_THIS, SDL_Surface *surface, int w, int h);
326 static private_hwdata *glSDL_UploadSurface(_THIS, SDL_Surface *surface);
327 static private_hwdata *glSDL_GetTexInfo(SDL_Surface *surface);
328 static void glSDL_init_formats(_THIS);
329 static private_hwdata *glSDL_AddTexInfo(_THIS, SDL_Surface *surface);
330 static void glSDL_RemoveTexInfo(_THIS, SDL_Surface *surface);
331 static void glSDL_UnloadTexture(_THIS, private_hwdata *txi);
332 static int glSDL_BlitGL(_THIS, SDL_Surface *src,
333 SDL_Rect *srcrect, SDL_Rect *dstrect);
334
335 /* some variables */
336 static GLint maxtexsize = -1;
337 static SDL_PixelFormat *RGBfmt = NULL;
338 static SDL_PixelFormat *RGBAfmt = NULL;
339 static void *mirrorbuf = NULL;
340 /* the raw 888 opengl surface, hidden from the application */
341 SDL_Surface* OpenGL_Surface;
342
343 /* pointer to the beggining of the list used for memory allocation */
344 SDL_Surface* first = NULL;
345
346 #ifdef DEBUG_GLSDL
347 static __inline__ int GLERET(const char *txt)
348 {
349 fprintf(stderr, "glSDL ERROR: '%s'\n", txt);
350 return -1;
351 }
352 static __inline__ void GLERR(const char *txt)
353 {
354 fprintf(stderr, "glSDL ERROR: '%s'\n", txt);
355 }
356 #else
357 #define GLERET(x) (-1)
358 #define GLERR(x)
359 #endif
360
361 static SDL_VideoDevice underlying_device;
362 static int old_screen_flags;
363
364 /*
365 * List of video drivers known to support OpenGL
366 * The purpose of this is to make glSDL "portable" across
367 * all video backends that support OpenGL
368 */
369 static VideoBootStrap *opengl_bootstrap =
370 #if SDL_VIDEO_DRIVER_QUARTZ
371 &QZ_bootstrap;
372 #elif SDL_VIDEO_DRIVER_X11
373 &X11_bootstrap;
374 #elif SDL_VIDEO_DRIVER_WINDIB
375 &WINDIB_bootstrap;
376 #elif SDL_VIDEO_DRIVER_BWINDOW
377 &BWINDOW_bootstrap;
378 #elif SDL_VIDEO_DRIVER_TOOLBOX
379 &TOOLBOX_bootstrap;
380 #elif SDL_VIDEO_DRIVER_CYBERGRAPHICS
381 &CGX_bootstrap;
382 #elif SDL_VIDEO_DRIVER_PHOTON
383 &ph_bootstrap;
384 #elif SDL_VIDEO_DRIVER_DC
385 &DC_bootstrap;
386 #else
387 NULL;
388 #endif
389
390 static int glSDL_Available(void)
391 {
392 #ifdef DEBUG_GLSDL
393 fprintf(stderr,"available\n");
394 #endif
395 if (opengl_bootstrap==NULL)
396 return 0;
397 return (opengl_bootstrap->available());
398 }
399
400 static void glSDL_DeleteDevice(SDL_VideoDevice *device)
401 {
402 SDL_free(device->hidden);
403 SDL_free(device);
404 }
405
406 /* Create a glSDL device */
407 static SDL_VideoDevice* glSDL_CreateDevice(int devindex)
408 {
409 SDL_VideoDevice *device;
410 #ifdef DEBUG_GLSDL
411 fprintf(stderr,"entering createdevice\n");
412 #endif
413
414 /* Create the device with the underlying driver */
415 device = opengl_bootstrap->create(devindex);
416
417 /* Save the video device contents for future use */
418 SDL_memcpy(&underlying_device,device,sizeof(SDL_VideoDevice));
419
420 /* Hook glSDL on the video device */
421 device->VideoInit = glSDL_VideoInit;
422 device->ListModes = glSDL_ListModes;
423 device->VideoQuit = glSDL_VideoQuit;
424 device->UpdateRects = glSDL_UpdateRects;
425 device->FillHWRect = glSDL_FillHWRect;
426 device->SetHWColorKey = glSDL_SetHWColorKey;
427 device->SetHWAlpha = glSDL_SetHWAlpha;
428 device->AllocHWSurface = glSDL_AllocHWSurface;
429 device->LockHWSurface = glSDL_LockHWSurface;
430 device->UnlockHWSurface = glSDL_UnlockHWSurface;
431 device->FlipHWSurface = glSDL_FlipHWSurface;
432 device->FreeHWSurface = glSDL_FreeHWSurface;
433 device->CheckHWBlit = glSDL_CheckHWBlit;
434 device->SetColors = glSDL_SetColors;
435 device->SetVideoMode = glSDL_SetVideoMode;
436 device->info.hw_available=1;
437 device->info.blit_hw=1;
438 device->info.blit_hw_CC=1;
439 device->info.blit_hw_A=1;
440 device->info.blit_sw=1;
441 device->info.blit_sw_CC=1;
442 device->info.blit_sw_A=1;
443 device->info.blit_fill=1;
444
445 /* These functions are not supported by glSDL, so we NULLify them */
446 device->SetGamma = NULL;
447 device->GetGamma = NULL;
448 device->SetGammaRamp = NULL;
449 device->GetGammaRamp = NULL;
450 device->ToggleFullScreen = NULL;
451
452 device->free = glSDL_DeleteDevice;
453
454 #ifdef DEBUG_GLSDL
455 fprintf(stderr,"leaving createdevice\n");
456 #endif
457
458 return device;
459 }
460
461 /* Our bootstraping structure */
462 VideoBootStrap glSDL_bootstrap = {
463 "glSDL", "glSDL - SDL over OpenGL",
464 glSDL_Available, glSDL_CreateDevice
465 };
466
467 static int glSDL_VideoInit(_THIS, SDL_PixelFormat *vformat)
468 {
469 int r;
470 printf("glSDL videoinit\n");
471 #ifdef DEBUG_GLSDL
472 fprintf(stderr,"videoinit\n");
473 #endif
474 r=underlying_device.VideoInit(this,vformat);
475 this->info.hw_available=1;
476 this->info.blit_hw=1;
477 this->info.blit_hw_CC=1;
478 this->info.blit_hw_A=1;
479 this->info.blit_sw=1;
480 this->info.blit_sw_CC=1;
481 this->info.blit_sw_A=1;
482 this->info.blit_fill=1;
483
484 return r;
485 }
486
487 SDL_Rect **glSDL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
488 {
489 return((SDL_Rect **)-1);
490 }
491
492 static void glSDL_VideoQuit(_THIS)
493 {
494 SDL_Surface* scr;
495
496 /* free all hwdata structures */
497 while(first!=NULL)
498 glSDL_RemoveTexInfo(this, first);
499
500 SDL_free(mirrorbuf);
501 mirrorbuf = NULL;
502
503 SDL_FreeFormat(RGBfmt);
504 SDL_FreeFormat(RGBAfmt);
505 RGBfmt = RGBAfmt = NULL;
506
507 SDL_FreeFormat(this->displayformatalphapixel);
508 this->displayformatalphapixel = NULL;
509
510 SDL_FreeSurface(OpenGL_Surface);
511 OpenGL_Surface = NULL;
512
513 /* restore the flags to gracefully exit from fullscreen */
514 this->screen->flags = old_screen_flags;
515
516 /* keep the screen */
517 scr=this->screen;
518
519 /* we cleaned up our stuff, now restore the underlying video driver */
520 SDL_memcpy(this,&underlying_device,sizeof(SDL_VideoDevice));
521
522 this->screen=scr;
523
524 /* call the underlying video driver's VideoQuit function */
525 this->VideoQuit(this);
526 }
527
528 static SDL_Surface* glSDL_SetVideoMode(_THIS, SDL_Surface *current,int width, int height, int bpp, Uint32 flags)
529 {
530 SDL_Surface* hooked_screen;
531 int i;
532 int flag_doublebuf=0;
533
534 if (opengl_bootstrap==NULL)
535 {
536 GLERR("No bootstrap for glSDL compiled in !\n");
537 return NULL;
538 }
539
540 /* we don't have OpenGL */
541 if ((flags&SDL_INTERNALOPENGL)==SDL_INTERNALOPENGL)
542 {
543 GLERR("OpenGL video modes are not supported by glSDL !\n");
544 return(NULL);
545 }
546
547 /*
548 * Adjust the flags
549 */
550 flags &= ~SDL_HWPALETTE;
551 flags |= SDL_INTERNALOPENGL;
552
553 /* remember whether the user requested DOUBLEBUF */
554
555 if (flags&SDL_DOUBLEBUF)
556 {
557 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
558 flag_doublebuf=1;
559 }
560 else
561 {
562 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,0);
563 flag_doublebuf=0;
564 }
565
566 hooked_screen = underlying_device.SetVideoMode(this,current,width,height,0,flags);
567
568 if (!hooked_screen)
569 {
570 GLERR("Unable to open an OpenGL window !\n");
571 return(NULL);
572 }
573
574 /* save the screen flags for restore time */
575 old_screen_flags = hooked_screen->flags;
576
577 #ifdef DEBUG_GLSDL
578 fprintf(stderr,"got %d bpp\n",bpp);
579 #endif
580
581 /* setup the public surface format
582 * glSDL always returns the bpp its asked
583 */
584 switch(bpp)
585 {
586 case 32:
587 this->is_32bit = 1;
588 this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
589 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
590 0x00FF0000,
591 0x0000FF00,
592 0x000000FF,
593 0x00000000
594 #else
595 0x0000FF00,
596 0x00FF0000,
597 0xFF000000,
598 0x00000000
599 #endif
600 );
601 break;
602 case 24:
603 this->is_32bit = 0;
604 this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
605 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
606 0x00FF0000,
607 0x0000FF00,
608 0x000000FF,
609 0x00000000
610 #else
611 0x0000FF00,
612 0x00FF0000,
613 0xFF000000,
614 0x00000000
615 #endif
616 );
617 break;
618 case 16:
619 this->is_32bit = 0;
620 this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
621 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
622 0x0000F800,
623 0x000007E0,
624 0x0000001F,
625 0x00000000
626 #else
627 0x0000001F,
628 0x000007E0,
629 0x0000F800,
630 0x00000000
631 #endif
632 );
633 break;
634 case 15:
635 this->is_32bit = 0;
636 this->screen = SDL_CreateRGBSurface(flags, width, height, bpp,
637 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
638 0x00007C00,
639 0x000003E0,
640 0x0000001F,
641 0x00000000
642 #else
643 0x0000001F,
644 0x000003E0,
645 0x00007C00,
646 0x00000000
647 #endif
648 );
649 break;
650 case 8:
651 default:
652 this->is_32bit = 0;
653 this->screen = SDL_CreateRGBSurface(flags, width, height, bpp, 0, 0, 0, 0);
654 /* give it a default palette if 8 bpp
655 * note : SDL already takes care of the palette for 4 bits & 1 bit surfaces
656 */
657 /* if (bpp==8)
658 {
659 this->screen->format->palette->ncolors=255;
660 SDL_DitherColors(this->screen->format->palette->colors,bpp);
661 }*/
662 break;
663 }
664
665 /* also, we add SDL_HWSURFACE all the time, and let SDL create a shadow surface accordingly */
666 this->screen->flags = hooked_screen->flags | SDL_HWSURFACE | SDL_INTERNALOPENGL;
667 /* add SDL_DOUBLEBUF if it was requested */
668 if (flag_doublebuf)
669 this->screen->flags|=SDL_DOUBLEBUF;
670
671 /* Tell SDL the alpha pixel format we'd like to have */
672 this->displayformatalphapixel = SDL_AllocFormat(32,
673 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
674 0xFF000000,
675 0x00FF0000,
676 0x0000FF00,
677 0x000000FF
678 #else
679 0x000000FF,
680 0x0000FF00,
681 0x00FF0000,
682 0xFF000000
683 #endif
684 );
685
686 /* Now create the raw OpenGL surface */
687 OpenGL_Surface = SDL_CreateRGBSurface(flags, width, height, 24,
688 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
689 0x000000FF,
690 0x0000FF00,
691 0x00FF0000,
692 0x00000000
693 #else
694 0xFF000000,
695 0x00FF0000,
696 0x0000FF00,
697 0x00000000
698 #endif
699 );
700
701 /* Here we have to setup OpenGL funcs ourselves */
702 #ifndef __QNXNTO__
703 #define SDL_PROC(ret,func,params) \
704 do { \
705 this->func = SDL_GL_GetProcAddress(#func); \
706 if ( ! this->func ) { \
707 SDL_SetError("Couldn't load GL function: %s\n", #func); \
708 return(NULL); \
709 } \
710 } while ( 0 );
711 #else
712 #define SDL_PROC(ret,func,params) this->func=func;
713 #endif /* __QNXNTO__ */
714 #include "../SDL_glfuncs.h"
715 #undef SDL_PROC
716
717 if ( this->GL_MakeCurrent(this) < 0 )
718 return(NULL);
719 #define SDL_PROC(ret,func,params) \
720 do { \
721 this->func = SDL_GL_GetProcAddress(#func); \
722 if ( ! this->func ) { \
723 SDL_SetError("Couldn't load GL function: %s\n", #func); \
724 return(NULL); \
725 } \
726 } while ( 0 );
727 #include "../SDL_glfuncs.h"
728 #undef SDL_PROC
729
730
731 #ifdef FAKE_MAXTEXSIZE
732 maxtexsize = FAKE_MAXTEXSIZE;
733 #else
734 this->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);
735 #endif
736 #ifdef DEBUG_GLSDL
737 fprintf(stderr, "glSDL: Max texture size: %d\n", maxtexsize);
738 #endif
739
740 glSDL_init_formats(this);
741
742 if (flag_doublebuf)
743 this->glDrawBuffer(GL_BACK);
744 else
745 this->glDrawBuffer(GL_FRONT);
746
747 this->glDisable(GL_DITHER);
748
749 if(glSDL_AddTexInfo(this, this->screen) < 0)
750 {
751 GLERR("HookDevice() failed to add info to screen surface!");
752 return NULL;
753 }
754
755 glSDL_SetLogicSize(this, this->screen,
756 this->screen->w, this->screen->h);
757
758 glSDL_do_texture(this, 0);
759 glSDL_do_blend(this, 0);
760
761 for(i = 0; i < 1+flag_doublebuf; ++i)
762 {
763 this->glBegin(GL_TRIANGLE_FAN);
764 this->glColor3ub(0, 0, 0);
765 this->glVertex2i(0, 0);
766 this->glVertex2i(this->screen->w, 0);
767 this->glVertex2i(this->screen->w, this->screen->h);
768 this->glVertex2i(0, this->screen->h);
769 this->glEnd();
770 if(!i)
771 this->GL_SwapBuffers(this);
772 }
773
774 mirrorbuf = SDL_malloc(this->screen->h * this->screen->pitch);
775 if(!mirrorbuf)
776 {
777 GLERR("HookDevice() failed to allocate temp buffer for mirroring!");
778 return NULL;
779 }
780
781 return this->screen;
782 }
783
784 static int glSDL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
785 {
786 /* We don't need to fill this one */
787 return 0;
788 }
789
790
791 #ifdef DEBUG_GLSDL
792 static void glSDL_print_glerror(_THIS, int point)
793 {
794 const char *err = "<unknown>";
795 switch(this->glGetError())
796 {
797 case GL_NO_ERROR:
798 return;
799 case GL_INVALID_ENUM:
800 err = "GL_INVALID_ENUM";
801 break;
802 case GL_INVALID_VALUE:
803 err = "GL_INVALID_VALUE";
804 break;
805 case GL_INVALID_OPERATION:
806 err = "GL_INVALID_OPERATION";
807 break;
808 case GL_STACK_OVERFLOW:
809 err = "GL_STACK_OVERFLOW";
810 break;
811 case GL_STACK_UNDERFLOW:
812 err = "GL_STACK_UNDERFLOW";
813 break;
814 case GL_OUT_OF_MEMORY:
815 err = "GL_OUT_OF_MEMORY";
816 default:
817 break;
818 }
819 fprintf(stderr,"OpenGL error \"%s\" at point %d.\n", err, point);
820 }
821 #endif
822
823 /* Get texinfo for a surface. */
824 static __inline__ private_hwdata *glSDL_GetTexInfo(SDL_Surface *surface)
825 {
826 if(!surface)
827 return NULL;
828 return surface->hwdata;
829 }
830
831
832 /* Allocate a "blank" texinfo for a suface. */
833 static private_hwdata *glSDL_AllocTexInfo(SDL_Surface *surface)
834 {
835 private_hwdata *txi;
836 if(!surface)
837 return NULL;
838
839 txi = glSDL_GetTexInfo(surface);
840 if(txi)
841 return txi; /* There already is one! --> */
842
843 /* ...and hook a new texinfo struct up to it. */
844 txi = (private_hwdata *)SDL_calloc(1, sizeof(private_hwdata));
845 if(!txi)
846 {
847 GLERR("AllocTexInfo(): Failed allocating TexInfo struct!");
848 return NULL;
849 }
850 txi->temporary = 1;
851 #ifdef DEBUG_GLSDL
852 fprintf(stderr, "glSDL: Allocated TexInfo %p.\n", txi);
853 #endif
854 return txi;
855 }
856
857
858 static void glSDL_FreeTexInfo(_THIS, private_hwdata *txi)
859 {
860 if(!txi)
861 return;
862
863 glSDL_UnloadTexture(this, txi);
864 SDL_free(txi->texture);
865 SDL_free(txi);
866 #ifdef DEBUG_GLSDL
867 fprintf(stderr, "glSDL: Freed TexInfo %p.\n", txi);
868 #endif
869 }
870
871
872 /* Detach and free the texinfo of a surface. */
873 static void glSDL_RemoveTexInfo(_THIS, SDL_Surface *surface)
874 {
875 SDL_Surface *next,*prev;
876 if(!glSDL_GetTexInfo(surface))
877 return;
878
879 /* maintain our doubly linked list */
880 next=surface->hwdata->next;
881 prev=surface->hwdata->prev;
882 if (prev!=NULL)
883 {
884 prev->hwdata->next = next;
885 }
886 else
887 {
888 first = next;
889 }
890 if (next!=NULL)
891 {
892 next->hwdata->prev = prev;
893 }
894
895 glSDL_FreeTexInfo(this, surface->hwdata);
896 surface->hwdata = NULL;
897 }
898
899
900 /*
901 * Calculate chopping/tiling of a surface to
902 * fit it into the smallest possible OpenGL
903 * texture.
904 */
905 static int glSDL_CalcChop(private_hwdata *txi)
906 {
907 int rows, vw, vh;
908 int vertical = 0;
909 int texsize;
910 int lastw, lasth, minsize;
911
912 vw = txi->virt.w;
913 vh = txi->virt.h;
914
915 #ifdef DEBUG_GLSDL_CHOP
916 fprintf(stderr, "w=%d, h=%d ", vw, vh);
917 #endif
918 if(vh > vw)
919 {
920 int t = vw;
921 vw = vh;
922 vh = t;
923 vertical = 1;
924 #ifdef DEBUG_GLSDL_CHOP
925 fprintf(stderr, "(vertical) \t");
926 #endif
927 }
928
929 /*
930 * Check whether this is a "huge" surface - at least one dimension
931 * must be <= than the maximum texture size, or we'll have to chop
932 * in both directions.
933 */
934 #ifdef DEBUG_GLSDL
935 if(maxtexsize < 0)
936 return GLERET("glSDL_CalcChop() called before OpenGL init!");
937 #endif
938 if(vh > maxtexsize)
939 {
940 /*
941 * Very simple hack for now; we just tile
942 * both ways with maximum size textures.
943 */
944 texsize = maxtexsize;
945
946 txi->tilemode = GLSDL_TM_HUGE;
947 txi->texsize = texsize;
948 txi->tilew = texsize;
949 txi->tileh = texsize;
950 txi->tilespertex = 1;
951
952 /* Calculate number of textures needed */
953 txi->textures = (vw + texsize - 1) / texsize;
954 txi->textures *= (vh + texsize - 1) / texsize;
955 txi->texture = SDL_malloc(txi->textures * sizeof(int));
956 SDL_memset(txi->texture, -1, txi->textures * sizeof(int));
957 #ifdef DEBUG_GLSDL
958 fprintf(stderr, "two-way tiling; textures=%d\n", txi->textures);
959 #endif
960 if(!txi->texture)
961 {
962 fprintf(stderr, "glSDL: INTERNAL ERROR: Failed to allocate"
963 " texture name table!\n");
964 return -3;
965 }
966 return 0;
967 }
968
969 /* Calculate minimum size */
970 rows = 1;
971 lastw = vw;
972 lasth = vh;
973 minsize = lastw > lasth ? lastw : lasth;
974 while(1)
975 {
976 int w, h, size;
977 ++rows;
978 w = vw / rows;
979 h = rows * vh;
980 size = w > h ? w : h;
981 if(size >= minsize)
982 {
983 --rows;
984 break;
985 }
986 lastw = w;
987 lasth = h;
988 minsize = size;
989 }
990 if(minsize > maxtexsize)
991 {
992 /* Handle multiple textures for very wide/tall surfaces. */
993 minsize = maxtexsize;
994 rows = (vw + minsize-1) / minsize;
995 }
996 #ifdef DEBUG_GLSDL_CHOP
997 fprintf(stderr, "==> minsize=%d ", minsize);
998 fprintf(stderr, "(rows=%d) \t", rows);
999 #endif
1000
1001 /* Recalculate with nearest higher power-of-2 width. */
1002 for(texsize = 1; texsize < minsize; texsize <<= 1)
1003 ;
1004 txi->texsize = texsize;
1005 rows = (vw + texsize-1) / texsize;
1006 #ifdef DEBUG_GLSDL_CHOP
1007 fprintf(stderr, "==> texsize=%d (rows=%d) \t", texsize, rows);
1008 #endif
1009
1010 /* Calculate number of tiles per texture */
1011 txi->tilespertex = txi->texsize / vh;
1012 #ifdef DEBUG_GLSDL_CHOP
1013 fprintf(stderr, "tilespertex=%d \t", txi->tilespertex);
1014 #endif
1015
1016 /* Calculate number of textures needed */
1017 txi->textures = (rows + txi->tilespertex-1) / txi->tilespertex;
1018 txi->texture = (GLuint *)SDL_malloc(txi->textures * sizeof(GLuint));
1019 SDL_memset(txi->texture, GLSDL_NOTEX, txi->textures * sizeof(GLuint));
1020 #ifdef DEBUG_GLSDL_CHOP
1021 fprintf(stderr, "textures=%d, ", txi->textures);
1022 #endif
1023 if(!txi->texture)
1024 return GLERET("Failed to allocate texture name table!");
1025
1026 /* Set up tile size. (Only one axis supported here!) */
1027 if(1 == rows)
1028 {
1029 txi->tilemode = GLSDL_TM_SINGLE;
1030 if(vertical)
1031 {
1032 txi->tilew = vh;
1033 txi->tileh = vw;
1034 }
1035 else
1036 {
1037 txi->tilew = vw;
1038 txi->tileh = vh;
1039 }
1040 }
1041 else if(vertical)
1042 {
1043 txi->tilemode = GLSDL_TM_VERTICAL;
1044 txi->tilew = vh;
1045 txi->tileh = texsize;
1046 }
1047 else
1048 {
1049 txi->tilemode = GLSDL_TM_HORIZONTAL;
1050 txi->tilew = texsize;
1051 txi->tileh = vh;
1052 }
1053
1054 #ifdef DEBUG_GLSDL_CHOP
1055 fprintf(stderr, "tilew=%d, tileh=%d\n", txi->tilew, txi->tileh);
1056 #endif
1057 return 0;
1058 }
1059
1060
1061 /* Create a temporary TexInfo struct for an SDL_Surface */
1062 static private_hwdata *glSDL_CreateTempTexInfo(_THIS, SDL_Surface *surface)
1063 {
1064 private_hwdata *txi;
1065 if(!surface)
1066 {
1067 GLERR("CreateTempTexInfo(); no surface!");
1068 return NULL;
1069 }
1070 if(IS_GLSDL_SURFACE(surface))
1071 return glSDL_GetTexInfo(surface); /* Do nothing */
1072
1073 txi = glSDL_AllocTexInfo(surface);
1074 if(!txi)
1075 {
1076 GLERR("CreateTempTexInfo(); Could not alloc TexInfo!");
1077 return NULL;
1078 }
1079 txi->virt.w = txi->lw = surface->w;
1080 txi->virt.h = txi->lh = surface->h;
1081
1082 if(glSDL_CalcChop(txi) < 0)
1083 {
1084 glSDL_FreeTexInfo(this, txi);
1085 GLERR("CreateTempTexInfo(); CalcChop() failed!");
1086 return NULL;
1087 }
1088
1089 return txi;
1090 }
1091
1092 /* Add a glSDL_TexInfo struct to an SDL_Surface */
1093 static private_hwdata *glSDL_AddTexInfo(_THIS, SDL_Surface *surface)
1094 {
1095 private_hwdata *txi = glSDL_CreateTempTexInfo(this, surface);
1096 if(!txi)
1097 return NULL;
1098
1099 /* Connect the surface to the new TexInfo. */
1100 txi->temporary = 0;
1101 surface->hwdata = txi;
1102
1103 /* add this new surface in front of the list of hw surfaces */
1104 txi->next = first;
1105 txi->prev = NULL;
1106 first = surface;
1107 if (txi->next!=NULL)
1108 {
1109 txi->next->hwdata->prev=surface;
1110 }
1111
1112 SDL_SetClipRect(surface, &txi->virt);
1113 return txi;
1114 }
1115
1116
1117 /* Create a surface of the prefered OpenGL RGB texture format */
1118 /*static SDL_Surface *glSDL_CreateRGBSurface(int w, int h)
1119 {
1120 SDL_Surface *s;
1121 Uint32 rmask, gmask, bmask;
1122 int bits = 24;
1123 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1124 rmask = 0x000000FF;
1125 gmask = 0x0000FF00;
1126 bmask = 0x00FF0000;
1127 #else
1128 rmask = 0x00FF0000;
1129 gmask = 0x0000FF00;
1130 bmask = 0x000000FF;
1131 #endif
1132 s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
1133 bits, rmask, gmask, bmask, 0);
1134 if(s)
1135 s->flags |= SDL_HWACCEL;
1136
1137 return s;
1138 }
1139 */
1140
1141 /* Create a surface of the prefered OpenGL RGBA texture format */
1142 static SDL_Surface *glSDL_CreateRGBASurface(int w, int h)
1143 {
1144 SDL_Surface *s;
1145 Uint32 rmask, gmask, bmask, amask;
1146 int bits = 32;
1147 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1148 rmask = 0x000000FF;
1149 gmask = 0x0000FF00;
1150 bmask = 0x00FF0000;
1151 amask = 0xFF000000;
1152 #else
1153 rmask = 0xFF000000;
1154 gmask = 0x00FF0000;
1155 bmask = 0x0000FF00;
1156 amask = 0x000000FF;
1157 #endif
1158 s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
1159 bits, rmask, gmask, bmask, amask);
1160 if(s)
1161 s->flags |= SDL_HWACCEL;
1162
1163 return s;
1164 }
1165
1166
1167 static void glSDL_init_formats(_THIS)
1168 {
1169 RGBfmt = SDL_AllocFormat(24,
1170 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1171 0x000000FF,
1172 0x0000FF00,
1173 0x00FF0000,
1174 0);
1175 #else
1176 0x00FF0000,
1177 0x0000FF00,
1178 0x000000FF,
1179 0);
1180 #endif
1181 RGBAfmt = SDL_AllocFormat(32,
1182 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
1183 0x000000FF,
1184 0x0000FF00,
1185 0x00FF0000,
1186 0xFF000000);
1187 #else
1188 0xFF000000,
1189 0x00FF0000,
1190 0x0000FF00,
1191 0x000000FF);
1192 #endif
1193 }
1194
1195
1196 static int glSDL_FormatIsOk(SDL_Surface *surface)
1197 {
1198 SDL_PixelFormat *pf;
1199 if(!surface)
1200 return 1; /* Well, there ain't much we can do anyway... */
1201
1202 pf = surface->format;
1203
1204 /* Colorkeying requires an alpha channel! */
1205 if(surface->flags & SDL_SRCCOLORKEY)
1206 if(!pf->Amask)
1207 return 0;
1208
1209 /* We need pitch == (width * BytesPerPixel) for glTex[Sub]Image2D() */
1210 if(surface->pitch != (surface->w * pf->BytesPerPixel))
1211 return 0;
1212
1213 if(pf->Amask)
1214 {
1215 if(pf->BytesPerPixel != RGBAfmt->BytesPerPixel)
1216 return 0;
1217 if(pf->Rmask != RGBAfmt->Rmask)
1218 return 0;
1219 if(pf->Gmask != RGBAfmt->Gmask)
1220 return 0;
1221 if(pf->Bmask != RGBAfmt->Bmask)
1222 return 0;
1223 if(pf->Amask != RGBAfmt->Amask)
1224 return 0;
1225 }
1226 else
1227 {
1228 if(pf->BytesPerPixel != RGBfmt->BytesPerPixel)
1229 return 0;
1230 if(pf->Rmask != RGBfmt->Rmask)
1231 return 0;
1232 if(pf->Gmask != RGBfmt->Gmask)
1233 return 0;
1234 if(pf->Bmask != RGBfmt->Bmask)
1235 return 0;
1236 }
1237 return 1;
1238 }
1239
1240 static void glSDL_key2alpha(SDL_Surface *surface)
1241 {
1242 int x, y;
1243 Uint32 ckey = surface->format->colorkey;
1244
1245 #ifdef DEBUG_GLSDL
1246 fprintf(stderr,"glSDL_key2alpha()\n");
1247 #endif
1248 for(y = 0; y < surface->h; ++y)
1249 {
1250 Uint32 *px = (Uint32 *)((char *)surface->pixels + y*surface->pitch);
1251 for(x = 0; x < surface->w; ++x)
1252 if(px[x] == ckey)
1253 px[x] = 0;
1254 }
1255 }
1256
1257
1258
1259 /*----------------------------------------------------------
1260 SDL style API
1261 ----------------------------------------------------------*/
1262
1263 static int glSDL_FlipHWSurface(_THIS, SDL_Surface *surface)
1264 {
1265 #ifdef GLSDL_GRAPHICAL_DEBUG
1266 this->glDisable(GL_TEXTURE_2D);
1267 this->glBegin(GL_LINE_LOOP);
1268 this->glColor4ub(0, 0, 255, 128);
1269 this->glVertex2i(0,0);
1270 this->glVertex2i(surface->w,0);
1271 this->glVertex2i(surface->w,surface->h);
1272 this->glVertex2i(0,surface->h);
1273 this->glEnd();
1274 this->glEnable(GL_TEXTURE_2D);
1275 #endif
1276 if (this->screen->flags&SDL_DOUBLEBUF)
1277 this->GL_SwapBuffers(this);
1278 else
1279 this->glFinish();
1280 return 0;
1281 }
1282
1283
1284 static void glSDL_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
1285 {
1286 #ifdef GLSDL_GRAPHICAL_DEBUG
1287 int i;
1288 this->glDisable(GL_TEXTURE_2D);
1289 for(i=0;i<numrects;i++)
1290 {
1291 this->glColor4ub(255, 0, 0, 128);
1292 this->glBegin(GL_LINE_LOOP);
1293 this->glVertex2i(rects[i].x,rects[i].y);
1294 this->glVertex2i(rects[i].x+rects[i].w,rects[i].y);
1295 this->glVertex2i(rects[i].x+rects[i].w,rects[i].y+rects[i].h);
1296 this->glVertex2i(rects[i].x,rects[i].y+rects[i].h);
1297 this->glEnd();
1298 }
1299 this->glEnable(GL_TEXTURE_2D);
1300 #endif
1301 if (this->screen->flags&SDL_DOUBLEBUF)
1302 this->GL_SwapBuffers(this);
1303 else
1304 this->glFinish();
1305 }
1306
1307
1308 static int glSDL_AllocHWSurface(_THIS, SDL_Surface *surface)
1309 {
1310 surface->flags |= (SDL_HWSURFACE|SDL_HWACCEL);
1311
1312 surface->pixels = SDL_malloc(surface->h*surface->pitch);
1313 if ( surface->pixels == NULL ) {
1314 SDL_FreeSurface(surface);
1315 SDL_OutOfMemory();
1316 return(-1);
1317 }
1318 SDL_memset(surface->pixels, 0, surface->h*surface->pitch);
1319 return 0;
1320 }
1321
1322
1323 static void glSDL_FreeHWSurface(_THIS, SDL_Surface *surface)
1324 {
1325 if(!surface)
1326 return;
1327 glSDL_RemoveTexInfo(this, surface);
1328 }
1329
1330
1331 static int glSDL_LockHWSurface(_THIS, SDL_Surface *surface)
1332 {
1333 int y;
1334
1335 if(!surface)
1336 return -1;
1337
1338 #ifdef DEBUG_GLSDL
1339 fprintf(stderr, "glSDL: Lock Surface.\n");
1340 #endif
1341
1342 if(SDL_VideoSurface == surface)
1343 {
1344 glSDL_Invalidate(surface, NULL);
1345 this->glPixelStorei(GL_UNPACK_ROW_LENGTH,
1346 surface->pitch /
1347 surface->format->BytesPerPixel);
1348 this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
1349 GL_RGB,
1350 GL_UNSIGNED_BYTE,
1351 OpenGL_Surface->pixels);
1352 for(y = 0; y < OpenGL_Surface->h / 2; ++y)
1353 {
1354 void *upper = (Uint8 *)OpenGL_Surface->pixels +
1355 OpenGL_Surface->pitch * y;
1356 void *lower = (Uint8 *)OpenGL_Surface->pixels +
1357 OpenGL_Surface->pitch * (OpenGL_Surface->h - y - 1);
1358 SDL_memcpy(mirrorbuf, upper, OpenGL_Surface->pitch);
1359 SDL_memcpy(upper, lower, OpenGL_Surface->pitch);
1360 SDL_memcpy(lower, mirrorbuf, OpenGL_Surface->pitch);
1361 }
1362 /* the mapping has to be invalidated on 8bpp video surfaces in case of a hw palette change.
1363 * Now if someone could tell me why this is not handled by SDL... */
1364 if (SDL_VideoSurface->format->BitsPerPixel==8)
1365 SDL_InvalidateMap(OpenGL_Surface->map);
1366
1367 /* convert this raw surface to the application-requested format
1368 * FIXME this is sometimes overkill, we could use glPixelStore smartly
1369 * But this would be slow anyway :) */
1370
1371 glSDL_SoftBlit(OpenGL_Surface, NULL, SDL_VideoSurface, NULL);
1372 }
1373 else
1374 glSDL_Invalidate(surface, NULL);
1375
1376 return 0;
1377 }
1378
1379
1380 static void glSDL_UnlockHWSurface(_THIS, SDL_Surface *surface)
1381 {
1382 private_hwdata *txi;
1383
1384 if(!surface)
1385 return;
1386
1387 /* upload this surface ONLY if this is a glSDL surface
1388 * because sometimes (during displayformating for ex.) surfaces are unlocked that aren't glSDL
1389 */
1390 if(!IS_GLSDL_SURFACE(surface))
1391 return;
1392
1393 #ifdef DEBUG_GLSDL
1394 fprintf(stderr, "glSDL: Unlock Surface.\n");
1395 #endif
1396
1397 txi = glSDL_UploadSurface(this, surface);
1398
1399 if(!txi)
1400 {
1401 GLERR("glSDL_UnlockHWSurface() failed to upload surface!");
1402 return;
1403 }
1404 if(txi->temporary)
1405 {
1406 GLERR("Weirdness... glSDL_UnlockHWSurface() got a temporary TexInfo.");
1407 return;
1408 }
1409 if(surface == SDL_VideoSurface)
1410 glSDL_BlitGL(this, SDL_VideoSurface, NULL, NULL);
1411 }
1412
1413
1414 static int glSDL_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key)
1415 {
1416 /*
1417 * If an application does this *after* SDL_DisplayFormat,
1418 * we're basically screwed, unless we want to do an
1419 * in-place surface conversion hack here.
1420 *
1421 * What we do is just kill the glSDL texinfo... No big
1422 * deal in most cases, as glSDL only converts once anyway,
1423 * *unless* you keep modifying the surface.
1424 */
1425 if(IS_GLSDL_SURFACE(surface))
1426 glSDL_RemoveTexInfo(this, surface);
1427 return 0;
1428 }
1429
1430
1431 static int glSDL_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha)
1432 {
1433 /*
1434 * If an application does this *after* SDL_DisplayFormat,
1435 * we're basically screwed, unless we want to do an
1436 * in-place surface conversion hack here.
1437 *
1438 * What we do is just kill the glSDL texinfo... No big
1439 * deal in most cases, as glSDL only converts once anyway,
1440 * *unless* you keep modifying the surface.
1441 */
1442 if(IS_GLSDL_SURFACE(surface))
1443 glSDL_RemoveTexInfo(this, surface);
1444 return 0;
1445 }
1446
1447 static SDL_bool glSDL_SetClipRect(_THIS, SDL_Surface *surface, SDL_Rect *rect)
1448 {
1449 SDL_bool res;
1450 if(!surface)
1451 return SDL_FALSE;
1452
1453 res = SDL_SetClipRect(surface, rect);
1454 if(!res)
1455 return SDL_FALSE;
1456
1457 rect = &surface->clip_rect;
1458
1459 if(surface == SDL_VideoSurface)
1460 {
1461 SDL_Rect r;
1462 float xscale, yscale;
1463 private_hwdata *txi;
1464
1465 r.x = rect->x;
1466 r.y = rect->y;
1467 r.w = rect->w;
1468 r.h = rect->h;
1469 SDL_SetClipRect(surface, rect);
1470
1471 txi = glSDL_GetTexInfo(surface);
1472 if(!txi)
1473 return GLERET("SetClipRect(): Could not get TexInfo!");
1474
1475 this->glViewport(rect->x,
1476 surface->h - (rect->y + rect->h),
1477 rect->w,
1478 rect->h);
1479 /*
1480 * Note that this projection is upside down in
1481 * relation to the OpenGL coordinate system.
1482 */
1483 this->glMatrixMode(GL_PROJECTION);
1484 this->glLoadIdentity();
1485 xscale = (float)txi->lw / (float)surface->w;
1486 yscale = (float)txi->lh / (float)surface->h;
1487 this->glOrtho( xscale*(float)rect->x,
1488 xscale*(float)(rect->w+rect->x),
1489 yscale*(float)(rect->h+rect->y),
1490 yscale*(float)rect->y,
1491 -1.0, 1.0);
1492 return SDL_TRUE;
1493 }
1494 return res;
1495 }
1496
1497 static int glSDL_BlitFromGL(_THIS, SDL_Rect *srcrect,
1498 SDL_Surface *dst, SDL_Rect *dstrect)
1499 {
1500 SDL_Rect sr, dr;
1501
1502 /* In case the destination has an OpenGL texture... */
1503 glSDL_Invalidate(dst, dstrect);
1504
1505 /* Abuse the fake screen buffer a little. */
1506 this->glPixelStorei(GL_UNPACK_ROW_LENGTH, SDL_VideoSurface->pitch /
1507 SDL_VideoSurface->format->BytesPerPixel);
1508 if(srcrect)
1509 this->glReadPixels(srcrect->x, OpenGL_Surface->h - (srcrect->y + srcrect->h - 1),
1510 srcrect->w, srcrect->h,
1511 GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
1512 else
1513 this->glReadPixels(0, 0, OpenGL_Surface->w, OpenGL_Surface->h,
1514 GL_RGB, GL_UNSIGNED_BYTE, OpenGL_Surface->pixels);
1515 sr = *srcrect;
1516 dr = *dstrect;
1517 glSDL_SoftBlit(OpenGL_Surface, &sr, dst, &dr);
1518 return 0;
1519 }
1520
1521 static __inline__ void glSDL_BlitGL_single(_THIS, private_hwdata *txi,
1522 float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
1523 {
1524 float sx2, sy2, texscale;
1525 if(!txi->textures)
1526 return;
1527 if(-1 == txi->texture[0])
1528 return;
1529 glSDL_texture(this, txi->texture[0]);
1530
1531 texscale = 1.0 / (float)txi->texsize;
1532 sx2 = (sx1 + (float)dst->w) * texscale;
1533 sy2 = (sy1 + (float)dst->h) * texscale;
1534 sx1 *= texscale;
1535 sy1 *= texscale;
1536
1537 #ifdef GLSDL_GRAPHICAL_DEBUG
1538 this->glDisable(GL_TEXTURE_2D);
1539 this->glBegin(GL_LINE_LOOP);
1540 this->glColor4ub(0, 255, 0, 128);
1541 this->glVertex2i(dst->x, dst->y);
1542 this->glVertex2i(dst->x + dst->w, dst->y);
1543 this->glVertex2i(dst->x + dst->w, dst->y + dst->h);
1544 this->glVertex2i(dst->x, dst->y + dst->h);
1545 this->glEnd();
1546 this->glEnable(GL_TEXTURE_2D);
1547 #endif
1548
1549 this->glBegin(GL_TRIANGLE_FAN);
1550 this->glColor4ub(255, 255, 255, alpha);
1551 this->glTexCoord2f(sx1, sy1);
1552 this->glVertex2i(dst->x, dst->y);
1553 this->glTexCoord2f(sx2, sy1);
1554 this->glVertex2i(dst->x + dst->w, dst->y);
1555 this->glTexCoord2f(sx2, sy2);
1556 this->glVertex2i(dst->x + dst->w, dst->y + dst->h);
1557 this->glTexCoord2f(sx1, sy2);
1558 this->glVertex2i(dst->x, dst->y + dst->h);
1559 this->glEnd();
1560 }
1561
1562
1563 static void glSDL_BlitGL_htile(_THIS, private_hwdata *txi,
1564 float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
1565 {
1566 int tex;
1567 float tile, sx2, sy2, yo;
1568 float texscale = 1.0 / (float)txi->texsize;
1569 float tileh = (float)txi->tileh * texscale;
1570 sx2 = (sx1 + (float)dst->w) * texscale;
1571 sy2 = (sy1 + (float)dst->h) * texscale;
1572 sx1 *= texscale;
1573 sy1 *= texscale;
1574 tile = floor(sx1);
1575 tex = (int)tile / txi->tilespertex;
1576 yo = ((int)tile % txi->tilespertex) * tileh;
1577
1578 if(tex >= txi->textures)
1579 return;
1580 if(-1 == txi->texture[tex])
1581 return;
1582 glSDL_texture(this, txi->texture[tex]);
1583
1584 while(tile < sx2)
1585 {
1586 int tdx1 = dst->x;
1587 int tdx2 = dst->x + dst->w;
1588 float tsx1 = sx1 - tile;
1589 float tsx2 = sx2 - tile;
1590
1591 /* Clip to current tile */
1592 if(tsx1 < 0.0)
1593 {
1594 tdx1 -= tsx1 * txi->texsize;
1595 tsx1 = 0.0;
1596 }
1597 if(tsx2 > 1.0)
1598 {
1599 tdx2 -= (tsx2 - 1.0) * txi->texsize;
1600 tsx2 = 1.0;
1601 }
1602
1603 /* Maybe select next texture? */
1604 if(yo + tileh > 1.0)
1605 {
1606 ++tex;
1607 if(tex >= txi->textures)
1608 return;
1609 if(-1 == txi->texture[tex])
1610 return;
1611 glSDL_texture(this, txi->texture[tex]);
1612 yo = 0.0;
1613 }
1614
1615 #ifdef GLSDL_GRAPHICAL_DEBUG
1616 this->glDisable(GL_TEXTURE_2D);
1617 this->glBegin(GL_LINE_LOOP);
1618 this->glColor4ub(0, 255, 0, 128);
1619 this->glVertex2i(tdx1, dst->y);
1620 this->glVertex2i(tdx2, dst->y);
1621 this->glVertex2i(tdx2, dst->y + dst->h);
1622 this->glVertex2i(tdx1, dst->y + dst->h);
1623 this->glEnd();
1624 this->glEnable(GL_TEXTURE_2D);
1625 #endif
1626
1627 this->glBegin(GL_TRIANGLE_FAN);
1628 this->glColor4ub(255, 255, 255, alpha);
1629 this->glTexCoord2f(tsx1, yo + sy1);
1630 this->glVertex2i(tdx1, dst->y);
1631 this->glTexCoord2f(tsx2, yo + sy1);
1632 this->glVertex2i(tdx2, dst->y);
1633 this->glTexCoord2f(tsx2, yo + sy2);
1634 this->glVertex2i(tdx2, dst->y + dst->h);
1635 this->glTexCoord2f(tsx1, yo + sy2);
1636 this->glVertex2i(tdx1, dst->y + dst->h);
1637 this->glEnd();
1638 tile += 1.0;
1639 yo += tileh;
1640 }
1641 }
1642
1643
1644 static void glSDL_BlitGL_vtile(_THIS, private_hwdata *txi,
1645 float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
1646 {
1647 int tex;
1648 float tile, sx2, sy2, xo;
1649 float texscale = 1.0 / (float)txi->texsize;
1650 float tilew = (float)txi->tilew * texscale;
1651 sx2 = (sx1 + (float)dst->w) * texscale;
1652 sy2 = (sy1 + (float)dst->h) * texscale;
1653 sx1 *= texscale;
1654 sy1 *= texscale;
1655 tile = floor(sy1);
1656 tex = (int)tile / txi->tilespertex;
1657 xo = ((int)tile % txi->tilespertex) * tilew;
1658
1659 if(tex >= txi->textures)
1660 return;
1661 if(-1 == txi->texture[tex])
1662 return;
1663 glSDL_texture(this, txi->texture[tex]);
1664
1665 while(tile < sy2)
1666 {
1667 int tdy1 = dst->y;
1668 int tdy2 = dst->y + dst->h;
1669 float tsy1 = sy1 - tile;
1670 float tsy2 = sy2 - tile;
1671
1672 /* Clip to current tile */
1673 if(tsy1 < 0.0)
1674 {
1675 tdy1 -= tsy1 * txi->texsize;
1676 tsy1 = 0.0;
1677 }
1678 if(tsy2 > 1.0)
1679 {
1680 tdy2 -= (tsy2 - 1.0) * txi->texsize;
1681 tsy2 = 1.0;
1682 }
1683
1684 /* Maybe select next texture? */
1685 if(xo + tilew > 1.0)
1686 {
1687 ++tex;
1688 if(tex >= txi->textures)
1689 return;
1690 if(-1 == txi->texture[tex])
1691 return;
1692 glSDL_texture(this, txi->texture[tex]);
1693 xo = 0.0;
1694 }
1695
1696 #ifdef GLSDL_GRAPHICAL_DEBUG
1697 this->glDisable(GL_TEXTURE_2D);
1698 this->glBegin(GL_LINE_LOOP);
1699 this->glColor4ub(0, 255, 0, 128);
1700 this->glVertex2i(dst->x, tdy1);
1701 this->glVertex2i(dst->x + dst->w, tdy1);
1702 this->glVertex2i(dst->x + dst->w, tdy2);
1703 this->glVertex2i(dst->x, tdy2);
1704 this->glEnd();
1705 this->glEnable(GL_TEXTURE_2D);
1706 #endif
1707
1708 this->glBegin(GL_TRIANGLE_FAN);
1709 this->glColor4ub(255, 255, 255, alpha);
1710 this->glTexCoord2f(xo + sx1, tsy1);
1711 this->glVertex2i(dst->x, tdy1);
1712 this->glTexCoord2f(xo + sx2, tsy1);
1713 this->glVertex2i(dst->x + dst->w, tdy1);
1714 this->glTexCoord2f(xo + sx2, tsy2);
1715 this->glVertex2i(dst->x + dst->w, tdy2);
1716 this->glTexCoord2f(xo + sx1, tsy2);
1717 this->glVertex2i(dst->x, tdy2);
1718 this->glEnd();
1719
1720 tile += 1.0;
1721 xo += tilew;
1722 }
1723 }
1724
1725
1726 static void glSDL_BlitGL_hvtile(_THIS, SDL_Surface *src, private_hwdata *txi,
1727 float sx1, float sy1, SDL_Rect *dst, unsigned char alpha)
1728 {
1729 int x, y, last_tex, tex;
1730 float sx2, sy2;
1731 float texscale = 1.0 / (float)txi->texsize;
1732 int tilesperrow = (src->w + txi->tilew - 1) / txi->tilew;
1733 sx2 = (sx1 + (float)dst->w) * texscale;
1734 sy2 = (sy1 + (float)dst->h) * texscale;
1735 sx1 *= texscale;
1736 sy1 *= texscale;
1737
1738 last_tex = tex = floor(sy1) * tilesperrow + floor(sx1);
1739 if(tex >= txi->textures)
1740 return;
1741 if(-1 == txi->texture[tex])
1742 return;
1743 glSDL_texture(this, txi->texture[tex]);
1744
1745 for(y = floor(sy1); y < sy2; ++y)
1746 {
1747 int tdy1 = dst->y;
1748 int tdy2 = dst->y + dst->h;
1749 float tsy1 = sy1 - y;
1750 float tsy2 = sy2 - y;
1751
1752 /* Clip to current tile */
1753 if(tsy1 < 0.0)
1754 {
1755 tdy1 -= tsy1 * txi->texsize;
1756 tsy1 = 0.0;
1757 }
1758 if(tsy2 > 1.0)
1759 {
1760 tdy2 -= (tsy2 - 1.0) * txi->texsize;
1761 tsy2 = 1.0;
1762 }
1763 for(x = floor(sx1); x < sx2; ++x)
1764 {
1765 int tdx1 = dst->x;
1766 int tdx2 = dst->x + dst->w;
1767 float tsx1 = sx1 - x;
1768 float tsx2 = sx2 - x;
1769
1770 /* Clip to current tile */
1771 if(tsx1 < 0.0)
1772 {
1773 tdx1 -= tsx1 * txi->texsize;
1774 tsx1 = 0.0;
1775 }
1776 if(tsx2 > 1.0)
1777 {
1778 tdx2 -= (tsx2 - 1.0) * txi->texsize;
1779 tsx2 = 1.0;
1780 }
1781
1782 /* Select texture */
1783 tex = y * tilesperrow + x;
1784 if(tex != last_tex)
1785 {
1786 if(tex >= txi->textures)
1787 return;
1788 if(-1 == txi->texture[tex])
1789 return;
1790 glSDL_texture(this, txi->texture[tex]);
1791 last_tex = tex;
1792 }
1793
1794 #ifdef GLSDL_GRAPHICAL_DEBUG
1795 this->glDisable(GL_TEXTURE_2D);
1796 this->glBegin(GL_LINE_LOOP);
1797 this->glColor4ub(0, 255, 0, 128);
1798 this->glVertex2i(tdx1, tdy1);
1799 this->glVertex2i(tdx2, tdy1);
1800 this->glVertex2i(tdx2, tdy2);
1801 this->glVertex2i(tdx1, tdy2);
1802 this->glEnd();
1803 this->glEnable(GL_TEXTURE_2D);
1804 #endif
1805
1806 this->glBegin(GL_TRIANGLE_FAN);
1807 this->glColor4ub(255, 255, 255, alpha);
1808 this->glTexCoord2f(tsx1, tsy1);
1809 this->glVertex2i(tdx1, tdy1);
1810 this->glTexCoord2f(tsx2, tsy1);
1811 this->glVertex2i(tdx2, tdy1);
1812 this->glTexCoord2f(tsx2, tsy2);
1813 this->glVertex2i(tdx2, tdy2);
1814 this->glTexCoord2f(tsx1, tsy2);
1815 this->glVertex2i(tdx1, tdy2);
1816 this->glEnd();
1817 }
1818 }
1819 }
1820
1821 /*
1822 * Calculate the actual blit rectangle and source offset
1823 * for a blit from a rectangle in a surface with specified
1824 * size to a surface with a cliprect.
1825 *
1826 * In: rect source rectangle
1827 * w, h source surface size
1828 * (x, y) destination coordinate
1829 * clip destination clip rectangle
1830 *
1831 * Out: (x, y) source top-left offset
1832 * rect destination rectangle
1833 *
1834 * Returns 1 if the result is visible, otherwise 0.
1835 */
1836 static __inline__ int blitclip(SDL_Rect *rect, int w, int h,
1837 int *x, int *y, SDL_Rect *clip)
1838 {
1839 int sx1, sy1, sx2, sy2;
1840 int dx1, dy1, dx2, dy2;
1841
1842 /* Get source and destination coordinates */
1843 sx1 = rect->x;
1844 sy1 = rect->y;
1845 sx2 = sx1 + rect->w;
1846 sy2 = sy1 + rect->h;
1847 dx1 = *x;
1848 dy1 = *y;
1849
1850 /* Keep source rect inside source surface */
1851 if(sx1 < 0)
1852 {
1853 dx1 -= sx1;
1854 sx1 = 0;
1855 }
1856 if(sy1 < 0)
1857 {
1858 dy1 -= sy1;
1859 sy1 = 0;
1860 }
1861 if(sx2 > w)
1862 sx2 = w;
1863 if(sy2 > h)
1864 sy2 = h;
1865
1866 /* Cull blits from void space */
1867 if(sx1 >= sx2 || sy1 >= sy2)
1868 return 0;
1869
1870 /* Calculate destination lower-right */
1871 dx2 = dx1 + (sx2 - sx1);
1872 dy2 = dy1 + (sy2 - sy1);
1873
1874 /* Clip to destination cliprect */
1875 if(dx1 < clip->x)
1876 {
1877 sx1 += clip->x - dx1;
1878 dx1 = clip->x;
1879 }
1880 if(dy1 < clip->y)
1881 {
1882 sy1 += clip->y - dy1;
1883 dy1 = clip->y;
1884 }
1885 if(dx2 > clip->x + clip->w)
1886 dx2 = clip->x + clip->w;
1887 if(dy2 > clip->y + clip->h)
1888 dy2 = clip->y + clip->h;
1889
1890 /* Cull nop/off-screen blits */
1891 if(dx1 >= dx2 || dy1 >= dy2)
1892 return 0;
1893
1894 *x = sx1;
1895 *y = sy1;
1896 rect->x = dx1;
1897 rect->y = dy1;
1898 rect->w = dx2 - dx1;
1899 rect->h = dy2 - dy1;
1900 return 1;
1901 }
1902
1903 static int glSDL_BlitGL(_THIS, SDL_Surface *src,
1904 SDL_Rect *srcrect, SDL_Rect *dstrect)
1905 {
1906 private_hwdata *txi;
1907 float x1, y1;
1908 unsigned char alpha;
1909 SDL_Rect d;
1910 int x, y;
1911 SDL_Rect r;
1912
1913 if(!src)
1914 return GLERET("BlitGL(): No src surface!");
1915
1916 /* Get source and destination coordinates */
1917 if(srcrect)
1918 r = *srcrect;
1919 else
1920 {
1921 r.x = r.y = 0;
1922 r.w = src->w;
1923 r.h = src->h;
1924 }
1925 if(dstrect)
1926 {
1927 x = dstrect->x;
1928 y = dstrect->y;
1929 }
1930 else
1931 x = y = 0;
1932
1933 /* Clip! */
1934 if(!blitclip(&r, src->w, src->h, &x, &y, &this->screen->clip_rect))
1935 {
1936 if(dstrect)
1937 dstrect->w = dstrect->h = 0;
1938 return 0;
1939 }
1940
1941 /* Write back the resulting cliprect */
1942 if(dstrect)
1943 *dstrect = r;
1944
1945 /* Make sure we have a source with a valid texture */
1946 txi = glSDL_UploadSurface(this, src);
1947 if(!txi)
1948 return GLERET("BlitGL(): Could not get a TexInfo!");
1949
1950 /* Set up blending */
1951 if(src->flags & (SDL_SRCALPHA | SDL_SRCCOLORKEY))
1952 {
1953 glSDL_blendfunc(this, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1954 glSDL_do_blend(this, 1);
1955 }
1956 else
1957 glSDL_do_blend(this, 0);
1958
1959 /* Enable texturing */
1960 glSDL_do_texture(this, 1);
1961
1962 /* Calculate texcoords */
1963 if(!srcrect)
1964 srcrect = &txi->virt;
1965 x1 = (float)srcrect->x;
1966 y1 = (float)srcrect->y;
1967
1968 /* Calculate screen coords. */
1969 if(dstrect)
1970 {
1971 d.x = dstrect->x;
1972 d.y = dstrect->y;
1973 d.w = (int)(srcrect->w * (float)txi->lw / (float)txi->virt.w);
1974 d.h = (int)(srcrect->h * (float)txi->lh / (float)txi->virt.h);
1975 }
1976 else
1977 {
1978 d.x = 0;
1979 d.y = 0;
1980 d.w = (int)(srcrect->w * (float)txi->lw / (float)txi->virt.w);
1981 d.h = (int)(srcrect->h * (float)txi->lh / (float)txi->virt.h);
1982 }
1983
1984 /*
1985 * Note that we actually *prevent* the use of "full surface alpha"
1986 * and alpha channel in combination - to stay SDL 2D compatible.
1987 */
1988 if ((src->flags & SDL_SRCALPHA)&&(src->format->Amask))
1989 alpha = 255;
1990 else
1991 alpha = src->format->alpha;
1992
1993 /* Render! */
1994 switch(txi->tilemode)
1995 {
1996 case GLSDL_TM_SINGLE:
1997 glSDL_BlitGL_single(this, txi, x1, y1,
1998 &d,
1999 alpha);
2000 break;
2001 case GLSDL_TM_HORIZONTAL:
2002 glSDL_BlitGL_htile(this, txi, x1, y1,
2003 &d,
2004 alpha);
2005 break;
2006 case GLSDL_TM_VERTICAL:
2007 glSDL_BlitGL_vtile(this, txi, x1, y1,
2008 &d,
2009 alpha);
2010 break;
2011 case GLSDL_TM_HUGE:
2012 glSDL_BlitGL_hvtile(this, src, txi, x1, y1,
2013 &d,
2014 alpha);
2015 break;
2016 }
2017
2018 if(txi->temporary)
2019 glSDL_FreeTexInfo(this, txi);
2020
2021 return 0;
2022 }
2023
2024
2025 static int glSDL_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
2026 SDL_Surface *dst, SDL_Rect *dstrect)
2027 {
2028 SDL_Surface *vs;
2029
2030 if(!src)
2031 return GLERET("HWAccelBlit(): No src surface!");
2032 if(!dst)
2033 return GLERET("HWAccelBlit(): No dst surface!");
2034
2035 /*
2036 * Figure out what to do:
2037 * screen->screen: glSDL_BlitFromGL() + glSDL_BlitGL()
2038 * surface->screen: glSDL_BlitGL()
2039 * screen->surface: glSDL_BlitFromGL()
2040 * surface->surface: glSDL_SoftBlit()
2041 */
2042 vs = SDL_VideoSurface;
2043 if(src == vs)
2044 {
2045 if(dst == vs)
2046 {
2047 /*
2048 FIXME: Try glCopyPixels() instead...
2049 */
2050 glSDL_BlitFromGL(current_video, srcrect, vs, dstrect);
2051 return glSDL_BlitGL(current_video, vs,
2052 srcrect, dstrect);
2053 }
2054 else
2055 {
2056 return glSDL_BlitFromGL(current_video, srcrect,
2057 dst, dstrect);
2058 }
2059 }
2060 else
2061 {
2062 if(dst == vs)
2063 {
2064 return glSDL_BlitGL(current_video, src,
2065 srcrect, dstrect);
2066 }
2067 else
2068 {
2069 glSDL_Invalidate(dst, dstrect);
2070 glSDL_SoftBlit(src, srcrect, dst, dstrect);
2071 return 0;
2072 }
2073 }
2074 }
2075
2076
2077 static int glSDL_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
2078 {
2079 SDL_Surface *vs = SDL_VideoSurface;
2080 int dx1, dy1, dx2, dy2;
2081 Uint32 r, g, b;
2082 Uint8 br,bg,bb;
2083
2084 /*
2085 * Some ugly reverse conversion for compatibility...
2086 * (We must do this before losing the dst pointer,
2087 * as the pixel formats of the screen and
2088 * SDL_VideoSurface may differ!)
2089 */
2090
2091 if (dst->format->palette)
2092 {
2093 /* this a paletted color */
2094 SDL_GetRGB(color,dst->format,&br,&bg,&bb);
2095 }
2096 else
2097 {
2098 /* this a RGB color */
2099 r = color & dst->format->Rmask;
2100 r = r >> dst->format->Rshift;
2101 r = r << dst->format->Rloss;
2102 br = r;
2103
2104 g = color & dst->format->Gmask;
2105 g = g >> dst->format->Gshift;
2106 g = g << dst->format->Gloss;
2107 bg = g;
2108
2109 b = color & dst->format->Bmask;
2110 b = b >> dst->format->Bshift;
2111 b = b << dst->format->Bloss;
2112 bb = b;
2113 }
2114
2115 if(vs != dst)
2116 {
2117 /* draw a rect offscreen */
2118 glSDL_Invalidate(dst, dstrect);
2119 /* software-fill the surface by faking it as a SW_SURFACE */
2120 dst->flags&=~SDL_HWSURFACE;
2121 SDL_FillRect(dst,dstrect,color);
2122 dst->flags|=SDL_HWSURFACE;
2123 }
2124 else
2125 {
2126 /* draw a rect onscreen */
2127 glSDL_do_texture(this, 0);
2128 glSDL_do_blend(this, 0);
2129
2130 dx1 = dstrect->x;
2131 dy1 = dstrect->y;
2132 dx2 = dx1 + dstrect->w;
2133 dy2 = dy1 + dstrect->h;
2134
2135 this->glBegin(GL_TRIANGLE_FAN);
2136 this->glColor3ub(br, bg, bb);
2137 this->glVertex2i(dx1, dy1);
2138 this->glVertex2i(dx2, dy1);
2139 this->glVertex2i(dx2, dy2);
2140 this->glVertex2i(dx1, dy2);
2141 this->glEnd();
2142 }
2143 return 0;
2144 }
2145
2146 static int glSDL_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)
2147 {
2148 src->flags |= SDL_HWACCEL;
2149 src->map->hw_blit = glSDL_HWAccelBlit;
2150 return 1;
2151 }
2152
2153
2154 static SDL_Surface *glSDL_DisplayFormat(SDL_Surface *surface)
2155 {
2156 SDL_Surface *tmp;
2157 int use_rgba = (surface->flags & SDL_SRCCOLORKEY) ||
2158 ((surface->flags & SDL_SRCALPHA) &&
2159 surface->format->Amask);
2160 #ifdef DEBUG_GLSDL
2161 fprintf(stderr,"#### glSDL_DisplayFormat()\n");
2162 #endif
2163 if(use_rgba)
2164 tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE);
2165 else
2166 tmp = glSDL_ConvertSurface(surface, RGBfmt, SDL_SWSURFACE);
2167 if(!tmp)
2168 {
2169 GLERR("glSDL_DisplayFormat() could not convert surface!");
2170 return NULL;
2171 }
2172 SDL_SetAlpha(tmp, 0, 0);
2173
2174 if(surface->flags & SDL_SRCCOLORKEY)
2175 {
2176 /*
2177 * We drop colorkey data here, but we have to,
2178 * or we'll run into trouble when converting,
2179 * in particular from indexed color formats.
2180 */
2181 SDL_SetColorKey(tmp, SDL_SRCCOLORKEY,
2182 surface->format->colorkey);
2183 glSDL_key2alpha(tmp);
2184 SDL_SetColorKey(tmp, 0, 0);
2185 }
2186
2187 return tmp;
2188 }
2189
2190
2191 static SDL_Surface *glSDL_DisplayFormatAlpha(SDL_Surface *surface)
2192 {
2193 SDL_Surface *s, *tmp;
2194 tmp = glSDL_ConvertSurface(surface, RGBAfmt, SDL_SWSURFACE);
2195 #ifdef DEBUG_GLSDL
2196 fprintf(stderr,"#### glSDL_DisplayFormatAlpha()\n");
2197 #endif
2198 if(!tmp)
2199 return NULL;
2200
2201 SDL_SetAlpha(tmp, 0, 0);
2202 SDL_SetColorKey(tmp, 0, 0);
2203 s = glSDL_CreateRGBASurface(surface->w, surface->h);
2204 if(!s)
2205 {
2206 SDL_FreeSurface(tmp);
2207 return NULL;
2208 }
2209 glSDL_SoftBlit(tmp, NULL, s, NULL);
2210 SDL_FreeSurface(tmp);
2211
2212 if(surface->flags & SDL_SRCCOLORKEY)
2213 {
2214 SDL_SetColorKey(s, SDL_SRCCOLORKEY,
2215 surface->format->colorkey);
2216 glSDL_key2alpha(s);
2217 SDL_SetColorKey(s, 0, 0);
2218 }
2219
2220 if(surface->flags & SDL_SRCALPHA)
2221 SDL_SetAlpha(s, SDL_SRCALPHA,
2222 surface->format->alpha);
2223 return s;
2224 }
2225
2226
2227 /*----------------------------------------------------------
2228 glSDL specific API extensions
2229 ----------------------------------------------------------*/
2230
2231 static void glSDL_Invalidate(SDL_Surface *surface, SDL_Rect *area)
2232 {
2233 private_hwdata *txi;
2234 if(!surface)
2235 return;
2236 txi = glSDL_GetTexInfo(surface);
2237 if(!txi)
2238 return;
2239 if(!area)
2240 {
2241 txi->invalid_area.x = 0;
2242 txi->invalid_area.y = 0;
2243 txi->invalid_area.w = surface->w;
2244 txi->invalid_area.h = surface->h;
2245 return;
2246 }
2247 txi->invalid_area = *area;
2248 }
2249
2250
2251 static void glSDL_SetLogicSize(_THIS, SDL_Surface *surface, int w, int h)
2252 {
2253 SDL_Rect r;
2254 private_hwdata *txi;
2255 if(!IS_GLSDL_SURFACE(surface))
2256 return;
2257
2258 txi = glSDL_GetTexInfo(surface);
2259
2260 txi->lw = w;
2261 txi->lh = h;
2262
2263 if(SDL_VideoSurface != surface)
2264 return;
2265
2266 r.x = r.y = 0;
2267 r.w = w;
2268 r.h = h;
2269 glSDL_SetClipRect(this, surface, &r);
2270
2271 this->glMatrixMode(GL_MODELVIEW);
2272 this->glLoadIdentity();
2273 this->glTranslated(0.0f, 0.0f, 0.0f);
2274
2275 this->glDisable(GL_DEPTH_TEST);
2276 this->glDisable(GL_CULL_FACE);
2277
2278 glSDL_reset();
2279 }
2280
2281 static int glSDL_InitTexture(_THIS, SDL_Surface *datasurf, private_hwdata *txi, int tex)
2282 {
2283 this->glGenTextures(1, (GLuint *)&txi->texture[tex]);
2284 this->glBindTexture(GL_TEXTURE_2D, txi->texture[tex]);
2285 glstate.texture = txi->texture[tex];
2286 this->glPixelStorei(GL_UNPACK_ROW_LENGTH, datasurf->pitch /
2287 datasurf->format->BytesPerPixel);
2288 this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2289 this->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2290 this->glTexImage2D(GL_TEXTURE_2D, 0,
2291 datasurf->format->Amask ? GL_RGBA8 : GL_RGB8,
2292 txi->texsize, txi->texsize, 0,
2293 datasurf->format->Amask ? GL_RGBA : GL_RGB,
2294 GL_UNSIGNED_BYTE, NULL);
2295 #ifdef DEBUG_GLSDL
2296 glSDL_print_glerror(this, 1);
2297 #endif
2298 return 0;
2299 }
2300
2301
2302 /* Image tiled horizontally (wide surface), or not at all */
2303 static int glSDL_UploadHoriz(_THIS, SDL_Surface *datasurf, private_hwdata *txi)
2304 {
2305 int bpp = datasurf->format->BytesPerPixel;
2306 int res;
2307 int tex = 0;
2308 int fromx = 0;
2309 int toy = txi->texsize; /* To init first texture */
2310 while(1)
2311 {
2312 int thistw = datasurf->w - fromx;
2313 if(thistw > txi->tilew)
2314 thistw = txi->tilew;
2315 else if(thistw <= 0)
2316 break;
2317 if(toy + txi->tileh > txi->texsize)
2318 {
2319 toy = 0;
2320 res = glSDL_InitTexture(this, datasurf, txi, tex);
2321 if(res < 0)
2322 return res;
2323 ++tex;
2324 }
2325 this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, toy,
2326 thistw, txi->tileh,
2327 datasurf->format->Amask ? GL_RGBA : GL_RGB,
2328 GL_UNSIGNED_BYTE,
2329 (char *)datasurf->pixels + bpp * fromx);
2330 #ifdef DEBUG_GLSDL
2331 glSDL_print_glerror(this, 2);
2332 #endif
2333 fromx += txi->tilew;
2334 toy += txi->tileh;
2335 }
2336 return 0;
2337 }
2338
2339
2340 /* Image tiled vertically (tall surface) */
2341 static int glSDL_UploadVert(_THIS, SDL_Surface *datasurf, private_hwdata *txi)
2342 {
2343 int res;
2344 int tex = 0;
2345 int fromy = 0;
2346 int tox = txi->texsize; /* To init first texture */
2347 while(1)
2348 {
2349 int thisth = datasurf->h - fromy;
2350 if(thisth > txi->tileh)
2351 thisth = txi->tileh;
2352 else if(thisth <= 0)
2353 break;
2354 if(tox + txi->tilew > txi->texsize)
2355 {
2356 tox = 0;
2357 res = glSDL_InitTexture(this, datasurf, txi, tex);
2358 if(res < 0)
2359 return res;
2360 ++tex;
2361 }
2362 this->glTexSubImage2D(GL_TEXTURE_2D, 0, tox, 0,
2363 txi->tilew, thisth,
2364 datasurf->format->Amask ? GL_RGBA : GL_RGB,
2365 GL_UNSIGNED_BYTE,
2366 (char *)datasurf->pixels + datasurf->pitch * fromy);
2367 #ifdef DEBUG_GLSDL
2368 glSDL_print_glerror(this, 3);
2369 #endif
2370 fromy += txi->tileh;
2371 tox += txi->tilew;
2372 }
2373 return 0;
2374 }
2375
2376
2377 /* Image tiled two-way (huge surface) */
2378 static int glSDL_UploadHuge(_THIS, SDL_Surface *datasurf, private_hwdata *txi)
2379 {
2380 int bpp = datasurf->format->BytesPerPixel;
2381 int res;
2382 int tex = 0;
2383 int y = 0;
2384 while(y < datasurf->h)
2385 {
2386 int x;
2387 int thisth = datasurf->h - y;
2388 if(thisth > txi->tileh)
2389 thisth = txi->tileh;
2390 x = 0;
2391 while(x < datasurf->w)
2392 {
2393 int thistw = datasurf->w - x;
2394 if(thistw > txi->tilew)
2395 thistw = txi->tilew;
2396 res = glSDL_InitTexture(this, datasurf, txi, tex++);
2397 if(res < 0)
2398 return res;
2399 this->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
2400 thistw, thisth,
2401 datasurf->format->Amask ? GL_RGBA : GL_RGB,
2402 GL_UNSIGNED_BYTE,
2403 (char *)datasurf->pixels +
2404 datasurf->pitch * y + bpp * x);
2405 #ifdef DEBUG_GLSDL
2406 fprintf(stderr,"glTexSubImage(x = %d, y = %d, w = %d, h = %d)\n",
2407 x, y, thistw, thisth);
2408 glSDL_print_glerror(this, 4);
2409 #endif
2410 x += txi->tilew;
2411 }
2412 y += txi->tileh;
2413 }
2414 return 0;
2415 }
2416
2417
2418 /* Upload all textures for a surface. */
2419 static int glSDL_UploadTextures(_THIS, SDL_Surface *datasurf, private_hwdata *txi)
2420 {
2421 switch(txi->tilemode)
2422 {
2423 case GLSDL_TM_SINGLE:
2424 case GLSDL_TM_HORIZONTAL:
2425 glSDL_UploadHoriz(this, datasurf, txi);
2426 break;
2427 case GLSDL_TM_VERTICAL:
2428 glSDL_UploadVert(this, datasurf, txi);
2429 break;
2430 case GLSDL_TM_HUGE:
2431 glSDL_UploadHuge(this, datasurf, txi);
2432 break;
2433 }
2434 return 0;
2435 }
2436
2437
2438 /*
2439 * IMPORTANT:
2440 * This function will try various ways of giving you
2441 * a TexInfo, and will succeed most of the time.
2442 *
2443 * However, the TexInfo returned may be temporary,
2444 * (as opposed to connected to 'surface'). A temporary
2445 * TexInfo must be used only once and then thrown away,
2446 * since it means that glSDL cannot track changes in
2447 * the pixel data of 'texture'.
2448 */
2449 static private_hwdata *glSDL_UploadSurface(_THIS, SDL_Surface *surface)
2450 {
2451 int i;
2452 int converted = 0;
2453 private_hwdata *txi = glSDL_GetTexInfo(surface);
2454
2455 if(IS_GLSDL_SURFACE(surface))
2456 {
2457 /*
2458 * Ok, this is a glSDL surface, and it *might* be
2459 * in texture memory already. If so, it may need
2460 * an update.
2461 */
2462 if(txi->invalid_area.w)
2463 {
2464 glSDL_UnloadTexture(this, txi);
2465 }
2466 else
2467 {
2468 int missing = 0;
2469 if(txi->textures)
2470 {
2471 for(i = 0; i < txi->textures; ++i)
2472 if(GLSDL_NOTEX == txi->texture[i])
2473 {
2474 missing = 1;
2475 break;
2476 }
2477 if(!missing)
2478 return txi; /* They're already there! */
2479 }
2480 }
2481 }
2482 else
2483 {
2484 /*
2485 * Nope, this isn't (yet) a glSDL surface. Let's
2486 * try to either make it one, or set up a temporary
2487 * TexInfo for it, valid for only one blit.
2488 */
2489 if( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE )
2490 {
2491 txi = glSDL_AddTexInfo(this, surface);
2492 if(!txi)
2493 {
2494 GLERR("UploadSurface(): Could not add TexInfo!");
2495 return NULL;
2496 }
2497 surface->flags |= SDL_HWSURFACE;
2498 surface->flags |= SDL_HWACCEL;
2499 }
2500 else
2501 {
2502 /*
2503 * FIXME
2504 * here if the surface is small enough, it's a good
2505 * candidate for a blit using glDrawPixels instead
2506 * of a texture blit
2507 */
2508 txi = glSDL_CreateTempTexInfo(this, surface);
2509 if(!txi)
2510 {
2511 GLERR("UploadSurface(): Could not create temp TexInfo!");
2512 return NULL;
2513 }
2514 }
2515 }
2516
2517 if(txi->texsize > maxtexsize)
2518 {
2519 /* This surface wasn't tiled properly... */
2520 if(txi->temporary)
2521 glSDL_FreeTexInfo(this, txi);
2522 GLERR("UploadSurface(): Too large texture!");
2523 return NULL;
2524 }
2525
2526 /*
2527 * Kludge: Convert if not of preferred RGB or RGBA format.
2528 *
2529 * Conversion should only be done when *really* needed.
2530 * That is, it should rarely have to be done with OpenGL
2531 * 1.2+.
2532 *
2533 * Besides, any surface that's been SDL_DisplayFormat()ed
2534 * should already be in the best known OpenGL format -
2535 * preferably one that makes DMA w/o conversion possible.
2536 */
2537 if(!glSDL_FormatIsOk(surface))
2538 {
2539 #ifdef DEBUG_GLSDL
2540 fprintf(stderr, "glSDL: WARNING: On-the-fly conversion performed!\n");
2541 #endif
2542 converted = 1;
2543 /* NOTE: We forget about the original surface here. */
2544 if(surface->format->Amask)
2545 surface = glSDL_DisplayFormatAlpha(surface);
2546 else
2547 surface = glSDL_DisplayFormat(surface);
2548 if(!surface)
2549 {
2550 GLERR("UploadSurface(): Could not convert surface!");
2551 if(txi->temporary)
2552 glSDL_FreeTexInfo(this, txi);
2553 return NULL;
2554 }
2555 }
2556
2557 glSDL_UploadTextures(this, surface, txi);
2558
2559 if(converted)
2560 SDL_FreeSurface(surface);
2561
2562 return txi;
2563 }
2564
2565
2566 static void glSDL_UnloadTexture(_THIS, private_hwdata *txi)
2567 {
2568 int i;
2569 for(i = 0; i < txi->textures; ++i)
2570 if(txi->texture[i] != GLSDL_NOTEX)
2571 this->glDeleteTextures(1, &txi->texture[i]);
2572 SDL_memset(&txi->invalid_area, 0, sizeof(txi->invalid_area));
2573 }