Mercurial > sdl-ios-xcode
annotate src/video/SDL_video.c @ 1207:c9ec00d3e8bc
To: sdl@libsdl.org
From: Christian Walther <cwalther@gmx.ch>
Date: Wed, 21 Dec 2005 13:39:39 +0100
Subject: [SDL] Another mouse bug patch for Mac OS X
Oh my, yet another change in the quartz mouse handling code! :)
The attached patch fixes the following bug:
Calling SDL_WarpMouse() while the cursor is invisible and grabbed should
only update SDL's internal mouse location, not try to warp the system
cursor (which is not at that location, but fixed in the middle of the
window). Otherwise, the next mouse motion event is wrong.
Please apply.
Thanks
Christian
| author | Ryan C. Gordon <icculus@icculus.org> |
|---|---|
| date | Wed, 21 Dec 2005 18:02:36 +0000 |
| parents | 173c063d4f55 |
| children | 8609567ea02f |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
769
b8d311d90021
Updated copyright information for 2004 (Happy New Year!)
Sam Lantinga <slouken@libsdl.org>
parents:
663
diff
changeset
|
3 Copyright (C) 1997-2004 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
| 6 modify it under the terms of the GNU Library General Public | |
| 7 License as published by the Free Software Foundation; either | |
| 8 version 2 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 Library General Public License for more details. | |
| 14 | |
| 15 You should have received a copy of the GNU Library General Public | |
| 16 License along with this library; if not, write to the Free | |
| 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| 18 | |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
229
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
| 22 | |
| 23 #ifdef SAVE_RCSID | |
| 24 static char rcsid = | |
| 25 "@(#) $Id$"; | |
| 26 #endif | |
| 27 | |
| 28 /* The high-level video driver subsystem */ | |
| 29 | |
| 30 #include <stdio.h> | |
| 31 #include <stdlib.h> | |
| 32 #include <string.h> | |
| 33 | |
| 34 #include "SDL.h" | |
| 35 #include "SDL_error.h" | |
| 36 #include "SDL_video.h" | |
| 37 #include "SDL_events.h" | |
| 38 #include "SDL_mutex.h" | |
| 39 #include "SDL_sysvideo.h" | |
| 40 #include "SDL_sysevents.h" | |
| 41 #include "SDL_blit.h" | |
| 42 #include "SDL_pixels_c.h" | |
| 43 #include "SDL_events_c.h" | |
| 44 #include "SDL_cursor_c.h" | |
| 45 | |
| 46 /* Available video drivers */ | |
| 47 static VideoBootStrap *bootstrap[] = { | |
|
1133
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
1076
diff
changeset
|
48 #ifdef ENABLE_QUARTZ |
|
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
1076
diff
changeset
|
49 &QZ_bootstrap, |
|
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
1076
diff
changeset
|
50 #endif |
| 0 | 51 #ifdef ENABLE_X11 |
| 52 &X11_bootstrap, | |
| 53 #endif | |
| 54 #ifdef ENABLE_DGA | |
| 55 &DGA_bootstrap, | |
| 56 #endif | |
|
30
57bf11a5efd7
Added initial support for Nano-X (thanks Hsieh-Fu!)
Sam Lantinga <slouken@lokigames.com>
parents:
19
diff
changeset
|
57 #ifdef ENABLE_NANOX |
|
57bf11a5efd7
Added initial support for Nano-X (thanks Hsieh-Fu!)
Sam Lantinga <slouken@lokigames.com>
parents:
19
diff
changeset
|
58 &NX_bootstrap, |
|
57bf11a5efd7
Added initial support for Nano-X (thanks Hsieh-Fu!)
Sam Lantinga <slouken@lokigames.com>
parents:
19
diff
changeset
|
59 #endif |
|
1140
af8b0f9ac2f4
iPod Linux framebuffer support.
Ryan C. Gordon <icculus@icculus.org>
parents:
1133
diff
changeset
|
60 #ifdef ENABLE_IPOD |
|
af8b0f9ac2f4
iPod Linux framebuffer support.
Ryan C. Gordon <icculus@icculus.org>
parents:
1133
diff
changeset
|
61 &iPod_bootstrap, |
|
af8b0f9ac2f4
iPod Linux framebuffer support.
Ryan C. Gordon <icculus@icculus.org>
parents:
1133
diff
changeset
|
62 #endif |
| 567 | 63 #ifdef ENABLE_QTOPIA |
| 64 &Qtopia_bootstrap, | |
| 65 #endif | |
| 1187 | 66 #ifdef ENABLE_WSCONS |
| 67 &WSCONS_bootstrap, | |
| 68 #endif | |
| 0 | 69 #ifdef ENABLE_FBCON |
| 70 &FBCON_bootstrap, | |
| 71 #endif | |
|
167
cb384ef627f6
Added support for DirectFB video on Linux (thanks Denis!)
Sam Lantinga <slouken@libsdl.org>
parents:
125
diff
changeset
|
72 #ifdef ENABLE_DIRECTFB |
|
cb384ef627f6
Added support for DirectFB video on Linux (thanks Denis!)
Sam Lantinga <slouken@libsdl.org>
parents:
125
diff
changeset
|
73 &DirectFB_bootstrap, |
|
cb384ef627f6
Added support for DirectFB video on Linux (thanks Denis!)
Sam Lantinga <slouken@libsdl.org>
parents:
125
diff
changeset
|
74 #endif |
| 0 | 75 #ifdef ENABLE_PS2GS |
| 76 &PS2GS_bootstrap, | |
| 77 #endif | |
| 78 #ifdef ENABLE_GGI | |
| 79 &GGI_bootstrap, | |
| 80 #endif | |
|
75
b0ae59d0f3ee
Added patches from FreeBSD ports
Sam Lantinga <slouken@lokigames.com>
parents:
58
diff
changeset
|
81 #ifdef ENABLE_VGL |
|
b0ae59d0f3ee
Added patches from FreeBSD ports
Sam Lantinga <slouken@lokigames.com>
parents:
58
diff
changeset
|
82 &VGL_bootstrap, |
|
b0ae59d0f3ee
Added patches from FreeBSD ports
Sam Lantinga <slouken@lokigames.com>
parents:
58
diff
changeset
|
83 #endif |
| 0 | 84 #ifdef ENABLE_SVGALIB |
| 85 &SVGALIB_bootstrap, | |
| 86 #endif | |
| 87 #ifdef ENABLE_AALIB | |
|
610
95433459fbd2
Date: Mon, 14 Apr 2003 22:08:27 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
580
diff
changeset
|
88 &AALIB_bootstrap, |
| 0 | 89 #endif |
| 90 #ifdef ENABLE_DIRECTX | |
| 91 &DIRECTX_bootstrap, | |
| 92 #endif | |
| 93 #ifdef ENABLE_WINDIB | |
| 94 &WINDIB_bootstrap, | |
| 95 #endif | |
| 96 #ifdef ENABLE_BWINDOW | |
| 97 &BWINDOW_bootstrap, | |
| 98 #endif | |
| 99 #ifdef ENABLE_TOOLBOX | |
| 100 &TOOLBOX_bootstrap, | |
| 101 #endif | |
| 102 #ifdef ENABLE_DRAWSPROCKET | |
| 103 &DSp_bootstrap, | |
| 104 #endif | |
| 105 #ifdef ENABLE_CYBERGRAPHICS | |
| 106 &CGX_bootstrap, | |
| 107 #endif | |
|
173
83018110dce8
Added initial support for EPOC/Symbian OS (thanks Hannu!)
Sam Lantinga <slouken@libsdl.org>
parents:
167
diff
changeset
|
108 #ifdef ENABLE_PHOTON |
|
83018110dce8
Added initial support for EPOC/Symbian OS (thanks Hannu!)
Sam Lantinga <slouken@libsdl.org>
parents:
167
diff
changeset
|
109 &ph_bootstrap, |
|
83018110dce8
Added initial support for EPOC/Symbian OS (thanks Hannu!)
Sam Lantinga <slouken@libsdl.org>
parents:
167
diff
changeset
|
110 #endif |
|
83018110dce8
Added initial support for EPOC/Symbian OS (thanks Hannu!)
Sam Lantinga <slouken@libsdl.org>
parents:
167
diff
changeset
|
111 #ifdef ENABLE_EPOC |
|
83018110dce8
Added initial support for EPOC/Symbian OS (thanks Hannu!)
Sam Lantinga <slouken@libsdl.org>
parents:
167
diff
changeset
|
112 &EPOC_bootstrap, |
|
83018110dce8
Added initial support for EPOC/Symbian OS (thanks Hannu!)
Sam Lantinga <slouken@libsdl.org>
parents:
167
diff
changeset
|
113 #endif |
|
281
c5010ab8ba35
Added initial support for Atari (thanks Patrice!)
Sam Lantinga <slouken@libsdl.org>
parents:
266
diff
changeset
|
114 #ifdef ENABLE_XBIOS |
|
c5010ab8ba35
Added initial support for Atari (thanks Patrice!)
Sam Lantinga <slouken@libsdl.org>
parents:
266
diff
changeset
|
115 &XBIOS_bootstrap, |
|
c5010ab8ba35
Added initial support for Atari (thanks Patrice!)
Sam Lantinga <slouken@libsdl.org>
parents:
266
diff
changeset
|
116 #endif |
|
c5010ab8ba35
Added initial support for Atari (thanks Patrice!)
Sam Lantinga <slouken@libsdl.org>
parents:
266
diff
changeset
|
117 #ifdef ENABLE_GEM |
|
c5010ab8ba35
Added initial support for Atari (thanks Patrice!)
Sam Lantinga <slouken@libsdl.org>
parents:
266
diff
changeset
|
118 &GEM_bootstrap, |
|
c5010ab8ba35
Added initial support for Atari (thanks Patrice!)
Sam Lantinga <slouken@libsdl.org>
parents:
266
diff
changeset
|
119 #endif |
|
433
706de3956894
Added initial support for PicoGUI (thanks Micah!)
Sam Lantinga <slouken@libsdl.org>
parents:
430
diff
changeset
|
120 #ifdef ENABLE_PICOGUI |
|
706de3956894
Added initial support for PicoGUI (thanks Micah!)
Sam Lantinga <slouken@libsdl.org>
parents:
430
diff
changeset
|
121 &PG_bootstrap, |
|
706de3956894
Added initial support for PicoGUI (thanks Micah!)
Sam Lantinga <slouken@libsdl.org>
parents:
430
diff
changeset
|
122 #endif |
|
509
dad72daf44b3
Added initial support for Dreamcast (thanks HERO!)
Sam Lantinga <slouken@libsdl.org>
parents:
488
diff
changeset
|
123 #ifdef ENABLE_DC |
|
dad72daf44b3
Added initial support for Dreamcast (thanks HERO!)
Sam Lantinga <slouken@libsdl.org>
parents:
488
diff
changeset
|
124 &DC_bootstrap, |
|
dad72daf44b3
Added initial support for Dreamcast (thanks HERO!)
Sam Lantinga <slouken@libsdl.org>
parents:
488
diff
changeset
|
125 #endif |
|
630
550bccdf04bd
Added initial support for RISC OS (thanks Peter Naulls!)
Sam Lantinga <slouken@libsdl.org>
parents:
610
diff
changeset
|
126 #ifdef ENABLE_RISCOS |
|
550bccdf04bd
Added initial support for RISC OS (thanks Peter Naulls!)
Sam Lantinga <slouken@libsdl.org>
parents:
610
diff
changeset
|
127 &RISCOS_bootstrap, |
|
550bccdf04bd
Added initial support for RISC OS (thanks Peter Naulls!)
Sam Lantinga <slouken@libsdl.org>
parents:
610
diff
changeset
|
128 #endif |
| 1190 | 129 #ifdef __OS2__ |
| 130 &OS2FSLib_bootstrap, | |
| 131 #endif | |
|
610
95433459fbd2
Date: Mon, 14 Apr 2003 22:08:27 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
580
diff
changeset
|
132 #ifdef ENABLE_DUMMYVIDEO |
|
95433459fbd2
Date: Mon, 14 Apr 2003 22:08:27 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
580
diff
changeset
|
133 &DUMMY_bootstrap, |
|
95433459fbd2
Date: Mon, 14 Apr 2003 22:08:27 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
580
diff
changeset
|
134 #endif |
| 0 | 135 NULL |
| 136 }; | |
|
173
83018110dce8
Added initial support for EPOC/Symbian OS (thanks Hannu!)
Sam Lantinga <slouken@libsdl.org>
parents:
167
diff
changeset
|
137 |
| 0 | 138 SDL_VideoDevice *current_video = NULL; |
| 139 | |
| 140 /* Various local functions */ | |
| 141 int SDL_VideoInit(const char *driver_name, Uint32 flags); | |
| 142 void SDL_VideoQuit(void); | |
| 143 void SDL_GL_UpdateRectsLock(SDL_VideoDevice* this, int numrects, SDL_Rect* rects); | |
| 144 | |
| 145 static SDL_GrabMode SDL_WM_GrabInputOff(void); | |
| 146 #ifdef HAVE_OPENGL | |
| 147 static int lock_count = 0; | |
| 148 #endif | |
| 149 | |
| 150 | |
| 151 /* | |
| 152 * Initialize the video and event subsystems -- determine native pixel format | |
| 153 */ | |
| 154 int SDL_VideoInit (const char *driver_name, Uint32 flags) | |
| 155 { | |
| 156 SDL_VideoDevice *video; | |
| 157 int index; | |
| 158 int i; | |
| 159 SDL_PixelFormat vformat; | |
| 160 Uint32 video_flags; | |
| 161 | |
| 162 /* Toggle the event thread flags, based on OS requirements */ | |
| 163 #if defined(MUST_THREAD_EVENTS) | |
| 164 flags |= SDL_INIT_EVENTTHREAD; | |
| 165 #elif defined(CANT_THREAD_EVENTS) | |
| 166 if ( (flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD ) { | |
| 167 SDL_SetError("OS doesn't support threaded events"); | |
| 168 return(-1); | |
| 169 } | |
| 170 #endif | |
| 171 | |
| 172 /* Check to make sure we don't overwrite 'current_video' */ | |
| 173 if ( current_video != NULL ) { | |
| 174 SDL_VideoQuit(); | |
| 175 } | |
| 176 | |
| 177 /* Select the proper video driver */ | |
| 178 index = 0; | |
| 179 video = NULL; | |
| 180 if ( driver_name != NULL ) { | |
| 181 #if 0 /* This will be replaced with a better driver selection API */ | |
| 182 if ( strrchr(driver_name, ':') != NULL ) { | |
| 183 index = atoi(strrchr(driver_name, ':')+1); | |
| 184 } | |
| 185 #endif | |
| 186 for ( i=0; bootstrap[i]; ++i ) { | |
| 187 if ( strncmp(bootstrap[i]->name, driver_name, | |
| 188 strlen(bootstrap[i]->name)) == 0 ) { | |
| 189 if ( bootstrap[i]->available() ) { | |
| 190 video = bootstrap[i]->create(index); | |
| 191 break; | |
| 192 } | |
| 193 } | |
| 194 } | |
| 195 } else { | |
| 196 for ( i=0; bootstrap[i]; ++i ) { | |
| 197 if ( bootstrap[i]->available() ) { | |
| 198 video = bootstrap[i]->create(index); | |
| 199 if ( video != NULL ) { | |
| 200 break; | |
| 201 } | |
| 202 } | |
| 203 } | |
| 204 } | |
| 205 if ( video == NULL ) { | |
| 206 SDL_SetError("No available video device"); | |
| 207 return(-1); | |
| 208 } | |
| 209 current_video = video; | |
| 210 current_video->name = bootstrap[i]->name; | |
| 211 | |
| 212 /* Do some basic variable initialization */ | |
| 213 video->screen = NULL; | |
| 214 video->shadow = NULL; | |
| 215 video->visible = NULL; | |
| 216 video->physpal = NULL; | |
| 217 video->gammacols = NULL; | |
| 218 video->gamma = NULL; | |
| 219 video->wm_title = NULL; | |
| 220 video->wm_icon = NULL; | |
| 221 video->offset_x = 0; | |
| 222 video->offset_y = 0; | |
| 223 memset(&video->info, 0, (sizeof video->info)); | |
|
1052
68f607298ca9
Some work on using accelerated alpha blits with hardware surfaces.
Ryan C. Gordon <icculus@icculus.org>
parents:
1032
diff
changeset
|
224 |
|
68f607298ca9
Some work on using accelerated alpha blits with hardware surfaces.
Ryan C. Gordon <icculus@icculus.org>
parents:
1032
diff
changeset
|
225 video->displayformatalphapixel = NULL; |
| 0 | 226 |
| 227 /* Set some very sane GL defaults */ | |
| 228 video->gl_config.driver_loaded = 0; | |
| 229 video->gl_config.dll_handle = NULL; | |
| 230 video->gl_config.red_size = 5; | |
| 231 #if 1 /* This seems to work on more video cards, as a default */ | |
| 232 video->gl_config.green_size = 5; | |
| 233 #else | |
| 234 video->gl_config.green_size = 6; | |
| 235 #endif | |
| 236 video->gl_config.blue_size = 5; | |
| 237 video->gl_config.alpha_size = 0; | |
| 238 video->gl_config.buffer_size = 0; | |
| 239 video->gl_config.depth_size = 16; | |
| 240 video->gl_config.stencil_size = 0; | |
| 241 video->gl_config.double_buffer = 1; | |
| 242 video->gl_config.accum_red_size = 0; | |
| 243 video->gl_config.accum_green_size = 0; | |
| 244 video->gl_config.accum_blue_size = 0; | |
| 245 video->gl_config.accum_alpha_size = 0; | |
|
450
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
246 video->gl_config.stereo = 0; |
|
656
864e2d2a9a55
Merged in Ryan's multisample code for MacOS, and changed the constants to match.
Sam Lantinga <slouken@libsdl.org>
parents:
655
diff
changeset
|
247 video->gl_config.multisamplebuffers = 0; |
|
864e2d2a9a55
Merged in Ryan's multisample code for MacOS, and changed the constants to match.
Sam Lantinga <slouken@libsdl.org>
parents:
655
diff
changeset
|
248 video->gl_config.multisamplesamples = 0; |
| 0 | 249 |
| 250 /* Initialize the video subsystem */ | |
| 251 memset(&vformat, 0, sizeof(vformat)); | |
| 252 if ( video->VideoInit(video, &vformat) < 0 ) { | |
| 253 SDL_VideoQuit(); | |
| 254 return(-1); | |
| 255 } | |
| 256 | |
| 257 /* Create a zero sized video surface of the appropriate format */ | |
| 258 video_flags = SDL_SWSURFACE; | |
| 259 SDL_VideoSurface = SDL_CreateRGBSurface(video_flags, 0, 0, | |
| 260 vformat.BitsPerPixel, | |
| 261 vformat.Rmask, vformat.Gmask, vformat.Bmask, 0); | |
| 262 if ( SDL_VideoSurface == NULL ) { | |
| 263 SDL_VideoQuit(); | |
| 264 return(-1); | |
| 265 } | |
| 266 SDL_PublicSurface = NULL; /* Until SDL_SetVideoMode() */ | |
| 267 | |
| 268 #if 0 /* Don't change the current palette - may be used by other programs. | |
| 269 * The application can't do anything with the display surface until | |
| 270 * a video mode has been set anyway. :) | |
| 271 */ | |
| 272 /* If we have a palettized surface, create a default palette */ | |
| 273 if ( SDL_VideoSurface->format->palette ) { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
274 SDL_PixelFormat *vf = SDL_VideoSurface->format; |
| 0 | 275 SDL_DitherColors(vf->palette->colors, vf->BitsPerPixel); |
| 276 video->SetColors(video, | |
| 277 0, vf->palette->ncolors, vf->palette->colors); | |
| 278 } | |
| 279 #endif | |
| 280 video->info.vfmt = SDL_VideoSurface->format; | |
| 281 | |
| 282 /* Start the event loop */ | |
| 283 if ( SDL_StartEventLoop(flags) < 0 ) { | |
| 284 SDL_VideoQuit(); | |
| 285 return(-1); | |
| 286 } | |
| 287 SDL_CursorInit(flags & SDL_INIT_EVENTTHREAD); | |
| 288 | |
| 289 /* We're ready to go! */ | |
| 290 return(0); | |
| 291 } | |
| 292 | |
| 293 char *SDL_VideoDriverName(char *namebuf, int maxlen) | |
| 294 { | |
| 295 if ( current_video != NULL ) { | |
| 296 strncpy(namebuf, current_video->name, maxlen-1); | |
| 297 namebuf[maxlen-1] = '\0'; | |
| 298 return(namebuf); | |
| 299 } | |
| 300 return(NULL); | |
| 301 } | |
| 302 | |
| 303 /* | |
| 304 * Get the current display surface | |
| 305 */ | |
| 306 SDL_Surface *SDL_GetVideoSurface(void) | |
| 307 { | |
| 308 SDL_Surface *visible; | |
| 309 | |
| 310 visible = NULL; | |
| 311 if ( current_video ) { | |
| 312 visible = current_video->visible; | |
| 313 } | |
| 314 return(visible); | |
| 315 } | |
| 316 | |
| 317 /* | |
| 318 * Get the current information about the video hardware | |
| 319 */ | |
| 320 const SDL_VideoInfo *SDL_GetVideoInfo(void) | |
| 321 { | |
| 322 const SDL_VideoInfo *info; | |
| 323 | |
| 324 info = NULL; | |
| 325 if ( current_video ) { | |
| 326 info = ¤t_video->info; | |
| 327 } | |
| 328 return(info); | |
| 329 } | |
| 330 | |
| 331 /* | |
| 332 * Return a pointer to an array of available screen dimensions for the | |
| 333 * given format, sorted largest to smallest. Returns NULL if there are | |
| 334 * no dimensions available for a particular format, or (SDL_Rect **)-1 | |
| 335 * if any dimension is okay for the given format. If 'format' is NULL, | |
| 336 * the mode list will be for the format given by SDL_GetVideoInfo()->vfmt | |
| 337 */ | |
| 338 SDL_Rect ** SDL_ListModes (SDL_PixelFormat *format, Uint32 flags) | |
| 339 { | |
| 340 SDL_VideoDevice *video = current_video; | |
| 341 SDL_VideoDevice *this = current_video; | |
| 342 SDL_Rect **modes; | |
| 343 | |
| 344 modes = NULL; | |
| 345 if ( SDL_VideoSurface ) { | |
| 346 if ( format == NULL ) { | |
| 347 format = SDL_VideoSurface->format; | |
| 348 } | |
| 349 modes = video->ListModes(this, format, flags); | |
| 350 } | |
| 351 return(modes); | |
| 352 } | |
| 353 | |
| 354 /* | |
| 355 * Check to see if a particular video mode is supported. | |
| 356 * It returns 0 if the requested mode is not supported under any bit depth, | |
| 357 * or returns the bits-per-pixel of the closest available mode with the | |
| 358 * given width and height. If this bits-per-pixel is different from the | |
| 359 * one used when setting the video mode, SDL_SetVideoMode() will succeed, | |
| 360 * but will emulate the requested bits-per-pixel with a shadow surface. | |
| 361 */ | |
| 362 static Uint8 SDL_closest_depths[4][8] = { | |
| 363 /* 8 bit closest depth ordering */ | |
| 364 { 0, 8, 16, 15, 32, 24, 0, 0 }, | |
| 365 /* 15,16 bit closest depth ordering */ | |
| 366 { 0, 16, 15, 32, 24, 8, 0, 0 }, | |
| 367 /* 24 bit closest depth ordering */ | |
| 368 { 0, 24, 32, 16, 15, 8, 0, 0 }, | |
| 369 /* 32 bit closest depth ordering */ | |
| 370 { 0, 32, 16, 15, 24, 8, 0, 0 } | |
| 371 }; | |
| 372 | |
|
853
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
373 |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
374 #ifdef macintosh /* MPW optimization bug? */ |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
375 #define NEGATIVE_ONE 0xFFFFFFFF |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
376 #else |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
377 #define NEGATIVE_ONE -1 |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
378 #endif |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
379 |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
380 int SDL_VideoModeOK (int width, int height, int bpp, Uint32 flags) |
| 0 | 381 { |
| 382 int table, b, i; | |
| 383 int supported; | |
| 384 SDL_PixelFormat format; | |
| 385 SDL_Rect **sizes; | |
| 386 | |
| 387 /* Currently 1 and 4 bpp are not supported */ | |
| 388 if ( bpp < 8 || bpp > 32 ) { | |
| 389 return(0); | |
| 390 } | |
|
456
b4e14b15af3c
Fixed crash with invalid bpp in SDL_SetVideoMode()
Sam Lantinga <slouken@libsdl.org>
parents:
450
diff
changeset
|
391 if ( (width <= 0) || (height <= 0) ) { |
| 0 | 392 return(0); |
| 393 } | |
| 394 | |
| 395 /* Search through the list valid of modes */ | |
| 396 memset(&format, 0, sizeof(format)); | |
| 397 supported = 0; | |
| 398 table = ((bpp+7)/8)-1; | |
| 399 SDL_closest_depths[table][0] = bpp; | |
| 400 SDL_closest_depths[table][7] = 0; | |
| 401 for ( b = 0; !supported && SDL_closest_depths[table][b]; ++b ) { | |
| 402 format.BitsPerPixel = SDL_closest_depths[table][b]; | |
| 403 sizes = SDL_ListModes(&format, flags); | |
| 404 if ( sizes == (SDL_Rect **)0 ) { | |
| 405 /* No sizes supported at this bit-depth */ | |
| 406 continue; | |
| 407 } else | |
|
853
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
408 if (sizes == (SDL_Rect **)NEGATIVE_ONE) { |
| 0 | 409 /* Any size supported at this bit-depth */ |
| 410 supported = 1; | |
| 411 continue; | |
|
853
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
412 } else if (current_video->handles_any_size) { |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
413 /* Driver can center a smaller surface to simulate fullscreen */ |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
414 for ( i=0; sizes[i]; ++i ) { |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
415 if ((sizes[i]->w >= width) && (sizes[i]->h >= height)) { |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
416 supported = 1; /* this mode can fit the centered window. */ |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
417 break; |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
418 } |
|
dddfc37e1f65
Don't allow video modes larger than the maximum size
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
419 } |
| 0 | 420 } else |
| 421 for ( i=0; sizes[i]; ++i ) { | |
| 422 if ((sizes[i]->w == width) && (sizes[i]->h == height)) { | |
| 423 supported = 1; | |
| 424 break; | |
| 425 } | |
| 426 } | |
| 427 } | |
| 428 if ( supported ) { | |
| 429 --b; | |
| 430 return(SDL_closest_depths[table][b]); | |
| 431 } else { | |
| 432 return(0); | |
| 433 } | |
| 434 } | |
| 435 | |
| 436 /* | |
| 437 * Get the closest non-emulated video mode to the one requested | |
| 438 */ | |
| 439 static int SDL_GetVideoMode (int *w, int *h, int *BitsPerPixel, Uint32 flags) | |
| 440 { | |
| 441 int table, b, i; | |
| 442 int supported; | |
| 443 int native_bpp; | |
| 444 SDL_PixelFormat format; | |
| 445 SDL_Rect **sizes; | |
| 446 | |
|
456
b4e14b15af3c
Fixed crash with invalid bpp in SDL_SetVideoMode()
Sam Lantinga <slouken@libsdl.org>
parents:
450
diff
changeset
|
447 /* Check parameters */ |
|
b4e14b15af3c
Fixed crash with invalid bpp in SDL_SetVideoMode()
Sam Lantinga <slouken@libsdl.org>
parents:
450
diff
changeset
|
448 if ( *BitsPerPixel < 8 || *BitsPerPixel > 32 ) { |
|
b4e14b15af3c
Fixed crash with invalid bpp in SDL_SetVideoMode()
Sam Lantinga <slouken@libsdl.org>
parents:
450
diff
changeset
|
449 SDL_SetError("Invalid bits per pixel (range is {8...32})"); |
|
b4e14b15af3c
Fixed crash with invalid bpp in SDL_SetVideoMode()
Sam Lantinga <slouken@libsdl.org>
parents:
450
diff
changeset
|
450 return(0); |
|
b4e14b15af3c
Fixed crash with invalid bpp in SDL_SetVideoMode()
Sam Lantinga <slouken@libsdl.org>
parents:
450
diff
changeset
|
451 } |
|
430
60effdbf14ee
Make sure width and height passed to SDL_GetVideoMode() are sane.
Ryan C. Gordon <icculus@icculus.org>
parents:
423
diff
changeset
|
452 if ((*w <= 0) || (*h <= 0)) { |
|
456
b4e14b15af3c
Fixed crash with invalid bpp in SDL_SetVideoMode()
Sam Lantinga <slouken@libsdl.org>
parents:
450
diff
changeset
|
453 SDL_SetError("Invalid width or height"); |
|
430
60effdbf14ee
Make sure width and height passed to SDL_GetVideoMode() are sane.
Ryan C. Gordon <icculus@icculus.org>
parents:
423
diff
changeset
|
454 return(0); |
|
60effdbf14ee
Make sure width and height passed to SDL_GetVideoMode() are sane.
Ryan C. Gordon <icculus@icculus.org>
parents:
423
diff
changeset
|
455 } |
|
60effdbf14ee
Make sure width and height passed to SDL_GetVideoMode() are sane.
Ryan C. Gordon <icculus@icculus.org>
parents:
423
diff
changeset
|
456 |
| 0 | 457 /* Try the original video mode, get the closest depth */ |
| 458 native_bpp = SDL_VideoModeOK(*w, *h, *BitsPerPixel, flags); | |
| 459 if ( native_bpp == *BitsPerPixel ) { | |
| 460 return(1); | |
| 461 } | |
| 462 if ( native_bpp > 0 ) { | |
| 463 *BitsPerPixel = native_bpp; | |
| 464 return(1); | |
| 465 } | |
| 466 | |
| 467 /* No exact size match at any depth, look for closest match */ | |
| 468 memset(&format, 0, sizeof(format)); | |
| 469 supported = 0; | |
| 470 table = ((*BitsPerPixel+7)/8)-1; | |
| 471 SDL_closest_depths[table][0] = *BitsPerPixel; | |
| 472 SDL_closest_depths[table][7] = SDL_VideoSurface->format->BitsPerPixel; | |
| 473 for ( b = 0; !supported && SDL_closest_depths[table][b]; ++b ) { | |
|
1076
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
474 int best; |
|
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
475 |
| 0 | 476 format.BitsPerPixel = SDL_closest_depths[table][b]; |
| 477 sizes = SDL_ListModes(&format, flags); | |
| 478 if ( sizes == (SDL_Rect **)0 ) { | |
| 479 /* No sizes supported at this bit-depth */ | |
| 480 continue; | |
| 481 } | |
|
1076
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
482 best=0; |
| 0 | 483 for ( i=0; sizes[i]; ++i ) { |
|
1076
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
484 /* Mode with both dimensions bigger or equal than asked ? */ |
|
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
485 if ((sizes[i]->w >= *w) && (sizes[i]->h >= *h)) { |
|
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
486 /* Mode with any dimension smaller or equal than current best ? */ |
|
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
487 if ((sizes[i]->w <= sizes[best]->w) || (sizes[i]->h <= sizes[best]->h)) { |
|
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
488 best=i; |
| 0 | 489 supported = 1; |
| 490 } | |
| 491 } | |
| 492 } | |
|
1076
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
493 if (supported) { |
|
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
494 *w=sizes[best]->w; |
|
8d3b95ece376
[PATCH] SDL_GetVideoMode() do not find the best video mode
Patrice Mandin <patmandin@gmail.com>
parents:
1052
diff
changeset
|
495 *h=sizes[best]->h; |
| 0 | 496 *BitsPerPixel = SDL_closest_depths[table][b]; |
| 497 } | |
| 498 } | |
| 499 if ( ! supported ) { | |
| 500 SDL_SetError("No video mode large enough for %dx%d", *w, *h); | |
| 501 } | |
| 502 return(supported); | |
| 503 } | |
| 504 | |
| 505 /* This should probably go somewhere else -- like SDL_surface.c */ | |
| 506 static void SDL_ClearSurface(SDL_Surface *surface) | |
| 507 { | |
| 508 Uint32 black; | |
| 509 | |
| 510 black = SDL_MapRGB(surface->format, 0, 0, 0); | |
| 511 SDL_FillRect(surface, NULL, black); | |
| 512 if ((surface->flags&SDL_HWSURFACE) && (surface->flags&SDL_DOUBLEBUF)) { | |
| 513 SDL_Flip(surface); | |
| 514 SDL_FillRect(surface, NULL, black); | |
| 515 } | |
| 516 SDL_Flip(surface); | |
| 517 } | |
| 518 | |
| 519 /* | |
| 520 * Create a shadow surface suitable for fooling the app. :-) | |
| 521 */ | |
| 522 static void SDL_CreateShadowSurface(int depth) | |
| 523 { | |
| 524 Uint32 Rmask, Gmask, Bmask; | |
| 525 | |
| 526 /* Allocate the shadow surface */ | |
| 527 if ( depth == (SDL_VideoSurface->format)->BitsPerPixel ) { | |
| 528 Rmask = (SDL_VideoSurface->format)->Rmask; | |
| 529 Gmask = (SDL_VideoSurface->format)->Gmask; | |
| 530 Bmask = (SDL_VideoSurface->format)->Bmask; | |
| 531 } else { | |
| 532 Rmask = Gmask = Bmask = 0; | |
| 533 } | |
| 534 SDL_ShadowSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, | |
| 535 SDL_VideoSurface->w, SDL_VideoSurface->h, | |
| 536 depth, Rmask, Gmask, Bmask, 0); | |
| 537 if ( SDL_ShadowSurface == NULL ) { | |
| 538 return; | |
| 539 } | |
| 540 | |
| 541 /* 8-bit shadow surfaces report that they have exclusive palette */ | |
| 542 if ( SDL_ShadowSurface->format->palette ) { | |
| 543 SDL_ShadowSurface->flags |= SDL_HWPALETTE; | |
| 544 if ( depth == (SDL_VideoSurface->format)->BitsPerPixel ) { | |
| 545 memcpy(SDL_ShadowSurface->format->palette->colors, | |
| 546 SDL_VideoSurface->format->palette->colors, | |
| 547 SDL_VideoSurface->format->palette->ncolors* | |
| 548 sizeof(SDL_Color)); | |
| 549 } else { | |
| 550 SDL_DitherColors( | |
| 551 SDL_ShadowSurface->format->palette->colors, depth); | |
| 552 } | |
| 553 } | |
| 554 | |
| 555 /* If the video surface is resizable, the shadow should say so */ | |
| 556 if ( (SDL_VideoSurface->flags & SDL_RESIZABLE) == SDL_RESIZABLE ) { | |
| 557 SDL_ShadowSurface->flags |= SDL_RESIZABLE; | |
| 558 } | |
| 559 /* If the video surface has no frame, the shadow should say so */ | |
| 560 if ( (SDL_VideoSurface->flags & SDL_NOFRAME) == SDL_NOFRAME ) { | |
| 561 SDL_ShadowSurface->flags |= SDL_NOFRAME; | |
| 562 } | |
| 563 /* If the video surface is fullscreen, the shadow should say so */ | |
| 564 if ( (SDL_VideoSurface->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 565 SDL_ShadowSurface->flags |= SDL_FULLSCREEN; | |
| 566 } | |
| 567 /* If the video surface is flippable, the shadow should say so */ | |
| 568 if ( (SDL_VideoSurface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { | |
| 569 SDL_ShadowSurface->flags |= SDL_DOUBLEBUF; | |
| 570 } | |
| 571 return; | |
| 572 } | |
| 573 | |
|
910
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
574 #ifdef __QNXNTO__ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
575 #include <sys/neutrino.h> |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
576 #endif /* __QNXNTO__ */ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
577 |
| 0 | 578 /* |
| 579 * Set the requested video mode, allocating a shadow buffer if necessary. | |
| 580 */ | |
| 581 SDL_Surface * SDL_SetVideoMode (int width, int height, int bpp, Uint32 flags) | |
| 582 { | |
| 583 SDL_VideoDevice *video, *this; | |
| 584 SDL_Surface *prev_mode, *mode; | |
| 585 int video_w; | |
| 586 int video_h; | |
| 587 int video_bpp; | |
| 588 int is_opengl; | |
| 589 SDL_GrabMode saved_grab; | |
| 590 | |
| 591 /* Start up the video driver, if necessary.. | |
| 592 WARNING: This is the only function protected this way! | |
| 593 */ | |
| 594 if ( ! current_video ) { | |
| 595 if ( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE) < 0 ) { | |
| 596 return(NULL); | |
| 597 } | |
| 598 } | |
| 599 this = video = current_video; | |
| 600 | |
| 601 /* Default to the current video bpp */ | |
| 602 if ( bpp == 0 ) { | |
| 603 flags |= SDL_ANYFORMAT; | |
| 604 bpp = SDL_VideoSurface->format->BitsPerPixel; | |
| 605 } | |
| 606 | |
| 607 /* Get a good video mode, the closest one possible */ | |
| 608 video_w = width; | |
| 609 video_h = height; | |
| 610 video_bpp = bpp; | |
| 611 if ( ! SDL_GetVideoMode(&video_w, &video_h, &video_bpp, flags) ) { | |
| 612 return(NULL); | |
| 613 } | |
| 614 | |
| 615 /* Check the requested flags */ | |
| 616 /* There's no palette in > 8 bits-per-pixel mode */ | |
| 617 if ( video_bpp > 8 ) { | |
| 618 flags &= ~SDL_HWPALETTE; | |
| 619 } | |
| 620 #if 0 | |
| 621 if ( (flags&SDL_FULLSCREEN) != SDL_FULLSCREEN ) { | |
| 622 /* There's no windowed double-buffering */ | |
| 623 flags &= ~SDL_DOUBLEBUF; | |
| 624 } | |
| 625 #endif | |
| 626 if ( (flags&SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { | |
| 627 /* Use hardware surfaces when double-buffering */ | |
| 628 flags |= SDL_HWSURFACE; | |
| 629 } | |
| 630 | |
| 631 is_opengl = ( ( flags & SDL_OPENGL ) == SDL_OPENGL ); | |
| 632 if ( is_opengl ) { | |
| 633 /* These flags are for 2D video modes only */ | |
| 634 flags &= ~(SDL_HWSURFACE|SDL_DOUBLEBUF); | |
| 635 } | |
| 636 | |
|
14
c3e9d4a623c1
Fixed stuck keys when changing the video mode
Sam Lantinga <slouken@lokigames.com>
parents:
11
diff
changeset
|
637 /* Reset the keyboard here so event callbacks can run */ |
|
c3e9d4a623c1
Fixed stuck keys when changing the video mode
Sam Lantinga <slouken@lokigames.com>
parents:
11
diff
changeset
|
638 SDL_ResetKeyboard(); |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
456
diff
changeset
|
639 SDL_ResetMouse(); |
|
14
c3e9d4a623c1
Fixed stuck keys when changing the video mode
Sam Lantinga <slouken@lokigames.com>
parents:
11
diff
changeset
|
640 |
| 0 | 641 /* Clean up any previous video mode */ |
| 642 if ( SDL_PublicSurface != NULL ) { | |
| 643 SDL_PublicSurface = NULL; | |
| 644 } | |
| 645 if ( SDL_ShadowSurface != NULL ) { | |
| 646 SDL_Surface *ready_to_go; | |
| 647 ready_to_go = SDL_ShadowSurface; | |
| 648 SDL_ShadowSurface = NULL; | |
| 649 SDL_FreeSurface(ready_to_go); | |
| 650 } | |
| 651 if ( video->physpal ) { | |
| 652 free(video->physpal->colors); | |
| 653 free(video->physpal); | |
| 654 video->physpal = NULL; | |
| 655 } | |
| 656 if( video->gammacols) { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
657 free(video->gammacols); |
| 0 | 658 video->gammacols = NULL; |
| 659 } | |
| 660 | |
| 661 /* Save the previous grab state and turn off grab for mode switch */ | |
| 662 saved_grab = SDL_WM_GrabInputOff(); | |
| 663 | |
| 664 /* Try to set the video mode, along with offset and clipping */ | |
| 665 prev_mode = SDL_VideoSurface; | |
| 666 SDL_LockCursor(); | |
| 667 SDL_VideoSurface = NULL; /* In case it's freed by driver */ | |
| 668 mode = video->SetVideoMode(this, prev_mode,video_w,video_h,video_bpp,flags); | |
| 669 if ( mode ) { /* Prevent resize events from mode change */ | |
| 1190 | 670 /* But not on OS/2 */ |
| 671 #ifndef __OS2__ | |
| 0 | 672 SDL_PrivateResize(mode->w, mode->h); |
| 1190 | 673 #endif |
|
229
4d24d5a660a8
Fix a crash if an OpenGL video mode can't be set.
Sam Lantinga <slouken@libsdl.org>
parents:
216
diff
changeset
|
674 |
|
4d24d5a660a8
Fix a crash if an OpenGL video mode can't be set.
Sam Lantinga <slouken@libsdl.org>
parents:
216
diff
changeset
|
675 /* Sam - If we asked for OpenGL mode, and didn't get it, fail */ |
|
4d24d5a660a8
Fix a crash if an OpenGL video mode can't be set.
Sam Lantinga <slouken@libsdl.org>
parents:
216
diff
changeset
|
676 if ( is_opengl && !(mode->flags & SDL_OPENGL) ) { |
|
4d24d5a660a8
Fix a crash if an OpenGL video mode can't be set.
Sam Lantinga <slouken@libsdl.org>
parents:
216
diff
changeset
|
677 mode = NULL; |
|
883
50f5a29c6a17
Date: Sat, 10 Apr 2004 02:25:33 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
853
diff
changeset
|
678 SDL_SetError("OpenGL not available"); |
|
229
4d24d5a660a8
Fix a crash if an OpenGL video mode can't be set.
Sam Lantinga <slouken@libsdl.org>
parents:
216
diff
changeset
|
679 } |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
680 } |
| 0 | 681 /* |
| 682 * rcg11292000 | |
| 683 * If you try to set an SDL_OPENGL surface, and fail to find a | |
| 684 * matching visual, then the next call to SDL_SetVideoMode() | |
| 685 * will segfault, since we no longer point to a dummy surface, | |
| 686 * but rather NULL. | |
| 687 * Sam 11/29/00 | |
| 688 * WARNING, we need to make sure that the previous mode hasn't | |
| 689 * already been freed by the video driver. What do we do in | |
| 690 * that case? Should we call SDL_VideoInit() again? | |
| 691 */ | |
| 692 SDL_VideoSurface = (mode != NULL) ? mode : prev_mode; | |
| 693 | |
| 694 if ( (mode != NULL) && (!is_opengl) ) { | |
| 695 /* Sanity check */ | |
| 696 if ( (mode->w < width) || (mode->h < height) ) { | |
| 697 SDL_SetError("Video mode smaller than requested"); | |
| 698 return(NULL); | |
| 699 } | |
| 700 | |
| 701 /* If we have a palettized surface, create a default palette */ | |
| 702 if ( mode->format->palette ) { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
703 SDL_PixelFormat *vf = mode->format; |
| 0 | 704 SDL_DitherColors(vf->palette->colors, vf->BitsPerPixel); |
| 705 video->SetColors(this, 0, vf->palette->ncolors, | |
| 706 vf->palette->colors); | |
| 707 } | |
| 708 | |
| 709 /* Clear the surface to black */ | |
| 710 video->offset_x = 0; | |
| 711 video->offset_y = 0; | |
| 712 mode->offset = 0; | |
| 713 SDL_SetClipRect(mode, NULL); | |
| 714 SDL_ClearSurface(mode); | |
| 715 | |
| 716 /* Now adjust the offsets to match the desired mode */ | |
| 717 video->offset_x = (mode->w-width)/2; | |
| 718 video->offset_y = (mode->h-height)/2; | |
| 719 mode->offset = video->offset_y*mode->pitch + | |
| 720 video->offset_x*mode->format->BytesPerPixel; | |
| 721 #ifdef DEBUG_VIDEO | |
| 722 fprintf(stderr, | |
| 723 "Requested mode: %dx%dx%d, obtained mode %dx%dx%d (offset %d)\n", | |
| 724 width, height, bpp, | |
| 725 mode->w, mode->h, mode->format->BitsPerPixel, mode->offset); | |
| 726 #endif | |
| 727 mode->w = width; | |
| 728 mode->h = height; | |
| 729 SDL_SetClipRect(mode, NULL); | |
| 730 } | |
| 731 SDL_ResetCursor(); | |
| 732 SDL_UnlockCursor(); | |
| 733 | |
| 734 /* If we failed setting a video mode, return NULL... (Uh Oh!) */ | |
| 735 if ( mode == NULL ) { | |
| 736 return(NULL); | |
| 737 } | |
| 738 | |
| 739 /* If there is no window manager, set the SDL_NOFRAME flag */ | |
| 740 if ( ! video->info.wm_available ) { | |
| 741 mode->flags |= SDL_NOFRAME; | |
| 742 } | |
| 743 | |
| 744 /* Reset the mouse cursor and grab for new video mode */ | |
| 745 SDL_SetCursor(NULL); | |
| 746 if ( video->UpdateMouse ) { | |
| 747 video->UpdateMouse(this); | |
| 748 } | |
| 749 SDL_WM_GrabInput(saved_grab); | |
| 750 SDL_GetRelativeMouseState(NULL, NULL); /* Clear first large delta */ | |
| 751 | |
|
650
fe445b59d307
We need to lookup the address of glGetString before calling GL_MakeCurrent(),
Ryan C. Gordon <icculus@icculus.org>
parents:
630
diff
changeset
|
752 #ifdef HAVE_OPENGL |
|
fe445b59d307
We need to lookup the address of glGetString before calling GL_MakeCurrent(),
Ryan C. Gordon <icculus@icculus.org>
parents:
630
diff
changeset
|
753 /* Load GL symbols (before MakeCurrent, where we need glGetString). */ |
|
fe445b59d307
We need to lookup the address of glGetString before calling GL_MakeCurrent(),
Ryan C. Gordon <icculus@icculus.org>
parents:
630
diff
changeset
|
754 if ( flags & (SDL_OPENGL | SDL_OPENGLBLIT) ) { |
|
910
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
755 |
|
1032
c1c2efca4548
Date: Mon, 24 Jan 2005 21:37:56 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
989
diff
changeset
|
756 #if defined(__QNXNTO__) && (_NTO_VERSION < 630) |
|
916
46916168361d
Date: Sun, 25 Jul 2004 23:10:03 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
910
diff
changeset
|
757 #define __SDL_NOGETPROCADDR__ |
|
989
475166d13b44
Factorize OSMesa OpenGL code for Atari drivers
Patrice Mandin <patmandin@gmail.com>
parents:
944
diff
changeset
|
758 #elif defined(__MINT__) |
|
475166d13b44
Factorize OSMesa OpenGL code for Atari drivers
Patrice Mandin <patmandin@gmail.com>
parents:
944
diff
changeset
|
759 #define __SDL_NOGETPROCADDR__ |
|
916
46916168361d
Date: Sun, 25 Jul 2004 23:10:03 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
910
diff
changeset
|
760 #endif |
|
910
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
761 #ifdef __SDL_NOGETPROCADDR__ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
762 #define SDL_PROC(ret,func,params) video->func=func; |
|
663
8bedd6d61642
Date: Sat, 2 Aug 2003 16:22:51 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
662
diff
changeset
|
763 #else |
|
910
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
764 #define SDL_PROC(ret,func,params) \ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
765 do { \ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
766 video->func = SDL_GL_GetProcAddress(#func); \ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
767 if ( ! video->func ) { \ |
|
1141
fe1fa56dcbc6
If couldn't load a needed GL symbol in SDL_SetVideoMode(), report it more
Ryan C. Gordon <icculus@icculus.org>
parents:
1140
diff
changeset
|
768 SDL_SetError("Couldn't load GL function %s: %s\n", #func, SDL_GetError()); \ |
|
910
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
769 return(NULL); \ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
770 } \ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
771 } while ( 0 ); |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
772 |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
773 #endif /* __SDL_NOGETPROCADDR__ */ |
|
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
774 |
|
650
fe445b59d307
We need to lookup the address of glGetString before calling GL_MakeCurrent(),
Ryan C. Gordon <icculus@icculus.org>
parents:
630
diff
changeset
|
775 #include "SDL_glfuncs.h" |
|
fe445b59d307
We need to lookup the address of glGetString before calling GL_MakeCurrent(),
Ryan C. Gordon <icculus@icculus.org>
parents:
630
diff
changeset
|
776 #undef SDL_PROC |
|
fe445b59d307
We need to lookup the address of glGetString before calling GL_MakeCurrent(),
Ryan C. Gordon <icculus@icculus.org>
parents:
630
diff
changeset
|
777 } |
|
910
4ab6d1fd028f
Date: Sat, 26 Jun 2004 14:58:42 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
883
diff
changeset
|
778 #endif /* HAVE_OPENGL */ |
|
650
fe445b59d307
We need to lookup the address of glGetString before calling GL_MakeCurrent(),
Ryan C. Gordon <icculus@icculus.org>
parents:
630
diff
changeset
|
779 |
| 0 | 780 /* If we're running OpenGL, make the context current */ |
| 781 if ( (video->screen->flags & SDL_OPENGL) && | |
| 782 video->GL_MakeCurrent ) { | |
| 783 if ( video->GL_MakeCurrent(this) < 0 ) { | |
| 784 return(NULL); | |
| 785 } | |
| 786 } | |
| 787 | |
| 788 /* Set up a fake SDL surface for OpenGL "blitting" */ | |
| 789 if ( (flags & SDL_OPENGLBLIT) == SDL_OPENGLBLIT ) { | |
| 790 /* Load GL functions for performing the texture updates */ | |
| 791 #ifdef HAVE_OPENGL | |
| 792 | |
| 793 /* Create a software surface for blitting */ | |
| 794 #ifdef GL_VERSION_1_2 | |
| 795 /* If the implementation either supports the packed pixels | |
| 796 extension, or implements the core OpenGL 1.2 API, it will | |
| 797 support the GL_UNSIGNED_SHORT_5_6_5 texture format. | |
| 798 */ | |
| 799 if ( (bpp == 16) && | |
|
282
b42d80e73896
Fixed SDL_OPENGLBLIT with OpenGL API newer than 1.2
Sam Lantinga <slouken@libsdl.org>
parents:
281
diff
changeset
|
800 (strstr((const char *)video->glGetString(GL_EXTENSIONS), "GL_EXT_packed_pixels") || |
|
b42d80e73896
Fixed SDL_OPENGLBLIT with OpenGL API newer than 1.2
Sam Lantinga <slouken@libsdl.org>
parents:
281
diff
changeset
|
801 (atof((const char *)video->glGetString(GL_VERSION)) >= 1.2f)) |
|
b42d80e73896
Fixed SDL_OPENGLBLIT with OpenGL API newer than 1.2
Sam Lantinga <slouken@libsdl.org>
parents:
281
diff
changeset
|
802 ) { |
| 0 | 803 video->is_32bit = 0; |
| 804 SDL_VideoSurface = SDL_CreateRGBSurface( | |
| 805 flags, | |
| 806 width, | |
| 807 height, | |
| 808 16, | |
| 809 31 << 11, | |
| 810 63 << 5, | |
| 811 31, | |
| 812 0 | |
| 813 ); | |
| 814 } | |
| 815 else | |
| 816 #endif /* OpenGL 1.2 */ | |
| 817 { | |
| 818 video->is_32bit = 1; | |
| 819 SDL_VideoSurface = SDL_CreateRGBSurface( | |
| 820 flags, | |
| 821 width, | |
| 822 height, | |
| 823 32, | |
| 824 #if SDL_BYTEORDER == SDL_LIL_ENDIAN | |
| 825 0x000000FF, | |
| 826 0x0000FF00, | |
| 827 0x00FF0000, | |
| 828 0xFF000000 | |
| 829 #else | |
| 830 0xFF000000, | |
| 831 0x00FF0000, | |
| 832 0x0000FF00, | |
| 833 0x000000FF | |
| 834 #endif | |
| 835 ); | |
| 836 } | |
| 837 if ( ! SDL_VideoSurface ) { | |
| 838 return(NULL); | |
| 839 } | |
| 840 SDL_VideoSurface->flags = mode->flags | SDL_OPENGLBLIT; | |
| 841 | |
| 842 /* Free the original video mode surface (is this safe?) */ | |
| 843 SDL_FreeSurface(mode); | |
| 844 | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
845 /* Set the surface completely opaque & white by default */ |
| 0 | 846 memset( SDL_VideoSurface->pixels, 255, SDL_VideoSurface->h * SDL_VideoSurface->pitch ); |
| 847 video->glGenTextures( 1, &video->texture ); | |
| 848 video->glBindTexture( GL_TEXTURE_2D, video->texture ); | |
| 849 video->glTexImage2D( | |
| 850 GL_TEXTURE_2D, | |
| 851 0, | |
| 852 video->is_32bit ? GL_RGBA : GL_RGB, | |
| 853 256, | |
| 854 256, | |
| 855 0, | |
| 856 video->is_32bit ? GL_RGBA : GL_RGB, | |
| 857 #ifdef GL_VERSION_1_2 | |
| 858 video->is_32bit ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5, | |
| 859 #else | |
| 860 GL_UNSIGNED_BYTE, | |
| 861 #endif | |
| 862 NULL); | |
| 863 | |
| 864 video->UpdateRects = SDL_GL_UpdateRectsLock; | |
| 865 #else | |
| 866 SDL_SetError("Somebody forgot to #define HAVE_OPENGL"); | |
| 867 return(NULL); | |
| 868 #endif | |
| 869 } | |
| 870 | |
| 871 /* Create a shadow surface if necessary */ | |
| 872 /* There are three conditions under which we create a shadow surface: | |
| 873 1. We need a particular bits-per-pixel that we didn't get. | |
| 874 2. We need a hardware palette and didn't get one. | |
| 875 3. We need a software surface and got a hardware surface. | |
| 876 */ | |
| 877 if ( !(SDL_VideoSurface->flags & SDL_OPENGL) && | |
| 878 ( | |
| 879 ( !(flags&SDL_ANYFORMAT) && | |
| 880 (SDL_VideoSurface->format->BitsPerPixel != bpp)) || | |
| 881 ( (flags&SDL_HWPALETTE) && | |
| 882 !(SDL_VideoSurface->flags&SDL_HWPALETTE)) || | |
| 883 /* If the surface is in hardware, video writes are visible | |
| 884 as soon as they are performed, so we need to buffer them | |
| 885 */ | |
| 886 ( ((flags&SDL_HWSURFACE) == SDL_SWSURFACE) && | |
|
580
be6495850a62
If a double-buffered surface was requested, and a plain hardware surface
Sam Lantinga <slouken@libsdl.org>
parents:
567
diff
changeset
|
887 (SDL_VideoSurface->flags&SDL_HWSURFACE)) || |
|
be6495850a62
If a double-buffered surface was requested, and a plain hardware surface
Sam Lantinga <slouken@libsdl.org>
parents:
567
diff
changeset
|
888 ( (flags&SDL_DOUBLEBUF) && |
|
be6495850a62
If a double-buffered surface was requested, and a plain hardware surface
Sam Lantinga <slouken@libsdl.org>
parents:
567
diff
changeset
|
889 (SDL_VideoSurface->flags&SDL_HWSURFACE) && |
|
be6495850a62
If a double-buffered surface was requested, and a plain hardware surface
Sam Lantinga <slouken@libsdl.org>
parents:
567
diff
changeset
|
890 !(SDL_VideoSurface->flags&SDL_DOUBLEBUF)) |
| 0 | 891 ) ) { |
| 892 SDL_CreateShadowSurface(bpp); | |
| 893 if ( SDL_ShadowSurface == NULL ) { | |
| 894 SDL_SetError("Couldn't create shadow surface"); | |
| 895 return(NULL); | |
| 896 } | |
| 897 SDL_PublicSurface = SDL_ShadowSurface; | |
| 898 } else { | |
| 899 SDL_PublicSurface = SDL_VideoSurface; | |
| 900 } | |
| 901 video->info.vfmt = SDL_VideoSurface->format; | |
| 902 | |
| 903 /* We're done! */ | |
| 904 return(SDL_PublicSurface); | |
| 905 } | |
| 906 | |
| 907 /* | |
| 908 * Convert a surface into the video pixel format. | |
| 909 */ | |
| 910 SDL_Surface * SDL_DisplayFormat (SDL_Surface *surface) | |
| 911 { | |
| 912 Uint32 flags; | |
| 913 | |
| 914 if ( ! SDL_PublicSurface ) { | |
| 915 SDL_SetError("No video mode has been set"); | |
| 916 return(NULL); | |
| 917 } | |
| 918 /* Set the flags appropriate for copying to display surface */ | |
|
313
67ad846ed21c
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
306
diff
changeset
|
919 if (((SDL_PublicSurface->flags&SDL_HWSURFACE) == SDL_HWSURFACE) && current_video->info.blit_hw) |
|
306
3879bed3395c
Only put surfaces in video memory if there are accelerated blits
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
920 flags = SDL_HWSURFACE; |
|
3879bed3395c
Only put surfaces in video memory if there are accelerated blits
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
921 else |
|
3879bed3395c
Only put surfaces in video memory if there are accelerated blits
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
922 flags = SDL_SWSURFACE; |
| 0 | 923 #ifdef AUTORLE_DISPLAYFORMAT |
| 924 flags |= (surface->flags & (SDL_SRCCOLORKEY|SDL_SRCALPHA)); | |
| 925 flags |= SDL_RLEACCELOK; | |
| 926 #else | |
| 927 flags |= surface->flags & (SDL_SRCCOLORKEY|SDL_SRCALPHA|SDL_RLEACCELOK); | |
| 928 #endif | |
| 929 return(SDL_ConvertSurface(surface, SDL_PublicSurface->format, flags)); | |
| 930 } | |
| 931 | |
| 932 /* | |
| 933 * Convert a surface into a format that's suitable for blitting to | |
| 934 * the screen, but including an alpha channel. | |
| 935 */ | |
| 936 SDL_Surface *SDL_DisplayFormatAlpha(SDL_Surface *surface) | |
| 937 { | |
| 938 SDL_PixelFormat *vf; | |
| 939 SDL_PixelFormat *format; | |
| 940 SDL_Surface *converted; | |
| 941 Uint32 flags; | |
| 942 /* default to ARGB8888 */ | |
| 943 Uint32 amask = 0xff000000; | |
| 944 Uint32 rmask = 0x00ff0000; | |
| 945 Uint32 gmask = 0x0000ff00; | |
| 946 Uint32 bmask = 0x000000ff; | |
| 947 | |
| 948 if ( ! SDL_PublicSurface ) { | |
| 949 SDL_SetError("No video mode has been set"); | |
| 950 return(NULL); | |
| 951 } | |
| 952 vf = SDL_PublicSurface->format; | |
| 953 | |
| 954 switch(vf->BytesPerPixel) { | |
| 955 case 2: | |
| 956 /* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}. | |
| 957 For anything else (like ARGB4444) it doesn't matter | |
| 958 since we have no special code for it anyway */ | |
| 959 if ( (vf->Rmask == 0x1f) && | |
| 960 (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) { | |
| 961 rmask = 0xff; | |
| 962 bmask = 0xff0000; | |
| 963 } | |
| 964 break; | |
| 965 | |
| 966 case 3: | |
| 967 case 4: | |
| 968 /* Keep the video format, as long as the high 8 bits are | |
| 969 unused or alpha */ | |
| 970 if ( (vf->Rmask == 0xff) && (vf->Bmask == 0xff0000) ) { | |
| 971 rmask = 0xff; | |
| 972 bmask = 0xff0000; | |
| 973 } | |
| 974 break; | |
| 975 | |
| 976 default: | |
| 977 /* We have no other optimised formats right now. When/if a new | |
| 978 optimised alpha format is written, add the converter here */ | |
| 979 break; | |
| 980 } | |
| 981 format = SDL_AllocFormat(32, rmask, gmask, bmask, amask); | |
| 982 flags = SDL_PublicSurface->flags & SDL_HWSURFACE; | |
| 983 flags |= surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK); | |
| 984 converted = SDL_ConvertSurface(surface, format, flags); | |
| 985 SDL_FreeFormat(format); | |
| 986 return(converted); | |
| 987 } | |
| 988 | |
| 989 /* | |
| 990 * Update a specific portion of the physical screen | |
| 991 */ | |
| 992 void SDL_UpdateRect(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h) | |
| 993 { | |
| 994 if ( screen ) { | |
| 995 SDL_Rect rect; | |
| 996 | |
| 997 /* Perform some checking */ | |
| 998 if ( w == 0 ) | |
| 999 w = screen->w; | |
| 1000 if ( h == 0 ) | |
| 1001 h = screen->h; | |
| 1002 if ( (int)(x+w) > screen->w ) | |
| 1003 return; | |
| 1004 if ( (int)(y+h) > screen->h ) | |
| 1005 return; | |
| 1006 | |
| 1007 /* Fill the rectangle */ | |
| 1008 rect.x = x; | |
| 1009 rect.y = y; | |
| 1010 rect.w = w; | |
| 1011 rect.h = h; | |
| 1012 SDL_UpdateRects(screen, 1, &rect); | |
| 1013 } | |
| 1014 } | |
| 1015 void SDL_UpdateRects (SDL_Surface *screen, int numrects, SDL_Rect *rects) | |
| 1016 { | |
| 1017 int i; | |
| 1018 SDL_VideoDevice *video = current_video; | |
| 1019 SDL_VideoDevice *this = current_video; | |
| 1020 | |
| 1021 if ( screen == SDL_ShadowSurface ) { | |
| 1022 /* Blit the shadow surface using saved mapping */ | |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1023 SDL_Palette *pal = screen->format->palette; |
| 0 | 1024 SDL_Color *saved_colors = NULL; |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1025 if ( pal && !(SDL_VideoSurface->flags & SDL_HWPALETTE) ) { |
| 0 | 1026 /* simulated 8bpp, use correct physical palette */ |
| 1027 saved_colors = pal->colors; | |
| 1028 if ( video->gammacols ) { | |
| 1029 /* gamma-corrected palette */ | |
| 1030 pal->colors = video->gammacols; | |
| 1031 } else if ( video->physpal ) { | |
| 1032 /* physical palette different from logical */ | |
| 1033 pal->colors = video->physpal->colors; | |
| 1034 } | |
| 1035 } | |
| 1036 if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) { | |
| 1037 SDL_LockCursor(); | |
| 1038 SDL_DrawCursor(SDL_ShadowSurface); | |
| 1039 for ( i=0; i<numrects; ++i ) { | |
| 1040 SDL_LowerBlit(SDL_ShadowSurface, &rects[i], | |
| 1041 SDL_VideoSurface, &rects[i]); | |
| 1042 } | |
| 1043 SDL_EraseCursor(SDL_ShadowSurface); | |
| 1044 SDL_UnlockCursor(); | |
| 1045 } else { | |
| 1046 for ( i=0; i<numrects; ++i ) { | |
| 1047 SDL_LowerBlit(SDL_ShadowSurface, &rects[i], | |
| 1048 SDL_VideoSurface, &rects[i]); | |
| 1049 } | |
| 1050 } | |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1051 if ( saved_colors ) { |
| 0 | 1052 pal->colors = saved_colors; |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1053 } |
| 0 | 1054 |
| 1055 /* Fall through to video surface update */ | |
| 1056 screen = SDL_VideoSurface; | |
| 1057 } | |
| 1058 if ( screen == SDL_VideoSurface ) { | |
| 1059 /* Update the video surface */ | |
| 1060 if ( screen->offset ) { | |
| 1061 for ( i=0; i<numrects; ++i ) { | |
| 1062 rects[i].x += video->offset_x; | |
| 1063 rects[i].y += video->offset_y; | |
| 1064 } | |
| 1065 video->UpdateRects(this, numrects, rects); | |
| 1066 for ( i=0; i<numrects; ++i ) { | |
| 1067 rects[i].x -= video->offset_x; | |
| 1068 rects[i].y -= video->offset_y; | |
| 1069 } | |
| 1070 } else { | |
| 1071 video->UpdateRects(this, numrects, rects); | |
| 1072 } | |
| 1073 } | |
| 1074 } | |
| 1075 | |
| 1076 /* | |
| 1077 * Performs hardware double buffering, if possible, or a full update if not. | |
| 1078 */ | |
| 1079 int SDL_Flip(SDL_Surface *screen) | |
| 1080 { | |
| 1081 SDL_VideoDevice *video = current_video; | |
| 1082 /* Copy the shadow surface to the video surface */ | |
| 1083 if ( screen == SDL_ShadowSurface ) { | |
| 1084 SDL_Rect rect; | |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1085 SDL_Palette *pal = screen->format->palette; |
| 0 | 1086 SDL_Color *saved_colors = NULL; |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1087 if ( pal && !(SDL_VideoSurface->flags & SDL_HWPALETTE) ) { |
| 0 | 1088 /* simulated 8bpp, use correct physical palette */ |
| 1089 saved_colors = pal->colors; | |
| 1090 if ( video->gammacols ) { | |
| 1091 /* gamma-corrected palette */ | |
| 1092 pal->colors = video->gammacols; | |
| 1093 } else if ( video->physpal ) { | |
| 1094 /* physical palette different from logical */ | |
| 1095 pal->colors = video->physpal->colors; | |
| 1096 } | |
| 1097 } | |
| 1098 | |
| 1099 rect.x = 0; | |
| 1100 rect.y = 0; | |
| 1101 rect.w = screen->w; | |
| 1102 rect.h = screen->h; | |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1103 if ( SHOULD_DRAWCURSOR(SDL_cursorstate) ) { |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1104 SDL_LockCursor(); |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1105 SDL_DrawCursor(SDL_ShadowSurface); |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1106 SDL_LowerBlit(SDL_ShadowSurface, &rect, |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1107 SDL_VideoSurface, &rect); |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1108 SDL_EraseCursor(SDL_ShadowSurface); |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1109 SDL_UnlockCursor(); |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1110 } else { |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1111 SDL_LowerBlit(SDL_ShadowSurface, &rect, |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1112 SDL_VideoSurface, &rect); |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1113 } |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1114 if ( saved_colors ) { |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1115 pal->colors = saved_colors; |
|
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1116 } |
| 0 | 1117 |
|
488
0a111805b53a
Fixed missing cursor after shadow buffer flip (thanks Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
1118 /* Fall through to video surface update */ |
| 0 | 1119 screen = SDL_VideoSurface; |
| 1120 } | |
| 1121 if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { | |
| 1122 SDL_VideoDevice *this = current_video; | |
| 1123 return(video->FlipHWSurface(this, SDL_VideoSurface)); | |
| 1124 } else { | |
| 1125 SDL_UpdateRect(screen, 0, 0, 0, 0); | |
| 1126 } | |
| 1127 return(0); | |
| 1128 } | |
| 1129 | |
| 1130 static void SetPalette_logical(SDL_Surface *screen, SDL_Color *colors, | |
| 1131 int firstcolor, int ncolors) | |
| 1132 { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1133 SDL_Palette *pal = screen->format->palette; |
| 0 | 1134 SDL_Palette *vidpal; |
| 1135 | |
| 1136 if ( colors != (pal->colors + firstcolor) ) { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1137 memcpy(pal->colors + firstcolor, colors, |
| 0 | 1138 ncolors * sizeof(*colors)); |
| 1139 } | |
| 1140 | |
| 1141 vidpal = SDL_VideoSurface->format->palette; | |
| 1142 if ( (screen == SDL_ShadowSurface) && vidpal ) { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1143 /* |
| 0 | 1144 * This is a shadow surface, and the physical |
| 1145 * framebuffer is also indexed. Propagate the | |
| 1146 * changes to its logical palette so that | |
| 1147 * updates are always identity blits | |
| 1148 */ | |
| 1149 memcpy(vidpal->colors + firstcolor, colors, | |
| 1150 ncolors * sizeof(*colors)); | |
| 1151 } | |
| 1152 SDL_FormatChanged(screen); | |
| 1153 } | |
| 1154 | |
| 1155 static int SetPalette_physical(SDL_Surface *screen, | |
| 1156 SDL_Color *colors, int firstcolor, int ncolors) | |
| 1157 { | |
| 1158 SDL_VideoDevice *video = current_video; | |
| 1159 int gotall = 1; | |
| 1160 | |
| 1161 if ( video->physpal ) { | |
| 1162 /* We need to copy the new colors, since we haven't | |
| 1163 * already done the copy in the logical set above. | |
| 1164 */ | |
| 1165 memcpy(video->physpal->colors + firstcolor, | |
| 1166 colors, ncolors * sizeof(*colors)); | |
| 1167 } | |
| 1168 if ( screen == SDL_ShadowSurface ) { | |
| 1169 if ( SDL_VideoSurface->flags & SDL_HWPALETTE ) { | |
| 1170 /* | |
| 1171 * The real screen is also indexed - set its physical | |
| 1172 * palette. The physical palette does not include the | |
| 1173 * gamma modification, we apply it directly instead, | |
| 1174 * but this only happens if we have hardware palette. | |
| 1175 */ | |
| 1176 screen = SDL_VideoSurface; | |
| 1177 } else { | |
| 1178 /* | |
| 1179 * The video surface is not indexed - invalidate any | |
| 1180 * active shadow-to-video blit mappings. | |
| 1181 */ | |
| 1182 if ( screen->map->dst == SDL_VideoSurface ) { | |
| 1183 SDL_InvalidateMap(screen->map); | |
| 1184 } | |
| 1185 if ( video->gamma ) { | |
| 1186 if( ! video->gammacols ) { | |
| 1187 SDL_Palette *pp = video->physpal; | |
| 1188 if(!pp) | |
| 1189 pp = screen->format->palette; | |
| 1190 video->gammacols = malloc(pp->ncolors | |
| 1191 * sizeof(SDL_Color)); | |
| 1192 SDL_ApplyGamma(video->gamma, | |
| 1193 pp->colors, | |
| 1194 video->gammacols, | |
| 1195 pp->ncolors); | |
| 1196 } else { | |
| 1197 SDL_ApplyGamma(video->gamma, colors, | |
| 1198 video->gammacols | |
| 1199 + firstcolor, | |
| 1200 ncolors); | |
| 1201 } | |
| 1202 } | |
| 1203 SDL_UpdateRect(screen, 0, 0, 0, 0); | |
| 1204 } | |
| 1205 } | |
| 1206 | |
| 1207 if ( screen == SDL_VideoSurface ) { | |
| 1208 SDL_Color gcolors[256]; | |
| 1209 | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1210 if ( video->gamma ) { |
|
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1211 SDL_ApplyGamma(video->gamma, colors, gcolors, ncolors); |
| 0 | 1212 colors = gcolors; |
| 1213 } | |
| 1214 gotall = video->SetColors(video, firstcolor, ncolors, colors); | |
| 1215 if ( ! gotall ) { | |
| 1216 /* The video flags shouldn't have SDL_HWPALETTE, and | |
| 1217 the video driver is responsible for copying back the | |
| 1218 correct colors into the video surface palette. | |
| 1219 */ | |
| 1220 ; | |
| 1221 } | |
| 1222 SDL_CursorPaletteChanged(); | |
| 1223 } | |
| 1224 return gotall; | |
| 1225 } | |
| 1226 | |
| 1227 /* | |
| 1228 * Set the physical and/or logical colormap of a surface: | |
| 1229 * Only the screen has a physical colormap. It determines what is actually | |
| 1230 * sent to the display. | |
| 1231 * The logical colormap is used to map blits to/from the surface. | |
| 1232 * 'which' is one or both of SDL_LOGPAL, SDL_PHYSPAL | |
| 1233 * | |
| 1234 * Return nonzero if all colours were set as requested, or 0 otherwise. | |
| 1235 */ | |
| 1236 int SDL_SetPalette(SDL_Surface *screen, int which, | |
| 1237 SDL_Color *colors, int firstcolor, int ncolors) | |
| 1238 { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1239 SDL_Palette *pal; |
| 0 | 1240 int gotall; |
| 1241 int palsize; | |
| 1242 | |
| 34 | 1243 if ( ! current_video ) { |
| 1244 return 0; | |
| 1245 } | |
| 0 | 1246 if ( screen != SDL_PublicSurface ) { |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1247 /* only screens have physical palettes */ |
|
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1248 which &= ~SDL_PHYSPAL; |
| 0 | 1249 } else if( (screen->flags & SDL_HWPALETTE) != SDL_HWPALETTE ) { |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1250 /* hardware palettes required for split colormaps */ |
|
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1251 which |= SDL_PHYSPAL | SDL_LOGPAL; |
| 0 | 1252 } |
| 1253 | |
| 1254 /* Verify the parameters */ | |
| 1255 pal = screen->format->palette; | |
| 1256 if( !pal ) { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1257 return 0; /* not a palettized surface */ |
| 0 | 1258 } |
| 1259 gotall = 1; | |
| 1260 palsize = 1 << screen->format->BitsPerPixel; | |
| 1261 if ( ncolors > (palsize - firstcolor) ) { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1262 ncolors = (palsize - firstcolor); |
| 0 | 1263 gotall = 0; |
| 1264 } | |
| 1265 | |
| 1266 if ( which & SDL_LOGPAL ) { | |
| 1267 /* | |
| 1268 * Logical palette change: The actual screen isn't affected, | |
| 1269 * but the internal colormap is altered so that the | |
| 1270 * interpretation of the pixel values (for blits etc) is | |
| 1271 * changed. | |
| 1272 */ | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1273 SetPalette_logical(screen, colors, firstcolor, ncolors); |
| 0 | 1274 } |
| 1275 if ( which & SDL_PHYSPAL ) { | |
| 1276 SDL_VideoDevice *video = current_video; | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1277 /* |
| 0 | 1278 * Physical palette change: This doesn't affect the |
| 1279 * program's idea of what the screen looks like, but changes | |
| 1280 * its actual appearance. | |
| 1281 */ | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1282 if(!video) |
|
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1283 return gotall; /* video not yet initialized */ |
| 0 | 1284 if(!video->physpal && !(which & SDL_LOGPAL) ) { |
| 1285 /* Lazy physical palette allocation */ | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1286 int size; |
| 0 | 1287 SDL_Palette *pp = malloc(sizeof(*pp)); |
|
944
cdea7cbc3e23
Date: Wed, 28 Jul 2004 14:56:57 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
916
diff
changeset
|
1288 if ( !pp ) { |
|
cdea7cbc3e23
Date: Wed, 28 Jul 2004 14:56:57 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
916
diff
changeset
|
1289 return 0; |
|
cdea7cbc3e23
Date: Wed, 28 Jul 2004 14:56:57 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
916
diff
changeset
|
1290 } |
| 0 | 1291 current_video->physpal = pp; |
| 1292 pp->ncolors = pal->ncolors; | |
| 1293 size = pp->ncolors * sizeof(SDL_Color); | |
| 1294 pp->colors = malloc(size); | |
|
944
cdea7cbc3e23
Date: Wed, 28 Jul 2004 14:56:57 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
916
diff
changeset
|
1295 if ( !pp->colors ) { |
|
cdea7cbc3e23
Date: Wed, 28 Jul 2004 14:56:57 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
916
diff
changeset
|
1296 return 0; |
|
cdea7cbc3e23
Date: Wed, 28 Jul 2004 14:56:57 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
916
diff
changeset
|
1297 } |
| 0 | 1298 memcpy(pp->colors, pal->colors, size); |
| 1299 } | |
| 1300 if ( ! SetPalette_physical(screen, | |
| 1301 colors, firstcolor, ncolors) ) { | |
| 1302 gotall = 0; | |
| 1303 } | |
| 1304 } | |
| 1305 return gotall; | |
| 1306 } | |
| 1307 | |
| 1308 int SDL_SetColors(SDL_Surface *screen, SDL_Color *colors, int firstcolor, | |
| 1309 int ncolors) | |
| 1310 { | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1311 return SDL_SetPalette(screen, SDL_LOGPAL | SDL_PHYSPAL, |
| 0 | 1312 colors, firstcolor, ncolors); |
| 1313 } | |
| 1314 | |
| 1315 /* | |
| 1316 * Clean up the video subsystem | |
| 1317 */ | |
| 1318 void SDL_VideoQuit (void) | |
| 1319 { | |
| 1320 SDL_Surface *ready_to_go; | |
| 1321 | |
| 1322 if ( current_video ) { | |
| 1323 SDL_VideoDevice *video = current_video; | |
| 1324 SDL_VideoDevice *this = current_video; | |
| 1325 | |
| 1326 /* Halt event processing before doing anything else */ | |
| 1327 SDL_StopEventLoop(); | |
| 1328 | |
| 1329 /* Clean up allocated window manager items */ | |
| 1330 if ( SDL_PublicSurface ) { | |
| 1331 SDL_PublicSurface = NULL; | |
| 1332 } | |
| 1333 SDL_CursorQuit(); | |
| 1334 | |
| 1335 /* Just in case... */ | |
| 1336 SDL_WM_GrabInputOff(); | |
| 1337 | |
| 1338 /* Clean up the system video */ | |
| 1339 video->VideoQuit(this); | |
| 1340 | |
| 1341 /* Free any lingering surfaces */ | |
| 1342 ready_to_go = SDL_ShadowSurface; | |
| 1343 SDL_ShadowSurface = NULL; | |
| 1344 SDL_FreeSurface(ready_to_go); | |
| 1345 if ( SDL_VideoSurface != NULL ) { | |
| 1346 ready_to_go = SDL_VideoSurface; | |
| 1347 SDL_VideoSurface = NULL; | |
| 1348 SDL_FreeSurface(ready_to_go); | |
| 1349 } | |
| 1350 SDL_PublicSurface = NULL; | |
| 1351 | |
| 1352 /* Clean up miscellaneous memory */ | |
| 1353 if ( video->physpal ) { | |
| 1354 free(video->physpal->colors); | |
| 1355 free(video->physpal); | |
| 1356 video->physpal = NULL; | |
| 1357 } | |
| 1358 if ( video->gammacols ) { | |
| 1359 free(video->gammacols); | |
| 1360 video->gammacols = NULL; | |
| 1361 } | |
| 1362 if ( video->gamma ) { | |
| 1363 free(video->gamma); | |
| 1364 video->gamma = NULL; | |
| 1365 } | |
|
58
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1366 if ( video->wm_title != NULL ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1367 free(video->wm_title); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1368 video->wm_title = NULL; |
| 0 | 1369 } |
|
58
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1370 if ( video->wm_icon != NULL ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1371 free(video->wm_icon); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1372 video->wm_icon = NULL; |
| 0 | 1373 } |
| 1374 | |
| 1375 /* Finish cleaning up video subsystem */ | |
| 1376 video->free(this); | |
| 1377 current_video = NULL; | |
| 1378 } | |
| 1379 return; | |
| 1380 } | |
| 1381 | |
| 1382 /* Load the GL driver library */ | |
| 1383 int SDL_GL_LoadLibrary(const char *path) | |
| 1384 { | |
| 1385 SDL_VideoDevice *video = current_video; | |
| 1386 SDL_VideoDevice *this = current_video; | |
| 1387 int retval; | |
| 1388 | |
| 1389 retval = -1; | |
|
423
d1565c52ded5
More correct error reported when calling SDL_GL_LoadLibrary() without
Ryan C. Gordon <icculus@icculus.org>
parents:
371
diff
changeset
|
1390 if ( video == NULL ) { |
|
d1565c52ded5
More correct error reported when calling SDL_GL_LoadLibrary() without
Ryan C. Gordon <icculus@icculus.org>
parents:
371
diff
changeset
|
1391 SDL_SetError("Video subsystem has not been initialized"); |
| 0 | 1392 } else { |
|
423
d1565c52ded5
More correct error reported when calling SDL_GL_LoadLibrary() without
Ryan C. Gordon <icculus@icculus.org>
parents:
371
diff
changeset
|
1393 if ( video->GL_LoadLibrary ) { |
|
d1565c52ded5
More correct error reported when calling SDL_GL_LoadLibrary() without
Ryan C. Gordon <icculus@icculus.org>
parents:
371
diff
changeset
|
1394 retval = video->GL_LoadLibrary(this, path); |
|
d1565c52ded5
More correct error reported when calling SDL_GL_LoadLibrary() without
Ryan C. Gordon <icculus@icculus.org>
parents:
371
diff
changeset
|
1395 } else { |
|
d1565c52ded5
More correct error reported when calling SDL_GL_LoadLibrary() without
Ryan C. Gordon <icculus@icculus.org>
parents:
371
diff
changeset
|
1396 SDL_SetError("No dynamic GL support in video driver"); |
|
d1565c52ded5
More correct error reported when calling SDL_GL_LoadLibrary() without
Ryan C. Gordon <icculus@icculus.org>
parents:
371
diff
changeset
|
1397 } |
| 0 | 1398 } |
| 1399 return(retval); | |
| 1400 } | |
| 1401 | |
| 1402 void *SDL_GL_GetProcAddress(const char* proc) | |
| 1403 { | |
| 1404 SDL_VideoDevice *video = current_video; | |
| 1405 SDL_VideoDevice *this = current_video; | |
| 1406 void *func; | |
| 1407 | |
| 1408 func = NULL; | |
| 1409 if ( video->GL_GetProcAddress ) { | |
| 1410 if ( video->gl_config.driver_loaded ) { | |
| 1411 func = video->GL_GetProcAddress(this, proc); | |
| 1412 } else { | |
| 1413 SDL_SetError("No GL driver has been loaded"); | |
| 1414 } | |
| 1415 } else { | |
| 1416 SDL_SetError("No dynamic GL support in video driver"); | |
| 1417 } | |
| 1418 return func; | |
| 1419 } | |
| 1420 | |
| 1421 /* Set the specified GL attribute for setting up a GL video mode */ | |
| 1422 int SDL_GL_SetAttribute( SDL_GLattr attr, int value ) | |
| 1423 { | |
| 1424 int retval; | |
| 1425 SDL_VideoDevice *video = current_video; | |
| 1426 | |
| 1427 retval = 0; | |
| 1428 switch (attr) { | |
| 1429 case SDL_GL_RED_SIZE: | |
| 1430 video->gl_config.red_size = value; | |
| 1431 break; | |
| 1432 case SDL_GL_GREEN_SIZE: | |
| 1433 video->gl_config.green_size = value; | |
| 1434 break; | |
| 1435 case SDL_GL_BLUE_SIZE: | |
| 1436 video->gl_config.blue_size = value; | |
| 1437 break; | |
| 1438 case SDL_GL_ALPHA_SIZE: | |
| 1439 video->gl_config.alpha_size = value; | |
| 1440 break; | |
| 1441 case SDL_GL_DOUBLEBUFFER: | |
| 1442 video->gl_config.double_buffer = value; | |
| 1443 break; | |
|
662
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1444 case SDL_GL_BUFFER_SIZE: |
|
66c02f83f5bf
Date: Sun, 27 Jul 2003 22:37:59 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
656
diff
changeset
|
1445 video->gl_config.buffer_size = value; |
| 0 | 1446 break; |
| 1447 case SDL_GL_DEPTH_SIZE: | |
| 1448 video->gl_config.depth_size = value; | |
| 1449 break; | |
| 1450 case SDL_GL_STENCIL_SIZE: | |
| 1451 video->gl_config.stencil_size = value; | |
| 1452 break; | |
|
450
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
1453 case SDL_GL_ACCUM_RED_SIZE: |
| 0 | 1454 video->gl_config.accum_red_size = value; |
| 1455 break; | |
|
450
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
1456 case SDL_GL_ACCUM_GREEN_SIZE: |
| 0 | 1457 video->gl_config.accum_green_size = value; |
| 1458 break; | |
|
450
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
1459 case SDL_GL_ACCUM_BLUE_SIZE: |
| 0 | 1460 video->gl_config.accum_blue_size = value; |
| 1461 break; | |
|
450
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
1462 case SDL_GL_ACCUM_ALPHA_SIZE: |
| 0 | 1463 video->gl_config.accum_alpha_size = value; |
| 1464 break; | |
|
450
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
1465 case SDL_GL_STEREO: |
|
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
1466 video->gl_config.stereo = value; |
|
8a43e0cbf02f
Added SDL_GL_STEREO for stereoscopic OpenGL contexts
Sam Lantinga <slouken@libsdl.org>
parents:
433
diff
changeset
|
1467 break; |
|
656
864e2d2a9a55
Merged in Ryan's multisample code for MacOS, and changed the constants to match.
Sam Lantinga <slouken@libsdl.org>
parents:
655
diff
changeset
|
1468 case SDL_GL_MULTISAMPLEBUFFERS: |
|
864e2d2a9a55
Merged in Ryan's multisample code for MacOS, and changed the constants to match.
Sam Lantinga <slouken@libsdl.org>
parents:
655
diff
changeset
|
1469 video->gl_config.multisamplebuffers = value; |
|
655
9c42ee1b7d77
Date: Thu, 24 Apr 2003 15:13:47 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
650
diff
changeset
|
1470 break; |
|
656
864e2d2a9a55
Merged in Ryan's multisample code for MacOS, and changed the constants to match.
Sam Lantinga <slouken@libsdl.org>
parents:
655
diff
changeset
|
1471 case SDL_GL_MULTISAMPLESAMPLES: |
|
864e2d2a9a55
Merged in Ryan's multisample code for MacOS, and changed the constants to match.
Sam Lantinga <slouken@libsdl.org>
parents:
655
diff
changeset
|
1472 video->gl_config.multisamplesamples = value; |
|
655
9c42ee1b7d77
Date: Thu, 24 Apr 2003 15:13:47 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
650
diff
changeset
|
1473 break; |
| 0 | 1474 default: |
| 1475 SDL_SetError("Unknown OpenGL attribute"); | |
| 1476 retval = -1; | |
| 1477 break; | |
| 1478 } | |
| 1479 return(retval); | |
| 1480 } | |
| 1481 | |
| 1482 /* Retrieve an attribute value from the windowing system. */ | |
| 1483 int SDL_GL_GetAttribute(SDL_GLattr attr, int* value) | |
| 1484 { | |
| 1485 int retval = -1; | |
| 1486 SDL_VideoDevice* video = current_video; | |
| 1487 SDL_VideoDevice* this = current_video; | |
| 1488 | |
| 1489 if ( video->GL_GetAttribute ) { | |
| 1490 retval = this->GL_GetAttribute(this, attr, value); | |
|
11
7b94b6379341
*** empty log message ***
Sam Lantinga <slouken@lokigames.com>
parents:
7
diff
changeset
|
1491 } else { |
|
7b94b6379341
*** empty log message ***
Sam Lantinga <slouken@lokigames.com>
parents:
7
diff
changeset
|
1492 *value = 0; |
|
7b94b6379341
*** empty log message ***
Sam Lantinga <slouken@lokigames.com>
parents:
7
diff
changeset
|
1493 SDL_SetError("GL_GetAttribute not supported"); |
| 0 | 1494 } |
| 1495 return retval; | |
| 1496 } | |
| 1497 | |
| 1498 /* Perform a GL buffer swap on the current GL context */ | |
| 1499 void SDL_GL_SwapBuffers(void) | |
| 1500 { | |
| 1501 SDL_VideoDevice *video = current_video; | |
| 1502 SDL_VideoDevice *this = current_video; | |
| 1503 | |
| 1504 if ( video->screen->flags & SDL_OPENGL ) { | |
|
266
c6abdda2f666
Added QNX cleanups by Mike Gorchak (thanks!)
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
1505 video->GL_SwapBuffers(this); |
|
c6abdda2f666
Added QNX cleanups by Mike Gorchak (thanks!)
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
1506 } else { |
|
c6abdda2f666
Added QNX cleanups by Mike Gorchak (thanks!)
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
1507 SDL_SetError("OpenGL video mode has not been set"); |
| 0 | 1508 } |
| 1509 } | |
| 1510 | |
| 1511 /* Update rects with locking */ | |
| 1512 void SDL_GL_UpdateRectsLock(SDL_VideoDevice* this, int numrects, SDL_Rect *rects) | |
| 1513 { | |
| 1514 SDL_GL_Lock(); | |
| 1515 SDL_GL_UpdateRects(numrects, rects); | |
| 1516 SDL_GL_Unlock(); | |
| 1517 } | |
| 1518 | |
| 1519 /* Update rects without state setting and changing (the caller is responsible for it) */ | |
| 1520 void SDL_GL_UpdateRects(int numrects, SDL_Rect *rects) | |
| 1521 { | |
| 1522 #ifdef HAVE_OPENGL | |
| 1523 SDL_VideoDevice *this = current_video; | |
| 1524 SDL_Rect update, tmp; | |
| 1525 int x, y, i; | |
| 1526 | |
| 1527 for ( i = 0; i < numrects; i++ ) | |
| 1528 { | |
| 1529 tmp.y = rects[i].y; | |
| 1530 tmp.h = rects[i].h; | |
| 1531 for ( y = 0; y <= rects[i].h / 256; y++ ) | |
| 1532 { | |
| 1533 tmp.x = rects[i].x; | |
| 1534 tmp.w = rects[i].w; | |
| 1535 for ( x = 0; x <= rects[i].w / 256; x++ ) | |
| 1536 { | |
| 1537 update.x = tmp.x; | |
| 1538 update.y = tmp.y; | |
| 1539 update.w = tmp.w; | |
| 1540 update.h = tmp.h; | |
| 1541 | |
| 1542 if ( update.w > 256 ) | |
| 1543 update.w = 256; | |
| 1544 | |
| 1545 if ( update.h > 256 ) | |
| 1546 update.h = 256; | |
| 1547 | |
| 1548 this->glFlush(); | |
| 1549 this->glTexSubImage2D( | |
| 1550 GL_TEXTURE_2D, | |
| 1551 0, | |
| 1552 0, | |
| 1553 0, | |
| 1554 update.w, | |
| 1555 update.h, | |
| 1556 this->is_32bit? GL_RGBA : GL_RGB, | |
| 1557 #ifdef GL_VERSION_1_2 | |
| 1558 this->is_32bit ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5, | |
| 1559 #else | |
| 1560 GL_UNSIGNED_BYTE, | |
| 1561 #endif | |
| 1562 (Uint8 *)this->screen->pixels + | |
| 1563 this->screen->format->BytesPerPixel * update.x + | |
| 1564 update.y * this->screen->pitch ); | |
| 1565 | |
| 1566 this->glFlush(); | |
| 1567 /* | |
| 1568 * Note the parens around the function name: | |
| 1569 * This is because some OpenGL implementations define glTexCoord etc | |
| 1570 * as macros, and we don't want them expanded here. | |
| 1571 */ | |
| 1572 this->glBegin(GL_TRIANGLE_STRIP); | |
| 1573 (this->glTexCoord2f)( 0.0, 0.0 ); | |
| 1574 (this->glVertex2i)( update.x, update.y ); | |
| 1575 (this->glTexCoord2f)( (float)(update.w / 256.0), 0.0 ); | |
| 1576 (this->glVertex2i)( update.x + update.w, update.y ); | |
| 1577 (this->glTexCoord2f)( 0.0, (float)(update.h / 256.0) ); | |
| 1578 (this->glVertex2i)( update.x, update.y + update.h ); | |
| 1579 (this->glTexCoord2f)( (float)(update.w / 256.0), (float)(update.h / 256.0) ); | |
| 1580 (this->glVertex2i)( update.x + update.w , update.y + update.h ); | |
| 1581 this->glEnd(); | |
| 1582 | |
| 1583 tmp.x += 256; | |
| 1584 tmp.w -= 256; | |
| 1585 } | |
| 1586 tmp.y += 256; | |
| 1587 tmp.h -= 256; | |
| 1588 } | |
| 1589 } | |
| 1590 #endif | |
| 1591 } | |
| 1592 | |
| 1593 /* Lock == save current state */ | |
| 1594 void SDL_GL_Lock() | |
| 1595 { | |
| 1596 #ifdef HAVE_OPENGL | |
| 1597 lock_count--; | |
| 1598 if (lock_count==-1) | |
| 1599 { | |
| 1600 SDL_VideoDevice *this = current_video; | |
| 1601 | |
| 1602 this->glPushAttrib( GL_ALL_ATTRIB_BITS ); /* TODO: narrow range of what is saved */ | |
|
125
0ae324925dd7
Fix build when GL_CLIENT_PIXEL_STORE_BIT is not defined
Sam Lantinga <slouken@libsdl.org>
parents:
75
diff
changeset
|
1603 #ifdef GL_CLIENT_PIXEL_STORE_BIT |
| 0 | 1604 this->glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT ); |
|
125
0ae324925dd7
Fix build when GL_CLIENT_PIXEL_STORE_BIT is not defined
Sam Lantinga <slouken@libsdl.org>
parents:
75
diff
changeset
|
1605 #endif |
| 0 | 1606 |
| 1607 this->glEnable(GL_TEXTURE_2D); | |
| 1608 this->glEnable(GL_BLEND); | |
| 1609 this->glDisable(GL_FOG); | |
| 1610 this->glDisable(GL_ALPHA_TEST); | |
| 1611 this->glDisable(GL_DEPTH_TEST); | |
| 1612 this->glDisable(GL_SCISSOR_TEST); | |
| 1613 this->glDisable(GL_STENCIL_TEST); | |
| 1614 this->glDisable(GL_CULL_FACE); | |
| 1615 | |
| 1616 this->glBindTexture( GL_TEXTURE_2D, this->texture ); | |
| 1617 this->glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); | |
| 1618 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); | |
| 1619 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); | |
| 1620 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); | |
| 1621 this->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); | |
| 1622 | |
| 1623 this->glPixelStorei( GL_UNPACK_ROW_LENGTH, this->screen->pitch / this->screen->format->BytesPerPixel ); | |
| 1624 this->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); | |
| 1625 (this->glColor4f)(1.0, 1.0, 1.0, 1.0); /* Solaris workaround */ | |
| 1626 | |
| 1627 this->glViewport(0, 0, this->screen->w, this->screen->h); | |
| 1628 this->glMatrixMode(GL_PROJECTION); | |
| 1629 this->glPushMatrix(); | |
| 1630 this->glLoadIdentity(); | |
| 1631 | |
| 1632 this->glOrtho(0.0, (GLdouble) this->screen->w, (GLdouble) this->screen->h, 0.0, 0.0, 1.0); | |
| 1633 | |
| 1634 this->glMatrixMode(GL_MODELVIEW); | |
| 1635 this->glPushMatrix(); | |
| 1636 this->glLoadIdentity(); | |
| 1637 } | |
| 1638 #endif | |
| 1639 } | |
| 1640 | |
| 1641 /* Unlock == restore saved state */ | |
| 1642 void SDL_GL_Unlock() | |
| 1643 { | |
| 1644 #ifdef HAVE_OPENGL | |
| 1645 lock_count++; | |
| 1646 if (lock_count==0) | |
| 1647 { | |
| 1648 SDL_VideoDevice *this = current_video; | |
| 1649 | |
| 1650 this->glPopMatrix(); | |
| 1651 this->glMatrixMode(GL_PROJECTION); | |
| 1652 this->glPopMatrix(); | |
| 1653 | |
| 1654 this->glPopClientAttrib(); | |
| 1655 this->glPopAttrib(); | |
| 1656 } | |
| 1657 #endif | |
| 1658 } | |
| 1659 | |
| 1660 /* | |
| 1661 * Sets/Gets the title and icon text of the display window, if any. | |
| 1662 */ | |
| 1663 void SDL_WM_SetCaption (const char *title, const char *icon) | |
| 1664 { | |
| 1665 SDL_VideoDevice *video = current_video; | |
| 1666 SDL_VideoDevice *this = current_video; | |
| 1667 | |
|
58
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1668 if ( video ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1669 if ( title ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1670 if ( video->wm_title ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1671 free(video->wm_title); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1672 } |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1673 video->wm_title = (char *)malloc(strlen(title)+1); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1674 if ( video->wm_title != NULL ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1675 strcpy(video->wm_title, title); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1676 } |
| 0 | 1677 } |
|
58
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1678 if ( icon ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1679 if ( video->wm_icon ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1680 free(video->wm_icon); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1681 } |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1682 video->wm_icon = (char *)malloc(strlen(icon)+1); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1683 if ( video->wm_icon != NULL ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1684 strcpy(video->wm_icon, icon); |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1685 } |
| 0 | 1686 } |
|
58
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1687 if ( (title || icon) && (video->SetCaption != NULL) ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1688 video->SetCaption(this, video->wm_title,video->wm_icon); |
| 0 | 1689 } |
| 1690 } | |
| 1691 } | |
| 1692 void SDL_WM_GetCaption (char **title, char **icon) | |
| 1693 { | |
|
58
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1694 SDL_VideoDevice *video = current_video; |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1695 |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1696 if ( video ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1697 if ( title ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1698 *title = video->wm_title; |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1699 } |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1700 if ( icon ) { |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1701 *icon = video->wm_icon; |
|
bd6b0a910a65
* Removed fullscreen menu option from the "Window" menu
Sam Lantinga <slouken@lokigames.com>
parents:
47
diff
changeset
|
1702 } |
| 0 | 1703 } |
| 1704 } | |
| 1705 | |
|
541
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1706 /* Utility function used by SDL_WM_SetIcon(); |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1707 * flags & 1 for color key, flags & 2 for alpha channel. */ |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1708 static void CreateMaskFromColorKeyOrAlpha(SDL_Surface *icon, Uint8 *mask, int flags) |
| 0 | 1709 { |
| 1710 int x, y; | |
| 1711 Uint32 colorkey; | |
| 1712 #define SET_MASKBIT(icon, x, y, mask) \ | |
| 1713 mask[(y*((icon->w+7)/8))+(x/8)] &= ~(0x01<<(7-(x%8))) | |
| 1714 | |
| 1715 colorkey = icon->format->colorkey; | |
| 1716 switch (icon->format->BytesPerPixel) { | |
| 1717 case 1: { Uint8 *pixels; | |
| 1718 for ( y=0; y<icon->h; ++y ) { | |
| 1719 pixels = (Uint8 *)icon->pixels + y*icon->pitch; | |
| 1720 for ( x=0; x<icon->w; ++x ) { | |
| 1721 if ( *pixels++ == colorkey ) { | |
| 1722 SET_MASKBIT(icon, x, y, mask); | |
| 1723 } | |
| 1724 } | |
| 1725 } | |
| 1726 } | |
| 1727 break; | |
| 1728 | |
| 1729 case 2: { Uint16 *pixels; | |
| 1730 for ( y=0; y<icon->h; ++y ) { | |
| 1731 pixels = (Uint16 *)icon->pixels + | |
| 1732 y*icon->pitch/2; | |
| 1733 for ( x=0; x<icon->w; ++x ) { | |
|
541
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1734 if ( (flags & 1) && *pixels == colorkey ) { |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1735 SET_MASKBIT(icon, x, y, mask); |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1736 } else if((flags & 2) && (*pixels & icon->format->Amask) == 0) { |
| 0 | 1737 SET_MASKBIT(icon, x, y, mask); |
| 1738 } | |
|
541
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1739 pixels++; |
| 0 | 1740 } |
| 1741 } | |
| 1742 } | |
| 1743 break; | |
| 1744 | |
| 1745 case 4: { Uint32 *pixels; | |
| 1746 for ( y=0; y<icon->h; ++y ) { | |
| 1747 pixels = (Uint32 *)icon->pixels + | |
| 1748 y*icon->pitch/4; | |
| 1749 for ( x=0; x<icon->w; ++x ) { | |
|
541
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1750 if ( (flags & 1) && *pixels == colorkey ) { |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1751 SET_MASKBIT(icon, x, y, mask); |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1752 } else if((flags & 2) && (*pixels & icon->format->Amask) == 0) { |
| 0 | 1753 SET_MASKBIT(icon, x, y, mask); |
| 1754 } | |
|
541
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1755 pixels++; |
| 0 | 1756 } |
| 1757 } | |
| 1758 } | |
| 1759 break; | |
| 1760 } | |
| 1761 } | |
| 1762 | |
| 1763 /* | |
| 1764 * Sets the window manager icon for the display window. | |
| 1765 */ | |
| 1766 void SDL_WM_SetIcon (SDL_Surface *icon, Uint8 *mask) | |
| 1767 { | |
| 1768 SDL_VideoDevice *video = current_video; | |
| 1769 SDL_VideoDevice *this = current_video; | |
| 1770 | |
| 1771 if ( icon && video->SetIcon ) { | |
| 1772 /* Generate a mask if necessary, and create the icon! */ | |
| 1773 if ( mask == NULL ) { | |
| 1774 int mask_len = icon->h*(icon->w+7)/8; | |
|
541
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1775 int flags = 0; |
| 0 | 1776 mask = (Uint8 *)malloc(mask_len); |
| 1777 if ( mask == NULL ) { | |
| 1778 return; | |
| 1779 } | |
| 1780 memset(mask, ~0, mask_len); | |
|
541
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1781 if ( icon->flags & SDL_SRCCOLORKEY ) flags |= 1; |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1782 if ( icon->flags & SDL_SRCALPHA ) flags |= 2; |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1783 if( flags ) { |
|
796f2fe699be
Support 1-bit alpha on surfaces passed to SDL_WM_SetIcon() (thanks Glenn!)
Sam Lantinga <slouken@libsdl.org>
parents:
509
diff
changeset
|
1784 CreateMaskFromColorKeyOrAlpha(icon, mask, flags); |
| 0 | 1785 } |
| 1786 video->SetIcon(video, icon, mask); | |
| 1787 free(mask); | |
| 1788 } else { | |
| 1789 video->SetIcon(this, icon, mask); | |
| 1790 } | |
| 1791 } | |
| 1792 } | |
| 1793 | |
| 1794 /* | |
| 1795 * Grab or ungrab the keyboard and mouse input. | |
| 1796 * This function returns the final grab mode after calling the | |
| 1797 * driver dependent function. | |
| 1798 */ | |
| 1799 static SDL_GrabMode SDL_WM_GrabInputRaw(SDL_GrabMode mode) | |
| 1800 { | |
| 1801 SDL_VideoDevice *video = current_video; | |
| 1802 SDL_VideoDevice *this = current_video; | |
| 1803 | |
| 1804 /* Only do something if we have support for grabs */ | |
| 1805 if ( video->GrabInput == NULL ) { | |
| 1806 return(video->input_grab); | |
| 1807 } | |
| 1808 | |
| 1809 /* If the final grab mode if off, only then do we actually grab */ | |
| 1810 #ifdef DEBUG_GRAB | |
| 1811 printf("SDL_WM_GrabInputRaw(%d) ... ", mode); | |
| 1812 #endif | |
| 1813 if ( mode == SDL_GRAB_OFF ) { | |
| 1814 if ( video->input_grab != SDL_GRAB_OFF ) { | |
| 1815 mode = video->GrabInput(this, mode); | |
| 1816 } | |
| 1817 } else { | |
| 1818 if ( video->input_grab == SDL_GRAB_OFF ) { | |
| 1819 mode = video->GrabInput(this, mode); | |
| 1820 } | |
| 1821 } | |
| 1822 if ( mode != video->input_grab ) { | |
| 1823 video->input_grab = mode; | |
| 1824 if ( video->CheckMouseMode ) { | |
| 1825 video->CheckMouseMode(this); | |
| 1826 } | |
| 1827 } | |
| 1828 #ifdef DEBUG_GRAB | |
| 1829 printf("Final mode %d\n", video->input_grab); | |
| 1830 #endif | |
| 1831 | |
| 1832 /* Return the final grab state */ | |
| 1833 if ( mode >= SDL_GRAB_FULLSCREEN ) { | |
| 1834 mode -= SDL_GRAB_FULLSCREEN; | |
| 1835 } | |
| 1836 return(mode); | |
| 1837 } | |
| 1838 SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode) | |
| 1839 { | |
| 1840 SDL_VideoDevice *video = current_video; | |
| 1841 | |
|
11
7b94b6379341
*** empty log message ***
Sam Lantinga <slouken@lokigames.com>
parents:
7
diff
changeset
|
1842 /* If the video isn't initialized yet, we can't do anything */ |
|
7b94b6379341
*** empty log message ***
Sam Lantinga <slouken@lokigames.com>
parents:
7
diff
changeset
|
1843 if ( ! video ) { |
|
7b94b6379341
*** empty log message ***
Sam Lantinga <slouken@lokigames.com>
parents:
7
diff
changeset
|
1844 return SDL_GRAB_OFF; |
|
7b94b6379341
*** empty log message ***
Sam Lantinga <slouken@lokigames.com>
parents:
7
diff
changeset
|
1845 } |
| 0 | 1846 |
| 1847 /* Return the current mode on query */ | |
| 1848 if ( mode == SDL_GRAB_QUERY ) { | |
| 1849 mode = video->input_grab; | |
| 1850 if ( mode >= SDL_GRAB_FULLSCREEN ) { | |
| 1851 mode -= SDL_GRAB_FULLSCREEN; | |
| 1852 } | |
| 1853 return(mode); | |
| 1854 } | |
| 1855 | |
| 1856 #ifdef DEBUG_GRAB | |
| 1857 printf("SDL_WM_GrabInput(%d) ... ", mode); | |
| 1858 #endif | |
| 1859 /* If the video surface is fullscreen, we always grab */ | |
| 1860 if ( mode >= SDL_GRAB_FULLSCREEN ) { | |
| 1861 mode -= SDL_GRAB_FULLSCREEN; | |
| 1862 } | |
| 1863 if ( SDL_VideoSurface && (SDL_VideoSurface->flags & SDL_FULLSCREEN) ) { | |
| 1864 mode += SDL_GRAB_FULLSCREEN; | |
| 1865 } | |
| 1866 return(SDL_WM_GrabInputRaw(mode)); | |
| 1867 } | |
| 1868 static SDL_GrabMode SDL_WM_GrabInputOff(void) | |
| 1869 { | |
| 1870 SDL_GrabMode mode; | |
| 1871 | |
| 1872 /* First query the current grab state */ | |
| 1873 mode = SDL_WM_GrabInput(SDL_GRAB_QUERY); | |
| 1874 | |
| 1875 /* Now explicitly turn off input grab */ | |
| 1876 SDL_WM_GrabInputRaw(SDL_GRAB_OFF); | |
| 1877 | |
| 1878 /* Return the old state */ | |
| 1879 return(mode); | |
| 1880 } | |
| 1881 | |
| 1882 /* | |
| 1883 * Iconify the window in window managed environments. | |
| 1884 * A successful iconification will result in an SDL_APPACTIVE loss event. | |
| 1885 */ | |
| 1886 int SDL_WM_IconifyWindow(void) | |
| 1887 { | |
| 1888 SDL_VideoDevice *video = current_video; | |
| 1889 SDL_VideoDevice *this = current_video; | |
| 1890 int retval; | |
| 1891 | |
| 1892 retval = 0; | |
| 1893 if ( video->IconifyWindow ) { | |
| 1894 retval = video->IconifyWindow(this); | |
| 1895 } | |
| 1896 return(retval); | |
| 1897 } | |
| 1898 | |
| 1899 /* | |
| 1900 * Toggle fullscreen mode | |
| 1901 */ | |
| 1902 int SDL_WM_ToggleFullScreen(SDL_Surface *surface) | |
| 1903 { | |
| 1904 SDL_VideoDevice *video = current_video; | |
| 1905 SDL_VideoDevice *this = current_video; | |
| 1906 int toggled; | |
| 1907 | |
| 1908 toggled = 0; | |
| 1909 if ( SDL_PublicSurface && (surface == SDL_PublicSurface) && | |
| 1910 video->ToggleFullScreen ) { | |
| 1911 if ( surface->flags & SDL_FULLSCREEN ) { | |
| 1912 toggled = video->ToggleFullScreen(this, 0); | |
| 1913 if ( toggled ) { | |
| 1914 SDL_VideoSurface->flags &= ~SDL_FULLSCREEN; | |
| 1915 SDL_PublicSurface->flags &= ~SDL_FULLSCREEN; | |
| 1916 } | |
| 1917 } else { | |
| 1918 toggled = video->ToggleFullScreen(this, 1); | |
| 1919 if ( toggled ) { | |
| 1920 SDL_VideoSurface->flags |= SDL_FULLSCREEN; | |
| 1921 SDL_PublicSurface->flags |= SDL_FULLSCREEN; | |
| 1922 } | |
| 1923 } | |
| 1924 /* Double-check the grab state inside SDL_WM_GrabInput() */ | |
| 1925 if ( toggled ) { | |
| 1926 SDL_WM_GrabInput(video->input_grab); | |
| 1927 } | |
| 1928 } | |
| 1929 return(toggled); | |
| 1930 } | |
| 1931 | |
| 1932 /* | |
| 1933 * Get some platform dependent window manager information | |
| 1934 */ | |
| 1935 int SDL_GetWMInfo (SDL_SysWMinfo *info) | |
| 1936 { | |
| 1937 SDL_VideoDevice *video = current_video; | |
| 1938 SDL_VideoDevice *this = current_video; | |
| 1939 | |
| 1940 if ( video && video->GetWMInfo ) { | |
| 1941 return(video->GetWMInfo(this, info)); | |
| 1942 } else { | |
| 1943 return(0); | |
| 1944 } | |
| 1945 } |