vid_sdl.c

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