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 cvar_t vid_soft = {CVAR_SAVE, "vid_soft", "0", "enables use of the DarkPlaces Software Rasterizer rather than OpenGL or Direct3D"};
70 cvar_t vid_soft_threads = {CVAR_SAVE, "vid_soft_threads", "2", "the number of threads the DarkPlaces Software Rasterizer should use"};
71 cvar_t vid_soft_interlace = {CVAR_SAVE, "vid_soft_interlace", "1", "whether the DarkPlaces Software Rasterizer should interlace the screen bands occupied by each thread"};
72 cvar_t joy_detected = {CVAR_READONLY, "joy_detected", "0", "number of joysticks detected by engine"};
73 cvar_t joy_enable = {CVAR_SAVE, "joy_enable", "0", "enables joystick support"};
74 cvar_t joy_index = {0, "joy_index", "0", "selects which joystick to use if you have multiple"};
75 cvar_t joy_axisforward = {0, "joy_axisforward", "1", "which joystick axis to query for forward/backward movement"};
76 cvar_t joy_axisside = {0, "joy_axisside", "0", "which joystick axis to query for right/left movement"};
77 cvar_t joy_axisup = {0, "joy_axisup", "-1", "which joystick axis to query for up/down movement"};
78 cvar_t joy_axispitch = {0, "joy_axispitch", "3", "which joystick axis to query for looking up/down"};
79 cvar_t joy_axisyaw = {0, "joy_axisyaw", "2", "which joystick axis to query for looking right/left"};
80 cvar_t joy_axisroll = {0, "joy_axisroll", "-1", "which joystick axis to query for tilting head right/left"};
81 cvar_t joy_deadzoneforward = {0, "joy_deadzoneforward", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
82 cvar_t joy_deadzoneside = {0, "joy_deadzoneside", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
83 cvar_t joy_deadzoneup = {0, "joy_deadzoneup", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
84 cvar_t joy_deadzonepitch = {0, "joy_deadzonepitch", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
85 cvar_t joy_deadzoneyaw = {0, "joy_deadzoneyaw", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
86 cvar_t joy_deadzoneroll = {0, "joy_deadzoneroll", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
87 cvar_t joy_sensitivityforward = {0, "joy_sensitivityforward", "-1", "movement multiplier"};
88 cvar_t joy_sensitivityside = {0, "joy_sensitivityside", "1", "movement multiplier"};
89 cvar_t joy_sensitivityup = {0, "joy_sensitivityup", "1", "movement multiplier"};
90 cvar_t joy_sensitivitypitch = {0, "joy_sensitivitypitch", "1", "movement multiplier"};
91 cvar_t joy_sensitivityyaw = {0, "joy_sensitivityyaw", "-1", "movement multiplier"};
92 cvar_t joy_sensitivityroll = {0, "joy_sensitivityroll", "1", "movement multiplier"};
93 cvar_t joy_axiskeyevents = {CVAR_SAVE, "joy_axiskeyevents", "0", "generate uparrow/leftarrow etc. keyevents for joystick axes, use if your joystick driver is not generating them"};
96 # define SETVIDEOMODE 0
98 # if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
99 # define SETVIDEOMODE 1
101 // 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...
102 # ifndef SETVIDEOMODE
103 # define SETVIDEOMODE 1
108 static qboolean vid_usingmouse = false;
109 static qboolean vid_usinghidecursor = false;
110 static qboolean vid_hasfocus = false;
111 static qboolean vid_isfullscreen;
112 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
114 static qboolean vid_usingvsync = false;
116 static int vid_numjoysticks = 0;
117 #define MAX_JOYSTICKS 8
118 static SDL_Joystick *vid_joysticks[MAX_JOYSTICKS];
120 static int win_half_width = 50;
121 static int win_half_height = 50;
122 static int video_bpp;
125 static SDL_Surface *screen;
126 static int video_flags;
128 static SDL_GLContext *context;
129 static SDL_Window *window;
130 static int window_flags;
132 static SDL_Surface *vid_softsurface;
134 // joystick axes state
135 #define MAX_JOYSTICK_AXES 16
142 static joy_axiscache_t joy_axescache[MAX_JOYSTICK_AXES];
144 /////////////////////////
147 //TODO: Add joystick support
148 //TODO: Add error checking
151 #define SDLK_PERCENT '%'
152 #define SDLK_PRINTSCREEN SDLK_PRINT
153 #define SDLK_SCROLLLOCK SDLK_SCROLLOCK
154 #define SDLK_NUMLOCKCLEAR SDLK_NUMLOCK
155 #define SDLK_KP_1 SDLK_KP1
156 #define SDLK_KP_2 SDLK_KP2
157 #define SDLK_KP_3 SDLK_KP3
158 #define SDLK_KP_4 SDLK_KP4
159 #define SDLK_KP_5 SDLK_KP5
160 #define SDLK_KP_6 SDLK_KP6
161 #define SDLK_KP_7 SDLK_KP7
162 #define SDLK_KP_8 SDLK_KP8
163 #define SDLK_KP_9 SDLK_KP9
164 #define SDLK_KP_0 SDLK_KP0
167 static int MapKey( unsigned int sdlkey )
172 // case SDLK_UNKNOWN: return K_UNKNOWN;
173 case SDLK_RETURN: return K_ENTER;
174 case SDLK_ESCAPE: return K_ESCAPE;
175 case SDLK_BACKSPACE: return K_BACKSPACE;
176 case SDLK_TAB: return K_TAB;
177 case SDLK_SPACE: return K_SPACE;
178 case SDLK_EXCLAIM: return '!';
179 case SDLK_QUOTEDBL: return '"';
180 case SDLK_HASH: return '#';
181 case SDLK_PERCENT: return '%';
182 case SDLK_DOLLAR: return '$';
183 case SDLK_AMPERSAND: return '&';
184 case SDLK_QUOTE: return '\'';
185 case SDLK_LEFTPAREN: return '(';
186 case SDLK_RIGHTPAREN: return ')';
187 case SDLK_ASTERISK: return '*';
188 case SDLK_PLUS: return '+';
189 case SDLK_COMMA: return ',';
190 case SDLK_MINUS: return '-';
191 case SDLK_PERIOD: return '.';
192 case SDLK_SLASH: return '/';
193 case SDLK_0: return '0';
194 case SDLK_1: return '1';
195 case SDLK_2: return '2';
196 case SDLK_3: return '3';
197 case SDLK_4: return '4';
198 case SDLK_5: return '5';
199 case SDLK_6: return '6';
200 case SDLK_7: return '7';
201 case SDLK_8: return '8';
202 case SDLK_9: return '9';
203 case SDLK_COLON: return ':';
204 case SDLK_SEMICOLON: return ';';
205 case SDLK_LESS: return '<';
206 case SDLK_EQUALS: return '=';
207 case SDLK_GREATER: return '>';
208 case SDLK_QUESTION: return '?';
209 case SDLK_AT: return '@';
210 case SDLK_LEFTBRACKET: return '[';
211 case SDLK_BACKSLASH: return '\\';
212 case SDLK_RIGHTBRACKET: return ']';
213 case SDLK_CARET: return '^';
214 case SDLK_UNDERSCORE: return '_';
215 case SDLK_BACKQUOTE: return '`';
216 case SDLK_a: return 'a';
217 case SDLK_b: return 'b';
218 case SDLK_c: return 'c';
219 case SDLK_d: return 'd';
220 case SDLK_e: return 'e';
221 case SDLK_f: return 'f';
222 case SDLK_g: return 'g';
223 case SDLK_h: return 'h';
224 case SDLK_i: return 'i';
225 case SDLK_j: return 'j';
226 case SDLK_k: return 'k';
227 case SDLK_l: return 'l';
228 case SDLK_m: return 'm';
229 case SDLK_n: return 'n';
230 case SDLK_o: return 'o';
231 case SDLK_p: return 'p';
232 case SDLK_q: return 'q';
233 case SDLK_r: return 'r';
234 case SDLK_s: return 's';
235 case SDLK_t: return 't';
236 case SDLK_u: return 'u';
237 case SDLK_v: return 'v';
238 case SDLK_w: return 'w';
239 case SDLK_x: return 'x';
240 case SDLK_y: return 'y';
241 case SDLK_z: return 'z';
242 case SDLK_CAPSLOCK: return K_CAPSLOCK;
243 case SDLK_F1: return K_F1;
244 case SDLK_F2: return K_F2;
245 case SDLK_F3: return K_F3;
246 case SDLK_F4: return K_F4;
247 case SDLK_F5: return K_F5;
248 case SDLK_F6: return K_F6;
249 case SDLK_F7: return K_F7;
250 case SDLK_F8: return K_F8;
251 case SDLK_F9: return K_F9;
252 case SDLK_F10: return K_F10;
253 case SDLK_F11: return K_F11;
254 case SDLK_F12: return K_F12;
255 case SDLK_PRINTSCREEN: return K_PRINTSCREEN;
256 case SDLK_SCROLLLOCK: return K_SCROLLOCK;
257 case SDLK_PAUSE: return K_PAUSE;
258 case SDLK_INSERT: return K_INS;
259 case SDLK_HOME: return K_HOME;
260 case SDLK_PAGEUP: return K_PGUP;
262 case SDLK_DELETE: return K_BACKSPACE;
264 case SDLK_DELETE: return K_DEL;
266 case SDLK_END: return K_END;
267 case SDLK_PAGEDOWN: return K_PGDN;
268 case SDLK_RIGHT: return K_RIGHTARROW;
269 case SDLK_LEFT: return K_LEFTARROW;
270 case SDLK_DOWN: return K_DOWNARROW;
271 case SDLK_UP: return K_UPARROW;
272 case SDLK_NUMLOCKCLEAR: return K_NUMLOCK;
273 case SDLK_KP_DIVIDE: return K_KP_DIVIDE;
274 case SDLK_KP_MULTIPLY: return K_KP_MULTIPLY;
275 case SDLK_KP_MINUS: return K_KP_MINUS;
276 case SDLK_KP_PLUS: return K_KP_PLUS;
277 case SDLK_KP_ENTER: return K_KP_ENTER;
278 case SDLK_KP_1: return K_KP_1;
279 case SDLK_KP_2: return K_KP_2;
280 case SDLK_KP_3: return K_KP_3;
281 case SDLK_KP_4: return K_KP_4;
282 case SDLK_KP_5: return K_KP_5;
283 case SDLK_KP_6: return K_KP_6;
284 case SDLK_KP_7: return K_KP_7;
285 case SDLK_KP_8: return K_KP_8;
286 case SDLK_KP_9: return K_KP_9;
287 case SDLK_KP_0: return K_KP_0;
288 case SDLK_KP_PERIOD: return K_KP_PERIOD;
289 // case SDLK_APPLICATION: return K_APPLICATION;
290 // case SDLK_POWER: return K_POWER;
291 case SDLK_KP_EQUALS: return K_KP_EQUALS;
292 // case SDLK_F13: return K_F13;
293 // case SDLK_F14: return K_F14;
294 // case SDLK_F15: return K_F15;
295 // case SDLK_F16: return K_F16;
296 // case SDLK_F17: return K_F17;
297 // case SDLK_F18: return K_F18;
298 // case SDLK_F19: return K_F19;
299 // case SDLK_F20: return K_F20;
300 // case SDLK_F21: return K_F21;
301 // case SDLK_F22: return K_F22;
302 // case SDLK_F23: return K_F23;
303 // case SDLK_F24: return K_F24;
304 // case SDLK_EXECUTE: return K_EXECUTE;
305 // case SDLK_HELP: return K_HELP;
306 // case SDLK_MENU: return K_MENU;
307 // case SDLK_SELECT: return K_SELECT;
308 // case SDLK_STOP: return K_STOP;
309 // case SDLK_AGAIN: return K_AGAIN;
310 // case SDLK_UNDO: return K_UNDO;
311 // case SDLK_CUT: return K_CUT;
312 // case SDLK_COPY: return K_COPY;
313 // case SDLK_PASTE: return K_PASTE;
314 // case SDLK_FIND: return K_FIND;
315 // case SDLK_MUTE: return K_MUTE;
316 // case SDLK_VOLUMEUP: return K_VOLUMEUP;
317 // case SDLK_VOLUMEDOWN: return K_VOLUMEDOWN;
318 // case SDLK_KP_COMMA: return K_KP_COMMA;
319 // case SDLK_KP_EQUALSAS400: return K_KP_EQUALSAS400;
320 // case SDLK_ALTERASE: return K_ALTERASE;
321 // case SDLK_SYSREQ: return K_SYSREQ;
322 // case SDLK_CANCEL: return K_CANCEL;
323 // case SDLK_CLEAR: return K_CLEAR;
324 // case SDLK_PRIOR: return K_PRIOR;
325 // case SDLK_RETURN2: return K_RETURN2;
326 // case SDLK_SEPARATOR: return K_SEPARATOR;
327 // case SDLK_OUT: return K_OUT;
328 // case SDLK_OPER: return K_OPER;
329 // case SDLK_CLEARAGAIN: return K_CLEARAGAIN;
330 // case SDLK_CRSEL: return K_CRSEL;
331 // case SDLK_EXSEL: return K_EXSEL;
332 // case SDLK_KP_00: return K_KP_00;
333 // case SDLK_KP_000: return K_KP_000;
334 // case SDLK_THOUSANDSSEPARATOR: return K_THOUSANDSSEPARATOR;
335 // case SDLK_DECIMALSEPARATOR: return K_DECIMALSEPARATOR;
336 // case SDLK_CURRENCYUNIT: return K_CURRENCYUNIT;
337 // case SDLK_CURRENCYSUBUNIT: return K_CURRENCYSUBUNIT;
338 // case SDLK_KP_LEFTPAREN: return K_KP_LEFTPAREN;
339 // case SDLK_KP_RIGHTPAREN: return K_KP_RIGHTPAREN;
340 // case SDLK_KP_LEFTBRACE: return K_KP_LEFTBRACE;
341 // case SDLK_KP_RIGHTBRACE: return K_KP_RIGHTBRACE;
342 // case SDLK_KP_TAB: return K_KP_TAB;
343 // case SDLK_KP_BACKSPACE: return K_KP_BACKSPACE;
344 // case SDLK_KP_A: return K_KP_A;
345 // case SDLK_KP_B: return K_KP_B;
346 // case SDLK_KP_C: return K_KP_C;
347 // case SDLK_KP_D: return K_KP_D;
348 // case SDLK_KP_E: return K_KP_E;
349 // case SDLK_KP_F: return K_KP_F;
350 // case SDLK_KP_XOR: return K_KP_XOR;
351 // case SDLK_KP_POWER: return K_KP_POWER;
352 // case SDLK_KP_PERCENT: return K_KP_PERCENT;
353 // case SDLK_KP_LESS: return K_KP_LESS;
354 // case SDLK_KP_GREATER: return K_KP_GREATER;
355 // case SDLK_KP_AMPERSAND: return K_KP_AMPERSAND;
356 // case SDLK_KP_DBLAMPERSAND: return K_KP_DBLAMPERSAND;
357 // case SDLK_KP_VERTICALBAR: return K_KP_VERTICALBAR;
358 // case SDLK_KP_DBLVERTICALBAR: return K_KP_DBLVERTICALBAR;
359 // case SDLK_KP_COLON: return K_KP_COLON;
360 // case SDLK_KP_HASH: return K_KP_HASH;
361 // case SDLK_KP_SPACE: return K_KP_SPACE;
362 // case SDLK_KP_AT: return K_KP_AT;
363 // case SDLK_KP_EXCLAM: return K_KP_EXCLAM;
364 // case SDLK_KP_MEMSTORE: return K_KP_MEMSTORE;
365 // case SDLK_KP_MEMRECALL: return K_KP_MEMRECALL;
366 // case SDLK_KP_MEMCLEAR: return K_KP_MEMCLEAR;
367 // case SDLK_KP_MEMADD: return K_KP_MEMADD;
368 // case SDLK_KP_MEMSUBTRACT: return K_KP_MEMSUBTRACT;
369 // case SDLK_KP_MEMMULTIPLY: return K_KP_MEMMULTIPLY;
370 // case SDLK_KP_MEMDIVIDE: return K_KP_MEMDIVIDE;
371 // case SDLK_KP_PLUSMINUS: return K_KP_PLUSMINUS;
372 // case SDLK_KP_CLEAR: return K_KP_CLEAR;
373 // case SDLK_KP_CLEARENTRY: return K_KP_CLEARENTRY;
374 // case SDLK_KP_BINARY: return K_KP_BINARY;
375 // case SDLK_KP_OCTAL: return K_KP_OCTAL;
376 // case SDLK_KP_DECIMAL: return K_KP_DECIMAL;
377 // case SDLK_KP_HEXADECIMAL: return K_KP_HEXADECIMAL;
378 case SDLK_LCTRL: return K_CTRL;
379 case SDLK_LSHIFT: return K_SHIFT;
380 case SDLK_LALT: return K_ALT;
381 // case SDLK_LGUI: return K_LGUI;
382 case SDLK_RCTRL: return K_CTRL;
383 case SDLK_RSHIFT: return K_SHIFT;
384 case SDLK_RALT: return K_ALT;
385 // case SDLK_RGUI: return K_RGUI;
386 // case SDLK_MODE: return K_MODE;
387 // case SDLK_AUDIONEXT: return K_AUDIONEXT;
388 // case SDLK_AUDIOPREV: return K_AUDIOPREV;
389 // case SDLK_AUDIOSTOP: return K_AUDIOSTOP;
390 // case SDLK_AUDIOPLAY: return K_AUDIOPLAY;
391 // case SDLK_AUDIOMUTE: return K_AUDIOMUTE;
392 // case SDLK_MEDIASELECT: return K_MEDIASELECT;
393 // case SDLK_WWW: return K_WWW;
394 // case SDLK_MAIL: return K_MAIL;
395 // case SDLK_CALCULATOR: return K_CALCULATOR;
396 // case SDLK_COMPUTER: return K_COMPUTER;
397 // case SDLK_AC_SEARCH: return K_AC_SEARCH;
398 // case SDLK_AC_HOME: return K_AC_HOME;
399 // case SDLK_AC_BACK: return K_AC_BACK;
400 // case SDLK_AC_FORWARD: return K_AC_FORWARD;
401 // case SDLK_AC_STOP: return K_AC_STOP;
402 // case SDLK_AC_REFRESH: return K_AC_REFRESH;
403 // case SDLK_AC_BOOKMARKS: return K_AC_BOOKMARKS;
404 // case SDLK_BRIGHTNESSDOWN: return K_BRIGHTNESSDOWN;
405 // case SDLK_BRIGHTNESSUP: return K_BRIGHTNESSUP;
406 // case SDLK_DISPLAYSWITCH: return K_DISPLAYSWITCH;
407 // case SDLK_KBDILLUMTOGGLE: return K_KBDILLUMTOGGLE;
408 // case SDLK_KBDILLUMDOWN: return K_KBDILLUMDOWN;
409 // case SDLK_KBDILLUMUP: return K_KBDILLUMUP;
410 // case SDLK_EJECT: return K_EJECT;
411 // case SDLK_SLEEP: return K_SLEEP;
416 int SDL_iPhoneKeyboardShow(SDL_Window * window); // reveals the onscreen keyboard. Returns 0 on success and -1 on error.
417 int SDL_iPhoneKeyboardHide(SDL_Window * window); // hides the onscreen keyboard. Returns 0 on success and -1 on error.
418 SDL_bool SDL_iPhoneKeyboardIsShown(SDL_Window * window); // returns whether or not the onscreen keyboard is currently visible.
419 int SDL_iPhoneKeyboardToggle(SDL_Window * window); // toggles the visibility of the onscreen keyboard. Returns 0 on success and -1 on error.
422 void VID_ShowKeyboard(qboolean show)
427 if (!SDL_iPhoneKeyboardIsShown(window))
428 SDL_iPhoneKeyboardShow(window);
432 if (SDL_iPhoneKeyboardIsShown(window))
433 SDL_iPhoneKeyboardHide(window);
439 qboolean VID_ShowingKeyboard(void)
441 return SDL_iPhoneKeyboardIsShown(window);
445 void VID_SetMouse(qboolean fullscreengrab, qboolean relative, qboolean hidecursor)
450 if(vid_usingmouse && (vid_usingnoaccel != !!apple_mouse_noaccel.integer))
451 VID_SetMouse(false, false, false); // ungrab first!
453 if (vid_usingmouse != relative)
455 vid_usingmouse = relative;
456 cl_ignoremousemoves = 2;
458 SDL_WM_GrabInput( relative ? SDL_GRAB_ON : SDL_GRAB_OFF );
460 SDL_SetRelativeMouseMode(relative ? SDL_TRUE : SDL_FALSE);
465 // Save the status of mouse acceleration
466 originalMouseSpeed = -1.0; // in case of error
467 if(apple_mouse_noaccel.integer)
469 io_connect_t mouseDev = IN_GetIOHandle();
472 if(IOHIDGetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), &originalMouseSpeed) == kIOReturnSuccess)
474 Con_DPrintf("previous mouse acceleration: %f\n", originalMouseSpeed);
475 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), -1.0) != kIOReturnSuccess)
477 Con_Print("Could not disable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
478 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
483 Con_Print("Could not disable mouse acceleration (failed at IOHIDGetAccelerationWithKey).\n");
484 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
486 IOServiceClose(mouseDev);
490 Con_Print("Could not disable mouse acceleration (failed at IO_GetIOHandle).\n");
491 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
495 vid_usingnoaccel = !!apple_mouse_noaccel.integer;
499 if(originalMouseSpeed != -1.0)
501 io_connect_t mouseDev = IN_GetIOHandle();
504 Con_DPrintf("restoring mouse acceleration to: %f\n", originalMouseSpeed);
505 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), originalMouseSpeed) != kIOReturnSuccess)
506 Con_Print("Could not re-enable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
507 IOServiceClose(mouseDev);
510 Con_Print("Could not re-enable mouse acceleration (failed at IO_GetIOHandle).\n");
515 if (vid_usinghidecursor != hidecursor)
517 vid_usinghidecursor = hidecursor;
518 SDL_ShowCursor( hidecursor ? SDL_DISABLE : SDL_ENABLE);
523 static double IN_JoystickGetAxis(SDL_Joystick *joy, int axis, double sensitivity, double deadzone)
526 if (axis < 0 || axis >= SDL_JoystickNumAxes(joy))
527 return 0; // no such axis on this joystick
528 value = SDL_JoystickGetAxis(joy, axis) * (1.0 / 32767.0);
529 value = bound(-1, value, 1);
530 if (fabs(value) < deadzone)
531 return 0; // within deadzone around center
532 return value * sensitivity;
535 /////////////////////
536 // Joystick axis keyevents
537 // a sort of hack emulating Arrow keys for joystick axises
538 // as some drives dont send such keyevents for them
539 // additionally we should block drivers that do send arrow keyevents to prevent double events
542 static void IN_JoystickKeyeventForAxis(SDL_Joystick *joy, int axis, int key_pos, int key_neg)
546 if (axis < 0 || axis >= SDL_JoystickNumAxes(joy))
547 return; // no such axis on this joystick
549 joytime = Sys_DoubleTime();
550 // no key event, continuous keydown event
551 if (joy_axescache[axis].move == joy_axescache[axis].oldmove)
553 if (joy_axescache[axis].move != 0 && joytime > joy_axescache[axis].keytime)
555 //Con_Printf("joy %s %i %f\n", Key_KeynumToString((joy_axescache[axis].move > 0) ? key_pos : key_neg), 1, cl.time);
556 Key_Event((joy_axescache[axis].move > 0) ? key_pos : key_neg, 0, 1);
557 joy_axescache[axis].keytime = joytime + 0.5 / 20;
561 // generate key up event
562 if (joy_axescache[axis].oldmove)
564 //Con_Printf("joy %s %i %f\n", Key_KeynumToString((joy_axescache[axis].oldmove > 0) ? key_pos : key_neg), 1, cl.time);
565 Key_Event((joy_axescache[axis].oldmove > 0) ? key_pos : key_neg, 0, 0);
567 // generate key down event
568 if (joy_axescache[axis].move)
570 //Con_Printf("joy %s %i %f\n", Key_KeynumToString((joy_axescache[axis].move > 0) ? key_pos : key_neg), 1, cl.time);
571 Key_Event((joy_axescache[axis].move > 0) ? key_pos : key_neg, 0, 1);
572 joy_axescache[axis].keytime = joytime + 0.5;
576 static qboolean IN_JoystickBlockDoubledKeyEvents(int keycode)
578 if (!joy_axiskeyevents.integer)
581 // block keyevent if it's going to be provided by joystick keyevent system
582 if (vid_numjoysticks && joy_enable.integer && joy_index.integer >= 0 && joy_index.integer < vid_numjoysticks)
584 SDL_Joystick *joy = vid_joysticks[joy_index.integer];
586 if (keycode == K_UPARROW || keycode == K_DOWNARROW)
587 if (IN_JoystickGetAxis(joy, joy_axisforward.integer, 1, 0.01) || joy_axescache[joy_axisforward.integer].move || joy_axescache[joy_axisforward.integer].oldmove)
589 if (keycode == K_RIGHTARROW || keycode == K_LEFTARROW)
590 if (IN_JoystickGetAxis(joy, joy_axisside.integer, 1, 0.01) || joy_axescache[joy_axisside.integer].move || joy_axescache[joy_axisside.integer].oldmove)
597 // multitouch[10][] represents the mouse pointer
598 // X and Y coordinates are 0-32767 as per SDL spec
599 #define MAXFINGERS 11
600 int multitouch[MAXFINGERS][3];
602 qboolean VID_TouchscreenArea(int corner, float px, float py, float pwidth, float pheight, const char *icon, float *resultmove, qboolean *resultbutton, keynum_t key)
605 float fx, fy, fwidth, fheight;
607 qboolean button = false;
609 if (pwidth > 0 && pheight > 0)
611 if (!VID_ShowingKeyboard())
614 if (corner & 1) px += vid_conwidth.value;
615 if (corner & 2) py += vid_conheight.value;
616 if (corner & 4) px += vid_conwidth.value * 0.5f;
617 if (corner & 8) py += vid_conheight.value * 0.5f;
618 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);}
619 fx = px * 32768.0f / vid_conwidth.value;
620 fy = py * 32768.0f / vid_conheight.value;
621 fwidth = pwidth * 32768.0f / vid_conwidth.value;
622 fheight = pheight * 32768.0f / vid_conheight.value;
623 for (finger = 0;finger < MAXFINGERS;finger++)
625 if (multitouch[finger][0] && multitouch[finger][1] >= fx && multitouch[finger][2] >= fy && multitouch[finger][1] < fx + fwidth && multitouch[finger][2] < fy + fheight)
627 rel[0] = (multitouch[finger][1] - (fx + 0.5f * fwidth)) * (2.0f / fwidth);
628 rel[1] = (multitouch[finger][2] - (fy + 0.5f * fheight)) * (2.0f / fheight);
634 if (scr_numtouchscreenareas < 16)
636 scr_touchscreenareas[scr_numtouchscreenareas].pic = icon;
637 scr_touchscreenareas[scr_numtouchscreenareas].rect[0] = px;
638 scr_touchscreenareas[scr_numtouchscreenareas].rect[1] = py;
639 scr_touchscreenareas[scr_numtouchscreenareas].rect[2] = pwidth;
640 scr_touchscreenareas[scr_numtouchscreenareas].rect[3] = pheight;
641 scr_touchscreenareas[scr_numtouchscreenareas].active = button;
642 scr_numtouchscreenareas++;
648 VectorCopy(rel, resultmove);
650 VectorClear(resultmove);
654 if (*resultbutton != button && (int)key > 0)
655 Key_Event(key, 0, button);
656 *resultbutton = button;
661 /////////////////////
668 static int old_x = 0, old_y = 0;
669 static int stuck = 0;
670 int x, y, numaxes, numballs;
672 scr_numtouchscreenareas = 0;
673 if (vid_touchscreen.integer)
675 vec3_t move, aim, click;
676 static qboolean buttons[16];
677 static keydest_t oldkeydest;
678 keydest_t keydest = (key_consoleactive & KEY_CONSOLEACTIVE_USER) ? key_console : key_dest;
679 multitouch[MAXFINGERS-1][0] = SDL_GetMouseState(&x, &y);
680 multitouch[MAXFINGERS-1][1] = x * 32768 / vid.width;
681 multitouch[MAXFINGERS-1][2] = y * 32768 / vid.height;
682 if (oldkeydest != keydest)
686 case key_game: VID_ShowKeyboard(false);break;
687 case key_console: VID_ShowKeyboard(true);break;
688 case key_message: VID_ShowKeyboard(true);break;
692 oldkeydest = keydest;
693 // top of screen is toggleconsole and K_ESCAPE
698 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
699 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
700 if (!VID_ShowingKeyboard())
702 // user entered a command, close the console now
703 Con_ToggleConsole_f();
706 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
707 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
708 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
709 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
710 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
711 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
715 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
716 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
718 VID_TouchscreenArea( 2, 0,-128, 128, 128, "gfx/touch_movebutton.tga" , move, &buttons[0], K_MOUSE4);
719 VID_TouchscreenArea( 3,-128,-128, 128, 128, "gfx/touch_aimbutton.tga" , aim, &buttons[1], K_MOUSE5);
720 VID_TouchscreenArea( 2, 0,-160, 64, 32, "gfx/touch_jumpbutton.tga" , NULL, &buttons[3], K_SPACE);
721 VID_TouchscreenArea( 3,-128,-160, 64, 32, "gfx/touch_attackbutton.tga" , NULL, &buttons[2], K_MOUSE1);
722 VID_TouchscreenArea( 3, -64,-160, 64, 32, "gfx/touch_attack2button.tga", NULL, &buttons[4], K_MOUSE2);
727 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
728 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
729 // in menus, an icon in the corner activates keyboard
730 VID_TouchscreenArea( 2, 0, -32, 32, 32, "gfx/touch_keyboard.tga" , NULL, &buttons[15], (keynum_t)0);
732 VID_ShowKeyboard(true);
733 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
734 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
735 VID_TouchscreenArea(16, -320,-480,640, 960, NULL , click,&buttons[2], K_MOUSE1);
736 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
737 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
740 in_windowmouse_x = x;
741 in_windowmouse_y = y;
744 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
745 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
746 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
747 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
748 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
749 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
753 cl.cmd.forwardmove -= move[1] * cl_forwardspeed.value;
754 cl.cmd.sidemove += move[0] * cl_sidespeed.value;
755 cl.viewangles[0] += aim[1] * cl_pitchspeed.value * cl.realframetime;
756 cl.viewangles[1] -= aim[0] * cl_yawspeed.value * cl.realframetime;
762 if (vid_stick_mouse.integer)
764 // have the mouse stuck in the middle, example use: prevent expose effect of beryl during the game when not using
765 // window grabbing. --blub
767 // we need 2 frames to initialize the center position
771 SDL_WarpMouse(win_half_width, win_half_height);
773 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
775 SDL_GetMouseState(&x, &y);
776 SDL_GetRelativeMouseState(&x, &y);
779 SDL_GetRelativeMouseState(&x, &y);
780 in_mouse_x = x + old_x;
781 in_mouse_y = y + old_y;
782 SDL_GetMouseState(&x, &y);
783 old_x = x - win_half_width;
784 old_y = y - win_half_height;
786 SDL_WarpMouse(win_half_width, win_half_height);
788 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
792 SDL_GetRelativeMouseState( &x, &y );
798 SDL_GetMouseState(&x, &y);
799 in_windowmouse_x = x;
800 in_windowmouse_y = y;
803 if (vid_numjoysticks && joy_enable.integer && joy_index.integer >= 0 && joy_index.integer < vid_numjoysticks)
805 SDL_Joystick *joy = vid_joysticks[joy_index.integer];
807 // balls convert to mousemove
808 numballs = SDL_JoystickNumBalls(joy);
809 for (j = 0;j < numballs;j++)
811 SDL_JoystickGetBall(joy, j, &x, &y);
817 cl.cmd.forwardmove += IN_JoystickGetAxis(joy, joy_axisforward.integer, joy_sensitivityforward.value, joy_deadzoneforward.value) * cl_forwardspeed.value;
818 cl.cmd.sidemove += IN_JoystickGetAxis(joy, joy_axisside.integer, joy_sensitivityside.value, joy_deadzoneside.value) * cl_sidespeed.value;
819 cl.cmd.upmove += IN_JoystickGetAxis(joy, joy_axisup.integer, joy_sensitivityup.value, joy_deadzoneup.value) * cl_upspeed.value;
820 cl.viewangles[0] += IN_JoystickGetAxis(joy, joy_axispitch.integer, joy_sensitivitypitch.value, joy_deadzonepitch.value) * cl.realframetime * cl_pitchspeed.value;
821 cl.viewangles[1] += IN_JoystickGetAxis(joy, joy_axisyaw.integer, joy_sensitivityyaw.value, joy_deadzoneyaw.value) * cl.realframetime * cl_yawspeed.value;
822 //cl.viewangles[2] += IN_JoystickGetAxis(joy, joy_axisroll.integer, joy_sensitivityroll.value, joy_deadzoneroll.value) * cl.realframetime * cl_rollspeed.value;
824 // cache state of axes to emulate button events for them
825 numaxes = min(MAX_JOYSTICK_AXES, SDL_JoystickNumAxes(joy));
826 for (j = 0; j < numaxes; j++)
828 joy_axescache[j].oldmove = joy_axescache[j].move;
829 joy_axescache[j].move = IN_JoystickGetAxis(joy, j, 1, 0.01);
833 if (joy_axiskeyevents.integer)
835 IN_JoystickKeyeventForAxis(joy, joy_axisforward.integer, K_DOWNARROW, K_UPARROW);
836 IN_JoystickKeyeventForAxis(joy, joy_axisside.integer, K_RIGHTARROW, K_LEFTARROW);
841 /////////////////////
846 static qboolean sdl_needs_restart;
847 static void sdl_start(void)
850 static void sdl_shutdown(void)
852 sdl_needs_restart = false;
854 static void sdl_newmap(void)
860 static keynum_t buttonremap[18] =
885 void Sys_SendKeyEvents( void )
887 static qboolean sound_active = true;
891 while( SDL_PollEvent( &event ) )
892 switch( event.type ) {
898 keycode = MapKey(event.key.keysym.sym);
899 if (!IN_JoystickBlockDoubledKeyEvents(keycode))
900 Key_Event(keycode, event.key.keysym.unicode, (event.key.state == SDL_PRESSED));
902 case SDL_ACTIVEEVENT:
903 if( event.active.state & SDL_APPACTIVE )
905 if( event.active.gain )
911 case SDL_MOUSEBUTTONDOWN:
912 case SDL_MOUSEBUTTONUP:
913 if (!vid_touchscreen.integer)
914 if (event.button.button <= 18)
915 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
917 case SDL_JOYBUTTONDOWN:
918 if (!joy_enable.integer)
919 break; // ignore down events if joystick has been disabled
920 case SDL_JOYBUTTONUP:
921 if (event.jbutton.button < 48)
922 Key_Event( event.jbutton.button + (event.jbutton.button < 16 ? K_JOY1 : K_AUX1 - 16), 0, (event.jbutton.state == SDL_PRESSED) );
924 case SDL_VIDEORESIZE:
925 if(vid_resizable.integer < 2)
927 vid.width = event.resize.w;
928 vid.height = event.resize.h;
929 screen = SDL_SetVideoMode(vid.width, vid.height, video_bpp, video_flags);
932 SDL_FreeSurface(vid_softsurface);
933 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
934 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
935 SDL_SetAlpha(vid_softsurface, 0, 255);
936 if (vid.softdepthpixels)
937 free(vid.softdepthpixels);
938 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
941 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
942 // so, let's better queue it for next frame
943 if(!sdl_needs_restart)
945 Cbuf_AddText("\nr_restart\n");
946 sdl_needs_restart = true;
951 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
953 case SDL_TEXTEDITING:
954 // unused when SETVIDEOMODE API is used
957 // this occurs with SETVIDEOMODE but we are not using it
960 case SDL_MOUSEMOTION:
963 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
967 // enable/disable sound on focus gain/loss
968 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
981 sound_active = false;
989 void Sys_SendKeyEvents( void )
991 static qboolean sound_active = true;
992 static qboolean missingunicodehack = true;
999 while( SDL_PollEvent( &event ) )
1000 switch( event.type ) {
1006 keycode = MapKey(event.key.keysym.sym);
1007 if (!IN_JoystickBlockDoubledKeyEvents(keycode))
1009 // the virtual keyboard seems to produce no unicode values...
1010 if (missingunicodehack && keycode >= ' ' && keycode < 0x7F && event.key.keysym.unicode == 0)
1012 Con_DPrintf("SDL hack: no unicode value reported, substituting ascii value %i\n", keycode);
1013 Key_Event(keycode, keycode, (event.key.state == SDL_PRESSED));
1017 Key_Event(keycode, 0, (event.key.state == SDL_PRESSED));
1019 case SDL_MOUSEBUTTONDOWN:
1020 case SDL_MOUSEBUTTONUP:
1021 #ifndef __IPHONEOS__
1022 if (!vid_touchscreen.integer)
1023 if (event.button.button <= 18)
1024 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
1027 case SDL_JOYBUTTONDOWN:
1028 if (!joy_enable.integer)
1029 break; // ignore down events if joystick has been disabled
1030 case SDL_JOYBUTTONUP:
1031 if (event.jbutton.button < 48)
1032 Key_Event( event.jbutton.button + (event.jbutton.button < 16 ? K_JOY1 : K_AUX1 - 16), 0, (event.jbutton.state == SDL_PRESSED) );
1034 case SDL_WINDOWEVENT:
1035 //if (event.window.windowID == window) // how to compare?
1037 switch(event.window.event)
1039 case SDL_WINDOWEVENT_SHOWN:
1042 case SDL_WINDOWEVENT_HIDDEN:
1045 case SDL_WINDOWEVENT_EXPOSED:
1047 case SDL_WINDOWEVENT_MOVED:
1049 case SDL_WINDOWEVENT_RESIZED:
1050 if(vid_resizable.integer < 2)
1052 vid.width = event.window.data1;
1053 vid.height = event.window.data2;
1054 if (vid_softsurface)
1056 SDL_FreeSurface(vid_softsurface);
1057 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
1058 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
1059 SDL_SetAlpha(vid_softsurface, 0, 255);
1060 if (vid.softdepthpixels)
1061 free(vid.softdepthpixels);
1062 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
1064 #ifdef SDL_R_RESTART
1065 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
1066 // so, let's better queue it for next frame
1067 if(!sdl_needs_restart)
1069 Cbuf_AddText("\nr_restart\n");
1070 sdl_needs_restart = true;
1075 case SDL_WINDOWEVENT_MINIMIZED:
1077 case SDL_WINDOWEVENT_MAXIMIZED:
1079 case SDL_WINDOWEVENT_RESTORED:
1081 case SDL_WINDOWEVENT_ENTER:
1083 case SDL_WINDOWEVENT_LEAVE:
1085 case SDL_WINDOWEVENT_FOCUS_GAINED:
1086 vid_hasfocus = true;
1088 case SDL_WINDOWEVENT_FOCUS_LOST:
1089 vid_hasfocus = false;
1091 case SDL_WINDOWEVENT_CLOSE:
1097 case SDL_TEXTEDITING:
1098 // FIXME! this is where composition gets supported
1101 // we have some characters to parse
1102 missingunicodehack = false;
1105 for (i = 0;event.text.text[i];)
1107 unicode = event.text.text[i++];
1111 // strip high bits (we could count these to validate character length but we don't)
1112 for (j = 0x80;unicode & j;j >>= 1)
1114 for (;(event.text.text[i] & 0xC0) == 0x80;i++)
1115 unicode = (unicode << 6) | (event.text.text[i] & 0x3F);
1116 // low characters are invalid and could be bad, so replace them
1118 unicode = '?'; // we could use 0xFFFD instead, the unicode substitute character
1120 //Con_DPrintf("SDL_TEXTINPUT: K_TEXT %i \n", unicode);
1121 Key_Event(K_TEXT, unicode, true);
1122 Key_Event(K_TEXT, unicode, false);
1126 case SDL_MOUSEMOTION:
1128 case SDL_FINGERDOWN:
1129 Con_DPrintf("SDL_FINGERDOWN for finger %i\n", (int)event.tfinger.fingerId);
1130 for (i = 0;i < MAXFINGERS-1;i++)
1132 if (!multitouch[i][0])
1134 multitouch[i][0] = event.tfinger.fingerId;
1135 multitouch[i][1] = event.tfinger.x;
1136 multitouch[i][2] = event.tfinger.y;
1137 // TODO: use event.tfinger.pressure?
1141 if (i == MAXFINGERS-1)
1142 Con_DPrintf("Too many fingers at once!\n");
1145 Con_DPrintf("SDL_FINGERUP for finger %i\n", (int)event.tfinger.fingerId);
1146 for (i = 0;i < MAXFINGERS-1;i++)
1148 if (multitouch[i][0] == event.tfinger.fingerId)
1150 multitouch[i][0] = 0;
1154 if (i == MAXFINGERS-1)
1155 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1157 case SDL_FINGERMOTION:
1158 Con_DPrintf("SDL_FINGERMOTION for finger %i\n", (int)event.tfinger.fingerId);
1159 for (i = 0;i < MAXFINGERS-1;i++)
1161 if (multitouch[i][0] == event.tfinger.fingerId)
1163 multitouch[i][1] = event.tfinger.x;
1164 multitouch[i][2] = event.tfinger.y;
1168 if (i == MAXFINGERS-1)
1169 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1171 case SDL_TOUCHBUTTONDOWN:
1172 // not sure what to do with this...
1174 case SDL_TOUCHBUTTONUP:
1175 // not sure what to do with this...
1177 case SDL_JOYAXISMOTION:
1178 // we poll the joystick instead
1180 case SDL_JOYBALLMOTION:
1181 // we poll the joystick instead
1183 case SDL_JOYHATMOTION:
1184 // we poll the joystick instead
1187 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
1191 // enable/disable sound on focus gain/loss
1192 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
1197 sound_active = true;
1205 sound_active = false;
1216 //#include <SDL_opengles.h>
1217 #include <OpenGLES/ES2/gl.h>
1219 GLboolean wrapglIsBuffer(GLuint buffer) {return glIsBuffer(buffer);}
1220 GLboolean wrapglIsEnabled(GLenum cap) {return glIsEnabled(cap);}
1221 GLboolean wrapglIsFramebuffer(GLuint framebuffer) {return glIsFramebuffer(framebuffer);}
1222 //GLboolean wrapglIsQuery(GLuint qid) {return glIsQuery(qid);}
1223 GLboolean wrapglIsRenderbuffer(GLuint renderbuffer) {return glIsRenderbuffer(renderbuffer);}
1224 //GLboolean wrapglUnmapBuffer(GLenum target) {return glUnmapBuffer(target);}
1225 GLenum wrapglCheckFramebufferStatus(GLenum target) {return glCheckFramebufferStatus(target);}
1226 GLenum wrapglGetError(void) {return glGetError();}
1227 GLuint wrapglCreateProgram(void) {return glCreateProgram();}
1228 GLuint wrapglCreateShader(GLenum shaderType) {return glCreateShader(shaderType);}
1229 //GLuint wrapglGetHandle(GLenum pname) {return glGetHandle(pname);}
1230 GLint wrapglGetAttribLocation(GLuint programObj, const GLchar *name) {return glGetAttribLocation(programObj, name);}
1231 GLint wrapglGetUniformLocation(GLuint programObj, const GLchar *name) {return glGetUniformLocation(programObj, name);}
1232 //GLvoid* wrapglMapBuffer(GLenum target, GLenum access) {return glMapBuffer(target, access);}
1233 const GLubyte* wrapglGetString(GLenum name) {return glGetString(name);}
1234 void wrapglActiveStencilFace(GLenum e) {Con_Printf("glActiveStencilFace(e)\n");}
1235 void wrapglActiveTexture(GLenum e) {glActiveTexture(e);}
1236 void wrapglAlphaFunc(GLenum func, GLclampf ref) {Con_Printf("glAlphaFunc(func, ref)\n");}
1237 void wrapglArrayElement(GLint i) {Con_Printf("glArrayElement(i)\n");}
1238 void wrapglAttachShader(GLuint containerObj, GLuint obj) {glAttachShader(containerObj, obj);}
1239 void wrapglBegin(GLenum mode) {Con_Printf("glBegin(mode)\n");}
1240 //void wrapglBeginQuery(GLenum target, GLuint qid) {glBeginQuery(target, qid);}
1241 void wrapglBindAttribLocation(GLuint programObj, GLuint index, const GLchar *name) {glBindAttribLocation(programObj, index, name);}
1242 void wrapglBindFragDataLocation(GLuint programObj, GLuint index, const GLchar *name) {glBindFragDataLocation(programObj, index, name);}
1243 void wrapglBindBuffer(GLenum target, GLuint buffer) {glBindBuffer(target, buffer);}
1244 void wrapglBindFramebuffer(GLenum target, GLuint framebuffer) {glBindFramebuffer(target, framebuffer);}
1245 void wrapglBindRenderbuffer(GLenum target, GLuint renderbuffer) {glBindRenderbuffer(target, renderbuffer);}
1246 void wrapglBindTexture(GLenum target, GLuint texture) {glBindTexture(target, texture);}
1247 void wrapglBlendEquation(GLenum e) {glBlendEquation(e);}
1248 void wrapglBlendFunc(GLenum sfactor, GLenum dfactor) {glBlendFunc(sfactor, dfactor);}
1249 void wrapglBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) {glBufferData(target, size, data, usage);}
1250 void wrapglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) {glBufferSubData(target, offset, size, data);}
1251 void wrapglClear(GLbitfield mask) {glClear(mask);}
1252 void wrapglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {glClearColor(red, green, blue, alpha);}
1253 void wrapglClearDepth(GLclampd depth) {glClearDepthf((float)depth);}
1254 void wrapglClearStencil(GLint s) {glClearStencil(s);}
1255 void wrapglClientActiveTexture(GLenum target) {Con_Printf("glClientActiveTexture(target)\n");}
1256 void wrapglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {Con_Printf("glColor4f(red, green, blue, alpha)\n");}
1257 void wrapglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {Con_Printf("glColor4ub(red, green, blue, alpha)\n");}
1258 void wrapglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {glColorMask(red, green, blue, alpha);}
1259 void wrapglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glColorPointer(size, type, stride, ptr)\n");}
1260 void wrapglCompileShader(GLuint shaderObj) {glCompileShader(shaderObj);}
1261 void wrapglCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) {glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);}
1262 void wrapglCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) {Con_Printf("glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data)\n");}
1263 void wrapglCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) {glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);}
1264 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) {Con_Printf("glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)\n");}
1265 void wrapglCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);}
1266 void wrapglCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);}
1267 void wrapglCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {Con_Printf("glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)\n");}
1268 void wrapglCullFace(GLenum mode) {glCullFace(mode);}
1269 void wrapglDeleteBuffers(GLsizei n, const GLuint *buffers) {glDeleteBuffers(n, buffers);}
1270 void wrapglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {glDeleteFramebuffers(n, framebuffers);}
1271 void wrapglDeleteShader(GLuint obj) {glDeleteShader(obj);}
1272 void wrapglDeleteProgram(GLuint obj) {glDeleteProgram(obj);}
1273 //void wrapglDeleteQueries(GLsizei n, const GLuint *ids) {glDeleteQueries(n, ids);}
1274 void wrapglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {glDeleteRenderbuffers(n, renderbuffers);}
1275 void wrapglDeleteTextures(GLsizei n, const GLuint *textures) {glDeleteTextures(n, textures);}
1276 void wrapglDepthFunc(GLenum func) {glDepthFunc(func);}
1277 void wrapglDepthMask(GLboolean flag) {glDepthMask(flag);}
1278 void wrapglDepthRange(GLclampd near_val, GLclampd far_val) {glDepthRangef((float)near_val, (float)far_val);}
1279 void wrapglDetachShader(GLuint containerObj, GLuint attachedObj) {glDetachShader(containerObj, attachedObj);}
1280 void wrapglDisable(GLenum cap) {glDisable(cap);}
1281 void wrapglDisableClientState(GLenum cap) {Con_Printf("glDisableClientState(cap)\n");}
1282 void wrapglDisableVertexAttribArray(GLuint index) {glDisableVertexAttribArray(index);}
1283 void wrapglDrawArrays(GLenum mode, GLint first, GLsizei count) {glDrawArrays(mode, first, count);}
1284 void wrapglDrawBuffer(GLenum mode) {Con_Printf("glDrawBuffer(mode)\n");}
1285 void wrapglDrawBuffers(GLsizei n, const GLenum *bufs) {Con_Printf("glDrawBuffers(n, bufs)\n");}
1286 void wrapglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {glDrawElements(mode, count, type, indices);}
1287 //void wrapglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {glDrawRangeElements(mode, start, end, count, type, indices);}
1288 //void wrapglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {glDrawRangeElements(mode, start, end, count, type, indices);}
1289 void wrapglEnable(GLenum cap) {glEnable(cap);}
1290 void wrapglEnableClientState(GLenum cap) {Con_Printf("glEnableClientState(cap)\n");}
1291 void wrapglEnableVertexAttribArray(GLuint index) {glEnableVertexAttribArray(index);}
1292 void wrapglEnd(void) {Con_Printf("glEnd()\n");}
1293 //void wrapglEndQuery(GLenum target) {glEndQuery(target);}
1294 void wrapglFinish(void) {glFinish();}
1295 void wrapglFlush(void) {glFlush();}
1296 void wrapglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);}
1297 void wrapglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {glFramebufferTexture2D(target, attachment, textarget, texture, level);}
1298 void wrapglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {Con_Printf("glFramebufferTexture3D()\n");}
1299 void wrapglGenBuffers(GLsizei n, GLuint *buffers) {glGenBuffers(n, buffers);}
1300 void wrapglGenFramebuffers(GLsizei n, GLuint *framebuffers) {glGenFramebuffers(n, framebuffers);}
1301 //void wrapglGenQueries(GLsizei n, GLuint *ids) {glGenQueries(n, ids);}
1302 void wrapglGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {glGenRenderbuffers(n, renderbuffers);}
1303 void wrapglGenTextures(GLsizei n, GLuint *textures) {glGenTextures(n, textures);}
1304 void wrapglGenerateMipmap(GLenum target) {glGenerateMipmap(target);}
1305 void wrapglGetActiveAttrib(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {glGetActiveAttrib(programObj, index, maxLength, length, size, type, name);}
1306 void wrapglGetActiveUniform(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {glGetActiveUniform(programObj, index, maxLength, length, size, type, name);}
1307 void wrapglGetAttachedShaders(GLuint containerObj, GLsizei maxCount, GLsizei *count, GLuint *obj) {glGetAttachedShaders(containerObj, maxCount, count, obj);}
1308 void wrapglGetBooleanv(GLenum pname, GLboolean *params) {glGetBooleanv(pname, params);}
1309 void wrapglGetCompressedTexImage(GLenum target, GLint lod, void *img) {Con_Printf("glGetCompressedTexImage(target, lod, img)\n");}
1310 void wrapglGetDoublev(GLenum pname, GLdouble *params) {Con_Printf("glGetDoublev(pname, params)\n");}
1311 void wrapglGetFloatv(GLenum pname, GLfloat *params) {glGetFloatv(pname, params);}
1312 void wrapglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) {glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);}
1313 void wrapglGetShaderInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {glGetShaderInfoLog(obj, maxLength, length, infoLog);}
1314 void wrapglGetProgramInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {glGetProgramInfoLog(obj, maxLength, length, infoLog);}
1315 void wrapglGetIntegerv(GLenum pname, GLint *params) {glGetIntegerv(pname, params);}
1316 void wrapglGetShaderiv(GLuint obj, GLenum pname, GLint *params) {glGetShaderiv(obj, pname, params);}
1317 void wrapglGetProgramiv(GLuint obj, GLenum pname, GLint *params) {glGetProgramiv(obj, pname, params);}
1318 //void wrapglGetQueryObjectiv(GLuint qid, GLenum pname, GLint *params) {glGetQueryObjectiv(qid, pname, params);}
1319 //void wrapglGetQueryObjectuiv(GLuint qid, GLenum pname, GLuint *params) {glGetQueryObjectuiv(qid, pname, params);}
1320 //void wrapglGetQueryiv(GLenum target, GLenum pname, GLint *params) {glGetQueryiv(target, pname, params);}
1321 void wrapglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) {glGetRenderbufferParameteriv(target, pname, params);}
1322 void wrapglGetShaderSource(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *source) {glGetShaderSource(obj, maxLength, length, source);}
1323 void wrapglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {Con_Printf("glGetTexImage(target, level, format, type, pixels)\n");}
1324 void wrapglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {Con_Printf("glGetTexLevelParameterfv(target, level, pname, params)\n");}
1325 void wrapglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {Con_Printf("glGetTexLevelParameteriv(target, level, pname, params)\n");}
1326 void wrapglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {glGetTexParameterfv(target, pname, params);}
1327 void wrapglGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {glGetTexParameteriv(target, pname, params);}
1328 void wrapglGetUniformfv(GLuint programObj, GLint location, GLfloat *params) {glGetUniformfv(programObj, location, params);}
1329 void wrapglGetUniformiv(GLuint programObj, GLint location, GLint *params) {glGetUniformiv(programObj, location, params);}
1330 void wrapglHint(GLenum target, GLenum mode) {glHint(target, mode);}
1331 void wrapglLineWidth(GLfloat width) {glLineWidth(width);}
1332 void wrapglLinkProgram(GLuint programObj) {glLinkProgram(programObj);}
1333 void wrapglLoadIdentity(void) {Con_Printf("glLoadIdentity()\n");}
1334 void wrapglLoadMatrixf(const GLfloat *m) {Con_Printf("glLoadMatrixf(m)\n");}
1335 void wrapglMatrixMode(GLenum mode) {Con_Printf("glMatrixMode(mode)\n");}
1336 void wrapglMultiTexCoord1f(GLenum target, GLfloat s) {Con_Printf("glMultiTexCoord1f(target, s)\n");}
1337 void wrapglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {Con_Printf("glMultiTexCoord2f(target, s, t)\n");}
1338 void wrapglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {Con_Printf("glMultiTexCoord3f(target, s, t, r)\n");}
1339 void wrapglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {Con_Printf("glMultiTexCoord4f(target, s, t, r, q)\n");}
1340 void wrapglNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glNormalPointer(type, stride, ptr)\n");}
1341 void wrapglPixelStorei(GLenum pname, GLint param) {glPixelStorei(pname, param);}
1342 void wrapglPointSize(GLfloat size) {Con_Printf("glPointSize(size)\n");}
1343 void wrapglPolygonMode(GLenum face, GLenum mode) {Con_Printf("glPolygonMode(face, mode)\n");}
1344 void wrapglPolygonOffset(GLfloat factor, GLfloat units) {glPolygonOffset(factor, units);}
1345 void wrapglPolygonStipple(const GLubyte *mask) {Con_Printf("glPolygonStipple(mask)\n");}
1346 void wrapglReadBuffer(GLenum mode) {Con_Printf("glReadBuffer(mode)\n");}
1347 void wrapglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {glReadPixels(x, y, width, height, format, type, pixels);}
1348 void wrapglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {glRenderbufferStorage(target, internalformat, width, height);}
1349 void wrapglScissor(GLint x, GLint y, GLsizei width, GLsizei height) {glScissor(x, y, width, height);}
1350 void wrapglShaderSource(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length) {glShaderSource(shaderObj, count, string, length);}
1351 void wrapglStencilFunc(GLenum func, GLint ref, GLuint mask) {glStencilFunc(func, ref, mask);}
1352 void wrapglStencilFuncSeparate(GLenum func1, GLenum func2, GLint ref, GLuint mask) {Con_Printf("glStencilFuncSeparate(func1, func2, ref, mask)\n");}
1353 void wrapglStencilMask(GLuint mask) {glStencilMask(mask);}
1354 void wrapglStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {glStencilOp(fail, zfail, zpass);}
1355 void wrapglStencilOpSeparate(GLenum e1, GLenum e2, GLenum e3, GLenum e4) {Con_Printf("glStencilOpSeparate(e1, e2, e3, e4)\n");}
1356 void wrapglTexCoord1f(GLfloat s) {Con_Printf("glTexCoord1f(s)\n");}
1357 void wrapglTexCoord2f(GLfloat s, GLfloat t) {Con_Printf("glTexCoord2f(s, t)\n");}
1358 void wrapglTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {Con_Printf("glTexCoord3f(s, t, r)\n");}
1359 void wrapglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {Con_Printf("glTexCoord4f(s, t, r, q)\n");}
1360 void wrapglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glTexCoordPointer(size, type, stride, ptr)\n");}
1361 void wrapglTexEnvf(GLenum target, GLenum pname, GLfloat param) {Con_Printf("glTexEnvf(target, pname, param)\n");}
1362 void wrapglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {Con_Printf("glTexEnvfv(target, pname, params)\n");}
1363 void wrapglTexEnvi(GLenum target, GLenum pname, GLint param) {Con_Printf("glTexEnvi(target, pname, param)\n");}
1364 void wrapglTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);}
1365 void wrapglTexImage3D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {Con_Printf("glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels)\n");}
1366 void wrapglTexParameterf(GLenum target, GLenum pname, GLfloat param) {glTexParameterf(target, pname, param);}
1367 void wrapglTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {glTexParameterfv(target, pname, params);}
1368 void wrapglTexParameteri(GLenum target, GLenum pname, GLint param) {glTexParameteri(target, pname, param);}
1369 void wrapglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);}
1370 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) {Con_Printf("glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)\n");}
1371 void wrapglUniform1f(GLint location, GLfloat v0) {glUniform1f(location, v0);}
1372 void wrapglUniform1fv(GLint location, GLsizei count, const GLfloat *value) {glUniform1fv(location, count, value);}
1373 void wrapglUniform1i(GLint location, GLint v0) {glUniform1i(location, v0);}
1374 void wrapglUniform1iv(GLint location, GLsizei count, const GLint *value) {glUniform1iv(location, count, value);}
1375 void wrapglUniform2f(GLint location, GLfloat v0, GLfloat v1) {glUniform2f(location, v0, v1);}
1376 void wrapglUniform2fv(GLint location, GLsizei count, const GLfloat *value) {glUniform2fv(location, count, value);}
1377 void wrapglUniform2i(GLint location, GLint v0, GLint v1) {glUniform2i(location, v0, v1);}
1378 void wrapglUniform2iv(GLint location, GLsizei count, const GLint *value) {glUniform2iv(location, count, value);}
1379 void wrapglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {glUniform3f(location, v0, v1, v2);}
1380 void wrapglUniform3fv(GLint location, GLsizei count, const GLfloat *value) {glUniform3fv(location, count, value);}
1381 void wrapglUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {glUniform3i(location, v0, v1, v2);}
1382 void wrapglUniform3iv(GLint location, GLsizei count, const GLint *value) {glUniform3iv(location, count, value);}
1383 void wrapglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {glUniform4f(location, v0, v1, v2, v3);}
1384 void wrapglUniform4fv(GLint location, GLsizei count, const GLfloat *value) {glUniform4fv(location, count, value);}
1385 void wrapglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {glUniform4i(location, v0, v1, v2, v3);}
1386 void wrapglUniform4iv(GLint location, GLsizei count, const GLint *value) {glUniform4iv(location, count, value);}
1387 void wrapglUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix2fv(location, count, transpose, value);}
1388 void wrapglUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix3fv(location, count, transpose, value);}
1389 void wrapglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix4fv(location, count, transpose, value);}
1390 void wrapglUseProgram(GLuint programObj) {glUseProgram(programObj);}
1391 void wrapglValidateProgram(GLuint programObj) {glValidateProgram(programObj);}
1392 void wrapglVertex2f(GLfloat x, GLfloat y) {Con_Printf("glVertex2f(x, y)\n");}
1393 void wrapglVertex3f(GLfloat x, GLfloat y, GLfloat z) {Con_Printf("glVertex3f(x, y, z)\n");}
1394 void wrapglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {Con_Printf("glVertex4f(x, y, z, w)\n");}
1395 void wrapglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {glVertexAttribPointer(index, size, type, normalized, stride, pointer);}
1396 void wrapglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glVertexPointer(size, type, stride, ptr)\n");}
1397 void wrapglViewport(GLint x, GLint y, GLsizei width, GLsizei height) {glViewport(x, y, width, height);}
1398 void wrapglVertexAttrib1f(GLuint index, GLfloat v0) {glVertexAttrib1f(index, v0);}
1399 //void wrapglVertexAttrib1s(GLuint index, GLshort v0) {glVertexAttrib1s(index, v0);}
1400 //void wrapglVertexAttrib1d(GLuint index, GLdouble v0) {glVertexAttrib1d(index, v0);}
1401 void wrapglVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {glVertexAttrib2f(index, v0, v1);}
1402 //void wrapglVertexAttrib2s(GLuint index, GLshort v0, GLshort v1) {glVertexAttrib2s(index, v0, v1);}
1403 //void wrapglVertexAttrib2d(GLuint index, GLdouble v0, GLdouble v1) {glVertexAttrib2d(index, v0, v1);}
1404 void wrapglVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {glVertexAttrib3f(index, v0, v1, v2);}
1405 //void wrapglVertexAttrib3s(GLuint index, GLshort v0, GLshort v1, GLshort v2) {glVertexAttrib3s(index, v0, v1, v2);}
1406 //void wrapglVertexAttrib3d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2) {glVertexAttrib3d(index, v0, v1, v2);}
1407 void wrapglVertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {glVertexAttrib4f(index, v0, v1, v2, v3);}
1408 //void wrapglVertexAttrib4s(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3) {glVertexAttrib4s(index, v0, v1, v2, v3);}
1409 //void wrapglVertexAttrib4d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {glVertexAttrib4d(index, v0, v1, v2, v3);}
1410 //void wrapglVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {glVertexAttrib4Nub(index, x, y, z, w);}
1411 void wrapglVertexAttrib1fv(GLuint index, const GLfloat *v) {glVertexAttrib1fv(index, v);}
1412 //void wrapglVertexAttrib1sv(GLuint index, const GLshort *v) {glVertexAttrib1sv(index, v);}
1413 //void wrapglVertexAttrib1dv(GLuint index, const GLdouble *v) {glVertexAttrib1dv(index, v);}
1414 void wrapglVertexAttrib2fv(GLuint index, const GLfloat *v) {glVertexAttrib2fv(index, v);}
1415 //void wrapglVertexAttrib2sv(GLuint index, const GLshort *v) {glVertexAttrib2sv(index, v);}
1416 //void wrapglVertexAttrib2dv(GLuint index, const GLdouble *v) {glVertexAttrib2dv(index, v);}
1417 void wrapglVertexAttrib3fv(GLuint index, const GLfloat *v) {glVertexAttrib3fv(index, v);}
1418 //void wrapglVertexAttrib3sv(GLuint index, const GLshort *v) {glVertexAttrib3sv(index, v);}
1419 //void wrapglVertexAttrib3dv(GLuint index, const GLdouble *v) {glVertexAttrib3dv(index, v);}
1420 void wrapglVertexAttrib4fv(GLuint index, const GLfloat *v) {glVertexAttrib4fv(index, v);}
1421 //void wrapglVertexAttrib4sv(GLuint index, const GLshort *v) {glVertexAttrib4sv(index, v);}
1422 //void wrapglVertexAttrib4dv(GLuint index, const GLdouble *v) {glVertexAttrib4dv(index, v);}
1423 //void wrapglVertexAttrib4iv(GLuint index, const GLint *v) {glVertexAttrib4iv(index, v);}
1424 //void wrapglVertexAttrib4bv(GLuint index, const GLbyte *v) {glVertexAttrib4bv(index, v);}
1425 //void wrapglVertexAttrib4ubv(GLuint index, const GLubyte *v) {glVertexAttrib4ubv(index, v);}
1426 //void wrapglVertexAttrib4usv(GLuint index, const GLushort *v) {glVertexAttrib4usv(index, GLushort v);}
1427 //void wrapglVertexAttrib4uiv(GLuint index, const GLuint *v) {glVertexAttrib4uiv(index, v);}
1428 //void wrapglVertexAttrib4Nbv(GLuint index, const GLbyte *v) {glVertexAttrib4Nbv(index, v);}
1429 //void wrapglVertexAttrib4Nsv(GLuint index, const GLshort *v) {glVertexAttrib4Nsv(index, v);}
1430 //void wrapglVertexAttrib4Niv(GLuint index, const GLint *v) {glVertexAttrib4Niv(index, v);}
1431 //void wrapglVertexAttrib4Nubv(GLuint index, const GLubyte *v) {glVertexAttrib4Nubv(index, v);}
1432 //void wrapglVertexAttrib4Nusv(GLuint index, const GLushort *v) {glVertexAttrib4Nusv(index, GLushort v);}
1433 //void wrapglVertexAttrib4Nuiv(GLuint index, const GLuint *v) {glVertexAttrib4Nuiv(index, v);}
1434 //void wrapglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {glGetVertexAttribdv(index, pname, params);}
1435 void wrapglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {glGetVertexAttribfv(index, pname, params);}
1436 void wrapglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {glGetVertexAttribiv(index, pname, params);}
1437 void wrapglGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) {glGetVertexAttribPointerv(index, pname, pointer);}
1439 void GLES_Init(void)
1441 qglIsBufferARB = wrapglIsBuffer;
1442 qglIsEnabled = wrapglIsEnabled;
1443 qglIsFramebufferEXT = wrapglIsFramebuffer;
1444 // qglIsQueryARB = wrapglIsQuery;
1445 qglIsRenderbufferEXT = wrapglIsRenderbuffer;
1446 // qglUnmapBufferARB = wrapglUnmapBuffer;
1447 qglCheckFramebufferStatusEXT = wrapglCheckFramebufferStatus;
1448 qglGetError = wrapglGetError;
1449 qglCreateProgram = wrapglCreateProgram;
1450 qglCreateShader = wrapglCreateShader;
1451 // qglGetHandleARB = wrapglGetHandle;
1452 qglGetAttribLocation = wrapglGetAttribLocation;
1453 qglGetUniformLocation = wrapglGetUniformLocation;
1454 // qglMapBufferARB = wrapglMapBuffer;
1455 qglGetString = wrapglGetString;
1456 // qglActiveStencilFaceEXT = wrapglActiveStencilFace;
1457 qglActiveTexture = wrapglActiveTexture;
1458 qglAlphaFunc = wrapglAlphaFunc;
1459 qglArrayElement = wrapglArrayElement;
1460 qglAttachShader = wrapglAttachShader;
1461 qglBegin = wrapglBegin;
1462 // qglBeginQueryARB = wrapglBeginQuery;
1463 qglBindAttribLocation = wrapglBindAttribLocation;
1464 qglBindFragDataLocation = wrapglBindFragDataLocation;
1465 qglBindBufferARB = wrapglBindBuffer;
1466 qglBindFramebufferEXT = wrapglBindFramebuffer;
1467 qglBindRenderbufferEXT = wrapglBindRenderbuffer;
1468 qglBindTexture = wrapglBindTexture;
1469 qglBlendEquationEXT = wrapglBlendEquation;
1470 qglBlendFunc = wrapglBlendFunc;
1471 qglBufferDataARB = wrapglBufferData;
1472 qglBufferSubDataARB = wrapglBufferSubData;
1473 qglClear = wrapglClear;
1474 qglClearColor = wrapglClearColor;
1475 qglClearDepth = wrapglClearDepth;
1476 qglClearStencil = wrapglClearStencil;
1477 qglClientActiveTexture = wrapglClientActiveTexture;
1478 qglColor4f = wrapglColor4f;
1479 qglColor4ub = wrapglColor4ub;
1480 qglColorMask = wrapglColorMask;
1481 qglColorPointer = wrapglColorPointer;
1482 qglCompileShader = wrapglCompileShader;
1483 qglCompressedTexImage2DARB = wrapglCompressedTexImage2D;
1484 qglCompressedTexImage3DARB = wrapglCompressedTexImage3D;
1485 qglCompressedTexSubImage2DARB = wrapglCompressedTexSubImage2D;
1486 qglCompressedTexSubImage3DARB = wrapglCompressedTexSubImage3D;
1487 qglCopyTexImage2D = wrapglCopyTexImage2D;
1488 qglCopyTexSubImage2D = wrapglCopyTexSubImage2D;
1489 qglCopyTexSubImage3D = wrapglCopyTexSubImage3D;
1490 qglCullFace = wrapglCullFace;
1491 qglDeleteBuffersARB = wrapglDeleteBuffers;
1492 qglDeleteFramebuffersEXT = wrapglDeleteFramebuffers;
1493 qglDeleteProgram = wrapglDeleteProgram;
1494 qglDeleteShader = wrapglDeleteShader;
1495 // qglDeleteQueriesARB = wrapglDeleteQueries;
1496 qglDeleteRenderbuffersEXT = wrapglDeleteRenderbuffers;
1497 qglDeleteTextures = wrapglDeleteTextures;
1498 qglDepthFunc = wrapglDepthFunc;
1499 qglDepthMask = wrapglDepthMask;
1500 qglDepthRange = wrapglDepthRange;
1501 qglDetachShader = wrapglDetachShader;
1502 qglDisable = wrapglDisable;
1503 qglDisableClientState = wrapglDisableClientState;
1504 qglDisableVertexAttribArray = wrapglDisableVertexAttribArray;
1505 qglDrawArrays = wrapglDrawArrays;
1506 // qglDrawBuffer = wrapglDrawBuffer;
1507 // qglDrawBuffersARB = wrapglDrawBuffers;
1508 qglDrawElements = wrapglDrawElements;
1509 // qglDrawRangeElements = wrapglDrawRangeElements;
1510 qglEnable = wrapglEnable;
1511 qglEnableClientState = wrapglEnableClientState;
1512 qglEnableVertexAttribArray = wrapglEnableVertexAttribArray;
1514 // qglEndQueryARB = wrapglEndQuery;
1515 qglFinish = wrapglFinish;
1516 qglFlush = wrapglFlush;
1517 qglFramebufferRenderbufferEXT = wrapglFramebufferRenderbuffer;
1518 qglFramebufferTexture2DEXT = wrapglFramebufferTexture2D;
1519 qglFramebufferTexture3DEXT = wrapglFramebufferTexture3D;
1520 qglGenBuffersARB = wrapglGenBuffers;
1521 qglGenFramebuffersEXT = wrapglGenFramebuffers;
1522 // qglGenQueriesARB = wrapglGenQueries;
1523 qglGenRenderbuffersEXT = wrapglGenRenderbuffers;
1524 qglGenTextures = wrapglGenTextures;
1525 qglGenerateMipmapEXT = wrapglGenerateMipmap;
1526 qglGetActiveAttrib = wrapglGetActiveAttrib;
1527 qglGetActiveUniform = wrapglGetActiveUniform;
1528 qglGetAttachedShaders = wrapglGetAttachedShaders;
1529 qglGetBooleanv = wrapglGetBooleanv;
1530 // qglGetCompressedTexImageARB = wrapglGetCompressedTexImage;
1531 qglGetDoublev = wrapglGetDoublev;
1532 qglGetFloatv = wrapglGetFloatv;
1533 qglGetFramebufferAttachmentParameterivEXT = wrapglGetFramebufferAttachmentParameteriv;
1534 qglGetProgramInfoLog = wrapglGetProgramInfoLog;
1535 qglGetShaderInfoLog = wrapglGetShaderInfoLog;
1536 qglGetIntegerv = wrapglGetIntegerv;
1537 qglGetShaderiv = wrapglGetShaderiv;
1538 qglGetProgramiv = wrapglGetProgramiv;
1539 // qglGetQueryObjectivARB = wrapglGetQueryObjectiv;
1540 // qglGetQueryObjectuivARB = wrapglGetQueryObjectuiv;
1541 // qglGetQueryivARB = wrapglGetQueryiv;
1542 qglGetRenderbufferParameterivEXT = wrapglGetRenderbufferParameteriv;
1543 qglGetShaderSource = wrapglGetShaderSource;
1544 qglGetTexImage = wrapglGetTexImage;
1545 qglGetTexLevelParameterfv = wrapglGetTexLevelParameterfv;
1546 qglGetTexLevelParameteriv = wrapglGetTexLevelParameteriv;
1547 qglGetTexParameterfv = wrapglGetTexParameterfv;
1548 qglGetTexParameteriv = wrapglGetTexParameteriv;
1549 qglGetUniformfv = wrapglGetUniformfv;
1550 qglGetUniformiv = wrapglGetUniformiv;
1551 qglHint = wrapglHint;
1552 qglLineWidth = wrapglLineWidth;
1553 qglLinkProgram = wrapglLinkProgram;
1554 qglLoadIdentity = wrapglLoadIdentity;
1555 qglLoadMatrixf = wrapglLoadMatrixf;
1556 qglMatrixMode = wrapglMatrixMode;
1557 qglMultiTexCoord1f = wrapglMultiTexCoord1f;
1558 qglMultiTexCoord2f = wrapglMultiTexCoord2f;
1559 qglMultiTexCoord3f = wrapglMultiTexCoord3f;
1560 qglMultiTexCoord4f = wrapglMultiTexCoord4f;
1561 qglNormalPointer = wrapglNormalPointer;
1562 qglPixelStorei = wrapglPixelStorei;
1563 qglPointSize = wrapglPointSize;
1564 qglPolygonMode = wrapglPolygonMode;
1565 qglPolygonOffset = wrapglPolygonOffset;
1566 // qglPolygonStipple = wrapglPolygonStipple;
1567 qglReadBuffer = wrapglReadBuffer;
1568 qglReadPixels = wrapglReadPixels;
1569 qglRenderbufferStorageEXT = wrapglRenderbufferStorage;
1570 qglScissor = wrapglScissor;
1571 qglShaderSource = wrapglShaderSource;
1572 qglStencilFunc = wrapglStencilFunc;
1573 qglStencilFuncSeparate = wrapglStencilFuncSeparate;
1574 qglStencilMask = wrapglStencilMask;
1575 qglStencilOp = wrapglStencilOp;
1576 qglStencilOpSeparate = wrapglStencilOpSeparate;
1577 qglTexCoord1f = wrapglTexCoord1f;
1578 qglTexCoord2f = wrapglTexCoord2f;
1579 qglTexCoord3f = wrapglTexCoord3f;
1580 qglTexCoord4f = wrapglTexCoord4f;
1581 qglTexCoordPointer = wrapglTexCoordPointer;
1582 qglTexEnvf = wrapglTexEnvf;
1583 qglTexEnvfv = wrapglTexEnvfv;
1584 qglTexEnvi = wrapglTexEnvi;
1585 qglTexImage2D = wrapglTexImage2D;
1586 qglTexImage3D = wrapglTexImage3D;
1587 qglTexParameterf = wrapglTexParameterf;
1588 qglTexParameterfv = wrapglTexParameterfv;
1589 qglTexParameteri = wrapglTexParameteri;
1590 qglTexSubImage2D = wrapglTexSubImage2D;
1591 qglTexSubImage3D = wrapglTexSubImage3D;
1592 qglUniform1f = wrapglUniform1f;
1593 qglUniform1fv = wrapglUniform1fv;
1594 qglUniform1i = wrapglUniform1i;
1595 qglUniform1iv = wrapglUniform1iv;
1596 qglUniform2f = wrapglUniform2f;
1597 qglUniform2fv = wrapglUniform2fv;
1598 qglUniform2i = wrapglUniform2i;
1599 qglUniform2iv = wrapglUniform2iv;
1600 qglUniform3f = wrapglUniform3f;
1601 qglUniform3fv = wrapglUniform3fv;
1602 qglUniform3i = wrapglUniform3i;
1603 qglUniform3iv = wrapglUniform3iv;
1604 qglUniform4f = wrapglUniform4f;
1605 qglUniform4fv = wrapglUniform4fv;
1606 qglUniform4i = wrapglUniform4i;
1607 qglUniform4iv = wrapglUniform4iv;
1608 qglUniformMatrix2fv = wrapglUniformMatrix2fv;
1609 qglUniformMatrix3fv = wrapglUniformMatrix3fv;
1610 qglUniformMatrix4fv = wrapglUniformMatrix4fv;
1611 qglUseProgram = wrapglUseProgram;
1612 qglValidateProgram = wrapglValidateProgram;
1613 qglVertex2f = wrapglVertex2f;
1614 qglVertex3f = wrapglVertex3f;
1615 qglVertex4f = wrapglVertex4f;
1616 qglVertexAttribPointer = wrapglVertexAttribPointer;
1617 qglVertexPointer = wrapglVertexPointer;
1618 qglViewport = wrapglViewport;
1619 qglVertexAttrib1f = wrapglVertexAttrib1f;
1620 // qglVertexAttrib1s = wrapglVertexAttrib1s;
1621 // qglVertexAttrib1d = wrapglVertexAttrib1d;
1622 qglVertexAttrib2f = wrapglVertexAttrib2f;
1623 // qglVertexAttrib2s = wrapglVertexAttrib2s;
1624 // qglVertexAttrib2d = wrapglVertexAttrib2d;
1625 qglVertexAttrib3f = wrapglVertexAttrib3f;
1626 // qglVertexAttrib3s = wrapglVertexAttrib3s;
1627 // qglVertexAttrib3d = wrapglVertexAttrib3d;
1628 qglVertexAttrib4f = wrapglVertexAttrib4f;
1629 // qglVertexAttrib4s = wrapglVertexAttrib4s;
1630 // qglVertexAttrib4d = wrapglVertexAttrib4d;
1631 // qglVertexAttrib4Nub = wrapglVertexAttrib4Nub;
1632 qglVertexAttrib1fv = wrapglVertexAttrib1fv;
1633 // qglVertexAttrib1sv = wrapglVertexAttrib1sv;
1634 // qglVertexAttrib1dv = wrapglVertexAttrib1dv;
1635 qglVertexAttrib2fv = wrapglVertexAttrib2fv;
1636 // qglVertexAttrib2sv = wrapglVertexAttrib2sv;
1637 // qglVertexAttrib2dv = wrapglVertexAttrib2dv;
1638 qglVertexAttrib3fv = wrapglVertexAttrib3fv;
1639 // qglVertexAttrib3sv = wrapglVertexAttrib3sv;
1640 // qglVertexAttrib3dv = wrapglVertexAttrib3dv;
1641 qglVertexAttrib4fv = wrapglVertexAttrib4fv;
1642 // qglVertexAttrib4sv = wrapglVertexAttrib4sv;
1643 // qglVertexAttrib4dv = wrapglVertexAttrib4dv;
1644 // qglVertexAttrib4iv = wrapglVertexAttrib4iv;
1645 // qglVertexAttrib4bv = wrapglVertexAttrib4bv;
1646 // qglVertexAttrib4ubv = wrapglVertexAttrib4ubv;
1647 // qglVertexAttrib4usv = wrapglVertexAttrib4usv;
1648 // qglVertexAttrib4uiv = wrapglVertexAttrib4uiv;
1649 // qglVertexAttrib4Nbv = wrapglVertexAttrib4Nbv;
1650 // qglVertexAttrib4Nsv = wrapglVertexAttrib4Nsv;
1651 // qglVertexAttrib4Niv = wrapglVertexAttrib4Niv;
1652 // qglVertexAttrib4Nubv = wrapglVertexAttrib4Nubv;
1653 // qglVertexAttrib4Nusv = wrapglVertexAttrib4Nusv;
1654 // qglVertexAttrib4Nuiv = wrapglVertexAttrib4Nuiv;
1655 // qglGetVertexAttribdv = wrapglGetVertexAttribdv;
1656 qglGetVertexAttribfv = wrapglGetVertexAttribfv;
1657 qglGetVertexAttribiv = wrapglGetVertexAttribiv;
1658 qglGetVertexAttribPointerv = wrapglGetVertexAttribPointerv;
1660 gl_renderer = (const char *)qglGetString(GL_RENDERER);
1661 gl_vendor = (const char *)qglGetString(GL_VENDOR);
1662 gl_version = (const char *)qglGetString(GL_VERSION);
1663 gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
1667 if (!gl_platformextensions)
1668 gl_platformextensions = "";
1670 Con_Printf("GL_VENDOR: %s\n", gl_vendor);
1671 Con_Printf("GL_RENDERER: %s\n", gl_renderer);
1672 Con_Printf("GL_VERSION: %s\n", gl_version);
1673 Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
1674 Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
1676 // LordHavoc: report supported extensions
1677 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
1679 vid.support.gl20shaders = true;
1680 vid.support.amd_texture_texture4 = false;
1681 vid.support.arb_depth_texture = false;
1682 vid.support.arb_draw_buffers = false;
1683 vid.support.arb_multitexture = false;
1684 vid.support.arb_occlusion_query = false;
1685 vid.support.arb_shadow = false;
1686 vid.support.arb_texture_compression = false; // different (vendor-specific) formats than on desktop OpenGL...
1687 vid.support.arb_texture_cube_map = true;
1688 vid.support.arb_texture_env_combine = false;
1689 vid.support.arb_texture_gather = false;
1690 vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
1691 vid.support.arb_vertex_buffer_object = true;
1692 vid.support.ati_separate_stencil = false;
1693 vid.support.ext_blend_minmax = false;
1694 vid.support.ext_blend_subtract = true;
1695 vid.support.ext_draw_range_elements = true;
1696 vid.support.ext_framebuffer_object = false;//true;
1697 vid.support.ext_stencil_two_side = false;
1698 vid.support.ext_texture_3d = false;//SDL_GL_ExtensionSupported("GL_OES_texture_3D"); // iPhoneOS does not support 3D textures, odd...
1699 vid.support.ext_texture_compression_s3tc = false;
1700 vid.support.ext_texture_edge_clamp = true;
1701 vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
1703 qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
1704 if (vid.support.ext_texture_filter_anisotropic)
1705 qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
1706 if (vid.support.arb_texture_cube_map)
1707 qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, (GLint*)&vid.maxtexturesize_cubemap);
1708 if (vid.support.ext_texture_3d)
1709 qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_3d);
1710 Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
1711 Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
1713 // verify that cubemap textures are really supported
1714 if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
1715 vid.support.arb_texture_cube_map = false;
1717 // verify that 3d textures are really supported
1718 if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
1720 vid.support.ext_texture_3d = false;
1721 Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
1725 vid.teximageunits = 8;
1726 vid.texarrayunits = 5;
1727 vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
1728 vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
1729 vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
1730 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" : "");
1731 vid.renderpath = RENDERPATH_GLES2;
1732 vid.useinterleavedarrays = false;
1734 // VorteX: set other info (maybe place them in VID_InitMode?)
1735 extern cvar_t gl_info_vendor;
1736 extern cvar_t gl_info_renderer;
1737 extern cvar_t gl_info_version;
1738 extern cvar_t gl_info_platform;
1739 extern cvar_t gl_info_driver;
1740 Cvar_SetQuick(&gl_info_vendor, gl_vendor);
1741 Cvar_SetQuick(&gl_info_renderer, gl_renderer);
1742 Cvar_SetQuick(&gl_info_version, gl_version);
1743 Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
1744 Cvar_SetQuick(&gl_info_driver, gl_driver);
1748 void *GL_GetProcAddress(const char *name)
1751 p = SDL_GL_GetProcAddress(name);
1755 static qboolean vid_sdl_initjoysticksystem = false;
1757 void VID_Init (void)
1759 #ifndef __IPHONEOS__
1761 Cvar_RegisterVariable(&apple_mouse_noaccel);
1764 Cvar_RegisterVariable(&vid_soft);
1765 Cvar_RegisterVariable(&vid_soft_threads);
1766 Cvar_RegisterVariable(&vid_soft_interlace);
1767 Cvar_RegisterVariable(&joy_detected);
1768 Cvar_RegisterVariable(&joy_enable);
1769 Cvar_RegisterVariable(&joy_index);
1770 Cvar_RegisterVariable(&joy_axisforward);
1771 Cvar_RegisterVariable(&joy_axisside);
1772 Cvar_RegisterVariable(&joy_axisup);
1773 Cvar_RegisterVariable(&joy_axispitch);
1774 Cvar_RegisterVariable(&joy_axisyaw);
1775 //Cvar_RegisterVariable(&joy_axisroll);
1776 Cvar_RegisterVariable(&joy_deadzoneforward);
1777 Cvar_RegisterVariable(&joy_deadzoneside);
1778 Cvar_RegisterVariable(&joy_deadzoneup);
1779 Cvar_RegisterVariable(&joy_deadzonepitch);
1780 Cvar_RegisterVariable(&joy_deadzoneyaw);
1781 //Cvar_RegisterVariable(&joy_deadzoneroll);
1782 Cvar_RegisterVariable(&joy_sensitivityforward);
1783 Cvar_RegisterVariable(&joy_sensitivityside);
1784 Cvar_RegisterVariable(&joy_sensitivityup);
1785 Cvar_RegisterVariable(&joy_sensitivitypitch);
1786 Cvar_RegisterVariable(&joy_sensitivityyaw);
1787 //Cvar_RegisterVariable(&joy_sensitivityroll);
1788 Cvar_RegisterVariable(&joy_axiskeyevents);
1790 Cvar_SetValueQuick(&vid_touchscreen, 1);
1793 #ifdef SDL_R_RESTART
1794 R_RegisterModule("SDL", sdl_start, sdl_shutdown, sdl_newmap, NULL, NULL);
1797 if (SDL_Init(SDL_INIT_VIDEO) < 0)
1798 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
1799 vid_sdl_initjoysticksystem = SDL_InitSubSystem(SDL_INIT_JOYSTICK) >= 0;
1800 if (vid_sdl_initjoysticksystem)
1801 Con_Printf("Failed to init SDL joystick subsystem: %s\n", SDL_GetError());
1802 vid_isfullscreen = false;
1806 // set the icon (we dont use SDL here since it would be too much a PITA)
1808 #include "resource.h"
1809 #include <SDL_syswm.h>
1810 static void VID_SetCaption(void)
1816 SDL_WM_SetCaption( gamename, NULL );
1818 // get the HWND handle
1819 SDL_VERSION( &info.version );
1820 if( !SDL_GetWMInfo( &info ) )
1823 icon = LoadIcon( GetModuleHandle( NULL ), MAKEINTRESOURCE( IDI_ICON1 ) );
1824 #ifndef _W64 //If Windows 64bit data types don't exist
1825 #ifndef SetClassLongPtr
1826 #define SetClassLongPtr SetClassLong
1829 #define GCLP_HICON GCL_HICON
1832 #define LONG_PTR LONG
1835 SetClassLongPtr( info.window, GCLP_HICON, (LONG_PTR)icon );
1837 static void VID_SetIcon_Pre(void)
1840 static void VID_SetIcon_Post(void)
1844 // Adding the OS independent XPM version --blub
1845 #include "darkplaces.xpm"
1846 #include "nexuiz.xpm"
1847 static SDL_Surface *icon = NULL;
1848 static void VID_SetIcon_Pre(void)
1851 * Somewhat restricted XPM reader. Only supports XPMs saved by GIMP 2.4 at
1852 * default settings with less than 91 colors and transparency.
1855 int width, height, colors, isize, i, j;
1857 static SDL_Color palette[256];
1858 unsigned short palenc[256]; // store color id by char
1860 char **idata, *data;
1861 const SDL_version *version;
1863 version = SDL_Linked_Version();
1864 // only use non-XPM icon support in SDL v1.3 and higher
1865 // SDL v1.2 does not support "smooth" transparency, and thus is better
1867 if(version->major >= 2 || (version->major == 1 && version->minor >= 3))
1869 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1872 unsigned int red = 0x00FF0000;
1873 unsigned int green = 0x0000FF00;
1874 unsigned int blue = 0x000000FF;
1875 unsigned int alpha = 0xFF000000;
1876 width = image_width;
1877 height = image_height;
1879 // reallocate with malloc, as this is in tempmempool (do not want)
1881 data = malloc(width * height * 4);
1882 memcpy(data, xpm, width * height * 4);
1886 icon = SDL_CreateRGBSurface(SDL_SRCALPHA, width, height, 32, LittleLong(red), LittleLong(green), LittleLong(blue), LittleLong(alpha));
1889 Con_Printf( "Failed to create surface for the window Icon!\n"
1890 "%s\n", SDL_GetError());
1895 icon->pixels = data;
1899 // we only get here if non-XPM icon was missing, or SDL version is not
1900 // sufficient for transparent non-XPM icons
1903 xpm = (char *) FS_LoadFile("darkplaces-icon.xpm", tempmempool, false, NULL);
1906 idata = XPM_DecodeString(xpm);
1908 idata = ENGINE_ICON;
1914 if(sscanf(data, "%i %i %i %i", &width, &height, &colors, &isize) != 4)
1916 // NOTE: Only 1-char colornames are supported
1917 Con_Printf("Sorry, but this does not even look similar to an XPM.\n");
1923 // NOTE: Only 1-char colornames are supported
1924 Con_Printf("This XPM's palette is either huge or idiotically unoptimized. It's key size is %i\n", isize);
1928 for(i = 0; i < colors; ++i)
1930 unsigned int r, g, b;
1933 if(sscanf(idata[i+1], "%c c #%02x%02x%02x", &idx, &r, &g, &b) != 4)
1936 if(sscanf(idata[i+1], "%c c Non%1[e]", &idx, foo) != 2) // I take the DailyWTF credit for this. --div0
1938 Con_Printf("This XPM's palette looks odd. Can't continue.\n");
1943 palette[i].r = 255; // color key
1946 thenone = i; // weeeee
1951 palette[i].r = r - (r == 255 && g == 0 && b == 255); // change 255/0/255 pink to 254/0/255 for color key
1956 palenc[(unsigned char) idx] = i;
1959 // allocate the image data
1960 data = (char*) malloc(width*height);
1962 for(j = 0; j < height; ++j)
1964 for(i = 0; i < width; ++i)
1966 // casting to the safest possible datatypes ^^
1967 data[j * width + i] = palenc[((unsigned char*)idata[colors+j+1])[i]];
1973 // SDL_FreeSurface should free the data too
1974 // but for completeness' sake...
1975 if(icon->flags & SDL_PREALLOC)
1978 icon->pixels = NULL; // safety
1980 SDL_FreeSurface(icon);
1983 icon = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, width, height, 8, 0,0,0,0);// rmask, gmask, bmask, amask); no mask needed
1984 // 8 bit surfaces get an empty palette allocated according to the docs
1985 // so it's a palette image for sure :) no endian check necessary for the mask
1988 Con_Printf( "Failed to create surface for the window Icon!\n"
1989 "%s\n", SDL_GetError());
1994 icon->pixels = data;
1995 SDL_SetPalette(icon, SDL_PHYSPAL|SDL_LOGPAL, palette, 0, colors);
1996 SDL_SetColorKey(icon, SDL_SRCCOLORKEY, thenone);
1999 SDL_WM_SetIcon(icon, NULL);
2001 static void VID_SetIcon_Post(void)
2003 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2004 // LordHavoc: info.info.x11.lock_func and accompanying code do not seem to compile with SDL 1.3
2005 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
2008 const SDL_version *version;
2010 version = SDL_Linked_Version();
2011 // only use non-XPM icon support in SDL v1.3 and higher
2012 // SDL v1.2 does not support "smooth" transparency, and thus is better
2014 if(!(version->major >= 2 || (version->major == 1 && version->minor >= 3)))
2016 // in this case, we did not set the good icon yet
2018 SDL_VERSION(&info.version);
2019 if(SDL_GetWMInfo(&info) == 1 && info.subsystem == SDL_SYSWM_X11)
2021 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
2024 // use _NET_WM_ICON too
2025 static long netwm_icon[MAX_NETWM_ICON];
2031 if(pos + 2 * image_width * image_height < MAX_NETWM_ICON)
2033 netwm_icon[pos++] = image_width;
2034 netwm_icon[pos++] = image_height;
2035 for(i = 0; i < image_height; ++i)
2036 for(j = 0; j < image_width; ++j)
2037 netwm_icon[pos++] = BuffLittleLong((unsigned char *) &data[(i*image_width+j)*4]);
2041 Con_Printf("Skipping NETWM icon #%d because there is no space left\n", i);
2045 data = (char *) loadimagepixelsbgra(va("darkplaces-icon%d", i), false, false, false, NULL);
2048 info.info.x11.lock_func();
2050 Atom net_wm_icon = XInternAtom(info.info.x11.display, "_NET_WM_ICON", false);
2051 XChangeProperty(info.info.x11.display, info.info.x11.wmwindow, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (const unsigned char *) netwm_icon, pos);
2053 info.info.x11.unlock_func();
2062 static void VID_SetCaption(void)
2064 SDL_WM_SetCaption( gamename, NULL );
2069 static void VID_OutputVersion(void)
2071 const SDL_version *version;
2072 version = SDL_Linked_Version();
2073 Con_Printf( "Linked against SDL version %d.%d.%d\n"
2074 "Using SDL library version %d.%d.%d\n",
2075 SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL,
2076 version->major, version->minor, version->patch );
2079 qboolean VID_InitModeGL(viddef_mode_t *mode)
2083 static int notfirstvideomode = false;
2084 int flags = SDL_OPENGL;
2086 int windowflags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
2088 const char *drivername;
2090 win_half_width = mode->width>>1;
2091 win_half_height = mode->height>>1;
2093 if(vid_resizable.integer)
2095 flags |= SDL_RESIZABLE;
2097 windowflags |= SDL_WINDOW_RESIZABLE;
2100 VID_OutputVersion();
2105 We cant switch from one OpenGL video mode to another.
2106 Thus we first switch to some stupid 2D mode and then back to OpenGL.
2108 if (notfirstvideomode)
2109 SDL_SetVideoMode( 0, 0, 0, 0 );
2110 notfirstvideomode = true;
2113 // SDL usually knows best
2116 // 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
2117 i = COM_CheckParm("-gl_driver");
2118 if (i && i < com_argc - 1)
2119 drivername = com_argv[i + 1];
2120 if (SDL_GL_LoadLibrary(drivername) < 0)
2122 Con_Printf("Unable to load GL driver \"%s\": %s\n", drivername, SDL_GetError());
2127 // mobile platforms are always fullscreen, we'll get the resolution after opening the window
2128 mode->fullscreen = true;
2129 // hide the menu with SDL_WINDOW_BORDERLESS
2130 windowflags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
2132 if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
2135 Con_Print("Required OpenGL function glGetString not found\n");
2140 // Knghtbrd: should do platform-specific extension string function here
2142 vid_isfullscreen = false;
2143 if (mode->fullscreen) {
2145 flags |= SDL_FULLSCREEN;
2147 windowflags |= SDL_WINDOW_FULLSCREEN;
2149 vid_isfullscreen = true;
2151 //flags |= SDL_HWSURFACE;
2153 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
2154 if (mode->bitsperpixel >= 32)
2156 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 8);
2157 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 8);
2158 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 8);
2159 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8);
2160 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24);
2161 SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
2165 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
2166 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
2167 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
2168 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
2170 if (mode->stereobuffer)
2171 SDL_GL_SetAttribute (SDL_GL_STEREO, 1);
2172 if (mode->samples > 1)
2174 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
2175 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, mode->samples);
2177 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2178 if (vid_vsync.integer)
2179 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
2181 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 0);
2184 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 2);
2185 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 0);
2186 SDL_GL_SetAttribute (SDL_GL_RETAINED_BACKING, 1);
2187 // FIXME: get proper resolution from OS somehow (iPad for instance...)
2193 video_bpp = mode->bitsperpixel;
2195 video_flags = flags;
2197 screen = SDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2201 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2205 mode->width = screen->w;
2206 mode->height = screen->h;
2208 window_flags = windowflags;
2209 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2212 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2216 SDL_GetWindowSize(window, &mode->width, &mode->height);
2217 context = SDL_GL_CreateContext(window);
2218 if (context == NULL)
2220 Con_Printf("Failed to initialize OpenGL context: %s\n", SDL_GetError());
2226 vid_softsurface = NULL;
2227 vid.softpixels = NULL;
2234 SDL_EnableUNICODE( SDL_ENABLE );
2235 // enable key repeat since everyone expects it
2236 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2238 #if !(SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2)
2239 SDL_GL_SetSwapInterval(vid_vsync.integer != 0);
2240 vid_usingvsync = (vid_vsync.integer != 0);
2243 gl_platform = "SDL";
2244 gl_platformextensions = "";
2252 vid_numjoysticks = SDL_NumJoysticks();
2253 vid_numjoysticks = bound(0, vid_numjoysticks, MAX_JOYSTICKS);
2254 Cvar_SetValueQuick(&joy_detected, vid_numjoysticks);
2255 Con_Printf("%d SDL joystick(s) found:\n", vid_numjoysticks);
2256 memset(vid_joysticks, 0, sizeof(vid_joysticks));
2257 for (i = 0;i < vid_numjoysticks;i++)
2260 joy = vid_joysticks[i] = SDL_JoystickOpen(i);
2263 Con_Printf("joystick #%i: open failed: %s\n", i, SDL_GetError());
2266 Con_Printf("joystick #%i: opened \"%s\" with %i axes, %i buttons, %i balls\n", i, SDL_JoystickName(i), (int)SDL_JoystickNumAxes(joy), (int)SDL_JoystickNumButtons(joy), (int)SDL_JoystickNumBalls(joy));
2270 vid_activewindow = false;
2271 vid_hasfocus = true;
2272 vid_usingmouse = false;
2273 vid_usinghidecursor = false;
2276 SDL_WM_GrabInput(SDL_GRAB_OFF);
2281 extern cvar_t gl_info_extensions;
2282 extern cvar_t gl_info_vendor;
2283 extern cvar_t gl_info_renderer;
2284 extern cvar_t gl_info_version;
2285 extern cvar_t gl_info_platform;
2286 extern cvar_t gl_info_driver;
2288 qboolean VID_InitModeSoft(viddef_mode_t *mode)
2292 int flags = SDL_HWSURFACE;
2294 int windowflags = SDL_WINDOW_SHOWN;
2297 win_half_width = mode->width>>1;
2298 win_half_height = mode->height>>1;
2300 if(vid_resizable.integer)
2302 flags |= SDL_RESIZABLE;
2304 windowflags |= SDL_WINDOW_RESIZABLE;
2307 VID_OutputVersion();
2309 vid_isfullscreen = false;
2310 if (mode->fullscreen) {
2312 flags |= SDL_FULLSCREEN;
2314 windowflags |= SDL_WINDOW_FULLSCREEN;
2316 vid_isfullscreen = true;
2319 video_bpp = mode->bitsperpixel;
2321 video_flags = flags;
2323 screen = SDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2327 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2331 mode->width = screen->w;
2332 mode->height = screen->h;
2334 window_flags = windowflags;
2335 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2338 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2342 SDL_GetWindowSize(window, &mode->width, &mode->height);
2345 // create a framebuffer using our specific color format, we let the SDL blit function convert it in VID_Finish
2346 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, mode->width, mode->height, 32, 0x00FF0000, 0x0000FF00, 0x00000000FF, 0xFF000000);
2347 if (vid_softsurface == NULL)
2349 Con_Printf("Failed to setup software rasterizer framebuffer %ix%ix32bpp: %s\n", mode->width, mode->height, SDL_GetError());
2353 SDL_SetAlpha(vid_softsurface, 0, 255);
2355 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
2356 vid.softdepthpixels = (unsigned int *)calloc(1, mode->width * mode->height * 4);
2357 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)
2359 Con_Printf("Failed to initialize software rasterizer\n");
2369 SDL_EnableUNICODE( SDL_ENABLE );
2370 // enable key repeat since everyone expects it
2371 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2373 gl_platform = "SDLSoft";
2374 gl_platformextensions = "";
2376 gl_renderer = "DarkPlaces-Soft";
2377 gl_vendor = "Forest Hale";
2381 // clear the extension flags
2382 memset(&vid.support, 0, sizeof(vid.support));
2383 Cvar_SetQuick(&gl_info_extensions, "");
2385 vid.forcevbo = false;
2386 vid.support.arb_depth_texture = true;
2387 vid.support.arb_draw_buffers = true;
2388 vid.support.arb_occlusion_query = true;
2389 vid.support.arb_shadow = true;
2390 //vid.support.arb_texture_compression = true;
2391 vid.support.arb_texture_cube_map = true;
2392 vid.support.arb_texture_non_power_of_two = false;
2393 vid.support.arb_vertex_buffer_object = true;
2394 vid.support.ext_blend_subtract = true;
2395 vid.support.ext_draw_range_elements = true;
2396 vid.support.ext_framebuffer_object = true;
2397 vid.support.ext_texture_3d = true;
2398 //vid.support.ext_texture_compression_s3tc = true;
2399 vid.support.ext_texture_filter_anisotropic = true;
2400 vid.support.ati_separate_stencil = true;
2402 vid.maxtexturesize_2d = 16384;
2403 vid.maxtexturesize_3d = 512;
2404 vid.maxtexturesize_cubemap = 16384;
2406 vid.teximageunits = 32;
2407 vid.texarrayunits = 8;
2408 vid.max_anisotropy = 1;
2409 vid.maxdrawbuffers = 4;
2411 vid.texunits = bound(4, vid.texunits, MAX_TEXTUREUNITS);
2412 vid.teximageunits = bound(16, vid.teximageunits, MAX_TEXTUREUNITS);
2413 vid.texarrayunits = bound(8, vid.texarrayunits, MAX_TEXTUREUNITS);
2414 Con_DPrintf("Using DarkPlaces Software Rasterizer rendering path\n");
2415 vid.renderpath = RENDERPATH_SOFT;
2416 vid.useinterleavedarrays = false;
2418 Cvar_SetQuick(&gl_info_vendor, gl_vendor);
2419 Cvar_SetQuick(&gl_info_renderer, gl_renderer);
2420 Cvar_SetQuick(&gl_info_version, gl_version);
2421 Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
2422 Cvar_SetQuick(&gl_info_driver, gl_driver);
2424 // LordHavoc: report supported extensions
2425 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2427 // clear to black (loading plaque will be seen over this)
2428 GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
2430 vid_numjoysticks = SDL_NumJoysticks();
2431 vid_numjoysticks = bound(0, vid_numjoysticks, MAX_JOYSTICKS);
2432 Cvar_SetValueQuick(&joy_detected, vid_numjoysticks);
2433 Con_Printf("%d SDL joystick(s) found:\n", vid_numjoysticks);
2434 memset(vid_joysticks, 0, sizeof(vid_joysticks));
2435 for (i = 0;i < vid_numjoysticks;i++)
2438 joy = vid_joysticks[i] = SDL_JoystickOpen(i);
2441 Con_Printf("joystick #%i: open failed: %s\n", i, SDL_GetError());
2444 Con_Printf("joystick #%i: opened \"%s\" with %i axes, %i buttons, %i balls\n", i, SDL_JoystickName(i), (int)SDL_JoystickNumAxes(joy), (int)SDL_JoystickNumButtons(joy), (int)SDL_JoystickNumBalls(joy));
2448 vid_activewindow = false;
2449 vid_hasfocus = true;
2450 vid_usingmouse = false;
2451 vid_usinghidecursor = false;
2454 SDL_WM_GrabInput(SDL_GRAB_OFF);
2459 qboolean VID_InitMode(viddef_mode_t *mode)
2461 if (!SDL_WasInit(SDL_INIT_VIDEO) && SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
2462 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
2464 if (vid_soft.integer)
2465 return VID_InitModeSoft(mode);
2468 return VID_InitModeGL(mode);
2471 void VID_Shutdown (void)
2473 VID_SetMouse(false, false, false);
2474 VID_RestoreSystemGamma();
2479 SDL_FreeSurface(icon);
2484 if (vid_softsurface)
2485 SDL_FreeSurface(vid_softsurface);
2486 vid_softsurface = NULL;
2487 vid.softpixels = NULL;
2488 if (vid.softdepthpixels)
2489 free(vid.softdepthpixels);
2490 vid.softdepthpixels = NULL;
2494 SDL_DestroyWindow(window);
2498 SDL_QuitSubSystem(SDL_INIT_VIDEO);
2503 gl_platformextensions = "";
2506 int VID_SetGamma (unsigned short *ramps, int rampsize)
2508 return !SDL_SetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2511 int VID_GetGamma (unsigned short *ramps, int rampsize)
2513 return !SDL_GetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2516 void VID_Finish (void)
2521 //react on appstate changes
2522 appstate = SDL_GetAppState();
2524 vid_hidden = !(appstate & SDL_APPACTIVE);
2525 vid_hasfocus = (appstate & SDL_APPMOUSEFOCUS) && (appstate & SDL_APPINPUTFOCUS);
2527 vid_activewindow = !vid_hidden && vid_hasfocus;
2529 VID_UpdateGamma(false, 256);
2533 switch(vid.renderpath)
2535 case RENDERPATH_GL11:
2536 case RENDERPATH_GL13:
2537 case RENDERPATH_GL20:
2538 case RENDERPATH_GLES2:
2540 if (r_speeds.integer == 2 || gl_finish.integer)
2542 qglFinish();CHECKGLERROR
2544 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2547 qboolean vid_usevsync;
2548 vid_usevsync = (vid_vsync.integer && !cls.timedemo);
2549 if (vid_usingvsync != vid_usevsync)
2551 if (SDL_GL_SetSwapInterval(vid_usevsync != 0) >= 0)
2552 Con_DPrintf("Vsync %s\n", vid_usevsync ? "activated" : "deactivated");
2554 Con_DPrintf("ERROR: can't %s vsync\n", vid_usevsync ? "activate" : "deactivate");
2559 SDL_GL_SwapBuffers();
2561 SDL_GL_SwapWindow(window);
2564 case RENDERPATH_SOFT:
2565 DPSOFTRAST_Finish();
2567 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2571 SDL_Surface *screen = SDL_GetWindowSurface(window);
2572 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2573 SDL_UpdateWindowSurface(window);
2577 case RENDERPATH_D3D9:
2578 case RENDERPATH_D3D10:
2579 case RENDERPATH_D3D11:
2585 size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
2588 SDL_Rect **vidmodes;
2589 int bpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
2592 for(vidmodes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE); *vidmodes; ++vidmodes)
2596 modes[k].width = (*vidmodes)->w;
2597 modes[k].height = (*vidmodes)->h;
2599 modes[k].refreshrate = 60; // no support for refresh rate in SDL
2600 modes[k].pixelheight_num = 1;
2601 modes[k].pixelheight_denom = 1; // SDL does not provide this