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