2 Copyright (C) 2003 T. Joseph Carter
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.
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.
13 See the GNU General Public License for more details.
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.
19 #undef WIN32_LEAN_AND_MEAN //hush a warning, SDL.h redefines this
25 #include "dpsoftrast.h"
29 #include <Carbon/Carbon.h>
30 #include <IOKit/hidsystem/IOHIDLib.h>
31 #include <IOKit/hidsystem/IOHIDParameter.h>
32 #include <IOKit/hidsystem/event_status_driver.h>
33 static cvar_t apple_mouse_noaccel = {CVAR_SAVE, "apple_mouse_noaccel", "1", "disables mouse acceleration while DarkPlaces is active"};
34 static qboolean vid_usingnoaccel;
35 static double originalMouseSpeed = -1.0;
36 io_connect_t IN_GetIOHandle(void)
38 io_connect_t iohandle = MACH_PORT_NULL;
40 io_service_t iohidsystem = MACH_PORT_NULL;
41 mach_port_t masterport;
43 status = IOMasterPort(MACH_PORT_NULL, &masterport);
44 if(status != KERN_SUCCESS)
47 iohidsystem = IORegistryEntryFromPath(masterport, kIOServicePlane ":/IOResources/IOHIDSystem");
51 status = IOServiceOpen(iohidsystem, mach_task_self(), kIOHIDParamConnectType, &iohandle);
52 IOObjectRelease(iohidsystem);
63 // Tell startup code that we have a client
64 int cl_available = true;
66 qboolean vid_supportrefreshrate = false;
68 static qboolean vid_usingmouse = false;
69 static qboolean vid_usingmouse_relativeworks = false; // SDL2 workaround for unimplemented RelativeMouse mode
70 static qboolean vid_usinghidecursor = false;
71 static qboolean vid_hasfocus = false;
72 static qboolean vid_isfullscreen;
73 #if SDL_MAJOR_VERSION != 1
74 static qboolean vid_usingvsync = false;
76 static SDL_Joystick *vid_sdljoystick = NULL;
78 static int win_half_width = 50;
79 static int win_half_height = 50;
82 #if SDL_MAJOR_VERSION == 1
83 static SDL_Surface *screen;
84 static int video_flags;
86 static SDL_GLContext *context;
87 static SDL_Window *window;
88 static int window_flags;
90 static SDL_Surface *vid_softsurface;
92 /////////////////////////
95 //TODO: Add error checking
98 #define SDLK_PERCENT '%'
99 #define SDLK_PRINTSCREEN SDLK_PRINT
100 #define SDLK_SCROLLLOCK SDLK_SCROLLOCK
101 #define SDLK_NUMLOCKCLEAR SDLK_NUMLOCK
102 #define SDLK_KP_1 SDLK_KP1
103 #define SDLK_KP_2 SDLK_KP2
104 #define SDLK_KP_3 SDLK_KP3
105 #define SDLK_KP_4 SDLK_KP4
106 #define SDLK_KP_5 SDLK_KP5
107 #define SDLK_KP_6 SDLK_KP6
108 #define SDLK_KP_7 SDLK_KP7
109 #define SDLK_KP_8 SDLK_KP8
110 #define SDLK_KP_9 SDLK_KP9
111 #define SDLK_KP_0 SDLK_KP0
114 static int MapKey( unsigned int sdlkey )
119 // case SDLK_UNKNOWN: return K_UNKNOWN;
120 case SDLK_RETURN: return K_ENTER;
121 case SDLK_ESCAPE: return K_ESCAPE;
122 case SDLK_BACKSPACE: return K_BACKSPACE;
123 case SDLK_TAB: return K_TAB;
124 case SDLK_SPACE: return K_SPACE;
125 case SDLK_EXCLAIM: return '!';
126 case SDLK_QUOTEDBL: return '"';
127 case SDLK_HASH: return '#';
128 case SDLK_PERCENT: return '%';
129 case SDLK_DOLLAR: return '$';
130 case SDLK_AMPERSAND: return '&';
131 case SDLK_QUOTE: return '\'';
132 case SDLK_LEFTPAREN: return '(';
133 case SDLK_RIGHTPAREN: return ')';
134 case SDLK_ASTERISK: return '*';
135 case SDLK_PLUS: return '+';
136 case SDLK_COMMA: return ',';
137 case SDLK_MINUS: return '-';
138 case SDLK_PERIOD: return '.';
139 case SDLK_SLASH: return '/';
140 case SDLK_0: return '0';
141 case SDLK_1: return '1';
142 case SDLK_2: return '2';
143 case SDLK_3: return '3';
144 case SDLK_4: return '4';
145 case SDLK_5: return '5';
146 case SDLK_6: return '6';
147 case SDLK_7: return '7';
148 case SDLK_8: return '8';
149 case SDLK_9: return '9';
150 case SDLK_COLON: return ':';
151 case SDLK_SEMICOLON: return ';';
152 case SDLK_LESS: return '<';
153 case SDLK_EQUALS: return '=';
154 case SDLK_GREATER: return '>';
155 case SDLK_QUESTION: return '?';
156 case SDLK_AT: return '@';
157 case SDLK_LEFTBRACKET: return '[';
158 case SDLK_BACKSLASH: return '\\';
159 case SDLK_RIGHTBRACKET: return ']';
160 case SDLK_CARET: return '^';
161 case SDLK_UNDERSCORE: return '_';
162 case SDLK_BACKQUOTE: return '`';
163 case SDLK_a: return 'a';
164 case SDLK_b: return 'b';
165 case SDLK_c: return 'c';
166 case SDLK_d: return 'd';
167 case SDLK_e: return 'e';
168 case SDLK_f: return 'f';
169 case SDLK_g: return 'g';
170 case SDLK_h: return 'h';
171 case SDLK_i: return 'i';
172 case SDLK_j: return 'j';
173 case SDLK_k: return 'k';
174 case SDLK_l: return 'l';
175 case SDLK_m: return 'm';
176 case SDLK_n: return 'n';
177 case SDLK_o: return 'o';
178 case SDLK_p: return 'p';
179 case SDLK_q: return 'q';
180 case SDLK_r: return 'r';
181 case SDLK_s: return 's';
182 case SDLK_t: return 't';
183 case SDLK_u: return 'u';
184 case SDLK_v: return 'v';
185 case SDLK_w: return 'w';
186 case SDLK_x: return 'x';
187 case SDLK_y: return 'y';
188 case SDLK_z: return 'z';
189 case SDLK_CAPSLOCK: return K_CAPSLOCK;
190 case SDLK_F1: return K_F1;
191 case SDLK_F2: return K_F2;
192 case SDLK_F3: return K_F3;
193 case SDLK_F4: return K_F4;
194 case SDLK_F5: return K_F5;
195 case SDLK_F6: return K_F6;
196 case SDLK_F7: return K_F7;
197 case SDLK_F8: return K_F8;
198 case SDLK_F9: return K_F9;
199 case SDLK_F10: return K_F10;
200 case SDLK_F11: return K_F11;
201 case SDLK_F12: return K_F12;
202 #if SDL_MAJOR_VERSION == 1
203 case SDLK_PRINTSCREEN: return K_PRINTSCREEN;
204 case SDLK_SCROLLLOCK: return K_SCROLLOCK;
206 case SDLK_PAUSE: return K_PAUSE;
207 case SDLK_INSERT: return K_INS;
208 case SDLK_HOME: return K_HOME;
209 case SDLK_PAGEUP: return K_PGUP;
211 case SDLK_DELETE: return K_BACKSPACE;
213 case SDLK_DELETE: return K_DEL;
215 case SDLK_END: return K_END;
216 case SDLK_PAGEDOWN: return K_PGDN;
217 case SDLK_RIGHT: return K_RIGHTARROW;
218 case SDLK_LEFT: return K_LEFTARROW;
219 case SDLK_DOWN: return K_DOWNARROW;
220 case SDLK_UP: return K_UPARROW;
221 #if SDL_MAJOR_VERSION == 1
222 case SDLK_NUMLOCKCLEAR: return K_NUMLOCK;
224 case SDLK_KP_DIVIDE: return K_KP_DIVIDE;
225 case SDLK_KP_MULTIPLY: return K_KP_MULTIPLY;
226 case SDLK_KP_MINUS: return K_KP_MINUS;
227 case SDLK_KP_PLUS: return K_KP_PLUS;
228 case SDLK_KP_ENTER: return K_KP_ENTER;
229 #if SDL_MAJOR_VERSION == 1
230 case SDLK_KP_1: return K_KP_1;
231 case SDLK_KP_2: return K_KP_2;
232 case SDLK_KP_3: return K_KP_3;
233 case SDLK_KP_4: return K_KP_4;
234 case SDLK_KP_5: return K_KP_5;
235 case SDLK_KP_6: return K_KP_6;
236 case SDLK_KP_7: return K_KP_7;
237 case SDLK_KP_8: return K_KP_8;
238 case SDLK_KP_9: return K_KP_9;
239 case SDLK_KP_0: return K_KP_0;
241 case SDLK_KP_PERIOD: return K_KP_PERIOD;
242 // case SDLK_APPLICATION: return K_APPLICATION;
243 // case SDLK_POWER: return K_POWER;
244 case SDLK_KP_EQUALS: return K_KP_EQUALS;
245 // case SDLK_F13: return K_F13;
246 // case SDLK_F14: return K_F14;
247 // case SDLK_F15: return K_F15;
248 // case SDLK_F16: return K_F16;
249 // case SDLK_F17: return K_F17;
250 // case SDLK_F18: return K_F18;
251 // case SDLK_F19: return K_F19;
252 // case SDLK_F20: return K_F20;
253 // case SDLK_F21: return K_F21;
254 // case SDLK_F22: return K_F22;
255 // case SDLK_F23: return K_F23;
256 // case SDLK_F24: return K_F24;
257 // case SDLK_EXECUTE: return K_EXECUTE;
258 // case SDLK_HELP: return K_HELP;
259 // case SDLK_MENU: return K_MENU;
260 // case SDLK_SELECT: return K_SELECT;
261 // case SDLK_STOP: return K_STOP;
262 // case SDLK_AGAIN: return K_AGAIN;
263 // case SDLK_UNDO: return K_UNDO;
264 // case SDLK_CUT: return K_CUT;
265 // case SDLK_COPY: return K_COPY;
266 // case SDLK_PASTE: return K_PASTE;
267 // case SDLK_FIND: return K_FIND;
268 // case SDLK_MUTE: return K_MUTE;
269 // case SDLK_VOLUMEUP: return K_VOLUMEUP;
270 // case SDLK_VOLUMEDOWN: return K_VOLUMEDOWN;
271 // case SDLK_KP_COMMA: return K_KP_COMMA;
272 // case SDLK_KP_EQUALSAS400: return K_KP_EQUALSAS400;
273 // case SDLK_ALTERASE: return K_ALTERASE;
274 // case SDLK_SYSREQ: return K_SYSREQ;
275 // case SDLK_CANCEL: return K_CANCEL;
276 // case SDLK_CLEAR: return K_CLEAR;
277 // case SDLK_PRIOR: return K_PRIOR;
278 // case SDLK_RETURN2: return K_RETURN2;
279 // case SDLK_SEPARATOR: return K_SEPARATOR;
280 // case SDLK_OUT: return K_OUT;
281 // case SDLK_OPER: return K_OPER;
282 // case SDLK_CLEARAGAIN: return K_CLEARAGAIN;
283 // case SDLK_CRSEL: return K_CRSEL;
284 // case SDLK_EXSEL: return K_EXSEL;
285 // case SDLK_KP_00: return K_KP_00;
286 // case SDLK_KP_000: return K_KP_000;
287 // case SDLK_THOUSANDSSEPARATOR: return K_THOUSANDSSEPARATOR;
288 // case SDLK_DECIMALSEPARATOR: return K_DECIMALSEPARATOR;
289 // case SDLK_CURRENCYUNIT: return K_CURRENCYUNIT;
290 // case SDLK_CURRENCYSUBUNIT: return K_CURRENCYSUBUNIT;
291 // case SDLK_KP_LEFTPAREN: return K_KP_LEFTPAREN;
292 // case SDLK_KP_RIGHTPAREN: return K_KP_RIGHTPAREN;
293 // case SDLK_KP_LEFTBRACE: return K_KP_LEFTBRACE;
294 // case SDLK_KP_RIGHTBRACE: return K_KP_RIGHTBRACE;
295 // case SDLK_KP_TAB: return K_KP_TAB;
296 // case SDLK_KP_BACKSPACE: return K_KP_BACKSPACE;
297 // case SDLK_KP_A: return K_KP_A;
298 // case SDLK_KP_B: return K_KP_B;
299 // case SDLK_KP_C: return K_KP_C;
300 // case SDLK_KP_D: return K_KP_D;
301 // case SDLK_KP_E: return K_KP_E;
302 // case SDLK_KP_F: return K_KP_F;
303 // case SDLK_KP_XOR: return K_KP_XOR;
304 // case SDLK_KP_POWER: return K_KP_POWER;
305 // case SDLK_KP_PERCENT: return K_KP_PERCENT;
306 // case SDLK_KP_LESS: return K_KP_LESS;
307 // case SDLK_KP_GREATER: return K_KP_GREATER;
308 // case SDLK_KP_AMPERSAND: return K_KP_AMPERSAND;
309 // case SDLK_KP_DBLAMPERSAND: return K_KP_DBLAMPERSAND;
310 // case SDLK_KP_VERTICALBAR: return K_KP_VERTICALBAR;
311 // case SDLK_KP_DBLVERTICALBAR: return K_KP_DBLVERTICALBAR;
312 // case SDLK_KP_COLON: return K_KP_COLON;
313 // case SDLK_KP_HASH: return K_KP_HASH;
314 // case SDLK_KP_SPACE: return K_KP_SPACE;
315 // case SDLK_KP_AT: return K_KP_AT;
316 // case SDLK_KP_EXCLAM: return K_KP_EXCLAM;
317 // case SDLK_KP_MEMSTORE: return K_KP_MEMSTORE;
318 // case SDLK_KP_MEMRECALL: return K_KP_MEMRECALL;
319 // case SDLK_KP_MEMCLEAR: return K_KP_MEMCLEAR;
320 // case SDLK_KP_MEMADD: return K_KP_MEMADD;
321 // case SDLK_KP_MEMSUBTRACT: return K_KP_MEMSUBTRACT;
322 // case SDLK_KP_MEMMULTIPLY: return K_KP_MEMMULTIPLY;
323 // case SDLK_KP_MEMDIVIDE: return K_KP_MEMDIVIDE;
324 // case SDLK_KP_PLUSMINUS: return K_KP_PLUSMINUS;
325 // case SDLK_KP_CLEAR: return K_KP_CLEAR;
326 // case SDLK_KP_CLEARENTRY: return K_KP_CLEARENTRY;
327 // case SDLK_KP_BINARY: return K_KP_BINARY;
328 // case SDLK_KP_OCTAL: return K_KP_OCTAL;
329 // case SDLK_KP_DECIMAL: return K_KP_DECIMAL;
330 // case SDLK_KP_HEXADECIMAL: return K_KP_HEXADECIMAL;
331 case SDLK_LCTRL: return K_CTRL;
332 case SDLK_LSHIFT: return K_SHIFT;
333 case SDLK_LALT: return K_ALT;
334 // case SDLK_LGUI: return K_LGUI;
335 case SDLK_RCTRL: return K_CTRL;
336 case SDLK_RSHIFT: return K_SHIFT;
337 case SDLK_RALT: return K_ALT;
338 // case SDLK_RGUI: return K_RGUI;
339 // case SDLK_MODE: return K_MODE;
340 // case SDLK_AUDIONEXT: return K_AUDIONEXT;
341 // case SDLK_AUDIOPREV: return K_AUDIOPREV;
342 // case SDLK_AUDIOSTOP: return K_AUDIOSTOP;
343 // case SDLK_AUDIOPLAY: return K_AUDIOPLAY;
344 // case SDLK_AUDIOMUTE: return K_AUDIOMUTE;
345 // case SDLK_MEDIASELECT: return K_MEDIASELECT;
346 // case SDLK_WWW: return K_WWW;
347 // case SDLK_MAIL: return K_MAIL;
348 // case SDLK_CALCULATOR: return K_CALCULATOR;
349 // case SDLK_COMPUTER: return K_COMPUTER;
350 // case SDLK_AC_SEARCH: return K_AC_SEARCH;
351 // case SDLK_AC_HOME: return K_AC_HOME;
352 // case SDLK_AC_BACK: return K_AC_BACK;
353 // case SDLK_AC_FORWARD: return K_AC_FORWARD;
354 // case SDLK_AC_STOP: return K_AC_STOP;
355 // case SDLK_AC_REFRESH: return K_AC_REFRESH;
356 // case SDLK_AC_BOOKMARKS: return K_AC_BOOKMARKS;
357 // case SDLK_BRIGHTNESSDOWN: return K_BRIGHTNESSDOWN;
358 // case SDLK_BRIGHTNESSUP: return K_BRIGHTNESSUP;
359 // case SDLK_DISPLAYSWITCH: return K_DISPLAYSWITCH;
360 // case SDLK_KBDILLUMTOGGLE: return K_KBDILLUMTOGGLE;
361 // case SDLK_KBDILLUMDOWN: return K_KBDILLUMDOWN;
362 // case SDLK_KBDILLUMUP: return K_KBDILLUMUP;
363 // case SDLK_EJECT: return K_EJECT;
364 // case SDLK_SLEEP: return K_SLEEP;
369 int SDL_iPhoneKeyboardShow(SDL_Window * window); // reveals the onscreen keyboard. Returns 0 on success and -1 on error.
370 int SDL_iPhoneKeyboardHide(SDL_Window * window); // hides the onscreen keyboard. Returns 0 on success and -1 on error.
371 SDL_bool SDL_iPhoneKeyboardIsShown(SDL_Window * window); // returns whether or not the onscreen keyboard is currently visible.
372 int SDL_iPhoneKeyboardToggle(SDL_Window * window); // toggles the visibility of the onscreen keyboard. Returns 0 on success and -1 on error.
375 static void VID_ShowKeyboard(qboolean show)
380 if (!SDL_iPhoneKeyboardIsShown(window))
381 SDL_iPhoneKeyboardShow(window);
385 if (SDL_iPhoneKeyboardIsShown(window))
386 SDL_iPhoneKeyboardHide(window);
392 qboolean VID_ShowingKeyboard(void)
394 return SDL_iPhoneKeyboardIsShown(window);
398 void VID_SetMouse(qboolean fullscreengrab, qboolean relative, qboolean hidecursor)
403 if(vid_usingmouse && (vid_usingnoaccel != !!apple_mouse_noaccel.integer))
404 VID_SetMouse(false, false, false); // ungrab first!
406 if (vid_usingmouse != relative)
408 vid_usingmouse = relative;
409 cl_ignoremousemoves = 2;
410 #if SDL_MAJOR_VERSION == 1
411 SDL_WM_GrabInput( relative ? SDL_GRAB_ON : SDL_GRAB_OFF );
413 vid_usingmouse_relativeworks = SDL_SetRelativeMouseMode(relative ? SDL_TRUE : SDL_FALSE) == 0;
414 // Con_Printf("VID_SetMouse(%i, %i, %i) relativeworks = %i\n", (int)fullscreengrab, (int)relative, (int)hidecursor, (int)vid_usingmouse_relativeworks);
419 // Save the status of mouse acceleration
420 originalMouseSpeed = -1.0; // in case of error
421 if(apple_mouse_noaccel.integer)
423 io_connect_t mouseDev = IN_GetIOHandle();
426 if(IOHIDGetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), &originalMouseSpeed) == kIOReturnSuccess)
428 Con_DPrintf("previous mouse acceleration: %f\n", originalMouseSpeed);
429 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), -1.0) != kIOReturnSuccess)
431 Con_Print("Could not disable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
432 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
437 Con_Print("Could not disable mouse acceleration (failed at IOHIDGetAccelerationWithKey).\n");
438 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
440 IOServiceClose(mouseDev);
444 Con_Print("Could not disable mouse acceleration (failed at IO_GetIOHandle).\n");
445 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
449 vid_usingnoaccel = !!apple_mouse_noaccel.integer;
453 if(originalMouseSpeed != -1.0)
455 io_connect_t mouseDev = IN_GetIOHandle();
458 Con_DPrintf("restoring mouse acceleration to: %f\n", originalMouseSpeed);
459 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), originalMouseSpeed) != kIOReturnSuccess)
460 Con_Print("Could not re-enable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
461 IOServiceClose(mouseDev);
464 Con_Print("Could not re-enable mouse acceleration (failed at IO_GetIOHandle).\n");
469 if (vid_usinghidecursor != hidecursor)
471 vid_usinghidecursor = hidecursor;
472 SDL_ShowCursor( hidecursor ? SDL_DISABLE : SDL_ENABLE);
477 // multitouch[10][] represents the mouse pointer
478 // X and Y coordinates are 0-32767 as per SDL spec
479 #define MAXFINGERS 11
480 int multitouch[MAXFINGERS][3];
482 static qboolean VID_TouchscreenArea(int corner, float px, float py, float pwidth, float pheight, const char *icon, float *resultmove, qboolean *resultbutton, keynum_t key)
485 float fx, fy, fwidth, fheight;
487 qboolean button = false;
489 if (pwidth > 0 && pheight > 0)
491 if (!VID_ShowingKeyboard())
494 if (corner & 1) px += vid_conwidth.value;
495 if (corner & 2) py += vid_conheight.value;
496 if (corner & 4) px += vid_conwidth.value * 0.5f;
497 if (corner & 8) py += vid_conheight.value * 0.5f;
498 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);}
499 fx = px * 32768.0f / vid_conwidth.value;
500 fy = py * 32768.0f / vid_conheight.value;
501 fwidth = pwidth * 32768.0f / vid_conwidth.value;
502 fheight = pheight * 32768.0f / vid_conheight.value;
503 for (finger = 0;finger < MAXFINGERS;finger++)
505 if (multitouch[finger][0] && multitouch[finger][1] >= fx && multitouch[finger][2] >= fy && multitouch[finger][1] < fx + fwidth && multitouch[finger][2] < fy + fheight)
507 rel[0] = (multitouch[finger][1] - (fx + 0.5f * fwidth)) * (2.0f / fwidth);
508 rel[1] = (multitouch[finger][2] - (fy + 0.5f * fheight)) * (2.0f / fheight);
514 if (scr_numtouchscreenareas < 16)
516 scr_touchscreenareas[scr_numtouchscreenareas].pic = icon;
517 scr_touchscreenareas[scr_numtouchscreenareas].rect[0] = px;
518 scr_touchscreenareas[scr_numtouchscreenareas].rect[1] = py;
519 scr_touchscreenareas[scr_numtouchscreenareas].rect[2] = pwidth;
520 scr_touchscreenareas[scr_numtouchscreenareas].rect[3] = pheight;
521 scr_touchscreenareas[scr_numtouchscreenareas].active = button;
522 scr_numtouchscreenareas++;
528 VectorCopy(rel, resultmove);
530 VectorClear(resultmove);
534 if (*resultbutton != button && (int)key > 0)
535 Key_Event(key, 0, button);
536 *resultbutton = button;
541 void VID_BuildJoyState(vid_joystate_t *joystate)
543 VID_Shared_BuildJoyState_Begin(joystate);
547 SDL_Joystick *joy = vid_sdljoystick;
551 numaxes = SDL_JoystickNumAxes(joy);
552 for (j = 0;j < numaxes;j++)
553 joystate->axis[j] = SDL_JoystickGetAxis(joy, j) * (1.0f / 32767.0f);
554 numbuttons = SDL_JoystickNumButtons(joy);
555 for (j = 0;j < numbuttons;j++)
556 joystate->button[j] = SDL_JoystickGetButton(joy, j);
559 VID_Shared_BuildJoyState_Finish(joystate);
562 /////////////////////
568 static int old_x = 0, old_y = 0;
569 static int stuck = 0;
571 vid_joystate_t joystate;
573 scr_numtouchscreenareas = 0;
574 if (vid_touchscreen.integer)
576 float move[3], aim[3], click[3];
577 static qboolean buttons[16];
578 static keydest_t oldkeydest;
579 keydest_t keydest = (key_consoleactive & KEY_CONSOLEACTIVE_USER) ? key_console : key_dest;
580 multitouch[MAXFINGERS-1][0] = SDL_GetMouseState(&x, &y);
581 multitouch[MAXFINGERS-1][1] = x * 32768 / vid.width;
582 multitouch[MAXFINGERS-1][2] = y * 32768 / vid.height;
583 if (oldkeydest != keydest)
587 case key_game: VID_ShowKeyboard(false);break;
588 case key_console: VID_ShowKeyboard(true);break;
589 case key_message: VID_ShowKeyboard(true);break;
593 oldkeydest = keydest;
594 // top of screen is toggleconsole and K_ESCAPE
599 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
600 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
601 if (!VID_ShowingKeyboard())
603 // user entered a command, close the console now
604 Con_ToggleConsole_f();
607 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
608 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
609 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
610 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
611 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
612 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
616 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
617 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
619 VID_TouchscreenArea( 2, 0,-128, 128, 128, "gfx/touch_movebutton.tga" , move, &buttons[0], K_MOUSE4);
620 VID_TouchscreenArea( 3,-128,-128, 128, 128, "gfx/touch_aimbutton.tga" , aim, &buttons[1], K_MOUSE5);
621 VID_TouchscreenArea( 2, 0,-160, 64, 32, "gfx/touch_jumpbutton.tga" , NULL, &buttons[3], K_SPACE);
622 VID_TouchscreenArea( 3,-128,-160, 64, 32, "gfx/touch_attackbutton.tga" , NULL, &buttons[2], K_MOUSE1);
623 VID_TouchscreenArea( 3, -64,-160, 64, 32, "gfx/touch_attack2button.tga", NULL, &buttons[4], K_MOUSE2);
628 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
629 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
630 // in menus, an icon in the corner activates keyboard
631 VID_TouchscreenArea( 2, 0, -32, 32, 32, "gfx/touch_keyboard.tga" , NULL, &buttons[15], (keynum_t)0);
633 VID_ShowKeyboard(true);
634 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
635 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
636 VID_TouchscreenArea(16, -320,-480,640, 960, NULL , click,&buttons[2], K_MOUSE1);
637 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
638 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
641 in_windowmouse_x = x;
642 in_windowmouse_y = y;
645 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
646 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
647 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
648 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
649 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
650 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
654 cl.cmd.forwardmove -= move[1] * cl_forwardspeed.value;
655 cl.cmd.sidemove += move[0] * cl_sidespeed.value;
656 cl.viewangles[0] += aim[1] * cl_pitchspeed.value * cl.realframetime;
657 cl.viewangles[1] -= aim[0] * cl_yawspeed.value * cl.realframetime;
663 if (vid_stick_mouse.integer || !vid_usingmouse_relativeworks)
665 // have the mouse stuck in the middle, example use: prevent expose effect of beryl during the game when not using
666 // window grabbing. --blub
668 // we need 2 frames to initialize the center position
671 #if SDL_MAJOR_VERSION == 1
672 SDL_WarpMouse(win_half_width, win_half_height);
674 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
676 SDL_GetMouseState(&x, &y);
677 SDL_GetRelativeMouseState(&x, &y);
680 SDL_GetRelativeMouseState(&x, &y);
681 in_mouse_x = x + old_x;
682 in_mouse_y = y + old_y;
683 SDL_GetMouseState(&x, &y);
684 old_x = x - win_half_width;
685 old_y = y - win_half_height;
686 #if SDL_MAJOR_VERSION == 1
687 SDL_WarpMouse(win_half_width, win_half_height);
689 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
693 SDL_GetRelativeMouseState( &x, &y );
699 SDL_GetMouseState(&x, &y);
700 in_windowmouse_x = x;
701 in_windowmouse_y = y;
704 VID_BuildJoyState(&joystate);
705 VID_ApplyJoyState(&joystate);
708 /////////////////////
713 static qboolean sdl_needs_restart;
714 static void sdl_start(void)
717 static void sdl_shutdown(void)
719 sdl_needs_restart = false;
721 static void sdl_newmap(void)
727 static keynum_t buttonremap[18] =
750 #if SDL_MAJOR_VERSION == 1
752 void Sys_SendKeyEvents( void )
754 static qboolean sound_active = true;
758 VID_EnableJoystick(true);
760 while( SDL_PollEvent( &event ) )
761 switch( event.type ) {
767 keycode = MapKey(event.key.keysym.sym);
768 if (!VID_JoyBlockEmulatedKeys(keycode))
769 Key_Event(keycode, event.key.keysym.unicode, (event.key.state == SDL_PRESSED));
771 case SDL_ACTIVEEVENT:
772 if( event.active.state & SDL_APPACTIVE )
774 if( event.active.gain )
780 case SDL_MOUSEBUTTONDOWN:
781 case SDL_MOUSEBUTTONUP:
782 if (!vid_touchscreen.integer)
783 if (event.button.button <= 18)
784 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
786 case SDL_JOYBUTTONDOWN:
787 case SDL_JOYBUTTONUP:
788 case SDL_JOYAXISMOTION:
789 case SDL_JOYBALLMOTION:
790 case SDL_JOYHATMOTION:
792 case SDL_VIDEOEXPOSE:
794 case SDL_VIDEORESIZE:
795 if(vid_resizable.integer < 2)
797 vid.width = event.resize.w;
798 vid.height = event.resize.h;
799 screen = SDL_SetVideoMode(vid.width, vid.height, video_bpp, video_flags);
802 SDL_FreeSurface(vid_softsurface);
803 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
804 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
805 SDL_SetAlpha(vid_softsurface, 0, 255);
806 if (vid.softdepthpixels)
807 free(vid.softdepthpixels);
808 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
811 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
812 // so, let's better queue it for next frame
813 if(!sdl_needs_restart)
815 Cbuf_AddText("\nr_restart\n");
816 sdl_needs_restart = true;
821 #if SDL_MAJOR_VERSION != 1
822 case SDL_TEXTEDITING:
827 case SDL_MOUSEMOTION:
830 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
834 // enable/disable sound on focus gain/loss
835 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
848 sound_active = false;
856 void Sys_SendKeyEvents( void )
858 static qboolean sound_active = true;
865 VID_EnableJoystick(true);
867 while( SDL_PollEvent( &event ) )
868 switch( event.type ) {
874 keycode = MapKey(event.key.keysym.sym);
875 if (!VID_JoyBlockEmulatedKeys(keycode))
876 Key_Event(keycode, 0, (event.key.state == SDL_PRESSED));
878 case SDL_MOUSEBUTTONDOWN:
879 case SDL_MOUSEBUTTONUP:
880 if (!vid_touchscreen.integer)
881 if (event.button.button <= 18)
882 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
884 case SDL_JOYBUTTONDOWN:
885 case SDL_JOYBUTTONUP:
886 case SDL_JOYAXISMOTION:
887 case SDL_JOYBALLMOTION:
888 case SDL_JOYHATMOTION:
890 case SDL_WINDOWEVENT:
891 //if (event.window.windowID == window) // how to compare?
893 switch(event.window.event)
895 case SDL_WINDOWEVENT_SHOWN:
898 case SDL_WINDOWEVENT_HIDDEN:
901 case SDL_WINDOWEVENT_EXPOSED:
903 case SDL_WINDOWEVENT_MOVED:
905 case SDL_WINDOWEVENT_RESIZED:
906 if(vid_resizable.integer < 2)
908 vid.width = event.window.data1;
909 vid.height = event.window.data2;
912 SDL_FreeSurface(vid_softsurface);
913 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
914 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
915 if (vid.softdepthpixels)
916 free(vid.softdepthpixels);
917 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
920 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
921 // so, let's better queue it for next frame
922 if(!sdl_needs_restart)
924 Cbuf_AddText("\nr_restart\n");
925 sdl_needs_restart = true;
930 case SDL_WINDOWEVENT_MINIMIZED:
932 case SDL_WINDOWEVENT_MAXIMIZED:
934 case SDL_WINDOWEVENT_RESTORED:
936 case SDL_WINDOWEVENT_ENTER:
938 case SDL_WINDOWEVENT_LEAVE:
940 case SDL_WINDOWEVENT_FOCUS_GAINED:
943 case SDL_WINDOWEVENT_FOCUS_LOST:
944 vid_hasfocus = false;
946 case SDL_WINDOWEVENT_CLOSE:
952 case SDL_TEXTEDITING:
953 // FIXME! this is where composition gets supported
956 // we have some characters to parse
959 for (i = 0;event.text.text[i];)
961 unicode = event.text.text[i++];
965 // strip high bits (we could count these to validate character length but we don't)
966 for (j = 0x80;unicode & j;j >>= 1)
968 for (;(event.text.text[i] & 0xC0) == 0x80;i++)
969 unicode = (unicode << 6) | (event.text.text[i] & 0x3F);
970 // low characters are invalid and could be bad, so replace them
972 unicode = '?'; // we could use 0xFFFD instead, the unicode substitute character
974 //Con_DPrintf("SDL_TEXTINPUT: K_TEXT %i \n", unicode);
975 Key_Event(K_TEXT, unicode, true);
976 Key_Event(K_TEXT, unicode, false);
980 case SDL_MOUSEMOTION:
983 Con_DPrintf("SDL_FINGERDOWN for finger %i\n", (int)event.tfinger.fingerId);
984 for (i = 0;i < MAXFINGERS-1;i++)
986 if (!multitouch[i][0])
988 multitouch[i][0] = event.tfinger.fingerId;
989 multitouch[i][1] = event.tfinger.x;
990 multitouch[i][2] = event.tfinger.y;
991 // TODO: use event.tfinger.pressure?
995 if (i == MAXFINGERS-1)
996 Con_DPrintf("Too many fingers at once!\n");
999 Con_DPrintf("SDL_FINGERUP for finger %i\n", (int)event.tfinger.fingerId);
1000 for (i = 0;i < MAXFINGERS-1;i++)
1002 if (multitouch[i][0] == event.tfinger.fingerId)
1004 multitouch[i][0] = 0;
1008 if (i == MAXFINGERS-1)
1009 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1011 case SDL_FINGERMOTION:
1012 Con_DPrintf("SDL_FINGERMOTION for finger %i\n", (int)event.tfinger.fingerId);
1013 for (i = 0;i < MAXFINGERS-1;i++)
1015 if (multitouch[i][0] == event.tfinger.fingerId)
1017 multitouch[i][1] = event.tfinger.x;
1018 multitouch[i][2] = event.tfinger.y;
1022 if (i == MAXFINGERS-1)
1023 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1025 case SDL_TOUCHBUTTONDOWN:
1026 // not sure what to do with this...
1028 case SDL_TOUCHBUTTONUP:
1029 // not sure what to do with this...
1032 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
1036 // enable/disable sound on focus gain/loss
1037 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
1042 sound_active = true;
1050 sound_active = false;
1063 #include <OpenGLES/ES2/gl.h>
1065 #include <SDL_opengles.h>
1068 //#define PRECALL //Con_Printf("GLCALL %s:%i\n", __FILE__, __LINE__)
1071 GLboolean wrapglIsBuffer(GLuint buffer) {PRECALL;return glIsBuffer(buffer);POSTCALL;}
1072 GLboolean wrapglIsEnabled(GLenum cap) {PRECALL;return glIsEnabled(cap);POSTCALL;}
1073 GLboolean wrapglIsFramebuffer(GLuint framebuffer) {PRECALL;return glIsFramebuffer(framebuffer);POSTCALL;}
1074 //GLboolean wrapglIsQuery(GLuint qid) {PRECALL;return glIsQuery(qid);POSTCALL;}
1075 GLboolean wrapglIsRenderbuffer(GLuint renderbuffer) {PRECALL;return glIsRenderbuffer(renderbuffer);POSTCALL;}
1076 //GLboolean wrapglUnmapBuffer(GLenum target) {PRECALL;return glUnmapBuffer(target);POSTCALL;}
1077 GLenum wrapglCheckFramebufferStatus(GLenum target) {PRECALL;return glCheckFramebufferStatus(target);POSTCALL;}
1078 GLenum wrapglGetError(void) {PRECALL;return glGetError();POSTCALL;}
1079 GLuint wrapglCreateProgram(void) {PRECALL;return glCreateProgram();POSTCALL;}
1080 GLuint wrapglCreateShader(GLenum shaderType) {PRECALL;return glCreateShader(shaderType);POSTCALL;}
1081 //GLuint wrapglGetHandle(GLenum pname) {PRECALL;return glGetHandle(pname);POSTCALL;}
1082 GLint wrapglGetAttribLocation(GLuint programObj, const GLchar *name) {PRECALL;return glGetAttribLocation(programObj, name);POSTCALL;}
1083 GLint wrapglGetUniformLocation(GLuint programObj, const GLchar *name) {PRECALL;return glGetUniformLocation(programObj, name);POSTCALL;}
1084 //GLvoid* wrapglMapBuffer(GLenum target, GLenum access) {PRECALL;return glMapBuffer(target, access);POSTCALL;}
1085 const GLubyte* wrapglGetString(GLenum name) {PRECALL;return (const GLubyte*)glGetString(name);POSTCALL;}
1086 void wrapglActiveStencilFace(GLenum e) {PRECALL;Con_Printf("glActiveStencilFace(e)\n");POSTCALL;}
1087 void wrapglActiveTexture(GLenum e) {PRECALL;glActiveTexture(e);POSTCALL;}
1088 void wrapglAlphaFunc(GLenum func, GLclampf ref) {PRECALL;Con_Printf("glAlphaFunc(func, ref)\n");POSTCALL;}
1089 void wrapglArrayElement(GLint i) {PRECALL;Con_Printf("glArrayElement(i)\n");POSTCALL;}
1090 void wrapglAttachShader(GLuint containerObj, GLuint obj) {PRECALL;glAttachShader(containerObj, obj);POSTCALL;}
1091 //void wrapglBegin(GLenum mode) {PRECALL;Con_Printf("glBegin(mode)\n");POSTCALL;}
1092 //void wrapglBeginQuery(GLenum target, GLuint qid) {PRECALL;glBeginQuery(target, qid);POSTCALL;}
1093 void wrapglBindAttribLocation(GLuint programObj, GLuint index, const GLchar *name) {PRECALL;glBindAttribLocation(programObj, index, name);POSTCALL;}
1094 //void wrapglBindFragDataLocation(GLuint programObj, GLuint index, const GLchar *name) {PRECALL;glBindFragDataLocation(programObj, index, name);POSTCALL;}
1095 void wrapglBindBuffer(GLenum target, GLuint buffer) {PRECALL;glBindBuffer(target, buffer);POSTCALL;}
1096 void wrapglBindFramebuffer(GLenum target, GLuint framebuffer) {PRECALL;glBindFramebuffer(target, framebuffer);POSTCALL;}
1097 void wrapglBindRenderbuffer(GLenum target, GLuint renderbuffer) {PRECALL;glBindRenderbuffer(target, renderbuffer);POSTCALL;}
1098 void wrapglBindTexture(GLenum target, GLuint texture) {PRECALL;glBindTexture(target, texture);POSTCALL;}
1099 void wrapglBlendEquation(GLenum e) {PRECALL;glBlendEquation(e);POSTCALL;}
1100 void wrapglBlendFunc(GLenum sfactor, GLenum dfactor) {PRECALL;glBlendFunc(sfactor, dfactor);POSTCALL;}
1101 void wrapglBufferData(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage) {PRECALL;glBufferData(target, size, data, usage);POSTCALL;}
1102 void wrapglBufferSubData(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data) {PRECALL;glBufferSubData(target, offset, size, data);POSTCALL;}
1103 void wrapglClear(GLbitfield mask) {PRECALL;glClear(mask);POSTCALL;}
1104 void wrapglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {PRECALL;glClearColor(red, green, blue, alpha);POSTCALL;}
1105 void wrapglClearDepth(GLclampd depth) {PRECALL;/*Con_Printf("glClearDepth(%f)\n", depth);glClearDepthf((float)depth);*/POSTCALL;}
1106 void wrapglClearStencil(GLint s) {PRECALL;glClearStencil(s);POSTCALL;}
1107 void wrapglClientActiveTexture(GLenum target) {PRECALL;Con_Printf("glClientActiveTexture(target)\n");POSTCALL;}
1108 void wrapglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {PRECALL;Con_Printf("glColor4f(red, green, blue, alpha)\n");POSTCALL;}
1109 void wrapglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {PRECALL;Con_Printf("glColor4ub(red, green, blue, alpha)\n");POSTCALL;}
1110 void wrapglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {PRECALL;glColorMask(red, green, blue, alpha);POSTCALL;}
1111 void wrapglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glColorPointer(size, type, stride, ptr)\n");POSTCALL;}
1112 void wrapglCompileShader(GLuint shaderObj) {PRECALL;glCompileShader(shaderObj);POSTCALL;}
1113 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;}
1114 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;}
1115 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;}
1116 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;}
1117 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;}
1118 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;}
1119 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;}
1120 void wrapglCullFace(GLenum mode) {PRECALL;glCullFace(mode);POSTCALL;}
1121 void wrapglDeleteBuffers(GLsizei n, const GLuint *buffers) {PRECALL;glDeleteBuffers(n, buffers);POSTCALL;}
1122 void wrapglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {PRECALL;glDeleteFramebuffers(n, framebuffers);POSTCALL;}
1123 void wrapglDeleteShader(GLuint obj) {PRECALL;glDeleteShader(obj);POSTCALL;}
1124 void wrapglDeleteProgram(GLuint obj) {PRECALL;glDeleteProgram(obj);POSTCALL;}
1125 //void wrapglDeleteQueries(GLsizei n, const GLuint *ids) {PRECALL;glDeleteQueries(n, ids);POSTCALL;}
1126 void wrapglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {PRECALL;glDeleteRenderbuffers(n, renderbuffers);POSTCALL;}
1127 void wrapglDeleteTextures(GLsizei n, const GLuint *textures) {PRECALL;glDeleteTextures(n, textures);POSTCALL;}
1128 void wrapglDepthFunc(GLenum func) {PRECALL;glDepthFunc(func);POSTCALL;}
1129 void wrapglDepthMask(GLboolean flag) {PRECALL;glDepthMask(flag);POSTCALL;}
1130 //void wrapglDepthRange(GLclampd near_val, GLclampd far_val) {PRECALL;glDepthRangef((float)near_val, (float)far_val);POSTCALL;}
1131 void wrapglDepthRangef(GLclampf near_val, GLclampf far_val) {PRECALL;glDepthRangef(near_val, far_val);POSTCALL;}
1132 void wrapglDetachShader(GLuint containerObj, GLuint attachedObj) {PRECALL;glDetachShader(containerObj, attachedObj);POSTCALL;}
1133 void wrapglDisable(GLenum cap) {PRECALL;glDisable(cap);POSTCALL;}
1134 void wrapglDisableClientState(GLenum cap) {PRECALL;Con_Printf("glDisableClientState(cap)\n");POSTCALL;}
1135 void wrapglDisableVertexAttribArray(GLuint index) {PRECALL;glDisableVertexAttribArray(index);POSTCALL;}
1136 void wrapglDrawArrays(GLenum mode, GLint first, GLsizei count) {PRECALL;glDrawArrays(mode, first, count);POSTCALL;}
1137 void wrapglDrawBuffer(GLenum mode) {PRECALL;Con_Printf("glDrawBuffer(mode)\n");POSTCALL;}
1138 void wrapglDrawBuffers(GLsizei n, const GLenum *bufs) {PRECALL;Con_Printf("glDrawBuffers(n, bufs)\n");POSTCALL;}
1139 void wrapglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawElements(mode, count, type, indices);POSTCALL;}
1140 //void wrapglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawRangeElements(mode, start, end, count, type, indices);POSTCALL;}
1141 //void wrapglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawRangeElements(mode, start, end, count, type, indices);POSTCALL;}
1142 void wrapglEnable(GLenum cap) {PRECALL;glEnable(cap);POSTCALL;}
1143 void wrapglEnableClientState(GLenum cap) {PRECALL;Con_Printf("glEnableClientState(cap)\n");POSTCALL;}
1144 void wrapglEnableVertexAttribArray(GLuint index) {PRECALL;glEnableVertexAttribArray(index);POSTCALL;}
1145 //void wrapglEnd(void) {PRECALL;Con_Printf("glEnd()\n");POSTCALL;}
1146 //void wrapglEndQuery(GLenum target) {PRECALL;glEndQuery(target);POSTCALL;}
1147 void wrapglFinish(void) {PRECALL;glFinish();POSTCALL;}
1148 void wrapglFlush(void) {PRECALL;glFlush();POSTCALL;}
1149 void wrapglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {PRECALL;glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);POSTCALL;}
1150 void wrapglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {PRECALL;glFramebufferTexture2D(target, attachment, textarget, texture, level);POSTCALL;}
1151 void wrapglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {PRECALL;Con_Printf("glFramebufferTexture3D()\n");POSTCALL;}
1152 void wrapglGenBuffers(GLsizei n, GLuint *buffers) {PRECALL;glGenBuffers(n, buffers);POSTCALL;}
1153 void wrapglGenFramebuffers(GLsizei n, GLuint *framebuffers) {PRECALL;glGenFramebuffers(n, framebuffers);POSTCALL;}
1154 //void wrapglGenQueries(GLsizei n, GLuint *ids) {PRECALL;glGenQueries(n, ids);POSTCALL;}
1155 void wrapglGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {PRECALL;glGenRenderbuffers(n, renderbuffers);POSTCALL;}
1156 void wrapglGenTextures(GLsizei n, GLuint *textures) {PRECALL;glGenTextures(n, textures);POSTCALL;}
1157 void wrapglGenerateMipmap(GLenum target) {PRECALL;glGenerateMipmap(target);POSTCALL;}
1158 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;}
1159 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;}
1160 void wrapglGetAttachedShaders(GLuint containerObj, GLsizei maxCount, GLsizei *count, GLuint *obj) {PRECALL;glGetAttachedShaders(containerObj, maxCount, count, obj);POSTCALL;}
1161 void wrapglGetBooleanv(GLenum pname, GLboolean *params) {PRECALL;glGetBooleanv(pname, params);POSTCALL;}
1162 void wrapglGetCompressedTexImage(GLenum target, GLint lod, void *img) {PRECALL;Con_Printf("glGetCompressedTexImage(target, lod, img)\n");POSTCALL;}
1163 void wrapglGetDoublev(GLenum pname, GLdouble *params) {PRECALL;Con_Printf("glGetDoublev(pname, params)\n");POSTCALL;}
1164 void wrapglGetFloatv(GLenum pname, GLfloat *params) {PRECALL;glGetFloatv(pname, params);POSTCALL;}
1165 void wrapglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) {PRECALL;glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);POSTCALL;}
1166 void wrapglGetShaderInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {PRECALL;glGetShaderInfoLog(obj, maxLength, length, infoLog);POSTCALL;}
1167 void wrapglGetProgramInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {PRECALL;glGetProgramInfoLog(obj, maxLength, length, infoLog);POSTCALL;}
1168 void wrapglGetIntegerv(GLenum pname, GLint *params) {PRECALL;glGetIntegerv(pname, params);POSTCALL;}
1169 void wrapglGetShaderiv(GLuint obj, GLenum pname, GLint *params) {PRECALL;glGetShaderiv(obj, pname, params);POSTCALL;}
1170 void wrapglGetProgramiv(GLuint obj, GLenum pname, GLint *params) {PRECALL;glGetProgramiv(obj, pname, params);POSTCALL;}
1171 //void wrapglGetQueryObjectiv(GLuint qid, GLenum pname, GLint *params) {PRECALL;glGetQueryObjectiv(qid, pname, params);POSTCALL;}
1172 //void wrapglGetQueryObjectuiv(GLuint qid, GLenum pname, GLuint *params) {PRECALL;glGetQueryObjectuiv(qid, pname, params);POSTCALL;}
1173 //void wrapglGetQueryiv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetQueryiv(target, pname, params);POSTCALL;}
1174 void wrapglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetRenderbufferParameteriv(target, pname, params);POSTCALL;}
1175 void wrapglGetShaderSource(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *source) {PRECALL;glGetShaderSource(obj, maxLength, length, source);POSTCALL;}
1176 void wrapglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {PRECALL;Con_Printf("glGetTexImage(target, level, format, type, pixels)\n");POSTCALL;}
1177 void wrapglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {PRECALL;Con_Printf("glGetTexLevelParameterfv(target, level, pname, params)\n");POSTCALL;}
1178 void wrapglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {PRECALL;Con_Printf("glGetTexLevelParameteriv(target, level, pname, params)\n");POSTCALL;}
1179 void wrapglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {PRECALL;glGetTexParameterfv(target, pname, params);POSTCALL;}
1180 void wrapglGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetTexParameteriv(target, pname, params);POSTCALL;}
1181 void wrapglGetUniformfv(GLuint programObj, GLint location, GLfloat *params) {PRECALL;glGetUniformfv(programObj, location, params);POSTCALL;}
1182 void wrapglGetUniformiv(GLuint programObj, GLint location, GLint *params) {PRECALL;glGetUniformiv(programObj, location, params);POSTCALL;}
1183 void wrapglHint(GLenum target, GLenum mode) {PRECALL;glHint(target, mode);POSTCALL;}
1184 void wrapglLineWidth(GLfloat width) {PRECALL;glLineWidth(width);POSTCALL;}
1185 void wrapglLinkProgram(GLuint programObj) {PRECALL;glLinkProgram(programObj);POSTCALL;}
1186 void wrapglLoadIdentity(void) {PRECALL;Con_Printf("glLoadIdentity()\n");POSTCALL;}
1187 void wrapglLoadMatrixf(const GLfloat *m) {PRECALL;Con_Printf("glLoadMatrixf(m)\n");POSTCALL;}
1188 void wrapglMatrixMode(GLenum mode) {PRECALL;Con_Printf("glMatrixMode(mode)\n");POSTCALL;}
1189 void wrapglMultiTexCoord1f(GLenum target, GLfloat s) {PRECALL;Con_Printf("glMultiTexCoord1f(target, s)\n");POSTCALL;}
1190 void wrapglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {PRECALL;Con_Printf("glMultiTexCoord2f(target, s, t)\n");POSTCALL;}
1191 void wrapglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {PRECALL;Con_Printf("glMultiTexCoord3f(target, s, t, r)\n");POSTCALL;}
1192 void wrapglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {PRECALL;Con_Printf("glMultiTexCoord4f(target, s, t, r, q)\n");POSTCALL;}
1193 void wrapglNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glNormalPointer(type, stride, ptr)\n");POSTCALL;}
1194 void wrapglPixelStorei(GLenum pname, GLint param) {PRECALL;glPixelStorei(pname, param);POSTCALL;}
1195 void wrapglPointSize(GLfloat size) {PRECALL;Con_Printf("glPointSize(size)\n");POSTCALL;}
1196 //void wrapglPolygonMode(GLenum face, GLenum mode) {PRECALL;Con_Printf("glPolygonMode(face, mode)\n");POSTCALL;}
1197 void wrapglPolygonOffset(GLfloat factor, GLfloat units) {PRECALL;glPolygonOffset(factor, units);POSTCALL;}
1198 void wrapglPolygonStipple(const GLubyte *mask) {PRECALL;Con_Printf("glPolygonStipple(mask)\n");POSTCALL;}
1199 void wrapglReadBuffer(GLenum mode) {PRECALL;Con_Printf("glReadBuffer(mode)\n");POSTCALL;}
1200 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;}
1201 void wrapglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {PRECALL;glRenderbufferStorage(target, internalformat, width, height);POSTCALL;}
1202 void wrapglScissor(GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;glScissor(x, y, width, height);POSTCALL;}
1203 void wrapglShaderSource(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length) {PRECALL;glShaderSource(shaderObj, count, string, length);POSTCALL;}
1204 void wrapglStencilFunc(GLenum func, GLint ref, GLuint mask) {PRECALL;glStencilFunc(func, ref, mask);POSTCALL;}
1205 void wrapglStencilFuncSeparate(GLenum func1, GLenum func2, GLint ref, GLuint mask) {PRECALL;Con_Printf("glStencilFuncSeparate(func1, func2, ref, mask)\n");POSTCALL;}
1206 void wrapglStencilMask(GLuint mask) {PRECALL;glStencilMask(mask);POSTCALL;}
1207 void wrapglStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {PRECALL;glStencilOp(fail, zfail, zpass);POSTCALL;}
1208 void wrapglStencilOpSeparate(GLenum e1, GLenum e2, GLenum e3, GLenum e4) {PRECALL;Con_Printf("glStencilOpSeparate(e1, e2, e3, e4)\n");POSTCALL;}
1209 void wrapglTexCoord1f(GLfloat s) {PRECALL;Con_Printf("glTexCoord1f(s)\n");POSTCALL;}
1210 void wrapglTexCoord2f(GLfloat s, GLfloat t) {PRECALL;Con_Printf("glTexCoord2f(s, t)\n");POSTCALL;}
1211 void wrapglTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {PRECALL;Con_Printf("glTexCoord3f(s, t, r)\n");POSTCALL;}
1212 void wrapglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {PRECALL;Con_Printf("glTexCoord4f(s, t, r, q)\n");POSTCALL;}
1213 void wrapglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glTexCoordPointer(size, type, stride, ptr)\n");POSTCALL;}
1214 void wrapglTexEnvf(GLenum target, GLenum pname, GLfloat param) {PRECALL;Con_Printf("glTexEnvf(target, pname, param)\n");POSTCALL;}
1215 void wrapglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {PRECALL;Con_Printf("glTexEnvfv(target, pname, params)\n");POSTCALL;}
1216 void wrapglTexEnvi(GLenum target, GLenum pname, GLint param) {PRECALL;Con_Printf("glTexEnvi(target, pname, param)\n");POSTCALL;}
1217 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;}
1218 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;}
1219 void wrapglTexParameterf(GLenum target, GLenum pname, GLfloat param) {PRECALL;glTexParameterf(target, pname, param);POSTCALL;}
1220 void wrapglTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {PRECALL;glTexParameterfv(target, pname, params);POSTCALL;}
1221 void wrapglTexParameteri(GLenum target, GLenum pname, GLint param) {PRECALL;glTexParameteri(target, pname, param);POSTCALL;}
1222 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;}
1223 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;}
1224 void wrapglUniform1f(GLint location, GLfloat v0) {PRECALL;glUniform1f(location, v0);POSTCALL;}
1225 void wrapglUniform1fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform1fv(location, count, value);POSTCALL;}
1226 void wrapglUniform1i(GLint location, GLint v0) {PRECALL;glUniform1i(location, v0);POSTCALL;}
1227 void wrapglUniform1iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform1iv(location, count, value);POSTCALL;}
1228 void wrapglUniform2f(GLint location, GLfloat v0, GLfloat v1) {PRECALL;glUniform2f(location, v0, v1);POSTCALL;}
1229 void wrapglUniform2fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform2fv(location, count, value);POSTCALL;}
1230 void wrapglUniform2i(GLint location, GLint v0, GLint v1) {PRECALL;glUniform2i(location, v0, v1);POSTCALL;}
1231 void wrapglUniform2iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform2iv(location, count, value);POSTCALL;}
1232 void wrapglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {PRECALL;glUniform3f(location, v0, v1, v2);POSTCALL;}
1233 void wrapglUniform3fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform3fv(location, count, value);POSTCALL;}
1234 void wrapglUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {PRECALL;glUniform3i(location, v0, v1, v2);POSTCALL;}
1235 void wrapglUniform3iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform3iv(location, count, value);POSTCALL;}
1236 void wrapglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {PRECALL;glUniform4f(location, v0, v1, v2, v3);POSTCALL;}
1237 void wrapglUniform4fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform4fv(location, count, value);POSTCALL;}
1238 void wrapglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {PRECALL;glUniform4i(location, v0, v1, v2, v3);POSTCALL;}
1239 void wrapglUniform4iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform4iv(location, count, value);POSTCALL;}
1240 void wrapglUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix2fv(location, count, transpose, value);POSTCALL;}
1241 void wrapglUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix3fv(location, count, transpose, value);POSTCALL;}
1242 void wrapglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix4fv(location, count, transpose, value);POSTCALL;}
1243 void wrapglUseProgram(GLuint programObj) {PRECALL;glUseProgram(programObj);POSTCALL;}
1244 void wrapglValidateProgram(GLuint programObj) {PRECALL;glValidateProgram(programObj);POSTCALL;}
1245 void wrapglVertex2f(GLfloat x, GLfloat y) {PRECALL;Con_Printf("glVertex2f(x, y)\n");POSTCALL;}
1246 void wrapglVertex3f(GLfloat x, GLfloat y, GLfloat z) {PRECALL;Con_Printf("glVertex3f(x, y, z)\n");POSTCALL;}
1247 void wrapglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {PRECALL;Con_Printf("glVertex4f(x, y, z, w)\n");POSTCALL;}
1248 void wrapglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {PRECALL;glVertexAttribPointer(index, size, type, normalized, stride, pointer);POSTCALL;}
1249 void wrapglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glVertexPointer(size, type, stride, ptr)\n");POSTCALL;}
1250 void wrapglViewport(GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;glViewport(x, y, width, height);POSTCALL;}
1251 void wrapglVertexAttrib1f(GLuint index, GLfloat v0) {PRECALL;glVertexAttrib1f(index, v0);POSTCALL;}
1252 //void wrapglVertexAttrib1s(GLuint index, GLshort v0) {PRECALL;glVertexAttrib1s(index, v0);POSTCALL;}
1253 //void wrapglVertexAttrib1d(GLuint index, GLdouble v0) {PRECALL;glVertexAttrib1d(index, v0);POSTCALL;}
1254 void wrapglVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {PRECALL;glVertexAttrib2f(index, v0, v1);POSTCALL;}
1255 //void wrapglVertexAttrib2s(GLuint index, GLshort v0, GLshort v1) {PRECALL;glVertexAttrib2s(index, v0, v1);POSTCALL;}
1256 //void wrapglVertexAttrib2d(GLuint index, GLdouble v0, GLdouble v1) {PRECALL;glVertexAttrib2d(index, v0, v1);POSTCALL;}
1257 void wrapglVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {PRECALL;glVertexAttrib3f(index, v0, v1, v2);POSTCALL;}
1258 //void wrapglVertexAttrib3s(GLuint index, GLshort v0, GLshort v1, GLshort v2) {PRECALL;glVertexAttrib3s(index, v0, v1, v2);POSTCALL;}
1259 //void wrapglVertexAttrib3d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2) {PRECALL;glVertexAttrib3d(index, v0, v1, v2);POSTCALL;}
1260 void wrapglVertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {PRECALL;glVertexAttrib4f(index, v0, v1, v2, v3);POSTCALL;}
1261 //void wrapglVertexAttrib4s(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3) {PRECALL;glVertexAttrib4s(index, v0, v1, v2, v3);POSTCALL;}
1262 //void wrapglVertexAttrib4d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {PRECALL;glVertexAttrib4d(index, v0, v1, v2, v3);POSTCALL;}
1263 //void wrapglVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {PRECALL;glVertexAttrib4Nub(index, x, y, z, w);POSTCALL;}
1264 void wrapglVertexAttrib1fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib1fv(index, v);POSTCALL;}
1265 //void wrapglVertexAttrib1sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib1sv(index, v);POSTCALL;}
1266 //void wrapglVertexAttrib1dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib1dv(index, v);POSTCALL;}
1267 void wrapglVertexAttrib2fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib2fv(index, v);POSTCALL;}
1268 //void wrapglVertexAttrib2sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib2sv(index, v);POSTCALL;}
1269 //void wrapglVertexAttrib2dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib2dv(index, v);POSTCALL;}
1270 void wrapglVertexAttrib3fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib3fv(index, v);POSTCALL;}
1271 //void wrapglVertexAttrib3sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib3sv(index, v);POSTCALL;}
1272 //void wrapglVertexAttrib3dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib3dv(index, v);POSTCALL;}
1273 void wrapglVertexAttrib4fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib4fv(index, v);POSTCALL;}
1274 //void wrapglVertexAttrib4sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib4sv(index, v);POSTCALL;}
1275 //void wrapglVertexAttrib4dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib4dv(index, v);POSTCALL;}
1276 //void wrapglVertexAttrib4iv(GLuint index, const GLint *v) {PRECALL;glVertexAttrib4iv(index, v);POSTCALL;}
1277 //void wrapglVertexAttrib4bv(GLuint index, const GLbyte *v) {PRECALL;glVertexAttrib4bv(index, v);POSTCALL;}
1278 //void wrapglVertexAttrib4ubv(GLuint index, const GLubyte *v) {PRECALL;glVertexAttrib4ubv(index, v);POSTCALL;}
1279 //void wrapglVertexAttrib4usv(GLuint index, const GLushort *v) {PRECALL;glVertexAttrib4usv(index, GLushort v);POSTCALL;}
1280 //void wrapglVertexAttrib4uiv(GLuint index, const GLuint *v) {PRECALL;glVertexAttrib4uiv(index, v);POSTCALL;}
1281 //void wrapglVertexAttrib4Nbv(GLuint index, const GLbyte *v) {PRECALL;glVertexAttrib4Nbv(index, v);POSTCALL;}
1282 //void wrapglVertexAttrib4Nsv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib4Nsv(index, v);POSTCALL;}
1283 //void wrapglVertexAttrib4Niv(GLuint index, const GLint *v) {PRECALL;glVertexAttrib4Niv(index, v);POSTCALL;}
1284 //void wrapglVertexAttrib4Nubv(GLuint index, const GLubyte *v) {PRECALL;glVertexAttrib4Nubv(index, v);POSTCALL;}
1285 //void wrapglVertexAttrib4Nusv(GLuint index, const GLushort *v) {PRECALL;glVertexAttrib4Nusv(index, GLushort v);POSTCALL;}
1286 //void wrapglVertexAttrib4Nuiv(GLuint index, const GLuint *v) {PRECALL;glVertexAttrib4Nuiv(index, v);POSTCALL;}
1287 //void wrapglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {PRECALL;glGetVertexAttribdv(index, pname, params);POSTCALL;}
1288 void wrapglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {PRECALL;glGetVertexAttribfv(index, pname, params);POSTCALL;}
1289 void wrapglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {PRECALL;glGetVertexAttribiv(index, pname, params);POSTCALL;}
1290 void wrapglGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) {PRECALL;glGetVertexAttribPointerv(index, pname, pointer);POSTCALL;}
1293 #if SDL_MAJOR_VERSION == 1
1294 #define SDL_GL_ExtensionSupported(x) (strstr(gl_extensions, x) || strstr(gl_platformextensions, x))
1297 void GLES_Init(void)
1300 qglIsBufferARB = wrapglIsBuffer;
1301 qglIsEnabled = wrapglIsEnabled;
1302 qglIsFramebufferEXT = wrapglIsFramebuffer;
1303 // qglIsQueryARB = wrapglIsQuery;
1304 qglIsRenderbufferEXT = wrapglIsRenderbuffer;
1305 // qglUnmapBufferARB = wrapglUnmapBuffer;
1306 qglCheckFramebufferStatusEXT = wrapglCheckFramebufferStatus;
1307 qglGetError = wrapglGetError;
1308 qglCreateProgram = wrapglCreateProgram;
1309 qglCreateShader = wrapglCreateShader;
1310 // qglGetHandleARB = wrapglGetHandle;
1311 qglGetAttribLocation = wrapglGetAttribLocation;
1312 qglGetUniformLocation = wrapglGetUniformLocation;
1313 // qglMapBufferARB = wrapglMapBuffer;
1314 qglGetString = wrapglGetString;
1315 // qglActiveStencilFaceEXT = wrapglActiveStencilFace;
1316 qglActiveTexture = wrapglActiveTexture;
1317 qglAlphaFunc = wrapglAlphaFunc;
1318 qglArrayElement = wrapglArrayElement;
1319 qglAttachShader = wrapglAttachShader;
1320 // qglBegin = wrapglBegin;
1321 // qglBeginQueryARB = wrapglBeginQuery;
1322 qglBindAttribLocation = wrapglBindAttribLocation;
1323 // qglBindFragDataLocation = wrapglBindFragDataLocation;
1324 qglBindBufferARB = wrapglBindBuffer;
1325 qglBindFramebufferEXT = wrapglBindFramebuffer;
1326 qglBindRenderbufferEXT = wrapglBindRenderbuffer;
1327 qglBindTexture = wrapglBindTexture;
1328 qglBlendEquationEXT = wrapglBlendEquation;
1329 qglBlendFunc = wrapglBlendFunc;
1330 qglBufferDataARB = wrapglBufferData;
1331 qglBufferSubDataARB = wrapglBufferSubData;
1332 qglClear = wrapglClear;
1333 qglClearColor = wrapglClearColor;
1334 qglClearDepth = wrapglClearDepth;
1335 qglClearStencil = wrapglClearStencil;
1336 qglClientActiveTexture = wrapglClientActiveTexture;
1337 qglColor4f = wrapglColor4f;
1338 qglColor4ub = wrapglColor4ub;
1339 qglColorMask = wrapglColorMask;
1340 qglColorPointer = wrapglColorPointer;
1341 qglCompileShader = wrapglCompileShader;
1342 qglCompressedTexImage2DARB = wrapglCompressedTexImage2D;
1343 qglCompressedTexImage3DARB = wrapglCompressedTexImage3D;
1344 qglCompressedTexSubImage2DARB = wrapglCompressedTexSubImage2D;
1345 qglCompressedTexSubImage3DARB = wrapglCompressedTexSubImage3D;
1346 qglCopyTexImage2D = wrapglCopyTexImage2D;
1347 qglCopyTexSubImage2D = wrapglCopyTexSubImage2D;
1348 qglCopyTexSubImage3D = wrapglCopyTexSubImage3D;
1349 qglCullFace = wrapglCullFace;
1350 qglDeleteBuffersARB = wrapglDeleteBuffers;
1351 qglDeleteFramebuffersEXT = wrapglDeleteFramebuffers;
1352 qglDeleteProgram = wrapglDeleteProgram;
1353 qglDeleteShader = wrapglDeleteShader;
1354 // qglDeleteQueriesARB = wrapglDeleteQueries;
1355 qglDeleteRenderbuffersEXT = wrapglDeleteRenderbuffers;
1356 qglDeleteTextures = wrapglDeleteTextures;
1357 qglDepthFunc = wrapglDepthFunc;
1358 qglDepthMask = wrapglDepthMask;
1359 qglDepthRangef = wrapglDepthRangef;
1360 qglDetachShader = wrapglDetachShader;
1361 qglDisable = wrapglDisable;
1362 qglDisableClientState = wrapglDisableClientState;
1363 qglDisableVertexAttribArray = wrapglDisableVertexAttribArray;
1364 qglDrawArrays = wrapglDrawArrays;
1365 // qglDrawBuffer = wrapglDrawBuffer;
1366 // qglDrawBuffersARB = wrapglDrawBuffers;
1367 qglDrawElements = wrapglDrawElements;
1368 // qglDrawRangeElements = wrapglDrawRangeElements;
1369 qglEnable = wrapglEnable;
1370 qglEnableClientState = wrapglEnableClientState;
1371 qglEnableVertexAttribArray = wrapglEnableVertexAttribArray;
1372 // qglEnd = wrapglEnd;
1373 // qglEndQueryARB = wrapglEndQuery;
1374 qglFinish = wrapglFinish;
1375 qglFlush = wrapglFlush;
1376 qglFramebufferRenderbufferEXT = wrapglFramebufferRenderbuffer;
1377 qglFramebufferTexture2DEXT = wrapglFramebufferTexture2D;
1378 qglFramebufferTexture3DEXT = wrapglFramebufferTexture3D;
1379 qglGenBuffersARB = wrapglGenBuffers;
1380 qglGenFramebuffersEXT = wrapglGenFramebuffers;
1381 // qglGenQueriesARB = wrapglGenQueries;
1382 qglGenRenderbuffersEXT = wrapglGenRenderbuffers;
1383 qglGenTextures = wrapglGenTextures;
1384 qglGenerateMipmapEXT = wrapglGenerateMipmap;
1385 qglGetActiveAttrib = wrapglGetActiveAttrib;
1386 qglGetActiveUniform = wrapglGetActiveUniform;
1387 qglGetAttachedShaders = wrapglGetAttachedShaders;
1388 qglGetBooleanv = wrapglGetBooleanv;
1389 // qglGetCompressedTexImageARB = wrapglGetCompressedTexImage;
1390 qglGetDoublev = wrapglGetDoublev;
1391 qglGetFloatv = wrapglGetFloatv;
1392 qglGetFramebufferAttachmentParameterivEXT = wrapglGetFramebufferAttachmentParameteriv;
1393 qglGetProgramInfoLog = wrapglGetProgramInfoLog;
1394 qglGetShaderInfoLog = wrapglGetShaderInfoLog;
1395 qglGetIntegerv = wrapglGetIntegerv;
1396 qglGetShaderiv = wrapglGetShaderiv;
1397 qglGetProgramiv = wrapglGetProgramiv;
1398 // qglGetQueryObjectivARB = wrapglGetQueryObjectiv;
1399 // qglGetQueryObjectuivARB = wrapglGetQueryObjectuiv;
1400 // qglGetQueryivARB = wrapglGetQueryiv;
1401 qglGetRenderbufferParameterivEXT = wrapglGetRenderbufferParameteriv;
1402 qglGetShaderSource = wrapglGetShaderSource;
1403 qglGetTexImage = wrapglGetTexImage;
1404 qglGetTexLevelParameterfv = wrapglGetTexLevelParameterfv;
1405 qglGetTexLevelParameteriv = wrapglGetTexLevelParameteriv;
1406 qglGetTexParameterfv = wrapglGetTexParameterfv;
1407 qglGetTexParameteriv = wrapglGetTexParameteriv;
1408 qglGetUniformfv = wrapglGetUniformfv;
1409 qglGetUniformiv = wrapglGetUniformiv;
1410 qglHint = wrapglHint;
1411 qglLineWidth = wrapglLineWidth;
1412 qglLinkProgram = wrapglLinkProgram;
1413 qglLoadIdentity = wrapglLoadIdentity;
1414 qglLoadMatrixf = wrapglLoadMatrixf;
1415 qglMatrixMode = wrapglMatrixMode;
1416 qglMultiTexCoord1f = wrapglMultiTexCoord1f;
1417 qglMultiTexCoord2f = wrapglMultiTexCoord2f;
1418 qglMultiTexCoord3f = wrapglMultiTexCoord3f;
1419 qglMultiTexCoord4f = wrapglMultiTexCoord4f;
1420 qglNormalPointer = wrapglNormalPointer;
1421 qglPixelStorei = wrapglPixelStorei;
1422 qglPointSize = wrapglPointSize;
1423 // qglPolygonMode = wrapglPolygonMode;
1424 qglPolygonOffset = wrapglPolygonOffset;
1425 // qglPolygonStipple = wrapglPolygonStipple;
1426 qglReadBuffer = wrapglReadBuffer;
1427 qglReadPixels = wrapglReadPixels;
1428 qglRenderbufferStorageEXT = wrapglRenderbufferStorage;
1429 qglScissor = wrapglScissor;
1430 qglShaderSource = wrapglShaderSource;
1431 qglStencilFunc = wrapglStencilFunc;
1432 qglStencilFuncSeparate = wrapglStencilFuncSeparate;
1433 qglStencilMask = wrapglStencilMask;
1434 qglStencilOp = wrapglStencilOp;
1435 qglStencilOpSeparate = wrapglStencilOpSeparate;
1436 qglTexCoord1f = wrapglTexCoord1f;
1437 qglTexCoord2f = wrapglTexCoord2f;
1438 qglTexCoord3f = wrapglTexCoord3f;
1439 qglTexCoord4f = wrapglTexCoord4f;
1440 qglTexCoordPointer = wrapglTexCoordPointer;
1441 qglTexEnvf = wrapglTexEnvf;
1442 qglTexEnvfv = wrapglTexEnvfv;
1443 qglTexEnvi = wrapglTexEnvi;
1444 qglTexImage2D = wrapglTexImage2D;
1445 qglTexImage3D = wrapglTexImage3D;
1446 qglTexParameterf = wrapglTexParameterf;
1447 qglTexParameterfv = wrapglTexParameterfv;
1448 qglTexParameteri = wrapglTexParameteri;
1449 qglTexSubImage2D = wrapglTexSubImage2D;
1450 qglTexSubImage3D = wrapglTexSubImage3D;
1451 qglUniform1f = wrapglUniform1f;
1452 qglUniform1fv = wrapglUniform1fv;
1453 qglUniform1i = wrapglUniform1i;
1454 qglUniform1iv = wrapglUniform1iv;
1455 qglUniform2f = wrapglUniform2f;
1456 qglUniform2fv = wrapglUniform2fv;
1457 qglUniform2i = wrapglUniform2i;
1458 qglUniform2iv = wrapglUniform2iv;
1459 qglUniform3f = wrapglUniform3f;
1460 qglUniform3fv = wrapglUniform3fv;
1461 qglUniform3i = wrapglUniform3i;
1462 qglUniform3iv = wrapglUniform3iv;
1463 qglUniform4f = wrapglUniform4f;
1464 qglUniform4fv = wrapglUniform4fv;
1465 qglUniform4i = wrapglUniform4i;
1466 qglUniform4iv = wrapglUniform4iv;
1467 qglUniformMatrix2fv = wrapglUniformMatrix2fv;
1468 qglUniformMatrix3fv = wrapglUniformMatrix3fv;
1469 qglUniformMatrix4fv = wrapglUniformMatrix4fv;
1470 qglUseProgram = wrapglUseProgram;
1471 qglValidateProgram = wrapglValidateProgram;
1472 qglVertex2f = wrapglVertex2f;
1473 qglVertex3f = wrapglVertex3f;
1474 qglVertex4f = wrapglVertex4f;
1475 qglVertexAttribPointer = wrapglVertexAttribPointer;
1476 qglVertexPointer = wrapglVertexPointer;
1477 qglViewport = wrapglViewport;
1478 qglVertexAttrib1f = wrapglVertexAttrib1f;
1479 // qglVertexAttrib1s = wrapglVertexAttrib1s;
1480 // qglVertexAttrib1d = wrapglVertexAttrib1d;
1481 qglVertexAttrib2f = wrapglVertexAttrib2f;
1482 // qglVertexAttrib2s = wrapglVertexAttrib2s;
1483 // qglVertexAttrib2d = wrapglVertexAttrib2d;
1484 qglVertexAttrib3f = wrapglVertexAttrib3f;
1485 // qglVertexAttrib3s = wrapglVertexAttrib3s;
1486 // qglVertexAttrib3d = wrapglVertexAttrib3d;
1487 qglVertexAttrib4f = wrapglVertexAttrib4f;
1488 // qglVertexAttrib4s = wrapglVertexAttrib4s;
1489 // qglVertexAttrib4d = wrapglVertexAttrib4d;
1490 // qglVertexAttrib4Nub = wrapglVertexAttrib4Nub;
1491 qglVertexAttrib1fv = wrapglVertexAttrib1fv;
1492 // qglVertexAttrib1sv = wrapglVertexAttrib1sv;
1493 // qglVertexAttrib1dv = wrapglVertexAttrib1dv;
1494 qglVertexAttrib2fv = wrapglVertexAttrib2fv;
1495 // qglVertexAttrib2sv = wrapglVertexAttrib2sv;
1496 // qglVertexAttrib2dv = wrapglVertexAttrib2dv;
1497 qglVertexAttrib3fv = wrapglVertexAttrib3fv;
1498 // qglVertexAttrib3sv = wrapglVertexAttrib3sv;
1499 // qglVertexAttrib3dv = wrapglVertexAttrib3dv;
1500 qglVertexAttrib4fv = wrapglVertexAttrib4fv;
1501 // qglVertexAttrib4sv = wrapglVertexAttrib4sv;
1502 // qglVertexAttrib4dv = wrapglVertexAttrib4dv;
1503 // qglVertexAttrib4iv = wrapglVertexAttrib4iv;
1504 // qglVertexAttrib4bv = wrapglVertexAttrib4bv;
1505 // qglVertexAttrib4ubv = wrapglVertexAttrib4ubv;
1506 // qglVertexAttrib4usv = wrapglVertexAttrib4usv;
1507 // qglVertexAttrib4uiv = wrapglVertexAttrib4uiv;
1508 // qglVertexAttrib4Nbv = wrapglVertexAttrib4Nbv;
1509 // qglVertexAttrib4Nsv = wrapglVertexAttrib4Nsv;
1510 // qglVertexAttrib4Niv = wrapglVertexAttrib4Niv;
1511 // qglVertexAttrib4Nubv = wrapglVertexAttrib4Nubv;
1512 // qglVertexAttrib4Nusv = wrapglVertexAttrib4Nusv;
1513 // qglVertexAttrib4Nuiv = wrapglVertexAttrib4Nuiv;
1514 // qglGetVertexAttribdv = wrapglGetVertexAttribdv;
1515 qglGetVertexAttribfv = wrapglGetVertexAttribfv;
1516 qglGetVertexAttribiv = wrapglGetVertexAttribiv;
1517 qglGetVertexAttribPointerv = wrapglGetVertexAttribPointerv;
1520 gl_renderer = (const char *)qglGetString(GL_RENDERER);
1521 gl_vendor = (const char *)qglGetString(GL_VENDOR);
1522 gl_version = (const char *)qglGetString(GL_VERSION);
1523 gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
1527 if (!gl_platformextensions)
1528 gl_platformextensions = "";
1530 Con_Printf("GL_VENDOR: %s\n", gl_vendor);
1531 Con_Printf("GL_RENDERER: %s\n", gl_renderer);
1532 Con_Printf("GL_VERSION: %s\n", gl_version);
1533 Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
1534 Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
1536 // LordHavoc: report supported extensions
1537 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
1539 // GLES devices in general do not like GL_BGRA, so use GL_RGBA
1540 vid.forcetextype = TEXTYPE_RGBA;
1542 vid.support.gl20shaders = true;
1543 vid.support.amd_texture_texture4 = false;
1544 vid.support.arb_depth_texture = false;
1545 vid.support.arb_draw_buffers = false;
1546 vid.support.arb_multitexture = false;
1547 vid.support.arb_occlusion_query = false;
1548 vid.support.arb_shadow = false;
1549 vid.support.arb_texture_compression = false; // different (vendor-specific) formats than on desktop OpenGL...
1550 vid.support.arb_texture_cube_map = true;
1551 vid.support.arb_texture_env_combine = false;
1552 vid.support.arb_texture_gather = false;
1553 vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
1554 vid.support.arb_vertex_buffer_object = true;
1555 vid.support.ati_separate_stencil = false;
1556 vid.support.ext_blend_minmax = false;
1557 vid.support.ext_blend_subtract = true;
1558 vid.support.ext_draw_range_elements = true;
1559 vid.support.ext_framebuffer_object = false;//true;
1561 // FIXME remove this workaround once FBO + npot texture mapping is fixed
1562 if(!vid.support.arb_texture_non_power_of_two)
1564 vid.support.arb_framebuffer_object = false;
1565 vid.support.ext_framebuffer_object = false;
1568 vid.support.ext_packed_depth_stencil = false;
1569 vid.support.ext_stencil_two_side = false;
1570 vid.support.ext_texture_3d = SDL_GL_ExtensionSupported("GL_OES_texture_3D");
1571 vid.support.ext_texture_compression_s3tc = SDL_GL_ExtensionSupported("GL_EXT_texture_compression_s3tc");
1572 vid.support.ext_texture_edge_clamp = true;
1573 vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
1574 vid.support.ext_texture_srgb = false;
1576 qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
1577 if (vid.support.ext_texture_filter_anisotropic)
1578 qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
1579 if (vid.support.arb_texture_cube_map)
1580 qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_cubemap);
1581 #ifdef GL_MAX_3D_TEXTURE_SIZE
1582 if (vid.support.ext_texture_3d)
1583 qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_3d);
1585 Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
1586 Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
1588 #define GL_ALPHA_BITS 0x0D55
1589 #define GL_RED_BITS 0x0D52
1590 #define GL_GREEN_BITS 0x0D53
1591 #define GL_BLUE_BITS 0x0D54
1592 #define GL_DEPTH_BITS 0x0D56
1593 #define GL_STENCIL_BITS 0x0D57
1594 int fb_r = -1, fb_g = -1, fb_b = -1, fb_a = -1, fb_d = -1, fb_s = -1;
1595 qglGetIntegerv(GL_RED_BITS , &fb_r);
1596 qglGetIntegerv(GL_GREEN_BITS , &fb_g);
1597 qglGetIntegerv(GL_BLUE_BITS , &fb_b);
1598 qglGetIntegerv(GL_ALPHA_BITS , &fb_a);
1599 qglGetIntegerv(GL_DEPTH_BITS , &fb_d);
1600 qglGetIntegerv(GL_STENCIL_BITS, &fb_s);
1601 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);
1604 // verify that cubemap textures are really supported
1605 if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
1606 vid.support.arb_texture_cube_map = false;
1608 // verify that 3d textures are really supported
1609 if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
1611 vid.support.ext_texture_3d = false;
1612 Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
1616 vid.teximageunits = 8;
1617 vid.texarrayunits = 5;
1618 vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
1619 vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
1620 vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
1621 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" : "");
1622 vid.renderpath = RENDERPATH_GLES2;
1623 vid.useinterleavedarrays = false;
1624 vid.sRGBcapable2D = false;
1625 vid.sRGBcapable3D = false;
1627 // VorteX: set other info (maybe place them in VID_InitMode?)
1628 extern cvar_t gl_info_vendor;
1629 extern cvar_t gl_info_renderer;
1630 extern cvar_t gl_info_version;
1631 extern cvar_t gl_info_platform;
1632 extern cvar_t gl_info_driver;
1633 Cvar_SetQuick(&gl_info_vendor, gl_vendor);
1634 Cvar_SetQuick(&gl_info_renderer, gl_renderer);
1635 Cvar_SetQuick(&gl_info_version, gl_version);
1636 Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
1637 Cvar_SetQuick(&gl_info_driver, gl_driver);
1641 void *GL_GetProcAddress(const char *name)
1644 p = SDL_GL_GetProcAddress(name);
1648 static qboolean vid_sdl_initjoysticksystem = false;
1650 void VID_Init (void)
1652 #ifndef __IPHONEOS__
1654 Cvar_RegisterVariable(&apple_mouse_noaccel);
1658 Cvar_SetValueQuick(&vid_touchscreen, 1);
1661 #ifdef SDL_R_RESTART
1662 R_RegisterModule("SDL", sdl_start, sdl_shutdown, sdl_newmap, NULL, NULL);
1665 if (SDL_Init(SDL_INIT_VIDEO) < 0)
1666 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
1667 vid_sdl_initjoysticksystem = SDL_InitSubSystem(SDL_INIT_JOYSTICK) >= 0;
1668 if (vid_sdl_initjoysticksystem)
1669 Con_Printf("Failed to init SDL joystick subsystem: %s\n", SDL_GetError());
1670 vid_isfullscreen = false;
1673 static int vid_sdljoystickindex = -1;
1674 void VID_EnableJoystick(qboolean enable)
1676 int index = joy_enable.integer > 0 ? joy_index.integer : -1;
1677 int numsdljoysticks;
1678 qboolean success = false;
1679 int sharedcount = 0;
1681 sharedcount = VID_Shared_SetJoystick(index);
1682 if (index >= 0 && index < sharedcount)
1684 sdlindex = index - sharedcount;
1686 numsdljoysticks = SDL_NumJoysticks();
1687 if (sdlindex < 0 || sdlindex >= numsdljoysticks)
1690 // update cvar containing count of XInput joysticks + SDL joysticks
1691 if (joy_detected.integer != sharedcount + numsdljoysticks)
1692 Cvar_SetValueQuick(&joy_detected, sharedcount + numsdljoysticks);
1694 if (vid_sdljoystickindex != sdlindex)
1696 vid_sdljoystickindex = sdlindex;
1697 // close SDL joystick if active
1698 if (vid_sdljoystick)
1699 SDL_JoystickClose(vid_sdljoystick);
1700 vid_sdljoystick = NULL;
1703 vid_sdljoystick = SDL_JoystickOpen(sdlindex);
1704 if (vid_sdljoystick)
1705 Con_Printf("Joystick %i opened (SDL_Joystick %i is \"%s\" with %i axes, %i buttons, %i balls)\n", index, sdlindex, SDL_JoystickName(sdlindex), (int)SDL_JoystickNumAxes(vid_sdljoystick), (int)SDL_JoystickNumButtons(vid_sdljoystick), (int)SDL_JoystickNumBalls(vid_sdljoystick));
1708 Con_Printf("Joystick %i failed (SDL_JoystickOpen(%i) returned: %s)\n", index, sdlindex, SDL_GetError());
1717 if (joy_active.integer != (success ? 1 : 0))
1718 Cvar_SetValueQuick(&joy_active, success ? 1 : 0);
1721 #if SDL_MAJOR_VERSION == 1
1722 // set the icon (we dont use SDL here since it would be too much a PITA)
1724 #include "resource.h"
1725 #include <SDL_syswm.h>
1726 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
1728 SDL_Surface *screen = NULL;
1731 SDL_WM_SetCaption( gamename, NULL );
1732 screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
1735 // get the HWND handle
1736 SDL_VERSION( &info.version );
1737 if (SDL_GetWMInfo(&info))
1739 icon = LoadIcon( GetModuleHandle( NULL ), MAKEINTRESOURCE( IDI_ICON1 ) );
1740 #ifndef _W64 //If Windows 64bit data types don't exist
1741 #ifndef SetClassLongPtr
1742 #define SetClassLongPtr SetClassLong
1745 #define GCLP_HICON GCL_HICON
1748 #define LONG_PTR LONG
1751 SetClassLongPtr( info.window, GCLP_HICON, (LONG_PTR)icon );
1756 #elif defined(MACOSX)
1757 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
1759 SDL_Surface *screen = NULL;
1760 SDL_WM_SetCaption( gamename, NULL );
1761 screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
1762 // we don't use SDL_WM_SetIcon here because the icon in the .app should be used
1766 // Adding the OS independent XPM version --blub
1767 #include "darkplaces.xpm"
1768 #include "nexuiz.xpm"
1769 #if SDL_MAJOR_VERSION == 1
1770 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
1771 #include <SDL_syswm.h>
1774 static SDL_Surface *icon = NULL;
1775 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
1778 * Somewhat restricted XPM reader. Only supports XPMs saved by GIMP 2.4 at
1779 * default settings with less than 91 colors and transparency.
1782 int width, height, colors, isize, i, j;
1784 static SDL_Color palette[256];
1785 unsigned short palenc[256]; // store color id by char
1787 char **idata, *data;
1788 const SDL_version *version;
1789 SDL_Surface *screen = NULL;
1792 SDL_FreeSurface(icon);
1794 version = SDL_Linked_Version();
1795 // only use non-XPM icon support in SDL v1.3 and higher
1796 // SDL v1.2 does not support "smooth" transparency, and thus is better
1798 if(version->major >= 2 || (version->major == 1 && version->minor >= 3))
1800 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1803 unsigned int red = 0x00FF0000;
1804 unsigned int green = 0x0000FF00;
1805 unsigned int blue = 0x000000FF;
1806 unsigned int alpha = 0xFF000000;
1807 width = image_width;
1808 height = image_height;
1810 // reallocate with malloc, as this is in tempmempool (do not want)
1812 data = (char *) malloc(width * height * 4);
1813 memcpy(data, xpm, width * height * 4);
1817 icon = SDL_CreateRGBSurface(SDL_SRCALPHA, width, height, 32, LittleLong(red), LittleLong(green), LittleLong(blue), LittleLong(alpha));
1820 icon->pixels = data;
1823 Con_Printf( "Failed to create surface for the window Icon!\n"
1824 "%s\n", SDL_GetError());
1830 // we only get here if non-XPM icon was missing, or SDL version is not
1831 // sufficient for transparent non-XPM icons
1834 xpm = (char *) FS_LoadFile("darkplaces-icon.xpm", tempmempool, false, NULL);
1837 idata = XPM_DecodeString(xpm);
1839 idata = ENGINE_ICON;
1845 if(sscanf(data, "%i %i %i %i", &width, &height, &colors, &isize) == 4)
1849 for(i = 0; i < colors; ++i)
1851 unsigned int r, g, b;
1854 if(sscanf(idata[i+1], "%c c #%02x%02x%02x", &idx, &r, &g, &b) != 4)
1857 if(sscanf(idata[i+1], "%c c Non%1[e]", &idx, foo) != 2) // I take the DailyWTF credit for this. --div0
1861 palette[i].r = 255; // color key
1864 thenone = i; // weeeee
1865 palenc[(unsigned char) idx] = i;
1870 palette[i].r = r - (r == 255 && g == 0 && b == 255); // change 255/0/255 pink to 254/0/255 for color key
1873 palenc[(unsigned char) idx] = i;
1879 // allocate the image data
1880 data = (char*) malloc(width*height);
1882 for(j = 0; j < height; ++j)
1884 for(i = 0; i < width; ++i)
1886 // casting to the safest possible datatypes ^^
1887 data[j * width + i] = palenc[((unsigned char*)idata[colors+j+1])[i]];
1893 // SDL_FreeSurface should free the data too
1894 // but for completeness' sake...
1895 if(icon->flags & SDL_PREALLOC)
1898 icon->pixels = NULL; // safety
1900 SDL_FreeSurface(icon);
1903 icon = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, width, height, 8, 0,0,0,0);// rmask, gmask, bmask, amask); no mask needed
1904 // 8 bit surfaces get an empty palette allocated according to the docs
1905 // so it's a palette image for sure :) no endian check necessary for the mask
1909 icon->pixels = data;
1910 SDL_SetPalette(icon, SDL_PHYSPAL|SDL_LOGPAL, palette, 0, colors);
1911 SDL_SetColorKey(icon, SDL_SRCCOLORKEY, thenone);
1915 Con_Printf( "Failed to create surface for the window Icon!\n"
1916 "%s\n", SDL_GetError());
1922 Con_Printf("This XPM's palette looks odd. Can't continue.\n");
1927 // NOTE: Only 1-char colornames are supported
1928 Con_Printf("This XPM's palette is either huge or idiotically unoptimized. It's key size is %i\n", isize);
1933 // NOTE: Only 1-char colornames are supported
1934 Con_Printf("Sorry, but this does not even look similar to an XPM.\n");
1939 SDL_WM_SetIcon(icon, NULL);
1941 SDL_WM_SetCaption( gamename, NULL );
1942 screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
1944 #if SDL_MAJOR_VERSION == 1
1945 // LordHavoc: info.info.x11.lock_func and accompanying code do not seem to compile with SDL 1.3
1946 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
1948 version = SDL_Linked_Version();
1949 // only use non-XPM icon support in SDL v1.3 and higher
1950 // SDL v1.2 does not support "smooth" transparency, and thus is better
1952 if(screen && (!(version->major >= 2 || (version->major == 1 && version->minor >= 3))))
1954 // in this case, we did not set the good icon yet
1956 SDL_VERSION(&info.version);
1957 if(SDL_GetWMInfo(&info) == 1 && info.subsystem == SDL_SYSWM_X11)
1959 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1962 // use _NET_WM_ICON too
1963 static long netwm_icon[MAX_NETWM_ICON];
1970 if(pos + 2 * image_width * image_height < MAX_NETWM_ICON)
1972 netwm_icon[pos++] = image_width;
1973 netwm_icon[pos++] = image_height;
1974 for(i = 0; i < image_height; ++i)
1975 for(j = 0; j < image_width; ++j)
1976 netwm_icon[pos++] = BuffLittleLong((unsigned char *) &data[(i*image_width+j)*4]);
1980 Con_Printf("Skipping NETWM icon #%d because there is no space left\n", i);
1984 data = (char *) loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "darkplaces-icon%d", i), false, false, false, NULL);
1987 info.info.x11.lock_func();
1989 Atom net_wm_icon = XInternAtom(info.info.x11.display, "_NET_WM_ICON", false);
1990 XChangeProperty(info.info.x11.display, info.info.x11.wmwindow, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (const unsigned char *) netwm_icon, pos);
1992 info.info.x11.unlock_func();
2004 static void VID_OutputVersion(void)
2006 SDL_version version;
2007 #if SDL_MAJOR_VERSION == 1
2008 version = *SDL_Linked_Version();
2010 SDL_GetVersion(&version);
2012 Con_Printf( "Linked against SDL version %d.%d.%d\n"
2013 "Using SDL library version %d.%d.%d\n",
2014 SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL,
2015 version.major, version.minor, version.patch );
2018 static qboolean VID_InitModeGL(viddef_mode_t *mode)
2021 #if SDL_MAJOR_VERSION == 1
2022 static int notfirstvideomode = false;
2023 int flags = SDL_OPENGL;
2025 int windowflags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
2027 const char *drivername;
2029 win_half_width = mode->width>>1;
2030 win_half_height = mode->height>>1;
2032 if(vid_resizable.integer)
2033 #if SDL_MAJOR_VERSION == 1
2034 flags |= SDL_RESIZABLE;
2036 windowflags |= SDL_WINDOW_RESIZABLE;
2039 VID_OutputVersion();
2041 #if SDL_MAJOR_VERSION == 1
2044 We cant switch from one OpenGL video mode to another.
2045 Thus we first switch to some stupid 2D mode and then back to OpenGL.
2047 if (notfirstvideomode)
2048 SDL_SetVideoMode( 0, 0, 0, 0 );
2049 notfirstvideomode = true;
2053 // SDL usually knows best
2056 // 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
2057 i = COM_CheckParm("-gl_driver");
2058 if (i && i < com_argc - 1)
2059 drivername = com_argv[i + 1];
2060 if (SDL_GL_LoadLibrary(drivername) < 0)
2062 Con_Printf("Unable to load GL driver \"%s\": %s\n", drivername, SDL_GetError());
2068 // mobile platforms are always fullscreen, we'll get the resolution after opening the window
2069 mode->fullscreen = true;
2070 // hide the menu with SDL_WINDOW_BORDERLESS
2071 windowflags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
2074 if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
2077 Con_Print("Required OpenGL function glGetString not found\n");
2082 // Knghtbrd: should do platform-specific extension string function here
2084 vid_isfullscreen = false;
2085 if (mode->fullscreen) {
2086 #if SDL_MAJOR_VERSION == 1
2087 flags |= SDL_FULLSCREEN;
2089 windowflags |= SDL_WINDOW_FULLSCREEN;
2091 vid_isfullscreen = true;
2093 //flags |= SDL_HWSURFACE;
2095 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
2096 if (mode->bitsperpixel >= 32)
2098 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 8);
2099 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 8);
2100 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 8);
2101 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8);
2102 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24);
2103 SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
2107 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
2108 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
2109 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
2110 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
2112 if (mode->stereobuffer)
2113 SDL_GL_SetAttribute (SDL_GL_STEREO, 1);
2114 if (mode->samples > 1)
2116 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
2117 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, mode->samples);
2120 #if SDL_MAJOR_VERSION == 1
2121 if (vid_vsync.integer)
2122 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
2124 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 0);
2127 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 2);
2128 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 0);
2129 SDL_GL_SetAttribute (SDL_GL_RETAINED_BACKING, 1);
2133 video_bpp = mode->bitsperpixel;
2134 #if SDL_MAJOR_VERSION == 1
2135 video_flags = flags;
2136 screen = VID_WrapSDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2139 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2143 mode->width = screen->w;
2144 mode->height = screen->h;
2146 window_flags = windowflags;
2147 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2150 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2154 SDL_GetWindowSize(window, &mode->width, &mode->height);
2155 context = SDL_GL_CreateContext(window);
2156 if (context == NULL)
2158 Con_Printf("Failed to initialize OpenGL context: %s\n", SDL_GetError());
2164 vid_softsurface = NULL;
2165 vid.softpixels = NULL;
2167 #if SDL_MAJOR_VERSION == 1
2169 SDL_EnableUNICODE( SDL_ENABLE );
2170 // enable key repeat since everyone expects it
2171 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2174 #if SDL_MAJOR_VERSION != 1
2175 SDL_GL_SetSwapInterval(vid_vsync.integer != 0);
2176 vid_usingvsync = (vid_vsync.integer != 0);
2179 gl_platform = "SDL";
2180 gl_platformextensions = "";
2189 vid_activewindow = false;
2190 vid_hasfocus = true;
2191 vid_usingmouse = false;
2192 vid_usinghidecursor = false;
2194 #if SDL_MAJOR_VERSION == 1
2195 SDL_WM_GrabInput(SDL_GRAB_OFF);
2200 extern cvar_t gl_info_extensions;
2201 extern cvar_t gl_info_vendor;
2202 extern cvar_t gl_info_renderer;
2203 extern cvar_t gl_info_version;
2204 extern cvar_t gl_info_platform;
2205 extern cvar_t gl_info_driver;
2207 static qboolean VID_InitModeSoft(viddef_mode_t *mode)
2209 #if SDL_MAJOR_VERSION == 1
2210 int flags = SDL_HWSURFACE;
2211 if(!COM_CheckParm("-noasyncblit")) flags |= SDL_ASYNCBLIT;
2213 int windowflags = SDL_WINDOW_SHOWN;
2216 win_half_width = mode->width>>1;
2217 win_half_height = mode->height>>1;
2219 if(vid_resizable.integer)
2220 #if SDL_MAJOR_VERSION == 1
2221 flags |= SDL_RESIZABLE;
2223 windowflags |= SDL_WINDOW_RESIZABLE;
2226 VID_OutputVersion();
2228 vid_isfullscreen = false;
2229 if (mode->fullscreen) {
2230 #if SDL_MAJOR_VERSION == 1
2231 flags |= SDL_FULLSCREEN;
2233 windowflags |= SDL_WINDOW_FULLSCREEN;
2235 vid_isfullscreen = true;
2238 video_bpp = mode->bitsperpixel;
2239 #if SDL_MAJOR_VERSION == 1
2240 video_flags = flags;
2241 screen = VID_WrapSDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2244 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2248 mode->width = screen->w;
2249 mode->height = screen->h;
2251 window_flags = windowflags;
2252 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2255 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2259 SDL_GetWindowSize(window, &mode->width, &mode->height);
2262 // create a framebuffer using our specific color format, we let the SDL blit function convert it in VID_Finish
2263 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, mode->width, mode->height, 32, 0x00FF0000, 0x0000FF00, 0x00000000FF, 0xFF000000);
2264 if (vid_softsurface == NULL)
2266 Con_Printf("Failed to setup software rasterizer framebuffer %ix%ix32bpp: %s\n", mode->width, mode->height, SDL_GetError());
2270 #if SDL_MAJOR_VERSION == 1
2271 SDL_SetAlpha(vid_softsurface, 0, 255);
2274 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
2275 vid.softdepthpixels = (unsigned int *)calloc(1, mode->width * mode->height * 4);
2276 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)
2278 Con_Printf("Failed to initialize software rasterizer\n");
2283 #if SDL_MAJOR_VERSION == 1
2285 SDL_EnableUNICODE( SDL_ENABLE );
2286 // enable key repeat since everyone expects it
2287 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2290 VID_Soft_SharedSetup();
2293 vid_activewindow = false;
2294 vid_hasfocus = true;
2295 vid_usingmouse = false;
2296 vid_usinghidecursor = false;
2298 #if SDL_MAJOR_VERSION == 1
2299 SDL_WM_GrabInput(SDL_GRAB_OFF);
2304 qboolean VID_InitMode(viddef_mode_t *mode)
2306 if (!SDL_WasInit(SDL_INIT_VIDEO) && SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
2307 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
2309 if (vid_soft.integer)
2310 return VID_InitModeSoft(mode);
2313 return VID_InitModeGL(mode);
2316 void VID_Shutdown (void)
2318 VID_EnableJoystick(false);
2319 VID_SetMouse(false, false, false);
2320 VID_RestoreSystemGamma();
2322 #if SDL_MAJOR_VERSION == 1
2326 SDL_FreeSurface(icon);
2332 if (vid_softsurface)
2333 SDL_FreeSurface(vid_softsurface);
2334 vid_softsurface = NULL;
2335 vid.softpixels = NULL;
2336 if (vid.softdepthpixels)
2337 free(vid.softdepthpixels);
2338 vid.softdepthpixels = NULL;
2340 #if SDL_MAJOR_VERSION != 1
2341 SDL_DestroyWindow(window);
2345 SDL_QuitSubSystem(SDL_INIT_VIDEO);
2350 gl_platformextensions = "";
2353 int VID_SetGamma (unsigned short *ramps, int rampsize)
2355 #if SDL_MAJOR_VERSION == 1
2356 return !SDL_SetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2358 return !SDL_SetWindowGammaRamp (window, ramps, ramps + rampsize, ramps + rampsize*2);
2362 int VID_GetGamma (unsigned short *ramps, int rampsize)
2364 #if SDL_MAJOR_VERSION == 1
2365 return !SDL_GetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2367 return !SDL_GetWindowGammaRamp (window, ramps, ramps + rampsize, ramps + rampsize*2);
2371 void VID_Finish (void)
2373 #if SDL_MAJOR_VERSION == 1
2376 //react on appstate changes
2377 appstate = SDL_GetAppState();
2379 vid_hidden = !(appstate & SDL_APPACTIVE);
2380 vid_hasfocus = (appstate & SDL_APPINPUTFOCUS) != 0;
2382 vid_activewindow = !vid_hidden && vid_hasfocus;
2384 VID_UpdateGamma(false, 256);
2388 switch(vid.renderpath)
2390 case RENDERPATH_GL11:
2391 case RENDERPATH_GL13:
2392 case RENDERPATH_GL20:
2393 case RENDERPATH_GLES1:
2394 case RENDERPATH_GLES2:
2396 if (r_speeds.integer == 2 || gl_finish.integer)
2398 #if SDL_MAJOR_VERSION != 1
2400 qboolean vid_usevsync;
2401 vid_usevsync = (vid_vsync.integer && !cls.timedemo);
2402 if (vid_usingvsync != vid_usevsync)
2404 if (SDL_GL_SetSwapInterval(vid_usevsync != 0) >= 0)
2405 Con_DPrintf("Vsync %s\n", vid_usevsync ? "activated" : "deactivated");
2407 Con_DPrintf("ERROR: can't %s vsync\n", vid_usevsync ? "activate" : "deactivate");
2411 #if SDL_MAJOR_VERSION == 1
2412 SDL_GL_SwapBuffers();
2414 SDL_GL_SwapWindow(window);
2417 case RENDERPATH_SOFT:
2418 DPSOFTRAST_Finish();
2419 #if SDL_MAJOR_VERSION == 1
2420 // if (!r_test.integer)
2422 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2427 SDL_Surface *screen = SDL_GetWindowSurface(window);
2428 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2429 SDL_UpdateWindowSurface(window);
2433 case RENDERPATH_D3D9:
2434 case RENDERPATH_D3D10:
2435 case RENDERPATH_D3D11:
2436 if (r_speeds.integer == 2 || gl_finish.integer)
2443 size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
2446 #if SDL_MAJOR_VERSION == 1
2447 SDL_Rect **vidmodes;
2448 int bpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
2450 for(vidmodes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE); vidmodes && vidmodes != (SDL_Rect**)(-1) && *vidmodes; ++vidmodes)
2454 modes[k].width = (*vidmodes)->w;
2455 modes[k].height = (*vidmodes)->h;
2457 modes[k].refreshrate = 60; // no support for refresh rate in SDL
2458 modes[k].pixelheight_num = 1;
2459 modes[k].pixelheight_denom = 1; // SDL does not provide this
2464 int nummodes = SDL_GetNumDisplayModes(0);
2465 SDL_DisplayMode mode;
2466 for (modenum = 0;modenum < nummodes;modenum++)
2470 if (SDL_GetDisplayMode(0, modenum, &mode))
2472 modes[k].width = mode.w;
2473 modes[k].height = mode.h;
2474 modes[k].refreshrate = mode.refresh_rate;
2475 modes[k].pixelheight_num = 1;
2476 modes[k].pixelheight_num = 1;
2477 modes[k].pixelheight_denom = 1; // SDL does not provide this