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"};
94 cvar_t joy_axiskeyevents_deadzone = {CVAR_SAVE, "joy_axiskeyevents_deadzone", "0.5", "deadzone value for axes"};
97 # define SETVIDEOMODE 0
99 # if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
100 # define SETVIDEOMODE 1
102 // 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...
103 # ifndef SETVIDEOMODE
104 # define SETVIDEOMODE 1
109 static qboolean vid_usingmouse = false;
110 static qboolean vid_usinghidecursor = false;
111 static qboolean vid_hasfocus = false;
112 static qboolean vid_isfullscreen;
113 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
115 static qboolean vid_usingvsync = false;
117 static int vid_numjoysticks = 0;
118 #define MAX_JOYSTICKS 8
119 static SDL_Joystick *vid_joysticks[MAX_JOYSTICKS];
121 static int win_half_width = 50;
122 static int win_half_height = 50;
123 static int video_bpp;
126 static SDL_Surface *screen;
127 static int video_flags;
129 static SDL_GLContext *context;
130 static SDL_Window *window;
131 static int window_flags;
133 static SDL_Surface *vid_softsurface;
135 // joystick axes state
136 #define MAX_JOYSTICK_AXES 16
143 static joy_axiscache_t joy_axescache[MAX_JOYSTICK_AXES];
145 /////////////////////////
148 //TODO: Add joystick support
149 //TODO: Add error checking
152 #define SDLK_PERCENT '%'
153 #define SDLK_PRINTSCREEN SDLK_PRINT
154 #define SDLK_SCROLLLOCK SDLK_SCROLLOCK
155 #define SDLK_NUMLOCKCLEAR SDLK_NUMLOCK
156 #define SDLK_KP_1 SDLK_KP1
157 #define SDLK_KP_2 SDLK_KP2
158 #define SDLK_KP_3 SDLK_KP3
159 #define SDLK_KP_4 SDLK_KP4
160 #define SDLK_KP_5 SDLK_KP5
161 #define SDLK_KP_6 SDLK_KP6
162 #define SDLK_KP_7 SDLK_KP7
163 #define SDLK_KP_8 SDLK_KP8
164 #define SDLK_KP_9 SDLK_KP9
165 #define SDLK_KP_0 SDLK_KP0
168 static int MapKey( unsigned int sdlkey )
173 // case SDLK_UNKNOWN: return K_UNKNOWN;
174 case SDLK_RETURN: return K_ENTER;
175 case SDLK_ESCAPE: return K_ESCAPE;
176 case SDLK_BACKSPACE: return K_BACKSPACE;
177 case SDLK_TAB: return K_TAB;
178 case SDLK_SPACE: return K_SPACE;
179 case SDLK_EXCLAIM: return '!';
180 case SDLK_QUOTEDBL: return '"';
181 case SDLK_HASH: return '#';
182 case SDLK_PERCENT: return '%';
183 case SDLK_DOLLAR: return '$';
184 case SDLK_AMPERSAND: return '&';
185 case SDLK_QUOTE: return '\'';
186 case SDLK_LEFTPAREN: return '(';
187 case SDLK_RIGHTPAREN: return ')';
188 case SDLK_ASTERISK: return '*';
189 case SDLK_PLUS: return '+';
190 case SDLK_COMMA: return ',';
191 case SDLK_MINUS: return '-';
192 case SDLK_PERIOD: return '.';
193 case SDLK_SLASH: return '/';
194 case SDLK_0: return '0';
195 case SDLK_1: return '1';
196 case SDLK_2: return '2';
197 case SDLK_3: return '3';
198 case SDLK_4: return '4';
199 case SDLK_5: return '5';
200 case SDLK_6: return '6';
201 case SDLK_7: return '7';
202 case SDLK_8: return '8';
203 case SDLK_9: return '9';
204 case SDLK_COLON: return ':';
205 case SDLK_SEMICOLON: return ';';
206 case SDLK_LESS: return '<';
207 case SDLK_EQUALS: return '=';
208 case SDLK_GREATER: return '>';
209 case SDLK_QUESTION: return '?';
210 case SDLK_AT: return '@';
211 case SDLK_LEFTBRACKET: return '[';
212 case SDLK_BACKSLASH: return '\\';
213 case SDLK_RIGHTBRACKET: return ']';
214 case SDLK_CARET: return '^';
215 case SDLK_UNDERSCORE: return '_';
216 case SDLK_BACKQUOTE: return '`';
217 case SDLK_a: return 'a';
218 case SDLK_b: return 'b';
219 case SDLK_c: return 'c';
220 case SDLK_d: return 'd';
221 case SDLK_e: return 'e';
222 case SDLK_f: return 'f';
223 case SDLK_g: return 'g';
224 case SDLK_h: return 'h';
225 case SDLK_i: return 'i';
226 case SDLK_j: return 'j';
227 case SDLK_k: return 'k';
228 case SDLK_l: return 'l';
229 case SDLK_m: return 'm';
230 case SDLK_n: return 'n';
231 case SDLK_o: return 'o';
232 case SDLK_p: return 'p';
233 case SDLK_q: return 'q';
234 case SDLK_r: return 'r';
235 case SDLK_s: return 's';
236 case SDLK_t: return 't';
237 case SDLK_u: return 'u';
238 case SDLK_v: return 'v';
239 case SDLK_w: return 'w';
240 case SDLK_x: return 'x';
241 case SDLK_y: return 'y';
242 case SDLK_z: return 'z';
243 case SDLK_CAPSLOCK: return K_CAPSLOCK;
244 case SDLK_F1: return K_F1;
245 case SDLK_F2: return K_F2;
246 case SDLK_F3: return K_F3;
247 case SDLK_F4: return K_F4;
248 case SDLK_F5: return K_F5;
249 case SDLK_F6: return K_F6;
250 case SDLK_F7: return K_F7;
251 case SDLK_F8: return K_F8;
252 case SDLK_F9: return K_F9;
253 case SDLK_F10: return K_F10;
254 case SDLK_F11: return K_F11;
255 case SDLK_F12: return K_F12;
256 case SDLK_PRINTSCREEN: return K_PRINTSCREEN;
257 case SDLK_SCROLLLOCK: return K_SCROLLOCK;
258 case SDLK_PAUSE: return K_PAUSE;
259 case SDLK_INSERT: return K_INS;
260 case SDLK_HOME: return K_HOME;
261 case SDLK_PAGEUP: return K_PGUP;
263 case SDLK_DELETE: return K_BACKSPACE;
265 case SDLK_DELETE: return K_DEL;
267 case SDLK_END: return K_END;
268 case SDLK_PAGEDOWN: return K_PGDN;
269 case SDLK_RIGHT: return K_RIGHTARROW;
270 case SDLK_LEFT: return K_LEFTARROW;
271 case SDLK_DOWN: return K_DOWNARROW;
272 case SDLK_UP: return K_UPARROW;
273 case SDLK_NUMLOCKCLEAR: return K_NUMLOCK;
274 case SDLK_KP_DIVIDE: return K_KP_DIVIDE;
275 case SDLK_KP_MULTIPLY: return K_KP_MULTIPLY;
276 case SDLK_KP_MINUS: return K_KP_MINUS;
277 case SDLK_KP_PLUS: return K_KP_PLUS;
278 case SDLK_KP_ENTER: return K_KP_ENTER;
279 case SDLK_KP_1: return K_KP_1;
280 case SDLK_KP_2: return K_KP_2;
281 case SDLK_KP_3: return K_KP_3;
282 case SDLK_KP_4: return K_KP_4;
283 case SDLK_KP_5: return K_KP_5;
284 case SDLK_KP_6: return K_KP_6;
285 case SDLK_KP_7: return K_KP_7;
286 case SDLK_KP_8: return K_KP_8;
287 case SDLK_KP_9: return K_KP_9;
288 case SDLK_KP_0: return K_KP_0;
289 case SDLK_KP_PERIOD: return K_KP_PERIOD;
290 // case SDLK_APPLICATION: return K_APPLICATION;
291 // case SDLK_POWER: return K_POWER;
292 case SDLK_KP_EQUALS: return K_KP_EQUALS;
293 // case SDLK_F13: return K_F13;
294 // case SDLK_F14: return K_F14;
295 // case SDLK_F15: return K_F15;
296 // case SDLK_F16: return K_F16;
297 // case SDLK_F17: return K_F17;
298 // case SDLK_F18: return K_F18;
299 // case SDLK_F19: return K_F19;
300 // case SDLK_F20: return K_F20;
301 // case SDLK_F21: return K_F21;
302 // case SDLK_F22: return K_F22;
303 // case SDLK_F23: return K_F23;
304 // case SDLK_F24: return K_F24;
305 // case SDLK_EXECUTE: return K_EXECUTE;
306 // case SDLK_HELP: return K_HELP;
307 // case SDLK_MENU: return K_MENU;
308 // case SDLK_SELECT: return K_SELECT;
309 // case SDLK_STOP: return K_STOP;
310 // case SDLK_AGAIN: return K_AGAIN;
311 // case SDLK_UNDO: return K_UNDO;
312 // case SDLK_CUT: return K_CUT;
313 // case SDLK_COPY: return K_COPY;
314 // case SDLK_PASTE: return K_PASTE;
315 // case SDLK_FIND: return K_FIND;
316 // case SDLK_MUTE: return K_MUTE;
317 // case SDLK_VOLUMEUP: return K_VOLUMEUP;
318 // case SDLK_VOLUMEDOWN: return K_VOLUMEDOWN;
319 // case SDLK_KP_COMMA: return K_KP_COMMA;
320 // case SDLK_KP_EQUALSAS400: return K_KP_EQUALSAS400;
321 // case SDLK_ALTERASE: return K_ALTERASE;
322 // case SDLK_SYSREQ: return K_SYSREQ;
323 // case SDLK_CANCEL: return K_CANCEL;
324 // case SDLK_CLEAR: return K_CLEAR;
325 // case SDLK_PRIOR: return K_PRIOR;
326 // case SDLK_RETURN2: return K_RETURN2;
327 // case SDLK_SEPARATOR: return K_SEPARATOR;
328 // case SDLK_OUT: return K_OUT;
329 // case SDLK_OPER: return K_OPER;
330 // case SDLK_CLEARAGAIN: return K_CLEARAGAIN;
331 // case SDLK_CRSEL: return K_CRSEL;
332 // case SDLK_EXSEL: return K_EXSEL;
333 // case SDLK_KP_00: return K_KP_00;
334 // case SDLK_KP_000: return K_KP_000;
335 // case SDLK_THOUSANDSSEPARATOR: return K_THOUSANDSSEPARATOR;
336 // case SDLK_DECIMALSEPARATOR: return K_DECIMALSEPARATOR;
337 // case SDLK_CURRENCYUNIT: return K_CURRENCYUNIT;
338 // case SDLK_CURRENCYSUBUNIT: return K_CURRENCYSUBUNIT;
339 // case SDLK_KP_LEFTPAREN: return K_KP_LEFTPAREN;
340 // case SDLK_KP_RIGHTPAREN: return K_KP_RIGHTPAREN;
341 // case SDLK_KP_LEFTBRACE: return K_KP_LEFTBRACE;
342 // case SDLK_KP_RIGHTBRACE: return K_KP_RIGHTBRACE;
343 // case SDLK_KP_TAB: return K_KP_TAB;
344 // case SDLK_KP_BACKSPACE: return K_KP_BACKSPACE;
345 // case SDLK_KP_A: return K_KP_A;
346 // case SDLK_KP_B: return K_KP_B;
347 // case SDLK_KP_C: return K_KP_C;
348 // case SDLK_KP_D: return K_KP_D;
349 // case SDLK_KP_E: return K_KP_E;
350 // case SDLK_KP_F: return K_KP_F;
351 // case SDLK_KP_XOR: return K_KP_XOR;
352 // case SDLK_KP_POWER: return K_KP_POWER;
353 // case SDLK_KP_PERCENT: return K_KP_PERCENT;
354 // case SDLK_KP_LESS: return K_KP_LESS;
355 // case SDLK_KP_GREATER: return K_KP_GREATER;
356 // case SDLK_KP_AMPERSAND: return K_KP_AMPERSAND;
357 // case SDLK_KP_DBLAMPERSAND: return K_KP_DBLAMPERSAND;
358 // case SDLK_KP_VERTICALBAR: return K_KP_VERTICALBAR;
359 // case SDLK_KP_DBLVERTICALBAR: return K_KP_DBLVERTICALBAR;
360 // case SDLK_KP_COLON: return K_KP_COLON;
361 // case SDLK_KP_HASH: return K_KP_HASH;
362 // case SDLK_KP_SPACE: return K_KP_SPACE;
363 // case SDLK_KP_AT: return K_KP_AT;
364 // case SDLK_KP_EXCLAM: return K_KP_EXCLAM;
365 // case SDLK_KP_MEMSTORE: return K_KP_MEMSTORE;
366 // case SDLK_KP_MEMRECALL: return K_KP_MEMRECALL;
367 // case SDLK_KP_MEMCLEAR: return K_KP_MEMCLEAR;
368 // case SDLK_KP_MEMADD: return K_KP_MEMADD;
369 // case SDLK_KP_MEMSUBTRACT: return K_KP_MEMSUBTRACT;
370 // case SDLK_KP_MEMMULTIPLY: return K_KP_MEMMULTIPLY;
371 // case SDLK_KP_MEMDIVIDE: return K_KP_MEMDIVIDE;
372 // case SDLK_KP_PLUSMINUS: return K_KP_PLUSMINUS;
373 // case SDLK_KP_CLEAR: return K_KP_CLEAR;
374 // case SDLK_KP_CLEARENTRY: return K_KP_CLEARENTRY;
375 // case SDLK_KP_BINARY: return K_KP_BINARY;
376 // case SDLK_KP_OCTAL: return K_KP_OCTAL;
377 // case SDLK_KP_DECIMAL: return K_KP_DECIMAL;
378 // case SDLK_KP_HEXADECIMAL: return K_KP_HEXADECIMAL;
379 case SDLK_LCTRL: return K_CTRL;
380 case SDLK_LSHIFT: return K_SHIFT;
381 case SDLK_LALT: return K_ALT;
382 // case SDLK_LGUI: return K_LGUI;
383 case SDLK_RCTRL: return K_CTRL;
384 case SDLK_RSHIFT: return K_SHIFT;
385 case SDLK_RALT: return K_ALT;
386 // case SDLK_RGUI: return K_RGUI;
387 // case SDLK_MODE: return K_MODE;
388 // case SDLK_AUDIONEXT: return K_AUDIONEXT;
389 // case SDLK_AUDIOPREV: return K_AUDIOPREV;
390 // case SDLK_AUDIOSTOP: return K_AUDIOSTOP;
391 // case SDLK_AUDIOPLAY: return K_AUDIOPLAY;
392 // case SDLK_AUDIOMUTE: return K_AUDIOMUTE;
393 // case SDLK_MEDIASELECT: return K_MEDIASELECT;
394 // case SDLK_WWW: return K_WWW;
395 // case SDLK_MAIL: return K_MAIL;
396 // case SDLK_CALCULATOR: return K_CALCULATOR;
397 // case SDLK_COMPUTER: return K_COMPUTER;
398 // case SDLK_AC_SEARCH: return K_AC_SEARCH;
399 // case SDLK_AC_HOME: return K_AC_HOME;
400 // case SDLK_AC_BACK: return K_AC_BACK;
401 // case SDLK_AC_FORWARD: return K_AC_FORWARD;
402 // case SDLK_AC_STOP: return K_AC_STOP;
403 // case SDLK_AC_REFRESH: return K_AC_REFRESH;
404 // case SDLK_AC_BOOKMARKS: return K_AC_BOOKMARKS;
405 // case SDLK_BRIGHTNESSDOWN: return K_BRIGHTNESSDOWN;
406 // case SDLK_BRIGHTNESSUP: return K_BRIGHTNESSUP;
407 // case SDLK_DISPLAYSWITCH: return K_DISPLAYSWITCH;
408 // case SDLK_KBDILLUMTOGGLE: return K_KBDILLUMTOGGLE;
409 // case SDLK_KBDILLUMDOWN: return K_KBDILLUMDOWN;
410 // case SDLK_KBDILLUMUP: return K_KBDILLUMUP;
411 // case SDLK_EJECT: return K_EJECT;
412 // case SDLK_SLEEP: return K_SLEEP;
417 int SDL_iPhoneKeyboardShow(SDL_Window * window); // reveals the onscreen keyboard. Returns 0 on success and -1 on error.
418 int SDL_iPhoneKeyboardHide(SDL_Window * window); // hides the onscreen keyboard. Returns 0 on success and -1 on error.
419 SDL_bool SDL_iPhoneKeyboardIsShown(SDL_Window * window); // returns whether or not the onscreen keyboard is currently visible.
420 int SDL_iPhoneKeyboardToggle(SDL_Window * window); // toggles the visibility of the onscreen keyboard. Returns 0 on success and -1 on error.
423 void VID_ShowKeyboard(qboolean show)
428 if (!SDL_iPhoneKeyboardIsShown(window))
429 SDL_iPhoneKeyboardShow(window);
433 if (SDL_iPhoneKeyboardIsShown(window))
434 SDL_iPhoneKeyboardHide(window);
440 qboolean VID_ShowingKeyboard(void)
442 return SDL_iPhoneKeyboardIsShown(window);
446 void VID_SetMouse(qboolean fullscreengrab, qboolean relative, qboolean hidecursor)
451 if(vid_usingmouse && (vid_usingnoaccel != !!apple_mouse_noaccel.integer))
452 VID_SetMouse(false, false, false); // ungrab first!
454 if (vid_usingmouse != relative)
456 vid_usingmouse = relative;
457 cl_ignoremousemoves = 2;
459 SDL_WM_GrabInput( relative ? SDL_GRAB_ON : SDL_GRAB_OFF );
461 SDL_SetRelativeMouseMode(relative ? SDL_TRUE : SDL_FALSE);
466 // Save the status of mouse acceleration
467 originalMouseSpeed = -1.0; // in case of error
468 if(apple_mouse_noaccel.integer)
470 io_connect_t mouseDev = IN_GetIOHandle();
473 if(IOHIDGetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), &originalMouseSpeed) == kIOReturnSuccess)
475 Con_DPrintf("previous mouse acceleration: %f\n", originalMouseSpeed);
476 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), -1.0) != kIOReturnSuccess)
478 Con_Print("Could not disable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
479 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
484 Con_Print("Could not disable mouse acceleration (failed at IOHIDGetAccelerationWithKey).\n");
485 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
487 IOServiceClose(mouseDev);
491 Con_Print("Could not disable mouse acceleration (failed at IO_GetIOHandle).\n");
492 Cvar_SetValueQuick(&apple_mouse_noaccel, 0);
496 vid_usingnoaccel = !!apple_mouse_noaccel.integer;
500 if(originalMouseSpeed != -1.0)
502 io_connect_t mouseDev = IN_GetIOHandle();
505 Con_DPrintf("restoring mouse acceleration to: %f\n", originalMouseSpeed);
506 if(IOHIDSetAccelerationWithKey(mouseDev, CFSTR(kIOHIDMouseAccelerationType), originalMouseSpeed) != kIOReturnSuccess)
507 Con_Print("Could not re-enable mouse acceleration (failed at IOHIDSetAccelerationWithKey).\n");
508 IOServiceClose(mouseDev);
511 Con_Print("Could not re-enable mouse acceleration (failed at IO_GetIOHandle).\n");
516 if (vid_usinghidecursor != hidecursor)
518 vid_usinghidecursor = hidecursor;
519 SDL_ShowCursor( hidecursor ? SDL_DISABLE : SDL_ENABLE);
524 static double IN_JoystickGetAxis(SDL_Joystick *joy, int axis, double sensitivity, double deadzone)
527 if (axis < 0 || axis >= SDL_JoystickNumAxes(joy))
528 return 0; // no such axis on this joystick
529 value = SDL_JoystickGetAxis(joy, axis) * (1.0 / 32767.0);
530 value = bound(-1, value, 1);
531 if (fabs(value) < deadzone)
532 return 0; // within deadzone around center
533 return value * sensitivity;
536 /////////////////////
537 // Joystick axis keyevents
538 // a sort of hack emulating Arrow keys for joystick axises
539 // as some drives dont send such keyevents for them
540 // additionally we should block drivers that do send arrow keyevents to prevent double events
543 static void IN_JoystickKeyeventForAxis(SDL_Joystick *joy, int axis, int key_pos, int key_neg)
547 if (axis < 0 || axis >= SDL_JoystickNumAxes(joy))
548 return; // no such axis on this joystick
550 joytime = Sys_DoubleTime();
551 // no key event, continuous keydown event
552 if (joy_axescache[axis].move == joy_axescache[axis].oldmove)
554 if (joy_axescache[axis].move != 0 && joytime > joy_axescache[axis].keytime)
556 //Con_Printf("joy %s %i %f\n", Key_KeynumToString((joy_axescache[axis].move > 0) ? key_pos : key_neg), 1, cl.time);
557 Key_Event((joy_axescache[axis].move > 0) ? key_pos : key_neg, 0, 1);
558 joy_axescache[axis].keytime = joytime + 0.5 / 20;
562 // generate key up event
563 if (joy_axescache[axis].oldmove)
565 //Con_Printf("joy %s %i %f\n", Key_KeynumToString((joy_axescache[axis].oldmove > 0) ? key_pos : key_neg), 1, cl.time);
566 Key_Event((joy_axescache[axis].oldmove > 0) ? key_pos : key_neg, 0, 0);
568 // generate key down event
569 if (joy_axescache[axis].move)
571 //Con_Printf("joy %s %i %f\n", Key_KeynumToString((joy_axescache[axis].move > 0) ? key_pos : key_neg), 1, cl.time);
572 Key_Event((joy_axescache[axis].move > 0) ? key_pos : key_neg, 0, 1);
573 joy_axescache[axis].keytime = joytime + 0.5;
577 static qboolean IN_JoystickBlockDoubledKeyEvents(int keycode)
579 if (!joy_axiskeyevents.integer)
582 // block keyevent if it's going to be provided by joystick keyevent system
583 if (vid_numjoysticks && joy_enable.integer && joy_index.integer >= 0 && joy_index.integer < vid_numjoysticks)
585 SDL_Joystick *joy = vid_joysticks[joy_index.integer];
587 if (keycode == K_UPARROW || keycode == K_DOWNARROW)
588 if (IN_JoystickGetAxis(joy, joy_axisforward.integer, 1, joy_axiskeyevents_deadzone.value) || joy_axescache[joy_axisforward.integer].move || joy_axescache[joy_axisforward.integer].oldmove)
590 if (keycode == K_RIGHTARROW || keycode == K_LEFTARROW)
591 if (IN_JoystickGetAxis(joy, joy_axisside.integer, 1, joy_axiskeyevents_deadzone.value) || joy_axescache[joy_axisside.integer].move || joy_axescache[joy_axisside.integer].oldmove)
598 // multitouch[10][] represents the mouse pointer
599 // X and Y coordinates are 0-32767 as per SDL spec
600 #define MAXFINGERS 11
601 int multitouch[MAXFINGERS][3];
603 qboolean VID_TouchscreenArea(int corner, float px, float py, float pwidth, float pheight, const char *icon, float *resultmove, qboolean *resultbutton, keynum_t key)
606 float fx, fy, fwidth, fheight;
608 qboolean button = false;
610 if (pwidth > 0 && pheight > 0)
612 if (!VID_ShowingKeyboard())
615 if (corner & 1) px += vid_conwidth.value;
616 if (corner & 2) py += vid_conheight.value;
617 if (corner & 4) px += vid_conwidth.value * 0.5f;
618 if (corner & 8) py += vid_conheight.value * 0.5f;
619 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);}
620 fx = px * 32768.0f / vid_conwidth.value;
621 fy = py * 32768.0f / vid_conheight.value;
622 fwidth = pwidth * 32768.0f / vid_conwidth.value;
623 fheight = pheight * 32768.0f / vid_conheight.value;
624 for (finger = 0;finger < MAXFINGERS;finger++)
626 if (multitouch[finger][0] && multitouch[finger][1] >= fx && multitouch[finger][2] >= fy && multitouch[finger][1] < fx + fwidth && multitouch[finger][2] < fy + fheight)
628 rel[0] = (multitouch[finger][1] - (fx + 0.5f * fwidth)) * (2.0f / fwidth);
629 rel[1] = (multitouch[finger][2] - (fy + 0.5f * fheight)) * (2.0f / fheight);
635 if (scr_numtouchscreenareas < 16)
637 scr_touchscreenareas[scr_numtouchscreenareas].pic = icon;
638 scr_touchscreenareas[scr_numtouchscreenareas].rect[0] = px;
639 scr_touchscreenareas[scr_numtouchscreenareas].rect[1] = py;
640 scr_touchscreenareas[scr_numtouchscreenareas].rect[2] = pwidth;
641 scr_touchscreenareas[scr_numtouchscreenareas].rect[3] = pheight;
642 scr_touchscreenareas[scr_numtouchscreenareas].active = button;
643 scr_numtouchscreenareas++;
649 VectorCopy(rel, resultmove);
651 VectorClear(resultmove);
655 if (*resultbutton != button && (int)key > 0)
656 Key_Event(key, 0, button);
657 *resultbutton = button;
662 /////////////////////
669 static int old_x = 0, old_y = 0;
670 static int stuck = 0;
671 int x, y, numaxes, numballs;
673 scr_numtouchscreenareas = 0;
674 if (vid_touchscreen.integer)
676 vec3_t move, aim, click;
677 static qboolean buttons[16];
678 static keydest_t oldkeydest;
679 keydest_t keydest = (key_consoleactive & KEY_CONSOLEACTIVE_USER) ? key_console : key_dest;
680 multitouch[MAXFINGERS-1][0] = SDL_GetMouseState(&x, &y);
681 multitouch[MAXFINGERS-1][1] = x * 32768 / vid.width;
682 multitouch[MAXFINGERS-1][2] = y * 32768 / vid.height;
683 if (oldkeydest != keydest)
687 case key_game: VID_ShowKeyboard(false);break;
688 case key_console: VID_ShowKeyboard(true);break;
689 case key_message: VID_ShowKeyboard(true);break;
693 oldkeydest = keydest;
694 // top of screen is toggleconsole and K_ESCAPE
699 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
700 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
701 if (!VID_ShowingKeyboard())
703 // user entered a command, close the console now
704 Con_ToggleConsole_f();
707 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
708 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
709 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
710 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
711 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
712 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
716 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
717 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
719 VID_TouchscreenArea( 2, 0,-128, 128, 128, "gfx/touch_movebutton.tga" , move, &buttons[0], K_MOUSE4);
720 VID_TouchscreenArea( 3,-128,-128, 128, 128, "gfx/touch_aimbutton.tga" , aim, &buttons[1], K_MOUSE5);
721 VID_TouchscreenArea( 2, 0,-160, 64, 32, "gfx/touch_jumpbutton.tga" , NULL, &buttons[3], K_SPACE);
722 VID_TouchscreenArea( 3,-128,-160, 64, 32, "gfx/touch_attackbutton.tga" , NULL, &buttons[2], K_MOUSE1);
723 VID_TouchscreenArea( 3, -64,-160, 64, 32, "gfx/touch_attack2button.tga", NULL, &buttons[4], K_MOUSE2);
728 VID_TouchscreenArea( 0, 0, 0, 64, 64, NULL , NULL, &buttons[13], (keynum_t)'`');
729 VID_TouchscreenArea( 0, 64, 0, 64, 64, "gfx/touch_menu.tga" , NULL, &buttons[14], K_ESCAPE);
730 // in menus, an icon in the corner activates keyboard
731 VID_TouchscreenArea( 2, 0, -32, 32, 32, "gfx/touch_keyboard.tga" , NULL, &buttons[15], (keynum_t)0);
733 VID_ShowKeyboard(true);
734 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
735 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
736 VID_TouchscreenArea(16, -320,-480,640, 960, NULL , click,&buttons[2], K_MOUSE1);
737 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
738 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
741 in_windowmouse_x = x;
742 in_windowmouse_y = y;
745 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[15], (keynum_t)0);
746 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , move, &buttons[0], K_MOUSE4);
747 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , aim, &buttons[1], K_MOUSE5);
748 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , click,&buttons[2], K_MOUSE1);
749 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[3], K_SPACE);
750 VID_TouchscreenArea( 0, 0, 0, 0, 0, NULL , NULL, &buttons[4], K_MOUSE2);
754 cl.cmd.forwardmove -= move[1] * cl_forwardspeed.value;
755 cl.cmd.sidemove += move[0] * cl_sidespeed.value;
756 cl.viewangles[0] += aim[1] * cl_pitchspeed.value * cl.realframetime;
757 cl.viewangles[1] -= aim[0] * cl_yawspeed.value * cl.realframetime;
763 if (vid_stick_mouse.integer)
765 // have the mouse stuck in the middle, example use: prevent expose effect of beryl during the game when not using
766 // window grabbing. --blub
768 // we need 2 frames to initialize the center position
772 SDL_WarpMouse(win_half_width, win_half_height);
774 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
776 SDL_GetMouseState(&x, &y);
777 SDL_GetRelativeMouseState(&x, &y);
780 SDL_GetRelativeMouseState(&x, &y);
781 in_mouse_x = x + old_x;
782 in_mouse_y = y + old_y;
783 SDL_GetMouseState(&x, &y);
784 old_x = x - win_half_width;
785 old_y = y - win_half_height;
787 SDL_WarpMouse(win_half_width, win_half_height);
789 SDL_WarpMouseInWindow(window, win_half_width, win_half_height);
793 SDL_GetRelativeMouseState( &x, &y );
799 SDL_GetMouseState(&x, &y);
800 in_windowmouse_x = x;
801 in_windowmouse_y = y;
804 if (vid_numjoysticks && joy_enable.integer && joy_index.integer >= 0 && joy_index.integer < vid_numjoysticks)
806 SDL_Joystick *joy = vid_joysticks[joy_index.integer];
808 // balls convert to mousemove
809 numballs = SDL_JoystickNumBalls(joy);
810 for (j = 0;j < numballs;j++)
812 SDL_JoystickGetBall(joy, j, &x, &y);
818 cl.cmd.forwardmove += IN_JoystickGetAxis(joy, joy_axisforward.integer, joy_sensitivityforward.value, joy_deadzoneforward.value) * cl_forwardspeed.value;
819 cl.cmd.sidemove += IN_JoystickGetAxis(joy, joy_axisside.integer, joy_sensitivityside.value, joy_deadzoneside.value) * cl_sidespeed.value;
820 cl.cmd.upmove += IN_JoystickGetAxis(joy, joy_axisup.integer, joy_sensitivityup.value, joy_deadzoneup.value) * cl_upspeed.value;
821 cl.viewangles[0] += IN_JoystickGetAxis(joy, joy_axispitch.integer, joy_sensitivitypitch.value, joy_deadzonepitch.value) * cl.realframetime * cl_pitchspeed.value;
822 cl.viewangles[1] += IN_JoystickGetAxis(joy, joy_axisyaw.integer, joy_sensitivityyaw.value, joy_deadzoneyaw.value) * cl.realframetime * cl_yawspeed.value;
823 //cl.viewangles[2] += IN_JoystickGetAxis(joy, joy_axisroll.integer, joy_sensitivityroll.value, joy_deadzoneroll.value) * cl.realframetime * cl_rollspeed.value;
825 // cache state of axes to emulate button events for them
826 numaxes = min(MAX_JOYSTICK_AXES, SDL_JoystickNumAxes(joy));
827 for (j = 0; j < numaxes; j++)
829 joy_axescache[j].oldmove = joy_axescache[j].move;
830 joy_axescache[j].move = IN_JoystickGetAxis(joy, j, 1, joy_axiskeyevents_deadzone.value);
834 if (joy_axiskeyevents.integer)
836 IN_JoystickKeyeventForAxis(joy, joy_axisforward.integer, K_DOWNARROW, K_UPARROW);
837 IN_JoystickKeyeventForAxis(joy, joy_axisside.integer, K_RIGHTARROW, K_LEFTARROW);
842 /////////////////////
847 static qboolean sdl_needs_restart;
848 static void sdl_start(void)
851 static void sdl_shutdown(void)
853 sdl_needs_restart = false;
855 static void sdl_newmap(void)
861 static keynum_t buttonremap[18] =
886 void Sys_SendKeyEvents( void )
888 static qboolean sound_active = true;
892 while( SDL_PollEvent( &event ) )
893 switch( event.type ) {
899 keycode = MapKey(event.key.keysym.sym);
900 if (!IN_JoystickBlockDoubledKeyEvents(keycode))
901 Key_Event(keycode, event.key.keysym.unicode, (event.key.state == SDL_PRESSED));
903 case SDL_ACTIVEEVENT:
904 if( event.active.state & SDL_APPACTIVE )
906 if( event.active.gain )
912 case SDL_MOUSEBUTTONDOWN:
913 case SDL_MOUSEBUTTONUP:
914 if (!vid_touchscreen.integer)
915 if (event.button.button <= 18)
916 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
918 case SDL_JOYBUTTONDOWN:
919 if (!joy_enable.integer)
920 break; // ignore down events if joystick has been disabled
921 case SDL_JOYBUTTONUP:
922 if (event.jbutton.button < 48)
923 Key_Event( event.jbutton.button + (event.jbutton.button < 16 ? K_JOY1 : K_AUX1 - 16), 0, (event.jbutton.state == SDL_PRESSED) );
925 case SDL_JOYAXISMOTION:
926 case SDL_JOYBALLMOTION:
927 case SDL_JOYHATMOTION:
929 case SDL_VIDEOEXPOSE:
931 case SDL_VIDEORESIZE:
932 if(vid_resizable.integer < 2)
934 vid.width = event.resize.w;
935 vid.height = event.resize.h;
936 screen = SDL_SetVideoMode(vid.width, vid.height, video_bpp, video_flags);
939 SDL_FreeSurface(vid_softsurface);
940 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
941 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
942 SDL_SetAlpha(vid_softsurface, 0, 255);
943 if (vid.softdepthpixels)
944 free(vid.softdepthpixels);
945 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
948 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
949 // so, let's better queue it for next frame
950 if(!sdl_needs_restart)
952 Cbuf_AddText("\nr_restart\n");
953 sdl_needs_restart = true;
958 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
960 case SDL_TEXTEDITING:
961 // unused when SETVIDEOMODE API is used
964 // this occurs with SETVIDEOMODE but we are not using it
967 case SDL_MOUSEMOTION:
970 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
974 // enable/disable sound on focus gain/loss
975 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
988 sound_active = false;
996 void Sys_SendKeyEvents( void )
998 static qboolean sound_active = true;
999 static qboolean missingunicodehack = true;
1006 while( SDL_PollEvent( &event ) )
1007 switch( event.type ) {
1013 keycode = MapKey(event.key.keysym.sym);
1014 if (!IN_JoystickBlockDoubledKeyEvents(keycode))
1016 // the virtual keyboard seems to produce no unicode values...
1017 if (missingunicodehack && keycode >= ' ' && keycode < 0x7F && event.key.keysym.unicode == 0)
1019 Con_DPrintf("SDL hack: no unicode value reported, substituting ascii value %i\n", keycode);
1020 Key_Event(keycode, keycode, (event.key.state == SDL_PRESSED));
1024 Key_Event(keycode, 0, (event.key.state == SDL_PRESSED));
1026 case SDL_MOUSEBUTTONDOWN:
1027 case SDL_MOUSEBUTTONUP:
1028 #ifndef __IPHONEOS__
1029 if (!vid_touchscreen.integer)
1030 if (event.button.button <= 18)
1031 Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
1034 case SDL_JOYBUTTONDOWN:
1035 if (!joy_enable.integer)
1036 break; // ignore down events if joystick has been disabled
1037 case SDL_JOYBUTTONUP:
1038 if (event.jbutton.button < 48)
1039 Key_Event( event.jbutton.button + (event.jbutton.button < 16 ? K_JOY1 : K_AUX1 - 16), 0, (event.jbutton.state == SDL_PRESSED) );
1041 case SDL_JOYAXISMOTION:
1042 case SDL_JOYBALLMOTION:
1043 case SDL_JOYHATMOTION:
1045 case SDL_VIDEOEXPOSE:
1047 case SDL_WINDOWEVENT:
1048 //if (event.window.windowID == window) // how to compare?
1050 switch(event.window.event)
1052 case SDL_WINDOWEVENT_SHOWN:
1055 case SDL_WINDOWEVENT_HIDDEN:
1058 case SDL_WINDOWEVENT_EXPOSED:
1060 case SDL_WINDOWEVENT_MOVED:
1062 case SDL_WINDOWEVENT_RESIZED:
1063 if(vid_resizable.integer < 2)
1065 vid.width = event.window.data1;
1066 vid.height = event.window.data2;
1067 if (vid_softsurface)
1069 SDL_FreeSurface(vid_softsurface);
1070 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
1071 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
1072 SDL_SetAlpha(vid_softsurface, 0, 255);
1073 if (vid.softdepthpixels)
1074 free(vid.softdepthpixels);
1075 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
1077 #ifdef SDL_R_RESTART
1078 // better not call R_Modules_Restart from here directly, as this may wreak havoc...
1079 // so, let's better queue it for next frame
1080 if(!sdl_needs_restart)
1082 Cbuf_AddText("\nr_restart\n");
1083 sdl_needs_restart = true;
1088 case SDL_WINDOWEVENT_MINIMIZED:
1090 case SDL_WINDOWEVENT_MAXIMIZED:
1092 case SDL_WINDOWEVENT_RESTORED:
1094 case SDL_WINDOWEVENT_ENTER:
1096 case SDL_WINDOWEVENT_LEAVE:
1098 case SDL_WINDOWEVENT_FOCUS_GAINED:
1099 vid_hasfocus = true;
1101 case SDL_WINDOWEVENT_FOCUS_LOST:
1102 vid_hasfocus = false;
1104 case SDL_WINDOWEVENT_CLOSE:
1110 case SDL_TEXTEDITING:
1111 // FIXME! this is where composition gets supported
1114 // we have some characters to parse
1115 missingunicodehack = false;
1118 for (i = 0;event.text.text[i];)
1120 unicode = event.text.text[i++];
1124 // strip high bits (we could count these to validate character length but we don't)
1125 for (j = 0x80;unicode & j;j >>= 1)
1127 for (;(event.text.text[i] & 0xC0) == 0x80;i++)
1128 unicode = (unicode << 6) | (event.text.text[i] & 0x3F);
1129 // low characters are invalid and could be bad, so replace them
1131 unicode = '?'; // we could use 0xFFFD instead, the unicode substitute character
1133 //Con_DPrintf("SDL_TEXTINPUT: K_TEXT %i \n", unicode);
1134 Key_Event(K_TEXT, unicode, true);
1135 Key_Event(K_TEXT, unicode, false);
1139 case SDL_MOUSEMOTION:
1141 case SDL_FINGERDOWN:
1142 Con_DPrintf("SDL_FINGERDOWN for finger %i\n", (int)event.tfinger.fingerId);
1143 for (i = 0;i < MAXFINGERS-1;i++)
1145 if (!multitouch[i][0])
1147 multitouch[i][0] = event.tfinger.fingerId;
1148 multitouch[i][1] = event.tfinger.x;
1149 multitouch[i][2] = event.tfinger.y;
1150 // TODO: use event.tfinger.pressure?
1154 if (i == MAXFINGERS-1)
1155 Con_DPrintf("Too many fingers at once!\n");
1158 Con_DPrintf("SDL_FINGERUP 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][0] = 0;
1167 if (i == MAXFINGERS-1)
1168 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1170 case SDL_FINGERMOTION:
1171 Con_DPrintf("SDL_FINGERMOTION for finger %i\n", (int)event.tfinger.fingerId);
1172 for (i = 0;i < MAXFINGERS-1;i++)
1174 if (multitouch[i][0] == event.tfinger.fingerId)
1176 multitouch[i][1] = event.tfinger.x;
1177 multitouch[i][2] = event.tfinger.y;
1181 if (i == MAXFINGERS-1)
1182 Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1184 case SDL_TOUCHBUTTONDOWN:
1185 // not sure what to do with this...
1187 case SDL_TOUCHBUTTONUP:
1188 // not sure what to do with this...
1190 case SDL_JOYAXISMOTION:
1191 // we poll the joystick instead
1193 case SDL_JOYBALLMOTION:
1194 // we poll the joystick instead
1196 case SDL_JOYHATMOTION:
1197 // we poll the joystick instead
1200 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
1204 // enable/disable sound on focus gain/loss
1205 if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
1210 sound_active = true;
1218 sound_active = false;
1229 //#include <SDL_opengles.h>
1230 #include <OpenGLES/ES2/gl.h>
1232 GLboolean wrapglIsBuffer(GLuint buffer) {return glIsBuffer(buffer);}
1233 GLboolean wrapglIsEnabled(GLenum cap) {return glIsEnabled(cap);}
1234 GLboolean wrapglIsFramebuffer(GLuint framebuffer) {return glIsFramebuffer(framebuffer);}
1235 //GLboolean wrapglIsQuery(GLuint qid) {return glIsQuery(qid);}
1236 GLboolean wrapglIsRenderbuffer(GLuint renderbuffer) {return glIsRenderbuffer(renderbuffer);}
1237 //GLboolean wrapglUnmapBuffer(GLenum target) {return glUnmapBuffer(target);}
1238 GLenum wrapglCheckFramebufferStatus(GLenum target) {return glCheckFramebufferStatus(target);}
1239 GLenum wrapglGetError(void) {return glGetError();}
1240 GLuint wrapglCreateProgram(void) {return glCreateProgram();}
1241 GLuint wrapglCreateShader(GLenum shaderType) {return glCreateShader(shaderType);}
1242 //GLuint wrapglGetHandle(GLenum pname) {return glGetHandle(pname);}
1243 GLint wrapglGetAttribLocation(GLuint programObj, const GLchar *name) {return glGetAttribLocation(programObj, name);}
1244 GLint wrapglGetUniformLocation(GLuint programObj, const GLchar *name) {return glGetUniformLocation(programObj, name);}
1245 //GLvoid* wrapglMapBuffer(GLenum target, GLenum access) {return glMapBuffer(target, access);}
1246 const GLubyte* wrapglGetString(GLenum name) {return glGetString(name);}
1247 void wrapglActiveStencilFace(GLenum e) {Con_Printf("glActiveStencilFace(e)\n");}
1248 void wrapglActiveTexture(GLenum e) {glActiveTexture(e);}
1249 void wrapglAlphaFunc(GLenum func, GLclampf ref) {Con_Printf("glAlphaFunc(func, ref)\n");}
1250 void wrapglArrayElement(GLint i) {Con_Printf("glArrayElement(i)\n");}
1251 void wrapglAttachShader(GLuint containerObj, GLuint obj) {glAttachShader(containerObj, obj);}
1252 void wrapglBegin(GLenum mode) {Con_Printf("glBegin(mode)\n");}
1253 //void wrapglBeginQuery(GLenum target, GLuint qid) {glBeginQuery(target, qid);}
1254 void wrapglBindAttribLocation(GLuint programObj, GLuint index, const GLchar *name) {glBindAttribLocation(programObj, index, name);}
1255 void wrapglBindFragDataLocation(GLuint programObj, GLuint index, const GLchar *name) {glBindFragDataLocation(programObj, index, name);}
1256 void wrapglBindBuffer(GLenum target, GLuint buffer) {glBindBuffer(target, buffer);}
1257 void wrapglBindFramebuffer(GLenum target, GLuint framebuffer) {glBindFramebuffer(target, framebuffer);}
1258 void wrapglBindRenderbuffer(GLenum target, GLuint renderbuffer) {glBindRenderbuffer(target, renderbuffer);}
1259 void wrapglBindTexture(GLenum target, GLuint texture) {glBindTexture(target, texture);}
1260 void wrapglBlendEquation(GLenum e) {glBlendEquation(e);}
1261 void wrapglBlendFunc(GLenum sfactor, GLenum dfactor) {glBlendFunc(sfactor, dfactor);}
1262 void wrapglBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) {glBufferData(target, size, data, usage);}
1263 void wrapglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) {glBufferSubData(target, offset, size, data);}
1264 void wrapglClear(GLbitfield mask) {glClear(mask);}
1265 void wrapglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {glClearColor(red, green, blue, alpha);}
1266 void wrapglClearDepth(GLclampd depth) {glClearDepthf((float)depth);}
1267 void wrapglClearStencil(GLint s) {glClearStencil(s);}
1268 void wrapglClientActiveTexture(GLenum target) {Con_Printf("glClientActiveTexture(target)\n");}
1269 void wrapglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {Con_Printf("glColor4f(red, green, blue, alpha)\n");}
1270 void wrapglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {Con_Printf("glColor4ub(red, green, blue, alpha)\n");}
1271 void wrapglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {glColorMask(red, green, blue, alpha);}
1272 void wrapglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glColorPointer(size, type, stride, ptr)\n");}
1273 void wrapglCompileShader(GLuint shaderObj) {glCompileShader(shaderObj);}
1274 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);}
1275 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");}
1276 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);}
1277 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");}
1278 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);}
1279 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);}
1280 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");}
1281 void wrapglCullFace(GLenum mode) {glCullFace(mode);}
1282 void wrapglDeleteBuffers(GLsizei n, const GLuint *buffers) {glDeleteBuffers(n, buffers);}
1283 void wrapglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {glDeleteFramebuffers(n, framebuffers);}
1284 void wrapglDeleteShader(GLuint obj) {glDeleteShader(obj);}
1285 void wrapglDeleteProgram(GLuint obj) {glDeleteProgram(obj);}
1286 //void wrapglDeleteQueries(GLsizei n, const GLuint *ids) {glDeleteQueries(n, ids);}
1287 void wrapglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {glDeleteRenderbuffers(n, renderbuffers);}
1288 void wrapglDeleteTextures(GLsizei n, const GLuint *textures) {glDeleteTextures(n, textures);}
1289 void wrapglDepthFunc(GLenum func) {glDepthFunc(func);}
1290 void wrapglDepthMask(GLboolean flag) {glDepthMask(flag);}
1291 void wrapglDepthRange(GLclampd near_val, GLclampd far_val) {glDepthRangef((float)near_val, (float)far_val);}
1292 void wrapglDetachShader(GLuint containerObj, GLuint attachedObj) {glDetachShader(containerObj, attachedObj);}
1293 void wrapglDisable(GLenum cap) {glDisable(cap);}
1294 void wrapglDisableClientState(GLenum cap) {Con_Printf("glDisableClientState(cap)\n");}
1295 void wrapglDisableVertexAttribArray(GLuint index) {glDisableVertexAttribArray(index);}
1296 void wrapglDrawArrays(GLenum mode, GLint first, GLsizei count) {glDrawArrays(mode, first, count);}
1297 void wrapglDrawBuffer(GLenum mode) {Con_Printf("glDrawBuffer(mode)\n");}
1298 void wrapglDrawBuffers(GLsizei n, const GLenum *bufs) {Con_Printf("glDrawBuffers(n, bufs)\n");}
1299 void wrapglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {glDrawElements(mode, count, type, indices);}
1300 //void wrapglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {glDrawRangeElements(mode, start, end, count, type, indices);}
1301 //void wrapglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {glDrawRangeElements(mode, start, end, count, type, indices);}
1302 void wrapglEnable(GLenum cap) {glEnable(cap);}
1303 void wrapglEnableClientState(GLenum cap) {Con_Printf("glEnableClientState(cap)\n");}
1304 void wrapglEnableVertexAttribArray(GLuint index) {glEnableVertexAttribArray(index);}
1305 void wrapglEnd(void) {Con_Printf("glEnd()\n");}
1306 //void wrapglEndQuery(GLenum target) {glEndQuery(target);}
1307 void wrapglFinish(void) {glFinish();}
1308 void wrapglFlush(void) {glFlush();}
1309 void wrapglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);}
1310 void wrapglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {glFramebufferTexture2D(target, attachment, textarget, texture, level);}
1311 void wrapglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {Con_Printf("glFramebufferTexture3D()\n");}
1312 void wrapglGenBuffers(GLsizei n, GLuint *buffers) {glGenBuffers(n, buffers);}
1313 void wrapglGenFramebuffers(GLsizei n, GLuint *framebuffers) {glGenFramebuffers(n, framebuffers);}
1314 //void wrapglGenQueries(GLsizei n, GLuint *ids) {glGenQueries(n, ids);}
1315 void wrapglGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {glGenRenderbuffers(n, renderbuffers);}
1316 void wrapglGenTextures(GLsizei n, GLuint *textures) {glGenTextures(n, textures);}
1317 void wrapglGenerateMipmap(GLenum target) {glGenerateMipmap(target);}
1318 void wrapglGetActiveAttrib(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {glGetActiveAttrib(programObj, index, maxLength, length, size, type, name);}
1319 void wrapglGetActiveUniform(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {glGetActiveUniform(programObj, index, maxLength, length, size, type, name);}
1320 void wrapglGetAttachedShaders(GLuint containerObj, GLsizei maxCount, GLsizei *count, GLuint *obj) {glGetAttachedShaders(containerObj, maxCount, count, obj);}
1321 void wrapglGetBooleanv(GLenum pname, GLboolean *params) {glGetBooleanv(pname, params);}
1322 void wrapglGetCompressedTexImage(GLenum target, GLint lod, void *img) {Con_Printf("glGetCompressedTexImage(target, lod, img)\n");}
1323 void wrapglGetDoublev(GLenum pname, GLdouble *params) {Con_Printf("glGetDoublev(pname, params)\n");}
1324 void wrapglGetFloatv(GLenum pname, GLfloat *params) {glGetFloatv(pname, params);}
1325 void wrapglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) {glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);}
1326 void wrapglGetShaderInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {glGetShaderInfoLog(obj, maxLength, length, infoLog);}
1327 void wrapglGetProgramInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {glGetProgramInfoLog(obj, maxLength, length, infoLog);}
1328 void wrapglGetIntegerv(GLenum pname, GLint *params) {glGetIntegerv(pname, params);}
1329 void wrapglGetShaderiv(GLuint obj, GLenum pname, GLint *params) {glGetShaderiv(obj, pname, params);}
1330 void wrapglGetProgramiv(GLuint obj, GLenum pname, GLint *params) {glGetProgramiv(obj, pname, params);}
1331 //void wrapglGetQueryObjectiv(GLuint qid, GLenum pname, GLint *params) {glGetQueryObjectiv(qid, pname, params);}
1332 //void wrapglGetQueryObjectuiv(GLuint qid, GLenum pname, GLuint *params) {glGetQueryObjectuiv(qid, pname, params);}
1333 //void wrapglGetQueryiv(GLenum target, GLenum pname, GLint *params) {glGetQueryiv(target, pname, params);}
1334 void wrapglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) {glGetRenderbufferParameteriv(target, pname, params);}
1335 void wrapglGetShaderSource(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *source) {glGetShaderSource(obj, maxLength, length, source);}
1336 void wrapglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {Con_Printf("glGetTexImage(target, level, format, type, pixels)\n");}
1337 void wrapglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {Con_Printf("glGetTexLevelParameterfv(target, level, pname, params)\n");}
1338 void wrapglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {Con_Printf("glGetTexLevelParameteriv(target, level, pname, params)\n");}
1339 void wrapglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {glGetTexParameterfv(target, pname, params);}
1340 void wrapglGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {glGetTexParameteriv(target, pname, params);}
1341 void wrapglGetUniformfv(GLuint programObj, GLint location, GLfloat *params) {glGetUniformfv(programObj, location, params);}
1342 void wrapglGetUniformiv(GLuint programObj, GLint location, GLint *params) {glGetUniformiv(programObj, location, params);}
1343 void wrapglHint(GLenum target, GLenum mode) {glHint(target, mode);}
1344 void wrapglLineWidth(GLfloat width) {glLineWidth(width);}
1345 void wrapglLinkProgram(GLuint programObj) {glLinkProgram(programObj);}
1346 void wrapglLoadIdentity(void) {Con_Printf("glLoadIdentity()\n");}
1347 void wrapglLoadMatrixf(const GLfloat *m) {Con_Printf("glLoadMatrixf(m)\n");}
1348 void wrapglMatrixMode(GLenum mode) {Con_Printf("glMatrixMode(mode)\n");}
1349 void wrapglMultiTexCoord1f(GLenum target, GLfloat s) {Con_Printf("glMultiTexCoord1f(target, s)\n");}
1350 void wrapglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {Con_Printf("glMultiTexCoord2f(target, s, t)\n");}
1351 void wrapglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {Con_Printf("glMultiTexCoord3f(target, s, t, r)\n");}
1352 void wrapglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {Con_Printf("glMultiTexCoord4f(target, s, t, r, q)\n");}
1353 void wrapglNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glNormalPointer(type, stride, ptr)\n");}
1354 void wrapglPixelStorei(GLenum pname, GLint param) {glPixelStorei(pname, param);}
1355 void wrapglPointSize(GLfloat size) {Con_Printf("glPointSize(size)\n");}
1356 void wrapglPolygonMode(GLenum face, GLenum mode) {Con_Printf("glPolygonMode(face, mode)\n");}
1357 void wrapglPolygonOffset(GLfloat factor, GLfloat units) {glPolygonOffset(factor, units);}
1358 void wrapglPolygonStipple(const GLubyte *mask) {Con_Printf("glPolygonStipple(mask)\n");}
1359 void wrapglReadBuffer(GLenum mode) {Con_Printf("glReadBuffer(mode)\n");}
1360 void wrapglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {glReadPixels(x, y, width, height, format, type, pixels);}
1361 void wrapglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {glRenderbufferStorage(target, internalformat, width, height);}
1362 void wrapglScissor(GLint x, GLint y, GLsizei width, GLsizei height) {glScissor(x, y, width, height);}
1363 void wrapglShaderSource(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length) {glShaderSource(shaderObj, count, string, length);}
1364 void wrapglStencilFunc(GLenum func, GLint ref, GLuint mask) {glStencilFunc(func, ref, mask);}
1365 void wrapglStencilFuncSeparate(GLenum func1, GLenum func2, GLint ref, GLuint mask) {Con_Printf("glStencilFuncSeparate(func1, func2, ref, mask)\n");}
1366 void wrapglStencilMask(GLuint mask) {glStencilMask(mask);}
1367 void wrapglStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {glStencilOp(fail, zfail, zpass);}
1368 void wrapglStencilOpSeparate(GLenum e1, GLenum e2, GLenum e3, GLenum e4) {Con_Printf("glStencilOpSeparate(e1, e2, e3, e4)\n");}
1369 void wrapglTexCoord1f(GLfloat s) {Con_Printf("glTexCoord1f(s)\n");}
1370 void wrapglTexCoord2f(GLfloat s, GLfloat t) {Con_Printf("glTexCoord2f(s, t)\n");}
1371 void wrapglTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {Con_Printf("glTexCoord3f(s, t, r)\n");}
1372 void wrapglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {Con_Printf("glTexCoord4f(s, t, r, q)\n");}
1373 void wrapglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glTexCoordPointer(size, type, stride, ptr)\n");}
1374 void wrapglTexEnvf(GLenum target, GLenum pname, GLfloat param) {Con_Printf("glTexEnvf(target, pname, param)\n");}
1375 void wrapglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {Con_Printf("glTexEnvfv(target, pname, params)\n");}
1376 void wrapglTexEnvi(GLenum target, GLenum pname, GLint param) {Con_Printf("glTexEnvi(target, pname, param)\n");}
1377 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);}
1378 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");}
1379 void wrapglTexParameterf(GLenum target, GLenum pname, GLfloat param) {glTexParameterf(target, pname, param);}
1380 void wrapglTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {glTexParameterfv(target, pname, params);}
1381 void wrapglTexParameteri(GLenum target, GLenum pname, GLint param) {glTexParameteri(target, pname, param);}
1382 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);}
1383 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");}
1384 void wrapglUniform1f(GLint location, GLfloat v0) {glUniform1f(location, v0);}
1385 void wrapglUniform1fv(GLint location, GLsizei count, const GLfloat *value) {glUniform1fv(location, count, value);}
1386 void wrapglUniform1i(GLint location, GLint v0) {glUniform1i(location, v0);}
1387 void wrapglUniform1iv(GLint location, GLsizei count, const GLint *value) {glUniform1iv(location, count, value);}
1388 void wrapglUniform2f(GLint location, GLfloat v0, GLfloat v1) {glUniform2f(location, v0, v1);}
1389 void wrapglUniform2fv(GLint location, GLsizei count, const GLfloat *value) {glUniform2fv(location, count, value);}
1390 void wrapglUniform2i(GLint location, GLint v0, GLint v1) {glUniform2i(location, v0, v1);}
1391 void wrapglUniform2iv(GLint location, GLsizei count, const GLint *value) {glUniform2iv(location, count, value);}
1392 void wrapglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {glUniform3f(location, v0, v1, v2);}
1393 void wrapglUniform3fv(GLint location, GLsizei count, const GLfloat *value) {glUniform3fv(location, count, value);}
1394 void wrapglUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {glUniform3i(location, v0, v1, v2);}
1395 void wrapglUniform3iv(GLint location, GLsizei count, const GLint *value) {glUniform3iv(location, count, value);}
1396 void wrapglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {glUniform4f(location, v0, v1, v2, v3);}
1397 void wrapglUniform4fv(GLint location, GLsizei count, const GLfloat *value) {glUniform4fv(location, count, value);}
1398 void wrapglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {glUniform4i(location, v0, v1, v2, v3);}
1399 void wrapglUniform4iv(GLint location, GLsizei count, const GLint *value) {glUniform4iv(location, count, value);}
1400 void wrapglUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix2fv(location, count, transpose, value);}
1401 void wrapglUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix3fv(location, count, transpose, value);}
1402 void wrapglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix4fv(location, count, transpose, value);}
1403 void wrapglUseProgram(GLuint programObj) {glUseProgram(programObj);}
1404 void wrapglValidateProgram(GLuint programObj) {glValidateProgram(programObj);}
1405 void wrapglVertex2f(GLfloat x, GLfloat y) {Con_Printf("glVertex2f(x, y)\n");}
1406 void wrapglVertex3f(GLfloat x, GLfloat y, GLfloat z) {Con_Printf("glVertex3f(x, y, z)\n");}
1407 void wrapglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {Con_Printf("glVertex4f(x, y, z, w)\n");}
1408 void wrapglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {glVertexAttribPointer(index, size, type, normalized, stride, pointer);}
1409 void wrapglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glVertexPointer(size, type, stride, ptr)\n");}
1410 void wrapglViewport(GLint x, GLint y, GLsizei width, GLsizei height) {glViewport(x, y, width, height);}
1411 void wrapglVertexAttrib1f(GLuint index, GLfloat v0) {glVertexAttrib1f(index, v0);}
1412 //void wrapglVertexAttrib1s(GLuint index, GLshort v0) {glVertexAttrib1s(index, v0);}
1413 //void wrapglVertexAttrib1d(GLuint index, GLdouble v0) {glVertexAttrib1d(index, v0);}
1414 void wrapglVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {glVertexAttrib2f(index, v0, v1);}
1415 //void wrapglVertexAttrib2s(GLuint index, GLshort v0, GLshort v1) {glVertexAttrib2s(index, v0, v1);}
1416 //void wrapglVertexAttrib2d(GLuint index, GLdouble v0, GLdouble v1) {glVertexAttrib2d(index, v0, v1);}
1417 void wrapglVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {glVertexAttrib3f(index, v0, v1, v2);}
1418 //void wrapglVertexAttrib3s(GLuint index, GLshort v0, GLshort v1, GLshort v2) {glVertexAttrib3s(index, v0, v1, v2);}
1419 //void wrapglVertexAttrib3d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2) {glVertexAttrib3d(index, v0, v1, v2);}
1420 void wrapglVertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {glVertexAttrib4f(index, v0, v1, v2, v3);}
1421 //void wrapglVertexAttrib4s(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3) {glVertexAttrib4s(index, v0, v1, v2, v3);}
1422 //void wrapglVertexAttrib4d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {glVertexAttrib4d(index, v0, v1, v2, v3);}
1423 //void wrapglVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {glVertexAttrib4Nub(index, x, y, z, w);}
1424 void wrapglVertexAttrib1fv(GLuint index, const GLfloat *v) {glVertexAttrib1fv(index, v);}
1425 //void wrapglVertexAttrib1sv(GLuint index, const GLshort *v) {glVertexAttrib1sv(index, v);}
1426 //void wrapglVertexAttrib1dv(GLuint index, const GLdouble *v) {glVertexAttrib1dv(index, v);}
1427 void wrapglVertexAttrib2fv(GLuint index, const GLfloat *v) {glVertexAttrib2fv(index, v);}
1428 //void wrapglVertexAttrib2sv(GLuint index, const GLshort *v) {glVertexAttrib2sv(index, v);}
1429 //void wrapglVertexAttrib2dv(GLuint index, const GLdouble *v) {glVertexAttrib2dv(index, v);}
1430 void wrapglVertexAttrib3fv(GLuint index, const GLfloat *v) {glVertexAttrib3fv(index, v);}
1431 //void wrapglVertexAttrib3sv(GLuint index, const GLshort *v) {glVertexAttrib3sv(index, v);}
1432 //void wrapglVertexAttrib3dv(GLuint index, const GLdouble *v) {glVertexAttrib3dv(index, v);}
1433 void wrapglVertexAttrib4fv(GLuint index, const GLfloat *v) {glVertexAttrib4fv(index, v);}
1434 //void wrapglVertexAttrib4sv(GLuint index, const GLshort *v) {glVertexAttrib4sv(index, v);}
1435 //void wrapglVertexAttrib4dv(GLuint index, const GLdouble *v) {glVertexAttrib4dv(index, v);}
1436 //void wrapglVertexAttrib4iv(GLuint index, const GLint *v) {glVertexAttrib4iv(index, v);}
1437 //void wrapglVertexAttrib4bv(GLuint index, const GLbyte *v) {glVertexAttrib4bv(index, v);}
1438 //void wrapglVertexAttrib4ubv(GLuint index, const GLubyte *v) {glVertexAttrib4ubv(index, v);}
1439 //void wrapglVertexAttrib4usv(GLuint index, const GLushort *v) {glVertexAttrib4usv(index, GLushort v);}
1440 //void wrapglVertexAttrib4uiv(GLuint index, const GLuint *v) {glVertexAttrib4uiv(index, v);}
1441 //void wrapglVertexAttrib4Nbv(GLuint index, const GLbyte *v) {glVertexAttrib4Nbv(index, v);}
1442 //void wrapglVertexAttrib4Nsv(GLuint index, const GLshort *v) {glVertexAttrib4Nsv(index, v);}
1443 //void wrapglVertexAttrib4Niv(GLuint index, const GLint *v) {glVertexAttrib4Niv(index, v);}
1444 //void wrapglVertexAttrib4Nubv(GLuint index, const GLubyte *v) {glVertexAttrib4Nubv(index, v);}
1445 //void wrapglVertexAttrib4Nusv(GLuint index, const GLushort *v) {glVertexAttrib4Nusv(index, GLushort v);}
1446 //void wrapglVertexAttrib4Nuiv(GLuint index, const GLuint *v) {glVertexAttrib4Nuiv(index, v);}
1447 //void wrapglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {glGetVertexAttribdv(index, pname, params);}
1448 void wrapglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {glGetVertexAttribfv(index, pname, params);}
1449 void wrapglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {glGetVertexAttribiv(index, pname, params);}
1450 void wrapglGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) {glGetVertexAttribPointerv(index, pname, pointer);}
1452 void GLES_Init(void)
1454 qglIsBufferARB = wrapglIsBuffer;
1455 qglIsEnabled = wrapglIsEnabled;
1456 qglIsFramebufferEXT = wrapglIsFramebuffer;
1457 // qglIsQueryARB = wrapglIsQuery;
1458 qglIsRenderbufferEXT = wrapglIsRenderbuffer;
1459 // qglUnmapBufferARB = wrapglUnmapBuffer;
1460 qglCheckFramebufferStatusEXT = wrapglCheckFramebufferStatus;
1461 qglGetError = wrapglGetError;
1462 qglCreateProgram = wrapglCreateProgram;
1463 qglCreateShader = wrapglCreateShader;
1464 // qglGetHandleARB = wrapglGetHandle;
1465 qglGetAttribLocation = wrapglGetAttribLocation;
1466 qglGetUniformLocation = wrapglGetUniformLocation;
1467 // qglMapBufferARB = wrapglMapBuffer;
1468 qglGetString = wrapglGetString;
1469 // qglActiveStencilFaceEXT = wrapglActiveStencilFace;
1470 qglActiveTexture = wrapglActiveTexture;
1471 qglAlphaFunc = wrapglAlphaFunc;
1472 qglArrayElement = wrapglArrayElement;
1473 qglAttachShader = wrapglAttachShader;
1474 qglBegin = wrapglBegin;
1475 // qglBeginQueryARB = wrapglBeginQuery;
1476 qglBindAttribLocation = wrapglBindAttribLocation;
1477 qglBindFragDataLocation = wrapglBindFragDataLocation;
1478 qglBindBufferARB = wrapglBindBuffer;
1479 qglBindFramebufferEXT = wrapglBindFramebuffer;
1480 qglBindRenderbufferEXT = wrapglBindRenderbuffer;
1481 qglBindTexture = wrapglBindTexture;
1482 qglBlendEquationEXT = wrapglBlendEquation;
1483 qglBlendFunc = wrapglBlendFunc;
1484 qglBufferDataARB = wrapglBufferData;
1485 qglBufferSubDataARB = wrapglBufferSubData;
1486 qglClear = wrapglClear;
1487 qglClearColor = wrapglClearColor;
1488 qglClearDepth = wrapglClearDepth;
1489 qglClearStencil = wrapglClearStencil;
1490 qglClientActiveTexture = wrapglClientActiveTexture;
1491 qglColor4f = wrapglColor4f;
1492 qglColor4ub = wrapglColor4ub;
1493 qglColorMask = wrapglColorMask;
1494 qglColorPointer = wrapglColorPointer;
1495 qglCompileShader = wrapglCompileShader;
1496 qglCompressedTexImage2DARB = wrapglCompressedTexImage2D;
1497 qglCompressedTexImage3DARB = wrapglCompressedTexImage3D;
1498 qglCompressedTexSubImage2DARB = wrapglCompressedTexSubImage2D;
1499 qglCompressedTexSubImage3DARB = wrapglCompressedTexSubImage3D;
1500 qglCopyTexImage2D = wrapglCopyTexImage2D;
1501 qglCopyTexSubImage2D = wrapglCopyTexSubImage2D;
1502 qglCopyTexSubImage3D = wrapglCopyTexSubImage3D;
1503 qglCullFace = wrapglCullFace;
1504 qglDeleteBuffersARB = wrapglDeleteBuffers;
1505 qglDeleteFramebuffersEXT = wrapglDeleteFramebuffers;
1506 qglDeleteProgram = wrapglDeleteProgram;
1507 qglDeleteShader = wrapglDeleteShader;
1508 // qglDeleteQueriesARB = wrapglDeleteQueries;
1509 qglDeleteRenderbuffersEXT = wrapglDeleteRenderbuffers;
1510 qglDeleteTextures = wrapglDeleteTextures;
1511 qglDepthFunc = wrapglDepthFunc;
1512 qglDepthMask = wrapglDepthMask;
1513 qglDepthRange = wrapglDepthRange;
1514 qglDetachShader = wrapglDetachShader;
1515 qglDisable = wrapglDisable;
1516 qglDisableClientState = wrapglDisableClientState;
1517 qglDisableVertexAttribArray = wrapglDisableVertexAttribArray;
1518 qglDrawArrays = wrapglDrawArrays;
1519 // qglDrawBuffer = wrapglDrawBuffer;
1520 // qglDrawBuffersARB = wrapglDrawBuffers;
1521 qglDrawElements = wrapglDrawElements;
1522 // qglDrawRangeElements = wrapglDrawRangeElements;
1523 qglEnable = wrapglEnable;
1524 qglEnableClientState = wrapglEnableClientState;
1525 qglEnableVertexAttribArray = wrapglEnableVertexAttribArray;
1527 // qglEndQueryARB = wrapglEndQuery;
1528 qglFinish = wrapglFinish;
1529 qglFlush = wrapglFlush;
1530 qglFramebufferRenderbufferEXT = wrapglFramebufferRenderbuffer;
1531 qglFramebufferTexture2DEXT = wrapglFramebufferTexture2D;
1532 qglFramebufferTexture3DEXT = wrapglFramebufferTexture3D;
1533 qglGenBuffersARB = wrapglGenBuffers;
1534 qglGenFramebuffersEXT = wrapglGenFramebuffers;
1535 // qglGenQueriesARB = wrapglGenQueries;
1536 qglGenRenderbuffersEXT = wrapglGenRenderbuffers;
1537 qglGenTextures = wrapglGenTextures;
1538 qglGenerateMipmapEXT = wrapglGenerateMipmap;
1539 qglGetActiveAttrib = wrapglGetActiveAttrib;
1540 qglGetActiveUniform = wrapglGetActiveUniform;
1541 qglGetAttachedShaders = wrapglGetAttachedShaders;
1542 qglGetBooleanv = wrapglGetBooleanv;
1543 // qglGetCompressedTexImageARB = wrapglGetCompressedTexImage;
1544 qglGetDoublev = wrapglGetDoublev;
1545 qglGetFloatv = wrapglGetFloatv;
1546 qglGetFramebufferAttachmentParameterivEXT = wrapglGetFramebufferAttachmentParameteriv;
1547 qglGetProgramInfoLog = wrapglGetProgramInfoLog;
1548 qglGetShaderInfoLog = wrapglGetShaderInfoLog;
1549 qglGetIntegerv = wrapglGetIntegerv;
1550 qglGetShaderiv = wrapglGetShaderiv;
1551 qglGetProgramiv = wrapglGetProgramiv;
1552 // qglGetQueryObjectivARB = wrapglGetQueryObjectiv;
1553 // qglGetQueryObjectuivARB = wrapglGetQueryObjectuiv;
1554 // qglGetQueryivARB = wrapglGetQueryiv;
1555 qglGetRenderbufferParameterivEXT = wrapglGetRenderbufferParameteriv;
1556 qglGetShaderSource = wrapglGetShaderSource;
1557 qglGetTexImage = wrapglGetTexImage;
1558 qglGetTexLevelParameterfv = wrapglGetTexLevelParameterfv;
1559 qglGetTexLevelParameteriv = wrapglGetTexLevelParameteriv;
1560 qglGetTexParameterfv = wrapglGetTexParameterfv;
1561 qglGetTexParameteriv = wrapglGetTexParameteriv;
1562 qglGetUniformfv = wrapglGetUniformfv;
1563 qglGetUniformiv = wrapglGetUniformiv;
1564 qglHint = wrapglHint;
1565 qglLineWidth = wrapglLineWidth;
1566 qglLinkProgram = wrapglLinkProgram;
1567 qglLoadIdentity = wrapglLoadIdentity;
1568 qglLoadMatrixf = wrapglLoadMatrixf;
1569 qglMatrixMode = wrapglMatrixMode;
1570 qglMultiTexCoord1f = wrapglMultiTexCoord1f;
1571 qglMultiTexCoord2f = wrapglMultiTexCoord2f;
1572 qglMultiTexCoord3f = wrapglMultiTexCoord3f;
1573 qglMultiTexCoord4f = wrapglMultiTexCoord4f;
1574 qglNormalPointer = wrapglNormalPointer;
1575 qglPixelStorei = wrapglPixelStorei;
1576 qglPointSize = wrapglPointSize;
1577 qglPolygonMode = wrapglPolygonMode;
1578 qglPolygonOffset = wrapglPolygonOffset;
1579 // qglPolygonStipple = wrapglPolygonStipple;
1580 qglReadBuffer = wrapglReadBuffer;
1581 qglReadPixels = wrapglReadPixels;
1582 qglRenderbufferStorageEXT = wrapglRenderbufferStorage;
1583 qglScissor = wrapglScissor;
1584 qglShaderSource = wrapglShaderSource;
1585 qglStencilFunc = wrapglStencilFunc;
1586 qglStencilFuncSeparate = wrapglStencilFuncSeparate;
1587 qglStencilMask = wrapglStencilMask;
1588 qglStencilOp = wrapglStencilOp;
1589 qglStencilOpSeparate = wrapglStencilOpSeparate;
1590 qglTexCoord1f = wrapglTexCoord1f;
1591 qglTexCoord2f = wrapglTexCoord2f;
1592 qglTexCoord3f = wrapglTexCoord3f;
1593 qglTexCoord4f = wrapglTexCoord4f;
1594 qglTexCoordPointer = wrapglTexCoordPointer;
1595 qglTexEnvf = wrapglTexEnvf;
1596 qglTexEnvfv = wrapglTexEnvfv;
1597 qglTexEnvi = wrapglTexEnvi;
1598 qglTexImage2D = wrapglTexImage2D;
1599 qglTexImage3D = wrapglTexImage3D;
1600 qglTexParameterf = wrapglTexParameterf;
1601 qglTexParameterfv = wrapglTexParameterfv;
1602 qglTexParameteri = wrapglTexParameteri;
1603 qglTexSubImage2D = wrapglTexSubImage2D;
1604 qglTexSubImage3D = wrapglTexSubImage3D;
1605 qglUniform1f = wrapglUniform1f;
1606 qglUniform1fv = wrapglUniform1fv;
1607 qglUniform1i = wrapglUniform1i;
1608 qglUniform1iv = wrapglUniform1iv;
1609 qglUniform2f = wrapglUniform2f;
1610 qglUniform2fv = wrapglUniform2fv;
1611 qglUniform2i = wrapglUniform2i;
1612 qglUniform2iv = wrapglUniform2iv;
1613 qglUniform3f = wrapglUniform3f;
1614 qglUniform3fv = wrapglUniform3fv;
1615 qglUniform3i = wrapglUniform3i;
1616 qglUniform3iv = wrapglUniform3iv;
1617 qglUniform4f = wrapglUniform4f;
1618 qglUniform4fv = wrapglUniform4fv;
1619 qglUniform4i = wrapglUniform4i;
1620 qglUniform4iv = wrapglUniform4iv;
1621 qglUniformMatrix2fv = wrapglUniformMatrix2fv;
1622 qglUniformMatrix3fv = wrapglUniformMatrix3fv;
1623 qglUniformMatrix4fv = wrapglUniformMatrix4fv;
1624 qglUseProgram = wrapglUseProgram;
1625 qglValidateProgram = wrapglValidateProgram;
1626 qglVertex2f = wrapglVertex2f;
1627 qglVertex3f = wrapglVertex3f;
1628 qglVertex4f = wrapglVertex4f;
1629 qglVertexAttribPointer = wrapglVertexAttribPointer;
1630 qglVertexPointer = wrapglVertexPointer;
1631 qglViewport = wrapglViewport;
1632 qglVertexAttrib1f = wrapglVertexAttrib1f;
1633 // qglVertexAttrib1s = wrapglVertexAttrib1s;
1634 // qglVertexAttrib1d = wrapglVertexAttrib1d;
1635 qglVertexAttrib2f = wrapglVertexAttrib2f;
1636 // qglVertexAttrib2s = wrapglVertexAttrib2s;
1637 // qglVertexAttrib2d = wrapglVertexAttrib2d;
1638 qglVertexAttrib3f = wrapglVertexAttrib3f;
1639 // qglVertexAttrib3s = wrapglVertexAttrib3s;
1640 // qglVertexAttrib3d = wrapglVertexAttrib3d;
1641 qglVertexAttrib4f = wrapglVertexAttrib4f;
1642 // qglVertexAttrib4s = wrapglVertexAttrib4s;
1643 // qglVertexAttrib4d = wrapglVertexAttrib4d;
1644 // qglVertexAttrib4Nub = wrapglVertexAttrib4Nub;
1645 qglVertexAttrib1fv = wrapglVertexAttrib1fv;
1646 // qglVertexAttrib1sv = wrapglVertexAttrib1sv;
1647 // qglVertexAttrib1dv = wrapglVertexAttrib1dv;
1648 qglVertexAttrib2fv = wrapglVertexAttrib2fv;
1649 // qglVertexAttrib2sv = wrapglVertexAttrib2sv;
1650 // qglVertexAttrib2dv = wrapglVertexAttrib2dv;
1651 qglVertexAttrib3fv = wrapglVertexAttrib3fv;
1652 // qglVertexAttrib3sv = wrapglVertexAttrib3sv;
1653 // qglVertexAttrib3dv = wrapglVertexAttrib3dv;
1654 qglVertexAttrib4fv = wrapglVertexAttrib4fv;
1655 // qglVertexAttrib4sv = wrapglVertexAttrib4sv;
1656 // qglVertexAttrib4dv = wrapglVertexAttrib4dv;
1657 // qglVertexAttrib4iv = wrapglVertexAttrib4iv;
1658 // qglVertexAttrib4bv = wrapglVertexAttrib4bv;
1659 // qglVertexAttrib4ubv = wrapglVertexAttrib4ubv;
1660 // qglVertexAttrib4usv = wrapglVertexAttrib4usv;
1661 // qglVertexAttrib4uiv = wrapglVertexAttrib4uiv;
1662 // qglVertexAttrib4Nbv = wrapglVertexAttrib4Nbv;
1663 // qglVertexAttrib4Nsv = wrapglVertexAttrib4Nsv;
1664 // qglVertexAttrib4Niv = wrapglVertexAttrib4Niv;
1665 // qglVertexAttrib4Nubv = wrapglVertexAttrib4Nubv;
1666 // qglVertexAttrib4Nusv = wrapglVertexAttrib4Nusv;
1667 // qglVertexAttrib4Nuiv = wrapglVertexAttrib4Nuiv;
1668 // qglGetVertexAttribdv = wrapglGetVertexAttribdv;
1669 qglGetVertexAttribfv = wrapglGetVertexAttribfv;
1670 qglGetVertexAttribiv = wrapglGetVertexAttribiv;
1671 qglGetVertexAttribPointerv = wrapglGetVertexAttribPointerv;
1673 gl_renderer = (const char *)qglGetString(GL_RENDERER);
1674 gl_vendor = (const char *)qglGetString(GL_VENDOR);
1675 gl_version = (const char *)qglGetString(GL_VERSION);
1676 gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
1680 if (!gl_platformextensions)
1681 gl_platformextensions = "";
1683 Con_Printf("GL_VENDOR: %s\n", gl_vendor);
1684 Con_Printf("GL_RENDERER: %s\n", gl_renderer);
1685 Con_Printf("GL_VERSION: %s\n", gl_version);
1686 Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
1687 Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
1689 // LordHavoc: report supported extensions
1690 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
1692 vid.support.gl20shaders = true;
1693 vid.support.amd_texture_texture4 = false;
1694 vid.support.arb_depth_texture = false;
1695 vid.support.arb_draw_buffers = false;
1696 vid.support.arb_multitexture = false;
1697 vid.support.arb_occlusion_query = false;
1698 vid.support.arb_shadow = false;
1699 vid.support.arb_texture_compression = false; // different (vendor-specific) formats than on desktop OpenGL...
1700 vid.support.arb_texture_cube_map = true;
1701 vid.support.arb_texture_env_combine = false;
1702 vid.support.arb_texture_gather = false;
1703 vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
1704 vid.support.arb_vertex_buffer_object = true;
1705 vid.support.ati_separate_stencil = false;
1706 vid.support.ext_blend_minmax = false;
1707 vid.support.ext_blend_subtract = true;
1708 vid.support.ext_draw_range_elements = true;
1709 vid.support.ext_framebuffer_object = false;//true;
1710 vid.support.ext_stencil_two_side = false;
1711 vid.support.ext_texture_3d = false;//SDL_GL_ExtensionSupported("GL_OES_texture_3D"); // iPhoneOS does not support 3D textures, odd...
1712 vid.support.ext_texture_compression_s3tc = false;
1713 vid.support.ext_texture_edge_clamp = true;
1714 vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
1716 qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
1717 if (vid.support.ext_texture_filter_anisotropic)
1718 qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
1719 if (vid.support.arb_texture_cube_map)
1720 qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, (GLint*)&vid.maxtexturesize_cubemap);
1721 if (vid.support.ext_texture_3d)
1722 qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_3d);
1723 Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
1724 Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
1726 // verify that cubemap textures are really supported
1727 if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
1728 vid.support.arb_texture_cube_map = false;
1730 // verify that 3d textures are really supported
1731 if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
1733 vid.support.ext_texture_3d = false;
1734 Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
1738 vid.teximageunits = 8;
1739 vid.texarrayunits = 5;
1740 vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
1741 vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
1742 vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
1743 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" : "");
1744 vid.renderpath = RENDERPATH_GLES2;
1745 vid.useinterleavedarrays = false;
1747 // VorteX: set other info (maybe place them in VID_InitMode?)
1748 extern cvar_t gl_info_vendor;
1749 extern cvar_t gl_info_renderer;
1750 extern cvar_t gl_info_version;
1751 extern cvar_t gl_info_platform;
1752 extern cvar_t gl_info_driver;
1753 Cvar_SetQuick(&gl_info_vendor, gl_vendor);
1754 Cvar_SetQuick(&gl_info_renderer, gl_renderer);
1755 Cvar_SetQuick(&gl_info_version, gl_version);
1756 Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
1757 Cvar_SetQuick(&gl_info_driver, gl_driver);
1761 void *GL_GetProcAddress(const char *name)
1764 p = SDL_GL_GetProcAddress(name);
1768 static qboolean vid_sdl_initjoysticksystem = false;
1770 void VID_Init (void)
1772 #ifndef __IPHONEOS__
1774 Cvar_RegisterVariable(&apple_mouse_noaccel);
1777 Cvar_RegisterVariable(&vid_soft);
1778 Cvar_RegisterVariable(&vid_soft_threads);
1779 Cvar_RegisterVariable(&vid_soft_interlace);
1780 Cvar_RegisterVariable(&joy_detected);
1781 Cvar_RegisterVariable(&joy_enable);
1782 Cvar_RegisterVariable(&joy_index);
1783 Cvar_RegisterVariable(&joy_axisforward);
1784 Cvar_RegisterVariable(&joy_axisside);
1785 Cvar_RegisterVariable(&joy_axisup);
1786 Cvar_RegisterVariable(&joy_axispitch);
1787 Cvar_RegisterVariable(&joy_axisyaw);
1788 //Cvar_RegisterVariable(&joy_axisroll);
1789 Cvar_RegisterVariable(&joy_deadzoneforward);
1790 Cvar_RegisterVariable(&joy_deadzoneside);
1791 Cvar_RegisterVariable(&joy_deadzoneup);
1792 Cvar_RegisterVariable(&joy_deadzonepitch);
1793 Cvar_RegisterVariable(&joy_deadzoneyaw);
1794 //Cvar_RegisterVariable(&joy_deadzoneroll);
1795 Cvar_RegisterVariable(&joy_sensitivityforward);
1796 Cvar_RegisterVariable(&joy_sensitivityside);
1797 Cvar_RegisterVariable(&joy_sensitivityup);
1798 Cvar_RegisterVariable(&joy_sensitivitypitch);
1799 Cvar_RegisterVariable(&joy_sensitivityyaw);
1800 //Cvar_RegisterVariable(&joy_sensitivityroll);
1801 Cvar_RegisterVariable(&joy_axiskeyevents);
1802 Cvar_RegisterVariable(&joy_axiskeyevents_deadzone);
1804 Cvar_SetValueQuick(&vid_touchscreen, 1);
1807 #ifdef SDL_R_RESTART
1808 R_RegisterModule("SDL", sdl_start, sdl_shutdown, sdl_newmap, NULL, NULL);
1811 if (SDL_Init(SDL_INIT_VIDEO) < 0)
1812 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
1813 vid_sdl_initjoysticksystem = SDL_InitSubSystem(SDL_INIT_JOYSTICK) >= 0;
1814 if (vid_sdl_initjoysticksystem)
1815 Con_Printf("Failed to init SDL joystick subsystem: %s\n", SDL_GetError());
1816 vid_isfullscreen = false;
1820 // set the icon (we dont use SDL here since it would be too much a PITA)
1822 #include "resource.h"
1823 #include <SDL_syswm.h>
1824 static void VID_SetCaption(void)
1830 SDL_WM_SetCaption( gamename, NULL );
1832 // get the HWND handle
1833 SDL_VERSION( &info.version );
1834 if( !SDL_GetWMInfo( &info ) )
1837 icon = LoadIcon( GetModuleHandle( NULL ), MAKEINTRESOURCE( IDI_ICON1 ) );
1838 #ifndef _W64 //If Windows 64bit data types don't exist
1839 #ifndef SetClassLongPtr
1840 #define SetClassLongPtr SetClassLong
1843 #define GCLP_HICON GCL_HICON
1846 #define LONG_PTR LONG
1849 SetClassLongPtr( info.window, GCLP_HICON, (LONG_PTR)icon );
1851 static void VID_SetIcon_Pre(void)
1854 static void VID_SetIcon_Post(void)
1858 // Adding the OS independent XPM version --blub
1859 #include "darkplaces.xpm"
1860 #include "nexuiz.xpm"
1861 static SDL_Surface *icon = NULL;
1862 static void VID_SetIcon_Pre(void)
1865 * Somewhat restricted XPM reader. Only supports XPMs saved by GIMP 2.4 at
1866 * default settings with less than 91 colors and transparency.
1869 int width, height, colors, isize, i, j;
1871 static SDL_Color palette[256];
1872 unsigned short palenc[256]; // store color id by char
1874 char **idata, *data;
1875 const SDL_version *version;
1877 version = SDL_Linked_Version();
1878 // only use non-XPM icon support in SDL v1.3 and higher
1879 // SDL v1.2 does not support "smooth" transparency, and thus is better
1881 if(version->major >= 2 || (version->major == 1 && version->minor >= 3))
1883 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1886 unsigned int red = 0x00FF0000;
1887 unsigned int green = 0x0000FF00;
1888 unsigned int blue = 0x000000FF;
1889 unsigned int alpha = 0xFF000000;
1890 width = image_width;
1891 height = image_height;
1893 // reallocate with malloc, as this is in tempmempool (do not want)
1895 data = malloc(width * height * 4);
1896 memcpy(data, xpm, width * height * 4);
1900 icon = SDL_CreateRGBSurface(SDL_SRCALPHA, width, height, 32, LittleLong(red), LittleLong(green), LittleLong(blue), LittleLong(alpha));
1903 Con_Printf( "Failed to create surface for the window Icon!\n"
1904 "%s\n", SDL_GetError());
1909 icon->pixels = data;
1913 // we only get here if non-XPM icon was missing, or SDL version is not
1914 // sufficient for transparent non-XPM icons
1917 xpm = (char *) FS_LoadFile("darkplaces-icon.xpm", tempmempool, false, NULL);
1920 idata = XPM_DecodeString(xpm);
1922 idata = ENGINE_ICON;
1928 if(sscanf(data, "%i %i %i %i", &width, &height, &colors, &isize) != 4)
1930 // NOTE: Only 1-char colornames are supported
1931 Con_Printf("Sorry, but this does not even look similar to an XPM.\n");
1937 // NOTE: Only 1-char colornames are supported
1938 Con_Printf("This XPM's palette is either huge or idiotically unoptimized. It's key size is %i\n", isize);
1942 for(i = 0; i < colors; ++i)
1944 unsigned int r, g, b;
1947 if(sscanf(idata[i+1], "%c c #%02x%02x%02x", &idx, &r, &g, &b) != 4)
1950 if(sscanf(idata[i+1], "%c c Non%1[e]", &idx, foo) != 2) // I take the DailyWTF credit for this. --div0
1952 Con_Printf("This XPM's palette looks odd. Can't continue.\n");
1957 palette[i].r = 255; // color key
1960 thenone = i; // weeeee
1965 palette[i].r = r - (r == 255 && g == 0 && b == 255); // change 255/0/255 pink to 254/0/255 for color key
1970 palenc[(unsigned char) idx] = i;
1973 // allocate the image data
1974 data = (char*) malloc(width*height);
1976 for(j = 0; j < height; ++j)
1978 for(i = 0; i < width; ++i)
1980 // casting to the safest possible datatypes ^^
1981 data[j * width + i] = palenc[((unsigned char*)idata[colors+j+1])[i]];
1987 // SDL_FreeSurface should free the data too
1988 // but for completeness' sake...
1989 if(icon->flags & SDL_PREALLOC)
1992 icon->pixels = NULL; // safety
1994 SDL_FreeSurface(icon);
1997 icon = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, width, height, 8, 0,0,0,0);// rmask, gmask, bmask, amask); no mask needed
1998 // 8 bit surfaces get an empty palette allocated according to the docs
1999 // so it's a palette image for sure :) no endian check necessary for the mask
2002 Con_Printf( "Failed to create surface for the window Icon!\n"
2003 "%s\n", SDL_GetError());
2008 icon->pixels = data;
2009 SDL_SetPalette(icon, SDL_PHYSPAL|SDL_LOGPAL, palette, 0, colors);
2010 SDL_SetColorKey(icon, SDL_SRCCOLORKEY, thenone);
2013 SDL_WM_SetIcon(icon, NULL);
2015 static void VID_SetIcon_Post(void)
2017 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2018 // LordHavoc: info.info.x11.lock_func and accompanying code do not seem to compile with SDL 1.3
2019 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
2022 const SDL_version *version;
2024 version = SDL_Linked_Version();
2025 // only use non-XPM icon support in SDL v1.3 and higher
2026 // SDL v1.2 does not support "smooth" transparency, and thus is better
2028 if(!(version->major >= 2 || (version->major == 1 && version->minor >= 3)))
2030 // in this case, we did not set the good icon yet
2032 SDL_VERSION(&info.version);
2033 if(SDL_GetWMInfo(&info) == 1 && info.subsystem == SDL_SYSWM_X11)
2035 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
2038 // use _NET_WM_ICON too
2039 static long netwm_icon[MAX_NETWM_ICON];
2045 if(pos + 2 * image_width * image_height < MAX_NETWM_ICON)
2047 netwm_icon[pos++] = image_width;
2048 netwm_icon[pos++] = image_height;
2049 for(i = 0; i < image_height; ++i)
2050 for(j = 0; j < image_width; ++j)
2051 netwm_icon[pos++] = BuffLittleLong((unsigned char *) &data[(i*image_width+j)*4]);
2055 Con_Printf("Skipping NETWM icon #%d because there is no space left\n", i);
2059 data = (char *) loadimagepixelsbgra(va("darkplaces-icon%d", i), false, false, false, NULL);
2062 info.info.x11.lock_func();
2064 Atom net_wm_icon = XInternAtom(info.info.x11.display, "_NET_WM_ICON", false);
2065 XChangeProperty(info.info.x11.display, info.info.x11.wmwindow, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (const unsigned char *) netwm_icon, pos);
2067 info.info.x11.unlock_func();
2076 static void VID_SetCaption(void)
2078 SDL_WM_SetCaption( gamename, NULL );
2083 static void VID_OutputVersion(void)
2085 const SDL_version *version;
2086 version = SDL_Linked_Version();
2087 Con_Printf( "Linked against SDL version %d.%d.%d\n"
2088 "Using SDL library version %d.%d.%d\n",
2089 SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL,
2090 version->major, version->minor, version->patch );
2093 qboolean VID_InitModeGL(viddef_mode_t *mode)
2097 static int notfirstvideomode = false;
2098 int flags = SDL_OPENGL;
2100 int windowflags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
2102 const char *drivername;
2104 win_half_width = mode->width>>1;
2105 win_half_height = mode->height>>1;
2107 if(vid_resizable.integer)
2109 flags |= SDL_RESIZABLE;
2111 windowflags |= SDL_WINDOW_RESIZABLE;
2114 VID_OutputVersion();
2119 We cant switch from one OpenGL video mode to another.
2120 Thus we first switch to some stupid 2D mode and then back to OpenGL.
2122 if (notfirstvideomode)
2123 SDL_SetVideoMode( 0, 0, 0, 0 );
2124 notfirstvideomode = true;
2127 // SDL usually knows best
2130 // 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
2131 i = COM_CheckParm("-gl_driver");
2132 if (i && i < com_argc - 1)
2133 drivername = com_argv[i + 1];
2134 if (SDL_GL_LoadLibrary(drivername) < 0)
2136 Con_Printf("Unable to load GL driver \"%s\": %s\n", drivername, SDL_GetError());
2141 // mobile platforms are always fullscreen, we'll get the resolution after opening the window
2142 mode->fullscreen = true;
2143 // hide the menu with SDL_WINDOW_BORDERLESS
2144 windowflags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
2146 if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
2149 Con_Print("Required OpenGL function glGetString not found\n");
2154 // Knghtbrd: should do platform-specific extension string function here
2156 vid_isfullscreen = false;
2157 if (mode->fullscreen) {
2159 flags |= SDL_FULLSCREEN;
2161 windowflags |= SDL_WINDOW_FULLSCREEN;
2163 vid_isfullscreen = true;
2165 //flags |= SDL_HWSURFACE;
2167 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
2168 if (mode->bitsperpixel >= 32)
2170 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 8);
2171 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 8);
2172 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 8);
2173 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8);
2174 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24);
2175 SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
2179 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
2180 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
2181 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
2182 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
2184 if (mode->stereobuffer)
2185 SDL_GL_SetAttribute (SDL_GL_STEREO, 1);
2186 if (mode->samples > 1)
2188 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
2189 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, mode->samples);
2191 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2192 if (vid_vsync.integer)
2193 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
2195 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 0);
2198 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 2);
2199 SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 0);
2200 SDL_GL_SetAttribute (SDL_GL_RETAINED_BACKING, 1);
2201 // FIXME: get proper resolution from OS somehow (iPad for instance...)
2207 video_bpp = mode->bitsperpixel;
2209 video_flags = flags;
2211 screen = SDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2215 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2219 mode->width = screen->w;
2220 mode->height = screen->h;
2222 window_flags = windowflags;
2223 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2226 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2230 SDL_GetWindowSize(window, &mode->width, &mode->height);
2231 context = SDL_GL_CreateContext(window);
2232 if (context == NULL)
2234 Con_Printf("Failed to initialize OpenGL context: %s\n", SDL_GetError());
2240 vid_softsurface = NULL;
2241 vid.softpixels = NULL;
2248 SDL_EnableUNICODE( SDL_ENABLE );
2249 // enable key repeat since everyone expects it
2250 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2252 #if !(SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2)
2253 SDL_GL_SetSwapInterval(vid_vsync.integer != 0);
2254 vid_usingvsync = (vid_vsync.integer != 0);
2257 gl_platform = "SDL";
2258 gl_platformextensions = "";
2266 vid_numjoysticks = SDL_NumJoysticks();
2267 vid_numjoysticks = bound(0, vid_numjoysticks, MAX_JOYSTICKS);
2268 Cvar_SetValueQuick(&joy_detected, vid_numjoysticks);
2269 Con_Printf("%d SDL joystick(s) found:\n", vid_numjoysticks);
2270 memset(vid_joysticks, 0, sizeof(vid_joysticks));
2271 for (i = 0;i < vid_numjoysticks;i++)
2274 joy = vid_joysticks[i] = SDL_JoystickOpen(i);
2277 Con_Printf("joystick #%i: open failed: %s\n", i, SDL_GetError());
2280 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));
2284 vid_activewindow = false;
2285 vid_hasfocus = true;
2286 vid_usingmouse = false;
2287 vid_usinghidecursor = false;
2290 SDL_WM_GrabInput(SDL_GRAB_OFF);
2295 extern cvar_t gl_info_extensions;
2296 extern cvar_t gl_info_vendor;
2297 extern cvar_t gl_info_renderer;
2298 extern cvar_t gl_info_version;
2299 extern cvar_t gl_info_platform;
2300 extern cvar_t gl_info_driver;
2302 qboolean VID_InitModeSoft(viddef_mode_t *mode)
2306 int flags = SDL_HWSURFACE;
2308 int windowflags = SDL_WINDOW_SHOWN;
2311 win_half_width = mode->width>>1;
2312 win_half_height = mode->height>>1;
2314 if(vid_resizable.integer)
2316 flags |= SDL_RESIZABLE;
2318 windowflags |= SDL_WINDOW_RESIZABLE;
2321 VID_OutputVersion();
2323 vid_isfullscreen = false;
2324 if (mode->fullscreen) {
2326 flags |= SDL_FULLSCREEN;
2328 windowflags |= SDL_WINDOW_FULLSCREEN;
2330 vid_isfullscreen = true;
2333 video_bpp = mode->bitsperpixel;
2335 video_flags = flags;
2337 screen = SDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2341 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2345 mode->width = screen->w;
2346 mode->height = screen->h;
2348 window_flags = windowflags;
2349 window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2352 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2356 SDL_GetWindowSize(window, &mode->width, &mode->height);
2359 // create a framebuffer using our specific color format, we let the SDL blit function convert it in VID_Finish
2360 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, mode->width, mode->height, 32, 0x00FF0000, 0x0000FF00, 0x00000000FF, 0xFF000000);
2361 if (vid_softsurface == NULL)
2363 Con_Printf("Failed to setup software rasterizer framebuffer %ix%ix32bpp: %s\n", mode->width, mode->height, SDL_GetError());
2367 SDL_SetAlpha(vid_softsurface, 0, 255);
2369 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
2370 vid.softdepthpixels = (unsigned int *)calloc(1, mode->width * mode->height * 4);
2371 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)
2373 Con_Printf("Failed to initialize software rasterizer\n");
2383 SDL_EnableUNICODE( SDL_ENABLE );
2384 // enable key repeat since everyone expects it
2385 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2387 gl_platform = "SDLSoft";
2388 gl_platformextensions = "";
2390 gl_renderer = "DarkPlaces-Soft";
2391 gl_vendor = "Forest Hale";
2395 // clear the extension flags
2396 memset(&vid.support, 0, sizeof(vid.support));
2397 Cvar_SetQuick(&gl_info_extensions, "");
2399 vid.forcevbo = false;
2400 vid.support.arb_depth_texture = true;
2401 vid.support.arb_draw_buffers = true;
2402 vid.support.arb_occlusion_query = true;
2403 vid.support.arb_shadow = true;
2404 //vid.support.arb_texture_compression = true;
2405 vid.support.arb_texture_cube_map = true;
2406 vid.support.arb_texture_non_power_of_two = false;
2407 vid.support.arb_vertex_buffer_object = true;
2408 vid.support.ext_blend_subtract = true;
2409 vid.support.ext_draw_range_elements = true;
2410 vid.support.ext_framebuffer_object = true;
2411 vid.support.ext_texture_3d = true;
2412 //vid.support.ext_texture_compression_s3tc = true;
2413 vid.support.ext_texture_filter_anisotropic = true;
2414 vid.support.ati_separate_stencil = true;
2416 vid.maxtexturesize_2d = 16384;
2417 vid.maxtexturesize_3d = 512;
2418 vid.maxtexturesize_cubemap = 16384;
2420 vid.teximageunits = 32;
2421 vid.texarrayunits = 8;
2422 vid.max_anisotropy = 1;
2423 vid.maxdrawbuffers = 4;
2425 vid.texunits = bound(4, vid.texunits, MAX_TEXTUREUNITS);
2426 vid.teximageunits = bound(16, vid.teximageunits, MAX_TEXTUREUNITS);
2427 vid.texarrayunits = bound(8, vid.texarrayunits, MAX_TEXTUREUNITS);
2428 Con_DPrintf("Using DarkPlaces Software Rasterizer rendering path\n");
2429 vid.renderpath = RENDERPATH_SOFT;
2430 vid.useinterleavedarrays = false;
2432 Cvar_SetQuick(&gl_info_vendor, gl_vendor);
2433 Cvar_SetQuick(&gl_info_renderer, gl_renderer);
2434 Cvar_SetQuick(&gl_info_version, gl_version);
2435 Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
2436 Cvar_SetQuick(&gl_info_driver, gl_driver);
2438 // LordHavoc: report supported extensions
2439 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2441 // clear to black (loading plaque will be seen over this)
2442 GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
2444 vid_numjoysticks = SDL_NumJoysticks();
2445 vid_numjoysticks = bound(0, vid_numjoysticks, MAX_JOYSTICKS);
2446 Cvar_SetValueQuick(&joy_detected, vid_numjoysticks);
2447 Con_Printf("%d SDL joystick(s) found:\n", vid_numjoysticks);
2448 memset(vid_joysticks, 0, sizeof(vid_joysticks));
2449 for (i = 0;i < vid_numjoysticks;i++)
2452 joy = vid_joysticks[i] = SDL_JoystickOpen(i);
2455 Con_Printf("joystick #%i: open failed: %s\n", i, SDL_GetError());
2458 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));
2462 vid_activewindow = false;
2463 vid_hasfocus = true;
2464 vid_usingmouse = false;
2465 vid_usinghidecursor = false;
2468 SDL_WM_GrabInput(SDL_GRAB_OFF);
2473 qboolean VID_InitMode(viddef_mode_t *mode)
2475 if (!SDL_WasInit(SDL_INIT_VIDEO) && SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
2476 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
2478 if (vid_soft.integer)
2479 return VID_InitModeSoft(mode);
2482 return VID_InitModeGL(mode);
2485 void VID_Shutdown (void)
2487 VID_SetMouse(false, false, false);
2488 VID_RestoreSystemGamma();
2493 SDL_FreeSurface(icon);
2498 if (vid_softsurface)
2499 SDL_FreeSurface(vid_softsurface);
2500 vid_softsurface = NULL;
2501 vid.softpixels = NULL;
2502 if (vid.softdepthpixels)
2503 free(vid.softdepthpixels);
2504 vid.softdepthpixels = NULL;
2508 SDL_DestroyWindow(window);
2512 SDL_QuitSubSystem(SDL_INIT_VIDEO);
2517 gl_platformextensions = "";
2520 int VID_SetGamma (unsigned short *ramps, int rampsize)
2522 return !SDL_SetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2525 int VID_GetGamma (unsigned short *ramps, int rampsize)
2527 return !SDL_GetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2530 void VID_Finish (void)
2535 //react on appstate changes
2536 appstate = SDL_GetAppState();
2538 vid_hidden = !(appstate & SDL_APPACTIVE);
2539 vid_hasfocus = (appstate & SDL_APPMOUSEFOCUS) && (appstate & SDL_APPINPUTFOCUS);
2541 vid_activewindow = !vid_hidden && vid_hasfocus;
2543 VID_UpdateGamma(false, 256);
2547 switch(vid.renderpath)
2549 case RENDERPATH_GL11:
2550 case RENDERPATH_GL13:
2551 case RENDERPATH_GL20:
2552 case RENDERPATH_GLES2:
2554 if (r_speeds.integer == 2 || gl_finish.integer)
2556 qglFinish();CHECKGLERROR
2558 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2561 qboolean vid_usevsync;
2562 vid_usevsync = (vid_vsync.integer && !cls.timedemo);
2563 if (vid_usingvsync != vid_usevsync)
2565 if (SDL_GL_SetSwapInterval(vid_usevsync != 0) >= 0)
2566 Con_DPrintf("Vsync %s\n", vid_usevsync ? "activated" : "deactivated");
2568 Con_DPrintf("ERROR: can't %s vsync\n", vid_usevsync ? "activate" : "deactivate");
2573 SDL_GL_SwapBuffers();
2575 SDL_GL_SwapWindow(window);
2578 case RENDERPATH_SOFT:
2579 DPSOFTRAST_Finish();
2581 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2585 SDL_Surface *screen = SDL_GetWindowSurface(window);
2586 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2587 SDL_UpdateWindowSurface(window);
2591 case RENDERPATH_D3D9:
2592 case RENDERPATH_D3D10:
2593 case RENDERPATH_D3D11:
2599 size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
2602 SDL_Rect **vidmodes;
2603 int bpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
2606 for(vidmodes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE); vidmodes && *vidmodes; ++vidmodes)
2610 modes[k].width = (*vidmodes)->w;
2611 modes[k].height = (*vidmodes)->h;
2613 modes[k].refreshrate = 60; // no support for refresh rate in SDL
2614 modes[k].pixelheight_num = 1;
2615 modes[k].pixelheight_denom = 1; // SDL does not provide this