Mercurial > sdl-ios-xcode
annotate src/video/windx5/SDL_dx5video.c @ 809:dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
From: Dmitry Yakimov
Subject: [SDL] [PATCH] SDL bug patch
Let me introduce 2 fixes to SDL.
1. Preventing great slowdown on fast machines while hardware
flipping (it's obviously bug).
2. Setting up 85 Hz of monitor if supported. The reason is that
Win98 by default sets lowest frequency 60 Hz.
And we can't set up maximum frequency because some users can have
wrong monitor drivers.
This is important for shareware and commercial programs.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Wed, 11 Feb 2004 16:10:16 +0000 |
| parents | b8d311d90021 |
| children | 6176f9a0d61a |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
769
b8d311d90021
Updated copyright information for 2004 (Happy New Year!)
Sam Lantinga <slouken@libsdl.org>
parents:
525
diff
changeset
|
3 Copyright (C) 1997-2004 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
| 6 modify it under the terms of the GNU Library General Public | |
| 7 License as published by the Free Software Foundation; either | |
| 8 version 2 of the License, or (at your option) any later version. | |
| 9 | |
| 10 This library is distributed in the hope that it will be useful, | |
| 11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 13 Library General Public License for more details. | |
| 14 | |
| 15 You should have received a copy of the GNU Library General Public | |
| 16 License along with this library; if not, write to the Free | |
| 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| 18 | |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
169
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
| 22 | |
| 23 #ifdef SAVE_RCSID | |
| 24 static char rcsid = | |
| 25 "@(#) $Id$"; | |
| 26 #endif | |
| 27 | |
| 28 #include <stdio.h> | |
| 29 #include <stdlib.h> | |
| 30 #include <malloc.h> | |
| 31 #include <windows.h> | |
| 32 #include "directx.h" | |
| 33 | |
| 34 /* Not yet in the mingw32 cross-compile headers */ | |
| 35 #ifndef CDS_FULLSCREEN | |
| 36 #define CDS_FULLSCREEN 4 | |
| 37 #endif | |
| 38 | |
| 39 #include "SDL_error.h" | |
| 40 #include "SDL_timer.h" | |
| 41 #include "SDL_events.h" | |
| 42 #include "SDL_syswm.h" | |
| 43 #include "SDL_sysvideo.h" | |
| 44 #include "SDL_blit.h" | |
| 45 #include "SDL_pixels_c.h" | |
| 46 #include "SDL_dx5video.h" | |
| 47 #include "SDL_syswm_c.h" | |
| 48 #include "SDL_sysmouse_c.h" | |
| 49 #include "SDL_dx5events_c.h" | |
| 50 #include "SDL_dx5yuv_c.h" | |
| 51 #include "SDL_wingl_c.h" | |
| 52 | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
53 #ifdef _WIN32_WCE |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
54 #define NO_CHANGEDISPLAYSETTINGS |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
55 #endif |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
56 #ifndef WS_MAXIMIZE |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
57 #define WS_MAXIMIZE 0 |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
58 #endif |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
59 #ifndef SWP_NOCOPYBITS |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
60 #define SWP_NOCOPYBITS 0 |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
61 #endif |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
62 #ifndef PC_NOCOLLAPSE |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
63 #define PC_NOCOLLAPSE 0 |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
64 #endif |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
65 |
| 0 | 66 |
| 67 /* DirectX function pointers for video and events */ | |
| 68 HRESULT (WINAPI *DDrawCreate)( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter ); | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
69 HRESULT (WINAPI *DInputCreate)(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUT *ppDI, LPUNKNOWN punkOuter); |
| 0 | 70 |
| 71 /* This is the rect EnumModes2 uses */ | |
| 72 struct DX5EnumRect { | |
| 73 SDL_Rect r; | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
74 int refreshRate; |
| 0 | 75 struct DX5EnumRect* next; |
| 76 }; | |
| 77 static struct DX5EnumRect *enumlists[NUM_MODELISTS]; | |
| 78 | |
| 79 /* | |
| 80 * Experimentally determined values for c_cfDI* constants used in DirectX 5.0 | |
| 81 */ | |
| 82 | |
| 83 /* Keyboard */ | |
| 84 | |
| 85 static DIOBJECTDATAFORMAT KBD_fmt[] = { | |
| 86 { &GUID_Key, 0, 0x8000000C, 0x00000000 }, | |
| 87 { &GUID_Key, 1, 0x8000010C, 0x00000000 }, | |
| 88 { &GUID_Key, 2, 0x8000020C, 0x00000000 }, | |
| 89 { &GUID_Key, 3, 0x8000030C, 0x00000000 }, | |
| 90 { &GUID_Key, 4, 0x8000040C, 0x00000000 }, | |
| 91 { &GUID_Key, 5, 0x8000050C, 0x00000000 }, | |
| 92 { &GUID_Key, 6, 0x8000060C, 0x00000000 }, | |
| 93 { &GUID_Key, 7, 0x8000070C, 0x00000000 }, | |
| 94 { &GUID_Key, 8, 0x8000080C, 0x00000000 }, | |
| 95 { &GUID_Key, 9, 0x8000090C, 0x00000000 }, | |
| 96 { &GUID_Key, 10, 0x80000A0C, 0x00000000 }, | |
| 97 { &GUID_Key, 11, 0x80000B0C, 0x00000000 }, | |
| 98 { &GUID_Key, 12, 0x80000C0C, 0x00000000 }, | |
| 99 { &GUID_Key, 13, 0x80000D0C, 0x00000000 }, | |
| 100 { &GUID_Key, 14, 0x80000E0C, 0x00000000 }, | |
| 101 { &GUID_Key, 15, 0x80000F0C, 0x00000000 }, | |
| 102 { &GUID_Key, 16, 0x8000100C, 0x00000000 }, | |
| 103 { &GUID_Key, 17, 0x8000110C, 0x00000000 }, | |
| 104 { &GUID_Key, 18, 0x8000120C, 0x00000000 }, | |
| 105 { &GUID_Key, 19, 0x8000130C, 0x00000000 }, | |
| 106 { &GUID_Key, 20, 0x8000140C, 0x00000000 }, | |
| 107 { &GUID_Key, 21, 0x8000150C, 0x00000000 }, | |
| 108 { &GUID_Key, 22, 0x8000160C, 0x00000000 }, | |
| 109 { &GUID_Key, 23, 0x8000170C, 0x00000000 }, | |
| 110 { &GUID_Key, 24, 0x8000180C, 0x00000000 }, | |
| 111 { &GUID_Key, 25, 0x8000190C, 0x00000000 }, | |
| 112 { &GUID_Key, 26, 0x80001A0C, 0x00000000 }, | |
| 113 { &GUID_Key, 27, 0x80001B0C, 0x00000000 }, | |
| 114 { &GUID_Key, 28, 0x80001C0C, 0x00000000 }, | |
| 115 { &GUID_Key, 29, 0x80001D0C, 0x00000000 }, | |
| 116 { &GUID_Key, 30, 0x80001E0C, 0x00000000 }, | |
| 117 { &GUID_Key, 31, 0x80001F0C, 0x00000000 }, | |
| 118 { &GUID_Key, 32, 0x8000200C, 0x00000000 }, | |
| 119 { &GUID_Key, 33, 0x8000210C, 0x00000000 }, | |
| 120 { &GUID_Key, 34, 0x8000220C, 0x00000000 }, | |
| 121 { &GUID_Key, 35, 0x8000230C, 0x00000000 }, | |
| 122 { &GUID_Key, 36, 0x8000240C, 0x00000000 }, | |
| 123 { &GUID_Key, 37, 0x8000250C, 0x00000000 }, | |
| 124 { &GUID_Key, 38, 0x8000260C, 0x00000000 }, | |
| 125 { &GUID_Key, 39, 0x8000270C, 0x00000000 }, | |
| 126 { &GUID_Key, 40, 0x8000280C, 0x00000000 }, | |
| 127 { &GUID_Key, 41, 0x8000290C, 0x00000000 }, | |
| 128 { &GUID_Key, 42, 0x80002A0C, 0x00000000 }, | |
| 129 { &GUID_Key, 43, 0x80002B0C, 0x00000000 }, | |
| 130 { &GUID_Key, 44, 0x80002C0C, 0x00000000 }, | |
| 131 { &GUID_Key, 45, 0x80002D0C, 0x00000000 }, | |
| 132 { &GUID_Key, 46, 0x80002E0C, 0x00000000 }, | |
| 133 { &GUID_Key, 47, 0x80002F0C, 0x00000000 }, | |
| 134 { &GUID_Key, 48, 0x8000300C, 0x00000000 }, | |
| 135 { &GUID_Key, 49, 0x8000310C, 0x00000000 }, | |
| 136 { &GUID_Key, 50, 0x8000320C, 0x00000000 }, | |
| 137 { &GUID_Key, 51, 0x8000330C, 0x00000000 }, | |
| 138 { &GUID_Key, 52, 0x8000340C, 0x00000000 }, | |
| 139 { &GUID_Key, 53, 0x8000350C, 0x00000000 }, | |
| 140 { &GUID_Key, 54, 0x8000360C, 0x00000000 }, | |
| 141 { &GUID_Key, 55, 0x8000370C, 0x00000000 }, | |
| 142 { &GUID_Key, 56, 0x8000380C, 0x00000000 }, | |
| 143 { &GUID_Key, 57, 0x8000390C, 0x00000000 }, | |
| 144 { &GUID_Key, 58, 0x80003A0C, 0x00000000 }, | |
| 145 { &GUID_Key, 59, 0x80003B0C, 0x00000000 }, | |
| 146 { &GUID_Key, 60, 0x80003C0C, 0x00000000 }, | |
| 147 { &GUID_Key, 61, 0x80003D0C, 0x00000000 }, | |
| 148 { &GUID_Key, 62, 0x80003E0C, 0x00000000 }, | |
| 149 { &GUID_Key, 63, 0x80003F0C, 0x00000000 }, | |
| 150 { &GUID_Key, 64, 0x8000400C, 0x00000000 }, | |
| 151 { &GUID_Key, 65, 0x8000410C, 0x00000000 }, | |
| 152 { &GUID_Key, 66, 0x8000420C, 0x00000000 }, | |
| 153 { &GUID_Key, 67, 0x8000430C, 0x00000000 }, | |
| 154 { &GUID_Key, 68, 0x8000440C, 0x00000000 }, | |
| 155 { &GUID_Key, 69, 0x8000450C, 0x00000000 }, | |
| 156 { &GUID_Key, 70, 0x8000460C, 0x00000000 }, | |
| 157 { &GUID_Key, 71, 0x8000470C, 0x00000000 }, | |
| 158 { &GUID_Key, 72, 0x8000480C, 0x00000000 }, | |
| 159 { &GUID_Key, 73, 0x8000490C, 0x00000000 }, | |
| 160 { &GUID_Key, 74, 0x80004A0C, 0x00000000 }, | |
| 161 { &GUID_Key, 75, 0x80004B0C, 0x00000000 }, | |
| 162 { &GUID_Key, 76, 0x80004C0C, 0x00000000 }, | |
| 163 { &GUID_Key, 77, 0x80004D0C, 0x00000000 }, | |
| 164 { &GUID_Key, 78, 0x80004E0C, 0x00000000 }, | |
| 165 { &GUID_Key, 79, 0x80004F0C, 0x00000000 }, | |
| 166 { &GUID_Key, 80, 0x8000500C, 0x00000000 }, | |
| 167 { &GUID_Key, 81, 0x8000510C, 0x00000000 }, | |
| 168 { &GUID_Key, 82, 0x8000520C, 0x00000000 }, | |
| 169 { &GUID_Key, 83, 0x8000530C, 0x00000000 }, | |
| 170 { &GUID_Key, 84, 0x8000540C, 0x00000000 }, | |
| 171 { &GUID_Key, 85, 0x8000550C, 0x00000000 }, | |
| 172 { &GUID_Key, 86, 0x8000560C, 0x00000000 }, | |
| 173 { &GUID_Key, 87, 0x8000570C, 0x00000000 }, | |
| 174 { &GUID_Key, 88, 0x8000580C, 0x00000000 }, | |
| 175 { &GUID_Key, 89, 0x8000590C, 0x00000000 }, | |
| 176 { &GUID_Key, 90, 0x80005A0C, 0x00000000 }, | |
| 177 { &GUID_Key, 91, 0x80005B0C, 0x00000000 }, | |
| 178 { &GUID_Key, 92, 0x80005C0C, 0x00000000 }, | |
| 179 { &GUID_Key, 93, 0x80005D0C, 0x00000000 }, | |
| 180 { &GUID_Key, 94, 0x80005E0C, 0x00000000 }, | |
| 181 { &GUID_Key, 95, 0x80005F0C, 0x00000000 }, | |
| 182 { &GUID_Key, 96, 0x8000600C, 0x00000000 }, | |
| 183 { &GUID_Key, 97, 0x8000610C, 0x00000000 }, | |
| 184 { &GUID_Key, 98, 0x8000620C, 0x00000000 }, | |
| 185 { &GUID_Key, 99, 0x8000630C, 0x00000000 }, | |
| 186 { &GUID_Key, 100, 0x8000640C, 0x00000000 }, | |
| 187 { &GUID_Key, 101, 0x8000650C, 0x00000000 }, | |
| 188 { &GUID_Key, 102, 0x8000660C, 0x00000000 }, | |
| 189 { &GUID_Key, 103, 0x8000670C, 0x00000000 }, | |
| 190 { &GUID_Key, 104, 0x8000680C, 0x00000000 }, | |
| 191 { &GUID_Key, 105, 0x8000690C, 0x00000000 }, | |
| 192 { &GUID_Key, 106, 0x80006A0C, 0x00000000 }, | |
| 193 { &GUID_Key, 107, 0x80006B0C, 0x00000000 }, | |
| 194 { &GUID_Key, 108, 0x80006C0C, 0x00000000 }, | |
| 195 { &GUID_Key, 109, 0x80006D0C, 0x00000000 }, | |
| 196 { &GUID_Key, 110, 0x80006E0C, 0x00000000 }, | |
| 197 { &GUID_Key, 111, 0x80006F0C, 0x00000000 }, | |
| 198 { &GUID_Key, 112, 0x8000700C, 0x00000000 }, | |
| 199 { &GUID_Key, 113, 0x8000710C, 0x00000000 }, | |
| 200 { &GUID_Key, 114, 0x8000720C, 0x00000000 }, | |
| 201 { &GUID_Key, 115, 0x8000730C, 0x00000000 }, | |
| 202 { &GUID_Key, 116, 0x8000740C, 0x00000000 }, | |
| 203 { &GUID_Key, 117, 0x8000750C, 0x00000000 }, | |
| 204 { &GUID_Key, 118, 0x8000760C, 0x00000000 }, | |
| 205 { &GUID_Key, 119, 0x8000770C, 0x00000000 }, | |
| 206 { &GUID_Key, 120, 0x8000780C, 0x00000000 }, | |
| 207 { &GUID_Key, 121, 0x8000790C, 0x00000000 }, | |
| 208 { &GUID_Key, 122, 0x80007A0C, 0x00000000 }, | |
| 209 { &GUID_Key, 123, 0x80007B0C, 0x00000000 }, | |
| 210 { &GUID_Key, 124, 0x80007C0C, 0x00000000 }, | |
| 211 { &GUID_Key, 125, 0x80007D0C, 0x00000000 }, | |
| 212 { &GUID_Key, 126, 0x80007E0C, 0x00000000 }, | |
| 213 { &GUID_Key, 127, 0x80007F0C, 0x00000000 }, | |
| 214 { &GUID_Key, 128, 0x8000800C, 0x00000000 }, | |
| 215 { &GUID_Key, 129, 0x8000810C, 0x00000000 }, | |
| 216 { &GUID_Key, 130, 0x8000820C, 0x00000000 }, | |
| 217 { &GUID_Key, 131, 0x8000830C, 0x00000000 }, | |
| 218 { &GUID_Key, 132, 0x8000840C, 0x00000000 }, | |
| 219 { &GUID_Key, 133, 0x8000850C, 0x00000000 }, | |
| 220 { &GUID_Key, 134, 0x8000860C, 0x00000000 }, | |
| 221 { &GUID_Key, 135, 0x8000870C, 0x00000000 }, | |
| 222 { &GUID_Key, 136, 0x8000880C, 0x00000000 }, | |
| 223 { &GUID_Key, 137, 0x8000890C, 0x00000000 }, | |
| 224 { &GUID_Key, 138, 0x80008A0C, 0x00000000 }, | |
| 225 { &GUID_Key, 139, 0x80008B0C, 0x00000000 }, | |
| 226 { &GUID_Key, 140, 0x80008C0C, 0x00000000 }, | |
| 227 { &GUID_Key, 141, 0x80008D0C, 0x00000000 }, | |
| 228 { &GUID_Key, 142, 0x80008E0C, 0x00000000 }, | |
| 229 { &GUID_Key, 143, 0x80008F0C, 0x00000000 }, | |
| 230 { &GUID_Key, 144, 0x8000900C, 0x00000000 }, | |
| 231 { &GUID_Key, 145, 0x8000910C, 0x00000000 }, | |
| 232 { &GUID_Key, 146, 0x8000920C, 0x00000000 }, | |
| 233 { &GUID_Key, 147, 0x8000930C, 0x00000000 }, | |
| 234 { &GUID_Key, 148, 0x8000940C, 0x00000000 }, | |
| 235 { &GUID_Key, 149, 0x8000950C, 0x00000000 }, | |
| 236 { &GUID_Key, 150, 0x8000960C, 0x00000000 }, | |
| 237 { &GUID_Key, 151, 0x8000970C, 0x00000000 }, | |
| 238 { &GUID_Key, 152, 0x8000980C, 0x00000000 }, | |
| 239 { &GUID_Key, 153, 0x8000990C, 0x00000000 }, | |
| 240 { &GUID_Key, 154, 0x80009A0C, 0x00000000 }, | |
| 241 { &GUID_Key, 155, 0x80009B0C, 0x00000000 }, | |
| 242 { &GUID_Key, 156, 0x80009C0C, 0x00000000 }, | |
| 243 { &GUID_Key, 157, 0x80009D0C, 0x00000000 }, | |
| 244 { &GUID_Key, 158, 0x80009E0C, 0x00000000 }, | |
| 245 { &GUID_Key, 159, 0x80009F0C, 0x00000000 }, | |
| 246 { &GUID_Key, 160, 0x8000A00C, 0x00000000 }, | |
| 247 { &GUID_Key, 161, 0x8000A10C, 0x00000000 }, | |
| 248 { &GUID_Key, 162, 0x8000A20C, 0x00000000 }, | |
| 249 { &GUID_Key, 163, 0x8000A30C, 0x00000000 }, | |
| 250 { &GUID_Key, 164, 0x8000A40C, 0x00000000 }, | |
| 251 { &GUID_Key, 165, 0x8000A50C, 0x00000000 }, | |
| 252 { &GUID_Key, 166, 0x8000A60C, 0x00000000 }, | |
| 253 { &GUID_Key, 167, 0x8000A70C, 0x00000000 }, | |
| 254 { &GUID_Key, 168, 0x8000A80C, 0x00000000 }, | |
| 255 { &GUID_Key, 169, 0x8000A90C, 0x00000000 }, | |
| 256 { &GUID_Key, 170, 0x8000AA0C, 0x00000000 }, | |
| 257 { &GUID_Key, 171, 0x8000AB0C, 0x00000000 }, | |
| 258 { &GUID_Key, 172, 0x8000AC0C, 0x00000000 }, | |
| 259 { &GUID_Key, 173, 0x8000AD0C, 0x00000000 }, | |
| 260 { &GUID_Key, 174, 0x8000AE0C, 0x00000000 }, | |
| 261 { &GUID_Key, 175, 0x8000AF0C, 0x00000000 }, | |
| 262 { &GUID_Key, 176, 0x8000B00C, 0x00000000 }, | |
| 263 { &GUID_Key, 177, 0x8000B10C, 0x00000000 }, | |
| 264 { &GUID_Key, 178, 0x8000B20C, 0x00000000 }, | |
| 265 { &GUID_Key, 179, 0x8000B30C, 0x00000000 }, | |
| 266 { &GUID_Key, 180, 0x8000B40C, 0x00000000 }, | |
| 267 { &GUID_Key, 181, 0x8000B50C, 0x00000000 }, | |
| 268 { &GUID_Key, 182, 0x8000B60C, 0x00000000 }, | |
| 269 { &GUID_Key, 183, 0x8000B70C, 0x00000000 }, | |
| 270 { &GUID_Key, 184, 0x8000B80C, 0x00000000 }, | |
| 271 { &GUID_Key, 185, 0x8000B90C, 0x00000000 }, | |
| 272 { &GUID_Key, 186, 0x8000BA0C, 0x00000000 }, | |
| 273 { &GUID_Key, 187, 0x8000BB0C, 0x00000000 }, | |
| 274 { &GUID_Key, 188, 0x8000BC0C, 0x00000000 }, | |
| 275 { &GUID_Key, 189, 0x8000BD0C, 0x00000000 }, | |
| 276 { &GUID_Key, 190, 0x8000BE0C, 0x00000000 }, | |
| 277 { &GUID_Key, 191, 0x8000BF0C, 0x00000000 }, | |
| 278 { &GUID_Key, 192, 0x8000C00C, 0x00000000 }, | |
| 279 { &GUID_Key, 193, 0x8000C10C, 0x00000000 }, | |
| 280 { &GUID_Key, 194, 0x8000C20C, 0x00000000 }, | |
| 281 { &GUID_Key, 195, 0x8000C30C, 0x00000000 }, | |
| 282 { &GUID_Key, 196, 0x8000C40C, 0x00000000 }, | |
| 283 { &GUID_Key, 197, 0x8000C50C, 0x00000000 }, | |
| 284 { &GUID_Key, 198, 0x8000C60C, 0x00000000 }, | |
| 285 { &GUID_Key, 199, 0x8000C70C, 0x00000000 }, | |
| 286 { &GUID_Key, 200, 0x8000C80C, 0x00000000 }, | |
| 287 { &GUID_Key, 201, 0x8000C90C, 0x00000000 }, | |
| 288 { &GUID_Key, 202, 0x8000CA0C, 0x00000000 }, | |
| 289 { &GUID_Key, 203, 0x8000CB0C, 0x00000000 }, | |
| 290 { &GUID_Key, 204, 0x8000CC0C, 0x00000000 }, | |
| 291 { &GUID_Key, 205, 0x8000CD0C, 0x00000000 }, | |
| 292 { &GUID_Key, 206, 0x8000CE0C, 0x00000000 }, | |
| 293 { &GUID_Key, 207, 0x8000CF0C, 0x00000000 }, | |
| 294 { &GUID_Key, 208, 0x8000D00C, 0x00000000 }, | |
| 295 { &GUID_Key, 209, 0x8000D10C, 0x00000000 }, | |
| 296 { &GUID_Key, 210, 0x8000D20C, 0x00000000 }, | |
| 297 { &GUID_Key, 211, 0x8000D30C, 0x00000000 }, | |
| 298 { &GUID_Key, 212, 0x8000D40C, 0x00000000 }, | |
| 299 { &GUID_Key, 213, 0x8000D50C, 0x00000000 }, | |
| 300 { &GUID_Key, 214, 0x8000D60C, 0x00000000 }, | |
| 301 { &GUID_Key, 215, 0x8000D70C, 0x00000000 }, | |
| 302 { &GUID_Key, 216, 0x8000D80C, 0x00000000 }, | |
| 303 { &GUID_Key, 217, 0x8000D90C, 0x00000000 }, | |
| 304 { &GUID_Key, 218, 0x8000DA0C, 0x00000000 }, | |
| 305 { &GUID_Key, 219, 0x8000DB0C, 0x00000000 }, | |
| 306 { &GUID_Key, 220, 0x8000DC0C, 0x00000000 }, | |
| 307 { &GUID_Key, 221, 0x8000DD0C, 0x00000000 }, | |
| 308 { &GUID_Key, 222, 0x8000DE0C, 0x00000000 }, | |
| 309 { &GUID_Key, 223, 0x8000DF0C, 0x00000000 }, | |
| 310 { &GUID_Key, 224, 0x8000E00C, 0x00000000 }, | |
| 311 { &GUID_Key, 225, 0x8000E10C, 0x00000000 }, | |
| 312 { &GUID_Key, 226, 0x8000E20C, 0x00000000 }, | |
| 313 { &GUID_Key, 227, 0x8000E30C, 0x00000000 }, | |
| 314 { &GUID_Key, 228, 0x8000E40C, 0x00000000 }, | |
| 315 { &GUID_Key, 229, 0x8000E50C, 0x00000000 }, | |
| 316 { &GUID_Key, 230, 0x8000E60C, 0x00000000 }, | |
| 317 { &GUID_Key, 231, 0x8000E70C, 0x00000000 }, | |
| 318 { &GUID_Key, 232, 0x8000E80C, 0x00000000 }, | |
| 319 { &GUID_Key, 233, 0x8000E90C, 0x00000000 }, | |
| 320 { &GUID_Key, 234, 0x8000EA0C, 0x00000000 }, | |
| 321 { &GUID_Key, 235, 0x8000EB0C, 0x00000000 }, | |
| 322 { &GUID_Key, 236, 0x8000EC0C, 0x00000000 }, | |
| 323 { &GUID_Key, 237, 0x8000ED0C, 0x00000000 }, | |
| 324 { &GUID_Key, 238, 0x8000EE0C, 0x00000000 }, | |
| 325 { &GUID_Key, 239, 0x8000EF0C, 0x00000000 }, | |
| 326 { &GUID_Key, 240, 0x8000F00C, 0x00000000 }, | |
| 327 { &GUID_Key, 241, 0x8000F10C, 0x00000000 }, | |
| 328 { &GUID_Key, 242, 0x8000F20C, 0x00000000 }, | |
| 329 { &GUID_Key, 243, 0x8000F30C, 0x00000000 }, | |
| 330 { &GUID_Key, 244, 0x8000F40C, 0x00000000 }, | |
| 331 { &GUID_Key, 245, 0x8000F50C, 0x00000000 }, | |
| 332 { &GUID_Key, 246, 0x8000F60C, 0x00000000 }, | |
| 333 { &GUID_Key, 247, 0x8000F70C, 0x00000000 }, | |
| 334 { &GUID_Key, 248, 0x8000F80C, 0x00000000 }, | |
| 335 { &GUID_Key, 249, 0x8000F90C, 0x00000000 }, | |
| 336 { &GUID_Key, 250, 0x8000FA0C, 0x00000000 }, | |
| 337 { &GUID_Key, 251, 0x8000FB0C, 0x00000000 }, | |
| 338 { &GUID_Key, 252, 0x8000FC0C, 0x00000000 }, | |
| 339 { &GUID_Key, 253, 0x8000FD0C, 0x00000000 }, | |
| 340 { &GUID_Key, 254, 0x8000FE0C, 0x00000000 }, | |
| 341 { &GUID_Key, 255, 0x8000FF0C, 0x00000000 }, | |
| 342 }; | |
| 343 | |
| 344 const DIDATAFORMAT c_dfDIKeyboard = { 24, 16, 0x00000002, 256, 256, KBD_fmt }; | |
| 345 | |
| 346 | |
| 347 /* Mouse */ | |
| 348 | |
| 349 static DIOBJECTDATAFORMAT PTR_fmt[] = { | |
| 350 { &GUID_XAxis, 0, 0x00FFFF03, 0x00000000 }, | |
| 351 { &GUID_YAxis, 4, 0x00FFFF03, 0x00000000 }, | |
| 352 { &GUID_ZAxis, 8, 0x80FFFF03, 0x00000000 }, | |
| 353 { NULL, 12, 0x00FFFF0C, 0x00000000 }, | |
| 354 { NULL, 13, 0x00FFFF0C, 0x00000000 }, | |
| 355 { NULL, 14, 0x80FFFF0C, 0x00000000 }, | |
| 356 { NULL, 15, 0x80FFFF0C, 0x00000000 }, | |
| 357 }; | |
| 358 | |
| 359 const DIDATAFORMAT c_dfDIMouse = { 24, 16, 0x00000002, 16, 7, PTR_fmt }; | |
| 360 | |
| 361 | |
| 362 /* Joystick */ | |
| 363 | |
| 364 static DIOBJECTDATAFORMAT JOY_fmt[] = { | |
| 365 { &GUID_XAxis, 0, 0x80FFFF03, 0x00000100 }, | |
| 366 { &GUID_YAxis, 4, 0x80FFFF03, 0x00000100 }, | |
| 367 { &GUID_ZAxis, 8, 0x80FFFF03, 0x00000100 }, | |
| 368 { &GUID_RxAxis, 12, 0x80FFFF03, 0x00000100 }, | |
| 369 { &GUID_RyAxis, 16, 0x80FFFF03, 0x00000100 }, | |
| 370 { &GUID_RzAxis, 20, 0x80FFFF03, 0x00000100 }, | |
| 371 { &GUID_Slider, 24, 0x80FFFF03, 0x00000100 }, | |
| 372 { &GUID_Slider, 28, 0x80FFFF03, 0x00000100 }, | |
| 373 { &GUID_POV, 32, 0x80FFFF10, 0x00000000 }, | |
| 374 { &GUID_POV, 36, 0x80FFFF10, 0x00000000 }, | |
| 375 { &GUID_POV, 40, 0x80FFFF10, 0x00000000 }, | |
| 376 { &GUID_POV, 44, 0x80FFFF10, 0x00000000 }, | |
| 377 { NULL, 48, 0x80FFFF0C, 0x00000000 }, | |
| 378 { NULL, 49, 0x80FFFF0C, 0x00000000 }, | |
| 379 { NULL, 50, 0x80FFFF0C, 0x00000000 }, | |
| 380 { NULL, 51, 0x80FFFF0C, 0x00000000 }, | |
| 381 { NULL, 52, 0x80FFFF0C, 0x00000000 }, | |
| 382 { NULL, 53, 0x80FFFF0C, 0x00000000 }, | |
| 383 { NULL, 54, 0x80FFFF0C, 0x00000000 }, | |
| 384 { NULL, 55, 0x80FFFF0C, 0x00000000 }, | |
| 385 { NULL, 56, 0x80FFFF0C, 0x00000000 }, | |
| 386 { NULL, 57, 0x80FFFF0C, 0x00000000 }, | |
| 387 { NULL, 58, 0x80FFFF0C, 0x00000000 }, | |
| 388 { NULL, 59, 0x80FFFF0C, 0x00000000 }, | |
| 389 { NULL, 60, 0x80FFFF0C, 0x00000000 }, | |
| 390 { NULL, 61, 0x80FFFF0C, 0x00000000 }, | |
| 391 { NULL, 62, 0x80FFFF0C, 0x00000000 }, | |
| 392 { NULL, 63, 0x80FFFF0C, 0x00000000 }, | |
| 393 { NULL, 64, 0x80FFFF0C, 0x00000000 }, | |
| 394 { NULL, 65, 0x80FFFF0C, 0x00000000 }, | |
| 395 { NULL, 66, 0x80FFFF0C, 0x00000000 }, | |
| 396 { NULL, 67, 0x80FFFF0C, 0x00000000 }, | |
| 397 { NULL, 68, 0x80FFFF0C, 0x00000000 }, | |
| 398 { NULL, 69, 0x80FFFF0C, 0x00000000 }, | |
| 399 { NULL, 70, 0x80FFFF0C, 0x00000000 }, | |
| 400 { NULL, 71, 0x80FFFF0C, 0x00000000 }, | |
| 401 { NULL, 72, 0x80FFFF0C, 0x00000000 }, | |
| 402 { NULL, 73, 0x80FFFF0C, 0x00000000 }, | |
| 403 { NULL, 74, 0x80FFFF0C, 0x00000000 }, | |
| 404 { NULL, 75, 0x80FFFF0C, 0x00000000 }, | |
| 405 { NULL, 76, 0x80FFFF0C, 0x00000000 }, | |
| 406 { NULL, 77, 0x80FFFF0C, 0x00000000 }, | |
| 407 { NULL, 78, 0x80FFFF0C, 0x00000000 }, | |
| 408 { NULL, 79, 0x80FFFF0C, 0x00000000 }, | |
| 409 }; | |
| 410 | |
| 411 const DIDATAFORMAT c_dfDIJoystick = { 24, 16, 0x00000001, 80, 44, JOY_fmt }; | |
| 412 | |
| 413 | |
| 414 /* Initialization/Query functions */ | |
| 415 static int DX5_VideoInit(_THIS, SDL_PixelFormat *vformat); | |
| 416 static SDL_Rect **DX5_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); | |
| 417 static SDL_Surface *DX5_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | |
| 418 static int DX5_SetColors(_THIS, int firstcolor, int ncolors, | |
| 419 SDL_Color *colors); | |
| 420 static int DX5_SetGammaRamp(_THIS, Uint16 *ramp); | |
| 421 static int DX5_GetGammaRamp(_THIS, Uint16 *ramp); | |
| 422 static void DX5_VideoQuit(_THIS); | |
| 423 | |
| 424 /* Hardware surface functions */ | |
| 425 static int DX5_AllocHWSurface(_THIS, SDL_Surface *surface); | |
| 426 static int DX5_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst); | |
| 427 static int DX5_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color); | |
| 428 static int DX5_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key); | |
| 429 static int DX5_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha); | |
| 430 static int DX5_LockHWSurface(_THIS, SDL_Surface *surface); | |
| 431 static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface); | |
| 432 static int DX5_FlipHWSurface(_THIS, SDL_Surface *surface); | |
| 433 static void DX5_FreeHWSurface(_THIS, SDL_Surface *surface); | |
| 434 | |
| 435 static int DX5_AllocDDSurface(_THIS, SDL_Surface *surface, | |
| 436 LPDIRECTDRAWSURFACE3 requested, Uint32 flag); | |
| 437 | |
| 438 /* Windows message handling functions */ | |
| 439 static void DX5_RealizePalette(_THIS); | |
| 440 static void DX5_PaletteChanged(_THIS, HWND window); | |
| 441 static void DX5_WinPAINT(_THIS, HDC hdc); | |
| 442 | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
443 /* WinDIB driver functions for manipulating gamma ramps */ |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
444 extern int DIB_SetGammaRamp(_THIS, Uint16 *ramp); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
445 extern int DIB_GetGammaRamp(_THIS, Uint16 *ramp); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
446 extern void DIB_QuitGamma(_THIS); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
447 |
| 0 | 448 /* DX5 driver bootstrap functions */ |
| 449 | |
| 450 static int DX5_Available(void) | |
| 451 { | |
| 452 HINSTANCE DInputDLL; | |
| 453 HINSTANCE DDrawDLL; | |
| 454 int dinput_ok; | |
| 455 int ddraw_ok; | |
| 456 | |
| 457 /* Version check DINPUT.DLL and DDRAW.DLL (Is DirectX okay?) */ | |
| 458 dinput_ok = 0; | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
459 DInputDLL = LoadLibrary(TEXT("DINPUT.DLL")); |
| 0 | 460 if ( DInputDLL != NULL ) { |
| 461 dinput_ok = 1; | |
| 462 FreeLibrary(DInputDLL); | |
| 463 } | |
| 464 ddraw_ok = 0; | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
465 DDrawDLL = LoadLibrary(TEXT("DDRAW.DLL")); |
| 0 | 466 if ( DDrawDLL != NULL ) { |
| 467 HRESULT (WINAPI *DDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *); | |
| 468 LPDIRECTDRAW DDraw; | |
| 469 | |
| 470 /* Try to create a valid DirectDraw object */ | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
471 DDrawCreate = (void *)GetProcAddress(DDrawDLL, TEXT("DirectDrawCreate")); |
| 0 | 472 if ( (DDrawCreate != NULL) |
| 473 && !FAILED(DDrawCreate(NULL, &DDraw, NULL)) ) { | |
| 474 if ( !FAILED(IDirectDraw_SetCooperativeLevel(DDraw, | |
| 475 NULL, DDSCL_NORMAL)) ) { | |
| 476 DDSURFACEDESC desc; | |
| 477 LPDIRECTDRAWSURFACE DDrawSurf; | |
| 478 LPDIRECTDRAWSURFACE3 DDrawSurf3; | |
| 479 | |
| 480 /* Try to create a DirectDrawSurface3 object */ | |
| 481 memset(&desc, 0, sizeof(desc)); | |
| 482 desc.dwSize = sizeof(desc); | |
| 483 desc.dwFlags = DDSD_CAPS; | |
| 484 desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE|DDSCAPS_VIDEOMEMORY; | |
| 485 if ( !FAILED(IDirectDraw_CreateSurface(DDraw, &desc, | |
| 486 &DDrawSurf, NULL)) ) { | |
| 487 if ( !FAILED(IDirectDrawSurface_QueryInterface(DDrawSurf, | |
| 488 &IID_IDirectDrawSurface3, (LPVOID *)&DDrawSurf3)) ) { | |
| 489 /* Yay! */ | |
| 490 ddraw_ok = 1; | |
| 491 | |
| 492 /* Clean up.. */ | |
| 493 IDirectDrawSurface3_Release(DDrawSurf3); | |
| 494 } | |
| 495 IDirectDrawSurface_Release(DDrawSurf); | |
| 496 } | |
| 497 } | |
| 498 IDirectDraw_Release(DDraw); | |
| 499 } | |
| 500 FreeLibrary(DDrawDLL); | |
| 501 } | |
| 502 return(dinput_ok && ddraw_ok); | |
| 503 } | |
| 504 | |
| 505 /* Functions for loading the DirectX functions dynamically */ | |
| 506 static HINSTANCE DDrawDLL = NULL; | |
| 507 static HINSTANCE DInputDLL = NULL; | |
| 508 | |
| 509 static void DX5_Unload(void) | |
| 510 { | |
| 511 if ( DDrawDLL != NULL ) { | |
| 512 FreeLibrary(DDrawDLL); | |
| 513 DDrawCreate = NULL; | |
| 514 DDrawDLL = NULL; | |
| 515 } | |
| 516 if ( DInputDLL != NULL ) { | |
| 517 FreeLibrary(DInputDLL); | |
| 518 DInputCreate = NULL; | |
| 519 DInputDLL = NULL; | |
| 520 } | |
| 521 } | |
| 522 static int DX5_Load(void) | |
| 523 { | |
| 524 int status; | |
| 525 | |
| 526 DX5_Unload(); | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
527 DDrawDLL = LoadLibrary(TEXT("DDRAW.DLL")); |
| 0 | 528 if ( DDrawDLL != NULL ) { |
| 529 DDrawCreate = (void *)GetProcAddress(DDrawDLL, | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
530 TEXT("DirectDrawCreate")); |
| 0 | 531 } |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
532 DInputDLL = LoadLibrary(TEXT("DINPUT.DLL")); |
| 0 | 533 if ( DInputDLL != NULL ) { |
| 534 DInputCreate = (void *)GetProcAddress(DInputDLL, | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
535 TEXT("DirectInputCreateA")); |
| 0 | 536 } |
| 537 if ( DDrawDLL && DDrawCreate && DInputDLL && DInputCreate ) { | |
| 538 status = 0; | |
| 539 } else { | |
| 540 DX5_Unload(); | |
| 541 status = -1; | |
| 542 } | |
| 543 return status; | |
| 544 } | |
| 545 | |
| 546 static void DX5_DeleteDevice(SDL_VideoDevice *this) | |
| 547 { | |
| 548 /* Free DirectDraw object */ | |
| 549 if ( ddraw2 != NULL ) { | |
| 550 IDirectDraw2_Release(ddraw2); | |
| 551 } | |
| 552 DX5_Unload(); | |
| 553 if ( this ) { | |
| 554 if ( this->hidden ) { | |
| 555 free(this->hidden); | |
| 556 } | |
| 557 if ( this->gl_data ) { | |
| 558 free(this->gl_data); | |
| 559 } | |
| 560 free(this); | |
| 561 } | |
| 562 } | |
| 563 | |
| 564 static SDL_VideoDevice *DX5_CreateDevice(int devindex) | |
| 565 { | |
| 566 SDL_VideoDevice *device; | |
| 567 | |
| 568 /* Load DirectX */ | |
| 569 if ( DX5_Load() < 0 ) { | |
| 570 return(NULL); | |
| 571 } | |
| 572 | |
| 573 /* Initialize all variables that we clean on shutdown */ | |
| 574 device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); | |
| 575 if ( device ) { | |
| 576 memset(device, 0, (sizeof *device)); | |
| 577 device->hidden = (struct SDL_PrivateVideoData *) | |
| 578 malloc((sizeof *device->hidden)); | |
| 579 device->gl_data = (struct SDL_PrivateGLData *) | |
| 580 malloc((sizeof *device->gl_data)); | |
| 581 } | |
| 582 if ( (device == NULL) || (device->hidden == NULL) || | |
| 583 (device->gl_data == NULL) ) { | |
| 584 SDL_OutOfMemory(); | |
| 585 DX5_DeleteDevice(device); | |
| 586 return(NULL); | |
| 587 } | |
| 588 memset(device->hidden, 0, (sizeof *device->hidden)); | |
| 589 memset(device->gl_data, 0, (sizeof *device->gl_data)); | |
| 590 | |
| 591 /* Set the function pointers */ | |
| 592 device->VideoInit = DX5_VideoInit; | |
| 593 device->ListModes = DX5_ListModes; | |
| 594 device->SetVideoMode = DX5_SetVideoMode; | |
| 595 device->UpdateMouse = WIN_UpdateMouse; | |
| 596 device->CreateYUVOverlay = DX5_CreateYUVOverlay; | |
| 597 device->SetColors = DX5_SetColors; | |
| 598 device->UpdateRects = NULL; | |
| 599 device->VideoQuit = DX5_VideoQuit; | |
| 600 device->AllocHWSurface = DX5_AllocHWSurface; | |
| 601 device->CheckHWBlit = DX5_CheckHWBlit; | |
| 602 device->FillHWRect = DX5_FillHWRect; | |
| 603 device->SetHWColorKey = DX5_SetHWColorKey; | |
| 604 device->SetHWAlpha = DX5_SetHWAlpha; | |
| 605 device->LockHWSurface = DX5_LockHWSurface; | |
| 606 device->UnlockHWSurface = DX5_UnlockHWSurface; | |
| 607 device->FlipHWSurface = DX5_FlipHWSurface; | |
| 608 device->FreeHWSurface = DX5_FreeHWSurface; | |
| 609 device->SetGammaRamp = DX5_SetGammaRamp; | |
| 610 device->GetGammaRamp = DX5_GetGammaRamp; | |
| 611 #ifdef HAVE_OPENGL | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
612 device->GL_LoadLibrary = WIN_GL_LoadLibrary; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
613 device->GL_GetProcAddress = WIN_GL_GetProcAddress; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
614 device->GL_GetAttribute = WIN_GL_GetAttribute; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
615 device->GL_MakeCurrent = WIN_GL_MakeCurrent; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
616 device->GL_SwapBuffers = WIN_GL_SwapBuffers; |
| 0 | 617 #endif |
| 618 device->SetCaption = WIN_SetWMCaption; | |
| 619 device->SetIcon = WIN_SetWMIcon; | |
| 620 device->IconifyWindow = WIN_IconifyWindow; | |
| 621 device->GrabInput = WIN_GrabInput; | |
| 622 device->GetWMInfo = WIN_GetWMInfo; | |
| 623 device->FreeWMCursor = WIN_FreeWMCursor; | |
| 624 device->CreateWMCursor = WIN_CreateWMCursor; | |
| 625 device->ShowWMCursor = WIN_ShowWMCursor; | |
| 626 device->WarpWMCursor = WIN_WarpWMCursor; | |
| 627 device->CheckMouseMode = WIN_CheckMouseMode; | |
| 628 device->InitOSKeymap = DX5_InitOSKeymap; | |
| 629 device->PumpEvents = DX5_PumpEvents; | |
| 630 | |
| 631 /* Set up the windows message handling functions */ | |
| 632 WIN_RealizePalette = DX5_RealizePalette; | |
| 633 WIN_PaletteChanged = DX5_PaletteChanged; | |
| 634 WIN_WinPAINT = DX5_WinPAINT; | |
| 635 HandleMessage = DX5_HandleMessage; | |
| 636 | |
| 637 device->free = DX5_DeleteDevice; | |
| 638 | |
| 639 /* We're finally ready */ | |
| 640 return device; | |
| 641 } | |
| 642 | |
| 643 VideoBootStrap DIRECTX_bootstrap = { | |
| 644 "directx", "Win95/98/2000 DirectX", | |
| 645 DX5_Available, DX5_CreateDevice | |
| 646 }; | |
| 647 | |
| 648 static HRESULT WINAPI EnumModes2(DDSURFACEDESC *desc, VOID *udata) | |
| 649 { | |
| 650 SDL_VideoDevice *this = (SDL_VideoDevice *)udata; | |
| 651 struct DX5EnumRect *enumrect; | |
| 652 #if defined(NONAMELESSUNION) | |
| 653 int bpp = desc->ddpfPixelFormat.u1.dwRGBBitCount; | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
654 int refreshRate = desc->u2.dwRefreshRate; |
| 0 | 655 #else |
| 656 int bpp = desc->ddpfPixelFormat.dwRGBBitCount; | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
657 int refreshRate = desc->dwRefreshRate; |
| 0 | 658 #endif |
| 659 | |
| 660 switch (bpp) { | |
| 661 case 8: | |
| 662 case 16: | |
| 663 case 24: | |
| 664 case 32: | |
| 665 bpp /= 8; --bpp; | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
666 if ( enumlists[bpp] && |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
667 enumlists[bpp]->r.w == (Uint16)desc->dwWidth && |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
668 enumlists[bpp]->r.h == (Uint16)desc->dwHeight ) { |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
669 if ( refreshRate > enumlists[bpp]->refreshRate && |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
670 refreshRate <= 85 /* safe value? */ ) { |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
671 enumlists[bpp]->refreshRate = refreshRate; |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
672 printf("New refresh rate for %d bpp: %dx%d at %d Hz\n", (bpp+1)*8, (int)desc->dwWidth, (int)desc->dwHeight, refreshRate); |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
673 } |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
674 break; |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
675 } |
| 0 | 676 ++SDL_nummodes[bpp]; |
| 677 enumrect = (struct DX5EnumRect*)malloc(sizeof(struct DX5EnumRect)); | |
| 678 if ( !enumrect ) { | |
| 679 SDL_OutOfMemory(); | |
| 680 return(DDENUMRET_CANCEL); | |
| 681 } | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
682 enumrect->refreshRate = refreshRate; |
| 0 | 683 enumrect->r.x = 0; |
| 684 enumrect->r.y = 0; | |
| 685 enumrect->r.w = (Uint16)desc->dwWidth; | |
| 686 enumrect->r.h = (Uint16)desc->dwHeight; | |
| 687 enumrect->next = enumlists[bpp]; | |
| 688 enumlists[bpp] = enumrect; | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
689 printf("New mode for %d bpp: %dx%d at %d Hz\n", (bpp+1)*8, (int)desc->dwWidth, (int)desc->dwHeight, refreshRate); |
| 0 | 690 break; |
| 691 } | |
| 692 | |
| 693 return(DDENUMRET_OK); | |
| 694 } | |
| 695 | |
| 696 void SetDDerror(const char *function, int code) | |
| 697 { | |
| 698 static char *error; | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
699 static char errbuf[1024]; |
| 0 | 700 |
| 701 errbuf[0] = 0; | |
| 702 switch (code) { | |
| 703 case DDERR_GENERIC: | |
| 704 error = "Undefined error!"; | |
| 705 break; | |
| 706 case DDERR_EXCEPTION: | |
| 707 error = "Exception encountered"; | |
| 708 break; | |
| 709 case DDERR_INVALIDOBJECT: | |
| 710 error = "Invalid object"; | |
| 711 break; | |
| 712 case DDERR_INVALIDPARAMS: | |
| 713 error = "Invalid parameters"; | |
| 714 break; | |
| 715 case DDERR_NOTFOUND: | |
| 716 error = "Object not found"; | |
| 717 break; | |
| 718 case DDERR_INVALIDRECT: | |
| 719 error = "Invalid rectangle"; | |
| 720 break; | |
| 721 case DDERR_INVALIDCAPS: | |
| 722 error = "Invalid caps member"; | |
| 723 break; | |
| 724 case DDERR_INVALIDPIXELFORMAT: | |
| 725 error = "Invalid pixel format"; | |
| 726 break; | |
| 727 case DDERR_OUTOFMEMORY: | |
| 728 error = "Out of memory"; | |
| 729 break; | |
| 730 case DDERR_OUTOFVIDEOMEMORY: | |
| 731 error = "Out of video memory"; | |
| 732 break; | |
| 733 case DDERR_SURFACEBUSY: | |
| 734 error = "Surface busy"; | |
| 735 break; | |
| 736 case DDERR_SURFACELOST: | |
| 737 error = "Surface was lost"; | |
| 738 break; | |
| 739 case DDERR_WASSTILLDRAWING: | |
| 740 error = "DirectDraw is still drawing"; | |
| 741 break; | |
| 742 case DDERR_INVALIDSURFACETYPE: | |
| 743 error = "Invalid surface type"; | |
| 744 break; | |
| 745 case DDERR_NOEXCLUSIVEMODE: | |
| 746 error = "Not in exclusive access mode"; | |
| 747 break; | |
| 748 case DDERR_NOPALETTEATTACHED: | |
| 749 error = "No palette attached"; | |
| 750 break; | |
| 751 case DDERR_NOPALETTEHW: | |
| 752 error = "No palette hardware"; | |
| 753 break; | |
| 754 case DDERR_NOT8BITCOLOR: | |
| 755 error = "Not 8-bit color"; | |
| 756 break; | |
| 757 case DDERR_EXCLUSIVEMODEALREADYSET: | |
| 758 error = "Exclusive mode was already set"; | |
| 759 break; | |
| 760 case DDERR_HWNDALREADYSET: | |
| 761 error = "Window handle already set"; | |
| 762 break; | |
| 763 case DDERR_HWNDSUBCLASSED: | |
| 764 error = "Window handle is subclassed"; | |
| 765 break; | |
| 766 case DDERR_NOBLTHW: | |
| 767 error = "No blit hardware"; | |
| 768 break; | |
| 769 case DDERR_IMPLICITLYCREATED: | |
| 770 error = "Surface was implicitly created"; | |
| 771 break; | |
| 772 case DDERR_INCOMPATIBLEPRIMARY: | |
| 773 error = "Incompatible primary surface"; | |
| 774 break; | |
| 775 case DDERR_NOCOOPERATIVELEVELSET: | |
| 776 error = "No cooperative level set"; | |
| 777 break; | |
| 778 case DDERR_NODIRECTDRAWHW: | |
| 779 error = "No DirectDraw hardware"; | |
| 780 break; | |
| 781 case DDERR_NOEMULATION: | |
| 782 error = "No emulation available"; | |
| 783 break; | |
| 784 case DDERR_NOFLIPHW: | |
| 785 error = "No flip hardware"; | |
| 786 break; | |
| 787 case DDERR_NOTFLIPPABLE: | |
| 788 error = "Surface not flippable"; | |
| 789 break; | |
| 790 case DDERR_PRIMARYSURFACEALREADYEXISTS: | |
| 791 error = "Primary surface already exists"; | |
| 792 break; | |
| 793 case DDERR_UNSUPPORTEDMODE: | |
| 794 error = "Unsupported mode"; | |
| 795 break; | |
| 796 case DDERR_WRONGMODE: | |
| 797 error = "Surface created in different mode"; | |
| 798 break; | |
| 799 case DDERR_UNSUPPORTED: | |
| 800 error = "Operation not supported"; | |
| 801 break; | |
| 802 case E_NOINTERFACE: | |
| 803 error = "Interface not present"; | |
| 804 break; | |
| 805 default: | |
| 806 sprintf(errbuf, "%s: Unknown DirectDraw error: 0x%x", | |
| 807 function, code); | |
| 808 break; | |
| 809 } | |
| 810 if ( ! errbuf[0] ) { | |
| 811 sprintf(errbuf, "%s: %s", function, error); | |
| 812 } | |
| 813 SDL_SetError("%s", errbuf); | |
| 814 return; | |
| 815 } | |
| 816 | |
| 817 | |
| 818 static int DX5_UpdateVideoInfo(_THIS) | |
| 819 { | |
| 820 /* This needs to be DDCAPS_DX5 for the DirectDraw2 interface */ | |
| 821 #if DIRECTDRAW_VERSION <= 0x300 | |
| 822 #error Your version of DirectX must be greater than or equal to 5.0 | |
| 823 #endif | |
|
334
f65715bd8ad8
Fixed DirectX fullscreen gamma control (thanks John!)
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
824 #ifndef IDirectDrawGammaControl_SetGammaRamp |
| 0 | 825 /*if gamma is undefined then we really have directx <= 0x500*/ |
| 826 DDCAPS DDCaps; | |
| 827 #else | |
| 828 DDCAPS_DX5 DDCaps; | |
| 829 #endif | |
| 830 HRESULT result; | |
| 831 | |
| 832 /* Fill in our hardware acceleration capabilities */ | |
| 833 memset(&DDCaps, 0, sizeof(DDCaps)); | |
| 834 DDCaps.dwSize = sizeof(DDCaps); | |
| 835 result = IDirectDraw2_GetCaps(ddraw2, (DDCAPS *)&DDCaps, NULL); | |
| 836 if ( result != DD_OK ) { | |
| 837 SetDDerror("DirectDraw2::GetCaps", result); | |
| 838 return(-1); | |
| 839 } | |
| 840 this->info.hw_available = 1; | |
| 841 if ( (DDCaps.dwCaps & DDCAPS_BLT) == DDCAPS_BLT ) { | |
| 842 this->info.blit_hw = 1; | |
| 843 } | |
| 844 if ( ((DDCaps.dwCaps & DDCAPS_COLORKEY) == DDCAPS_COLORKEY) && | |
| 845 ((DDCaps.dwCKeyCaps & DDCKEYCAPS_SRCBLT) == DDCKEYCAPS_SRCBLT) ) { | |
| 846 this->info.blit_hw_CC = 1; | |
| 847 } | |
| 848 if ( (DDCaps.dwCaps & DDCAPS_ALPHA) == DDCAPS_ALPHA ) { | |
| 849 /* This is only for alpha channel, and DirectX 6 | |
| 850 doesn't support 2D alpha blits yet, so set it 0 | |
| 851 */ | |
| 852 this->info.blit_hw_A = 0; | |
| 853 } | |
| 854 if ( (DDCaps.dwCaps & DDCAPS_CANBLTSYSMEM) == DDCAPS_CANBLTSYSMEM ) { | |
| 855 this->info.blit_sw = 1; | |
| 856 /* This isn't necessarily true, but the HEL will cover us */ | |
| 857 this->info.blit_sw_CC = this->info.blit_hw_CC; | |
| 858 this->info.blit_sw_A = this->info.blit_hw_A; | |
| 859 } | |
| 860 if ( (DDCaps.dwCaps & DDCAPS_BLTCOLORFILL) == DDCAPS_BLTCOLORFILL ) { | |
| 861 this->info.blit_fill = 1; | |
| 862 } | |
| 863 | |
| 864 /* Find out how much video memory is available */ | |
| 865 { DDSCAPS ddsCaps; | |
| 866 DWORD total_mem; | |
| 867 ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY; | |
| 868 result = IDirectDraw2_GetAvailableVidMem(ddraw2, | |
| 869 &ddsCaps, &total_mem, NULL); | |
| 870 if ( result != DD_OK ) { | |
| 871 total_mem = DDCaps.dwVidMemTotal; | |
| 872 } | |
| 873 this->info.video_mem = total_mem/1024; | |
| 874 } | |
| 875 return(0); | |
| 876 } | |
| 877 | |
| 878 int DX5_VideoInit(_THIS, SDL_PixelFormat *vformat) | |
| 879 { | |
| 880 HRESULT result; | |
| 881 LPDIRECTDRAW ddraw; | |
| 882 int i, j; | |
| 883 HDC hdc; | |
| 884 | |
| 885 /* Intialize everything */ | |
| 886 ddraw2 = NULL; | |
| 887 SDL_primary = NULL; | |
| 888 SDL_clipper = NULL; | |
| 889 SDL_palette = NULL; | |
| 890 for ( i=0; i<NUM_MODELISTS; ++i ) { | |
| 891 SDL_nummodes[i] = 0; | |
| 892 SDL_modelist[i] = NULL; | |
| 893 SDL_modeindex[i] = 0; | |
| 894 } | |
| 895 colorchange_expected = 0; | |
| 896 | |
| 897 /* Create the window */ | |
| 898 if ( DX5_CreateWindow(this) < 0 ) { | |
| 899 return(-1); | |
| 900 } | |
|
169
8039a5b760b9
Allow building SDL on Windows without audio support
Sam Lantinga <slouken@libsdl.org>
parents:
1
diff
changeset
|
901 #ifndef DISABLE_AUDIO |
| 0 | 902 DX5_SoundFocus(SDL_Window); |
|
169
8039a5b760b9
Allow building SDL on Windows without audio support
Sam Lantinga <slouken@libsdl.org>
parents:
1
diff
changeset
|
903 #endif |
| 0 | 904 |
| 905 /* Create the DirectDraw object */ | |
| 906 result = DDrawCreate(NULL, &ddraw, NULL); | |
| 907 if ( result != DD_OK ) { | |
| 908 SetDDerror("DirectDrawCreate", result); | |
| 909 return(-1); | |
| 910 } | |
| 911 result = IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw2, | |
| 912 (LPVOID *)&ddraw2); | |
| 913 IDirectDraw_Release(ddraw); | |
| 914 if ( result != DD_OK ) { | |
| 915 SetDDerror("DirectDraw::QueryInterface", result); | |
| 916 return(-1); | |
| 917 } | |
| 918 | |
| 919 /* Determine the screen depth */ | |
| 920 hdc = GetDC(SDL_Window); | |
| 921 vformat->BitsPerPixel = GetDeviceCaps(hdc,PLANES) * | |
| 922 GetDeviceCaps(hdc,BITSPIXEL); | |
| 923 ReleaseDC(SDL_Window, hdc); | |
| 924 | |
| 925 /* Enumerate the available fullscreen modes */ | |
| 926 for ( i=0; i<NUM_MODELISTS; ++i ) | |
| 927 enumlists[i] = NULL; | |
| 928 | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
929 result = IDirectDraw2_EnumDisplayModes(ddraw2,DDEDM_REFRESHRATES,NULL,this,EnumModes2); |
| 0 | 930 if ( result != DD_OK ) { |
| 931 SetDDerror("DirectDraw2::EnumDisplayModes", result); | |
| 932 return(-1); | |
| 933 } | |
| 934 for ( i=0; i<NUM_MODELISTS; ++i ) { | |
| 935 struct DX5EnumRect *rect; | |
| 936 SDL_modelist[i] = (SDL_Rect **) | |
| 937 malloc((SDL_nummodes[i]+1)*sizeof(SDL_Rect *)); | |
| 938 if ( SDL_modelist[i] == NULL ) { | |
| 939 SDL_OutOfMemory(); | |
| 940 return(-1); | |
| 941 } | |
| 942 for ( j = 0, rect = enumlists[i]; rect; ++j, rect = rect->next ) { | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
943 SDL_modelist[i][j] = &rect->r; |
| 0 | 944 } |
| 945 SDL_modelist[i][j] = NULL; | |
| 946 } | |
| 947 | |
| 948 /* Fill in some window manager capabilities */ | |
| 949 this->info.wm_available = 1; | |
| 950 | |
| 951 /* Fill in the video hardware capabilities */ | |
| 952 DX5_UpdateVideoInfo(this); | |
| 953 | |
| 954 return(0); | |
| 955 } | |
| 956 | |
| 957 SDL_Rect **DX5_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) | |
| 958 { | |
| 959 int bpp; | |
| 960 | |
| 961 bpp = format->BitsPerPixel; | |
| 962 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 963 /* FIXME: No support for 1 bpp or 4 bpp formats */ | |
| 964 switch (bpp) { /* Does windows support other BPP? */ | |
| 965 case 8: | |
| 966 case 16: | |
| 967 case 24: | |
| 968 case 32: | |
| 969 bpp = (bpp/8)-1; | |
| 970 if ( SDL_nummodes[bpp] > 0 ) | |
| 971 return(SDL_modelist[bpp]); | |
| 972 /* Fall through */ | |
| 973 default: | |
| 974 return((SDL_Rect **)0); | |
| 975 } | |
| 976 } else { | |
| 977 if ( this->screen->format->BitsPerPixel == bpp ) { | |
| 978 return((SDL_Rect **)-1); | |
| 979 } else { | |
| 980 return((SDL_Rect **)0); | |
| 981 } | |
| 982 } | |
| 983 } | |
| 984 | |
| 985 /* Various screen update functions available */ | |
| 986 static void DX5_WindowUpdate(_THIS, int numrects, SDL_Rect *rects); | |
| 987 static void DX5_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); | |
| 988 | |
| 989 SDL_Surface *DX5_SetVideoMode(_THIS, SDL_Surface *current, | |
| 990 int width, int height, int bpp, Uint32 flags) | |
| 991 { | |
| 992 SDL_Surface *video; | |
| 993 HRESULT result; | |
| 994 DWORD sharemode; | |
| 995 DWORD style; | |
| 996 const DWORD directstyle = | |
| 997 (WS_POPUP); | |
| 998 const DWORD windowstyle = | |
| 999 (WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX); | |
| 1000 const DWORD resizestyle = | |
| 1001 (WS_THICKFRAME|WS_MAXIMIZEBOX); | |
| 1002 DDSURFACEDESC ddsd; | |
| 1003 LPDIRECTDRAWSURFACE dd_surface1; | |
| 1004 LPDIRECTDRAWSURFACE3 dd_surface3; | |
| 1005 BOOL was_visible; | |
| 1006 | |
| 1007 #ifdef DDRAW_DEBUG | |
| 1008 fprintf(stderr, "Setting %dx%dx%d video mode\n", width, height, bpp); | |
| 1009 #endif | |
| 1010 /* See whether or not we should center the window */ | |
| 1011 was_visible = IsWindowVisible(SDL_Window); | |
| 1012 | |
| 1013 /* Clean up any previous DirectDraw surfaces */ | |
| 1014 if ( current->hwdata ) { | |
| 1015 this->FreeHWSurface(this, current); | |
| 1016 current->hwdata = NULL; | |
| 1017 } | |
| 1018 if ( SDL_primary != NULL ) { | |
| 1019 IDirectDrawSurface3_Release(SDL_primary); | |
| 1020 SDL_primary = NULL; | |
| 1021 } | |
| 1022 | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1023 #ifndef NO_CHANGEDISPLAYSETTINGS |
| 0 | 1024 /* Unset any previous OpenGL fullscreen mode */ |
| 1025 if ( (current->flags & (SDL_OPENGL|SDL_FULLSCREEN)) == | |
| 1026 (SDL_OPENGL|SDL_FULLSCREEN) ) { | |
| 1027 ChangeDisplaySettings(NULL, 0); | |
| 1028 } | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1029 #endif |
| 0 | 1030 |
| 1031 /* Clean up any GL context that may be hanging around */ | |
| 1032 if ( current->flags & SDL_OPENGL ) { | |
| 1033 WIN_GL_ShutDown(this); | |
| 1034 } | |
| 1035 | |
| 1036 /* If we are setting a GL mode, use GDI, not DirectX (yuck) */ | |
| 1037 if ( flags & SDL_OPENGL ) { | |
| 1038 RECT bounds; | |
| 1039 int x, y; | |
| 1040 Uint32 Rmask, Gmask, Bmask; | |
| 1041 | |
| 1042 /* Recalculate the bitmasks if necessary */ | |
| 1043 if ( bpp == current->format->BitsPerPixel ) { | |
| 1044 video = current; | |
| 1045 } else { | |
| 1046 switch (bpp) { | |
| 1047 case 15: | |
| 1048 case 16: | |
| 1049 if ( 0 /*DIB_SussScreenDepth() == 15*/ ) { | |
| 1050 /* 5-5-5 */ | |
| 1051 Rmask = 0x00007c00; | |
| 1052 Gmask = 0x000003e0; | |
| 1053 Bmask = 0x0000001f; | |
| 1054 } else { | |
| 1055 /* 5-6-5 */ | |
| 1056 Rmask = 0x0000f800; | |
| 1057 Gmask = 0x000007e0; | |
| 1058 Bmask = 0x0000001f; | |
| 1059 } | |
| 1060 break; | |
| 1061 case 24: | |
| 1062 case 32: | |
| 1063 /* GDI defined as 8-8-8 */ | |
| 1064 Rmask = 0x00ff0000; | |
| 1065 Gmask = 0x0000ff00; | |
| 1066 Bmask = 0x000000ff; | |
| 1067 break; | |
| 1068 default: | |
| 1069 Rmask = 0x00000000; | |
| 1070 Gmask = 0x00000000; | |
| 1071 Bmask = 0x00000000; | |
| 1072 break; | |
| 1073 } | |
| 1074 video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, bpp, | |
| 1075 Rmask, Gmask, Bmask, 0); | |
| 1076 if ( video == NULL ) { | |
| 1077 SDL_OutOfMemory(); | |
| 1078 return(NULL); | |
| 1079 } | |
| 1080 } | |
| 1081 | |
| 1082 /* Fill in part of the video surface */ | |
| 1083 video->flags = 0; /* Clear flags */ | |
| 1084 video->w = width; | |
| 1085 video->h = height; | |
| 1086 video->pitch = SDL_CalculatePitch(video); | |
| 1087 | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1088 #ifndef NO_CHANGEDISPLAYSETTINGS |
| 0 | 1089 /* Set fullscreen mode if appropriate. |
| 1090 Ugh, since our list of valid video modes comes from | |
| 1091 the DirectX driver, we may not actually be able to | |
| 1092 change to the desired resolution here. | |
| 1093 FIXME: Should we do a closest match? | |
| 1094 */ | |
| 1095 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 1096 DEVMODE settings; | |
| 1097 | |
| 1098 memset(&settings, 0, sizeof(DEVMODE)); | |
| 1099 settings.dmSize = sizeof(DEVMODE); | |
| 1100 settings.dmBitsPerPel = video->format->BitsPerPixel; | |
| 1101 settings.dmPelsWidth = width; | |
| 1102 settings.dmPelsHeight = height; | |
| 1103 settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL; | |
| 1104 if ( ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL ) { | |
| 1105 video->flags |= SDL_FULLSCREEN; | |
|
304
ec53caed9fb2
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
1106 SDL_fullscreen_mode = settings; |
| 0 | 1107 } |
| 1108 } | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1109 #endif /* !NO_CHANGEDISPLAYSETTINGS */ |
| 0 | 1110 |
| 1111 style = GetWindowLong(SDL_Window, GWL_STYLE); | |
| 1112 style &= ~(resizestyle|WS_MAXIMIZE); | |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1113 if ( video->flags & SDL_FULLSCREEN ) { |
| 0 | 1114 style &= ~windowstyle; |
| 1115 style |= directstyle; | |
| 1116 } else { | |
| 1117 if ( flags & SDL_NOFRAME ) { | |
| 1118 style &= ~windowstyle; | |
| 1119 style |= directstyle; | |
| 1120 video->flags |= SDL_NOFRAME; | |
| 1121 } else { | |
| 1122 style &= ~directstyle; | |
| 1123 style |= windowstyle; | |
| 1124 if ( flags & SDL_RESIZABLE ) { | |
| 1125 style |= resizestyle; | |
| 1126 video->flags |= SDL_RESIZABLE; | |
| 1127 } | |
| 1128 } | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1129 #if WS_MAXIMIZE |
| 0 | 1130 if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE; |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1131 #endif |
| 0 | 1132 } |
| 1133 SetWindowLong(SDL_Window, GWL_STYLE, style); | |
| 1134 | |
| 1135 /* Resize the window (copied from SDL WinDIB driver) */ | |
| 1136 if ( SDL_windowid == NULL ) { | |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1137 HWND top; |
| 0 | 1138 UINT swp_flags; |
| 1139 | |
| 1140 SDL_resizing = 1; | |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1141 bounds.top = 0; |
| 0 | 1142 bounds.bottom = video->h; |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1143 bounds.left = 0; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1144 bounds.right = video->w; |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1145 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), FALSE, 0); |
| 0 | 1146 width = bounds.right-bounds.left; |
| 1147 height = bounds.bottom-bounds.top; | |
| 1148 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2; | |
| 1149 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2; | |
| 1150 if ( y < 0 ) { /* Cover up title bar for more client area */ | |
| 1151 y -= GetSystemMetrics(SM_CYCAPTION)/2; | |
| 1152 } | |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1153 swp_flags = (SWP_NOCOPYBITS | SWP_FRAMECHANGED | SWP_SHOWWINDOW); |
|
486
8b1c1ae7af11
Fixed a typo in a previous patch
Sam Lantinga <slouken@libsdl.org>
parents:
468
diff
changeset
|
1154 if ( was_visible && !(video->flags & SDL_FULLSCREEN) ) { |
| 0 | 1155 swp_flags |= SWP_NOMOVE; |
| 1156 } | |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1157 if ( video->flags & SDL_FULLSCREEN ) { |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1158 top = HWND_TOPMOST; |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1159 } else { |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1160 top = HWND_NOTOPMOST; |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1161 } |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
443
diff
changeset
|
1162 SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags); |
| 0 | 1163 SDL_resizing = 0; |
| 1164 SetForegroundWindow(SDL_Window); | |
| 1165 } | |
| 1166 | |
| 1167 /* Set up for OpenGL */ | |
| 1168 if ( WIN_GL_SetupWindow(this) < 0 ) { | |
| 1169 return(NULL); | |
| 1170 } | |
| 1171 video->flags |= SDL_OPENGL; | |
| 1172 return(video); | |
| 1173 } | |
| 1174 | |
| 1175 /* Set the appropriate window style */ | |
| 1176 style = GetWindowLong(SDL_Window, GWL_STYLE); | |
| 1177 style &= ~(resizestyle|WS_MAXIMIZE); | |
| 1178 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 1179 style &= ~windowstyle; | |
| 1180 style |= directstyle; | |
| 1181 } else { | |
| 1182 if ( flags & SDL_NOFRAME ) { | |
| 1183 style &= ~windowstyle; | |
| 1184 style |= directstyle; | |
| 1185 } else { | |
| 1186 style &= ~directstyle; | |
| 1187 style |= windowstyle; | |
| 1188 if ( flags & SDL_RESIZABLE ) { | |
| 1189 style |= resizestyle; | |
| 1190 } | |
| 1191 } | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1192 #if WS_MAXIMIZE |
| 0 | 1193 if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE; |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1194 #endif |
| 0 | 1195 } |
| 1196 SetWindowLong(SDL_Window, GWL_STYLE, style); | |
| 1197 | |
| 1198 /* Set DirectDraw sharing mode.. exclusive when fullscreen */ | |
| 1199 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 1200 sharemode = DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE|DDSCL_ALLOWREBOOT; | |
| 1201 } else { | |
| 1202 sharemode = DDSCL_NORMAL; | |
| 1203 } | |
| 1204 result = IDirectDraw2_SetCooperativeLevel(ddraw2,SDL_Window,sharemode); | |
| 1205 if ( result != DD_OK ) { | |
| 1206 SetDDerror("DirectDraw2::SetCooperativeLevel", result); | |
| 1207 return(NULL); | |
| 1208 } | |
| 1209 | |
| 1210 /* Set the display mode, if we are in fullscreen mode */ | |
| 1211 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1212 struct DX5EnumRect *rect; |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1213 int maxRefreshRate; |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1214 |
| 0 | 1215 /* Cover up desktop during mode change */ |
| 1216 SDL_resizing = 1; | |
| 1217 SetWindowPos(SDL_Window, NULL, 0, 0, | |
| 1218 GetSystemMetrics(SM_CXSCREEN), | |
| 1219 GetSystemMetrics(SM_CYSCREEN), | |
| 1220 (SWP_NOCOPYBITS | SWP_NOZORDER)); | |
| 1221 SDL_resizing = 0; | |
| 1222 ShowWindow(SDL_Window, SW_SHOW); | |
| 1223 while ( GetForegroundWindow() != SDL_Window ) { | |
| 1224 SetForegroundWindow(SDL_Window); | |
| 1225 SDL_Delay(100); | |
| 1226 } | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1227 |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1228 /* find maximum monitor refresh rate for this resolution */ |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1229 /* Dmitry Yakimov ftech@tula.net */ |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1230 maxRefreshRate = 0; /* system default */ |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1231 for ( rect = enumlists[bpp / 8 - 1]; rect; rect = rect->next ) { |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1232 if ( (width == rect->r.w) && (height == rect->r.h) ) { |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1233 maxRefreshRate = rect->refreshRate; |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1234 break; |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1235 } |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1236 } |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1237 printf("refresh rate = %d Hz\n", maxRefreshRate); |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1238 |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1239 result = IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp, maxRefreshRate, 0); |
| 0 | 1240 if ( result != DD_OK ) { |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1241 result = IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp, 0, 0); |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1242 if ( result != DD_OK ) { |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1243 /* We couldn't set fullscreen mode, try window */ |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1244 return(DX5_SetVideoMode(this, current, width, height, bpp, flags & ~SDL_FULLSCREEN)); |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1245 } |
| 0 | 1246 } |
| 1247 DX5_DInputReset(this, 1); | |
| 1248 } else { | |
| 1249 DX5_DInputReset(this, 0); | |
| 1250 } | |
| 1251 DX5_UpdateVideoInfo(this); | |
| 1252 | |
| 1253 /* Create a primary DirectDraw surface */ | |
| 1254 memset(&ddsd, 0, sizeof(ddsd)); | |
| 1255 ddsd.dwSize = sizeof(ddsd); | |
| 1256 ddsd.dwFlags = DDSD_CAPS; | |
| 1257 ddsd.ddsCaps.dwCaps = (DDSCAPS_PRIMARYSURFACE|DDSCAPS_VIDEOMEMORY); | |
| 1258 if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) { | |
| 1259 /* There's no windowed double-buffering */ | |
| 1260 flags &= ~SDL_DOUBLEBUF; | |
| 1261 } | |
| 1262 if ( (flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { | |
| 1263 ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT; | |
| 1264 ddsd.ddsCaps.dwCaps |= (DDSCAPS_COMPLEX|DDSCAPS_FLIP); | |
| 1265 ddsd.dwBackBufferCount = 1; | |
| 1266 } | |
| 1267 result = IDirectDraw2_CreateSurface(ddraw2, &ddsd, &dd_surface1, NULL); | |
| 1268 if ( (result != DD_OK) && ((flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) ) { | |
| 1269 ddsd.dwFlags &= ~DDSD_BACKBUFFERCOUNT; | |
| 1270 ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_COMPLEX|DDSCAPS_FLIP); | |
| 1271 ddsd.dwBackBufferCount = 0; | |
| 1272 result = IDirectDraw2_CreateSurface(ddraw2, | |
| 1273 &ddsd, &dd_surface1, NULL); | |
| 1274 } | |
| 1275 if ( result != DD_OK ) { | |
| 1276 SetDDerror("DirectDraw2::CreateSurface(PRIMARY)", result); | |
| 1277 return(NULL); | |
| 1278 } | |
| 1279 result = IDirectDrawSurface_QueryInterface(dd_surface1, | |
| 1280 &IID_IDirectDrawSurface3, (LPVOID *)&SDL_primary); | |
| 1281 if ( result != DD_OK ) { | |
| 1282 SetDDerror("DirectDrawSurface::QueryInterface", result); | |
| 1283 return(NULL); | |
| 1284 } | |
| 1285 result = IDirectDrawSurface_Release(dd_surface1); | |
| 1286 if ( result != DD_OK ) { | |
| 1287 SetDDerror("DirectDrawSurface::Release", result); | |
| 1288 return(NULL); | |
| 1289 } | |
| 1290 | |
| 1291 /* Get the format of the primary DirectDraw surface */ | |
| 1292 memset(&ddsd, 0, sizeof(ddsd)); | |
| 1293 ddsd.dwSize = sizeof(ddsd); | |
| 1294 ddsd.dwFlags = DDSD_PIXELFORMAT|DDSD_CAPS; | |
| 1295 result = IDirectDrawSurface3_GetSurfaceDesc(SDL_primary, &ddsd); | |
| 1296 if ( result != DD_OK ) { | |
| 1297 SetDDerror("DirectDrawSurface::Release", result); | |
| 1298 return(NULL); | |
| 1299 } | |
| 1300 if ( ! (ddsd.ddpfPixelFormat.dwFlags&DDPF_RGB) ) { | |
| 1301 SDL_SetError("Primary DDRAW surface is not RGB format"); | |
| 1302 return(NULL); | |
| 1303 } | |
| 1304 | |
| 1305 /* Free old palette and create a new one if we're in 8-bit mode */ | |
| 1306 if ( SDL_palette != NULL ) { | |
| 1307 IDirectDrawPalette_Release(SDL_palette); | |
| 1308 SDL_palette = NULL; | |
| 1309 } | |
| 1310 #if defined(NONAMELESSUNION) | |
| 1311 if ( ddsd.ddpfPixelFormat.u1.dwRGBBitCount == 8 ) { | |
| 1312 #else | |
| 1313 if ( ddsd.ddpfPixelFormat.dwRGBBitCount == 8 ) { | |
| 1314 #endif | |
| 1315 int i; | |
| 1316 | |
| 1317 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 1318 /* We have access to the entire palette */ | |
| 1319 for ( i=0; i<256; ++i ) { | |
| 1320 SDL_colors[i].peFlags = | |
| 1321 (PC_NOCOLLAPSE|PC_RESERVED); | |
| 1322 SDL_colors[i].peRed = 0; | |
| 1323 SDL_colors[i].peGreen = 0; | |
| 1324 SDL_colors[i].peBlue = 0; | |
| 1325 } | |
| 1326 } else { | |
| 1327 /* First 10 colors are reserved by Windows */ | |
| 1328 for ( i=0; i<10; ++i ) { | |
| 1329 SDL_colors[i].peFlags = PC_EXPLICIT; | |
| 1330 SDL_colors[i].peRed = i; | |
| 1331 SDL_colors[i].peGreen = 0; | |
| 1332 SDL_colors[i].peBlue = 0; | |
| 1333 } | |
| 1334 for ( i=10; i<(10+236); ++i ) { | |
| 1335 SDL_colors[i].peFlags = PC_NOCOLLAPSE; | |
| 1336 SDL_colors[i].peRed = 0; | |
| 1337 SDL_colors[i].peGreen = 0; | |
| 1338 SDL_colors[i].peBlue = 0; | |
| 1339 } | |
| 1340 /* Last 10 colors are reserved by Windows */ | |
| 1341 for ( i=246; i<256; ++i ) { | |
| 1342 SDL_colors[i].peFlags = PC_EXPLICIT; | |
| 1343 SDL_colors[i].peRed = i; | |
| 1344 SDL_colors[i].peGreen = 0; | |
| 1345 SDL_colors[i].peBlue = 0; | |
| 1346 } | |
| 1347 } | |
| 1348 result = IDirectDraw2_CreatePalette(ddraw2, | |
| 1349 (DDPCAPS_8BIT|DDPCAPS_ALLOW256), | |
| 1350 SDL_colors, &SDL_palette, NULL); | |
| 1351 if ( result != DD_OK ) { | |
| 1352 SetDDerror("DirectDraw2::CreatePalette", result); | |
| 1353 return(NULL); | |
| 1354 } | |
| 1355 result = IDirectDrawSurface3_SetPalette(SDL_primary, | |
| 1356 SDL_palette); | |
| 1357 if ( result != DD_OK ) { | |
| 1358 SetDDerror("DirectDrawSurface3::SetPalette", result); | |
| 1359 return(NULL); | |
| 1360 } | |
| 1361 } | |
| 1362 | |
| 1363 /* Create our video surface using the same pixel format */ | |
| 1364 video = current; | |
| 1365 if ( (width != video->w) || (height != video->h) | |
| 1366 || (video->format->BitsPerPixel != | |
| 1367 #if defined(NONAMELESSUNION) | |
| 1368 ddsd.ddpfPixelFormat.u1.dwRGBBitCount) ) { | |
| 1369 #else | |
| 1370 ddsd.ddpfPixelFormat.dwRGBBitCount) ) { | |
| 1371 #endif | |
| 1372 SDL_FreeSurface(video); | |
| 1373 video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, | |
| 1374 #if defined(NONAMELESSUNION) | |
| 1375 ddsd.ddpfPixelFormat.u1.dwRGBBitCount, | |
| 1376 ddsd.ddpfPixelFormat.u2.dwRBitMask, | |
| 1377 ddsd.ddpfPixelFormat.u3.dwGBitMask, | |
| 1378 ddsd.ddpfPixelFormat.u4.dwBBitMask, | |
| 1379 #else | |
| 1380 ddsd.ddpfPixelFormat.dwRGBBitCount, | |
| 1381 ddsd.ddpfPixelFormat.dwRBitMask, | |
| 1382 ddsd.ddpfPixelFormat.dwGBitMask, | |
| 1383 ddsd.ddpfPixelFormat.dwBBitMask, | |
| 1384 #endif | |
| 1385 0); | |
| 1386 if ( video == NULL ) { | |
| 1387 SDL_OutOfMemory(); | |
| 1388 return(NULL); | |
| 1389 } | |
| 1390 video->w = width; | |
| 1391 video->h = height; | |
| 1392 video->pitch = 0; | |
| 1393 } | |
| 1394 video->flags = 0; /* Clear flags */ | |
| 1395 | |
| 1396 /* If not fullscreen, locking is possible, but it doesn't do what | |
| 1397 the caller really expects -- if the locked surface is written to, | |
| 1398 the appropriate portion of the entire screen is modified, not | |
| 1399 the application window, as we would like. | |
| 1400 Note that it is still possible to write directly to display | |
| 1401 memory, but the application must respect the clip list of | |
| 1402 the surface. There might be some odd timing interactions | |
| 1403 involving clip list updates and background refreshing as | |
| 1404 Windows moves other windows across our window. | |
| 1405 We currently don't support this, even though it might be a | |
| 1406 good idea since BeOS has an implementation of BDirectWindow | |
| 1407 that does the same thing. This would be most useful for | |
| 1408 applications that do complete screen updates every frame. | |
| 1409 -- Fixme? | |
| 1410 */ | |
| 1411 if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) { | |
| 1412 /* Necessary if we're going from fullscreen to window */ | |
| 1413 if ( video->pixels == NULL ) { | |
| 1414 video->pitch = (width*video->format->BytesPerPixel); | |
| 1415 /* Pitch needs to be QWORD (8-byte) aligned */ | |
| 1416 video->pitch = (video->pitch + 7) & ~7; | |
| 1417 video->pixels = (void *)malloc(video->h*video->pitch); | |
| 1418 if ( video->pixels == NULL ) { | |
| 1419 if ( video != current ) { | |
| 1420 SDL_FreeSurface(video); | |
| 1421 } | |
| 1422 SDL_OutOfMemory(); | |
| 1423 return(NULL); | |
| 1424 } | |
| 1425 } | |
| 1426 dd_surface3 = NULL; | |
|
443
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1427 #if 0 /* FIXME: enable this when SDL consistently reports lost surfaces */ |
|
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1428 if ( (flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { |
|
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1429 video->flags |= SDL_HWSURFACE; |
|
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1430 } else { |
|
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1431 video->flags |= SDL_SWSURFACE; |
|
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1432 } |
|
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1433 #else |
| 0 | 1434 video->flags |= SDL_SWSURFACE; |
|
443
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1435 #endif |
| 0 | 1436 if ( (flags & SDL_RESIZABLE) && !(flags & SDL_NOFRAME) ) { |
| 1437 video->flags |= SDL_RESIZABLE; | |
| 1438 } | |
| 1439 if ( flags & SDL_NOFRAME ) { | |
| 1440 video->flags |= SDL_NOFRAME; | |
| 1441 } | |
| 1442 } else { | |
| 1443 /* Necessary if we're going from window to fullscreen */ | |
| 1444 if ( video->pixels != NULL ) { | |
| 1445 free(video->pixels); | |
| 1446 video->pixels = NULL; | |
| 1447 } | |
| 1448 dd_surface3 = SDL_primary; | |
| 1449 video->flags |= SDL_HWSURFACE; | |
| 1450 } | |
| 1451 | |
| 1452 /* See if the primary surface has double-buffering enabled */ | |
| 1453 if ( (ddsd.ddsCaps.dwCaps & DDSCAPS_FLIP) == DDSCAPS_FLIP ) { | |
| 1454 video->flags |= SDL_DOUBLEBUF; | |
| 1455 } | |
| 1456 | |
| 1457 /* Allocate the SDL surface associated with the primary surface */ | |
| 1458 if ( DX5_AllocDDSurface(this, video, dd_surface3, | |
| 1459 video->flags&SDL_HWSURFACE) < 0 ) { | |
| 1460 if ( video != current ) { | |
| 1461 SDL_FreeSurface(video); | |
| 1462 } | |
| 1463 return(NULL); | |
| 1464 } | |
| 1465 | |
| 1466 /* Use the appropriate blitting function */ | |
| 1467 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 1468 video->flags |= SDL_FULLSCREEN; | |
| 1469 if ( video->format->palette != NULL ) { | |
| 1470 video->flags |= SDL_HWPALETTE; | |
| 1471 } | |
| 1472 this->UpdateRects = DX5_DirectUpdate; | |
| 1473 } else { | |
| 1474 this->UpdateRects = DX5_WindowUpdate; | |
| 1475 } | |
| 1476 | |
| 1477 /* Make our window the proper size, set the clipper, then show it */ | |
| 1478 if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) { | |
| 1479 RECT bounds; | |
| 1480 int x, y; | |
| 1481 UINT swp_flags; | |
| 1482 | |
| 1483 /* Create and set a clipper on our primary surface */ | |
| 1484 if ( SDL_clipper == NULL ) { | |
| 1485 result = IDirectDraw2_CreateClipper(ddraw2, | |
| 1486 0, &SDL_clipper, NULL); | |
| 1487 if ( result != DD_OK ) { | |
| 1488 if ( video != current ) { | |
| 1489 SDL_FreeSurface(video); | |
| 1490 } | |
| 1491 SetDDerror("DirectDraw2::CreateClipper",result); | |
| 1492 return(NULL); | |
| 1493 } | |
| 1494 } | |
| 1495 result = IDirectDrawClipper_SetHWnd(SDL_clipper, 0, SDL_Window); | |
| 1496 if ( result != DD_OK ) { | |
| 1497 if ( video != current ) { | |
| 1498 SDL_FreeSurface(video); | |
| 1499 } | |
| 1500 SetDDerror("DirectDrawClipper::SetHWnd", result); | |
| 1501 return(NULL); | |
| 1502 } | |
| 1503 result = IDirectDrawSurface3_SetClipper(SDL_primary, | |
| 1504 SDL_clipper); | |
| 1505 if ( result != DD_OK ) { | |
| 1506 if ( video != current ) { | |
| 1507 SDL_FreeSurface(video); | |
| 1508 } | |
| 1509 SetDDerror("DirectDrawSurface3::SetClipper", result); | |
| 1510 return(NULL); | |
| 1511 } | |
| 1512 | |
| 1513 /* Set the size of the window, centering and adjusting */ | |
| 1514 SDL_resizing = 1; | |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1515 bounds.top = 0; |
| 0 | 1516 bounds.bottom = video->h; |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1517 bounds.left = 0; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1518 bounds.right = video->w; |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
1519 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), FALSE, 0); |
| 0 | 1520 width = bounds.right-bounds.left; |
| 1521 height = bounds.bottom-bounds.top; | |
| 1522 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2; | |
| 1523 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2; | |
| 1524 if ( y < 0 ) { /* Cover up title bar for more client area */ | |
| 1525 y -= GetSystemMetrics(SM_CYCAPTION)/2; | |
| 1526 } | |
| 1527 swp_flags = (SWP_NOCOPYBITS | SWP_NOZORDER); | |
| 1528 if ( was_visible ) { | |
| 1529 swp_flags |= SWP_NOMOVE; | |
| 1530 } | |
| 1531 SetWindowPos(SDL_Window, NULL, x, y, width, height, swp_flags); | |
| 1532 SDL_resizing = 0; | |
| 1533 } | |
| 1534 ShowWindow(SDL_Window, SW_SHOW); | |
| 1535 SetForegroundWindow(SDL_Window); | |
| 1536 | |
| 1537 /* We're live! */ | |
| 1538 return(video); | |
| 1539 } | |
| 1540 | |
| 1541 struct private_hwdata { | |
| 1542 LPDIRECTDRAWSURFACE3 dd_surface; | |
| 1543 LPDIRECTDRAWSURFACE3 dd_writebuf; | |
| 1544 }; | |
| 1545 | |
| 1546 static int DX5_AllocDDSurface(_THIS, SDL_Surface *surface, | |
| 1547 LPDIRECTDRAWSURFACE3 requested, Uint32 flag) | |
| 1548 { | |
| 1549 LPDIRECTDRAWSURFACE dd_surface1; | |
| 1550 LPDIRECTDRAWSURFACE3 dd_surface3; | |
| 1551 DDSURFACEDESC ddsd; | |
| 1552 HRESULT result; | |
| 1553 | |
| 1554 /* Clear the hardware flag, in case we fail */ | |
| 1555 surface->flags &= ~flag; | |
| 1556 | |
| 1557 /* Allocate the hardware acceleration data */ | |
| 1558 surface->hwdata = (struct private_hwdata *) | |
| 1559 malloc(sizeof(*surface->hwdata)); | |
| 1560 if ( surface->hwdata == NULL ) { | |
| 1561 SDL_OutOfMemory(); | |
| 1562 return(-1); | |
| 1563 } | |
| 1564 dd_surface3 = NULL; | |
| 1565 | |
| 1566 /* Set up the surface description */ | |
| 1567 memset(&ddsd, 0, sizeof(ddsd)); | |
| 1568 ddsd.dwSize = sizeof(ddsd); | |
| 1569 ddsd.dwFlags = (DDSD_WIDTH|DDSD_HEIGHT|DDSD_CAPS| | |
| 1570 DDSD_PITCH|DDSD_PIXELFORMAT); | |
| 1571 ddsd.dwWidth = surface->w; | |
| 1572 ddsd.dwHeight= surface->h; | |
| 1573 #if defined(NONAMELESSUNION) | |
| 1574 ddsd.u1.lPitch = surface->pitch; | |
| 1575 #else | |
| 1576 ddsd.lPitch = surface->pitch; | |
| 1577 #endif | |
| 1578 if ( (flag & SDL_HWSURFACE) == SDL_HWSURFACE ) { | |
| 1579 ddsd.ddsCaps.dwCaps = | |
| 1580 (DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY); | |
| 1581 } else { | |
| 1582 ddsd.ddsCaps.dwCaps = | |
| 1583 (DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY); | |
| 1584 } | |
| 1585 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); | |
| 1586 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; | |
| 1587 if ( surface->format->palette ) { | |
| 1588 ddsd.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8; | |
| 1589 } | |
| 1590 #if defined(NONAMELESSUNION) | |
| 1591 ddsd.ddpfPixelFormat.u1.dwRGBBitCount = surface->format->BitsPerPixel; | |
| 1592 ddsd.ddpfPixelFormat.u2.dwRBitMask = surface->format->Rmask; | |
| 1593 ddsd.ddpfPixelFormat.u3.dwGBitMask = surface->format->Gmask; | |
| 1594 ddsd.ddpfPixelFormat.u4.dwBBitMask = surface->format->Bmask; | |
| 1595 #else | |
| 1596 ddsd.ddpfPixelFormat.dwRGBBitCount = surface->format->BitsPerPixel; | |
| 1597 ddsd.ddpfPixelFormat.dwRBitMask = surface->format->Rmask; | |
| 1598 ddsd.ddpfPixelFormat.dwGBitMask = surface->format->Gmask; | |
| 1599 ddsd.ddpfPixelFormat.dwBBitMask = surface->format->Bmask; | |
| 1600 #endif | |
| 1601 | |
| 1602 /* Create the DirectDraw video surface */ | |
| 1603 if ( requested != NULL ) { | |
| 1604 dd_surface3 = requested; | |
| 1605 } else { | |
| 1606 result = IDirectDraw2_CreateSurface(ddraw2, | |
| 1607 &ddsd, &dd_surface1, NULL); | |
| 1608 if ( result != DD_OK ) { | |
| 1609 SetDDerror("DirectDraw2::CreateSurface", result); | |
| 1610 goto error_end; | |
| 1611 } | |
| 1612 result = IDirectDrawSurface_QueryInterface(dd_surface1, | |
| 1613 &IID_IDirectDrawSurface3, (LPVOID *)&dd_surface3); | |
| 1614 IDirectDrawSurface_Release(dd_surface1); | |
| 1615 if ( result != DD_OK ) { | |
| 1616 SetDDerror("DirectDrawSurface::QueryInterface", result); | |
| 1617 goto error_end; | |
| 1618 } | |
| 1619 } | |
| 1620 | |
| 1621 if ( (flag & SDL_HWSURFACE) == SDL_HWSURFACE ) { | |
| 1622 /* Check to see whether the surface actually ended up | |
| 1623 in video memory, and fail if not. We expect the | |
| 1624 surfaces we create here to actually be in hardware! | |
| 1625 */ | |
| 1626 result = IDirectDrawSurface3_GetCaps(dd_surface3,&ddsd.ddsCaps); | |
| 1627 if ( result != DD_OK ) { | |
| 1628 SetDDerror("DirectDrawSurface3::GetCaps", result); | |
| 1629 goto error_end; | |
| 1630 } | |
| 1631 if ( (ddsd.ddsCaps.dwCaps&DDSCAPS_VIDEOMEMORY) != | |
| 1632 DDSCAPS_VIDEOMEMORY ) { | |
| 1633 SDL_SetError("No room in video memory"); | |
| 1634 goto error_end; | |
| 1635 } | |
| 1636 } else { | |
| 1637 /* Try to hook our surface memory */ | |
| 1638 ddsd.dwFlags = DDSD_LPSURFACE; | |
| 1639 ddsd.lpSurface = surface->pixels; | |
| 1640 result = IDirectDrawSurface3_SetSurfaceDesc(dd_surface3, | |
| 1641 &ddsd, 0); | |
| 1642 if ( result != DD_OK ) { | |
| 1643 SetDDerror("DirectDraw2::SetSurfaceDesc", result); | |
| 1644 goto error_end; | |
| 1645 } | |
| 1646 | |
| 1647 } | |
| 1648 | |
| 1649 /* Make sure the surface format was set properly */ | |
| 1650 memset(&ddsd, 0, sizeof(ddsd)); | |
| 1651 ddsd.dwSize = sizeof(ddsd); | |
| 1652 result = IDirectDrawSurface3_Lock(dd_surface3, NULL, | |
|
443
778b970cec12
Added temporarily disabled code for hardware acceleration in windowed mode.
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
1653 &ddsd, (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL); |
| 0 | 1654 if ( result != DD_OK ) { |
| 1655 SetDDerror("DirectDrawSurface3::Lock", result); | |
| 1656 goto error_end; | |
| 1657 } | |
| 1658 IDirectDrawSurface3_Unlock(dd_surface3, NULL); | |
| 1659 | |
| 1660 if ( (flag & SDL_HWSURFACE) == SDL_SWSURFACE ) { | |
| 1661 if ( ddsd.lpSurface != surface->pixels ) { | |
| 1662 SDL_SetError("DDraw didn't use SDL surface memory"); | |
| 1663 goto error_end; | |
| 1664 } | |
| 1665 if ( | |
| 1666 #if defined(NONAMELESSUNION) | |
| 1667 ddsd.u1.lPitch | |
| 1668 #else | |
| 1669 ddsd.lPitch | |
| 1670 #endif | |
| 1671 != (LONG)surface->pitch ) { | |
| 1672 SDL_SetError("DDraw created surface with wrong pitch"); | |
| 1673 goto error_end; | |
| 1674 } | |
| 1675 } else { | |
| 1676 #if defined(NONAMELESSUNION) | |
| 1677 surface->pitch = (Uint16)ddsd.u1.lPitch; | |
| 1678 #else | |
| 1679 surface->pitch = (Uint16)ddsd.lPitch; | |
| 1680 #endif | |
| 1681 } | |
| 1682 #if defined(NONAMELESSUNION) | |
| 1683 if ( (ddsd.ddpfPixelFormat.u1.dwRGBBitCount != | |
| 1684 surface->format->BitsPerPixel) || | |
| 1685 (ddsd.ddpfPixelFormat.u2.dwRBitMask != surface->format->Rmask) || | |
| 1686 (ddsd.ddpfPixelFormat.u3.dwGBitMask != surface->format->Gmask) || | |
| 1687 (ddsd.ddpfPixelFormat.u4.dwBBitMask != surface->format->Bmask) ){ | |
| 1688 #else | |
| 1689 if ( (ddsd.ddpfPixelFormat.dwRGBBitCount != | |
| 1690 surface->format->BitsPerPixel) || | |
| 1691 (ddsd.ddpfPixelFormat.dwRBitMask != surface->format->Rmask) || | |
| 1692 (ddsd.ddpfPixelFormat.dwGBitMask != surface->format->Gmask) || | |
| 1693 (ddsd.ddpfPixelFormat.dwBBitMask != surface->format->Bmask) ){ | |
| 1694 #endif | |
| 1695 SDL_SetError("DDraw didn't use SDL surface description"); | |
| 1696 goto error_end; | |
| 1697 } | |
| 1698 if ( (ddsd.dwWidth != (DWORD)surface->w) || | |
| 1699 (ddsd.dwHeight != (DWORD)surface->h) ) { | |
| 1700 SDL_SetError("DDraw created surface with wrong size"); | |
| 1701 goto error_end; | |
| 1702 } | |
| 1703 | |
| 1704 /* Set the surface private data */ | |
| 1705 surface->flags |= flag; | |
| 1706 surface->hwdata->dd_surface = dd_surface3; | |
| 1707 if ( (surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { | |
| 1708 LPDIRECTDRAWSURFACE3 dd_writebuf; | |
| 1709 | |
| 1710 ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; | |
| 1711 result = IDirectDrawSurface3_GetAttachedSurface(dd_surface3, | |
| 1712 &ddsd.ddsCaps, &dd_writebuf); | |
| 1713 if ( result != DD_OK ) { | |
| 1714 SetDDerror("DirectDrawSurface3::GetAttachedSurface", | |
| 1715 result); | |
| 1716 } else { | |
| 1717 dd_surface3 = dd_writebuf; | |
| 1718 } | |
| 1719 } | |
| 1720 surface->hwdata->dd_writebuf = dd_surface3; | |
| 1721 | |
| 1722 /* We're ready to go! */ | |
| 1723 return(0); | |
| 1724 | |
| 1725 /* Okay, so goto's are cheesy, but there are so many possible | |
| 1726 errors in this function, and the cleanup is the same in | |
| 1727 every single case. Is there a better way, other than deeply | |
| 1728 nesting the code? | |
| 1729 */ | |
| 1730 error_end: | |
| 1731 if ( (dd_surface3 != NULL) && (dd_surface3 != requested) ) { | |
| 1732 IDirectDrawSurface_Release(dd_surface3); | |
| 1733 } | |
| 1734 free(surface->hwdata); | |
| 1735 surface->hwdata = NULL; | |
| 1736 return(-1); | |
| 1737 } | |
| 1738 | |
| 1739 static int DX5_AllocHWSurface(_THIS, SDL_Surface *surface) | |
| 1740 { | |
| 1741 /* DDraw limitation -- you need to set cooperative level first */ | |
| 1742 if ( SDL_primary == NULL ) { | |
| 1743 SDL_SetError("You must set a non-GL video mode first"); | |
| 1744 return(-1); | |
| 1745 } | |
| 1746 return(DX5_AllocDDSurface(this, surface, NULL, SDL_HWSURFACE)); | |
| 1747 } | |
| 1748 | |
|
1
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1749 #ifdef DDRAW_DEBUG |
| 0 | 1750 void PrintSurface(char *title, LPDIRECTDRAWSURFACE3 surface, Uint32 flags) |
| 1751 { | |
| 1752 DDSURFACEDESC ddsd; | |
| 1753 | |
| 1754 /* Lock and load! */ | |
| 1755 memset(&ddsd, 0, sizeof(ddsd)); | |
| 1756 ddsd.dwSize = sizeof(ddsd); | |
| 1757 if ( IDirectDrawSurface3_Lock(surface, NULL, &ddsd, | |
| 1758 (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL) != DD_OK ) { | |
| 1759 return; | |
| 1760 } | |
| 1761 IDirectDrawSurface3_Unlock(surface, NULL); | |
| 1762 | |
| 1763 fprintf(stderr, "%s:\n", title); | |
| 1764 fprintf(stderr, "\tSize: %dx%d in %s at %ld bpp (pitch = %ld)\n", | |
| 1765 ddsd.dwWidth, ddsd.dwHeight, | |
| 1766 (flags & SDL_HWSURFACE) ? "hardware" : "software", | |
| 1767 #if defined(NONAMELESSUNION) | |
| 1768 ddsd.ddpfPixelFormat.u1.dwRGBBitCount, ddsd.u1.lPitch); | |
| 1769 #else | |
| 1770 ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.lPitch); | |
| 1771 #endif | |
| 1772 fprintf(stderr, "\tR = 0x%X, G = 0x%X, B = 0x%X\n", | |
| 1773 #if defined(NONAMELESSUNION) | |
| 1774 ddsd.ddpfPixelFormat.u2.dwRBitMask, | |
| 1775 ddsd.ddpfPixelFormat.u3.dwGBitMask, | |
| 1776 ddsd.ddpfPixelFormat.u4.dwBBitMask); | |
| 1777 #else | |
| 1778 ddsd.ddpfPixelFormat.dwRBitMask, | |
| 1779 ddsd.ddpfPixelFormat.dwGBitMask, | |
| 1780 ddsd.ddpfPixelFormat.dwBBitMask); | |
| 1781 #endif | |
| 1782 } | |
|
1
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1783 #endif /* DDRAW_DEBUG */ |
| 0 | 1784 |
| 1785 static int DX5_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | |
| 1786 SDL_Surface *dst, SDL_Rect *dstrect) | |
| 1787 { | |
| 1788 LPDIRECTDRAWSURFACE3 src_surface; | |
| 1789 LPDIRECTDRAWSURFACE3 dst_surface; | |
| 1790 DWORD flags; | |
| 1791 RECT rect; | |
| 1792 HRESULT result; | |
| 1793 | |
| 1794 /* Set it up.. the desination must have a DDRAW surface */ | |
| 1795 src_surface = src->hwdata->dd_writebuf; | |
| 1796 dst_surface = dst->hwdata->dd_writebuf; | |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1797 rect.top = (LONG)srcrect->y; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1798 rect.bottom = (LONG)srcrect->y+srcrect->h; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1799 rect.left = (LONG)srcrect->x; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1800 rect.right = (LONG)srcrect->x+srcrect->w; |
| 0 | 1801 if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) |
| 1802 flags = DDBLTFAST_SRCCOLORKEY; | |
| 1803 else | |
| 1804 flags = DDBLTFAST_NOCOLORKEY; | |
| 1805 /* FIXME: We can remove this flag for _really_ fast blit queuing, | |
| 1806 but it will affect the return values of locks and flips. | |
| 1807 */ | |
| 1808 flags |= DDBLTFAST_WAIT; | |
| 1809 | |
| 1810 /* Do the blit! */ | |
| 1811 result = IDirectDrawSurface3_BltFast(dst_surface, | |
| 1812 dstrect->x, dstrect->y, src_surface, &rect, flags); | |
| 1813 if ( result != DD_OK ) { | |
| 1814 if ( result == DDERR_SURFACELOST ) { | |
| 1815 result = IDirectDrawSurface3_Restore(src_surface); | |
| 1816 result = IDirectDrawSurface3_Restore(dst_surface); | |
| 1817 /* The surfaces need to be reloaded with artwork */ | |
| 1818 SDL_SetError("Blit surfaces were lost, reload them"); | |
| 1819 return(-2); | |
| 1820 } | |
| 1821 SetDDerror("IDirectDrawSurface3::BltFast", result); | |
| 1822 #ifdef DDRAW_DEBUG | |
| 1823 fprintf(stderr, "Original dest rect: %dx%d at %d,%d\n", dstrect->w, dstrect->h, dstrect->x, dstrect->y); | |
| 1824 fprintf(stderr, "HW accelerated %sblit to from 0x%p to 0x%p at (%d,%d)\n", | |
| 1825 (src->flags & SDL_SRCCOLORKEY) ? "colorkey " : "", src, dst, | |
| 1826 dstrect->x, dstrect->y); | |
| 1827 PrintSurface("SRC", src_surface, src->flags); | |
| 1828 PrintSurface("DST", dst_surface, dst->flags); | |
| 1829 fprintf(stderr, "Source rectangle: (%d,%d) - (%d,%d)\n", | |
| 1830 rect.left, rect.top, rect.right, rect.bottom); | |
| 1831 #endif | |
| 1832 /* Unexpected error, fall back to software blit */ | |
| 1833 return(src->map->sw_blit(src, srcrect, dst, dstrect)); | |
| 1834 } | |
| 1835 return(0); | |
| 1836 } | |
| 1837 | |
| 1838 static int DX5_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst) | |
| 1839 { | |
| 1840 int accelerated; | |
| 1841 | |
| 1842 /* We need to have a DDraw surface for HW blits */ | |
| 1843 if ( (src->flags & SDL_HWSURFACE) == SDL_SWSURFACE ) { | |
| 1844 /* Allocate a DDraw surface for the blit */ | |
| 1845 if ( src->hwdata == NULL ) { | |
| 1846 DX5_AllocDDSurface(this, src, NULL, SDL_SWSURFACE); | |
| 1847 } | |
| 1848 } | |
| 1849 if ( src->hwdata == NULL ) { | |
| 1850 return(0); | |
| 1851 } | |
| 1852 | |
| 1853 /* Set initial acceleration on */ | |
| 1854 src->flags |= SDL_HWACCEL; | |
| 1855 | |
| 1856 /* Set the surface attributes */ | |
| 1857 if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | |
| 1858 if ( DX5_SetHWColorKey(this, src, src->format->colorkey) < 0 ) { | |
| 1859 src->flags &= ~SDL_HWACCEL; | |
| 1860 } | |
| 1861 } | |
| 1862 if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { | |
| 1863 if ( DX5_SetHWAlpha(this, src, src->format->alpha) < 0 ) { | |
| 1864 src->flags &= ~SDL_HWACCEL; | |
| 1865 } | |
| 1866 } | |
| 1867 | |
| 1868 /* Check to see if final surface blit is accelerated */ | |
| 1869 accelerated = !!(src->flags & SDL_HWACCEL); | |
| 1870 if ( accelerated ) { | |
| 1871 #ifdef DDRAW_DEBUG | |
| 1872 fprintf(stderr, "Setting accelerated blit on 0x%p\n", src); | |
| 1873 #endif | |
| 1874 src->map->hw_blit = DX5_HWAccelBlit; | |
| 1875 } | |
| 1876 return(accelerated); | |
| 1877 } | |
| 1878 | |
| 1879 static int DX5_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color) | |
| 1880 { | |
| 1881 LPDIRECTDRAWSURFACE3 dst_surface; | |
| 1882 RECT area; | |
| 1883 DDBLTFX bltfx; | |
| 1884 HRESULT result; | |
| 1885 | |
| 1886 #ifdef DDRAW_DEBUG | |
| 1887 fprintf(stderr, "HW accelerated fill at (%d,%d)\n", dstrect->x, dstrect->y); | |
| 1888 #endif | |
| 1889 dst_surface = dst->hwdata->dd_writebuf; | |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1890 area.top = (LONG)dstrect->y; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1891 area.bottom = (LONG)dstrect->y+dstrect->h; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1892 area.left = (LONG)dstrect->x; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
1893 area.right = (LONG)dstrect->x+dstrect->w; |
| 0 | 1894 bltfx.dwSize = sizeof(bltfx); |
| 1895 #if defined(NONAMELESSUNION) | |
| 1896 bltfx.u5.dwFillColor = color; | |
| 1897 #else | |
| 1898 bltfx.dwFillColor = color; | |
| 1899 #endif | |
| 1900 result = IDirectDrawSurface3_Blt(dst_surface, | |
| 1901 &area, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &bltfx); | |
| 1902 if ( result == DDERR_SURFACELOST ) { | |
| 1903 IDirectDrawSurface3_Restore(dst_surface); | |
| 1904 result = IDirectDrawSurface3_Blt(dst_surface, | |
| 1905 &area, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &bltfx); | |
| 1906 } | |
| 1907 if ( result != DD_OK ) { | |
| 1908 SetDDerror("IDirectDrawSurface3::Blt", result); | |
| 1909 return(-1); | |
| 1910 } | |
| 1911 return(0); | |
| 1912 } | |
| 1913 | |
| 1914 static int DX5_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) | |
| 1915 { | |
| 1916 DDCOLORKEY colorkey; | |
| 1917 HRESULT result; | |
| 1918 | |
| 1919 /* Set the surface colorkey */ | |
| 1920 colorkey.dwColorSpaceLowValue = key; | |
| 1921 colorkey.dwColorSpaceHighValue = key; | |
| 1922 result = IDirectDrawSurface3_SetColorKey( | |
| 1923 surface->hwdata->dd_surface, DDCKEY_SRCBLT, &colorkey); | |
| 1924 if ( result != DD_OK ) { | |
| 1925 SetDDerror("IDirectDrawSurface3::SetColorKey", result); | |
| 1926 return(-1); | |
| 1927 } | |
| 1928 return(0); | |
| 1929 } | |
| 1930 static int DX5_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha) | |
| 1931 { | |
| 1932 return(-1); | |
| 1933 } | |
| 1934 | |
| 1935 static int DX5_LockHWSurface(_THIS, SDL_Surface *surface) | |
| 1936 { | |
| 1937 HRESULT result; | |
| 1938 LPDIRECTDRAWSURFACE3 dd_surface; | |
| 1939 DDSURFACEDESC ddsd; | |
| 1940 | |
| 1941 /* Lock and load! */ | |
| 1942 dd_surface = surface->hwdata->dd_writebuf; | |
| 1943 memset(&ddsd, 0, sizeof(ddsd)); | |
| 1944 ddsd.dwSize = sizeof(ddsd); | |
| 1945 result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd, | |
| 1946 (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL); | |
| 1947 if ( result == DDERR_SURFACELOST ) { | |
| 1948 result = IDirectDrawSurface3_Restore( | |
| 1949 surface->hwdata->dd_surface); | |
| 1950 result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd, | |
| 1951 (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL); | |
| 1952 } | |
| 1953 if ( result != DD_OK ) { | |
| 1954 SetDDerror("DirectDrawSurface3::Lock", result); | |
| 1955 return(-1); | |
| 1956 } | |
| 1957 /* Pitch might have changed -- recalculate pitch and offset */ | |
| 1958 #if defined(NONAMELESSUNION) | |
| 1959 if ( surface->pitch != ddsd.u1.lPitch ) { | |
| 1960 surface->pitch = ddsd.u1.lPitch; | |
| 1961 #else | |
| 1962 if ( surface->pitch != ddsd.lPitch ) { | |
| 1963 surface->pitch = (Uint16)ddsd.lPitch; | |
| 1964 #endif | |
| 1965 surface->offset = | |
| 1966 ((ddsd.dwHeight-surface->h)/2)*surface->pitch + | |
| 1967 ((ddsd.dwWidth-surface->w)/2)* | |
| 1968 surface->format->BytesPerPixel; | |
| 1969 } | |
| 1970 surface->pixels = ddsd.lpSurface; | |
| 1971 return(0); | |
| 1972 } | |
| 1973 | |
| 1974 static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface) | |
| 1975 { | |
| 1976 IDirectDrawSurface3_Unlock(surface->hwdata->dd_writebuf, NULL); | |
| 1977 surface->pixels = NULL; | |
| 1978 } | |
| 1979 | |
| 1980 static int DX5_FlipHWSurface(_THIS, SDL_Surface *surface) | |
| 1981 { | |
| 1982 HRESULT result; | |
| 1983 LPDIRECTDRAWSURFACE3 dd_surface; | |
| 1984 | |
| 1985 dd_surface = surface->hwdata->dd_surface; | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1986 |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1987 /* to prevent big slowdown on fast computers, wait here instead of driver ring 0 code */ |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1988 /* Dmitry Yakimov (ftech@tula.net) */ |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1989 while(IDirectDrawSurface3_GetFlipStatus(dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING); |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1990 |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1991 result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT); |
| 0 | 1992 if ( result == DDERR_SURFACELOST ) { |
| 1993 result = IDirectDrawSurface3_Restore( | |
| 1994 surface->hwdata->dd_surface); | |
|
809
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1995 while(IDirectDrawSurface3_GetFlipStatus(dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING); |
|
dba98fb391e7
Date: Tue, 13 Jan 2004 19:25:37 +0300
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
1996 result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT); |
| 0 | 1997 } |
| 1998 if ( result != DD_OK ) { | |
| 1999 SetDDerror("DirectDrawSurface3::Flip", result); | |
| 2000 return(-1); | |
| 2001 } | |
| 2002 return(0); | |
| 2003 } | |
| 2004 | |
| 2005 static void DX5_FreeHWSurface(_THIS, SDL_Surface *surface) | |
| 2006 { | |
| 2007 if ( surface->hwdata ) { | |
| 2008 if ( surface->hwdata->dd_surface != SDL_primary ) { | |
| 2009 IDirectDrawSurface3_Release(surface->hwdata->dd_surface); | |
| 2010 } | |
| 2011 free(surface->hwdata); | |
| 2012 surface->hwdata = NULL; | |
| 2013 } | |
| 2014 } | |
| 2015 | |
| 2016 void DX5_WindowUpdate(_THIS, int numrects, SDL_Rect *rects) | |
| 2017 { | |
| 2018 HRESULT result; | |
| 2019 int i; | |
| 2020 RECT src, dst; | |
| 2021 | |
| 2022 for ( i=0; i<numrects; ++i ) { | |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
2023 src.top = (LONG)rects[i].y; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
2024 src.bottom = (LONG)rects[i].y+rects[i].h; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
2025 src.left = (LONG)rects[i].x; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
2026 src.right = (LONG)rects[i].x+rects[i].w; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
2027 dst.top = SDL_bounds.top+src.top; |
|
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
2028 dst.left = SDL_bounds.left+src.left; |
| 0 | 2029 dst.bottom = SDL_bounds.top+src.bottom; |
|
468
0b0c2e63eb27
Fixed 2048 pixel limitation in DirectX blit code
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
2030 dst.right = SDL_bounds.left+src.right; |
| 0 | 2031 result = IDirectDrawSurface3_Blt(SDL_primary, &dst, |
| 2032 this->screen->hwdata->dd_surface, &src, | |
| 2033 DDBLT_WAIT, NULL); | |
| 2034 /* Doh! Check for lost surface and restore it */ | |
| 2035 if ( result == DDERR_SURFACELOST ) { | |
| 2036 IDirectDrawSurface3_Restore(SDL_primary); | |
| 2037 IDirectDrawSurface3_Blt(SDL_primary, &dst, | |
| 2038 this->screen->hwdata->dd_surface, &src, | |
| 2039 DDBLT_WAIT, NULL); | |
| 2040 } | |
| 2041 } | |
| 2042 } | |
| 2043 | |
| 2044 void DX5_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) | |
| 2045 { | |
| 2046 } | |
| 2047 | |
| 2048 /* Compress a full palette into the limited number of colors given to us | |
| 2049 by windows. | |
| 2050 | |
| 2051 The "best" way to do this is to sort the colors by diversity and place | |
| 2052 the most diverse colors into the limited palette. Unfortunately this | |
| 2053 results in widely varying colors being displayed in the interval during | |
| 2054 which the windows palette has been set, and the mapping of the shadow | |
| 2055 surface to the new palette. This is especially noticeable during fades. | |
| 2056 | |
| 2057 To deal with this problem, we can copy a predetermined portion of the | |
| 2058 full palette, and use that as the limited palette. This allows colors | |
| 2059 to fade smoothly as the remapping is very similar on each palette change. | |
| 2060 Unfortunately, this breaks applications which partition the palette into | |
| 2061 distinct and widely varying areas, expecting all colors to be available. | |
| 2062 | |
| 2063 I'm making them both available, chosen at compile time. | |
| 2064 If you want the chunk-o-palette algorithm, define SIMPLE_COMPRESSION, | |
| 2065 otherwise the sort-by-diversity algorithm will be used. | |
| 2066 */ | |
| 2067 #define SIMPLE_COMPRESSION | |
| 2068 #define CS_CS_DIST(A, B) ({ \ | |
| 2069 int r = (A.r - B.r); \ | |
| 2070 int g = (A.g - B.g); \ | |
| 2071 int b = (A.b - B.b); \ | |
| 2072 (r*r + g*g + b*b); \ | |
| 2073 }) | |
| 2074 static void DX5_CompressPalette(_THIS, SDL_Color *colors, int ncolors, int maxcolors) | |
| 2075 { | |
| 2076 #ifdef SIMPLE_COMPRESSION | |
| 2077 int i, j; | |
| 2078 #else | |
| 2079 static SDL_Color zero = { 0, 0, 0, 0 }; | |
| 2080 int i, j; | |
| 2081 int max, dist; | |
| 2082 int prev, next; | |
| 2083 int *pool; | |
| 2084 int *seen, *order; | |
| 2085 #endif | |
| 2086 | |
| 2087 /* Does this happen? */ | |
| 2088 if ( maxcolors > ncolors ) { | |
| 2089 maxcolors = ncolors; | |
| 2090 } | |
| 2091 | |
| 2092 #ifdef SIMPLE_COMPRESSION | |
| 2093 /* Just copy the first "maxcolors" colors */ | |
| 2094 for ( j=10, i=0; i<maxcolors; ++i, ++j ) { | |
| 2095 SDL_colors[j].peRed = colors[i].r; | |
| 2096 SDL_colors[j].peGreen = colors[i].g; | |
| 2097 SDL_colors[j].peBlue = colors[i].b; | |
| 2098 } | |
| 2099 #else | |
| 2100 /* Allocate memory for the arrays we use */ | |
| 2101 pool = (int *)alloca(2*ncolors*sizeof(int)); | |
| 2102 if ( pool == NULL ) { | |
| 2103 /* No worries, just return */; | |
| 2104 return; | |
| 2105 } | |
| 2106 seen = pool; | |
| 2107 memset(seen, 0, ncolors*sizeof(int)); | |
| 2108 order = pool+ncolors; | |
| 2109 | |
| 2110 /* Start with the brightest color */ | |
| 2111 max = 0; | |
| 2112 for ( i=0; i<ncolors; ++i ) { | |
| 2113 dist = CS_CS_DIST(zero, colors[i]); | |
| 2114 if ( dist >= max ) { | |
| 2115 max = dist; | |
| 2116 next = i; | |
| 2117 } | |
| 2118 } | |
| 2119 j = 0; | |
| 2120 order[j++] = next; | |
| 2121 seen[next] = 1; | |
| 2122 prev = next; | |
| 2123 | |
| 2124 /* Keep going through all the colors */ | |
| 2125 while ( j < maxcolors ) { | |
| 2126 max = 0; | |
| 2127 for ( i=0; i<ncolors; ++i ) { | |
| 2128 if ( seen[i] ) { | |
| 2129 continue; | |
| 2130 } | |
| 2131 dist = CS_CS_DIST(colors[i], colors[prev]); | |
| 2132 if ( dist >= max ) { | |
| 2133 max = dist; | |
| 2134 next = i; | |
| 2135 } | |
| 2136 } | |
| 2137 order[j++] = next; | |
| 2138 seen[next] = 1; | |
| 2139 prev = next; | |
| 2140 } | |
| 2141 | |
| 2142 /* Compress the colors to the palette */ | |
| 2143 for ( j=10, i=0; i<maxcolors; ++i, ++j ) { | |
| 2144 SDL_colors[j].peRed = colors[order[i]].r; | |
| 2145 SDL_colors[j].peGreen = colors[order[i]].g; | |
| 2146 SDL_colors[j].peBlue = colors[order[i]].b; | |
| 2147 } | |
| 2148 #endif /* SIMPLE_COMPRESSION */ | |
| 2149 } | |
| 2150 | |
| 2151 /* Set the system colormap in both fullscreen and windowed modes */ | |
| 2152 int DX5_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | |
| 2153 { | |
| 2154 int i; | |
| 2155 int alloct_all; | |
| 2156 | |
| 2157 /* Copy palette colors into display palette */ | |
| 2158 alloct_all = 0; | |
| 2159 if ( SDL_palette != NULL ) { | |
| 2160 if ( (this->screen->flags&SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 2161 /* We can set all entries explicitly */ | |
| 2162 for ( i=0; i< ncolors; ++i ) { | |
| 2163 int j = firstcolor + i; | |
| 2164 SDL_colors[j].peRed = colors[i].r; | |
| 2165 SDL_colors[j].peGreen = colors[i].g; | |
| 2166 SDL_colors[j].peBlue = colors[i].b; | |
| 2167 } | |
| 2168 IDirectDrawPalette_SetEntries(SDL_palette, 0, | |
| 2169 firstcolor, ncolors, &SDL_colors[firstcolor]); | |
| 2170 alloct_all = 1; | |
| 2171 } else { | |
| 2172 /* Grab the 236 most diverse colors in the palette */ | |
| 2173 DX5_CompressPalette(this, colors, ncolors, 236); | |
| 2174 /* This sends an WM_PALETTECHANGED message to us */ | |
| 2175 colorchange_expected = 1; | |
| 2176 IDirectDrawPalette_SetEntries(SDL_palette, 0, | |
| 2177 0, 256, SDL_colors); | |
| 2178 } | |
| 2179 } | |
| 2180 return(alloct_all); | |
| 2181 } | |
| 2182 | |
| 2183 /* Gamma code is only available on DirectX 7 and newer */ | |
| 2184 static int DX5_SetGammaRamp(_THIS, Uint16 *ramp) | |
| 2185 { | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2186 #ifdef IDirectDrawGammaControl_SetGammaRamp |
| 0 | 2187 LPDIRECTDRAWGAMMACONTROL gamma; |
| 2188 DDGAMMARAMP gamma_ramp; | |
| 2189 HRESULT result; | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2190 #endif |
| 0 | 2191 |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2192 /* In windowed or OpenGL mode, use windib gamma code */ |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2193 if ( ! DDRAW_FULLSCREEN() ) { |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2194 return DIB_SetGammaRamp(this, ramp); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2195 } |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2196 |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2197 #ifndef IDirectDrawGammaControl_SetGammaRamp |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2198 SDL_SetError("SDL compiled without DirectX gamma ramp support"); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2199 return -1; |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2200 #else |
| 0 | 2201 /* Check for a video mode! */ |
| 2202 if ( ! SDL_primary ) { | |
| 2203 SDL_SetError("A video mode must be set for gamma correction"); | |
| 2204 return(-1); | |
| 2205 } | |
| 2206 | |
| 2207 /* Get the gamma control object */ | |
| 2208 result = IDirectDrawSurface3_QueryInterface(SDL_primary, | |
| 2209 &IID_IDirectDrawGammaControl, (LPVOID *)&gamma); | |
| 2210 if ( result != DD_OK ) { | |
| 2211 SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result); | |
| 2212 return(-1); | |
| 2213 } | |
| 2214 | |
| 2215 /* Set up the gamma ramp */ | |
| 2216 memcpy(gamma_ramp.red, &ramp[0*256], 256*sizeof(*ramp)); | |
| 2217 memcpy(gamma_ramp.green, &ramp[1*256], 256*sizeof(*ramp)); | |
| 2218 memcpy(gamma_ramp.blue, &ramp[2*256], 256*sizeof(*ramp)); | |
| 2219 result = IDirectDrawGammaControl_SetGammaRamp(gamma, 0, &gamma_ramp); | |
| 2220 if ( result != DD_OK ) { | |
| 2221 SetDDerror("DirectDrawGammaControl::SetGammaRamp()", result); | |
| 2222 } | |
| 2223 | |
| 2224 /* Release the interface and return */ | |
| 2225 IDirectDrawGammaControl_Release(gamma); | |
| 2226 return (result == DD_OK) ? 0 : -1; | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2227 #endif /* !IDirectDrawGammaControl_SetGammaRamp */ |
| 0 | 2228 } |
| 2229 | |
| 2230 static int DX5_GetGammaRamp(_THIS, Uint16 *ramp) | |
| 2231 { | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2232 #ifdef IDirectDrawGammaControl_SetGammaRamp |
| 0 | 2233 LPDIRECTDRAWGAMMACONTROL gamma; |
| 2234 DDGAMMARAMP gamma_ramp; | |
| 2235 HRESULT result; | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2236 #endif |
| 0 | 2237 |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2238 /* In windowed or OpenGL mode, use windib gamma code */ |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2239 if ( ! DDRAW_FULLSCREEN() ) { |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2240 return DIB_GetGammaRamp(this, ramp); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2241 } |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2242 |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2243 #ifndef IDirectDrawGammaControl_SetGammaRamp |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2244 SDL_SetError("SDL compiled without DirectX gamma ramp support"); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2245 return -1; |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2246 #else |
| 0 | 2247 /* Check for a video mode! */ |
| 2248 if ( ! SDL_primary ) { | |
| 2249 SDL_SetError("A video mode must be set for gamma correction"); | |
| 2250 return(-1); | |
| 2251 } | |
| 2252 | |
| 2253 /* Get the gamma control object */ | |
| 2254 result = IDirectDrawSurface3_QueryInterface(SDL_primary, | |
| 2255 &IID_IDirectDrawGammaControl, (LPVOID *)&gamma); | |
| 2256 if ( result != DD_OK ) { | |
| 2257 SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result); | |
| 2258 return(-1); | |
| 2259 } | |
| 2260 | |
| 2261 /* Set up the gamma ramp */ | |
| 2262 result = IDirectDrawGammaControl_GetGammaRamp(gamma, 0, &gamma_ramp); | |
| 2263 if ( result == DD_OK ) { | |
| 2264 memcpy(&ramp[0*256], gamma_ramp.red, 256*sizeof(*ramp)); | |
| 2265 memcpy(&ramp[1*256], gamma_ramp.green, 256*sizeof(*ramp)); | |
| 2266 memcpy(&ramp[2*256], gamma_ramp.blue, 256*sizeof(*ramp)); | |
| 2267 } else { | |
| 2268 SetDDerror("DirectDrawGammaControl::GetGammaRamp()", result); | |
| 2269 } | |
| 2270 | |
| 2271 /* Release the interface and return */ | |
| 2272 IDirectDrawGammaControl_Release(gamma); | |
| 2273 return (result == DD_OK) ? 0 : -1; | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2274 #endif /* !IDirectDrawGammaControl_SetGammaRamp */ |
| 0 | 2275 } |
| 2276 | |
|
442
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2277 static void FlushMessageQueue() |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2278 { |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2279 MSG msg; |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2280 while ( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) ) { |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2281 if ( msg.message == WM_QUIT ) break; |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2282 TranslateMessage( &msg ); |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2283 DispatchMessage( &msg ); |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2284 } |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2285 } |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2286 |
| 0 | 2287 void DX5_VideoQuit(_THIS) |
| 2288 { | |
| 2289 int i, j; | |
| 2290 | |
| 2291 /* If we're fullscreen GL, we need to reset the display */ | |
| 2292 if ( this->screen != NULL ) { | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
2293 #ifndef NO_CHANGEDISPLAYSETTINGS |
| 0 | 2294 if ( (this->screen->flags & (SDL_OPENGL|SDL_FULLSCREEN)) == |
| 2295 (SDL_OPENGL|SDL_FULLSCREEN) ) { | |
| 2296 ChangeDisplaySettings(NULL, 0); | |
|
376
a5f60a847a89
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
374
diff
changeset
|
2297 ShowWindow(SDL_Window, SW_HIDE); |
| 0 | 2298 } |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
2299 #endif |
| 0 | 2300 if ( this->screen->flags & SDL_OPENGL ) { |
| 2301 WIN_GL_ShutDown(this); | |
| 2302 } | |
| 2303 } | |
| 2304 | |
| 2305 /* Free any palettes we used */ | |
| 2306 if ( SDL_palette != NULL ) { | |
| 2307 IDirectDrawPalette_Release(SDL_palette); | |
| 2308 SDL_palette = NULL; | |
| 2309 } | |
| 2310 | |
| 2311 /* Allow the primary surface to be freed */ | |
| 2312 if ( SDL_primary != NULL ) { | |
| 2313 SDL_primary = NULL; | |
| 2314 } | |
| 2315 | |
| 2316 /* Free video mode lists */ | |
| 2317 for ( i=0; i<NUM_MODELISTS; ++i ) { | |
| 2318 if ( SDL_modelist[i] != NULL ) { | |
| 2319 for ( j=0; SDL_modelist[i][j]; ++j ) | |
| 2320 free(SDL_modelist[i][j]); | |
| 2321 free(SDL_modelist[i]); | |
| 2322 SDL_modelist[i] = NULL; | |
| 2323 } | |
| 2324 } | |
| 2325 | |
| 2326 /* Free the window */ | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
334
diff
changeset
|
2327 DIB_QuitGamma(this); |
| 0 | 2328 if ( SDL_Window ) { |
| 2329 DX5_DestroyWindow(this); | |
|
442
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
440
diff
changeset
|
2330 FlushMessageQueue(); |
| 0 | 2331 } |
| 2332 | |
| 2333 /* Free our window icon */ | |
| 2334 if ( screen_icn ) { | |
| 2335 DestroyIcon(screen_icn); | |
| 2336 screen_icn = NULL; | |
| 2337 } | |
| 2338 } | |
| 2339 | |
| 2340 /* Exported for the windows message loop only */ | |
| 2341 void DX5_RealizePalette(_THIS) | |
| 2342 { | |
| 2343 if ( SDL_palette ) { | |
| 2344 IDirectDrawSurface3_SetPalette(SDL_primary, SDL_palette); | |
| 2345 } | |
| 2346 } | |
| 2347 static void DX5_Recolor8Bit(_THIS, SDL_Surface *surface, Uint8 *mapping) | |
| 2348 { | |
| 2349 int row, col; | |
| 2350 Uint8 *pixels; | |
| 2351 | |
| 2352 if ( surface->w && surface->h ) { | |
| 2353 if ( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { | |
| 2354 if ( this->LockHWSurface(this, surface) < 0 ) { | |
| 2355 return; | |
| 2356 } | |
| 2357 } | |
| 2358 for ( row=0; row<surface->h; ++row ) { | |
| 2359 pixels = (Uint8 *)surface->pixels+row*surface->pitch; | |
| 2360 for ( col=0; col<surface->w; ++col, ++pixels ) { | |
| 2361 *pixels = mapping[*pixels]; | |
| 2362 } | |
| 2363 } | |
| 2364 if ( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { | |
| 2365 this->UnlockHWSurface(this, surface); | |
| 2366 } | |
| 2367 SDL_UpdateRect(surface, 0, 0, 0, 0); | |
| 2368 } | |
| 2369 } | |
| 2370 void DX5_PaletteChanged(_THIS, HWND window) | |
| 2371 { | |
| 2372 SDL_Palette *palette; | |
| 2373 SDL_Color *saved = NULL; | |
| 2374 HDC hdc; | |
| 2375 int i; | |
| 2376 PALETTEENTRY *entries; | |
| 2377 | |
| 2378 /* This is true when the window is closing */ | |
| 2379 if ( (SDL_primary == NULL) || (SDL_VideoSurface == NULL) ) | |
| 2380 return; | |
| 2381 | |
| 2382 /* We need to get the colors as they were set */ | |
| 2383 palette = this->physpal; | |
| 2384 if(!palette) | |
| 2385 palette = SDL_VideoSurface->format->palette; | |
| 2386 if ( palette == NULL ) { /* Sometimes we don't have a palette */ | |
| 2387 return; | |
| 2388 } | |
| 2389 entries = (PALETTEENTRY *)alloca(palette->ncolors*sizeof(*entries)); | |
| 2390 hdc = GetDC(window); | |
| 2391 GetSystemPaletteEntries(hdc, 0, palette->ncolors, entries); | |
| 2392 ReleaseDC(window, hdc); | |
| 2393 if ( ! colorchange_expected ) { | |
| 2394 saved = (SDL_Color *)alloca(palette->ncolors*sizeof(SDL_Color)); | |
| 2395 memcpy(saved, palette->colors, | |
| 2396 palette->ncolors*sizeof(SDL_Color)); | |
| 2397 } | |
| 2398 for ( i=0; i<palette->ncolors; ++i ) { | |
| 2399 palette->colors[i].r = entries[i].peRed; | |
| 2400 palette->colors[i].g = entries[i].peGreen; | |
| 2401 palette->colors[i].b = entries[i].peBlue; | |
| 2402 } | |
| 2403 if ( ! colorchange_expected ) { | |
| 2404 Uint8 mapping[256]; | |
| 2405 | |
| 2406 memset(mapping, 0, sizeof(mapping)); | |
| 2407 for ( i=0; i<palette->ncolors; ++i ) { | |
| 2408 mapping[i] = SDL_FindColor(palette, | |
| 2409 saved[i].r, saved[i].g, saved[i].b); | |
| 2410 } | |
| 2411 DX5_Recolor8Bit(this, SDL_VideoSurface, mapping); | |
| 2412 } | |
| 2413 colorchange_expected = 0; | |
| 2414 | |
| 2415 /* Notify all mapped surfaces of the change */ | |
| 2416 SDL_FormatChanged(SDL_VideoSurface); | |
| 2417 } | |
| 2418 | |
| 2419 /* Exported for the windows message loop only */ | |
| 2420 void DX5_WinPAINT(_THIS, HDC hdc) | |
| 2421 { | |
| 2422 SDL_UpdateRect(SDL_PublicSurface, 0, 0, 0, 0); | |
| 2423 } |