Fix several warnings with gcc-5 and an error with mingw (where
[xonotic/darkplaces.git] / vid_sdl.c
1 /*
2 Copyright (C) 2003  T. Joseph Carter
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18 */
19 #undef WIN32_LEAN_AND_MEAN  //hush a warning, SDL.h redefines this
20 #include <SDL.h>
21 #include <stdio.h>
22
23 #include "quakedef.h"
24 #include "image.h"
25 #include "dpsoftrast.h"
26 #include "utf8lib.h"
27
28 #ifndef __IPHONEOS__
29 #ifdef MACOSX
30 #include <Carbon/Carbon.h>
31 #include <IOKit/hidsystem/IOHIDLib.h>
32 #include <IOKit/hidsystem/IOHIDParameter.h>
33 #include <IOKit/hidsystem/event_status_driver.h>
34 static cvar_t apple_mouse_noaccel = {CVAR_SAVE, "apple_mouse_noaccel", "1", "disables mouse acceleration while DarkPlaces is active"};
35 static qboolean vid_usingnoaccel;
36 static double originalMouseSpeed = -1.0;
37 io_connect_t IN_GetIOHandle(void)
38 {
39         io_connect_t iohandle = MACH_PORT_NULL;
40         kern_return_t status;
41         io_service_t iohidsystem = MACH_PORT_NULL;
42         mach_port_t masterport;
43
44         status = IOMasterPort(MACH_PORT_NULL, &masterport);
45         if(status != KERN_SUCCESS)
46                 return 0;
47
48         iohidsystem = IORegistryEntryFromPath(masterport, kIOServicePlane ":/IOResources/IOHIDSystem");
49         if(!iohidsystem)
50                 return 0;
51
52         status = IOServiceOpen(iohidsystem, mach_task_self(), kIOHIDParamConnectType, &iohandle);
53         IOObjectRelease(iohidsystem);
54
55         return iohandle;
56 }
57 #endif
58 #endif
59
60 #ifdef WIN32
61 #define SDL_R_RESTART
62 #endif
63
64 // Tell startup code that we have a client
65 int cl_available = true;
66
67 qboolean vid_supportrefreshrate = false;
68
69 static qboolean vid_usingmouse = false;
70 static qboolean vid_usingmouse_relativeworks = false; // SDL2 workaround for unimplemented RelativeMouse mode
71 static qboolean vid_usinghidecursor = false;
72 static qboolean vid_hasfocus = false;
73 static qboolean vid_isfullscreen;
74 #if SDL_MAJOR_VERSION != 1
75 static qboolean vid_usingvsync = false;
76 #endif
77 static SDL_Joystick *vid_sdljoystick = NULL;
78 // GAME_STEELSTORM specific
79 static cvar_t *steelstorm_showing_map = NULL; // detect but do not create the cvar
80 static cvar_t *steelstorm_showing_mousecursor = NULL; // detect but do not create the cvar
81
82 static int win_half_width = 50;
83 static int win_half_height = 50;
84 static int video_bpp;
85
86 #if SDL_MAJOR_VERSION == 1
87 static SDL_Surface *screen;
88 static int video_flags;
89 #else
90 static SDL_GLContext context;
91 static SDL_Window *window;
92 static int window_flags;
93 #endif
94 static SDL_Surface *vid_softsurface;
95 static vid_mode_t desktop_mode;
96
97 /////////////////////////
98 // Input handling
99 ////
100 //TODO: Add error checking
101
102 #ifndef SDLK_PERCENT
103 #define SDLK_PERCENT '%'
104 #if SDL_MAJOR_VERSION == 1
105 #define SDLK_PRINTSCREEN SDLK_PRINT
106 #define SDLK_SCROLLLOCK SDLK_SCROLLOCK
107 #define SDLK_NUMLOCKCLEAR SDLK_NUMLOCK
108 #define SDLK_KP_1 SDLK_KP1
109 #define SDLK_KP_2 SDLK_KP2
110 #define SDLK_KP_3 SDLK_KP3
111 #define SDLK_KP_4 SDLK_KP4
112 #define SDLK_KP_5 SDLK_KP5
113 #define SDLK_KP_6 SDLK_KP6
114 #define SDLK_KP_7 SDLK_KP7
115 #define SDLK_KP_8 SDLK_KP8
116 #define SDLK_KP_9 SDLK_KP9
117 #define SDLK_KP_0 SDLK_KP0
118 #endif
119 #endif
120
121 static int MapKey( unsigned int sdlkey )
122 {
123         switch(sdlkey)
124         {
125         default: return 0;
126 //      case SDLK_UNKNOWN:            return K_UNKNOWN;
127         case SDLK_RETURN:             return K_ENTER;
128         case SDLK_ESCAPE:             return K_ESCAPE;
129         case SDLK_BACKSPACE:          return K_BACKSPACE;
130         case SDLK_TAB:                return K_TAB;
131         case SDLK_SPACE:              return K_SPACE;
132         case SDLK_EXCLAIM:            return '!';
133         case SDLK_QUOTEDBL:           return '"';
134         case SDLK_HASH:               return '#';
135         case SDLK_PERCENT:            return '%';
136         case SDLK_DOLLAR:             return '$';
137         case SDLK_AMPERSAND:          return '&';
138         case SDLK_QUOTE:              return '\'';
139         case SDLK_LEFTPAREN:          return '(';
140         case SDLK_RIGHTPAREN:         return ')';
141         case SDLK_ASTERISK:           return '*';
142         case SDLK_PLUS:               return '+';
143         case SDLK_COMMA:              return ',';
144         case SDLK_MINUS:              return '-';
145         case SDLK_PERIOD:             return '.';
146         case SDLK_SLASH:              return '/';
147         case SDLK_0:                  return '0';
148         case SDLK_1:                  return '1';
149         case SDLK_2:                  return '2';
150         case SDLK_3:                  return '3';
151         case SDLK_4:                  return '4';
152         case SDLK_5:                  return '5';
153         case SDLK_6:                  return '6';
154         case SDLK_7:                  return '7';
155         case SDLK_8:                  return '8';
156         case SDLK_9:                  return '9';
157         case SDLK_COLON:              return ':';
158         case SDLK_SEMICOLON:          return ';';
159         case SDLK_LESS:               return '<';
160         case SDLK_EQUALS:             return '=';
161         case SDLK_GREATER:            return '>';
162         case SDLK_QUESTION:           return '?';
163         case SDLK_AT:                 return '@';
164         case SDLK_LEFTBRACKET:        return '[';
165         case SDLK_BACKSLASH:          return '\\';
166         case SDLK_RIGHTBRACKET:       return ']';
167         case SDLK_CARET:              return '^';
168         case SDLK_UNDERSCORE:         return '_';
169         case SDLK_BACKQUOTE:          return '`';
170         case SDLK_a:                  return 'a';
171         case SDLK_b:                  return 'b';
172         case SDLK_c:                  return 'c';
173         case SDLK_d:                  return 'd';
174         case SDLK_e:                  return 'e';
175         case SDLK_f:                  return 'f';
176         case SDLK_g:                  return 'g';
177         case SDLK_h:                  return 'h';
178         case SDLK_i:                  return 'i';
179         case SDLK_j:                  return 'j';
180         case SDLK_k:                  return 'k';
181         case SDLK_l:                  return 'l';
182         case SDLK_m:                  return 'm';
183         case SDLK_n:                  return 'n';
184         case SDLK_o:                  return 'o';
185         case SDLK_p:                  return 'p';
186         case SDLK_q:                  return 'q';
187         case SDLK_r:                  return 'r';
188         case SDLK_s:                  return 's';
189         case SDLK_t:                  return 't';
190         case SDLK_u:                  return 'u';
191         case SDLK_v:                  return 'v';
192         case SDLK_w:                  return 'w';
193         case SDLK_x:                  return 'x';
194         case SDLK_y:                  return 'y';
195         case SDLK_z:                  return 'z';
196         case SDLK_CAPSLOCK:           return K_CAPSLOCK;
197         case SDLK_F1:                 return K_F1;
198         case SDLK_F2:                 return K_F2;
199         case SDLK_F3:                 return K_F3;
200         case SDLK_F4:                 return K_F4;
201         case SDLK_F5:                 return K_F5;
202         case SDLK_F6:                 return K_F6;
203         case SDLK_F7:                 return K_F7;
204         case SDLK_F8:                 return K_F8;
205         case SDLK_F9:                 return K_F9;
206         case SDLK_F10:                return K_F10;
207         case SDLK_F11:                return K_F11;
208         case SDLK_F12:                return K_F12;
209         case SDLK_PRINTSCREEN:        return K_PRINTSCREEN;
210         case SDLK_SCROLLLOCK:         return K_SCROLLOCK;
211         case SDLK_PAUSE:              return K_PAUSE;
212         case SDLK_INSERT:             return K_INS;
213         case SDLK_HOME:               return K_HOME;
214         case SDLK_PAGEUP:             return K_PGUP;
215 #ifdef __IPHONEOS__
216         case SDLK_DELETE:             return K_BACKSPACE;
217 #else
218         case SDLK_DELETE:             return K_DEL;
219 #endif
220         case SDLK_END:                return K_END;
221         case SDLK_PAGEDOWN:           return K_PGDN;
222         case SDLK_RIGHT:              return K_RIGHTARROW;
223         case SDLK_LEFT:               return K_LEFTARROW;
224         case SDLK_DOWN:               return K_DOWNARROW;
225         case SDLK_UP:                 return K_UPARROW;
226         case SDLK_NUMLOCKCLEAR:       return K_NUMLOCK;
227         case SDLK_KP_DIVIDE:          return K_KP_DIVIDE;
228         case SDLK_KP_MULTIPLY:        return K_KP_MULTIPLY;
229         case SDLK_KP_MINUS:           return K_KP_MINUS;
230         case SDLK_KP_PLUS:            return K_KP_PLUS;
231         case SDLK_KP_ENTER:           return K_KP_ENTER;
232         case SDLK_KP_1:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_1 : K_END);
233         case SDLK_KP_2:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_2 : K_DOWNARROW);
234         case SDLK_KP_3:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_3 : K_PGDN);
235         case SDLK_KP_4:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_4 : K_LEFTARROW);
236         case SDLK_KP_5:               return K_KP_5;
237         case SDLK_KP_6:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_6 : K_RIGHTARROW);
238         case SDLK_KP_7:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_7 : K_HOME);
239         case SDLK_KP_8:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_8 : K_UPARROW);
240         case SDLK_KP_9:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_9 : K_PGUP);
241         case SDLK_KP_0:               return ((SDL_GetModState() & KMOD_NUM) ? K_KP_0 : K_INS);
242         case SDLK_KP_PERIOD:          return ((SDL_GetModState() & KMOD_NUM) ? K_KP_PERIOD : K_DEL);
243 //      case SDLK_APPLICATION:        return K_APPLICATION;
244 //      case SDLK_POWER:              return K_POWER;
245         case SDLK_KP_EQUALS:          return K_KP_EQUALS;
246 //      case SDLK_F13:                return K_F13;
247 //      case SDLK_F14:                return K_F14;
248 //      case SDLK_F15:                return K_F15;
249 //      case SDLK_F16:                return K_F16;
250 //      case SDLK_F17:                return K_F17;
251 //      case SDLK_F18:                return K_F18;
252 //      case SDLK_F19:                return K_F19;
253 //      case SDLK_F20:                return K_F20;
254 //      case SDLK_F21:                return K_F21;
255 //      case SDLK_F22:                return K_F22;
256 //      case SDLK_F23:                return K_F23;
257 //      case SDLK_F24:                return K_F24;
258 //      case SDLK_EXECUTE:            return K_EXECUTE;
259 //      case SDLK_HELP:               return K_HELP;
260 //      case SDLK_MENU:               return K_MENU;
261 //      case SDLK_SELECT:             return K_SELECT;
262 //      case SDLK_STOP:               return K_STOP;
263 //      case SDLK_AGAIN:              return K_AGAIN;
264 //      case SDLK_UNDO:               return K_UNDO;
265 //      case SDLK_CUT:                return K_CUT;
266 //      case SDLK_COPY:               return K_COPY;
267 //      case SDLK_PASTE:              return K_PASTE;
268 //      case SDLK_FIND:               return K_FIND;
269 //      case SDLK_MUTE:               return K_MUTE;
270 //      case SDLK_VOLUMEUP:           return K_VOLUMEUP;
271 //      case SDLK_VOLUMEDOWN:         return K_VOLUMEDOWN;
272 //      case SDLK_KP_COMMA:           return K_KP_COMMA;
273 //      case SDLK_KP_EQUALSAS400:     return K_KP_EQUALSAS400;
274 //      case SDLK_ALTERASE:           return K_ALTERASE;
275 //      case SDLK_SYSREQ:             return K_SYSREQ;
276 //      case SDLK_CANCEL:             return K_CANCEL;
277 //      case SDLK_CLEAR:              return K_CLEAR;
278 //      case SDLK_PRIOR:              return K_PRIOR;
279 //      case SDLK_RETURN2:            return K_RETURN2;
280 //      case SDLK_SEPARATOR:          return K_SEPARATOR;
281 //      case SDLK_OUT:                return K_OUT;
282 //      case SDLK_OPER:               return K_OPER;
283 //      case SDLK_CLEARAGAIN:         return K_CLEARAGAIN;
284 //      case SDLK_CRSEL:              return K_CRSEL;
285 //      case SDLK_EXSEL:              return K_EXSEL;
286 //      case SDLK_KP_00:              return K_KP_00;
287 //      case SDLK_KP_000:             return K_KP_000;
288 //      case SDLK_THOUSANDSSEPARATOR: return K_THOUSANDSSEPARATOR;
289 //      case SDLK_DECIMALSEPARATOR:   return K_DECIMALSEPARATOR;
290 //      case SDLK_CURRENCYUNIT:       return K_CURRENCYUNIT;
291 //      case SDLK_CURRENCYSUBUNIT:    return K_CURRENCYSUBUNIT;
292 //      case SDLK_KP_LEFTPAREN:       return K_KP_LEFTPAREN;
293 //      case SDLK_KP_RIGHTPAREN:      return K_KP_RIGHTPAREN;
294 //      case SDLK_KP_LEFTBRACE:       return K_KP_LEFTBRACE;
295 //      case SDLK_KP_RIGHTBRACE:      return K_KP_RIGHTBRACE;
296 //      case SDLK_KP_TAB:             return K_KP_TAB;
297 //      case SDLK_KP_BACKSPACE:       return K_KP_BACKSPACE;
298 //      case SDLK_KP_A:               return K_KP_A;
299 //      case SDLK_KP_B:               return K_KP_B;
300 //      case SDLK_KP_C:               return K_KP_C;
301 //      case SDLK_KP_D:               return K_KP_D;
302 //      case SDLK_KP_E:               return K_KP_E;
303 //      case SDLK_KP_F:               return K_KP_F;
304 //      case SDLK_KP_XOR:             return K_KP_XOR;
305 //      case SDLK_KP_POWER:           return K_KP_POWER;
306 //      case SDLK_KP_PERCENT:         return K_KP_PERCENT;
307 //      case SDLK_KP_LESS:            return K_KP_LESS;
308 //      case SDLK_KP_GREATER:         return K_KP_GREATER;
309 //      case SDLK_KP_AMPERSAND:       return K_KP_AMPERSAND;
310 //      case SDLK_KP_DBLAMPERSAND:    return K_KP_DBLAMPERSAND;
311 //      case SDLK_KP_VERTICALBAR:     return K_KP_VERTICALBAR;
312 //      case SDLK_KP_DBLVERTICALBAR:  return K_KP_DBLVERTICALBAR;
313 //      case SDLK_KP_COLON:           return K_KP_COLON;
314 //      case SDLK_KP_HASH:            return K_KP_HASH;
315 //      case SDLK_KP_SPACE:           return K_KP_SPACE;
316 //      case SDLK_KP_AT:              return K_KP_AT;
317 //      case SDLK_KP_EXCLAM:          return K_KP_EXCLAM;
318 //      case SDLK_KP_MEMSTORE:        return K_KP_MEMSTORE;
319 //      case SDLK_KP_MEMRECALL:       return K_KP_MEMRECALL;
320 //      case SDLK_KP_MEMCLEAR:        return K_KP_MEMCLEAR;
321 //      case SDLK_KP_MEMADD:          return K_KP_MEMADD;
322 //      case SDLK_KP_MEMSUBTRACT:     return K_KP_MEMSUBTRACT;
323 //      case SDLK_KP_MEMMULTIPLY:     return K_KP_MEMMULTIPLY;
324 //      case SDLK_KP_MEMDIVIDE:       return K_KP_MEMDIVIDE;
325 //      case SDLK_KP_PLUSMINUS:       return K_KP_PLUSMINUS;
326 //      case SDLK_KP_CLEAR:           return K_KP_CLEAR;
327 //      case SDLK_KP_CLEARENTRY:      return K_KP_CLEARENTRY;
328 //      case SDLK_KP_BINARY:          return K_KP_BINARY;
329 //      case SDLK_KP_OCTAL:           return K_KP_OCTAL;
330 //      case SDLK_KP_DECIMAL:         return K_KP_DECIMAL;
331 //      case SDLK_KP_HEXADECIMAL:     return K_KP_HEXADECIMAL;
332         case SDLK_LCTRL:              return K_CTRL;
333         case SDLK_LSHIFT:             return K_SHIFT;
334         case SDLK_LALT:               return K_ALT;
335 //      case SDLK_LGUI:               return K_LGUI;
336         case SDLK_RCTRL:              return K_CTRL;
337         case SDLK_RSHIFT:             return K_SHIFT;
338         case SDLK_RALT:               return K_ALT;
339 //      case SDLK_RGUI:               return K_RGUI;
340 //      case SDLK_MODE:               return K_MODE;
341 #if SDL_MAJOR_VERSION != 1
342 //      case SDLK_AUDIONEXT:          return K_AUDIONEXT;
343 //      case SDLK_AUDIOPREV:          return K_AUDIOPREV;
344 //      case SDLK_AUDIOSTOP:          return K_AUDIOSTOP;
345 //      case SDLK_AUDIOPLAY:          return K_AUDIOPLAY;
346 //      case SDLK_AUDIOMUTE:          return K_AUDIOMUTE;
347 //      case SDLK_MEDIASELECT:        return K_MEDIASELECT;
348 //      case SDLK_WWW:                return K_WWW;
349 //      case SDLK_MAIL:               return K_MAIL;
350 //      case SDLK_CALCULATOR:         return K_CALCULATOR;
351 //      case SDLK_COMPUTER:           return K_COMPUTER;
352 //      case SDLK_AC_SEARCH:          return K_AC_SEARCH; // Android button
353 //      case SDLK_AC_HOME:            return K_AC_HOME; // Android button
354         case SDLK_AC_BACK:            return K_ESCAPE; // Android button
355 //      case SDLK_AC_FORWARD:         return K_AC_FORWARD; // Android button
356 //      case SDLK_AC_STOP:            return K_AC_STOP; // Android button
357 //      case SDLK_AC_REFRESH:         return K_AC_REFRESH; // Android button
358 //      case SDLK_AC_BOOKMARKS:       return K_AC_BOOKMARKS; // Android button
359 //      case SDLK_BRIGHTNESSDOWN:     return K_BRIGHTNESSDOWN;
360 //      case SDLK_BRIGHTNESSUP:       return K_BRIGHTNESSUP;
361 //      case SDLK_DISPLAYSWITCH:      return K_DISPLAYSWITCH;
362 //      case SDLK_KBDILLUMTOGGLE:     return K_KBDILLUMTOGGLE;
363 //      case SDLK_KBDILLUMDOWN:       return K_KBDILLUMDOWN;
364 //      case SDLK_KBDILLUMUP:         return K_KBDILLUMUP;
365 //      case SDLK_EJECT:              return K_EJECT;
366 //      case SDLK_SLEEP:              return K_SLEEP;
367 #endif
368         }
369 }
370
371 qboolean VID_HasScreenKeyboardSupport(void)
372 {
373 #if SDL_MAJOR_VERSION != 1
374         return SDL_HasScreenKeyboardSupport() != SDL_FALSE;
375 #else
376         return false;
377 #endif
378 }
379
380 void VID_ShowKeyboard(qboolean show)
381 {
382 #if SDL_MAJOR_VERSION != 1
383         if (!SDL_HasScreenKeyboardSupport())
384                 return;
385
386         if (show)
387         {
388                 if (!SDL_IsTextInputActive())
389                         SDL_StartTextInput();
390         }
391         else
392         {
393                 if (SDL_IsTextInputActive())
394                         SDL_StopTextInput();
395         }
396 #endif
397 }
398
399 qboolean VID_ShowingKeyboard(void)
400 {
401 #if SDL_MAJOR_VERSION != 1
402         return SDL_IsTextInputActive() != 0;
403 #else
404         return false;
405 #endif
406 }
407
408 void VID_SetMouse(qboolean fullscreengrab, qboolean relative, qboolean hidecursor)
409 {
410 #ifndef DP_MOBILETOUCH
411 #ifdef MACOSX
412         if(relative)
413                 if(vid_usingmouse && (vid_usingnoaccel != !!apple_mouse_noaccel.integer))
414                         VID_SetMouse(false, false, false); // ungrab first!
415 #endif
416         if (vid_usingmouse != relative)
417         {
418                 vid_usingmouse = relative;
419                 cl_ignoremousemoves = 2;
420 #if SDL_MAJOR_VERSION == 1
421                 SDL_WM_GrabInput( relative ? SDL_GRAB_ON : SDL_GRAB_OFF );
422 #else
423                 vid_usingmouse_relativeworks = SDL_SetRelativeMouseMode(relative ? SDL_TRUE : SDL_FALSE) == 0;
424 //              Con_Printf("VID_SetMouse(%i, %i, %i) relativeworks = %i\n", (int)fullscreengrab, (int)relative, (int)hidecursor, (int)vid_usingmouse_relativeworks);
425 #endif
426 #ifdef MACOSX
427                 if(relative)
428                 {
429                         // Save the status of mouse acceleration
430                         originalMouseSpeed = -1.0; // in case of error
431                         if(apple_mouse_noaccel.integer)
432                         {
433                                 io_connect_t mouseDev = IN_GetIOHandle();
434                                 if(mouseDev != 0)
435                                 {
436                                         if(IOHIDGetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), &originalMouseSpeed) == kIOReturnSuccess)
437                                         {
438                                                 Con_DPrintf("previous mouse acceleration: %f\n", originalMouseSpeed);
439                                                 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), -1.0) != kIOReturnSuccess)
440                                                 {
441                                                         Con_Print("Could not disable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
442                                                         Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
443                                                 }
444                                         }
445                                         else
446                                         {
447                                                 Con_Print("Could not disable mouse acceleration (failed at IOHIDGetAccelerationWithKey).\n");
448                                                 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
449                                         }
450                                         IOServiceClose(mouseDev);
451                                 }
452                                 else
453                                 {
454                                         Con_Print("Could not disable mouse acceleration (failed at IO_GetIOHandle).\n");
455                                         Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
456                                 }
457                         }
458
459                         vid_usingnoaccel = !!apple_mouse_noaccel.integer;
460                 }
461                 else
462                 {
463                         if(originalMouseSpeed != -1.0)
464                         {
465                                 io_connect_t mouseDev = IN_GetIOHandle();
466                                 if(mouseDev != 0)
467                                 {
468                                         Con_DPrintf("restoring mouse acceleration to: %f\n", originalMouseSpeed);
469                                         if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), originalMouseSpeed) != kIOReturnSuccess)
470                                                 Con_Print("Could not re-enable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
471                                         IOServiceClose(mouseDev);
472                                 }
473                                 else
474                                         Con_Print("Could not re-enable mouse acceleration (failed at IO_GetIOHandle).\n");
475                         }
476                 }
477 #endif
478         }
479         if (vid_usinghidecursor != hidecursor)
480         {
481                 vid_usinghidecursor = hidecursor;
482                 SDL_ShowCursor( hidecursor ? SDL_DISABLE : SDL_ENABLE);
483         }
484 #endif
485 }
486
487 // multitouch[10][] represents the mouse pointer
488 // multitouch[][0]: finger active
489 // multitouch[][1]: Y
490 // multitouch[][2]: Y
491 // X and Y coordinates are 0-1.
492 #define MAXFINGERS 11
493 float multitouch[MAXFINGERS][3];
494
495 // this one stores how many areas this finger has touched
496 int multitouchs[MAXFINGERS];
497
498 // modified heavily by ELUAN
499 static qboolean VID_TouchscreenArea(int corner, float px, float py, float pwidth, float pheight, const char *icon, float textheight, const char *text, float *resultmove, qboolean *resultbutton, keynum_t key, const char *typedtext, float deadzone, float oversizepixels_x, float oversizepixels_y, qboolean iamexclusive)
500 {
501         int finger;
502         float fx, fy, fwidth, fheight;
503         float overfx, overfy, overfwidth, overfheight;
504         float rel[3];
505         float sqsum;
506         qboolean button = false;
507         VectorClear(rel);
508         if (pwidth > 0 && pheight > 0)
509         {
510                 if (corner & 1) px += vid_conwidth.value;
511                 if (corner & 2) py += vid_conheight.value;
512                 if (corner & 4) px += vid_conwidth.value * 0.5f;
513                 if (corner & 8) py += vid_conheight.value * 0.5f;
514                 if (corner & 16) {px *= vid_conwidth.value * (1.0f / 640.0f);py *= vid_conheight.value * (1.0f / 480.0f);pwidth *= vid_conwidth.value * (1.0f / 640.0f);pheight *= vid_conheight.value * (1.0f / 480.0f);}
515                 fx = px / vid_conwidth.value;
516                 fy = py / vid_conheight.value;
517                 fwidth = pwidth / vid_conwidth.value;
518                 fheight = pheight / vid_conheight.value;
519
520                 // try to prevent oversizepixels_* from interfering with the iamexclusive cvar by not letting we start controlling from too far of the actual touch area (areas without resultbuttons should NEVER have the oversizepixels_* parameters set to anything other than 0)
521                 if (resultbutton)
522                         if (!(*resultbutton))
523                         {
524                                 oversizepixels_x *= 0.2;
525                                 oversizepixels_y *= 0.2;
526                         }
527
528                 oversizepixels_x /= vid_conwidth.value;
529                 oversizepixels_y /= vid_conheight.value;
530
531                 overfx = fx - oversizepixels_x;
532                 overfy = fy - oversizepixels_y;
533                 overfwidth = fwidth + 2*oversizepixels_x;
534                 overfheight = fheight + 2*oversizepixels_y;
535
536                 for (finger = 0;finger < MAXFINGERS;finger++)
537                 {
538                         if (multitouchs[finger] && iamexclusive) // for this to work correctly, you must call touch areas in order of highest to lowest priority
539                                 continue;
540
541                         if (multitouch[finger][0] && multitouch[finger][1] >= overfx && multitouch[finger][2] >= overfy && multitouch[finger][1] < overfx + overfwidth && multitouch[finger][2] < overfy + overfheight)
542                         {
543                                 multitouchs[finger]++;
544
545                                 rel[0] = bound(-1, (multitouch[finger][1] - (fx + 0.5f * fwidth)) * (2.0f / fwidth), 1);
546                                 rel[1] = bound(-1, (multitouch[finger][2] - (fy + 0.5f * fheight)) * (2.0f / fheight), 1);
547                                 rel[2] = 0;
548
549                                 sqsum = rel[0]*rel[0] + rel[1]*rel[1];
550                                 // 2d deadzone
551                                 if (sqsum < deadzone*deadzone)
552                                 {
553                                         rel[0] = 0;
554                                         rel[1] = 0;
555                                 }
556                                 else if (sqsum > 1)
557                                 {
558                                         // ignore the third component
559                                         Vector2Normalize2(rel, rel);
560                                 }
561                                 button = true;
562                                 break;
563                         }
564                 }
565                 if (scr_numtouchscreenareas < 128)
566                 {
567                         scr_touchscreenareas[scr_numtouchscreenareas].pic = icon;
568                         scr_touchscreenareas[scr_numtouchscreenareas].text = text;
569                         scr_touchscreenareas[scr_numtouchscreenareas].textheight = textheight;
570                         scr_touchscreenareas[scr_numtouchscreenareas].rect[0] = px;
571                         scr_touchscreenareas[scr_numtouchscreenareas].rect[1] = py;
572                         scr_touchscreenareas[scr_numtouchscreenareas].rect[2] = pwidth;
573                         scr_touchscreenareas[scr_numtouchscreenareas].rect[3] = pheight;
574                         scr_touchscreenareas[scr_numtouchscreenareas].active = button;
575                         // the pics may have alpha too.
576                         scr_touchscreenareas[scr_numtouchscreenareas].activealpha = 1.f;
577                         scr_touchscreenareas[scr_numtouchscreenareas].inactivealpha = 0.95f;
578                         scr_numtouchscreenareas++;
579                 }
580         }
581         if (resultmove)
582         {
583                 if (button)
584                         VectorCopy(rel, resultmove);
585                 else
586                         VectorClear(resultmove);
587         }
588         if (resultbutton)
589         {
590                 if (*resultbutton != button)
591                 {
592                         if ((int)key > 0)
593                                 Key_Event(key, 0, button);
594                         if (typedtext && typedtext[0] && !*resultbutton)
595                         {
596                                 // FIXME: implement UTF8 support - nothing actually specifies a UTF8 string here yet, but should support it...
597                                 int i;
598                                 for (i = 0;typedtext[i];i++)
599                                 {
600                                         Key_Event(K_TEXT, typedtext[i], true);
601                                         Key_Event(K_TEXT, typedtext[i], false);
602                                 }
603                         }
604                 }
605                 *resultbutton = button;
606         }
607         return button;
608 }
609
610 // ELUAN:
611 // not reentrant, but we only need one mouse cursor anyway...
612 static void VID_TouchscreenCursor(float px, float py, float pwidth, float pheight, qboolean *resultbutton, keynum_t key)
613 {
614         int finger;
615         float fx, fy, fwidth, fheight;
616         qboolean button = false;
617         static int cursorfinger = -1;
618         static int cursorfreemovement = false;
619         static int canclick = false;
620         static int clickxy[2];
621         static int relclickxy[2];
622         static double clickrealtime = 0;
623
624         if (steelstorm_showing_mousecursor && steelstorm_showing_mousecursor->integer)
625         if (pwidth > 0 && pheight > 0)
626         {
627                 fx = px / vid_conwidth.value;
628                 fy = py / vid_conheight.value;
629                 fwidth = pwidth / vid_conwidth.value;
630                 fheight = pheight / vid_conheight.value;
631                 for (finger = 0;finger < MAXFINGERS;finger++)
632                 {
633                         if (multitouch[finger][0] && multitouch[finger][1] >= fx && multitouch[finger][2] >= fy && multitouch[finger][1] < fx + fwidth && multitouch[finger][2] < fy + fheight)
634                         {
635                                 if (cursorfinger == -1)
636                                 {
637                                         clickxy[0] =  multitouch[finger][1] * vid_width.value - 0.5f * pwidth;
638                                         clickxy[1] =  multitouch[finger][2] * vid_height.value - 0.5f * pheight;
639                                         relclickxy[0] =  (multitouch[finger][1] - fx) * vid_width.value - 0.5f * pwidth;
640                                         relclickxy[1] =  (multitouch[finger][2] - fy) * vid_height.value - 0.5f * pheight;
641                                 }
642                                 cursorfinger = finger;
643                                 button = true;
644                                 canclick = true;
645                                 cursorfreemovement = false;
646                                 break;
647                         }
648                 }
649                 if (scr_numtouchscreenareas < 128)
650                 {
651                         if (clickrealtime + 1 > realtime)
652                         {
653                                 scr_touchscreenareas[scr_numtouchscreenareas].pic = "gfx/gui/touch_puck_cur_click.tga";
654                         }
655                         else if (button)
656                         {
657                                 scr_touchscreenareas[scr_numtouchscreenareas].pic = "gfx/gui/touch_puck_cur_touch.tga";
658                         }
659                         else
660                         {
661                                 switch ((int)realtime * 10 % 20)
662                                 {
663                                 case 0:
664                                         scr_touchscreenareas[scr_numtouchscreenareas].pic = "gfx/gui/touch_puck_cur_touch.tga";
665                                         break;
666                                 default:
667                                         scr_touchscreenareas[scr_numtouchscreenareas].pic = "gfx/gui/touch_puck_cur_idle.tga";
668                                 }
669                         }
670                         scr_touchscreenareas[scr_numtouchscreenareas].text = "";
671                         scr_touchscreenareas[scr_numtouchscreenareas].textheight = 0;
672                         scr_touchscreenareas[scr_numtouchscreenareas].rect[0] = px;
673                         scr_touchscreenareas[scr_numtouchscreenareas].rect[1] = py;
674                         scr_touchscreenareas[scr_numtouchscreenareas].rect[2] = pwidth;
675                         scr_touchscreenareas[scr_numtouchscreenareas].rect[3] = pheight;
676                         scr_touchscreenareas[scr_numtouchscreenareas].active = button;
677                         scr_touchscreenareas[scr_numtouchscreenareas].activealpha = 1.0f;
678                         scr_touchscreenareas[scr_numtouchscreenareas].inactivealpha = 1.0f;
679                         scr_numtouchscreenareas++;
680                 }
681         }
682
683         if (cursorfinger != -1)
684         {
685                 if (multitouch[cursorfinger][0])
686                 {
687                         if (multitouch[cursorfinger][1] * vid_width.value - 0.5f * pwidth < clickxy[0] - 1 ||
688                                 multitouch[cursorfinger][1] * vid_width.value - 0.5f * pwidth > clickxy[0] + 1 ||
689                                 multitouch[cursorfinger][2] * vid_height.value - 0.5f * pheight< clickxy[1] - 1 ||
690                                 multitouch[cursorfinger][2] * vid_height.value - 0.5f * pheight> clickxy[1] + 1) // finger drifted more than the allowed amount
691                         {
692                                 cursorfreemovement = true;
693                         }
694                         if (cursorfreemovement)
695                         {
696                                 // in_windowmouse_x* is in screen resolution coordinates, not console resolution
697                                 in_windowmouse_x = multitouch[cursorfinger][1] * vid_width.value - 0.5f * pwidth - relclickxy[0];
698                                 in_windowmouse_y = multitouch[cursorfinger][2] * vid_height.value - 0.5f * pheight - relclickxy[1];
699                         }
700                 }
701                 else
702                 {
703                         cursorfinger = -1;
704                 }
705         }
706
707         if (resultbutton)
708         {
709                 if (/**resultbutton != button && */(int)key > 0)
710                 {
711                         if (!button && !cursorfreemovement && canclick)
712                         {
713                                 Key_Event(key, 0, true);
714                                 canclick = false;
715                                 clickrealtime = realtime;
716                         }
717
718                         // SS:BR can't qc can't cope with presses and releases on the same frame
719                         if (clickrealtime && clickrealtime + 0.1 < realtime)
720                         {
721                                 Key_Event(key, 0, false);
722                                 clickrealtime = 0;
723                         }
724                 }
725
726                 *resultbutton = button;
727         }
728 }
729
730 void VID_BuildJoyState(vid_joystate_t *joystate)
731 {
732         VID_Shared_BuildJoyState_Begin(joystate);
733
734         if (vid_sdljoystick)
735         {
736                 SDL_Joystick *joy = vid_sdljoystick;
737                 int j;
738                 int numaxes;
739                 int numbuttons;
740                 numaxes = SDL_JoystickNumAxes(joy);
741                 for (j = 0;j < numaxes;j++)
742                         joystate->axis[j] = SDL_JoystickGetAxis(joy, j) * (1.0f / 32767.0f);
743                 numbuttons = SDL_JoystickNumButtons(joy);
744                 for (j = 0;j < numbuttons;j++)
745                         joystate->button[j] = SDL_JoystickGetButton(joy, j);
746         }
747
748         VID_Shared_BuildJoyState_Finish(joystate);
749 }
750
751 // clear every touch screen area, except the one with button[skip]
752 #define Vid_ClearAllTouchscreenAreas(skip) \
753         if (skip != 0) \
754                 VID_TouchscreenCursor(0, 0, 0, 0, &buttons[0], K_MOUSE1); \
755         if (skip != 1) \
756                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, move, &buttons[1], K_MOUSE4, NULL, 0, 0, 0, false); \
757         if (skip != 2) \
758                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, aim,  &buttons[2], K_MOUSE5, NULL, 0, 0, 0, false); \
759         if (skip != 3) \
760                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[3], K_SHIFT, NULL, 0, 0, 0, false); \
761         if (skip != 4) \
762                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[4], K_MOUSE2, NULL, 0, 0, 0, false); \
763         if (skip != 9) \
764                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[9], K_MOUSE3, NULL, 0, 0, 0, false); \
765         if (skip != 10) \
766                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[10], (keynum_t)'m', NULL, 0, 0, 0, false); \
767         if (skip != 11) \
768                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[11], (keynum_t)'b', NULL, 0, 0, 0, false); \
769         if (skip != 12) \
770                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[12], (keynum_t)'q', NULL, 0, 0, 0, false); \
771         if (skip != 13) \
772                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[13], (keynum_t)'`', NULL, 0, 0, 0, false); \
773         if (skip != 14) \
774                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[14], K_ESCAPE, NULL, 0, 0, 0, false); \
775         if (skip != 15) \
776                 VID_TouchscreenArea( 0,  0,  0,  0,  0, NULL                         , 0.0f, NULL, NULL, &buttons[15], K_SPACE, NULL, 0, 0, 0, false); \
777
778 /////////////////////
779 // Movement handling
780 ////
781
782 static void IN_Move_TouchScreen_SteelStorm(void)
783 {
784         // ELUAN
785         int i, numfingers;
786         float xscale, yscale;
787         float move[3], aim[3];
788         static qboolean oldbuttons[128];
789         static qboolean buttons[128];
790         static keydest_t oldkeydest;
791         keydest_t keydest = (key_consoleactive & KEY_CONSOLEACTIVE_USER) ? key_console : key_dest;
792         memcpy(oldbuttons, buttons, sizeof(oldbuttons));
793         memset(multitouchs, 0, sizeof(multitouchs));
794
795         for (i = 0, numfingers = 0; i < MAXFINGERS - 1; i++)
796                 if (multitouch[i][0])
797                         numfingers++;
798
799         /*
800         Enable this to use a mouse as a touch device (it may conflict with the iamexclusive parameter if a finger is also reported as a mouse at the same location
801         if (numfingers == 1)
802         {
803                 multitouch[MAXFINGERS-1][0] = SDL_GetMouseState(&x, &y) ? 11 : 0;
804                 multitouch[MAXFINGERS-1][1] = (float)x / vid.width;
805                 multitouch[MAXFINGERS-1][2] = (float)y / vid.height;
806         }
807         else
808         {
809                 // disable it so it doesn't get stuck, because SDL seems to stop updating it if there are more than 1 finger on screen
810                 multitouch[MAXFINGERS-1][0] = 0;
811         }*/
812
813         if (oldkeydest != keydest)
814         {
815                 switch(keydest)
816                 {
817                 case key_game: VID_ShowKeyboard(false);break;
818                 case key_console: VID_ShowKeyboard(true);break;
819                 case key_message: VID_ShowKeyboard(true);break;
820                 default: break; /* qc extensions control the other cases */
821                 }
822         }
823         oldkeydest = keydest;
824         // TODO: make touchscreen areas controlled by a config file or the VMs. THIS IS A MESS!
825         // TODO: can't just clear buttons[] when entering a new keydest, some keys would remain pressed
826         // SS:BR menuqc has many peculiarities, including that it can't accept more than one command per frame and pressing and releasing on the same frame
827
828         // Tuned for the SGS3, use it's value as a base. CLEAN THIS.
829         xscale = vid_touchscreen_density.value / 2.0f;
830         yscale = vid_touchscreen_density.value / 2.0f;
831         switch(keydest)
832         {
833         case key_console:
834                 Vid_ClearAllTouchscreenAreas(14);
835                 VID_TouchscreenArea( 0,   0, 160,  64,  64, "gfx/gui/touch_menu_button.tga"         , 0.0f, NULL, NULL, &buttons[14], K_ESCAPE, NULL, 0, 0, 0, false);
836                 break;
837         case key_game:
838                 if (steelstorm_showing_map && steelstorm_showing_map->integer) // FIXME: another hack to be removed when touchscreen areas go to QC
839                 {
840                         VID_TouchscreenArea( 0,   0,   0, vid_conwidth.value, vid_conheight.value, NULL                         , 0.0f, NULL, NULL, &buttons[10], (keynum_t)'m', NULL, 0, 0, 0, false);
841                         Vid_ClearAllTouchscreenAreas(10);
842                 }
843                 else if (steelstorm_showing_mousecursor && steelstorm_showing_mousecursor->integer)
844                 {
845                         // in_windowmouse_x* is in screen resolution coordinates, not console resolution
846                         VID_TouchscreenCursor((float)in_windowmouse_x/vid_width.value*vid_conwidth.value, (float)in_windowmouse_y/vid_height.value*vid_conheight.value, 192*xscale, 192*yscale, &buttons[0], K_MOUSE1);
847                         Vid_ClearAllTouchscreenAreas(0);
848                 }
849                 else
850                 {
851                         VID_TouchscreenCursor(0, 0, 0, 0, &buttons[0], K_MOUSE1);
852
853                         VID_TouchscreenArea( 2,16*xscale,-240*yscale, 224*xscale, 224*yscale, "gfx/gui/touch_l_thumb_dpad.tga", 0.0f, NULL, move, &buttons[1], (keynum_t)0, NULL, 0.15, 112*xscale, 112*yscale, false);
854
855                         VID_TouchscreenArea( 3,-240*xscale,-160*yscale, 224*xscale, 128*yscale, "gfx/gui/touch_r_thumb_turn_n_shoot.tga"    , 0.0f, NULL, NULL,  0, (keynum_t)0, NULL, 0, 56*xscale, 0, false);
856                         VID_TouchscreenArea( 3,-240*xscale,-256*yscale, 224*xscale, 224*yscale, NULL    , 0.0f, NULL, aim,  &buttons[2], (keynum_t)0, NULL, 0.2, 56*xscale, 0, false);
857
858                         VID_TouchscreenArea( 2, (vid_conwidth.value / 2) - 128,-80,  256,  80, NULL, 0.0f, NULL, NULL, &buttons[3], K_SHIFT, NULL, 0, 0, 0, true);
859
860                         VID_TouchscreenArea( 3,-240*xscale,-256*yscale, 224*xscale,  64*yscale, "gfx/gui/touch_secondary_slide.tga", 0.0f, NULL, NULL, &buttons[4], K_MOUSE2, NULL, 0, 56*xscale, 0, false);
861                         VID_TouchscreenArea( 3,-240*xscale,-256*yscale, 224*xscale,  160*yscale, NULL , 0.0f, NULL, NULL, &buttons[9], K_MOUSE3, NULL, 0.2, 56*xscale, 0, false);
862
863                         VID_TouchscreenArea( 1,-100,   0, 100, 100, NULL                         , 0.0f, NULL, NULL, &buttons[10], (keynum_t)'m', NULL, 0, 0, 0, true);
864                         VID_TouchscreenArea( 1,-100, 120, 100, 100, NULL                         , 0.0f, NULL, NULL, &buttons[11], (keynum_t)'b', NULL, 0, 0, 0, true);
865                         VID_TouchscreenArea( 0,   0,   0,  64,  64, NULL                         , 0.0f, NULL, NULL, &buttons[12], (keynum_t)'q', NULL, 0, 0, 0, true);
866                         if (developer.integer)
867                                 VID_TouchscreenArea( 0,   0,  96,  64,  64, NULL                         , 0.0f, NULL, NULL, &buttons[13], (keynum_t)'`', NULL, 0, 0, 0, true);
868                         else
869                                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[13], (keynum_t)'`', NULL, 0, 0, 0, false);
870                         VID_TouchscreenArea( 0,   0, 160,  64,  64, "gfx/gui/touch_menu_button.tga"         , 0.0f, NULL, NULL, &buttons[14], K_ESCAPE, NULL, 0, 0, 0, true);
871                         switch(cl.activeweapon)
872                         {
873                         case 14:
874                                 VID_TouchscreenArea( 2,  16*xscale,-320*yscale, 224*xscale, 64*yscale, "gfx/gui/touch_booster.tga" , 0.0f, NULL, NULL, &buttons[15], K_SPACE, NULL, 0, 0, 0, true);
875                                 break;
876                         case 12:
877                                 VID_TouchscreenArea( 2,  16*xscale,-320*yscale, 224*xscale, 64*yscale, "gfx/gui/touch_shockwave.tga" , 0.0f, NULL, NULL, &buttons[15], K_SPACE, NULL, 0, 0, 0, true);
878                                 break;
879                         default:
880                                 VID_TouchscreenArea( 0,  0,  0,  0,  0, NULL , 0.0f, NULL, NULL, &buttons[15], K_SPACE, NULL, 0, 0, 0, false);
881                         }
882                 }
883                 break;
884         default:
885                 if (!steelstorm_showing_mousecursor || !steelstorm_showing_mousecursor->integer)
886                 {
887                         Vid_ClearAllTouchscreenAreas(14);
888                         // this way we can skip cutscenes
889                         VID_TouchscreenArea( 0,   0,   0, vid_conwidth.value, vid_conheight.value, NULL                         , 0.0f, NULL, NULL, &buttons[14], K_ESCAPE, NULL, 0, 0, 0, false);
890                 }
891                 else
892                 {
893                         // in_windowmouse_x* is in screen resolution coordinates, not console resolution
894                         VID_TouchscreenCursor((float)in_windowmouse_x/vid_width.value*vid_conwidth.value, (float)in_windowmouse_y/vid_height.value*vid_conheight.value, 192*xscale, 192*yscale, &buttons[0], K_MOUSE1);
895                         Vid_ClearAllTouchscreenAreas(0);
896                 }
897                 break;
898         }
899
900         if (VID_ShowingKeyboard() && (float)in_windowmouse_y > vid_height.value / 2 - 10)
901                 in_windowmouse_y = 128;
902
903         cl.cmd.forwardmove -= move[1] * cl_forwardspeed.value;
904         cl.cmd.sidemove += move[0] * cl_sidespeed.value;
905         cl.viewangles[0] += aim[1] * cl_pitchspeed.value * cl.realframetime;
906         cl.viewangles[1] -= aim[0] * cl_yawspeed.value * cl.realframetime;
907 }
908
909 static void IN_Move_TouchScreen_Quake(void)
910 {
911         int x, y;
912         float move[3], aim[3], click[3];
913         static qboolean oldbuttons[128];
914         static qboolean buttons[128];
915         keydest_t keydest = (key_consoleactive & KEY_CONSOLEACTIVE_USER) ? key_console : key_dest;
916         memcpy(oldbuttons, buttons, sizeof(oldbuttons));
917         memset(multitouchs, 0, sizeof(multitouchs));
918
919         // simple quake controls
920         multitouch[MAXFINGERS-1][0] = SDL_GetMouseState(&x, &y);
921         multitouch[MAXFINGERS-1][1] = x * 32768 / vid.width;
922         multitouch[MAXFINGERS-1][2] = y * 32768 / vid.height;
923
924         // top of screen is toggleconsole and K_ESCAPE
925         switch(keydest)
926         {
927         case key_console:
928                 VID_TouchscreenArea( 0,   0,   0,  64,  64, NULL                         , 0.0f, NULL, NULL, &buttons[13], (keynum_t)'`', NULL, 0, 0, 0, true);
929                 VID_TouchscreenArea( 0,  64,   0,  64,  64, "gfx/touch_menu.tga"         , 0.0f, NULL, NULL, &buttons[14], K_ESCAPE, NULL, 0, 0, 0, true);
930                 if (!VID_ShowingKeyboard())
931                 {
932                         // user entered a command, close the console now
933                         Con_ToggleConsole_f();
934                 }
935                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[15], (keynum_t)0, NULL, 0, 0, 0, true);
936                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, move, &buttons[0], K_MOUSE4, NULL, 0, 0, 0, true);
937                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, aim,  &buttons[1], K_MOUSE5, NULL, 0, 0, 0, true);
938                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, click,&buttons[2], K_MOUSE1, NULL, 0, 0, 0, true);
939                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[3], K_SPACE, NULL, 0, 0, 0, true);
940                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[4], K_MOUSE2, NULL, 0, 0, 0, true);
941                 break;
942         case key_game:
943                 VID_TouchscreenArea( 0,   0,   0,  64,  64, NULL                         , 0.0f, NULL, NULL, &buttons[13], (keynum_t)'`', NULL, 0, 0, 0, true);
944                 VID_TouchscreenArea( 0,  64,   0,  64,  64, "gfx/touch_menu.tga"         , 0.0f, NULL, NULL, &buttons[14], K_ESCAPE, NULL, 0, 0, 0, true);
945                 VID_TouchscreenArea( 2,   0,-128, 128, 128, "gfx/touch_movebutton.tga"   , 0.0f, NULL, move, &buttons[0], K_MOUSE4, NULL, 0, 0, 0, true);
946                 VID_TouchscreenArea( 3,-128,-128, 128, 128, "gfx/touch_aimbutton.tga"    , 0.0f, NULL, aim,  &buttons[1], K_MOUSE5, NULL, 0, 0, 0, true);
947                 VID_TouchscreenArea( 2,   0,-160,  64,  32, "gfx/touch_jumpbutton.tga"   , 0.0f, NULL, NULL, &buttons[3], K_SPACE, NULL, 0, 0, 0, true);
948                 VID_TouchscreenArea( 3,-128,-160,  64,  32, "gfx/touch_attackbutton.tga" , 0.0f, NULL, NULL, &buttons[2], K_MOUSE1, NULL, 0, 0, 0, true);
949                 VID_TouchscreenArea( 3, -64,-160,  64,  32, "gfx/touch_attack2button.tga", 0.0f, NULL, NULL, &buttons[4], K_MOUSE2, NULL, 0, 0, 0, true);
950                 buttons[15] = false;
951                 break;
952         default:
953                 VID_TouchscreenArea( 0,   0,   0,  64,  64, NULL                         , 0.0f, NULL, NULL, &buttons[13], (keynum_t)'`', NULL, 0, 0, 0, true);
954                 VID_TouchscreenArea( 0,  64,   0,  64,  64, "gfx/touch_menu.tga"         , 0.0f, NULL, NULL, &buttons[14], K_ESCAPE, NULL, 0, 0, 0, true);
955                 // in menus, an icon in the corner activates keyboard
956                 VID_TouchscreenArea( 2,   0, -32,  32,  32, "gfx/touch_keyboard.tga"     , 0.0f, NULL, NULL, &buttons[15], (keynum_t)0, NULL, 0, 0, 0, true);
957                 if (buttons[15])
958                         VID_ShowKeyboard(true);
959                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, move, &buttons[0], K_MOUSE4, NULL, 0, 0, 0, true);
960                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, aim,  &buttons[1], K_MOUSE5, NULL, 0, 0, 0, true);
961                 VID_TouchscreenArea(16, -320,-480,640, 960, NULL                         , 0.0f, NULL, click,&buttons[2], K_MOUSE1, NULL, 0, 0, 0, true);
962                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[3], K_SPACE, NULL, 0, 0, 0, true);
963                 VID_TouchscreenArea( 0,   0,   0,   0,   0, NULL                         , 0.0f, NULL, NULL, &buttons[4], K_MOUSE2, NULL, 0, 0, 0, true);
964                 if (buttons[2])
965                 {
966                         in_windowmouse_x = x;
967                         in_windowmouse_y = y;
968                 }
969                 break;
970         }
971
972         cl.cmd.forwardmove -= move[1] * cl_forwardspeed.value;
973         cl.cmd.sidemove += move[0] * cl_sidespeed.value;
974         cl.viewangles[0] += aim[1] * cl_pitchspeed.value * cl.realframetime;
975         cl.viewangles[1] -= aim[0] * cl_yawspeed.value * cl.realframetime;
976 }
977
978 void IN_Move( void )
979 {
980         static int old_x = 0, old_y = 0;
981         static int stuck = 0;
982         int x, y;
983         vid_joystate_t joystate;
984
985         scr_numtouchscreenareas = 0;
986
987         if (vid_touchscreen.integer)
988         {
989                 switch(gamemode)
990                 {
991                 case GAME_STEELSTORM:
992                         IN_Move_TouchScreen_SteelStorm();
993                         break;
994                 default:
995                         IN_Move_TouchScreen_Quake();
996                         break;
997                 }
998         }
999         else
1000         {
1001                 if (vid_usingmouse)
1002                 {
1003                         if (vid_stick_mouse.integer || !vid_usingmouse_relativeworks)
1004                         {
1005                                 // have the mouse stuck in the middle, example use: prevent expose effect of beryl during the game when not using
1006                                 // window grabbing. --blub
1007         
1008                                 // we need 2 frames to initialize the center position
1009                                 if(!stuck)
1010                                 {
1011 #if SDL_MAJOR_VERSION == 1
1012                                         SDL_WarpMouse(win_half_width, win_half_height);
1013 #else
1014                                         SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
1015 #endif
1016                                         SDL_GetMouseState(&x, &y);
1017                                         SDL_GetRelativeMouseState(&x, &y);
1018                                         ++stuck;
1019                                 } else {
1020                                         SDL_GetRelativeMouseState(&x, &y);
1021                                         in_mouse_x = x + old_x;
1022                                         in_mouse_y = y + old_y;
1023                                         SDL_GetMouseState(&x, &y);
1024                                         old_x = x - win_half_width;
1025                                         old_y = y - win_half_height;
1026 #if SDL_MAJOR_VERSION == 1
1027                                         SDL_WarpMouse(win_half_width, win_half_height);
1028 #else
1029                                         SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
1030 #endif
1031                                 }
1032                         } else {
1033                                 SDL_GetRelativeMouseState( &x, &y );
1034                                 in_mouse_x = x;
1035                                 in_mouse_y = y;
1036                         }
1037                 }
1038
1039                 SDL_GetMouseState(&x, &y);
1040                 in_windowmouse_x = x;
1041                 in_windowmouse_y = y;
1042         }
1043
1044         VID_BuildJoyState(&joystate);
1045         VID_ApplyJoyState(&joystate);
1046 }
1047
1048 /////////////////////
1049 // Message Handling
1050 ////
1051
1052 #ifdef SDL_R_RESTART
1053 static qboolean sdl_needs_restart;
1054 static void sdl_start(void)
1055 {
1056 }
1057 static void sdl_shutdown(void)
1058 {
1059         sdl_needs_restart = false;
1060 }
1061 static void sdl_newmap(void)
1062 {
1063 }
1064 #endif
1065
1066 static keynum_t buttonremap[] =
1067 {
1068         K_MOUSE1,
1069         K_MOUSE3,
1070         K_MOUSE2,
1071 #if SDL_MAJOR_VERSION == 1
1072         // TODO Find out how SDL maps these buttons. It looks like we should
1073         // still include these for sdl2? At least the button indexes don't
1074         // differ between SDL1 and SDL2 for me, thus this array should stay the
1075         // same (in X11 button order).
1076         K_MWHEELUP,
1077         K_MWHEELDOWN,
1078 #endif
1079         K_MOUSE4,
1080         K_MOUSE5,
1081         K_MOUSE6,
1082         K_MOUSE7,
1083         K_MOUSE8,
1084         K_MOUSE9,
1085         K_MOUSE10,
1086         K_MOUSE11,
1087         K_MOUSE12,
1088         K_MOUSE13,
1089         K_MOUSE14,
1090         K_MOUSE15,
1091         K_MOUSE16,
1092 };
1093
1094 #if SDL_MAJOR_VERSION == 1
1095 // SDL
1096 void Sys_SendKeyEvents( void )
1097 {
1098         static qboolean sound_active = true;
1099         int keycode;
1100         SDL_Event event;
1101
1102         VID_EnableJoystick(true);
1103
1104         while( SDL_PollEvent( &event ) )
1105                 switch( event.type ) {
1106                         case SDL_QUIT:
1107                                 Sys_Quit(0);
1108                                 break;
1109                         case SDL_KEYDOWN:
1110                         case SDL_KEYUP:
1111                                 keycode = MapKey(event.key.keysym.sym);
1112                                 if (!VID_JoyBlockEmulatedKeys(keycode))
1113                                 {
1114                                         if(keycode == K_NUMLOCK || keycode == K_CAPSLOCK)
1115                                         {
1116                                                 // simulate down followed by up
1117                                                 Key_Event(keycode, event.key.keysym.unicode, true);
1118                                                 Key_Event(keycode, event.key.keysym.unicode, false);
1119                                                 break;
1120                                         }
1121                                         Key_Event(keycode, event.key.keysym.unicode, (event.key.state == SDL_PRESSED));
1122                                 }
1123                                 break;
1124                         case SDL_ACTIVEEVENT:
1125                                 if( event.active.state & SDL_APPACTIVE )
1126                                 {
1127                                         if( event.active.gain )
1128                                                 vid_hidden = false;
1129                                         else
1130                                                 vid_hidden = true;
1131                                 }
1132                                 break;
1133                         case SDL_MOUSEBUTTONDOWN:
1134                         case SDL_MOUSEBUTTONUP:
1135                                 if (!vid_touchscreen.integer)
1136                                 if (event.button.button > 0 && event.button.button <= ARRAY_SIZE(buttonremap))
1137                                         Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
1138                                 break;
1139                         case SDL_JOYBUTTONDOWN:
1140                         case SDL_JOYBUTTONUP:
1141                         case SDL_JOYAXISMOTION:
1142                         case SDL_JOYBALLMOTION:
1143                         case SDL_JOYHATMOTION:
1144                                 break;
1145                         case SDL_VIDEOEXPOSE:
1146                                 break;
1147                         case SDL_VIDEORESIZE:
1148                                 if(vid_resizable.integer < 2 || vid_isfullscreen)
1149                                 {
1150                                         vid.width = event.resize.w;
1151                                         vid.height = event.resize.h;
1152                                         if (!vid_isfullscreen)
1153                                                 screen = SDL_SetVideoMode(vid.width, vid.height, video_bpp, video_flags);
1154                                         if (vid_softsurface)
1155                                         {
1156                                                 SDL_FreeSurface(vid_softsurface);
1157                                                 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
1158                                                 SDL_SetAlpha(vid_softsurface, 0, 255);
1159                                                 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
1160                                                 if (vid.softdepthpixels)
1161                                                         free(vid.softdepthpixels);
1162                                                 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
1163                                         }
1164 #ifdef SDL_R_RESTART
1165                                         // better not call R_Modules_Restart from here directly, as this may wreak havoc...
1166                                         // so, let's better queue it for next frame
1167                                         if(!sdl_needs_restart)
1168                                         {
1169                                                 Cbuf_AddText("\nr_restart\n");
1170                                                 sdl_needs_restart = true;
1171                                         }
1172 #endif
1173                                 }
1174                                 break;
1175 #if SDL_MAJOR_VERSION != 1
1176                         case SDL_TEXTEDITING:
1177                                 break;
1178                         case SDL_TEXTINPUT:
1179                                 break;
1180 #endif
1181                         case SDL_MOUSEMOTION:
1182                                 break;
1183                         default:
1184                                 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
1185                                 break;
1186                 }
1187
1188         // enable/disable sound on focus gain/loss
1189         if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
1190         {
1191                 if (!sound_active)
1192                 {
1193                         S_UnblockSound ();
1194                         sound_active = true;
1195                 }
1196         }
1197         else
1198         {
1199                 if (sound_active)
1200                 {
1201                         S_BlockSound ();
1202                         sound_active = false;
1203                 }
1204         }
1205 }
1206
1207 #else
1208
1209 //#define DEBUGSDLEVENTS
1210
1211 // SDL2
1212 void Sys_SendKeyEvents( void )
1213 {
1214         static qboolean sound_active = true;
1215         int keycode;
1216         int i;
1217         Uchar unicode;
1218         SDL_Event event;
1219
1220         VID_EnableJoystick(true);
1221
1222         while( SDL_PollEvent( &event ) )
1223                 switch( event.type ) {
1224                         case SDL_QUIT:
1225 #ifdef DEBUGSDLEVENTS
1226                                 Con_DPrintf("SDL_Event: SDL_QUIT\n");
1227 #endif
1228                                 Sys_Quit(0);
1229                                 break;
1230                         case SDL_KEYDOWN:
1231                         case SDL_KEYUP:
1232 #ifdef DEBUGSDLEVENTS
1233                                 if (event.type == SDL_KEYDOWN)
1234                                         Con_DPrintf("SDL_Event: SDL_KEYDOWN %i\n", event.key.keysym.sym);
1235                                 else
1236                                         Con_DPrintf("SDL_Event: SDL_KEYUP %i\n", event.key.keysym.sym);
1237 #endif
1238                                 keycode = MapKey(event.key.keysym.sym);
1239                                 if (!VID_JoyBlockEmulatedKeys(keycode))
1240                                         Key_Event(keycode, 0, (event.key.state == SDL_PRESSED));
1241                                 break;
1242                         case SDL_MOUSEBUTTONDOWN:
1243                         case SDL_MOUSEBUTTONUP:
1244 #ifdef DEBUGSDLEVENTS
1245                                 if (event.type == SDL_MOUSEBUTTONDOWN)
1246                                         Con_DPrintf("SDL_Event: SDL_MOUSEBUTTONDOWN\n");
1247                                 else
1248                                         Con_DPrintf("SDL_Event: SDL_MOUSEBUTTONUP\n");
1249 #endif
1250                                 if (!vid_touchscreen.integer)
1251                                 if (event.button.button > 0 && event.button.button <= ARRAY_SIZE(buttonremap))
1252                                         Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
1253                                 break;
1254                         case SDL_MOUSEWHEEL:
1255                                 // TODO support wheel x direction.
1256                                 i = event.wheel.y;
1257                                 while (i > 0) {
1258                                         --i;
1259                                         Key_Event( K_MWHEELUP, 0, true );
1260                                         Key_Event( K_MWHEELUP, 0, false );
1261                                 }
1262                                 while (i < 0) {
1263                                         ++i;
1264                                         Key_Event( K_MWHEELDOWN, 0, true );
1265                                         Key_Event( K_MWHEELDOWN, 0, false );
1266                                 }
1267                                 break;
1268                         case SDL_JOYBUTTONDOWN:
1269                         case SDL_JOYBUTTONUP:
1270                         case SDL_JOYAXISMOTION:
1271                         case SDL_JOYBALLMOTION:
1272                         case SDL_JOYHATMOTION:
1273 #ifdef DEBUGSDLEVENTS
1274                                 Con_DPrintf("SDL_Event: SDL_JOY*\n");
1275 #endif
1276                                 break;
1277                         case SDL_WINDOWEVENT:
1278 #ifdef DEBUGSDLEVENTS
1279                                 Con_DPrintf("SDL_Event: SDL_WINDOWEVENT %i\n", (int)event.window.event);
1280 #endif
1281                                 //if (event.window.windowID == window) // how to compare?
1282                                 {
1283                                         switch(event.window.event)
1284                                         {
1285                                         case SDL_WINDOWEVENT_SHOWN:
1286                                                 vid_hidden = false;
1287                                                 break;
1288                                         case  SDL_WINDOWEVENT_HIDDEN:
1289                                                 vid_hidden = true;
1290                                                 break;
1291                                         case SDL_WINDOWEVENT_EXPOSED:
1292 #ifdef DEBUGSDLEVENTS
1293                                                 Con_DPrintf("SDL_Event: SDL_WINDOWEVENT_EXPOSED\n");
1294 #endif
1295                                                 break;
1296                                         case SDL_WINDOWEVENT_MOVED:
1297                                                 break;
1298                                         case SDL_WINDOWEVENT_RESIZED:
1299                                                 if(vid_resizable.integer < 2)
1300                                                 {
1301                                                         vid.width = event.window.data1;
1302                                                         vid.height = event.window.data2;
1303                                                         if (vid_softsurface)
1304                                                         {
1305                                                                 SDL_FreeSurface(vid_softsurface);
1306                                                                 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
1307                                                                 SDL_SetSurfaceBlendMode(vid_softsurface, SDL_BLENDMODE_NONE);
1308                                                                 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
1309                                                                 if (vid.softdepthpixels)
1310                                                                         free(vid.softdepthpixels);
1311                                                                 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
1312                                                         }
1313 #ifdef SDL_R_RESTART
1314                                                         // better not call R_Modules_Restart from here directly, as this may wreak havoc...
1315                                                         // so, let's better queue it for next frame
1316                                                         if(!sdl_needs_restart)
1317                                                         {
1318                                                                 Cbuf_AddText("\nr_restart\n");
1319                                                                 sdl_needs_restart = true;
1320                                                         }
1321 #endif
1322                                                 }
1323                                                 break;
1324                                         case SDL_WINDOWEVENT_MINIMIZED:
1325                                                 break;
1326                                         case SDL_WINDOWEVENT_MAXIMIZED:
1327                                                 break;
1328                                         case SDL_WINDOWEVENT_RESTORED:
1329                                                 break;
1330                                         case SDL_WINDOWEVENT_ENTER:
1331                                                 break;
1332                                         case SDL_WINDOWEVENT_LEAVE:
1333                                                 break;
1334                                         case SDL_WINDOWEVENT_FOCUS_GAINED:
1335                                                 vid_hasfocus = true;
1336                                                 break;
1337                                         case SDL_WINDOWEVENT_FOCUS_LOST:
1338                                                 vid_hasfocus = false;
1339                                                 break;
1340                                         case SDL_WINDOWEVENT_CLOSE:
1341                                                 Sys_Quit(0);
1342                                                 break;
1343                                         }
1344                                 }
1345                                 break;
1346                         case SDL_TEXTEDITING:
1347 #ifdef DEBUGSDLEVENTS
1348                                 Con_DPrintf("SDL_Event: SDL_TEXTEDITING - composition = %s, cursor = %d, selection lenght = %d\n", event.edit.text, event.edit.start, event.edit.length);
1349 #endif
1350                                 // FIXME!  this is where composition gets supported
1351                                 break;
1352                         case SDL_TEXTINPUT:
1353 #ifdef DEBUGSDLEVENTS
1354                                 Con_DPrintf("SDL_Event: SDL_TEXTINPUT - text: %s\n", event.text.text);
1355 #endif
1356                                 // convert utf8 string to char
1357                                 // NOTE: this code is supposed to run even if utf8enable is 0
1358                                 unicode = u8_getchar_utf8_enabled(event.text.text + (int)u8_bytelen(event.text.text, 0), NULL);
1359                                 Key_Event(K_TEXT, unicode, true);
1360                                 Key_Event(K_TEXT, unicode, false);
1361                                 break;
1362                         case SDL_MOUSEMOTION:
1363                                 break;
1364                         case SDL_FINGERDOWN:
1365 #ifdef DEBUGSDLEVENTS
1366                                 Con_DPrintf("SDL_FINGERDOWN for finger %i\n", (int)event.tfinger.fingerId);
1367 #endif
1368                                 for (i = 0;i < MAXFINGERS-1;i++)
1369                                 {
1370                                         if (!multitouch[i][0])
1371                                         {
1372                                                 multitouch[i][0] = event.tfinger.fingerId + 1;
1373                                                 multitouch[i][1] = event.tfinger.x;
1374                                                 multitouch[i][2] = event.tfinger.y;
1375                                                 // TODO: use event.tfinger.pressure?
1376                                                 break;
1377                                         }
1378                                 }
1379                                 if (i == MAXFINGERS-1)
1380                                         Con_DPrintf("Too many fingers at once!\n");
1381                                 break;
1382                         case SDL_FINGERUP:
1383 #ifdef DEBUGSDLEVENTS
1384                                 Con_DPrintf("SDL_FINGERUP for finger %i\n", (int)event.tfinger.fingerId);
1385 #endif
1386                                 for (i = 0;i < MAXFINGERS-1;i++)
1387                                 {
1388                                         if (multitouch[i][0] == event.tfinger.fingerId + 1)
1389                                         {
1390                                                 multitouch[i][0] = 0;
1391                                                 break;
1392                                         }
1393                                 }
1394                                 if (i == MAXFINGERS-1)
1395                                         Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1396                                 break;
1397                         case SDL_FINGERMOTION:
1398 #ifdef DEBUGSDLEVENTS
1399                                 Con_DPrintf("SDL_FINGERMOTION for finger %i\n", (int)event.tfinger.fingerId);
1400 #endif
1401                                 for (i = 0;i < MAXFINGERS-1;i++)
1402                                 {
1403                                         if (multitouch[i][0] == event.tfinger.fingerId + 1)
1404                                         {
1405                                                 multitouch[i][1] = event.tfinger.x;
1406                                                 multitouch[i][2] = event.tfinger.y;
1407                                                 break;
1408                                         }
1409                                 }
1410                                 if (i == MAXFINGERS-1)
1411                                         Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1412                                 break;
1413                         default:
1414 #ifdef DEBUGSDLEVENTS
1415                                 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
1416 #endif
1417                                 break;
1418                 }
1419
1420         // enable/disable sound on focus gain/loss
1421         if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
1422         {
1423                 if (!sound_active)
1424                 {
1425                         S_UnblockSound ();
1426                         sound_active = true;
1427                 }
1428         }
1429         else
1430         {
1431                 if (sound_active)
1432                 {
1433                         S_BlockSound ();
1434                         sound_active = false;
1435                 }
1436         }
1437 }
1438 #endif
1439
1440 /////////////////
1441 // Video system
1442 ////
1443
1444 #ifdef USE_GLES2
1445 #ifndef qglClear
1446 #ifdef __IPHONEOS__
1447 #include <OpenGLES/ES2/gl.h>
1448 #else
1449 #include <SDL_opengles.h>
1450 #endif
1451
1452 //#define PRECALL //Con_Printf("GLCALL %s:%i\n", __FILE__, __LINE__)
1453 #define PRECALL
1454 #define POSTCALL
1455 GLboolean wrapglIsBuffer(GLuint buffer) {PRECALL;return glIsBuffer(buffer);POSTCALL;}
1456 GLboolean wrapglIsEnabled(GLenum cap) {PRECALL;return glIsEnabled(cap);POSTCALL;}
1457 GLboolean wrapglIsFramebuffer(GLuint framebuffer) {PRECALL;return glIsFramebuffer(framebuffer);POSTCALL;}
1458 //GLboolean wrapglIsQuery(GLuint qid) {PRECALL;return glIsQuery(qid);POSTCALL;}
1459 GLboolean wrapglIsRenderbuffer(GLuint renderbuffer) {PRECALL;return glIsRenderbuffer(renderbuffer);POSTCALL;}
1460 //GLboolean wrapglUnmapBuffer(GLenum target) {PRECALL;return glUnmapBuffer(target);POSTCALL;}
1461 GLenum wrapglCheckFramebufferStatus(GLenum target) {PRECALL;return glCheckFramebufferStatus(target);POSTCALL;}
1462 GLenum wrapglGetError(void) {PRECALL;return glGetError();POSTCALL;}
1463 GLuint wrapglCreateProgram(void) {PRECALL;return glCreateProgram();POSTCALL;}
1464 GLuint wrapglCreateShader(GLenum shaderType) {PRECALL;return glCreateShader(shaderType);POSTCALL;}
1465 //GLuint wrapglGetHandle(GLenum pname) {PRECALL;return glGetHandle(pname);POSTCALL;}
1466 GLint wrapglGetAttribLocation(GLuint programObj, const GLchar *name) {PRECALL;return glGetAttribLocation(programObj, name);POSTCALL;}
1467 GLint wrapglGetUniformLocation(GLuint programObj, const GLchar *name) {PRECALL;return glGetUniformLocation(programObj, name);POSTCALL;}
1468 //GLvoid* wrapglMapBuffer(GLenum target, GLenum access) {PRECALL;return glMapBuffer(target, access);POSTCALL;}
1469 const GLubyte* wrapglGetString(GLenum name) {PRECALL;return (const GLubyte*)glGetString(name);POSTCALL;}
1470 void wrapglActiveStencilFace(GLenum e) {PRECALL;Con_Printf("glActiveStencilFace(e)\n");POSTCALL;}
1471 void wrapglActiveTexture(GLenum e) {PRECALL;glActiveTexture(e);POSTCALL;}
1472 void wrapglAlphaFunc(GLenum func, GLclampf ref) {PRECALL;Con_Printf("glAlphaFunc(func, ref)\n");POSTCALL;}
1473 void wrapglArrayElement(GLint i) {PRECALL;Con_Printf("glArrayElement(i)\n");POSTCALL;}
1474 void wrapglAttachShader(GLuint containerObj, GLuint obj) {PRECALL;glAttachShader(containerObj, obj);POSTCALL;}
1475 //void wrapglBegin(GLenum mode) {PRECALL;Con_Printf("glBegin(mode)\n");POSTCALL;}
1476 //void wrapglBeginQuery(GLenum target, GLuint qid) {PRECALL;glBeginQuery(target, qid);POSTCALL;}
1477 void wrapglBindAttribLocation(GLuint programObj, GLuint index, const GLchar *name) {PRECALL;glBindAttribLocation(programObj, index, name);POSTCALL;}
1478 //void wrapglBindFragDataLocation(GLuint programObj, GLuint index, const GLchar *name) {PRECALL;glBindFragDataLocation(programObj, index, name);POSTCALL;}
1479 void wrapglBindBuffer(GLenum target, GLuint buffer) {PRECALL;glBindBuffer(target, buffer);POSTCALL;}
1480 void wrapglBindFramebuffer(GLenum target, GLuint framebuffer) {PRECALL;glBindFramebuffer(target, framebuffer);POSTCALL;}
1481 void wrapglBindRenderbuffer(GLenum target, GLuint renderbuffer) {PRECALL;glBindRenderbuffer(target, renderbuffer);POSTCALL;}
1482 void wrapglBindTexture(GLenum target, GLuint texture) {PRECALL;glBindTexture(target, texture);POSTCALL;}
1483 void wrapglBlendEquation(GLenum e) {PRECALL;glBlendEquation(e);POSTCALL;}
1484 void wrapglBlendFunc(GLenum sfactor, GLenum dfactor) {PRECALL;glBlendFunc(sfactor, dfactor);POSTCALL;}
1485 void wrapglBufferData(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage) {PRECALL;glBufferData(target, size, data, usage);POSTCALL;}
1486 void wrapglBufferSubData(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data) {PRECALL;glBufferSubData(target, offset, size, data);POSTCALL;}
1487 void wrapglClear(GLbitfield mask) {PRECALL;glClear(mask);POSTCALL;}
1488 void wrapglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {PRECALL;glClearColor(red, green, blue, alpha);POSTCALL;}
1489 void wrapglClearDepth(GLclampd depth) {PRECALL;/*Con_Printf("glClearDepth(%f)\n", depth);glClearDepthf((float)depth);*/POSTCALL;}
1490 void wrapglClearStencil(GLint s) {PRECALL;glClearStencil(s);POSTCALL;}
1491 void wrapglClientActiveTexture(GLenum target) {PRECALL;Con_Printf("glClientActiveTexture(target)\n");POSTCALL;}
1492 void wrapglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {PRECALL;Con_Printf("glColor4f(red, green, blue, alpha)\n");POSTCALL;}
1493 void wrapglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {PRECALL;Con_Printf("glColor4ub(red, green, blue, alpha)\n");POSTCALL;}
1494 void wrapglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {PRECALL;glColorMask(red, green, blue, alpha);POSTCALL;}
1495 void wrapglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glColorPointer(size, type, stride, ptr)\n");POSTCALL;}
1496 void wrapglCompileShader(GLuint shaderObj) {PRECALL;glCompileShader(shaderObj);POSTCALL;}
1497 void wrapglCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border,  GLsizei imageSize, const void *data) {PRECALL;glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);POSTCALL;}
1498 void wrapglCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) {PRECALL;Con_Printf("glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data)\n");POSTCALL;}
1499 void wrapglCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) {PRECALL;glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);POSTCALL;}
1500 void wrapglCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) {PRECALL;Con_Printf("glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)\n");POSTCALL;}
1501 void wrapglCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {PRECALL;glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);POSTCALL;}
1502 void wrapglCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);POSTCALL;}
1503 void wrapglCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;Con_Printf("glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)\n");POSTCALL;}
1504 void wrapglCullFace(GLenum mode) {PRECALL;glCullFace(mode);POSTCALL;}
1505 void wrapglDeleteBuffers(GLsizei n, const GLuint *buffers) {PRECALL;glDeleteBuffers(n, buffers);POSTCALL;}
1506 void wrapglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {PRECALL;glDeleteFramebuffers(n, framebuffers);POSTCALL;}
1507 void wrapglDeleteShader(GLuint obj) {PRECALL;glDeleteShader(obj);POSTCALL;}
1508 void wrapglDeleteProgram(GLuint obj) {PRECALL;glDeleteProgram(obj);POSTCALL;}
1509 //void wrapglDeleteQueries(GLsizei n, const GLuint *ids) {PRECALL;glDeleteQueries(n, ids);POSTCALL;}
1510 void wrapglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {PRECALL;glDeleteRenderbuffers(n, renderbuffers);POSTCALL;}
1511 void wrapglDeleteTextures(GLsizei n, const GLuint *textures) {PRECALL;glDeleteTextures(n, textures);POSTCALL;}
1512 void wrapglDepthFunc(GLenum func) {PRECALL;glDepthFunc(func);POSTCALL;}
1513 void wrapglDepthMask(GLboolean flag) {PRECALL;glDepthMask(flag);POSTCALL;}
1514 //void wrapglDepthRange(GLclampd near_val, GLclampd far_val) {PRECALL;glDepthRangef((float)near_val, (float)far_val);POSTCALL;}
1515 void wrapglDepthRangef(GLclampf near_val, GLclampf far_val) {PRECALL;glDepthRangef(near_val, far_val);POSTCALL;}
1516 void wrapglDetachShader(GLuint containerObj, GLuint attachedObj) {PRECALL;glDetachShader(containerObj, attachedObj);POSTCALL;}
1517 void wrapglDisable(GLenum cap) {PRECALL;glDisable(cap);POSTCALL;}
1518 void wrapglDisableClientState(GLenum cap) {PRECALL;Con_Printf("glDisableClientState(cap)\n");POSTCALL;}
1519 void wrapglDisableVertexAttribArray(GLuint index) {PRECALL;glDisableVertexAttribArray(index);POSTCALL;}
1520 void wrapglDrawArrays(GLenum mode, GLint first, GLsizei count) {PRECALL;glDrawArrays(mode, first, count);POSTCALL;}
1521 void wrapglDrawBuffer(GLenum mode) {PRECALL;Con_Printf("glDrawBuffer(mode)\n");POSTCALL;}
1522 void wrapglDrawBuffers(GLsizei n, const GLenum *bufs) {PRECALL;Con_Printf("glDrawBuffers(n, bufs)\n");POSTCALL;}
1523 void wrapglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawElements(mode, count, type, indices);POSTCALL;}
1524 //void wrapglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawRangeElements(mode, start, end, count, type, indices);POSTCALL;}
1525 //void wrapglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawRangeElements(mode, start, end, count, type, indices);POSTCALL;}
1526 void wrapglEnable(GLenum cap) {PRECALL;glEnable(cap);POSTCALL;}
1527 void wrapglEnableClientState(GLenum cap) {PRECALL;Con_Printf("glEnableClientState(cap)\n");POSTCALL;}
1528 void wrapglEnableVertexAttribArray(GLuint index) {PRECALL;glEnableVertexAttribArray(index);POSTCALL;}
1529 //void wrapglEnd(void) {PRECALL;Con_Printf("glEnd()\n");POSTCALL;}
1530 //void wrapglEndQuery(GLenum target) {PRECALL;glEndQuery(target);POSTCALL;}
1531 void wrapglFinish(void) {PRECALL;glFinish();POSTCALL;}
1532 void wrapglFlush(void) {PRECALL;glFlush();POSTCALL;}
1533 void wrapglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {PRECALL;glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);POSTCALL;}
1534 void wrapglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {PRECALL;glFramebufferTexture2D(target, attachment, textarget, texture, level);POSTCALL;}
1535 void wrapglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {PRECALL;Con_Printf("glFramebufferTexture3D()\n");POSTCALL;}
1536 void wrapglGenBuffers(GLsizei n, GLuint *buffers) {PRECALL;glGenBuffers(n, buffers);POSTCALL;}
1537 void wrapglGenFramebuffers(GLsizei n, GLuint *framebuffers) {PRECALL;glGenFramebuffers(n, framebuffers);POSTCALL;}
1538 //void wrapglGenQueries(GLsizei n, GLuint *ids) {PRECALL;glGenQueries(n, ids);POSTCALL;}
1539 void wrapglGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {PRECALL;glGenRenderbuffers(n, renderbuffers);POSTCALL;}
1540 void wrapglGenTextures(GLsizei n, GLuint *textures) {PRECALL;glGenTextures(n, textures);POSTCALL;}
1541 void wrapglGenerateMipmap(GLenum target) {PRECALL;glGenerateMipmap(target);POSTCALL;}
1542 void wrapglGetActiveAttrib(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {PRECALL;glGetActiveAttrib(programObj, index, maxLength, length, size, type, name);POSTCALL;}
1543 void wrapglGetActiveUniform(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {PRECALL;glGetActiveUniform(programObj, index, maxLength, length, size, type, name);POSTCALL;}
1544 void wrapglGetAttachedShaders(GLuint containerObj, GLsizei maxCount, GLsizei *count, GLuint *obj) {PRECALL;glGetAttachedShaders(containerObj, maxCount, count, obj);POSTCALL;}
1545 void wrapglGetBooleanv(GLenum pname, GLboolean *params) {PRECALL;glGetBooleanv(pname, params);POSTCALL;}
1546 void wrapglGetCompressedTexImage(GLenum target, GLint lod, void *img) {PRECALL;Con_Printf("glGetCompressedTexImage(target, lod, img)\n");POSTCALL;}
1547 void wrapglGetDoublev(GLenum pname, GLdouble *params) {PRECALL;Con_Printf("glGetDoublev(pname, params)\n");POSTCALL;}
1548 void wrapglGetFloatv(GLenum pname, GLfloat *params) {PRECALL;glGetFloatv(pname, params);POSTCALL;}
1549 void wrapglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) {PRECALL;glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);POSTCALL;}
1550 void wrapglGetShaderInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {PRECALL;glGetShaderInfoLog(obj, maxLength, length, infoLog);POSTCALL;}
1551 void wrapglGetProgramInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {PRECALL;glGetProgramInfoLog(obj, maxLength, length, infoLog);POSTCALL;}
1552 void wrapglGetIntegerv(GLenum pname, GLint *params) {PRECALL;glGetIntegerv(pname, params);POSTCALL;}
1553 void wrapglGetShaderiv(GLuint obj, GLenum pname, GLint *params) {PRECALL;glGetShaderiv(obj, pname, params);POSTCALL;}
1554 void wrapglGetProgramiv(GLuint obj, GLenum pname, GLint *params) {PRECALL;glGetProgramiv(obj, pname, params);POSTCALL;}
1555 //void wrapglGetQueryObjectiv(GLuint qid, GLenum pname, GLint *params) {PRECALL;glGetQueryObjectiv(qid, pname, params);POSTCALL;}
1556 //void wrapglGetQueryObjectuiv(GLuint qid, GLenum pname, GLuint *params) {PRECALL;glGetQueryObjectuiv(qid, pname, params);POSTCALL;}
1557 //void wrapglGetQueryiv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetQueryiv(target, pname, params);POSTCALL;}
1558 void wrapglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetRenderbufferParameteriv(target, pname, params);POSTCALL;}
1559 void wrapglGetShaderSource(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *source) {PRECALL;glGetShaderSource(obj, maxLength, length, source);POSTCALL;}
1560 void wrapglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {PRECALL;Con_Printf("glGetTexImage(target, level, format, type, pixels)\n");POSTCALL;}
1561 void wrapglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {PRECALL;Con_Printf("glGetTexLevelParameterfv(target, level, pname, params)\n");POSTCALL;}
1562 void wrapglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {PRECALL;Con_Printf("glGetTexLevelParameteriv(target, level, pname, params)\n");POSTCALL;}
1563 void wrapglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {PRECALL;glGetTexParameterfv(target, pname, params);POSTCALL;}
1564 void wrapglGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetTexParameteriv(target, pname, params);POSTCALL;}
1565 void wrapglGetUniformfv(GLuint programObj, GLint location, GLfloat *params) {PRECALL;glGetUniformfv(programObj, location, params);POSTCALL;}
1566 void wrapglGetUniformiv(GLuint programObj, GLint location, GLint *params) {PRECALL;glGetUniformiv(programObj, location, params);POSTCALL;}
1567 void wrapglHint(GLenum target, GLenum mode) {PRECALL;glHint(target, mode);POSTCALL;}
1568 void wrapglLineWidth(GLfloat width) {PRECALL;glLineWidth(width);POSTCALL;}
1569 void wrapglLinkProgram(GLuint programObj) {PRECALL;glLinkProgram(programObj);POSTCALL;}
1570 void wrapglLoadIdentity(void) {PRECALL;Con_Printf("glLoadIdentity()\n");POSTCALL;}
1571 void wrapglLoadMatrixf(const GLfloat *m) {PRECALL;Con_Printf("glLoadMatrixf(m)\n");POSTCALL;}
1572 void wrapglMatrixMode(GLenum mode) {PRECALL;Con_Printf("glMatrixMode(mode)\n");POSTCALL;}
1573 void wrapglMultiTexCoord1f(GLenum target, GLfloat s) {PRECALL;Con_Printf("glMultiTexCoord1f(target, s)\n");POSTCALL;}
1574 void wrapglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {PRECALL;Con_Printf("glMultiTexCoord2f(target, s, t)\n");POSTCALL;}
1575 void wrapglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {PRECALL;Con_Printf("glMultiTexCoord3f(target, s, t, r)\n");POSTCALL;}
1576 void wrapglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {PRECALL;Con_Printf("glMultiTexCoord4f(target, s, t, r, q)\n");POSTCALL;}
1577 void wrapglNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glNormalPointer(type, stride, ptr)\n");POSTCALL;}
1578 void wrapglPixelStorei(GLenum pname, GLint param) {PRECALL;glPixelStorei(pname, param);POSTCALL;}
1579 void wrapglPointSize(GLfloat size) {PRECALL;Con_Printf("glPointSize(size)\n");POSTCALL;}
1580 //void wrapglPolygonMode(GLenum face, GLenum mode) {PRECALL;Con_Printf("glPolygonMode(face, mode)\n");POSTCALL;}
1581 void wrapglPolygonOffset(GLfloat factor, GLfloat units) {PRECALL;glPolygonOffset(factor, units);POSTCALL;}
1582 void wrapglPolygonStipple(const GLubyte *mask) {PRECALL;Con_Printf("glPolygonStipple(mask)\n");POSTCALL;}
1583 void wrapglReadBuffer(GLenum mode) {PRECALL;Con_Printf("glReadBuffer(mode)\n");POSTCALL;}
1584 void wrapglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {PRECALL;glReadPixels(x, y, width, height, format, type, pixels);POSTCALL;}
1585 void wrapglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {PRECALL;glRenderbufferStorage(target, internalformat, width, height);POSTCALL;}
1586 void wrapglScissor(GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;glScissor(x, y, width, height);POSTCALL;}
1587 void wrapglShaderSource(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length) {PRECALL;glShaderSource(shaderObj, count, string, length);POSTCALL;}
1588 void wrapglStencilFunc(GLenum func, GLint ref, GLuint mask) {PRECALL;glStencilFunc(func, ref, mask);POSTCALL;}
1589 void wrapglStencilFuncSeparate(GLenum func1, GLenum func2, GLint ref, GLuint mask) {PRECALL;Con_Printf("glStencilFuncSeparate(func1, func2, ref, mask)\n");POSTCALL;}
1590 void wrapglStencilMask(GLuint mask) {PRECALL;glStencilMask(mask);POSTCALL;}
1591 void wrapglStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {PRECALL;glStencilOp(fail, zfail, zpass);POSTCALL;}
1592 void wrapglStencilOpSeparate(GLenum e1, GLenum e2, GLenum e3, GLenum e4) {PRECALL;Con_Printf("glStencilOpSeparate(e1, e2, e3, e4)\n");POSTCALL;}
1593 void wrapglTexCoord1f(GLfloat s) {PRECALL;Con_Printf("glTexCoord1f(s)\n");POSTCALL;}
1594 void wrapglTexCoord2f(GLfloat s, GLfloat t) {PRECALL;Con_Printf("glTexCoord2f(s, t)\n");POSTCALL;}
1595 void wrapglTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {PRECALL;Con_Printf("glTexCoord3f(s, t, r)\n");POSTCALL;}
1596 void wrapglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {PRECALL;Con_Printf("glTexCoord4f(s, t, r, q)\n");POSTCALL;}
1597 void wrapglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glTexCoordPointer(size, type, stride, ptr)\n");POSTCALL;}
1598 void wrapglTexEnvf(GLenum target, GLenum pname, GLfloat param) {PRECALL;Con_Printf("glTexEnvf(target, pname, param)\n");POSTCALL;}
1599 void wrapglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {PRECALL;Con_Printf("glTexEnvfv(target, pname, params)\n");POSTCALL;}
1600 void wrapglTexEnvi(GLenum target, GLenum pname, GLint param) {PRECALL;Con_Printf("glTexEnvi(target, pname, param)\n");POSTCALL;}
1601 void wrapglTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {PRECALL;glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);POSTCALL;}
1602 void wrapglTexImage3D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {PRECALL;Con_Printf("glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels)\n");POSTCALL;}
1603 void wrapglTexParameterf(GLenum target, GLenum pname, GLfloat param) {PRECALL;glTexParameterf(target, pname, param);POSTCALL;}
1604 void wrapglTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {PRECALL;glTexParameterfv(target, pname, params);POSTCALL;}
1605 void wrapglTexParameteri(GLenum target, GLenum pname, GLint param) {PRECALL;glTexParameteri(target, pname, param);POSTCALL;}
1606 void wrapglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {PRECALL;glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);POSTCALL;}
1607 void wrapglTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) {PRECALL;Con_Printf("glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)\n");POSTCALL;}
1608 void wrapglUniform1f(GLint location, GLfloat v0) {PRECALL;glUniform1f(location, v0);POSTCALL;}
1609 void wrapglUniform1fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform1fv(location, count, value);POSTCALL;}
1610 void wrapglUniform1i(GLint location, GLint v0) {PRECALL;glUniform1i(location, v0);POSTCALL;}
1611 void wrapglUniform1iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform1iv(location, count, value);POSTCALL;}
1612 void wrapglUniform2f(GLint location, GLfloat v0, GLfloat v1) {PRECALL;glUniform2f(location, v0, v1);POSTCALL;}
1613 void wrapglUniform2fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform2fv(location, count, value);POSTCALL;}
1614 void wrapglUniform2i(GLint location, GLint v0, GLint v1) {PRECALL;glUniform2i(location, v0, v1);POSTCALL;}
1615 void wrapglUniform2iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform2iv(location, count, value);POSTCALL;}
1616 void wrapglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {PRECALL;glUniform3f(location, v0, v1, v2);POSTCALL;}
1617 void wrapglUniform3fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform3fv(location, count, value);POSTCALL;}
1618 void wrapglUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {PRECALL;glUniform3i(location, v0, v1, v2);POSTCALL;}
1619 void wrapglUniform3iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform3iv(location, count, value);POSTCALL;}
1620 void wrapglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {PRECALL;glUniform4f(location, v0, v1, v2, v3);POSTCALL;}
1621 void wrapglUniform4fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform4fv(location, count, value);POSTCALL;}
1622 void wrapglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {PRECALL;glUniform4i(location, v0, v1, v2, v3);POSTCALL;}
1623 void wrapglUniform4iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform4iv(location, count, value);POSTCALL;}
1624 void wrapglUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix2fv(location, count, transpose, value);POSTCALL;}
1625 void wrapglUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix3fv(location, count, transpose, value);POSTCALL;}
1626 void wrapglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix4fv(location, count, transpose, value);POSTCALL;}
1627 void wrapglUseProgram(GLuint programObj) {PRECALL;glUseProgram(programObj);POSTCALL;}
1628 void wrapglValidateProgram(GLuint programObj) {PRECALL;glValidateProgram(programObj);POSTCALL;}
1629 void wrapglVertex2f(GLfloat x, GLfloat y) {PRECALL;Con_Printf("glVertex2f(x, y)\n");POSTCALL;}
1630 void wrapglVertex3f(GLfloat x, GLfloat y, GLfloat z) {PRECALL;Con_Printf("glVertex3f(x, y, z)\n");POSTCALL;}
1631 void wrapglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {PRECALL;Con_Printf("glVertex4f(x, y, z, w)\n");POSTCALL;}
1632 void wrapglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {PRECALL;glVertexAttribPointer(index, size, type, normalized, stride, pointer);POSTCALL;}
1633 void wrapglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glVertexPointer(size, type, stride, ptr)\n");POSTCALL;}
1634 void wrapglViewport(GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;glViewport(x, y, width, height);POSTCALL;}
1635 void wrapglVertexAttrib1f(GLuint index, GLfloat v0) {PRECALL;glVertexAttrib1f(index, v0);POSTCALL;}
1636 //void wrapglVertexAttrib1s(GLuint index, GLshort v0) {PRECALL;glVertexAttrib1s(index, v0);POSTCALL;}
1637 //void wrapglVertexAttrib1d(GLuint index, GLdouble v0) {PRECALL;glVertexAttrib1d(index, v0);POSTCALL;}
1638 void wrapglVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {PRECALL;glVertexAttrib2f(index, v0, v1);POSTCALL;}
1639 //void wrapglVertexAttrib2s(GLuint index, GLshort v0, GLshort v1) {PRECALL;glVertexAttrib2s(index, v0, v1);POSTCALL;}
1640 //void wrapglVertexAttrib2d(GLuint index, GLdouble v0, GLdouble v1) {PRECALL;glVertexAttrib2d(index, v0, v1);POSTCALL;}
1641 void wrapglVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {PRECALL;glVertexAttrib3f(index, v0, v1, v2);POSTCALL;}
1642 //void wrapglVertexAttrib3s(GLuint index, GLshort v0, GLshort v1, GLshort v2) {PRECALL;glVertexAttrib3s(index, v0, v1, v2);POSTCALL;}
1643 //void wrapglVertexAttrib3d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2) {PRECALL;glVertexAttrib3d(index, v0, v1, v2);POSTCALL;}
1644 void wrapglVertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {PRECALL;glVertexAttrib4f(index, v0, v1, v2, v3);POSTCALL;}
1645 //void wrapglVertexAttrib4s(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3) {PRECALL;glVertexAttrib4s(index, v0, v1, v2, v3);POSTCALL;}
1646 //void wrapglVertexAttrib4d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {PRECALL;glVertexAttrib4d(index, v0, v1, v2, v3);POSTCALL;}
1647 //void wrapglVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {PRECALL;glVertexAttrib4Nub(index, x, y, z, w);POSTCALL;}
1648 void wrapglVertexAttrib1fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib1fv(index, v);POSTCALL;}
1649 //void wrapglVertexAttrib1sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib1sv(index, v);POSTCALL;}
1650 //void wrapglVertexAttrib1dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib1dv(index, v);POSTCALL;}
1651 void wrapglVertexAttrib2fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib2fv(index, v);POSTCALL;}
1652 //void wrapglVertexAttrib2sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib2sv(index, v);POSTCALL;}
1653 //void wrapglVertexAttrib2dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib2dv(index, v);POSTCALL;}
1654 void wrapglVertexAttrib3fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib3fv(index, v);POSTCALL;}
1655 //void wrapglVertexAttrib3sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib3sv(index, v);POSTCALL;}
1656 //void wrapglVertexAttrib3dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib3dv(index, v);POSTCALL;}
1657 void wrapglVertexAttrib4fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib4fv(index, v);POSTCALL;}
1658 //void wrapglVertexAttrib4sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib4sv(index, v);POSTCALL;}
1659 //void wrapglVertexAttrib4dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib4dv(index, v);POSTCALL;}
1660 //void wrapglVertexAttrib4iv(GLuint index, const GLint *v) {PRECALL;glVertexAttrib4iv(index, v);POSTCALL;}
1661 //void wrapglVertexAttrib4bv(GLuint index, const GLbyte *v) {PRECALL;glVertexAttrib4bv(index, v);POSTCALL;}
1662 //void wrapglVertexAttrib4ubv(GLuint index, const GLubyte *v) {PRECALL;glVertexAttrib4ubv(index, v);POSTCALL;}
1663 //void wrapglVertexAttrib4usv(GLuint index, const GLushort *v) {PRECALL;glVertexAttrib4usv(index, GLushort v);POSTCALL;}
1664 //void wrapglVertexAttrib4uiv(GLuint index, const GLuint *v) {PRECALL;glVertexAttrib4uiv(index, v);POSTCALL;}
1665 //void wrapglVertexAttrib4Nbv(GLuint index, const GLbyte *v) {PRECALL;glVertexAttrib4Nbv(index, v);POSTCALL;}
1666 //void wrapglVertexAttrib4Nsv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib4Nsv(index, v);POSTCALL;}
1667 //void wrapglVertexAttrib4Niv(GLuint index, const GLint *v) {PRECALL;glVertexAttrib4Niv(index, v);POSTCALL;}
1668 //void wrapglVertexAttrib4Nubv(GLuint index, const GLubyte *v) {PRECALL;glVertexAttrib4Nubv(index, v);POSTCALL;}
1669 //void wrapglVertexAttrib4Nusv(GLuint index, const GLushort *v) {PRECALL;glVertexAttrib4Nusv(index, GLushort v);POSTCALL;}
1670 //void wrapglVertexAttrib4Nuiv(GLuint index, const GLuint *v) {PRECALL;glVertexAttrib4Nuiv(index, v);POSTCALL;}
1671 //void wrapglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {PRECALL;glGetVertexAttribdv(index, pname, params);POSTCALL;}
1672 void wrapglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {PRECALL;glGetVertexAttribfv(index, pname, params);POSTCALL;}
1673 void wrapglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {PRECALL;glGetVertexAttribiv(index, pname, params);POSTCALL;}
1674 void wrapglGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) {PRECALL;glGetVertexAttribPointerv(index, pname, pointer);POSTCALL;}
1675 #endif
1676
1677 #if SDL_MAJOR_VERSION == 1
1678 #define SDL_GL_ExtensionSupported(x) (strstr(gl_extensions, x) || strstr(gl_platformextensions, x))
1679 #endif
1680
1681 void GLES_Init(void)
1682 {
1683 #ifndef qglClear
1684         qglIsBufferARB = wrapglIsBuffer;
1685         qglIsEnabled = wrapglIsEnabled;
1686         qglIsFramebufferEXT = wrapglIsFramebuffer;
1687 //      qglIsQueryARB = wrapglIsQuery;
1688         qglIsRenderbufferEXT = wrapglIsRenderbuffer;
1689 //      qglUnmapBufferARB = wrapglUnmapBuffer;
1690         qglCheckFramebufferStatus = wrapglCheckFramebufferStatus;
1691         qglGetError = wrapglGetError;
1692         qglCreateProgram = wrapglCreateProgram;
1693         qglCreateShader = wrapglCreateShader;
1694 //      qglGetHandleARB = wrapglGetHandle;
1695         qglGetAttribLocation = wrapglGetAttribLocation;
1696         qglGetUniformLocation = wrapglGetUniformLocation;
1697 //      qglMapBufferARB = wrapglMapBuffer;
1698         qglGetString = wrapglGetString;
1699 //      qglActiveStencilFaceEXT = wrapglActiveStencilFace;
1700         qglActiveTexture = wrapglActiveTexture;
1701         qglAlphaFunc = wrapglAlphaFunc;
1702         qglArrayElement = wrapglArrayElement;
1703         qglAttachShader = wrapglAttachShader;
1704 //      qglBegin = wrapglBegin;
1705 //      qglBeginQueryARB = wrapglBeginQuery;
1706         qglBindAttribLocation = wrapglBindAttribLocation;
1707 //      qglBindFragDataLocation = wrapglBindFragDataLocation;
1708         qglBindBufferARB = wrapglBindBuffer;
1709         qglBindFramebuffer = wrapglBindFramebuffer;
1710         qglBindRenderbuffer = wrapglBindRenderbuffer;
1711         qglBindTexture = wrapglBindTexture;
1712         qglBlendEquationEXT = wrapglBlendEquation;
1713         qglBlendFunc = wrapglBlendFunc;
1714         qglBufferDataARB = wrapglBufferData;
1715         qglBufferSubDataARB = wrapglBufferSubData;
1716         qglClear = wrapglClear;
1717         qglClearColor = wrapglClearColor;
1718         qglClearDepth = wrapglClearDepth;
1719         qglClearStencil = wrapglClearStencil;
1720         qglClientActiveTexture = wrapglClientActiveTexture;
1721         qglColor4f = wrapglColor4f;
1722         qglColor4ub = wrapglColor4ub;
1723         qglColorMask = wrapglColorMask;
1724         qglColorPointer = wrapglColorPointer;
1725         qglCompileShader = wrapglCompileShader;
1726         qglCompressedTexImage2DARB = wrapglCompressedTexImage2D;
1727         qglCompressedTexImage3DARB = wrapglCompressedTexImage3D;
1728         qglCompressedTexSubImage2DARB = wrapglCompressedTexSubImage2D;
1729         qglCompressedTexSubImage3DARB = wrapglCompressedTexSubImage3D;
1730         qglCopyTexImage2D = wrapglCopyTexImage2D;
1731         qglCopyTexSubImage2D = wrapglCopyTexSubImage2D;
1732         qglCopyTexSubImage3D = wrapglCopyTexSubImage3D;
1733         qglCullFace = wrapglCullFace;
1734         qglDeleteBuffersARB = wrapglDeleteBuffers;
1735         qglDeleteFramebuffers = wrapglDeleteFramebuffers;
1736         qglDeleteProgram = wrapglDeleteProgram;
1737         qglDeleteShader = wrapglDeleteShader;
1738 //      qglDeleteQueriesARB = wrapglDeleteQueries;
1739         qglDeleteRenderbuffers = wrapglDeleteRenderbuffers;
1740         qglDeleteTextures = wrapglDeleteTextures;
1741         qglDepthFunc = wrapglDepthFunc;
1742         qglDepthMask = wrapglDepthMask;
1743         qglDepthRangef = wrapglDepthRangef;
1744         qglDetachShader = wrapglDetachShader;
1745         qglDisable = wrapglDisable;
1746         qglDisableClientState = wrapglDisableClientState;
1747         qglDisableVertexAttribArray = wrapglDisableVertexAttribArray;
1748         qglDrawArrays = wrapglDrawArrays;
1749 //      qglDrawBuffer = wrapglDrawBuffer;
1750 //      qglDrawBuffersARB = wrapglDrawBuffers;
1751         qglDrawElements = wrapglDrawElements;
1752 //      qglDrawRangeElements = wrapglDrawRangeElements;
1753         qglEnable = wrapglEnable;
1754         qglEnableClientState = wrapglEnableClientState;
1755         qglEnableVertexAttribArray = wrapglEnableVertexAttribArray;
1756 //      qglEnd = wrapglEnd;
1757 //      qglEndQueryARB = wrapglEndQuery;
1758         qglFinish = wrapglFinish;
1759         qglFlush = wrapglFlush;
1760         qglFramebufferRenderbufferEXT = wrapglFramebufferRenderbuffer;
1761         qglFramebufferTexture2DEXT = wrapglFramebufferTexture2D;
1762         qglFramebufferTexture3DEXT = wrapglFramebufferTexture3D;
1763         qglGenBuffersARB = wrapglGenBuffers;
1764         qglGenFramebuffers = wrapglGenFramebuffers;
1765 //      qglGenQueriesARB = wrapglGenQueries;
1766         qglGenRenderbuffers = wrapglGenRenderbuffers;
1767         qglGenTextures = wrapglGenTextures;
1768         qglGenerateMipmapEXT = wrapglGenerateMipmap;
1769         qglGetActiveAttrib = wrapglGetActiveAttrib;
1770         qglGetActiveUniform = wrapglGetActiveUniform;
1771         qglGetAttachedShaders = wrapglGetAttachedShaders;
1772         qglGetBooleanv = wrapglGetBooleanv;
1773 //      qglGetCompressedTexImageARB = wrapglGetCompressedTexImage;
1774         qglGetDoublev = wrapglGetDoublev;
1775         qglGetFloatv = wrapglGetFloatv;
1776         qglGetFramebufferAttachmentParameterivEXT = wrapglGetFramebufferAttachmentParameteriv;
1777         qglGetProgramInfoLog = wrapglGetProgramInfoLog;
1778         qglGetShaderInfoLog = wrapglGetShaderInfoLog;
1779         qglGetIntegerv = wrapglGetIntegerv;
1780         qglGetShaderiv = wrapglGetShaderiv;
1781         qglGetProgramiv = wrapglGetProgramiv;
1782 //      qglGetQueryObjectivARB = wrapglGetQueryObjectiv;
1783 //      qglGetQueryObjectuivARB = wrapglGetQueryObjectuiv;
1784 //      qglGetQueryivARB = wrapglGetQueryiv;
1785         qglGetRenderbufferParameterivEXT = wrapglGetRenderbufferParameteriv;
1786         qglGetShaderSource = wrapglGetShaderSource;
1787         qglGetTexImage = wrapglGetTexImage;
1788         qglGetTexLevelParameterfv = wrapglGetTexLevelParameterfv;
1789         qglGetTexLevelParameteriv = wrapglGetTexLevelParameteriv;
1790         qglGetTexParameterfv = wrapglGetTexParameterfv;
1791         qglGetTexParameteriv = wrapglGetTexParameteriv;
1792         qglGetUniformfv = wrapglGetUniformfv;
1793         qglGetUniformiv = wrapglGetUniformiv;
1794         qglHint = wrapglHint;
1795         qglLineWidth = wrapglLineWidth;
1796         qglLinkProgram = wrapglLinkProgram;
1797         qglLoadIdentity = wrapglLoadIdentity;
1798         qglLoadMatrixf = wrapglLoadMatrixf;
1799         qglMatrixMode = wrapglMatrixMode;
1800         qglMultiTexCoord1f = wrapglMultiTexCoord1f;
1801         qglMultiTexCoord2f = wrapglMultiTexCoord2f;
1802         qglMultiTexCoord3f = wrapglMultiTexCoord3f;
1803         qglMultiTexCoord4f = wrapglMultiTexCoord4f;
1804         qglNormalPointer = wrapglNormalPointer;
1805         qglPixelStorei = wrapglPixelStorei;
1806         qglPointSize = wrapglPointSize;
1807 //      qglPolygonMode = wrapglPolygonMode;
1808         qglPolygonOffset = wrapglPolygonOffset;
1809 //      qglPolygonStipple = wrapglPolygonStipple;
1810         qglReadBuffer = wrapglReadBuffer;
1811         qglReadPixels = wrapglReadPixels;
1812         qglRenderbufferStorage = wrapglRenderbufferStorage;
1813         qglScissor = wrapglScissor;
1814         qglShaderSource = wrapglShaderSource;
1815         qglStencilFunc = wrapglStencilFunc;
1816         qglStencilFuncSeparate = wrapglStencilFuncSeparate;
1817         qglStencilMask = wrapglStencilMask;
1818         qglStencilOp = wrapglStencilOp;
1819         qglStencilOpSeparate = wrapglStencilOpSeparate;
1820         qglTexCoord1f = wrapglTexCoord1f;
1821         qglTexCoord2f = wrapglTexCoord2f;
1822         qglTexCoord3f = wrapglTexCoord3f;
1823         qglTexCoord4f = wrapglTexCoord4f;
1824         qglTexCoordPointer = wrapglTexCoordPointer;
1825         qglTexEnvf = wrapglTexEnvf;
1826         qglTexEnvfv = wrapglTexEnvfv;
1827         qglTexEnvi = wrapglTexEnvi;
1828         qglTexImage2D = wrapglTexImage2D;
1829         qglTexImage3D = wrapglTexImage3D;
1830         qglTexParameterf = wrapglTexParameterf;
1831         qglTexParameterfv = wrapglTexParameterfv;
1832         qglTexParameteri = wrapglTexParameteri;
1833         qglTexSubImage2D = wrapglTexSubImage2D;
1834         qglTexSubImage3D = wrapglTexSubImage3D;
1835         qglUniform1f = wrapglUniform1f;
1836         qglUniform1fv = wrapglUniform1fv;
1837         qglUniform1i = wrapglUniform1i;
1838         qglUniform1iv = wrapglUniform1iv;
1839         qglUniform2f = wrapglUniform2f;
1840         qglUniform2fv = wrapglUniform2fv;
1841         qglUniform2i = wrapglUniform2i;
1842         qglUniform2iv = wrapglUniform2iv;
1843         qglUniform3f = wrapglUniform3f;
1844         qglUniform3fv = wrapglUniform3fv;
1845         qglUniform3i = wrapglUniform3i;
1846         qglUniform3iv = wrapglUniform3iv;
1847         qglUniform4f = wrapglUniform4f;
1848         qglUniform4fv = wrapglUniform4fv;
1849         qglUniform4i = wrapglUniform4i;
1850         qglUniform4iv = wrapglUniform4iv;
1851         qglUniformMatrix2fv = wrapglUniformMatrix2fv;
1852         qglUniformMatrix3fv = wrapglUniformMatrix3fv;
1853         qglUniformMatrix4fv = wrapglUniformMatrix4fv;
1854         qglUseProgram = wrapglUseProgram;
1855         qglValidateProgram = wrapglValidateProgram;
1856         qglVertex2f = wrapglVertex2f;
1857         qglVertex3f = wrapglVertex3f;
1858         qglVertex4f = wrapglVertex4f;
1859         qglVertexAttribPointer = wrapglVertexAttribPointer;
1860         qglVertexPointer = wrapglVertexPointer;
1861         qglViewport = wrapglViewport;
1862         qglVertexAttrib1f = wrapglVertexAttrib1f;
1863 //      qglVertexAttrib1s = wrapglVertexAttrib1s;
1864 //      qglVertexAttrib1d = wrapglVertexAttrib1d;
1865         qglVertexAttrib2f = wrapglVertexAttrib2f;
1866 //      qglVertexAttrib2s = wrapglVertexAttrib2s;
1867 //      qglVertexAttrib2d = wrapglVertexAttrib2d;
1868         qglVertexAttrib3f = wrapglVertexAttrib3f;
1869 //      qglVertexAttrib3s = wrapglVertexAttrib3s;
1870 //      qglVertexAttrib3d = wrapglVertexAttrib3d;
1871         qglVertexAttrib4f = wrapglVertexAttrib4f;
1872 //      qglVertexAttrib4s = wrapglVertexAttrib4s;
1873 //      qglVertexAttrib4d = wrapglVertexAttrib4d;
1874 //      qglVertexAttrib4Nub = wrapglVertexAttrib4Nub;
1875         qglVertexAttrib1fv = wrapglVertexAttrib1fv;
1876 //      qglVertexAttrib1sv = wrapglVertexAttrib1sv;
1877 //      qglVertexAttrib1dv = wrapglVertexAttrib1dv;
1878         qglVertexAttrib2fv = wrapglVertexAttrib2fv;
1879 //      qglVertexAttrib2sv = wrapglVertexAttrib2sv;
1880 //      qglVertexAttrib2dv = wrapglVertexAttrib2dv;
1881         qglVertexAttrib3fv = wrapglVertexAttrib3fv;
1882 //      qglVertexAttrib3sv = wrapglVertexAttrib3sv;
1883 //      qglVertexAttrib3dv = wrapglVertexAttrib3dv;
1884         qglVertexAttrib4fv = wrapglVertexAttrib4fv;
1885 //      qglVertexAttrib4sv = wrapglVertexAttrib4sv;
1886 //      qglVertexAttrib4dv = wrapglVertexAttrib4dv;
1887 //      qglVertexAttrib4iv = wrapglVertexAttrib4iv;
1888 //      qglVertexAttrib4bv = wrapglVertexAttrib4bv;
1889 //      qglVertexAttrib4ubv = wrapglVertexAttrib4ubv;
1890 //      qglVertexAttrib4usv = wrapglVertexAttrib4usv;
1891 //      qglVertexAttrib4uiv = wrapglVertexAttrib4uiv;
1892 //      qglVertexAttrib4Nbv = wrapglVertexAttrib4Nbv;
1893 //      qglVertexAttrib4Nsv = wrapglVertexAttrib4Nsv;
1894 //      qglVertexAttrib4Niv = wrapglVertexAttrib4Niv;
1895 //      qglVertexAttrib4Nubv = wrapglVertexAttrib4Nubv;
1896 //      qglVertexAttrib4Nusv = wrapglVertexAttrib4Nusv;
1897 //      qglVertexAttrib4Nuiv = wrapglVertexAttrib4Nuiv;
1898 //      qglGetVertexAttribdv = wrapglGetVertexAttribdv;
1899         qglGetVertexAttribfv = wrapglGetVertexAttribfv;
1900         qglGetVertexAttribiv = wrapglGetVertexAttribiv;
1901         qglGetVertexAttribPointerv = wrapglGetVertexAttribPointerv;
1902 #endif
1903
1904         gl_renderer = (const char *)qglGetString(GL_RENDERER);
1905         gl_vendor = (const char *)qglGetString(GL_VENDOR);
1906         gl_version = (const char *)qglGetString(GL_VERSION);
1907         gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
1908         
1909         if (!gl_extensions)
1910                 gl_extensions = "";
1911         if (!gl_platformextensions)
1912                 gl_platformextensions = "";
1913         
1914         Con_Printf("GL_VENDOR: %s\n", gl_vendor);
1915         Con_Printf("GL_RENDERER: %s\n", gl_renderer);
1916         Con_Printf("GL_VERSION: %s\n", gl_version);
1917         Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
1918         Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
1919         
1920         // LordHavoc: report supported extensions
1921         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
1922
1923         // GLES devices in general do not like GL_BGRA, so use GL_RGBA
1924         vid.forcetextype = TEXTYPE_RGBA;
1925         
1926         vid.support.gl20shaders = true;
1927         vid.support.amd_texture_texture4 = false;
1928         vid.support.arb_depth_texture = SDL_GL_ExtensionSupported("GL_OES_depth_texture") != 0; // renderbuffer used anyway on gles2?
1929         vid.support.arb_draw_buffers = false;
1930         vid.support.arb_multitexture = false;
1931         vid.support.arb_occlusion_query = false;
1932         vid.support.arb_query_buffer_object = false;
1933         vid.support.arb_shadow = false;
1934         vid.support.arb_texture_compression = false; // different (vendor-specific) formats than on desktop OpenGL...
1935         vid.support.arb_texture_cube_map = SDL_GL_ExtensionSupported("GL_OES_texture_cube_map") != 0;
1936         vid.support.arb_texture_env_combine = false;
1937         vid.support.arb_texture_gather = false;
1938         vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
1939         vid.support.arb_vertex_buffer_object = true; // GLES2 core
1940         vid.support.ati_separate_stencil = false;
1941         vid.support.ext_blend_minmax = false;
1942         vid.support.ext_blend_subtract = true; // GLES2 core
1943         vid.support.ext_blend_func_separate = true; // GLES2 core
1944         vid.support.ext_draw_range_elements = false;
1945
1946         /*      ELUAN:
1947                 Note: "In OS 2.1, the functions in GL_OES_framebuffer_object were not usable from the Java API.
1948                 Calling them just threw an exception. Android developer relations confirmed that they forgot to implement these. (yeah...)
1949                 It's apparently been fixed in 2.2, though I haven't tested."
1950         */
1951         vid.support.ext_framebuffer_object = false;//true;
1952
1953         vid.support.ext_packed_depth_stencil = false;
1954         vid.support.ext_stencil_two_side = false;
1955         vid.support.ext_texture_3d = SDL_GL_ExtensionSupported("GL_OES_texture_3D") != 0;
1956         vid.support.ext_texture_compression_s3tc = SDL_GL_ExtensionSupported("GL_EXT_texture_compression_s3tc") != 0;
1957         vid.support.ext_texture_edge_clamp = true; // GLES2 core
1958         vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
1959         vid.support.ext_texture_srgb = false;
1960
1961         // NOTE: On some devices, a value of 512 gives better FPS than the maximum.
1962         qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
1963
1964 #ifdef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
1965         if (vid.support.ext_texture_filter_anisotropic)
1966                 qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
1967 #endif
1968         if (vid.support.arb_texture_cube_map)
1969                 qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_cubemap);
1970 #ifdef GL_MAX_3D_TEXTURE_SIZE
1971         if (vid.support.ext_texture_3d)
1972                 qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_3d);
1973 #endif
1974         Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
1975         Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
1976         {
1977 #define GL_ALPHA_BITS                           0x0D55
1978 #define GL_RED_BITS                             0x0D52
1979 #define GL_GREEN_BITS                           0x0D53
1980 #define GL_BLUE_BITS                            0x0D54
1981 #define GL_DEPTH_BITS                           0x0D56
1982 #define GL_STENCIL_BITS                         0x0D57
1983                 int fb_r = -1, fb_g = -1, fb_b = -1, fb_a = -1, fb_d = -1, fb_s = -1;
1984                 qglGetIntegerv(GL_RED_BITS    , &fb_r);
1985                 qglGetIntegerv(GL_GREEN_BITS  , &fb_g);
1986                 qglGetIntegerv(GL_BLUE_BITS   , &fb_b);
1987                 qglGetIntegerv(GL_ALPHA_BITS  , &fb_a);
1988                 qglGetIntegerv(GL_DEPTH_BITS  , &fb_d);
1989                 qglGetIntegerv(GL_STENCIL_BITS, &fb_s);
1990                 Con_Printf("Framebuffer depth is R%iG%iB%iA%iD%iS%i\n", fb_r, fb_g, fb_b, fb_a, fb_d, fb_s);
1991         }
1992
1993         // verify that cubemap textures are really supported
1994         if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
1995                 vid.support.arb_texture_cube_map = false;
1996         
1997         // verify that 3d textures are really supported
1998         if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
1999         {
2000                 vid.support.ext_texture_3d = false;
2001                 Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
2002         }
2003
2004         vid.texunits = 4;
2005         vid.teximageunits = 8;
2006         vid.texarrayunits = 5;
2007         //qglGetIntegerv(GL_MAX_TEXTURE_UNITS, (GLint*)&vid.texunits);
2008         qglGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, (GLint*)&vid.teximageunits);CHECKGLERROR
2009         //qglGetIntegerv(GL_MAX_TEXTURE_COORDS, (GLint*)&vid.texarrayunits);CHECKGLERROR
2010         vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
2011         vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
2012         vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
2013         Con_DPrintf("Using GLES2.0 rendering path - %i texture matrix, %i texture images, %i texcoords%s\n", vid.texunits, vid.teximageunits, vid.texarrayunits, vid.support.ext_framebuffer_object ? ", shadowmapping supported" : "");
2014         vid.renderpath = RENDERPATH_GLES2;
2015         vid.useinterleavedarrays = false;
2016         vid.sRGBcapable2D = false;
2017         vid.sRGBcapable3D = false;
2018
2019         // VorteX: set other info (maybe place them in VID_InitMode?)
2020         extern cvar_t gl_info_vendor;
2021         extern cvar_t gl_info_renderer;
2022         extern cvar_t gl_info_version;
2023         extern cvar_t gl_info_platform;
2024         extern cvar_t gl_info_driver;
2025         Cvar_SetQuick(&gl_info_vendor, gl_vendor);
2026         Cvar_SetQuick(&gl_info_renderer, gl_renderer);
2027         Cvar_SetQuick(&gl_info_version, gl_version);
2028         Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
2029         Cvar_SetQuick(&gl_info_driver, gl_driver);
2030 }
2031 #endif
2032
2033 void *GL_GetProcAddress(const char *name)
2034 {
2035         void *p = NULL;
2036         p = SDL_GL_GetProcAddress(name);
2037         return p;
2038 }
2039
2040 static qboolean vid_sdl_initjoysticksystem = false;
2041
2042 void VID_Init (void)
2043 {
2044 #ifndef __IPHONEOS__
2045 #ifdef MACOSX
2046         Cvar_RegisterVariable(&apple_mouse_noaccel);
2047 #endif
2048 #endif
2049 #ifdef DP_MOBILETOUCH
2050         Cvar_SetValueQuick(&vid_touchscreen, 1);
2051 #endif
2052
2053 #ifdef SDL_R_RESTART
2054         R_RegisterModule("SDL", sdl_start, sdl_shutdown, sdl_newmap, NULL, NULL);
2055 #endif
2056
2057         if (SDL_Init(SDL_INIT_VIDEO) < 0)
2058                 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
2059         vid_sdl_initjoysticksystem = SDL_InitSubSystem(SDL_INIT_JOYSTICK) >= 0;
2060         if (vid_sdl_initjoysticksystem)
2061                 Con_Printf("Failed to init SDL joystick subsystem: %s\n", SDL_GetError());
2062         vid_isfullscreen = false;
2063 }
2064
2065 static int vid_sdljoystickindex = -1;
2066 void VID_EnableJoystick(qboolean enable)
2067 {
2068         int index = joy_enable.integer > 0 ? joy_index.integer : -1;
2069         int numsdljoysticks;
2070         qboolean success = false;
2071         int sharedcount = 0;
2072         int sdlindex = -1;
2073         sharedcount = VID_Shared_SetJoystick(index);
2074         if (index >= 0 && index < sharedcount)
2075                 success = true;
2076         sdlindex = index - sharedcount;
2077
2078         numsdljoysticks = SDL_NumJoysticks();
2079         if (sdlindex < 0 || sdlindex >= numsdljoysticks)
2080                 sdlindex = -1;
2081
2082         // update cvar containing count of XInput joysticks + SDL joysticks
2083         if (joy_detected.integer != sharedcount + numsdljoysticks)
2084                 Cvar_SetValueQuick(&joy_detected, sharedcount + numsdljoysticks);
2085
2086         if (vid_sdljoystickindex != sdlindex)
2087         {
2088                 vid_sdljoystickindex = sdlindex;
2089                 // close SDL joystick if active
2090                 if (vid_sdljoystick)
2091                         SDL_JoystickClose(vid_sdljoystick);
2092                 vid_sdljoystick = NULL;
2093                 if (sdlindex >= 0)
2094                 {
2095                         vid_sdljoystick = SDL_JoystickOpen(sdlindex);
2096                         if (vid_sdljoystick)
2097                         {
2098 #if SDL_MAJOR_VERSION == 1
2099                                 const char *joystickname = SDL_JoystickName(sdlindex);
2100 #else
2101                                 const char *joystickname = SDL_JoystickName(vid_sdljoystick);
2102 #endif
2103                                 Con_Printf("Joystick %i opened (SDL_Joystick %i is \"%s\" with %i axes, %i buttons, %i balls)\n", index, sdlindex, joystickname, (int)SDL_JoystickNumAxes(vid_sdljoystick), (int)SDL_JoystickNumButtons(vid_sdljoystick), (int)SDL_JoystickNumBalls(vid_sdljoystick));
2104                         }
2105                         else
2106                         {
2107                                 Con_Printf("Joystick %i failed (SDL_JoystickOpen(%i) returned: %s)\n", index, sdlindex, SDL_GetError());
2108                                 sdlindex = -1;
2109                         }
2110                 }
2111         }
2112
2113         if (sdlindex >= 0)
2114                 success = true;
2115
2116         if (joy_active.integer != (success ? 1 : 0))
2117                 Cvar_SetValueQuick(&joy_active, success ? 1 : 0);
2118 }
2119
2120 #if SDL_MAJOR_VERSION == 1
2121 // set the icon (we dont use SDL here since it would be too much a PITA)
2122 #ifdef WIN32
2123 #include "resource.h"
2124 #include <SDL_syswm.h>
2125 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
2126 {
2127         SDL_Surface *screen = NULL;
2128         SDL_SysWMinfo info;
2129         HICON icon;
2130         SDL_WM_SetCaption( gamename, NULL );
2131         screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
2132         if (screen)
2133         {
2134                 // get the HWND handle
2135                 SDL_VERSION( &info.version );
2136                 if (SDL_GetWMInfo(&info))
2137                 {
2138                         icon = LoadIcon( GetModuleHandle( NULL ), MAKEINTRESOURCE( IDI_ICON1 ) );
2139 #ifndef _W64 //If Windows 64bit data types don't exist
2140 #ifndef SetClassLongPtr
2141 #define SetClassLongPtr SetClassLong
2142 #endif
2143 #ifndef GCLP_HICON
2144 #define GCLP_HICON GCL_HICON
2145 #endif
2146 #ifndef LONG_PTR
2147 #define LONG_PTR LONG
2148 #endif
2149 #endif
2150                         SetClassLongPtr( info.window, GCLP_HICON, (LONG_PTR)icon );
2151                 }
2152         }
2153         return screen;
2154 }
2155 #elif defined(MACOSX)
2156 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
2157 {
2158         SDL_Surface *screen = NULL;
2159         SDL_WM_SetCaption( gamename, NULL );
2160         screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
2161         // we don't use SDL_WM_SetIcon here because the icon in the .app should be used
2162         return screen;
2163 }
2164 #else
2165 // Adding the OS independent XPM version --blub
2166 #include "darkplaces.xpm"
2167 #include "nexuiz.xpm"
2168 #if SDL_MAJOR_VERSION == 1
2169 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
2170 #include <SDL_syswm.h>
2171 #endif
2172 #endif
2173 static SDL_Surface *icon = NULL;
2174 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
2175 {
2176         /*
2177          * Somewhat restricted XPM reader. Only supports XPMs saved by GIMP 2.4 at
2178          * default settings with less than 91 colors and transparency.
2179          */
2180
2181         int width, height, colors, isize, i, j;
2182         int thenone = -1;
2183         static SDL_Color palette[256];
2184         unsigned short palenc[256]; // store color id by char
2185         char *xpm;
2186         char **idata, *data;
2187         const SDL_version *version;
2188         SDL_Surface *screen = NULL;
2189
2190         if (icon)
2191                 SDL_FreeSurface(icon);
2192         icon = NULL;
2193         version = SDL_Linked_Version();
2194         // only use non-XPM icon support in SDL v1.3 and higher
2195         // SDL v1.2 does not support "smooth" transparency, and thus is better
2196         // off the xpm way
2197         if(version->major >= 2 || (version->major == 1 && version->minor >= 3))
2198         {
2199                 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
2200                 if(data)
2201                 {
2202                         unsigned int red = 0x00FF0000;
2203                         unsigned int green = 0x0000FF00;
2204                         unsigned int blue = 0x000000FF;
2205                         unsigned int alpha = 0xFF000000;
2206                         width = image_width;
2207                         height = image_height;
2208
2209                         // reallocate with malloc, as this is in tempmempool (do not want)
2210                         xpm = data;
2211                         data = (char *) malloc(width * height * 4);
2212                         memcpy(data, xpm, width * height * 4);
2213                         Mem_Free(xpm);
2214                         xpm = NULL;
2215
2216                         icon = SDL_CreateRGBSurface(SDL_SRCALPHA, width, height, 32, LittleLong(red), LittleLong(green), LittleLong(blue), LittleLong(alpha));
2217
2218                         if (icon)
2219                                 icon->pixels = data;
2220                         else
2221                         {
2222                                 Con_Printf(     "Failed to create surface for the window Icon!\n"
2223                                                 "%s\n", SDL_GetError());
2224                                 free(data);
2225                         }
2226                 }
2227         }
2228
2229         // we only get here if non-XPM icon was missing, or SDL version is not
2230         // sufficient for transparent non-XPM icons
2231         if(!icon)
2232         {
2233                 xpm = (char *) FS_LoadFile("darkplaces-icon.xpm", tempmempool, false, NULL);
2234                 idata = NULL;
2235                 if(xpm)
2236                         idata = XPM_DecodeString(xpm);
2237                 if(!idata)
2238                         idata = ENGINE_ICON;
2239                 if(xpm)
2240                         Mem_Free(xpm);
2241
2242                 data = idata[0];
2243
2244                 if(sscanf(data, "%i %i %i %i", &width, &height, &colors, &isize) == 4)
2245                 {
2246                         if(isize == 1)
2247                         {
2248                                 for(i = 0; i < colors; ++i)
2249                                 {
2250                                         unsigned int r, g, b;
2251                                         char idx;
2252
2253                                         if(sscanf(idata[i+1], "%c c #%02x%02x%02x", &idx, &r, &g, &b) != 4)
2254                                         {
2255                                                 char foo[2];
2256                                                 if(sscanf(idata[i+1], "%c c Non%1[e]", &idx, foo) != 2) // I take the DailyWTF credit for this. --div0
2257                                                         break;
2258                                                 else
2259                                                 {
2260                                                         palette[i].r = 255; // color key
2261                                                         palette[i].g = 0;
2262                                                         palette[i].b = 255;
2263                                                         thenone = i; // weeeee
2264                                                         palenc[(unsigned char) idx] = i;
2265                                                 }
2266                                         }
2267                                         else
2268                                         {
2269                                                 palette[i].r = r - (r == 255 && g == 0 && b == 255); // change 255/0/255 pink to 254/0/255 for color key
2270                                                 palette[i].g = g;
2271                                                 palette[i].b = b;
2272                                                 palenc[(unsigned char) idx] = i;
2273                                         }
2274                                 }
2275
2276                                 if (i == colors)
2277                                 {
2278                                         // allocate the image data
2279                                         data = (char*) malloc(width*height);
2280
2281                                         for(j = 0; j < height; ++j)
2282                                         {
2283                                                 for(i = 0; i < width; ++i)
2284                                                 {
2285                                                         // casting to the safest possible datatypes ^^
2286                                                         data[j * width + i] = palenc[((unsigned char*)idata[colors+j+1])[i]];
2287                                                 }
2288                                         }
2289
2290                                         if(icon != NULL)
2291                                         {
2292                                                 // SDL_FreeSurface should free the data too
2293                                                 // but for completeness' sake...
2294                                                 if(icon->flags & SDL_PREALLOC)
2295                                                 {
2296                                                         free(icon->pixels);
2297                                                         icon->pixels = NULL; // safety
2298                                                 }
2299                                                 SDL_FreeSurface(icon);
2300                                         }
2301
2302                                         icon = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, width, height, 8, 0,0,0,0);// rmask, gmask, bmask, amask); no mask needed
2303                                         // 8 bit surfaces get an empty palette allocated according to the docs
2304                                         // so it's a palette image for sure :) no endian check necessary for the mask
2305
2306                                         if(icon)
2307                                         {
2308                                                 icon->pixels = data;
2309                                                 SDL_SetPalette(icon, SDL_PHYSPAL|SDL_LOGPAL, palette, 0, colors);
2310                                                 SDL_SetColorKey(icon, SDL_SRCCOLORKEY, thenone);
2311                                         }
2312                                         else
2313                                         {
2314                                                 Con_Printf(     "Failed to create surface for the window Icon!\n"
2315                                                                 "%s\n", SDL_GetError());
2316                                                 free(data);
2317                                         }
2318                                 }
2319                                 else
2320                                 {
2321                                         Con_Printf("This XPM's palette looks odd. Can't continue.\n");
2322                                 }
2323                         }
2324                         else
2325                         {
2326                                 // NOTE: Only 1-char colornames are supported
2327                                 Con_Printf("This XPM's palette is either huge or idiotically unoptimized. It's key size is %i\n", isize);
2328                         }
2329                 }
2330                 else
2331                 {
2332                         // NOTE: Only 1-char colornames are supported
2333                         Con_Printf("Sorry, but this does not even look similar to an XPM.\n");
2334                 }
2335         }
2336
2337         if (icon)
2338                 SDL_WM_SetIcon(icon, NULL);
2339
2340         SDL_WM_SetCaption( gamename, NULL );
2341         screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
2342
2343 #if SDL_MAJOR_VERSION == 1
2344 // LordHavoc: info.info.x11.lock_func and accompanying code do not seem to compile with SDL 1.3
2345 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
2346
2347         version = SDL_Linked_Version();
2348         // only use non-XPM icon support in SDL v1.3 and higher
2349         // SDL v1.2 does not support "smooth" transparency, and thus is better
2350         // off the xpm way
2351         if(screen && (!(version->major >= 2 || (version->major == 1 && version->minor >= 3))))
2352         {
2353                 // in this case, we did not set the good icon yet
2354                 SDL_SysWMinfo info;
2355                 SDL_VERSION(&info.version);
2356                 if(SDL_GetWMInfo(&info) == 1 && info.subsystem == SDL_SYSWM_X11)
2357                 {
2358                         data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
2359                         if(data)
2360                         {
2361                                 // use _NET_WM_ICON too
2362                                 static long netwm_icon[MAX_NETWM_ICON];
2363                                 int pos = 0;
2364                                 int i = 1;
2365                                 char vabuf[1024];
2366
2367                                 while(data)
2368                                 {
2369                                         if(pos + 2 * image_width * image_height < MAX_NETWM_ICON)
2370                                         {
2371                                                 netwm_icon[pos++] = image_width;
2372                                                 netwm_icon[pos++] = image_height;
2373                                                 for(i = 0; i < image_height; ++i)
2374                                                         for(j = 0; j < image_width; ++j)
2375                                                                 netwm_icon[pos++] = BuffLittleLong((unsigned char *) &data[(i*image_width+j)*4]);
2376                                         }
2377                                         else
2378                                         {
2379                                                 Con_Printf("Skipping NETWM icon #%d because there is no space left\n", i);
2380                                         }
2381                                         ++i;
2382                                         Mem_Free(data);
2383                                         data = (char *) loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "darkplaces-icon%d", i), false, false, false, NULL);
2384                                 }
2385
2386                                 info.info.x11.lock_func();
2387                                 {
2388                                         Atom net_wm_icon = XInternAtom(info.info.x11.display, "_NET_WM_ICON", false);
2389                                         XChangeProperty(info.info.x11.display, info.info.x11.wmwindow, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (const unsigned char *) netwm_icon, pos);
2390                                 }
2391                                 info.info.x11.unlock_func();
2392                         }
2393                 }
2394         }
2395 #endif
2396 #endif
2397         return screen;
2398 }
2399
2400 #endif
2401 #endif
2402
2403 static void VID_OutputVersion(void)
2404 {
2405         SDL_version version;
2406 #if SDL_MAJOR_VERSION == 1
2407         version = *SDL_Linked_Version();
2408 #else
2409         SDL_GetVersion(&version);
2410 #endif
2411         Con_Printf(     "Linked against SDL version %d.%d.%d\n"
2412                                         "Using SDL library version %d.%d.%d\n",
2413                                         SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL,
2414                                         version.major, version.minor, version.patch );
2415 }
2416
2417 #ifdef WIN32
2418 static void AdjustWindowBounds(viddef_mode_t *mode, RECT *rect)
2419 {
2420         LONG width = mode->width; // vid_width
2421         LONG height = mode->height; // vid_height
2422
2423         // adjust width and height for the space occupied by window decorators (title bar, borders)
2424         rect->top = 0;
2425         rect->left = 0;
2426         rect->right = width;
2427         rect->bottom = height;
2428         AdjustWindowRectEx(rect, WS_CAPTION|WS_THICKFRAME, false, 0);
2429
2430         RECT workArea;
2431         SystemParametersInfo(SPI_GETWORKAREA, 0, &workArea, 0);
2432         int workWidth = workArea.right - workArea.left;
2433         int workHeight = workArea.bottom - workArea.top;
2434
2435         // SDL forces the window height to be <= screen height - 27px (on Win8.1 - probably intended for the title bar) 
2436         // If the task bar is docked to the the left screen border and we move the window to negative y,
2437         // there would be some part of the regular desktop visible on the bottom of the screen.
2438         int titleBarPixels = 2;
2439         int screenHeight = GetSystemMetrics(SM_CYSCREEN);
2440         if (screenHeight == workHeight)
2441                 titleBarPixels = -rect->top;
2442
2443         //Con_Printf("window mode: %dx%d, workArea: %d/%d-%d/%d (%dx%d), title: %d\n", width, height, workArea.left, workArea.top, workArea.right, workArea.bottom, workArea.right - workArea.left, workArea.bottom - workArea.top, titleBarPixels);
2444
2445         // if height and width matches the physical or previously adjusted screen height and width, adjust it to available desktop area
2446         if ((width == GetSystemMetrics(SM_CXSCREEN) || width == workWidth) && (height == screenHeight || height == workHeight - titleBarPixels))
2447         {
2448                 rect->left = workArea.left;
2449                 mode->width = workWidth;
2450                 rect->top = workArea.top + titleBarPixels;
2451                 mode->height = workHeight - titleBarPixels;
2452         }
2453         else 
2454         {
2455                 rect->left = workArea.left + max(0, (workWidth - width) / 2);
2456                 rect->top = workArea.top + ((workHeight - height) / 2);
2457         }
2458 }
2459 #endif
2460
2461 static qboolean VID_InitModeGL(viddef_mode_t *mode)
2462 {
2463 #if SDL_MAJOR_VERSION == 1
2464         static int notfirstvideomode = false;
2465         int flags = SDL_OPENGL;
2466 #else
2467         int windowflags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
2468 #endif
2469 #ifndef USE_GLES2
2470         int i;
2471         const char *drivername;
2472 #endif
2473
2474         win_half_width = mode->width>>1;
2475         win_half_height = mode->height>>1;
2476
2477         if(vid_resizable.integer)
2478 #if SDL_MAJOR_VERSION == 1
2479                 flags |= SDL_RESIZABLE;
2480 #else
2481                 windowflags |= SDL_WINDOW_RESIZABLE;
2482 #endif
2483
2484         VID_OutputVersion();
2485
2486 #if SDL_MAJOR_VERSION == 1
2487         /*
2488         SDL 1.2 Hack
2489                 We cant switch from one OpenGL video mode to another.
2490                 Thus we first switch to some stupid 2D mode and then back to OpenGL.
2491         */
2492         if (notfirstvideomode)
2493                 SDL_SetVideoMode( 0, 0, 0, 0 );
2494         notfirstvideomode = true;
2495 #endif
2496
2497 #ifndef USE_GLES2
2498         // SDL usually knows best
2499         drivername = NULL;
2500
2501 // COMMANDLINEOPTION: SDL GL: -gl_driver <drivername> selects a GL driver library, default is whatever SDL recommends, useful only for 3dfxogl.dll/3dfxvgl.dll or fxmesa or similar, if you don't know what this is for, you don't need it
2502         i = COM_CheckParm("-gl_driver");
2503         if (i && i < com_argc - 1)
2504                 drivername = com_argv[i + 1];
2505         if (SDL_GL_LoadLibrary(drivername) < 0)
2506         {
2507                 Con_Printf("Unable to load GL driver \"%s\": %s\n", drivername, SDL_GetError());
2508                 return false;
2509         }
2510 #endif
2511
2512 #ifdef DP_MOBILETOUCH
2513         // mobile platforms are always fullscreen, we'll get the resolution after opening the window
2514         mode->fullscreen = true;
2515         // hide the menu with SDL_WINDOW_BORDERLESS
2516         windowflags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
2517 #endif
2518 #ifndef USE_GLES2
2519         if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
2520         {
2521                 VID_Shutdown();
2522                 Con_Print("Required OpenGL function glGetString not found\n");
2523                 return false;
2524         }
2525 #endif
2526
2527         // Knghtbrd: should do platform-specific extension string function here
2528
2529         vid_isfullscreen = false;
2530 #if SDL_MAJOR_VERSION == 1
2531         {
2532                 const SDL_VideoInfo *vi = SDL_GetVideoInfo();
2533                 desktop_mode.width = vi->current_w;
2534                 desktop_mode.height = vi->current_h;
2535                 desktop_mode.bpp = vi->vfmt->BitsPerPixel;
2536                 desktop_mode.pixelheight_num = 1;
2537                 desktop_mode.pixelheight_denom = 1; // SDL does not provide this
2538                 if (mode->fullscreen) {
2539                         if (vid_desktopfullscreen.integer)
2540                         {
2541                                 mode->width = vi->current_w;
2542                                 mode->height = vi->current_h;
2543                                 mode->bitsperpixel = vi->vfmt->BitsPerPixel;
2544                         }
2545                         flags |= SDL_FULLSCREEN;
2546                         vid_isfullscreen = true;
2547                 }
2548         }
2549 #else
2550         int xPos = SDL_WINDOWPOS_UNDEFINED;
2551         int yPos = SDL_WINDOWPOS_UNDEFINED;
2552         {
2553                 if (mode->fullscreen) {
2554                         if (vid_desktopfullscreen.integer)
2555                         {
2556                                 vid_mode_t *m = VID_GetDesktopMode();
2557                                 mode->width = m->width;
2558                                 mode->height = m->height;
2559                                 windowflags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
2560                         }
2561                         else
2562                                 windowflags |= SDL_WINDOW_FULLSCREEN;
2563                         vid_isfullscreen = true;
2564                 }
2565                 else {
2566 #ifdef WIN32
2567                         RECT rect;
2568                         AdjustWindowBounds(mode, &rect);
2569                         xPos = rect.left;
2570                         yPos = rect.top;
2571 #endif
2572                 }
2573         }
2574 #endif
2575         //flags |= SDL_HWSURFACE;
2576
2577         SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
2578         if (mode->bitsperpixel >= 32)
2579         {
2580                 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 8);
2581                 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 8);
2582                 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 8);
2583                 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8);
2584                 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24);
2585                 SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
2586         }
2587         else
2588         {
2589                 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
2590                 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
2591                 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
2592                 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
2593         }
2594         if (mode->stereobuffer)
2595                 SDL_GL_SetAttribute (SDL_GL_STEREO, 1);
2596         if (mode->samples > 1)
2597         {
2598                 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
2599                 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, mode->samples);
2600         }
2601
2602 #if SDL_MAJOR_VERSION == 1
2603         if (vid_vsync.integer)
2604                 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
2605         else
2606                 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 0);
2607 #else
2608 #ifdef USE_GLES2
2609         SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 2);
2610         SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 0);
2611         SDL_GL_SetAttribute (SDL_GL_RETAINED_BACKING, 1);
2612 #endif
2613 #endif
2614
2615         video_bpp = mode->bitsperpixel;
2616 #if SDL_MAJOR_VERSION == 1
2617         video_flags = flags;
2618         screen = VID_WrapSDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2619         if (screen == NULL)
2620         {
2621                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2622                 VID_Shutdown();
2623                 return false;
2624         }
2625         mode->width = screen->w;
2626         mode->height = screen->h;
2627 #else
2628         window_flags = windowflags;
2629         window = SDL_CreateWindow(gamename, xPos, yPos, mode->width, mode->height, windowflags);
2630         if (window == NULL)
2631         {
2632                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2633                 VID_Shutdown();
2634                 return false;
2635         }
2636         SDL_GetWindowSize(window, &mode->width, &mode->height);
2637         context = SDL_GL_CreateContext(window);
2638         if (context == NULL)
2639         {
2640                 Con_Printf("Failed to initialize OpenGL context: %s\n", SDL_GetError());
2641                 VID_Shutdown();
2642                 return false;
2643         }
2644 #endif
2645
2646         vid_softsurface = NULL;
2647         vid.softpixels = NULL;
2648
2649 #if SDL_MAJOR_VERSION == 1
2650         // init keyboard
2651         SDL_EnableUNICODE( SDL_ENABLE );
2652         // enable key repeat since everyone expects it
2653         SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2654 #endif
2655
2656 #if SDL_MAJOR_VERSION != 1
2657         SDL_GL_SetSwapInterval(vid_vsync.integer != 0);
2658         vid_usingvsync = (vid_vsync.integer != 0);
2659 #endif
2660
2661         gl_platform = "SDL";
2662         gl_platformextensions = "";
2663
2664 #ifdef USE_GLES2
2665         GLES_Init();
2666 #else
2667         GL_Init();
2668 #endif
2669
2670         vid_hidden = false;
2671         vid_activewindow = false;
2672         vid_hasfocus = true;
2673         vid_usingmouse = false;
2674         vid_usinghidecursor = false;
2675                 
2676 #if SDL_MAJOR_VERSION == 1
2677         SDL_WM_GrabInput(SDL_GRAB_OFF);
2678 #endif
2679         return true;
2680 }
2681
2682 extern cvar_t gl_info_extensions;
2683 extern cvar_t gl_info_vendor;
2684 extern cvar_t gl_info_renderer;
2685 extern cvar_t gl_info_version;
2686 extern cvar_t gl_info_platform;
2687 extern cvar_t gl_info_driver;
2688
2689 static qboolean VID_InitModeSoft(viddef_mode_t *mode)
2690 {
2691 #if SDL_MAJOR_VERSION == 1
2692         int flags = SDL_HWSURFACE;
2693         if(!COM_CheckParm("-noasyncblit")) flags |= SDL_ASYNCBLIT;
2694 #else
2695         int windowflags = SDL_WINDOW_SHOWN;
2696 #endif
2697
2698         win_half_width = mode->width>>1;
2699         win_half_height = mode->height>>1;
2700
2701         if(vid_resizable.integer)
2702 #if SDL_MAJOR_VERSION == 1
2703                 flags |= SDL_RESIZABLE;
2704 #else
2705                 windowflags |= SDL_WINDOW_RESIZABLE;
2706 #endif
2707
2708         VID_OutputVersion();
2709
2710         vid_isfullscreen = false;
2711         if (mode->fullscreen) {
2712 #if SDL_MAJOR_VERSION == 1
2713                 const SDL_VideoInfo *vi = SDL_GetVideoInfo();
2714                 mode->width = vi->current_w;
2715                 mode->height = vi->current_h;
2716                 mode->bitsperpixel = vi->vfmt->BitsPerPixel;
2717                 flags |= SDL_FULLSCREEN;
2718 #else
2719                 if (vid_desktopfullscreen.integer)
2720                         windowflags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
2721                 else
2722                         windowflags |= SDL_WINDOW_FULLSCREEN;
2723 #endif
2724                 vid_isfullscreen = true;
2725         }
2726
2727         video_bpp = mode->bitsperpixel;
2728 #if SDL_MAJOR_VERSION == 1
2729         video_flags = flags;
2730         screen = VID_WrapSDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2731         if (screen == NULL)
2732         {
2733                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2734                 VID_Shutdown();
2735                 return false;
2736         }
2737         mode->width = screen->w;
2738         mode->height = screen->h;
2739 #else
2740         window_flags = windowflags;
2741         window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2742         if (window == NULL)
2743         {
2744                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2745                 VID_Shutdown();
2746                 return false;
2747         }
2748         SDL_GetWindowSize(window, &mode->width, &mode->height);
2749 #endif
2750
2751         // create a framebuffer using our specific color format, we let the SDL blit function convert it in VID_Finish
2752         vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, mode->width, mode->height, 32, 0x00FF0000, 0x0000FF00, 0x00000000FF, 0xFF000000);
2753         if (vid_softsurface == NULL)
2754         {
2755                 Con_Printf("Failed to setup software rasterizer framebuffer %ix%ix32bpp: %s\n", mode->width, mode->height, SDL_GetError());
2756                 VID_Shutdown();
2757                 return false;
2758         }
2759 #if SDL_MAJOR_VERSION == 1
2760         SDL_SetAlpha(vid_softsurface, 0, 255);
2761 #else
2762         SDL_SetSurfaceBlendMode(vid_softsurface, SDL_BLENDMODE_NONE);
2763 #endif
2764
2765         vid.softpixels = (unsigned int *)vid_softsurface->pixels;
2766         vid.softdepthpixels = (unsigned int *)calloc(1, mode->width * mode->height * 4);
2767         if (DPSOFTRAST_Init(mode->width, mode->height, vid_soft_threads.integer, vid_soft_interlace.integer, (unsigned int *)vid_softsurface->pixels, (unsigned int *)vid.softdepthpixels) < 0)
2768         {
2769                 Con_Printf("Failed to initialize software rasterizer\n");
2770                 VID_Shutdown();
2771                 return false;
2772         }
2773
2774 #if SDL_MAJOR_VERSION == 1
2775         // init keyboard
2776         SDL_EnableUNICODE( SDL_ENABLE );
2777         // enable key repeat since everyone expects it
2778         SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2779 #endif
2780
2781         VID_Soft_SharedSetup();
2782
2783         vid_hidden = false;
2784         vid_activewindow = false;
2785         vid_hasfocus = true;
2786         vid_usingmouse = false;
2787         vid_usinghidecursor = false;
2788
2789 #if SDL_MAJOR_VERSION == 1
2790         SDL_WM_GrabInput(SDL_GRAB_OFF);
2791 #endif
2792         return true;
2793 }
2794
2795 qboolean VID_InitMode(viddef_mode_t *mode)
2796 {
2797         // GAME_STEELSTORM specific
2798         steelstorm_showing_map = Cvar_FindVar("steelstorm_showing_map");
2799         steelstorm_showing_mousecursor = Cvar_FindVar("steelstorm_showing_mousecursor");
2800
2801         if (!SDL_WasInit(SDL_INIT_VIDEO) && SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
2802                 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
2803
2804 #if SDL_MAJOR_VERSION != 1
2805         Cvar_SetValueQuick(&vid_touchscreen_supportshowkeyboard, SDL_HasScreenKeyboardSupport() ? 1 : 0);
2806 #endif
2807 #ifdef SSE_POSSIBLE
2808         if (vid_soft.integer)
2809                 return VID_InitModeSoft(mode);
2810         else
2811 #endif
2812                 return VID_InitModeGL(mode);
2813 }
2814
2815 void VID_Shutdown (void)
2816 {
2817         VID_EnableJoystick(false);
2818         VID_SetMouse(false, false, false);
2819         VID_RestoreSystemGamma();
2820
2821 #if SDL_MAJOR_VERSION == 1
2822 #ifndef WIN32
2823 #ifndef MACOSX
2824         if (icon)
2825                 SDL_FreeSurface(icon);
2826         icon = NULL;
2827 #endif
2828 #endif
2829 #endif
2830
2831         if (vid_softsurface)
2832                 SDL_FreeSurface(vid_softsurface);
2833         vid_softsurface = NULL;
2834         vid.softpixels = NULL;
2835         if (vid.softdepthpixels)
2836                 free(vid.softdepthpixels);
2837         vid.softdepthpixels = NULL;
2838
2839 #if SDL_MAJOR_VERSION != 1
2840         SDL_DestroyWindow(window);
2841         window = NULL;
2842 #endif
2843
2844         SDL_QuitSubSystem(SDL_INIT_VIDEO);
2845
2846         gl_driver[0] = 0;
2847         gl_extensions = "";
2848         gl_platform = "";
2849         gl_platformextensions = "";
2850 }
2851
2852 int VID_SetGamma (unsigned short *ramps, int rampsize)
2853 {
2854 #if SDL_MAJOR_VERSION == 1
2855         return !SDL_SetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2856 #else
2857         return !SDL_SetWindowGammaRamp (window, ramps, ramps + rampsize, ramps + rampsize*2);
2858 #endif
2859 }
2860
2861 int VID_GetGamma (unsigned short *ramps, int rampsize)
2862 {
2863 #if SDL_MAJOR_VERSION == 1
2864         return !SDL_GetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2865 #else
2866         return !SDL_GetWindowGammaRamp (window, ramps, ramps + rampsize, ramps + rampsize*2);
2867 #endif
2868 }
2869
2870 void VID_Finish (void)
2871 {
2872 #if SDL_MAJOR_VERSION == 1
2873         Uint8 appstate;
2874
2875         //react on appstate changes
2876         appstate = SDL_GetAppState();
2877
2878         vid_hidden = !(appstate & SDL_APPACTIVE);
2879         vid_hasfocus = (appstate & SDL_APPINPUTFOCUS) != 0;
2880 #endif
2881         vid_activewindow = !vid_hidden && vid_hasfocus;
2882
2883         VID_UpdateGamma(false, 256);
2884
2885         if (!vid_hidden)
2886         {
2887                 switch(vid.renderpath)
2888                 {
2889                 case RENDERPATH_GL11:
2890                 case RENDERPATH_GL13:
2891                 case RENDERPATH_GL20:
2892                 case RENDERPATH_GLES1:
2893                 case RENDERPATH_GLES2:
2894                         CHECKGLERROR
2895                         if (r_speeds.integer == 2 || gl_finish.integer)
2896                                 GL_Finish();
2897
2898 #if SDL_MAJOR_VERSION != 1
2899 {
2900         qboolean vid_usevsync;
2901         vid_usevsync = (vid_vsync.integer && !cls.timedemo);
2902         if (vid_usingvsync != vid_usevsync)
2903         {
2904                 vid_usingvsync = vid_usevsync;
2905                 if (SDL_GL_SetSwapInterval(vid_usevsync != 0) >= 0)
2906                         Con_DPrintf("Vsync %s\n", vid_usevsync ? "activated" : "deactivated");
2907                 else
2908                         Con_DPrintf("ERROR: can't %s vsync\n", vid_usevsync ? "activate" : "deactivate");
2909         }
2910 }
2911 #endif
2912 #if SDL_MAJOR_VERSION == 1
2913                         SDL_GL_SwapBuffers();
2914 #else
2915                         SDL_GL_SwapWindow(window);
2916 #endif
2917                         break;
2918                 case RENDERPATH_SOFT:
2919                         DPSOFTRAST_Finish();
2920 #if SDL_MAJOR_VERSION == 1
2921 //              if (!r_test.integer)
2922                 {
2923                         SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2924                         SDL_Flip(screen);
2925                 }
2926 #else
2927                         {
2928                                 SDL_Surface *screen = SDL_GetWindowSurface(window);
2929                                 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2930                                 SDL_UpdateWindowSurface(window);
2931                         }
2932 #endif
2933                         break;
2934                 case RENDERPATH_D3D9:
2935                 case RENDERPATH_D3D10:
2936                 case RENDERPATH_D3D11:
2937                         if (r_speeds.integer == 2 || gl_finish.integer)
2938                                 GL_Finish();
2939                         break;
2940                 }
2941         }
2942 }
2943
2944 vid_mode_t *VID_GetDesktopMode(void)
2945 {
2946 #if SDL_MAJOR_VERSION != 1
2947         SDL_DisplayMode mode;
2948         int bpp;
2949         Uint32 rmask, gmask, bmask, amask;
2950         SDL_GetDesktopDisplayMode(0, &mode);
2951         SDL_PixelFormatEnumToMasks(mode.format, &bpp, &rmask, &gmask, &bmask, &amask);
2952         desktop_mode.width = mode.w;
2953         desktop_mode.height = mode.h;
2954         desktop_mode.bpp = bpp;
2955         desktop_mode.refreshrate = mode.refresh_rate;
2956         desktop_mode.pixelheight_num = 1;
2957         desktop_mode.pixelheight_denom = 1; // SDL does not provide this
2958         // TODO check whether this actually works, or whether we do still need
2959         // a read-window-size-after-entering-desktop-fullscreen hack for
2960         // multiscreen setups.
2961 #endif
2962         return &desktop_mode;
2963 }
2964
2965 size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
2966 {
2967         size_t k = 0;
2968 #if SDL_MAJOR_VERSION == 1
2969         SDL_Rect **vidmodes;
2970         int bpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
2971 #ifdef WIN64
2972         SDL_Rect **ENDRECT = (SDL_Rect**)-1LL;
2973 #else
2974         SDL_Rect **ENDRECT = (SDL_Rect**)-1;
2975 #endif
2976
2977         for(vidmodes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE); vidmodes && vidmodes != ENDRECT && *vidmodes; ++vidmodes)
2978         {
2979                 if(k >= maxcount)
2980                         break;
2981                 modes[k].width = (*vidmodes)->w;
2982                 modes[k].height = (*vidmodes)->h;
2983                 modes[k].bpp = bpp;
2984                 modes[k].refreshrate = 60; // no support for refresh rate in SDL
2985                 modes[k].pixelheight_num = 1;
2986                 modes[k].pixelheight_denom = 1; // SDL does not provide this
2987                 ++k;
2988         }
2989 #else
2990         int modenum;
2991         int nummodes = SDL_GetNumDisplayModes(0);
2992         SDL_DisplayMode mode;
2993         for (modenum = 0;modenum < nummodes;modenum++)
2994         {
2995                 if (k >= maxcount)
2996                         break;
2997                 if (SDL_GetDisplayMode(0, modenum, &mode))
2998                         continue;
2999                 modes[k].width = mode.w;
3000                 modes[k].height = mode.h;
3001                 // FIXME bpp?
3002                 modes[k].refreshrate = mode.refresh_rate;
3003                 modes[k].pixelheight_num = 1;
3004                 modes[k].pixelheight_denom = 1; // SDL does not provide this
3005                 k++;
3006         }
3007 #endif
3008         return k;
3009 }