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