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