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
21 #include <SDL_syswm.h>
26 #include "dpsoftrast.h"
30 #include <Carbon/Carbon.h>
31 #include <IOKit/hidsystem/IOHIDLib.h>
32 #include <IOKit/hidsystem/IOHIDParameter.h>
33 #include <IOKit/hidsystem/event_status_driver.h>
34 static cvar_t apple_mouse_noaccel = {CVAR_SAVE, "apple_mouse_noaccel", "1", "disables mouse acceleration while DarkPlaces is active"};
35 static qboolean vid_usingnoaccel;
36 static double originalMouseSpeed = -1.0;
37 io_connect_t IN_GetIOHandle(void)
39 io_connect_t iohandle = MACH_PORT_NULL;
41 io_service_t iohidsystem = MACH_PORT_NULL;
42 mach_port_t masterport;
44 status = IOMasterPort(MACH_PORT_NULL, &masterport);
45 if(status != KERN_SUCCESS)
48 iohidsystem = IORegistryEntryFromPath(masterport, kIOServicePlane ":/IOResources/IOHIDSystem");
52 status = IOServiceOpen(iohidsystem, mach_task_self(), kIOHIDParamConnectType, &iohandle);
53 IOObjectRelease(iohidsystem);
64 // Tell startup code that we have a client
65 int cl_available = true;
67 qboolean vid_supportrefreshrate = false;
69 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
70 # define SETVIDEOMODE 1
73 # define SETVIDEOMODE 0
75 // LordHavoc: SDL 1.3's SDL_CreateWindow API is not finished enough to use yet, but you can set this to 0 if you want to try it...
77 # define SETVIDEOMODE 1
82 static qboolean vid_usingmouse = false;
83 static qboolean vid_usinghidecursor = false;
84 static qboolean vid_hasfocus = false;
85 static qboolean vid_isfullscreen;
86 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
88 static qboolean vid_usingvsync = false;
90 static SDL_Joystick *vid_sdljoystick = NULL;
92 static int win_half_width = 50;
93 static int win_half_height = 50;
97 static SDL_Surface *screen;
98 static int video_flags;
100 static SDL_GLContext *context;
101 static SDL_Window *window;
102 static int window_flags;
104 static SDL_Surface *vid_softsurface;
106 /////////////////////////
109 //TODO: Add error checking
112 #define SDLK_PERCENT '%'
113 #define SDLK_PRINTSCREEN SDLK_PRINT
114 #define SDLK_SCROLLLOCK SDLK_SCROLLOCK
115 #define SDLK_NUMLOCKCLEAR SDLK_NUMLOCK
116 #define SDLK_KP_1 SDLK_KP1
117 #define SDLK_KP_2 SDLK_KP2
118 #define SDLK_KP_3 SDLK_KP3
119 #define SDLK_KP_4 SDLK_KP4
120 #define SDLK_KP_5 SDLK_KP5
121 #define SDLK_KP_6 SDLK_KP6
122 #define SDLK_KP_7 SDLK_KP7
123 #define SDLK_KP_8 SDLK_KP8
124 #define SDLK_KP_9 SDLK_KP9
125 #define SDLK_KP_0 SDLK_KP0
128 static int MapKey( unsigned int sdlkey )
133 // case SDLK_UNKNOWN: return K_UNKNOWN;
134 case SDLK_RETURN: return K_ENTER;
135 case SDLK_ESCAPE: return K_ESCAPE;
136 case SDLK_BACKSPACE: return K_BACKSPACE;
137 case SDLK_TAB: return K_TAB;
138 case SDLK_SPACE: return K_SPACE;
139 case SDLK_EXCLAIM: return '!';
140 case SDLK_QUOTEDBL: return '"';
141 case SDLK_HASH: return '#';
142 case SDLK_PERCENT: return '%';
143 case SDLK_DOLLAR: return '$';
144 case SDLK_AMPERSAND: return '&';
145 case SDLK_QUOTE: return '\'';
146 case SDLK_LEFTPAREN: return '(';
147 case SDLK_RIGHTPAREN: return ')';
148 case SDLK_ASTERISK: return '*';
149 case SDLK_PLUS: return '+';
150 case SDLK_COMMA: return ',';
151 case SDLK_MINUS: return '-';
152 case SDLK_PERIOD: return '.';
153 case SDLK_SLASH: return '/';
154 case SDLK_0: return '0';
155 case SDLK_1: return '1';
156 case SDLK_2: return '2';
157 case SDLK_3: return '3';
158 case SDLK_4: return '4';
159 case SDLK_5: return '5';
160 case SDLK_6: return '6';
161 case SDLK_7: return '7';
162 case SDLK_8: return '8';
163 case SDLK_9: return '9';
164 case SDLK_COLON: return ':';
165 case SDLK_SEMICOLON: return ';';
166 case SDLK_LESS: return '<';
167 case SDLK_EQUALS: return '=';
168 case SDLK_GREATER: return '>';
169 case SDLK_QUESTION: return '?';
170 case SDLK_AT: return '@';
171 case SDLK_LEFTBRACKET: return '[';
172 case SDLK_BACKSLASH: return '\\';
173 case SDLK_RIGHTBRACKET: return ']';
174 case SDLK_CARET: return '^';
175 case SDLK_UNDERSCORE: return '_';
176 case SDLK_BACKQUOTE: return '`';
177 case SDLK_a: return 'a';
178 case SDLK_b: return 'b';
179 case SDLK_c: return 'c';
180 case SDLK_d: return 'd';
181 case SDLK_e: return 'e';
182 case SDLK_f: return 'f';
183 case SDLK_g: return 'g';
184 case SDLK_h: return 'h';
185 case SDLK_i: return 'i';
186 case SDLK_j: return 'j';
187 case SDLK_k: return 'k';
188 case SDLK_l: return 'l';
189 case SDLK_m: return 'm';
190 case SDLK_n: return 'n';
191 case SDLK_o: return 'o';
192 case SDLK_p: return 'p';
193 case SDLK_q: return 'q';
194 case SDLK_r: return 'r';
195 case SDLK_s: return 's';
196 case SDLK_t: return 't';
197 case SDLK_u: return 'u';
198 case SDLK_v: return 'v';
199 case SDLK_w: return 'w';
200 case SDLK_x: return 'x';
201 case SDLK_y: return 'y';
202 case SDLK_z: return 'z';
203 case SDLK_CAPSLOCK: return K_CAPSLOCK;
204 case SDLK_F1: return K_F1;
205 case SDLK_F2: return K_F2;
206 case SDLK_F3: return K_F3;
207 case SDLK_F4: return K_F4;
208 case SDLK_F5: return K_F5;
209 case SDLK_F6: return K_F6;
210 case SDLK_F7: return K_F7;
211 case SDLK_F8: return K_F8;
212 case SDLK_F9: return K_F9;
213 case SDLK_F10: return K_F10;
214 case SDLK_F11: return K_F11;
215 case SDLK_F12: return K_F12;
216 case SDLK_PRINTSCREEN: return K_PRINTSCREEN;
217 case SDLK_SCROLLLOCK: return K_SCROLLOCK;
218 case SDLK_PAUSE: return K_PAUSE;
219 case SDLK_INSERT: return K_INS;
220 case SDLK_HOME: return K_HOME;
221 case SDLK_PAGEUP: return K_PGUP;
223 case SDLK_DELETE: return K_BACKSPACE;
225 case SDLK_DELETE: return K_DEL;
227 case SDLK_END: return K_END;
228 case SDLK_PAGEDOWN: return K_PGDN;
229 case SDLK_RIGHT: return K_RIGHTARROW;
230 case SDLK_LEFT: return K_LEFTARROW;
231 case SDLK_DOWN: return K_DOWNARROW;
232 case SDLK_UP: return K_UPARROW;
233 case SDLK_NUMLOCKCLEAR: return K_NUMLOCK;
234 case SDLK_KP_DIVIDE: return K_KP_DIVIDE;
235 case SDLK_KP_MULTIPLY: return K_KP_MULTIPLY;
236 case SDLK_KP_MINUS: return K_KP_MINUS;
237 case SDLK_KP_PLUS: return K_KP_PLUS;
238 case SDLK_KP_ENTER: return K_KP_ENTER;
239 case SDLK_KP_1: return K_KP_1;
240 case SDLK_KP_2: return K_KP_2;
241 case SDLK_KP_3: return K_KP_3;
242 case SDLK_KP_4: return K_KP_4;
243 case SDLK_KP_5: return K_KP_5;
244 case SDLK_KP_6: return K_KP_6;
245 case SDLK_KP_7: return K_KP_7;
246 case SDLK_KP_8: return K_KP_8;
247 case SDLK_KP_9: return K_KP_9;
248 case SDLK_KP_0: return K_KP_0;
249 case SDLK_KP_PERIOD: return K_KP_PERIOD;
250 // case SDLK_APPLICATION: return K_APPLICATION;
251 // case SDLK_POWER: return K_POWER;
252 case SDLK_KP_EQUALS: return K_KP_EQUALS;
253 // case SDLK_F13: return K_F13;
254 // case SDLK_F14: return K_F14;
255 // case SDLK_F15: return K_F15;
256 // case SDLK_F16: return K_F16;
257 // case SDLK_F17: return K_F17;
258 // case SDLK_F18: return K_F18;
259 // case SDLK_F19: return K_F19;
260 // case SDLK_F20: return K_F20;
261 // case SDLK_F21: return K_F21;
262 // case SDLK_F22: return K_F22;
263 // case SDLK_F23: return K_F23;
264 // case SDLK_F24: return K_F24;
265 // case SDLK_EXECUTE: return K_EXECUTE;
266 // case SDLK_HELP: return K_HELP;
267 // case SDLK_MENU: return K_MENU;
268 // case SDLK_SELECT: return K_SELECT;
269 // case SDLK_STOP: return K_STOP;
270 // case SDLK_AGAIN: return K_AGAIN;
271 // case SDLK_UNDO: return K_UNDO;
272 // case SDLK_CUT: return K_CUT;
273 // case SDLK_COPY: return K_COPY;
274 // case SDLK_PASTE: return K_PASTE;
275 // case SDLK_FIND: return K_FIND;
276 // case SDLK_MUTE: return K_MUTE;
277 // case SDLK_VOLUMEUP: return K_VOLUMEUP;
278 // case SDLK_VOLUMEDOWN: return K_VOLUMEDOWN;
279 // case SDLK_KP_COMMA: return K_KP_COMMA;
280 // case SDLK_KP_EQUALSAS400: return K_KP_EQUALSAS400;
281 // case SDLK_ALTERASE: return K_ALTERASE;
282 // case SDLK_SYSREQ: return K_SYSREQ;
283 // case SDLK_CANCEL: return K_CANCEL;
284 // case SDLK_CLEAR: return K_CLEAR;
285 // case SDLK_PRIOR: return K_PRIOR;
286 // case SDLK_RETURN2: return K_RETURN2;
287 // case SDLK_SEPARATOR: return K_SEPARATOR;
288 // case SDLK_OUT: return K_OUT;
289 // case SDLK_OPER: return K_OPER;
290 // case SDLK_CLEARAGAIN: return K_CLEARAGAIN;
291 // case SDLK_CRSEL: return K_CRSEL;
292 // case SDLK_EXSEL: return K_EXSEL;
293 // case SDLK_KP_00: return K_KP_00;
294 // case SDLK_KP_000: return K_KP_000;
295 // case SDLK_THOUSANDSSEPARATOR: return K_THOUSANDSSEPARATOR;
296 // case SDLK_DECIMALSEPARATOR: return K_DECIMALSEPARATOR;
297 // case SDLK_CURRENCYUNIT: return K_CURRENCYUNIT;
298 // case SDLK_CURRENCYSUBUNIT: return K_CURRENCYSUBUNIT;
299 // case SDLK_KP_LEFTPAREN: return K_KP_LEFTPAREN;
300 // case SDLK_KP_RIGHTPAREN: return K_KP_RIGHTPAREN;
301 // case SDLK_KP_LEFTBRACE: return K_KP_LEFTBRACE;
302 // case SDLK_KP_RIGHTBRACE: return K_KP_RIGHTBRACE;
303 // case SDLK_KP_TAB: return K_KP_TAB;
304 // case SDLK_KP_BACKSPACE: return K_KP_BACKSPACE;
305 // case SDLK_KP_A: return K_KP_A;
306 // case SDLK_KP_B: return K_KP_B;
307 // case SDLK_KP_C: return K_KP_C;
308 // case SDLK_KP_D: return K_KP_D;
309 // case SDLK_KP_E: return K_KP_E;
310 // case SDLK_KP_F: return K_KP_F;
311 // case SDLK_KP_XOR: return K_KP_XOR;
312 // case SDLK_KP_POWER: return K_KP_POWER;
313 // case SDLK_KP_PERCENT: return K_KP_PERCENT;
314 // case SDLK_KP_LESS: return K_KP_LESS;
315 // case SDLK_KP_GREATER: return K_KP_GREATER;
316 // case SDLK_KP_AMPERSAND: return K_KP_AMPERSAND;
317 // case SDLK_KP_DBLAMPERSAND: return K_KP_DBLAMPERSAND;
318 // case SDLK_KP_VERTICALBAR: return K_KP_VERTICALBAR;
319 // case SDLK_KP_DBLVERTICALBAR: return K_KP_DBLVERTICALBAR;
320 // case SDLK_KP_COLON: return K_KP_COLON;
321 // case SDLK_KP_HASH: return K_KP_HASH;
322 // case SDLK_KP_SPACE: return K_KP_SPACE;
323 // case SDLK_KP_AT: return K_KP_AT;
324 // case SDLK_KP_EXCLAM: return K_KP_EXCLAM;
325 // case SDLK_KP_MEMSTORE: return K_KP_MEMSTORE;
326 // case SDLK_KP_MEMRECALL: return K_KP_MEMRECALL;
327 // case SDLK_KP_MEMCLEAR: return K_KP_MEMCLEAR;
328 // case SDLK_KP_MEMADD: return K_KP_MEMADD;
329 // case SDLK_KP_MEMSUBTRACT: return K_KP_MEMSUBTRACT;
330 // case SDLK_KP_MEMMULTIPLY: return K_KP_MEMMULTIPLY;
331 // case SDLK_KP_MEMDIVIDE: return K_KP_MEMDIVIDE;
332 // case SDLK_KP_PLUSMINUS: return K_KP_PLUSMINUS;
333 // case SDLK_KP_CLEAR: return K_KP_CLEAR;
334 // case SDLK_KP_CLEARENTRY: return K_KP_CLEARENTRY;
335 // case SDLK_KP_BINARY: return K_KP_BINARY;
336 // case SDLK_KP_OCTAL: return K_KP_OCTAL;
337 // case SDLK_KP_DECIMAL: return K_KP_DECIMAL;
338 // case SDLK_KP_HEXADECIMAL: return K_KP_HEXADECIMAL;
339 case SDLK_LCTRL: return K_CTRL;
340 case SDLK_LSHIFT: return K_SHIFT;
341 case SDLK_LALT: return K_ALT;
342 // case SDLK_LGUI: return K_LGUI;
343 case SDLK_RCTRL: return K_CTRL;
344 case SDLK_RSHIFT: return K_SHIFT;
345 case SDLK_RALT: return K_ALT;
346 // case SDLK_RGUI: return K_RGUI;
347 // case SDLK_MODE: return K_MODE;
348 // case SDLK_AUDIONEXT: return K_AUDIONEXT;
349 // case SDLK_AUDIOPREV: return K_AUDIOPREV;
350 // case SDLK_AUDIOSTOP: return K_AUDIOSTOP;
351 // case SDLK_AUDIOPLAY: return K_AUDIOPLAY;
352 // case SDLK_AUDIOMUTE: return K_AUDIOMUTE;
353 // case SDLK_MEDIASELECT: return K_MEDIASELECT;
354 // case SDLK_WWW: return K_WWW;
355 // case SDLK_MAIL: return K_MAIL;
356 // case SDLK_CALCULATOR: return K_CALCULATOR;
357 // case SDLK_COMPUTER: return K_COMPUTER;
358 // case SDLK_AC_SEARCH: return K_AC_SEARCH;
359 // case SDLK_AC_HOME: return K_AC_HOME;
360 // case SDLK_AC_BACK: return K_AC_BACK;
361 // case SDLK_AC_FORWARD: return K_AC_FORWARD;
362 // case SDLK_AC_STOP: return K_AC_STOP;
363 // case SDLK_AC_REFRESH: return K_AC_REFRESH;
364 // case SDLK_AC_BOOKMARKS: return K_AC_BOOKMARKS;
365 // case SDLK_BRIGHTNESSDOWN: return K_BRIGHTNESSDOWN;
366 // case SDLK_BRIGHTNESSUP: return K_BRIGHTNESSUP;
367 // case SDLK_DISPLAYSWITCH: return K_DISPLAYSWITCH;
368 // case SDLK_KBDILLUMTOGGLE: return K_KBDILLUMTOGGLE;
369 // case SDLK_KBDILLUMDOWN: return K_KBDILLUMDOWN;
370 // case SDLK_KBDILLUMUP: return K_KBDILLUMUP;
371 // case SDLK_EJECT: return K_EJECT;
372 // case SDLK_SLEEP: return K_SLEEP;
377 int SDL_iPhoneKeyboardShow(SDL_Window * window); // reveals the onscreen keyboard. Returns 0 on success and -1 on error.
378 int SDL_iPhoneKeyboardHide(SDL_Window * window); // hides the onscreen keyboard. Returns 0 on success and -1 on error.
379 SDL_bool SDL_iPhoneKeyboardIsShown(SDL_Window * window); // returns whether or not the onscreen keyboard is currently visible.
380 int SDL_iPhoneKeyboardToggle(SDL_Window * window); // toggles the visibility of the onscreen keyboard. Returns 0 on success and -1 on error.
383 static void VID_ShowKeyboard(qboolean show)
388 if (!SDL_iPhoneKeyboardIsShown(window))
389 SDL_iPhoneKeyboardShow(window);
393 if (SDL_iPhoneKeyboardIsShown(window))
394 SDL_iPhoneKeyboardHide(window);
400 qboolean VID_ShowingKeyboard(void)
402 return SDL_iPhoneKeyboardIsShown(window);
406 void VID_SetMouse(qboolean fullscreengrab, qboolean relative, qboolean hidecursor)
411 if(vid_usingmouse && (vid_usingnoaccel != !!apple_mouse_noaccel.integer))
412 VID_SetMouse(false, false, false); // ungrab first!
414 if (vid_usingmouse != relative)
416 vid_usingmouse = relative;
417 cl_ignoremousemoves = 2;
419 SDL_WM_GrabInput( relative ? SDL_GRAB_ON : SDL_GRAB_OFF );
421 SDL_SetRelativeMouseMode(relative ? SDL_TRUE : SDL_FALSE);
426 // Save the status of mouse acceleration
427 originalMouseSpeed = -1.0; // in case of error
428 if(apple_mouse_noaccel.integer)
430 io_connect_t mouseDev = IN_GetIOHandle();
433 if(IOHIDGetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), &originalMouseSpeed) == kIOReturnSuccess)
435 Con_DPrintf("previous mouse acceleration: %f\n", originalMouseSpeed);
436 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), -1.0) != kIOReturnSuccess)
438 Con_Print("Could not disable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
439 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
444 Con_Print("Could not disable mouse acceleration (failed at IOHIDGetAccelerationWithKey).\n");
445 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
447 IOServiceClose(mouseDev);
451 Con_Print("Could not disable mouse acceleration (failed at IO_GetIOHandle).\n");
452 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
456 vid_usingnoaccel = !!apple_mouse_noaccel.integer;
460 if(originalMouseSpeed != -1.0)
462 io_connect_t mouseDev = IN_GetIOHandle();
465 Con_DPrintf("restoring mouse acceleration to: %f\n", originalMouseSpeed);
466 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), originalMouseSpeed) != kIOReturnSuccess)
467 Con_Print("Could not re-enable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
468 IOServiceClose(mouseDev);
471 Con_Print("Could not re-enable mouse acceleration (failed at IO_GetIOHandle).\n");
476 if (vid_usinghidecursor != hidecursor)
478 vid_usinghidecursor = hidecursor;
479 SDL_ShowCursor( hidecursor ? SDL_DISABLE : SDL_ENABLE);
484 // multitouch[10][] represents the mouse pointer
485 // X and Y coordinates are 0-32767 as per SDL spec
486 #define MAXFINGERS 11
487 int multitouch[MAXFINGERS][3];
489 static qboolean VID_TouchscreenArea(int corner, float px, float py, float pwidth, float pheight, const char *icon, float *resultmove, qboolean *resultbutton, keynum_t key)
492 float fx, fy, fwidth, fheight;
494 qboolean button = false;
496 if (pwidth > 0 && pheight > 0)
498 if (!VID_ShowingKeyboard())
501 if (corner & 1) px += vid_conwidth.value;
502 if (corner & 2) py += vid_conheight.value;
503 if (corner & 4) px += vid_conwidth.value * 0.5f;
504 if (corner & 8) py += vid_conheight.value * 0.5f;
505 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);}
506 fx = px * 32768.0f / vid_conwidth.value;
507 fy = py * 32768.0f / vid_conheight.value;
508 fwidth = pwidth * 32768.0f / vid_conwidth.value;
509 fheight = pheight * 32768.0f / vid_conheight.value;
510 for (finger = 0;finger < MAXFINGERS;finger++)
512 if (multitouch[finger][0] && multitouch[finger][1] >= fx && multitouch[finger][2] >= fy && multitouch[finger][1] < fx + fwidth && multitouch[finger][2] < fy + fheight)
514 rel[0] = (multitouch[finger][1] - (fx + 0.5f * fwidth)) * (2.0f / fwidth);
515 rel[1] = (multitouch[finger][2] - (fy + 0.5f * fheight)) * (2.0f / fheight);
521 if (scr_numtouchscreenareas < 16)
523 scr_touchscreenareas[scr_numtouchscreenareas].pic = icon;
524 scr_touchscreenareas[scr_numtouchscreenareas].rect[0] = px;
525 scr_touchscreenareas[scr_numtouchscreenareas].rect[1] = py;
526 scr_touchscreenareas[scr_numtouchscreenareas].rect[2] = pwidth;
527 scr_touchscreenareas[scr_numtouchscreenareas].rect[3] = pheight;
528 scr_touchscreenareas[scr_numtouchscreenareas].active = button;
529 scr_numtouchscreenareas++;
535 VectorCopy(rel, resultmove);
537 VectorClear(resultmove);
541 if (*resultbutton != button && (int)key > 0)
542 Key_Event(key, 0, button);
543 *resultbutton = button;
548 void VID_BuildJoyState(vid_joystate_t *joystate)
550 VID_Shared_BuildJoyState_Begin(joystate);
554 SDL_Joystick *joy = vid_sdljoystick;
558 numaxes = SDL_JoystickNumAxes(joy);
559 for (j = 0;j < numaxes;j++)
560 joystate->axis[j] = SDL_JoystickGetAxis(joy, j) * (1.0f / 32767.0f);
561 numbuttons = SDL_JoystickNumButtons(joy);
562 for (j = 0;j < numbuttons;j++)
563 joystate->button[j] = SDL_JoystickGetButton(joy, j);
566 VID_Shared_BuildJoyState_Finish(joystate);
569 /////////////////////
575 static int old_x = 0, old_y = 0;
576 static int stuck = 0;
578 vid_joystate_t joystate;
580 scr_numtouchscreenareas = 0;
581 if (vid_touchscreen.integer)
583 vec3_t move, aim, click;
584 static qboolean buttons[16];
585 static keydest_t oldkeydest;
586 keydest_t keydest = (key_consoleactive & KEY_CONSOLEACTIVE_USER) ? key_console : key_dest;
587 multitouch[MAXFINGERS-1][0] = SDL_GetMouseState(&x, &y);
588 multitouch[MAXFINGERS-1][1] = x * 32768 / vid.width;
589 multitouch[MAXFINGERS-1][2] = y * 32768 / vid.height;
590 if (oldkeydest != keydest)
594 case key_game: VID_ShowKeyboard(false);break;
595 case key_console: VID_ShowKeyboard(true);break;
596 case key_message: VID_ShowKeyboard(true);break;
600 oldkeydest = keydest;
601 // top of screen is toggleconsole and K_ESCAPE
606 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
607 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
608 if (!VID_ShowingKeyboard())
610 // user entered a command, close the console now
611 Con_ToggleConsole_f();
614 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
615 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
616 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
617 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
618 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
619 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
623 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
624 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
626 VID_TouchscreenArea( 2, 0,-128, 128, 128, "gfx/touch_movebutton.tga" , move, &buttons[0], K_MOUSE4);
627 VID_TouchscreenArea( 3,-128,-128, 128, 128, "gfx/touch_aimbutton.tga" , aim, &buttons[1], K_MOUSE5);
628 VID_TouchscreenArea( 2, 0,-160, 64, 32, "gfx/touch_jumpbutton.tga" , NULL, &buttons[3], K_SPACE);
629 VID_TouchscreenArea( 3,-128,-160, 64, 32, "gfx/touch_attackbutton.tga" , NULL, &buttons[2], K_MOUSE1);
630 VID_TouchscreenArea( 3, -64,-160, 64, 32, "gfx/touch_attack2button.tga", NULL, &buttons[4], K_MOUSE2);
635 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
636 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
637 // in menus, an icon in the corner activates keyboard
638 VID_TouchscreenArea( 2, 0, -32, 32, 32, "gfx/touch_keyboard.tga" , NULL, &buttons[15], (keynum_t)0);
640 VID_ShowKeyboard(true);
641 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
642 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
643 VID_TouchscreenArea(16, -320,-480,640, 960, NULL , click,&buttons[2], K_MOUSE1);
644 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
645 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
648 in_windowmouse_x = x;
649 in_windowmouse_y = y;
652 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
653 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
654 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
655 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
656 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
657 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
661 cl.cmd.forwardmove -= move[1] * cl_forwardspeed.value;
662 cl.cmd.sidemove += move[0] * cl_sidespeed.value;
663 cl.viewangles[0] += aim[1] * cl_pitchspeed.value * cl.realframetime;
664 cl.viewangles[1] -= aim[0] * cl_yawspeed.value * cl.realframetime;
670 if (vid_stick_mouse.integer)
672 // have the mouse stuck in the middle, example use: prevent expose effect of beryl during the game when not using
673 // window grabbing. --blub
675 // we need 2 frames to initialize the center position
679 SDL_WarpMouse(win_half_width, win_half_height);
681 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
683 SDL_GetMouseState(&x, &y);
684 SDL_GetRelativeMouseState(&x, &y);
687 SDL_GetRelativeMouseState(&x, &y);
688 in_mouse_x = x + old_x;
689 in_mouse_y = y + old_y;
690 SDL_GetMouseState(&x, &y);
691 old_x = x - win_half_width;
692 old_y = y - win_half_height;
694 SDL_WarpMouse(win_half_width, win_half_height);
696 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
700 SDL_GetRelativeMouseState( &x, &y );
706 SDL_GetMouseState(&x, &y);
707 in_windowmouse_x = x;
708 in_windowmouse_y = y;
711 VID_BuildJoyState(&joystate);
712 VID_ApplyJoyState(&joystate);
715 /////////////////////
720 static qboolean sdl_needs_restart;
721 static void sdl_start(void)
724 static void sdl_shutdown(void)
726 sdl_needs_restart = false;
728 static void sdl_newmap(void)
734 static keynum_t buttonremap[18] =
759 void Sys_SendKeyEvents( void )
761 static qboolean sound_active = true;
765 VID_EnableJoystick(true);
767 while( SDL_PollEvent( &event ) )
768 switch( event.type ) {
774 keycode = MapKey(event.key.keysym.sym);
775 if (!VID_JoyBlockEmulatedKeys(keycode))
776 Key_Event(keycode, event.key.keysym.unicode, (event.key.state == SDL_PRESSED));
778 case SDL_ACTIVEEVENT:
779 if( event.active.state & SDL_APPACTIVE )
781 if( event.active.gain )
787 case SDL_MOUSEBUTTONDOWN:
788 case SDL_MOUSEBUTTONUP:
789 if (!vid_touchscreen.integer)
790 if (event.button.button <= 18)
791 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
793 case SDL_JOYBUTTONDOWN:
794 case SDL_JOYBUTTONUP:
795 case SDL_JOYAXISMOTION:
796 case SDL_JOYBALLMOTION:
797 case SDL_JOYHATMOTION:
799 case SDL_VIDEOEXPOSE:
801 case SDL_VIDEORESIZE:
802 if(vid_resizable.integer < 2)
804 vid.width = event.resize.w;
805 vid.height = event.resize.h;
806 screen = SDL_SetVideoMode(vid.width, vid.height, video_bpp, video_flags);
809 SDL_FreeSurface(vid_softsurface);
810 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
811 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
812 SDL_SetAlpha(vid_softsurface, 0, 255);
813 if (vid.softdepthpixels)
814 free(vid.softdepthpixels);
815 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
818 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
819 // so, let's better queue it for next frame
820 if(!sdl_needs_restart)
822 Cbuf_AddText("\nr_restart\n");
823 sdl_needs_restart = true;
828 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
830 case SDL_TEXTEDITING:
831 // unused when SETVIDEOMODE API is used
834 // this occurs with SETVIDEOMODE but we are not using it
837 case SDL_MOUSEMOTION:
840 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
844 // enable/disable sound on focus gain/loss
845 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
858 sound_active = false;
866 void Sys_SendKeyEvents( void )
868 static qboolean sound_active = true;
869 static qboolean missingunicodehack = true;
876 VID_EnableJoystick(true);
878 while( SDL_PollEvent( &event ) )
879 switch( event.type ) {
885 keycode = MapKey(event.key.keysym.sym);
886 if (!VID_JoyBlockEmulatedKeys(keycode))
887 Key_Event(keycode, 0, (event.key.state == SDL_PRESSED));
889 case SDL_MOUSEBUTTONDOWN:
890 case SDL_MOUSEBUTTONUP:
891 if (!vid_touchscreen.integer)
892 if (event.button.button <= 18)
893 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
895 case SDL_JOYBUTTONDOWN:
896 case SDL_JOYBUTTONUP:
897 case SDL_JOYAXISMOTION:
898 case SDL_JOYBALLMOTION:
899 case SDL_JOYHATMOTION:
901 case SDL_VIDEOEXPOSE:
903 case SDL_WINDOWEVENT:
904 //if (event.window.windowID == window) // how to compare?
906 switch(event.window.event)
908 case SDL_WINDOWEVENT_SHOWN:
911 case SDL_WINDOWEVENT_HIDDEN:
914 case SDL_WINDOWEVENT_EXPOSED:
916 case SDL_WINDOWEVENT_MOVED:
918 case SDL_WINDOWEVENT_RESIZED:
919 if(vid_resizable.integer < 2)
921 vid.width = event.window.data1;
922 vid.height = event.window.data2;
925 SDL_FreeSurface(vid_softsurface);
926 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
927 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
928 SDL_SetAlpha(vid_softsurface, 0, 255);
929 if (vid.softdepthpixels)
930 free(vid.softdepthpixels);
931 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
934 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
935 // so, let's better queue it for next frame
936 if(!sdl_needs_restart)
938 Cbuf_AddText("\nr_restart\n");
939 sdl_needs_restart = true;
944 case SDL_WINDOWEVENT_MINIMIZED:
946 case SDL_WINDOWEVENT_MAXIMIZED:
948 case SDL_WINDOWEVENT_RESTORED:
950 case SDL_WINDOWEVENT_ENTER:
952 case SDL_WINDOWEVENT_LEAVE:
954 case SDL_WINDOWEVENT_FOCUS_GAINED:
957 case SDL_WINDOWEVENT_FOCUS_LOST:
958 vid_hasfocus = false;
960 case SDL_WINDOWEVENT_CLOSE:
966 case SDL_TEXTEDITING:
967 // FIXME! this is where composition gets supported
970 // we have some characters to parse
971 missingunicodehack = false;
974 for (i = 0;event.text.text[i];)
976 unicode = event.text.text[i++];
980 // strip high bits (we could count these to validate character length but we don't)
981 for (j = 0x80;unicode & j;j >>= 1)
983 for (;(event.text.text[i] & 0xC0) == 0x80;i++)
984 unicode = (unicode << 6) | (event.text.text[i] & 0x3F);
985 // low characters are invalid and could be bad, so replace them
987 unicode = '?'; // we could use 0xFFFD instead, the unicode substitute character
989 //Con_DPrintf("SDL_TEXTINPUT: K_TEXT %i \n", unicode);
990 Key_Event(K_TEXT, unicode, true);
991 Key_Event(K_TEXT, unicode, false);
995 case SDL_MOUSEMOTION:
998 Con_DPrintf("SDL_FINGERDOWN for finger %i\n", (int)event.tfinger.fingerId);
999 for (i = 0;i < MAXFINGERS-1;i++)
1001 if (!multitouch[i][0])
1003 multitouch[i][0] = event.tfinger.fingerId;
1004 multitouch[i][1] = event.tfinger.x;
1005 multitouch[i][2] = event.tfinger.y;
1006 // TODO: use event.tfinger.pressure?
1010 if (i == MAXFINGERS-1)
1011 Con_DPrintf("Too many fingers at once!\n");
1014 Con_DPrintf("SDL_FINGERUP for finger %i\n", (int)event.tfinger.fingerId);
1015 for (i = 0;i < MAXFINGERS-1;i++)
1017 if (multitouch[i][0] == event.tfinger.fingerId)
1019 multitouch[i][0] = 0;
1023 if (i == MAXFINGERS-1)
1024 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1026 case SDL_FINGERMOTION:
1027 Con_DPrintf("SDL_FINGERMOTION for finger %i\n", (int)event.tfinger.fingerId);
1028 for (i = 0;i < MAXFINGERS-1;i++)
1030 if (multitouch[i][0] == event.tfinger.fingerId)
1032 multitouch[i][1] = event.tfinger.x;
1033 multitouch[i][2] = event.tfinger.y;
1037 if (i == MAXFINGERS-1)
1038 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1040 case SDL_TOUCHBUTTONDOWN:
1041 // not sure what to do with this...
1043 case SDL_TOUCHBUTTONUP:
1044 // not sure what to do with this...
1047 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
1051 // enable/disable sound on focus gain/loss
1052 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
1057 sound_active = true;
1065 sound_active = false;
1078 #include <OpenGLES/ES2/gl.h>
1080 #include <SDL_opengles.h>
1083 //#define PRECALL //Con_Printf("GLCALL %s:%i\n", __FILE__, __LINE__)
1086 GLboolean wrapglIsBuffer(GLuint buffer) {PRECALL;return glIsBuffer(buffer);POSTCALL;}
1087 GLboolean wrapglIsEnabled(GLenum cap) {PRECALL;return glIsEnabled(cap);POSTCALL;}
1088 GLboolean wrapglIsFramebuffer(GLuint framebuffer) {PRECALL;return glIsFramebuffer(framebuffer);POSTCALL;}
1089 //GLboolean wrapglIsQuery(GLuint qid) {PRECALL;return glIsQuery(qid);POSTCALL;}
1090 GLboolean wrapglIsRenderbuffer(GLuint renderbuffer) {PRECALL;return glIsRenderbuffer(renderbuffer);POSTCALL;}
1091 //GLboolean wrapglUnmapBuffer(GLenum target) {PRECALL;return glUnmapBuffer(target);POSTCALL;}
1092 GLenum wrapglCheckFramebufferStatus(GLenum target) {PRECALL;return glCheckFramebufferStatus(target);POSTCALL;}
1093 GLenum wrapglGetError(void) {PRECALL;return glGetError();POSTCALL;}
1094 GLuint wrapglCreateProgram(void) {PRECALL;return glCreateProgram();POSTCALL;}
1095 GLuint wrapglCreateShader(GLenum shaderType) {PRECALL;return glCreateShader(shaderType);POSTCALL;}
1096 //GLuint wrapglGetHandle(GLenum pname) {PRECALL;return glGetHandle(pname);POSTCALL;}
1097 GLint wrapglGetAttribLocation(GLuint programObj, const GLchar *name) {PRECALL;return glGetAttribLocation(programObj, name);POSTCALL;}
1098 GLint wrapglGetUniformLocation(GLuint programObj, const GLchar *name) {PRECALL;return glGetUniformLocation(programObj, name);POSTCALL;}
1099 //GLvoid* wrapglMapBuffer(GLenum target, GLenum access) {PRECALL;return glMapBuffer(target, access);POSTCALL;}
1100 const GLubyte* wrapglGetString(GLenum name) {PRECALL;return (const GLubyte*)glGetString(name);POSTCALL;}
1101 void wrapglActiveStencilFace(GLenum e) {PRECALL;Con_Printf("glActiveStencilFace(e)\n");POSTCALL;}
1102 void wrapglActiveTexture(GLenum e) {PRECALL;glActiveTexture(e);POSTCALL;}
1103 void wrapglAlphaFunc(GLenum func, GLclampf ref) {PRECALL;Con_Printf("glAlphaFunc(func, ref)\n");POSTCALL;}
1104 void wrapglArrayElement(GLint i) {PRECALL;Con_Printf("glArrayElement(i)\n");POSTCALL;}
1105 void wrapglAttachShader(GLuint containerObj, GLuint obj) {PRECALL;glAttachShader(containerObj, obj);POSTCALL;}
1106 //void wrapglBegin(GLenum mode) {PRECALL;Con_Printf("glBegin(mode)\n");POSTCALL;}
1107 //void wrapglBeginQuery(GLenum target, GLuint qid) {PRECALL;glBeginQuery(target, qid);POSTCALL;}
1108 void wrapglBindAttribLocation(GLuint programObj, GLuint index, const GLchar *name) {PRECALL;glBindAttribLocation(programObj, index, name);POSTCALL;}
1109 //void wrapglBindFragDataLocation(GLuint programObj, GLuint index, const GLchar *name) {PRECALL;glBindFragDataLocation(programObj, index, name);POSTCALL;}
1110 void wrapglBindBuffer(GLenum target, GLuint buffer) {PRECALL;glBindBuffer(target, buffer);POSTCALL;}
1111 void wrapglBindFramebuffer(GLenum target, GLuint framebuffer) {PRECALL;glBindFramebuffer(target, framebuffer);POSTCALL;}
1112 void wrapglBindRenderbuffer(GLenum target, GLuint renderbuffer) {PRECALL;glBindRenderbuffer(target, renderbuffer);POSTCALL;}
1113 void wrapglBindTexture(GLenum target, GLuint texture) {PRECALL;glBindTexture(target, texture);POSTCALL;}
1114 void wrapglBlendEquation(GLenum e) {PRECALL;glBlendEquation(e);POSTCALL;}
1115 void wrapglBlendFunc(GLenum sfactor, GLenum dfactor) {PRECALL;glBlendFunc(sfactor, dfactor);POSTCALL;}
1116 void wrapglBufferData(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage) {PRECALL;glBufferData(target, size, data, usage);POSTCALL;}
1117 void wrapglBufferSubData(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data) {PRECALL;glBufferSubData(target, offset, size, data);POSTCALL;}
1118 void wrapglClear(GLbitfield mask) {PRECALL;glClear(mask);POSTCALL;}
1119 void wrapglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {PRECALL;glClearColor(red, green, blue, alpha);POSTCALL;}
1120 void wrapglClearDepth(GLclampd depth) {PRECALL;/*Con_Printf("glClearDepth(%f)\n", depth);glClearDepthf((float)depth);*/POSTCALL;}
1121 void wrapglClearStencil(GLint s) {PRECALL;glClearStencil(s);POSTCALL;}
1122 void wrapglClientActiveTexture(GLenum target) {PRECALL;Con_Printf("glClientActiveTexture(target)\n");POSTCALL;}
1123 void wrapglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {PRECALL;Con_Printf("glColor4f(red, green, blue, alpha)\n");POSTCALL;}
1124 void wrapglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {PRECALL;Con_Printf("glColor4ub(red, green, blue, alpha)\n");POSTCALL;}
1125 void wrapglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {PRECALL;glColorMask(red, green, blue, alpha);POSTCALL;}
1126 void wrapglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glColorPointer(size, type, stride, ptr)\n");POSTCALL;}
1127 void wrapglCompileShader(GLuint shaderObj) {PRECALL;glCompileShader(shaderObj);POSTCALL;}
1128 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;}
1129 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;}
1130 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;}
1131 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;}
1132 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;}
1133 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;}
1134 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;}
1135 void wrapglCullFace(GLenum mode) {PRECALL;glCullFace(mode);POSTCALL;}
1136 void wrapglDeleteBuffers(GLsizei n, const GLuint *buffers) {PRECALL;glDeleteBuffers(n, buffers);POSTCALL;}
1137 void wrapglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {PRECALL;glDeleteFramebuffers(n, framebuffers);POSTCALL;}
1138 void wrapglDeleteShader(GLuint obj) {PRECALL;glDeleteShader(obj);POSTCALL;}
1139 void wrapglDeleteProgram(GLuint obj) {PRECALL;glDeleteProgram(obj);POSTCALL;}
1140 //void wrapglDeleteQueries(GLsizei n, const GLuint *ids) {PRECALL;glDeleteQueries(n, ids);POSTCALL;}
1141 void wrapglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {PRECALL;glDeleteRenderbuffers(n, renderbuffers);POSTCALL;}
1142 void wrapglDeleteTextures(GLsizei n, const GLuint *textures) {PRECALL;glDeleteTextures(n, textures);POSTCALL;}
1143 void wrapglDepthFunc(GLenum func) {PRECALL;glDepthFunc(func);POSTCALL;}
1144 void wrapglDepthMask(GLboolean flag) {PRECALL;glDepthMask(flag);POSTCALL;}
1145 //void wrapglDepthRange(GLclampd near_val, GLclampd far_val) {PRECALL;glDepthRangef((float)near_val, (float)far_val);POSTCALL;}
1146 void wrapglDepthRangef(GLclampf near_val, GLclampf far_val) {PRECALL;glDepthRangef(near_val, far_val);POSTCALL;}
1147 void wrapglDetachShader(GLuint containerObj, GLuint attachedObj) {PRECALL;glDetachShader(containerObj, attachedObj);POSTCALL;}
1148 void wrapglDisable(GLenum cap) {PRECALL;glDisable(cap);POSTCALL;}
1149 void wrapglDisableClientState(GLenum cap) {PRECALL;Con_Printf("glDisableClientState(cap)\n");POSTCALL;}
1150 void wrapglDisableVertexAttribArray(GLuint index) {PRECALL;glDisableVertexAttribArray(index);POSTCALL;}
1151 void wrapglDrawArrays(GLenum mode, GLint first, GLsizei count) {PRECALL;glDrawArrays(mode, first, count);POSTCALL;}
1152 void wrapglDrawBuffer(GLenum mode) {PRECALL;Con_Printf("glDrawBuffer(mode)\n");POSTCALL;}
1153 void wrapglDrawBuffers(GLsizei n, const GLenum *bufs) {PRECALL;Con_Printf("glDrawBuffers(n, bufs)\n");POSTCALL;}
1154 void wrapglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawElements(mode, count, type, indices);POSTCALL;}
1155 //void wrapglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawRangeElements(mode, start, end, count, type, indices);POSTCALL;}
1156 //void wrapglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {PRECALL;glDrawRangeElements(mode, start, end, count, type, indices);POSTCALL;}
1157 void wrapglEnable(GLenum cap) {PRECALL;glEnable(cap);POSTCALL;}
1158 void wrapglEnableClientState(GLenum cap) {PRECALL;Con_Printf("glEnableClientState(cap)\n");POSTCALL;}
1159 void wrapglEnableVertexAttribArray(GLuint index) {PRECALL;glEnableVertexAttribArray(index);POSTCALL;}
1160 //void wrapglEnd(void) {PRECALL;Con_Printf("glEnd()\n");POSTCALL;}
1161 //void wrapglEndQuery(GLenum target) {PRECALL;glEndQuery(target);POSTCALL;}
1162 void wrapglFinish(void) {PRECALL;glFinish();POSTCALL;}
1163 void wrapglFlush(void) {PRECALL;glFlush();POSTCALL;}
1164 void wrapglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {PRECALL;glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);POSTCALL;}
1165 void wrapglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {PRECALL;glFramebufferTexture2D(target, attachment, textarget, texture, level);POSTCALL;}
1166 void wrapglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {PRECALL;Con_Printf("glFramebufferTexture3D()\n");POSTCALL;}
1167 void wrapglGenBuffers(GLsizei n, GLuint *buffers) {PRECALL;glGenBuffers(n, buffers);POSTCALL;}
1168 void wrapglGenFramebuffers(GLsizei n, GLuint *framebuffers) {PRECALL;glGenFramebuffers(n, framebuffers);POSTCALL;}
1169 //void wrapglGenQueries(GLsizei n, GLuint *ids) {PRECALL;glGenQueries(n, ids);POSTCALL;}
1170 void wrapglGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {PRECALL;glGenRenderbuffers(n, renderbuffers);POSTCALL;}
1171 void wrapglGenTextures(GLsizei n, GLuint *textures) {PRECALL;glGenTextures(n, textures);POSTCALL;}
1172 void wrapglGenerateMipmap(GLenum target) {PRECALL;glGenerateMipmap(target);POSTCALL;}
1173 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;}
1174 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;}
1175 void wrapglGetAttachedShaders(GLuint containerObj, GLsizei maxCount, GLsizei *count, GLuint *obj) {PRECALL;glGetAttachedShaders(containerObj, maxCount, count, obj);POSTCALL;}
1176 void wrapglGetBooleanv(GLenum pname, GLboolean *params) {PRECALL;glGetBooleanv(pname, params);POSTCALL;}
1177 void wrapglGetCompressedTexImage(GLenum target, GLint lod, void *img) {PRECALL;Con_Printf("glGetCompressedTexImage(target, lod, img)\n");POSTCALL;}
1178 void wrapglGetDoublev(GLenum pname, GLdouble *params) {PRECALL;Con_Printf("glGetDoublev(pname, params)\n");POSTCALL;}
1179 void wrapglGetFloatv(GLenum pname, GLfloat *params) {PRECALL;glGetFloatv(pname, params);POSTCALL;}
1180 void wrapglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) {PRECALL;glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);POSTCALL;}
1181 void wrapglGetShaderInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {PRECALL;glGetShaderInfoLog(obj, maxLength, length, infoLog);POSTCALL;}
1182 void wrapglGetProgramInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {PRECALL;glGetProgramInfoLog(obj, maxLength, length, infoLog);POSTCALL;}
1183 void wrapglGetIntegerv(GLenum pname, GLint *params) {PRECALL;glGetIntegerv(pname, params);POSTCALL;}
1184 void wrapglGetShaderiv(GLuint obj, GLenum pname, GLint *params) {PRECALL;glGetShaderiv(obj, pname, params);POSTCALL;}
1185 void wrapglGetProgramiv(GLuint obj, GLenum pname, GLint *params) {PRECALL;glGetProgramiv(obj, pname, params);POSTCALL;}
1186 //void wrapglGetQueryObjectiv(GLuint qid, GLenum pname, GLint *params) {PRECALL;glGetQueryObjectiv(qid, pname, params);POSTCALL;}
1187 //void wrapglGetQueryObjectuiv(GLuint qid, GLenum pname, GLuint *params) {PRECALL;glGetQueryObjectuiv(qid, pname, params);POSTCALL;}
1188 //void wrapglGetQueryiv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetQueryiv(target, pname, params);POSTCALL;}
1189 void wrapglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetRenderbufferParameteriv(target, pname, params);POSTCALL;}
1190 void wrapglGetShaderSource(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *source) {PRECALL;glGetShaderSource(obj, maxLength, length, source);POSTCALL;}
1191 void wrapglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {PRECALL;Con_Printf("glGetTexImage(target, level, format, type, pixels)\n");POSTCALL;}
1192 void wrapglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {PRECALL;Con_Printf("glGetTexLevelParameterfv(target, level, pname, params)\n");POSTCALL;}
1193 void wrapglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {PRECALL;Con_Printf("glGetTexLevelParameteriv(target, level, pname, params)\n");POSTCALL;}
1194 void wrapglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {PRECALL;glGetTexParameterfv(target, pname, params);POSTCALL;}
1195 void wrapglGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {PRECALL;glGetTexParameteriv(target, pname, params);POSTCALL;}
1196 void wrapglGetUniformfv(GLuint programObj, GLint location, GLfloat *params) {PRECALL;glGetUniformfv(programObj, location, params);POSTCALL;}
1197 void wrapglGetUniformiv(GLuint programObj, GLint location, GLint *params) {PRECALL;glGetUniformiv(programObj, location, params);POSTCALL;}
1198 void wrapglHint(GLenum target, GLenum mode) {PRECALL;glHint(target, mode);POSTCALL;}
1199 void wrapglLineWidth(GLfloat width) {PRECALL;glLineWidth(width);POSTCALL;}
1200 void wrapglLinkProgram(GLuint programObj) {PRECALL;glLinkProgram(programObj);POSTCALL;}
1201 void wrapglLoadIdentity(void) {PRECALL;Con_Printf("glLoadIdentity()\n");POSTCALL;}
1202 void wrapglLoadMatrixf(const GLfloat *m) {PRECALL;Con_Printf("glLoadMatrixf(m)\n");POSTCALL;}
1203 void wrapglMatrixMode(GLenum mode) {PRECALL;Con_Printf("glMatrixMode(mode)\n");POSTCALL;}
1204 void wrapglMultiTexCoord1f(GLenum target, GLfloat s) {PRECALL;Con_Printf("glMultiTexCoord1f(target, s)\n");POSTCALL;}
1205 void wrapglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {PRECALL;Con_Printf("glMultiTexCoord2f(target, s, t)\n");POSTCALL;}
1206 void wrapglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {PRECALL;Con_Printf("glMultiTexCoord3f(target, s, t, r)\n");POSTCALL;}
1207 void wrapglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {PRECALL;Con_Printf("glMultiTexCoord4f(target, s, t, r, q)\n");POSTCALL;}
1208 void wrapglNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glNormalPointer(type, stride, ptr)\n");POSTCALL;}
1209 void wrapglPixelStorei(GLenum pname, GLint param) {PRECALL;glPixelStorei(pname, param);POSTCALL;}
1210 void wrapglPointSize(GLfloat size) {PRECALL;Con_Printf("glPointSize(size)\n");POSTCALL;}
1211 //void wrapglPolygonMode(GLenum face, GLenum mode) {PRECALL;Con_Printf("glPolygonMode(face, mode)\n");POSTCALL;}
1212 void wrapglPolygonOffset(GLfloat factor, GLfloat units) {PRECALL;glPolygonOffset(factor, units);POSTCALL;}
1213 void wrapglPolygonStipple(const GLubyte *mask) {PRECALL;Con_Printf("glPolygonStipple(mask)\n");POSTCALL;}
1214 void wrapglReadBuffer(GLenum mode) {PRECALL;Con_Printf("glReadBuffer(mode)\n");POSTCALL;}
1215 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;}
1216 void wrapglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {PRECALL;glRenderbufferStorage(target, internalformat, width, height);POSTCALL;}
1217 void wrapglScissor(GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;glScissor(x, y, width, height);POSTCALL;}
1218 void wrapglShaderSource(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length) {PRECALL;glShaderSource(shaderObj, count, string, length);POSTCALL;}
1219 void wrapglStencilFunc(GLenum func, GLint ref, GLuint mask) {PRECALL;glStencilFunc(func, ref, mask);POSTCALL;}
1220 void wrapglStencilFuncSeparate(GLenum func1, GLenum func2, GLint ref, GLuint mask) {PRECALL;Con_Printf("glStencilFuncSeparate(func1, func2, ref, mask)\n");POSTCALL;}
1221 void wrapglStencilMask(GLuint mask) {PRECALL;glStencilMask(mask);POSTCALL;}
1222 void wrapglStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {PRECALL;glStencilOp(fail, zfail, zpass);POSTCALL;}
1223 void wrapglStencilOpSeparate(GLenum e1, GLenum e2, GLenum e3, GLenum e4) {PRECALL;Con_Printf("glStencilOpSeparate(e1, e2, e3, e4)\n");POSTCALL;}
1224 void wrapglTexCoord1f(GLfloat s) {PRECALL;Con_Printf("glTexCoord1f(s)\n");POSTCALL;}
1225 void wrapglTexCoord2f(GLfloat s, GLfloat t) {PRECALL;Con_Printf("glTexCoord2f(s, t)\n");POSTCALL;}
1226 void wrapglTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {PRECALL;Con_Printf("glTexCoord3f(s, t, r)\n");POSTCALL;}
1227 void wrapglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {PRECALL;Con_Printf("glTexCoord4f(s, t, r, q)\n");POSTCALL;}
1228 void wrapglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glTexCoordPointer(size, type, stride, ptr)\n");POSTCALL;}
1229 void wrapglTexEnvf(GLenum target, GLenum pname, GLfloat param) {PRECALL;Con_Printf("glTexEnvf(target, pname, param)\n");POSTCALL;}
1230 void wrapglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {PRECALL;Con_Printf("glTexEnvfv(target, pname, params)\n");POSTCALL;}
1231 void wrapglTexEnvi(GLenum target, GLenum pname, GLint param) {PRECALL;Con_Printf("glTexEnvi(target, pname, param)\n");POSTCALL;}
1232 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;}
1233 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;}
1234 void wrapglTexParameterf(GLenum target, GLenum pname, GLfloat param) {PRECALL;glTexParameterf(target, pname, param);POSTCALL;}
1235 void wrapglTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {PRECALL;glTexParameterfv(target, pname, params);POSTCALL;}
1236 void wrapglTexParameteri(GLenum target, GLenum pname, GLint param) {PRECALL;glTexParameteri(target, pname, param);POSTCALL;}
1237 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;}
1238 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;}
1239 void wrapglUniform1f(GLint location, GLfloat v0) {PRECALL;glUniform1f(location, v0);POSTCALL;}
1240 void wrapglUniform1fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform1fv(location, count, value);POSTCALL;}
1241 void wrapglUniform1i(GLint location, GLint v0) {PRECALL;glUniform1i(location, v0);POSTCALL;}
1242 void wrapglUniform1iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform1iv(location, count, value);POSTCALL;}
1243 void wrapglUniform2f(GLint location, GLfloat v0, GLfloat v1) {PRECALL;glUniform2f(location, v0, v1);POSTCALL;}
1244 void wrapglUniform2fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform2fv(location, count, value);POSTCALL;}
1245 void wrapglUniform2i(GLint location, GLint v0, GLint v1) {PRECALL;glUniform2i(location, v0, v1);POSTCALL;}
1246 void wrapglUniform2iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform2iv(location, count, value);POSTCALL;}
1247 void wrapglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {PRECALL;glUniform3f(location, v0, v1, v2);POSTCALL;}
1248 void wrapglUniform3fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform3fv(location, count, value);POSTCALL;}
1249 void wrapglUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {PRECALL;glUniform3i(location, v0, v1, v2);POSTCALL;}
1250 void wrapglUniform3iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform3iv(location, count, value);POSTCALL;}
1251 void wrapglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {PRECALL;glUniform4f(location, v0, v1, v2, v3);POSTCALL;}
1252 void wrapglUniform4fv(GLint location, GLsizei count, const GLfloat *value) {PRECALL;glUniform4fv(location, count, value);POSTCALL;}
1253 void wrapglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {PRECALL;glUniform4i(location, v0, v1, v2, v3);POSTCALL;}
1254 void wrapglUniform4iv(GLint location, GLsizei count, const GLint *value) {PRECALL;glUniform4iv(location, count, value);POSTCALL;}
1255 void wrapglUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix2fv(location, count, transpose, value);POSTCALL;}
1256 void wrapglUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix3fv(location, count, transpose, value);POSTCALL;}
1257 void wrapglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {PRECALL;glUniformMatrix4fv(location, count, transpose, value);POSTCALL;}
1258 void wrapglUseProgram(GLuint programObj) {PRECALL;glUseProgram(programObj);POSTCALL;}
1259 void wrapglValidateProgram(GLuint programObj) {PRECALL;glValidateProgram(programObj);POSTCALL;}
1260 void wrapglVertex2f(GLfloat x, GLfloat y) {PRECALL;Con_Printf("glVertex2f(x, y)\n");POSTCALL;}
1261 void wrapglVertex3f(GLfloat x, GLfloat y, GLfloat z) {PRECALL;Con_Printf("glVertex3f(x, y, z)\n");POSTCALL;}
1262 void wrapglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {PRECALL;Con_Printf("glVertex4f(x, y, z, w)\n");POSTCALL;}
1263 void wrapglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {PRECALL;glVertexAttribPointer(index, size, type, normalized, stride, pointer);POSTCALL;}
1264 void wrapglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {PRECALL;Con_Printf("glVertexPointer(size, type, stride, ptr)\n");POSTCALL;}
1265 void wrapglViewport(GLint x, GLint y, GLsizei width, GLsizei height) {PRECALL;glViewport(x, y, width, height);POSTCALL;}
1266 void wrapglVertexAttrib1f(GLuint index, GLfloat v0) {PRECALL;glVertexAttrib1f(index, v0);POSTCALL;}
1267 //void wrapglVertexAttrib1s(GLuint index, GLshort v0) {PRECALL;glVertexAttrib1s(index, v0);POSTCALL;}
1268 //void wrapglVertexAttrib1d(GLuint index, GLdouble v0) {PRECALL;glVertexAttrib1d(index, v0);POSTCALL;}
1269 void wrapglVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {PRECALL;glVertexAttrib2f(index, v0, v1);POSTCALL;}
1270 //void wrapglVertexAttrib2s(GLuint index, GLshort v0, GLshort v1) {PRECALL;glVertexAttrib2s(index, v0, v1);POSTCALL;}
1271 //void wrapglVertexAttrib2d(GLuint index, GLdouble v0, GLdouble v1) {PRECALL;glVertexAttrib2d(index, v0, v1);POSTCALL;}
1272 void wrapglVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {PRECALL;glVertexAttrib3f(index, v0, v1, v2);POSTCALL;}
1273 //void wrapglVertexAttrib3s(GLuint index, GLshort v0, GLshort v1, GLshort v2) {PRECALL;glVertexAttrib3s(index, v0, v1, v2);POSTCALL;}
1274 //void wrapglVertexAttrib3d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2) {PRECALL;glVertexAttrib3d(index, v0, v1, v2);POSTCALL;}
1275 void wrapglVertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {PRECALL;glVertexAttrib4f(index, v0, v1, v2, v3);POSTCALL;}
1276 //void wrapglVertexAttrib4s(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3) {PRECALL;glVertexAttrib4s(index, v0, v1, v2, v3);POSTCALL;}
1277 //void wrapglVertexAttrib4d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {PRECALL;glVertexAttrib4d(index, v0, v1, v2, v3);POSTCALL;}
1278 //void wrapglVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {PRECALL;glVertexAttrib4Nub(index, x, y, z, w);POSTCALL;}
1279 void wrapglVertexAttrib1fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib1fv(index, v);POSTCALL;}
1280 //void wrapglVertexAttrib1sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib1sv(index, v);POSTCALL;}
1281 //void wrapglVertexAttrib1dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib1dv(index, v);POSTCALL;}
1282 void wrapglVertexAttrib2fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib2fv(index, v);POSTCALL;}
1283 //void wrapglVertexAttrib2sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib2sv(index, v);POSTCALL;}
1284 //void wrapglVertexAttrib2dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib2dv(index, v);POSTCALL;}
1285 void wrapglVertexAttrib3fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib3fv(index, v);POSTCALL;}
1286 //void wrapglVertexAttrib3sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib3sv(index, v);POSTCALL;}
1287 //void wrapglVertexAttrib3dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib3dv(index, v);POSTCALL;}
1288 void wrapglVertexAttrib4fv(GLuint index, const GLfloat *v) {PRECALL;glVertexAttrib4fv(index, v);POSTCALL;}
1289 //void wrapglVertexAttrib4sv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib4sv(index, v);POSTCALL;}
1290 //void wrapglVertexAttrib4dv(GLuint index, const GLdouble *v) {PRECALL;glVertexAttrib4dv(index, v);POSTCALL;}
1291 //void wrapglVertexAttrib4iv(GLuint index, const GLint *v) {PRECALL;glVertexAttrib4iv(index, v);POSTCALL;}
1292 //void wrapglVertexAttrib4bv(GLuint index, const GLbyte *v) {PRECALL;glVertexAttrib4bv(index, v);POSTCALL;}
1293 //void wrapglVertexAttrib4ubv(GLuint index, const GLubyte *v) {PRECALL;glVertexAttrib4ubv(index, v);POSTCALL;}
1294 //void wrapglVertexAttrib4usv(GLuint index, const GLushort *v) {PRECALL;glVertexAttrib4usv(index, GLushort v);POSTCALL;}
1295 //void wrapglVertexAttrib4uiv(GLuint index, const GLuint *v) {PRECALL;glVertexAttrib4uiv(index, v);POSTCALL;}
1296 //void wrapglVertexAttrib4Nbv(GLuint index, const GLbyte *v) {PRECALL;glVertexAttrib4Nbv(index, v);POSTCALL;}
1297 //void wrapglVertexAttrib4Nsv(GLuint index, const GLshort *v) {PRECALL;glVertexAttrib4Nsv(index, v);POSTCALL;}
1298 //void wrapglVertexAttrib4Niv(GLuint index, const GLint *v) {PRECALL;glVertexAttrib4Niv(index, v);POSTCALL;}
1299 //void wrapglVertexAttrib4Nubv(GLuint index, const GLubyte *v) {PRECALL;glVertexAttrib4Nubv(index, v);POSTCALL;}
1300 //void wrapglVertexAttrib4Nusv(GLuint index, const GLushort *v) {PRECALL;glVertexAttrib4Nusv(index, GLushort v);POSTCALL;}
1301 //void wrapglVertexAttrib4Nuiv(GLuint index, const GLuint *v) {PRECALL;glVertexAttrib4Nuiv(index, v);POSTCALL;}
1302 //void wrapglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {PRECALL;glGetVertexAttribdv(index, pname, params);POSTCALL;}
1303 void wrapglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {PRECALL;glGetVertexAttribfv(index, pname, params);POSTCALL;}
1304 void wrapglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {PRECALL;glGetVertexAttribiv(index, pname, params);POSTCALL;}
1305 void wrapglGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) {PRECALL;glGetVertexAttribPointerv(index, pname, pointer);POSTCALL;}
1308 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
1309 #define SDL_GL_ExtensionSupported(x) (strstr(gl_extensions, x) || strstr(gl_platformextensions, x))
1312 void GLES_Init(void)
1315 qglIsBufferARB = wrapglIsBuffer;
1316 qglIsEnabled = wrapglIsEnabled;
1317 qglIsFramebufferEXT = wrapglIsFramebuffer;
1318 // qglIsQueryARB = wrapglIsQuery;
1319 qglIsRenderbufferEXT = wrapglIsRenderbuffer;
1320 // qglUnmapBufferARB = wrapglUnmapBuffer;
1321 qglCheckFramebufferStatusEXT = wrapglCheckFramebufferStatus;
1322 qglGetError = wrapglGetError;
1323 qglCreateProgram = wrapglCreateProgram;
1324 qglCreateShader = wrapglCreateShader;
1325 // qglGetHandleARB = wrapglGetHandle;
1326 qglGetAttribLocation = wrapglGetAttribLocation;
1327 qglGetUniformLocation = wrapglGetUniformLocation;
1328 // qglMapBufferARB = wrapglMapBuffer;
1329 qglGetString = wrapglGetString;
1330 // qglActiveStencilFaceEXT = wrapglActiveStencilFace;
1331 qglActiveTexture = wrapglActiveTexture;
1332 qglAlphaFunc = wrapglAlphaFunc;
1333 qglArrayElement = wrapglArrayElement;
1334 qglAttachShader = wrapglAttachShader;
1335 // qglBegin = wrapglBegin;
1336 // qglBeginQueryARB = wrapglBeginQuery;
1337 qglBindAttribLocation = wrapglBindAttribLocation;
1338 // qglBindFragDataLocation = wrapglBindFragDataLocation;
1339 qglBindBufferARB = wrapglBindBuffer;
1340 qglBindFramebufferEXT = wrapglBindFramebuffer;
1341 qglBindRenderbufferEXT = wrapglBindRenderbuffer;
1342 qglBindTexture = wrapglBindTexture;
1343 qglBlendEquationEXT = wrapglBlendEquation;
1344 qglBlendFunc = wrapglBlendFunc;
1345 qglBufferDataARB = wrapglBufferData;
1346 qglBufferSubDataARB = wrapglBufferSubData;
1347 qglClear = wrapglClear;
1348 qglClearColor = wrapglClearColor;
1349 qglClearDepth = wrapglClearDepth;
1350 qglClearStencil = wrapglClearStencil;
1351 qglClientActiveTexture = wrapglClientActiveTexture;
1352 qglColor4f = wrapglColor4f;
1353 qglColor4ub = wrapglColor4ub;
1354 qglColorMask = wrapglColorMask;
1355 qglColorPointer = wrapglColorPointer;
1356 qglCompileShader = wrapglCompileShader;
1357 qglCompressedTexImage2DARB = wrapglCompressedTexImage2D;
1358 qglCompressedTexImage3DARB = wrapglCompressedTexImage3D;
1359 qglCompressedTexSubImage2DARB = wrapglCompressedTexSubImage2D;
1360 qglCompressedTexSubImage3DARB = wrapglCompressedTexSubImage3D;
1361 qglCopyTexImage2D = wrapglCopyTexImage2D;
1362 qglCopyTexSubImage2D = wrapglCopyTexSubImage2D;
1363 qglCopyTexSubImage3D = wrapglCopyTexSubImage3D;
1364 qglCullFace = wrapglCullFace;
1365 qglDeleteBuffersARB = wrapglDeleteBuffers;
1366 qglDeleteFramebuffersEXT = wrapglDeleteFramebuffers;
1367 qglDeleteProgram = wrapglDeleteProgram;
1368 qglDeleteShader = wrapglDeleteShader;
1369 // qglDeleteQueriesARB = wrapglDeleteQueries;
1370 qglDeleteRenderbuffersEXT = wrapglDeleteRenderbuffers;
1371 qglDeleteTextures = wrapglDeleteTextures;
1372 qglDepthFunc = wrapglDepthFunc;
1373 qglDepthMask = wrapglDepthMask;
1374 qglDepthRangef = wrapglDepthRangef;
1375 qglDetachShader = wrapglDetachShader;
1376 qglDisable = wrapglDisable;
1377 qglDisableClientState = wrapglDisableClientState;
1378 qglDisableVertexAttribArray = wrapglDisableVertexAttribArray;
1379 qglDrawArrays = wrapglDrawArrays;
1380 // qglDrawBuffer = wrapglDrawBuffer;
1381 // qglDrawBuffersARB = wrapglDrawBuffers;
1382 qglDrawElements = wrapglDrawElements;
1383 // qglDrawRangeElements = wrapglDrawRangeElements;
1384 qglEnable = wrapglEnable;
1385 qglEnableClientState = wrapglEnableClientState;
1386 qglEnableVertexAttribArray = wrapglEnableVertexAttribArray;
1387 // qglEnd = wrapglEnd;
1388 // qglEndQueryARB = wrapglEndQuery;
1389 qglFinish = wrapglFinish;
1390 qglFlush = wrapglFlush;
1391 qglFramebufferRenderbufferEXT = wrapglFramebufferRenderbuffer;
1392 qglFramebufferTexture2DEXT = wrapglFramebufferTexture2D;
1393 qglFramebufferTexture3DEXT = wrapglFramebufferTexture3D;
1394 qglGenBuffersARB = wrapglGenBuffers;
1395 qglGenFramebuffersEXT = wrapglGenFramebuffers;
1396 // qglGenQueriesARB = wrapglGenQueries;
1397 qglGenRenderbuffersEXT = wrapglGenRenderbuffers;
1398 qglGenTextures = wrapglGenTextures;
1399 qglGenerateMipmapEXT = wrapglGenerateMipmap;
1400 qglGetActiveAttrib = wrapglGetActiveAttrib;
1401 qglGetActiveUniform = wrapglGetActiveUniform;
1402 qglGetAttachedShaders = wrapglGetAttachedShaders;
1403 qglGetBooleanv = wrapglGetBooleanv;
1404 // qglGetCompressedTexImageARB = wrapglGetCompressedTexImage;
1405 qglGetDoublev = wrapglGetDoublev;
1406 qglGetFloatv = wrapglGetFloatv;
1407 qglGetFramebufferAttachmentParameterivEXT = wrapglGetFramebufferAttachmentParameteriv;
1408 qglGetProgramInfoLog = wrapglGetProgramInfoLog;
1409 qglGetShaderInfoLog = wrapglGetShaderInfoLog;
1410 qglGetIntegerv = wrapglGetIntegerv;
1411 qglGetShaderiv = wrapglGetShaderiv;
1412 qglGetProgramiv = wrapglGetProgramiv;
1413 // qglGetQueryObjectivARB = wrapglGetQueryObjectiv;
1414 // qglGetQueryObjectuivARB = wrapglGetQueryObjectuiv;
1415 // qglGetQueryivARB = wrapglGetQueryiv;
1416 qglGetRenderbufferParameterivEXT = wrapglGetRenderbufferParameteriv;
1417 qglGetShaderSource = wrapglGetShaderSource;
1418 qglGetTexImage = wrapglGetTexImage;
1419 qglGetTexLevelParameterfv = wrapglGetTexLevelParameterfv;
1420 qglGetTexLevelParameteriv = wrapglGetTexLevelParameteriv;
1421 qglGetTexParameterfv = wrapglGetTexParameterfv;
1422 qglGetTexParameteriv = wrapglGetTexParameteriv;
1423 qglGetUniformfv = wrapglGetUniformfv;
1424 qglGetUniformiv = wrapglGetUniformiv;
1425 qglHint = wrapglHint;
1426 qglLineWidth = wrapglLineWidth;
1427 qglLinkProgram = wrapglLinkProgram;
1428 qglLoadIdentity = wrapglLoadIdentity;
1429 qglLoadMatrixf = wrapglLoadMatrixf;
1430 qglMatrixMode = wrapglMatrixMode;
1431 qglMultiTexCoord1f = wrapglMultiTexCoord1f;
1432 qglMultiTexCoord2f = wrapglMultiTexCoord2f;
1433 qglMultiTexCoord3f = wrapglMultiTexCoord3f;
1434 qglMultiTexCoord4f = wrapglMultiTexCoord4f;
1435 qglNormalPointer = wrapglNormalPointer;
1436 qglPixelStorei = wrapglPixelStorei;
1437 qglPointSize = wrapglPointSize;
1438 // qglPolygonMode = wrapglPolygonMode;
1439 qglPolygonOffset = wrapglPolygonOffset;
1440 // qglPolygonStipple = wrapglPolygonStipple;
1441 qglReadBuffer = wrapglReadBuffer;
1442 qglReadPixels = wrapglReadPixels;
1443 qglRenderbufferStorageEXT = wrapglRenderbufferStorage;
1444 qglScissor = wrapglScissor;
1445 qglShaderSource = wrapglShaderSource;
1446 qglStencilFunc = wrapglStencilFunc;
1447 qglStencilFuncSeparate = wrapglStencilFuncSeparate;
1448 qglStencilMask = wrapglStencilMask;
1449 qglStencilOp = wrapglStencilOp;
1450 qglStencilOpSeparate = wrapglStencilOpSeparate;
1451 qglTexCoord1f = wrapglTexCoord1f;
1452 qglTexCoord2f = wrapglTexCoord2f;
1453 qglTexCoord3f = wrapglTexCoord3f;
1454 qglTexCoord4f = wrapglTexCoord4f;
1455 qglTexCoordPointer = wrapglTexCoordPointer;
1456 qglTexEnvf = wrapglTexEnvf;
1457 qglTexEnvfv = wrapglTexEnvfv;
1458 qglTexEnvi = wrapglTexEnvi;
1459 qglTexImage2D = wrapglTexImage2D;
1460 qglTexImage3D = wrapglTexImage3D;
1461 qglTexParameterf = wrapglTexParameterf;
1462 qglTexParameterfv = wrapglTexParameterfv;
1463 qglTexParameteri = wrapglTexParameteri;
1464 qglTexSubImage2D = wrapglTexSubImage2D;
1465 qglTexSubImage3D = wrapglTexSubImage3D;
1466 qglUniform1f = wrapglUniform1f;
1467 qglUniform1fv = wrapglUniform1fv;
1468 qglUniform1i = wrapglUniform1i;
1469 qglUniform1iv = wrapglUniform1iv;
1470 qglUniform2f = wrapglUniform2f;
1471 qglUniform2fv = wrapglUniform2fv;
1472 qglUniform2i = wrapglUniform2i;
1473 qglUniform2iv = wrapglUniform2iv;
1474 qglUniform3f = wrapglUniform3f;
1475 qglUniform3fv = wrapglUniform3fv;
1476 qglUniform3i = wrapglUniform3i;
1477 qglUniform3iv = wrapglUniform3iv;
1478 qglUniform4f = wrapglUniform4f;
1479 qglUniform4fv = wrapglUniform4fv;
1480 qglUniform4i = wrapglUniform4i;
1481 qglUniform4iv = wrapglUniform4iv;
1482 qglUniformMatrix2fv = wrapglUniformMatrix2fv;
1483 qglUniformMatrix3fv = wrapglUniformMatrix3fv;
1484 qglUniformMatrix4fv = wrapglUniformMatrix4fv;
1485 qglUseProgram = wrapglUseProgram;
1486 qglValidateProgram = wrapglValidateProgram;
1487 qglVertex2f = wrapglVertex2f;
1488 qglVertex3f = wrapglVertex3f;
1489 qglVertex4f = wrapglVertex4f;
1490 qglVertexAttribPointer = wrapglVertexAttribPointer;
1491 qglVertexPointer = wrapglVertexPointer;
1492 qglViewport = wrapglViewport;
1493 qglVertexAttrib1f = wrapglVertexAttrib1f;
1494 // qglVertexAttrib1s = wrapglVertexAttrib1s;
1495 // qglVertexAttrib1d = wrapglVertexAttrib1d;
1496 qglVertexAttrib2f = wrapglVertexAttrib2f;
1497 // qglVertexAttrib2s = wrapglVertexAttrib2s;
1498 // qglVertexAttrib2d = wrapglVertexAttrib2d;
1499 qglVertexAttrib3f = wrapglVertexAttrib3f;
1500 // qglVertexAttrib3s = wrapglVertexAttrib3s;
1501 // qglVertexAttrib3d = wrapglVertexAttrib3d;
1502 qglVertexAttrib4f = wrapglVertexAttrib4f;
1503 // qglVertexAttrib4s = wrapglVertexAttrib4s;
1504 // qglVertexAttrib4d = wrapglVertexAttrib4d;
1505 // qglVertexAttrib4Nub = wrapglVertexAttrib4Nub;
1506 qglVertexAttrib1fv = wrapglVertexAttrib1fv;
1507 // qglVertexAttrib1sv = wrapglVertexAttrib1sv;
1508 // qglVertexAttrib1dv = wrapglVertexAttrib1dv;
1509 qglVertexAttrib2fv = wrapglVertexAttrib2fv;
1510 // qglVertexAttrib2sv = wrapglVertexAttrib2sv;
1511 // qglVertexAttrib2dv = wrapglVertexAttrib2dv;
1512 qglVertexAttrib3fv = wrapglVertexAttrib3fv;
1513 // qglVertexAttrib3sv = wrapglVertexAttrib3sv;
1514 // qglVertexAttrib3dv = wrapglVertexAttrib3dv;
1515 qglVertexAttrib4fv = wrapglVertexAttrib4fv;
1516 // qglVertexAttrib4sv = wrapglVertexAttrib4sv;
1517 // qglVertexAttrib4dv = wrapglVertexAttrib4dv;
1518 // qglVertexAttrib4iv = wrapglVertexAttrib4iv;
1519 // qglVertexAttrib4bv = wrapglVertexAttrib4bv;
1520 // qglVertexAttrib4ubv = wrapglVertexAttrib4ubv;
1521 // qglVertexAttrib4usv = wrapglVertexAttrib4usv;
1522 // qglVertexAttrib4uiv = wrapglVertexAttrib4uiv;
1523 // qglVertexAttrib4Nbv = wrapglVertexAttrib4Nbv;
1524 // qglVertexAttrib4Nsv = wrapglVertexAttrib4Nsv;
1525 // qglVertexAttrib4Niv = wrapglVertexAttrib4Niv;
1526 // qglVertexAttrib4Nubv = wrapglVertexAttrib4Nubv;
1527 // qglVertexAttrib4Nusv = wrapglVertexAttrib4Nusv;
1528 // qglVertexAttrib4Nuiv = wrapglVertexAttrib4Nuiv;
1529 // qglGetVertexAttribdv = wrapglGetVertexAttribdv;
1530 qglGetVertexAttribfv = wrapglGetVertexAttribfv;
1531 qglGetVertexAttribiv = wrapglGetVertexAttribiv;
1532 qglGetVertexAttribPointerv = wrapglGetVertexAttribPointerv;
1535 gl_renderer = (const char *)qglGetString(GL_RENDERER);
1536 gl_vendor = (const char *)qglGetString(GL_VENDOR);
1537 gl_version = (const char *)qglGetString(GL_VERSION);
1538 gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
1542 if (!gl_platformextensions)
1543 gl_platformextensions = "";
1545 Con_Printf("GL_VENDOR: %s\n", gl_vendor);
1546 Con_Printf("GL_RENDERER: %s\n", gl_renderer);
1547 Con_Printf("GL_VERSION: %s\n", gl_version);
1548 Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
1549 Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
1551 // LordHavoc: report supported extensions
1552 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
1554 // GLES devices in general do not like GL_BGRA, so use GL_RGBA
1555 vid.forcetextype = TEXTYPE_RGBA;
1557 vid.support.gl20shaders = true;
1558 vid.support.amd_texture_texture4 = false;
1559 vid.support.arb_depth_texture = false;
1560 vid.support.arb_draw_buffers = false;
1561 vid.support.arb_multitexture = false;
1562 vid.support.arb_occlusion_query = false;
1563 vid.support.arb_shadow = false;
1564 vid.support.arb_texture_compression = false; // different (vendor-specific) formats than on desktop OpenGL...
1565 vid.support.arb_texture_cube_map = true;
1566 vid.support.arb_texture_env_combine = false;
1567 vid.support.arb_texture_gather = false;
1568 vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
1569 vid.support.arb_vertex_buffer_object = true;
1570 vid.support.ati_separate_stencil = false;
1571 vid.support.ext_blend_minmax = false;
1572 vid.support.ext_blend_subtract = true;
1573 vid.support.ext_draw_range_elements = true;
1574 vid.support.ext_framebuffer_object = false;//true;
1576 // FIXME remove this workaround once FBO + npot texture mapping is fixed
1577 if(!vid.support.arb_texture_non_power_of_two)
1579 vid.support.arb_framebuffer_object = false;
1580 vid.support.ext_framebuffer_object = false;
1583 vid.support.ext_packed_depth_stencil = false;
1584 vid.support.ext_stencil_two_side = false;
1585 vid.support.ext_texture_3d = SDL_GL_ExtensionSupported("GL_OES_texture_3D");
1586 vid.support.ext_texture_compression_s3tc = SDL_GL_ExtensionSupported("GL_EXT_texture_compression_s3tc");
1587 vid.support.ext_texture_edge_clamp = true;
1588 vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
1589 vid.support.ext_texture_srgb = false;
1591 qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
1592 if (vid.support.ext_texture_filter_anisotropic)
1593 qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
1594 if (vid.support.arb_texture_cube_map)
1595 qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_cubemap);
1596 #ifdef GL_MAX_3D_TEXTURE_SIZE
1597 if (vid.support.ext_texture_3d)
1598 qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_3d);
1600 Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
1601 Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
1603 #define GL_ALPHA_BITS 0x0D55
1604 #define GL_RED_BITS 0x0D52
1605 #define GL_GREEN_BITS 0x0D53
1606 #define GL_BLUE_BITS 0x0D54
1607 #define GL_DEPTH_BITS 0x0D56
1608 #define GL_STENCIL_BITS 0x0D57
1609 int fb_r = -1, fb_g = -1, fb_b = -1, fb_a = -1, fb_d = -1, fb_s = -1;
1610 qglGetIntegerv(GL_RED_BITS , &fb_r);
1611 qglGetIntegerv(GL_GREEN_BITS , &fb_g);
1612 qglGetIntegerv(GL_BLUE_BITS , &fb_b);
1613 qglGetIntegerv(GL_ALPHA_BITS , &fb_a);
1614 qglGetIntegerv(GL_DEPTH_BITS , &fb_d);
1615 qglGetIntegerv(GL_STENCIL_BITS, &fb_s);
1616 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);
1619 // verify that cubemap textures are really supported
1620 if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
1621 vid.support.arb_texture_cube_map = false;
1623 // verify that 3d textures are really supported
1624 if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
1626 vid.support.ext_texture_3d = false;
1627 Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
1631 vid.teximageunits = 8;
1632 vid.texarrayunits = 5;
1633 vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
1634 vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
1635 vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
1636 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" : "");
1637 vid.renderpath = RENDERPATH_GLES2;
1638 vid.useinterleavedarrays = false;
1639 vid.sRGBcapable2D = false;
1640 vid.sRGBcapable3D = false;
1642 // VorteX: set other info (maybe place them in VID_InitMode?)
1643 extern cvar_t gl_info_vendor;
1644 extern cvar_t gl_info_renderer;
1645 extern cvar_t gl_info_version;
1646 extern cvar_t gl_info_platform;
1647 extern cvar_t gl_info_driver;
1648 Cvar_SetQuick(&gl_info_vendor, gl_vendor);
1649 Cvar_SetQuick(&gl_info_renderer, gl_renderer);
1650 Cvar_SetQuick(&gl_info_version, gl_version);
1651 Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
1652 Cvar_SetQuick(&gl_info_driver, gl_driver);
1656 void *GL_GetProcAddress(const char *name)
1659 p = SDL_GL_GetProcAddress(name);
1663 static qboolean vid_sdl_initjoysticksystem = false;
1665 void VID_Init (void)
1667 #ifndef __IPHONEOS__
1669 Cvar_RegisterVariable(&apple_mouse_noaccel);
1673 Cvar_SetValueQuick(&vid_touchscreen, 1);
1676 #ifdef SDL_R_RESTART
1677 R_RegisterModule("SDL", sdl_start, sdl_shutdown, sdl_newmap, NULL, NULL);
1680 if (SDL_Init(SDL_INIT_VIDEO) < 0)
1681 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
1682 vid_sdl_initjoysticksystem = SDL_InitSubSystem(SDL_INIT_JOYSTICK) >= 0;
1683 if (vid_sdl_initjoysticksystem)
1684 Con_Printf("Failed to init SDL joystick subsystem: %s\n", SDL_GetError());
1685 vid_isfullscreen = false;
1688 static int vid_sdljoystickindex = -1;
1689 void VID_EnableJoystick(qboolean enable)
1691 int index = joy_enable.integer > 0 ? joy_index.integer : -1;
1692 int numsdljoysticks;
1693 qboolean success = false;
1694 int sharedcount = 0;
1696 sharedcount = VID_Shared_SetJoystick(index);
1697 if (index >= 0 && index < sharedcount)
1699 sdlindex = index - sharedcount;
1701 numsdljoysticks = SDL_NumJoysticks();
1702 if (sdlindex < 0 || sdlindex >= numsdljoysticks)
1705 // update cvar containing count of XInput joysticks + SDL joysticks
1706 if (joy_detected.integer != sharedcount + numsdljoysticks)
1707 Cvar_SetValueQuick(&joy_detected, sharedcount + numsdljoysticks);
1709 if (vid_sdljoystickindex != sdlindex)
1711 vid_sdljoystickindex = sdlindex;
1712 // close SDL joystick if active
1713 if (vid_sdljoystick)
1714 SDL_JoystickClose(vid_sdljoystick);
1715 vid_sdljoystick = NULL;
1718 vid_sdljoystick = SDL_JoystickOpen(sdlindex);
1719 if (vid_sdljoystick)
1720 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));
1723 Con_Printf("Joystick %i failed (SDL_JoystickOpen(%i) returned: %s)\n", index, sdlindex, SDL_GetError());
1732 if (joy_active.integer != (success ? 1 : 0))
1733 Cvar_SetValueQuick(&joy_active, success ? 1 : 0);
1737 // set the icon (we dont use SDL here since it would be too much a PITA)
1739 #include "resource.h"
1740 #include <SDL_syswm.h>
1741 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
1743 SDL_Surface *screen = NULL;
1746 SDL_WM_SetCaption( gamename, NULL );
1747 screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
1750 // get the HWND handle
1751 SDL_VERSION( &info.version );
1752 if (SDL_GetWMInfo(&info))
1754 icon = LoadIcon( GetModuleHandle( NULL ), MAKEINTRESOURCE( IDI_ICON1 ) );
1755 #ifndef _W64 //If Windows 64bit data types don't exist
1756 #ifndef SetClassLongPtr
1757 #define SetClassLongPtr SetClassLong
1760 #define GCLP_HICON GCL_HICON
1763 #define LONG_PTR LONG
1766 SetClassLongPtr( info.window, GCLP_HICON, (LONG_PTR)icon );
1771 #elif defined(MACOSX)
1772 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
1774 SDL_Surface *screen = NULL;
1775 SDL_WM_SetCaption( gamename, NULL );
1776 screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
1777 // we don't use SDL_WM_SetIcon here because the icon in the .app should be used
1781 // Adding the OS independent XPM version --blub
1782 #include "darkplaces.xpm"
1783 #include "nexuiz.xpm"
1784 static SDL_Surface *icon = NULL;
1785 static SDL_Surface *VID_WrapSDL_SetVideoMode(int screenwidth, int screenheight, int screenbpp, int screenflags)
1788 * Somewhat restricted XPM reader. Only supports XPMs saved by GIMP 2.4 at
1789 * default settings with less than 91 colors and transparency.
1792 int width, height, colors, isize, i, j;
1794 static SDL_Color palette[256];
1795 unsigned short palenc[256]; // store color id by char
1797 char **idata, *data;
1798 const SDL_version *version;
1799 SDL_Surface *screen = NULL;
1802 SDL_FreeSurface(icon);
1804 version = SDL_Linked_Version();
1805 // only use non-XPM icon support in SDL v1.3 and higher
1806 // SDL v1.2 does not support "smooth" transparency, and thus is better
1808 if(version->major >= 2 || (version->major == 1 && version->minor >= 3))
1810 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1813 unsigned int red = 0x00FF0000;
1814 unsigned int green = 0x0000FF00;
1815 unsigned int blue = 0x000000FF;
1816 unsigned int alpha = 0xFF000000;
1817 width = image_width;
1818 height = image_height;
1820 // reallocate with malloc, as this is in tempmempool (do not want)
1822 data = (char *) malloc(width * height * 4);
1823 memcpy(data, xpm, width * height * 4);
1827 icon = SDL_CreateRGBSurface(SDL_SRCALPHA, width, height, 32, LittleLong(red), LittleLong(green), LittleLong(blue), LittleLong(alpha));
1830 icon->pixels = data;
1833 Con_Printf( "Failed to create surface for the window Icon!\n"
1834 "%s\n", SDL_GetError());
1840 // we only get here if non-XPM icon was missing, or SDL version is not
1841 // sufficient for transparent non-XPM icons
1844 xpm = (char *) FS_LoadFile("darkplaces-icon.xpm", tempmempool, false, NULL);
1847 idata = XPM_DecodeString(xpm);
1849 idata = ENGINE_ICON;
1855 if(sscanf(data, "%i %i %i %i", &width, &height, &colors, &isize) == 4)
1859 for(i = 0; i < colors; ++i)
1861 unsigned int r, g, b;
1864 if(sscanf(idata[i+1], "%c c #%02x%02x%02x", &idx, &r, &g, &b) != 4)
1867 if(sscanf(idata[i+1], "%c c Non%1[e]", &idx, foo) != 2) // I take the DailyWTF credit for this. --div0
1871 palette[i].r = 255; // color key
1874 thenone = i; // weeeee
1875 palenc[(unsigned char) idx] = i;
1880 palette[i].r = r - (r == 255 && g == 0 && b == 255); // change 255/0/255 pink to 254/0/255 for color key
1883 palenc[(unsigned char) idx] = i;
1889 // allocate the image data
1890 data = (char*) malloc(width*height);
1892 for(j = 0; j < height; ++j)
1894 for(i = 0; i < width; ++i)
1896 // casting to the safest possible datatypes ^^
1897 data[j * width + i] = palenc[((unsigned char*)idata[colors+j+1])[i]];
1903 // SDL_FreeSurface should free the data too
1904 // but for completeness' sake...
1905 if(icon->flags & SDL_PREALLOC)
1908 icon->pixels = NULL; // safety
1910 SDL_FreeSurface(icon);
1913 icon = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, width, height, 8, 0,0,0,0);// rmask, gmask, bmask, amask); no mask needed
1914 // 8 bit surfaces get an empty palette allocated according to the docs
1915 // so it's a palette image for sure :) no endian check necessary for the mask
1919 icon->pixels = data;
1920 SDL_SetPalette(icon, SDL_PHYSPAL|SDL_LOGPAL, palette, 0, colors);
1921 SDL_SetColorKey(icon, SDL_SRCCOLORKEY, thenone);
1925 Con_Printf( "Failed to create surface for the window Icon!\n"
1926 "%s\n", SDL_GetError());
1932 Con_Printf("This XPM's palette looks odd. Can't continue.\n");
1937 // NOTE: Only 1-char colornames are supported
1938 Con_Printf("This XPM's palette is either huge or idiotically unoptimized. It's key size is %i\n", isize);
1943 // NOTE: Only 1-char colornames are supported
1944 Con_Printf("Sorry, but this does not even look similar to an XPM.\n");
1949 SDL_WM_SetIcon(icon, NULL);
1951 SDL_WM_SetCaption( gamename, NULL );
1952 screen = SDL_SetVideoMode(screenwidth, screenheight, screenbpp, screenflags);
1954 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
1955 // LordHavoc: info.info.x11.lock_func and accompanying code do not seem to compile with SDL 1.3
1956 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
1958 version = SDL_Linked_Version();
1959 // only use non-XPM icon support in SDL v1.3 and higher
1960 // SDL v1.2 does not support "smooth" transparency, and thus is better
1962 if(screen && (!(version->major >= 2 || (version->major == 1 && version->minor >= 3))))
1964 // in this case, we did not set the good icon yet
1966 SDL_VERSION(&info.version);
1967 if(SDL_GetWMInfo(&info) == 1 && info.subsystem == SDL_SYSWM_X11)
1969 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1972 // use _NET_WM_ICON too
1973 static long netwm_icon[MAX_NETWM_ICON];
1980 if(pos + 2 * image_width * image_height < MAX_NETWM_ICON)
1982 netwm_icon[pos++] = image_width;
1983 netwm_icon[pos++] = image_height;
1984 for(i = 0; i < image_height; ++i)
1985 for(j = 0; j < image_width; ++j)
1986 netwm_icon[pos++] = BuffLittleLong((unsigned char *) &data[(i*image_width+j)*4]);
1990 Con_Printf("Skipping NETWM icon #%d because there is no space left\n", i);
1994 data = (char *) loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "darkplaces-icon%d", i), false, false, false, NULL);
1997 info.info.x11.lock_func();
1999 Atom net_wm_icon = XInternAtom(info.info.x11.display, "_NET_WM_ICON", false);
2000 XChangeProperty(info.info.x11.display, info.info.x11.wmwindow, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (const unsigned char *) netwm_icon, pos);
2002 info.info.x11.unlock_func();
2014 static void VID_OutputVersion(void)
2016 const SDL_version *version;
2017 version = SDL_Linked_Version();
2018 Con_Printf( "Linked against SDL version %d.%d.%d\n"
2019 "Using SDL library version %d.%d.%d\n",
2020 SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL,
2021 version->major, version->minor, version->patch );
2024 static qboolean VID_InitModeGL(viddef_mode_t *mode)
2028 static int notfirstvideomode = false;
2029 int flags = SDL_OPENGL;
2031 int windowflags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
2033 const char *drivername;
2035 win_half_width = mode->width>>1;
2036 win_half_height = mode->height>>1;
2038 if(vid_resizable.integer)
2040 flags |= SDL_RESIZABLE;
2042 windowflags |= SDL_WINDOW_RESIZABLE;
2045 VID_OutputVersion();
2050 We cant switch from one OpenGL video mode to another.
2051 Thus we first switch to some stupid 2D mode and then back to OpenGL.
2053 if (notfirstvideomode)
2054 SDL_SetVideoMode( 0, 0, 0, 0 );
2055 notfirstvideomode = true;
2059 // SDL usually knows best
2062 // 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
2063 i = COM_CheckParm("-gl_driver");
2064 if (i && i < com_argc - 1)
2065 drivername = com_argv[i + 1];
2066 if (SDL_GL_LoadLibrary(drivername) < 0)
2068 Con_Printf("Unable to load GL driver \"%s\": %s\n", drivername, SDL_GetError());
2074 // mobile platforms are always fullscreen, we'll get the resolution after opening the window
2075 mode->fullscreen = true;
2076 // hide the menu with SDL_WINDOW_BORDERLESS
2077 windowflags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
2080 if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
2083 Con_Print("Required OpenGL function glGetString not found\n");
2088 // Knghtbrd: should do platform-specific extension string function here
2090 vid_isfullscreen = false;
2091 if (mode->fullscreen) {
2093 flags |= SDL_FULLSCREEN;
2095 windowflags |= SDL_WINDOW_FULLSCREEN;
2097 vid_isfullscreen = true;
2099 //flags |= SDL_HWSURFACE;
2101 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
2102 if (mode->bitsperpixel >= 32)
2104 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 8);
2105 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 8);
2106 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 8);
2107 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8);
2108 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24);
2109 SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
2113 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
2114 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
2115 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
2116 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
2118 if (mode->stereobuffer)
2119 SDL_GL_SetAttribute (SDL_GL_STEREO, 1);
2120 if (mode->samples > 1)
2122 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
2123 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, mode->samples);
2126 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2127 if (vid_vsync.integer)
2128 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
2130 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 0);
2133 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 2);
2134 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 0);
2135 SDL_GL_SetAttribute (SDL_GL_RETAINED_BACKING, 1);
2139 video_bpp = mode->bitsperpixel;
2141 video_flags = flags;
2142 screen = VID_WrapSDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2145 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2149 mode->width = screen->w;
2150 mode->height = screen->h;
2152 window_flags = windowflags;
2153 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2156 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2160 SDL_GetWindowSize(window, &mode->width, &mode->height);
2161 context = SDL_GL_CreateContext(window);
2162 if (context == NULL)
2164 Con_Printf("Failed to initialize OpenGL context: %s\n", SDL_GetError());
2170 vid_softsurface = NULL;
2171 vid.softpixels = NULL;
2174 SDL_EnableUNICODE( SDL_ENABLE );
2175 // enable key repeat since everyone expects it
2176 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2178 #if !(SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2)
2179 SDL_GL_SetSwapInterval(vid_vsync.integer != 0);
2180 vid_usingvsync = (vid_vsync.integer != 0);
2183 gl_platform = "SDL";
2184 gl_platformextensions = "";
2193 vid_activewindow = false;
2194 vid_hasfocus = true;
2195 vid_usingmouse = false;
2196 vid_usinghidecursor = false;
2199 SDL_WM_GrabInput(SDL_GRAB_OFF);
2204 extern cvar_t gl_info_extensions;
2205 extern cvar_t gl_info_vendor;
2206 extern cvar_t gl_info_renderer;
2207 extern cvar_t gl_info_version;
2208 extern cvar_t gl_info_platform;
2209 extern cvar_t gl_info_driver;
2211 static qboolean VID_InitModeSoft(viddef_mode_t *mode)
2214 int flags = SDL_HWSURFACE;
2215 if(!COM_CheckParm("-noasyncblit")) flags |= SDL_ASYNCBLIT;
2217 int windowflags = SDL_WINDOW_SHOWN;
2220 win_half_width = mode->width>>1;
2221 win_half_height = mode->height>>1;
2223 if(vid_resizable.integer)
2225 flags |= SDL_RESIZABLE;
2227 windowflags |= SDL_WINDOW_RESIZABLE;
2230 VID_OutputVersion();
2232 vid_isfullscreen = false;
2233 if (mode->fullscreen) {
2235 flags |= SDL_FULLSCREEN;
2237 windowflags |= SDL_WINDOW_FULLSCREEN;
2239 vid_isfullscreen = true;
2242 video_bpp = mode->bitsperpixel;
2244 video_flags = flags;
2245 screen = VID_WrapSDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2248 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2252 mode->width = screen->w;
2253 mode->height = screen->h;
2255 window_flags = windowflags;
2256 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2259 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2263 SDL_GetWindowSize(window, &mode->width, &mode->height);
2266 // create a framebuffer using our specific color format, we let the SDL blit function convert it in VID_Finish
2267 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, mode->width, mode->height, 32, 0x00FF0000, 0x0000FF00, 0x00000000FF, 0xFF000000);
2268 if (vid_softsurface == NULL)
2270 Con_Printf("Failed to setup software rasterizer framebuffer %ix%ix32bpp: %s\n", mode->width, mode->height, SDL_GetError());
2274 SDL_SetAlpha(vid_softsurface, 0, 255);
2276 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
2277 vid.softdepthpixels = (unsigned int *)calloc(1, mode->width * mode->height * 4);
2278 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)
2280 Con_Printf("Failed to initialize software rasterizer\n");
2286 SDL_EnableUNICODE( SDL_ENABLE );
2287 // enable key repeat since everyone expects it
2288 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;
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();
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;
2342 SDL_DestroyWindow(window);
2346 SDL_QuitSubSystem(SDL_INIT_VIDEO);
2351 gl_platformextensions = "";
2354 int VID_SetGamma (unsigned short *ramps, int rampsize)
2356 return !SDL_SetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2359 int VID_GetGamma (unsigned short *ramps, int rampsize)
2361 return !SDL_GetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2364 void VID_Finish (void)
2369 //react on appstate changes
2370 appstate = SDL_GetAppState();
2372 vid_hidden = !(appstate & SDL_APPACTIVE);
2373 vid_hasfocus = (appstate & SDL_APPINPUTFOCUS) != 0;
2375 vid_activewindow = !vid_hidden && vid_hasfocus;
2377 VID_UpdateGamma(false, 256);
2381 switch(vid.renderpath)
2383 case RENDERPATH_GL11:
2384 case RENDERPATH_GL13:
2385 case RENDERPATH_GL20:
2386 case RENDERPATH_GLES1:
2387 case RENDERPATH_GLES2:
2389 if (r_speeds.integer == 2 || gl_finish.integer)
2391 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2394 qboolean vid_usevsync;
2395 vid_usevsync = (vid_vsync.integer && !cls.timedemo);
2396 if (vid_usingvsync != vid_usevsync)
2398 if (SDL_GL_SetSwapInterval(vid_usevsync != 0) >= 0)
2399 Con_DPrintf("Vsync %s\n", vid_usevsync ? "activated" : "deactivated");
2401 Con_DPrintf("ERROR: can't %s vsync\n", vid_usevsync ? "activate" : "deactivate");
2406 SDL_GL_SwapBuffers();
2408 SDL_GL_SwapWindow(window);
2411 case RENDERPATH_SOFT:
2412 DPSOFTRAST_Finish();
2414 // if (!r_test.integer)
2416 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2421 SDL_Surface *screen = SDL_GetWindowSurface(window);
2422 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2423 SDL_UpdateWindowSurface(window);
2427 case RENDERPATH_D3D9:
2428 case RENDERPATH_D3D10:
2429 case RENDERPATH_D3D11:
2430 if (r_speeds.integer == 2 || gl_finish.integer)
2437 size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
2440 SDL_Rect **vidmodes;
2441 int bpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
2444 for(vidmodes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE); vidmodes && vidmodes != (SDL_Rect**)(-1) && *vidmodes; ++vidmodes)
2448 modes[k].width = (*vidmodes)->w;
2449 modes[k].height = (*vidmodes)->h;
2451 modes[k].refreshrate = 60; // no support for refresh rate in SDL
2452 modes[k].pixelheight_num = 1;
2453 modes[k].pixelheight_denom = 1; // SDL does not provide this