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