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 #ifndef __IPHONEOS__
 834 static keynum_t buttonremap[18] =
 835 {
 836         K_MOUSE1,
 837         K_MOUSE3,
 838         K_MOUSE2,
 839         K_MWHEELUP,
 840         K_MWHEELDOWN,
 841         K_MOUSE4,
 842         K_MOUSE5,
 843         K_MOUSE6,
 844         K_MOUSE7,
 845         K_MOUSE8,
 846         K_MOUSE9,
 847         K_MOUSE10,
 848         K_MOUSE11,
 849         K_MOUSE12,
 850         K_MOUSE13,
 851         K_MOUSE14,
 852         K_MOUSE15,
 853         K_MOUSE16,
 854 };
 855 #endif
 856
 857 #if SETVIDEOMODE
 858 // SDL 1.2
 859 void Sys_SendKeyEvents( void )
 860 {
 861         static qboolean sound_active = true;
 862         int keycode;
 863         SDL_Event event;
 864
 865         while( SDL_PollEvent( &event ) )
 866                 switch( event.type ) {
 867                         case SDL_QUIT:
 868                                 Sys_Quit(0);
 869                                 break;
 870                         case SDL_KEYDOWN:
 871                         case SDL_KEYUP:
 872                                 keycode = MapKey(event.key.keysym.sym);
 873                                 if (!IN_JoystickBlockDoubledKeyEvents(keycode))
 874                                         Key_Event(keycode, event.key.keysym.unicode, (event.key.state == SDL_PRESSED));
 875                                 break;
 876                         case SDL_ACTIVEEVENT:
 877                                 if( event.active.state & SDL_APPACTIVE )
 878                                 {
 879                                         if( event.active.gain )
 880                                                 vid_hidden = false;
 881                                         else
 882                                                 vid_hidden = true;
 883                                 }
 884                                 break;
 885                         case SDL_MOUSEBUTTONDOWN:
 886                         case SDL_MOUSEBUTTONUP:
 887                                 if (event.button.button <= 18)
 888                                         Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
 889                                 break;
 890                         case SDL_JOYBUTTONDOWN:
 891                                 if (!joy_enable.integer)
 892                                         break; // ignore down events if joystick has been disabled
 893                         case SDL_JOYBUTTONUP:
 894                                 if (event.jbutton.button < 48)
 895                                         Key_Event( event.jbutton.button + (event.jbutton.button < 16 ? K_JOY1 : K_AUX1 - 16), 0, (event.jbutton.state == SDL_PRESSED) );
 896                                 break;
 897                         case SDL_VIDEORESIZE:
 898                                 if(vid_resizable.integer < 2)
 899                                 {
 900                                         vid.width = event.resize.w;
 901                                         vid.height = event.resize.h;
 902                                         screen = SDL_SetVideoMode(vid.width, vid.height, video_bpp, video_flags);
 903                                         if (vid_softsurface)
 904                                         {
 905                                                 SDL_FreeSurface(vid_softsurface);
 906                                                 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
 907                                                 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
 908                                                 SDL_SetAlpha(vid_softsurface, 0, 255);
 909                                                 if (vid.softdepthpixels)
 910                                                         free(vid.softdepthpixels);
 911                                                 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
 912                                         }
 913 #ifdef SDL_R_RESTART
 914                                         // better not call R_Modules_Restart from here directly, as this may wreak havoc...
 915                                         // so, let's better queue it for next frame
 916                                         if(!sdl_needs_restart)
 917                                         {
 918                                                 Cbuf_AddText("\nr_restart\n");
 919                                                 sdl_needs_restart = true;
 920                                         }
 921 #endif
 922                                 }
 923                                 break;
 924 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
 925 #else
 926                         case SDL_TEXTEDITING:
 927                                 // unused when SETVIDEOMODE API is used
 928                                 break;
 929                         case SDL_TEXTINPUT:
 930                                 // this occurs with SETVIDEOMODE but we are not using it
 931                                 break;
 932 #endif
 933                         case SDL_MOUSEMOTION:
 934                                 break;
 935                         default:
 936                                 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
 937                                 break;
 938                 }
 939
 940         // enable/disable sound on focus gain/loss
 941         if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
 942         {
 943                 if (!sound_active)
 944                 {
 945                         S_UnblockSound ();
 946                         sound_active = true;
 947                 }
 948         }
 949         else
 950         {
 951                 if (sound_active)
 952                 {
 953                         S_BlockSound ();
 954                         sound_active = false;
 955                 }
 956         }
 957 }
 958
 959 #else
 960
 961 // SDL 1.3
 962 void Sys_SendKeyEvents( void )
 963 {
 964         static qboolean sound_active = true;
 965         static qboolean missingunicodehack = true;
 966         int keycode;
 967         int i;
 968         int j;
 969         int unicode;
 970         SDL_Event event;
 971
 972         while( SDL_PollEvent( &event ) )
 973                 switch( event.type ) {
 974                         case SDL_QUIT:
 975                                 Sys_Quit(0);
 976                                 break;
 977                         case SDL_KEYDOWN:
 978                         case SDL_KEYUP:
 979                                 keycode = MapKey(event.key.keysym.sym);
 980                                 if (!IN_JoystickBlockDoubledKeyEvents(keycode))
 981 #ifdef __IPHONEOS__
 982                                 // the virtual keyboard seems to produce no unicode values...
 983                                 if (missingunicodehack && keycode >= ' ' && keycode < 0x7F && event.key.keysym.unicode == 0)
 984                                 {
 985                                         Con_DPrintf("SDL hack: no unicode value reported, substituting ascii value %i\n", keycode);
 986                                         Key_Event(keycode, keycode, (event.key.state == SDL_PRESSED));
 987                                 }
 988                                 else
 989 #endif
 990                                         Key_Event(keycode, 0, (event.key.state == SDL_PRESSED));
 991                                 break;
 992                         case SDL_MOUSEBUTTONDOWN:
 993                         case SDL_MOUSEBUTTONUP:
 994 #ifndef __IPHONEOS__
 995                                 if (event.button.button <= 18)
 996                                         Key_Event( buttonremap[event.button.button - 1], 0, event.button.state == SDL_PRESSED );
 997 #endif
 998                                 break;
 999                         case SDL_JOYBUTTONDOWN:
1000                                 if (!joy_enable.integer)
1001                                         break; // ignore down events if joystick has been disabled
1002                         case SDL_JOYBUTTONUP:
1003                                 if (event.jbutton.button < 48)
1004                                         Key_Event( event.jbutton.button + (event.jbutton.button < 16 ? K_JOY1 : K_AUX1 - 16), 0, (event.jbutton.state == SDL_PRESSED) );
1005                                 break;
1006                         case SDL_WINDOWEVENT:
1007                                 //if (event.window.windowID == window) // how to compare?
1008                                 {
1009                                         switch(event.window.event)
1010                                         {
1011                                         case SDL_WINDOWEVENT_SHOWN:
1012                                                 vid_hidden = false;
1013                                                 break;
1014                                         case  SDL_WINDOWEVENT_HIDDEN:
1015                                                 vid_hidden = true;
1016                                                 break;
1017                                         case SDL_WINDOWEVENT_EXPOSED:
1018                                                 break;
1019                                         case SDL_WINDOWEVENT_MOVED:
1020                                                 break;
1021                                         case SDL_WINDOWEVENT_RESIZED:
1022                                                 if(vid_resizable.integer < 2)
1023                                                 {
1024                                                         vid.width = event.window.data1;
1025                                                         vid.height = event.window.data2;
1026                                                         if (vid_softsurface)
1027                                                         {
1028                                                                 SDL_FreeSurface(vid_softsurface);
1029                                                                 vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, vid.width, vid.height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
1030                                                                 vid.softpixels = (unsigned int *)vid_softsurface->pixels;
1031                                                                 SDL_SetAlpha(vid_softsurface, 0, 255);
1032                                                                 if (vid.softdepthpixels)
1033                                                                         free(vid.softdepthpixels);
1034                                                                 vid.softdepthpixels = (unsigned int*)calloc(1, vid.width * vid.height * 4);
1035                                                         }
1036 #ifdef SDL_R_RESTART
1037                                                         // better not call R_Modules_Restart from here directly, as this may wreak havoc...
1038                                                         // so, let's better queue it for next frame
1039                                                         if(!sdl_needs_restart)
1040                                                         {
1041                                                                 Cbuf_AddText("\nr_restart\n");
1042                                                                 sdl_needs_restart = true;
1043                                                         }
1044 #endif
1045                                                 }
1046                                                 break;
1047                                         case SDL_WINDOWEVENT_MINIMIZED:
1048                                                 break;
1049                                         case SDL_WINDOWEVENT_MAXIMIZED:
1050                                                 break;
1051                                         case SDL_WINDOWEVENT_RESTORED:
1052                                                 break;
1053                                         case SDL_WINDOWEVENT_ENTER:
1054                                                 break;
1055                                         case SDL_WINDOWEVENT_LEAVE:
1056                                                 break;
1057                                         case SDL_WINDOWEVENT_FOCUS_GAINED:
1058                                                 vid_hasfocus = true;
1059                                                 break;
1060                                         case SDL_WINDOWEVENT_FOCUS_LOST:
1061                                                 vid_hasfocus = false;
1062                                                 break;
1063                                         case SDL_WINDOWEVENT_CLOSE:
1064                                                 Sys_Quit(0);
1065                                                 break;
1066                                         }
1067                                 }
1068                                 break;
1069                         case SDL_TEXTEDITING:
1070                                 // FIXME!  this is where composition gets supported
1071                                 break;
1072                         case SDL_TEXTINPUT:
1073                                 // we have some characters to parse
1074                                 missingunicodehack = false;
1075                                 {
1076                                         unicode = 0;
1077                                         for (i = 0;event.text.text[i];)
1078                                         {
1079                                                 unicode = event.text.text[i++];
1080                                                 if (unicode & 0x80)
1081                                                 {
1082                                                         // UTF-8 character
1083                                                         // strip high bits (we could count these to validate character length but we don't)
1084                                                         for (j = 0x80;unicode & j;j >>= 1)
1085                                                                 unicode ^= j;
1086                                                         for (;(event.text.text[i] & 0xC0) == 0x80;i++)
1087                                                                 unicode = (unicode << 6) | (event.text.text[i] & 0x3F);
1088                                                         // low characters are invalid and could be bad, so replace them
1089                                                         if (unicode < 0x80)
1090                                                                 unicode = '?'; // we could use 0xFFFD instead, the unicode substitute character
1091                                                 }
1092                                                 //Con_DPrintf("SDL_TEXTINPUT: K_TEXT %i \n", unicode);
1093                                                 Key_Event(K_TEXT, unicode, true);
1094                                                 Key_Event(K_TEXT, unicode, false);
1095                                         }
1096                                 }
1097                                 break;
1098                         case SDL_MOUSEMOTION:
1099                                 break;
1100                         case SDL_FINGERDOWN:
1101                                 Con_DPrintf("SDL_FINGERDOWN for finger %i\n", (int)event.tfinger.fingerId);
1102                                 for (i = 0;i < MAXFINGERS-1;i++)
1103                                 {
1104                                         if (!multitouch[i][0])
1105                                         {
1106                                                 multitouch[i][0] = event.tfinger.fingerId;
1107                                                 multitouch[i][1] = event.tfinger.x;
1108                                                 multitouch[i][2] = event.tfinger.y;
1109                                                 // TODO: use event.tfinger.pressure?
1110                                                 break;
1111                                         }
1112                                 }
1113                                 if (i == MAXFINGERS-1)
1114                                         Con_DPrintf("Too many fingers at once!\n");
1115                                 break;
1116                         case SDL_FINGERUP:
1117                                 Con_DPrintf("SDL_FINGERUP for finger %i\n", (int)event.tfinger.fingerId);
1118                                 for (i = 0;i < MAXFINGERS-1;i++)
1119                                 {
1120                                         if (multitouch[i][0] == event.tfinger.fingerId)
1121                                         {
1122                                                 multitouch[i][0] = 0;
1123                                                 break;
1124                                         }
1125                                 }
1126                                 if (i == MAXFINGERS-1)
1127                                         Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1128                                 break;
1129                         case SDL_FINGERMOTION:
1130                                 Con_DPrintf("SDL_FINGERMOTION for finger %i\n", (int)event.tfinger.fingerId);
1131                                 for (i = 0;i < MAXFINGERS-1;i++)
1132                                 {
1133                                         if (multitouch[i][0] == event.tfinger.fingerId)
1134                                         {
1135                                                 multitouch[i][1] = event.tfinger.x;
1136                                                 multitouch[i][2] = event.tfinger.y;
1137                                                 break;
1138                                         }
1139                                 }
1140                                 if (i == MAXFINGERS-1)
1141                                         Con_DPrintf("No SDL_FINGERDOWN event matches this SDL_FINGERMOTION event\n");
1142                                 break;
1143                         case SDL_TOUCHBUTTONDOWN:
1144                                 // not sure what to do with this...
1145                                 break;
1146                         case SDL_TOUCHBUTTONUP:
1147                                 // not sure what to do with this...
1148                                 break;
1149                         case SDL_JOYAXISMOTION:
1150                                 // we poll the joystick instead
1151                                 break;
1152                         case SDL_JOYBALLMOTION:
1153                                 // we poll the joystick instead
1154                                 break;
1155                         case SDL_JOYHATMOTION:
1156                                 // we poll the joystick instead
1157                                 break;
1158                         default:
1159                                 Con_DPrintf("Received unrecognized SDL_Event type 0x%x\n", event.type);
1160                                 break;
1161                 }
1162
1163         // enable/disable sound on focus gain/loss
1164         if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
1165         {
1166                 if (!sound_active)
1167                 {
1168                         S_UnblockSound ();
1169                         sound_active = true;
1170                 }
1171         }
1172         else
1173         {
1174                 if (sound_active)
1175                 {
1176                         S_BlockSound ();
1177                         sound_active = false;
1178                 }
1179         }
1180 }
1181 #endif
1182
1183 /////////////////
1184 // Video system
1185 ////
1186
1187 #ifdef __IPHONEOS__
1188 //#include <SDL_opengles.h>
1189 #include <OpenGLES/ES2/gl.h>
1190
1191 GLboolean wrapglIsBuffer(GLuint buffer) {return glIsBuffer(buffer);}
1192 GLboolean wrapglIsEnabled(GLenum cap) {return glIsEnabled(cap);}
1193 GLboolean wrapglIsFramebuffer(GLuint framebuffer) {return glIsFramebuffer(framebuffer);}
1194 //GLboolean wrapglIsQuery(GLuint qid) {return glIsQuery(qid);}
1195 GLboolean wrapglIsRenderbuffer(GLuint renderbuffer) {return glIsRenderbuffer(renderbuffer);}
1196 //GLboolean wrapglUnmapBuffer(GLenum target) {return glUnmapBuffer(target);}
1197 GLenum wrapglCheckFramebufferStatus(GLenum target) {return glCheckFramebufferStatus(target);}
1198 GLenum wrapglGetError(void) {return glGetError();}
1199 GLuint wrapglCreateProgram(void) {return glCreateProgram();}
1200 GLuint wrapglCreateShader(GLenum shaderType) {return glCreateShader(shaderType);}
1201 //GLuint wrapglGetHandle(GLenum pname) {return glGetHandle(pname);}
1202 GLint wrapglGetAttribLocation(GLuint programObj, const GLchar *name) {return glGetAttribLocation(programObj, name);}
1203 GLint wrapglGetUniformLocation(GLuint programObj, const GLchar *name) {return glGetUniformLocation(programObj, name);}
1204 //GLvoid* wrapglMapBuffer(GLenum target, GLenum access) {return glMapBuffer(target, access);}
1205 const GLubyte* wrapglGetString(GLenum name) {return glGetString(name);}
1206 void wrapglActiveStencilFace(GLenum e) {Con_Printf("glActiveStencilFace(e)\n");}
1207 void wrapglActiveTexture(GLenum e) {glActiveTexture(e);}
1208 void wrapglAlphaFunc(GLenum func, GLclampf ref) {Con_Printf("glAlphaFunc(func, ref)\n");}
1209 void wrapglArrayElement(GLint i) {Con_Printf("glArrayElement(i)\n");}
1210 void wrapglAttachShader(GLuint containerObj, GLuint obj) {glAttachShader(containerObj, obj);}
1211 void wrapglBegin(GLenum mode) {Con_Printf("glBegin(mode)\n");}
1212 //void wrapglBeginQuery(GLenum target, GLuint qid) {glBeginQuery(target, qid);}
1213 void wrapglBindAttribLocation(GLuint programObj, GLuint index, const GLchar *name) {glBindAttribLocation(programObj, index, name);}
1214 void wrapglBindFragDataLocation(GLuint programObj, GLuint index, const GLchar *name) {glBindFragDataLocation(programObj, index, name);}
1215 void wrapglBindBuffer(GLenum target, GLuint buffer) {glBindBuffer(target, buffer);}
1216 void wrapglBindFramebuffer(GLenum target, GLuint framebuffer) {glBindFramebuffer(target, framebuffer);}
1217 void wrapglBindRenderbuffer(GLenum target, GLuint renderbuffer) {glBindRenderbuffer(target, renderbuffer);}
1218 void wrapglBindTexture(GLenum target, GLuint texture) {glBindTexture(target, texture);}
1219 void wrapglBlendEquation(GLenum e) {glBlendEquation(e);}
1220 void wrapglBlendFunc(GLenum sfactor, GLenum dfactor) {glBlendFunc(sfactor, dfactor);}
1221 void wrapglBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) {glBufferData(target, size, data, usage);}
1222 void wrapglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) {glBufferSubData(target, offset, size, data);}
1223 void wrapglClear(GLbitfield mask) {glClear(mask);}
1224 void wrapglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {glClearColor(red, green, blue, alpha);}
1225 void wrapglClearDepth(GLclampd depth) {glClearDepthf((float)depth);}
1226 void wrapglClearStencil(GLint s) {glClearStencil(s);}
1227 void wrapglClientActiveTexture(GLenum target) {Con_Printf("glClientActiveTexture(target)\n");}
1228 void wrapglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {Con_Printf("glColor4f(red, green, blue, alpha)\n");}
1229 void wrapglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {Con_Printf("glColor4ub(red, green, blue, alpha)\n");}
1230 void wrapglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {glColorMask(red, green, blue, alpha);}
1231 void wrapglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glColorPointer(size, type, stride, ptr)\n");}
1232 void wrapglCompileShader(GLuint shaderObj) {glCompileShader(shaderObj);}
1233 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);}
1234 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");}
1235 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);}
1236 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");}
1237 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);}
1238 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);}
1239 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");}
1240 void wrapglCullFace(GLenum mode) {glCullFace(mode);}
1241 void wrapglDeleteBuffers(GLsizei n, const GLuint *buffers) {glDeleteBuffers(n, buffers);}
1242 void wrapglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {glDeleteFramebuffers(n, framebuffers);}
1243 void wrapglDeleteShader(GLuint obj) {glDeleteShader(obj);}
1244 void wrapglDeleteProgram(GLuint obj) {glDeleteProgram(obj);}
1245 //void wrapglDeleteQueries(GLsizei n, const GLuint *ids) {glDeleteQueries(n, ids);}
1246 void wrapglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {glDeleteRenderbuffers(n, renderbuffers);}
1247 void wrapglDeleteTextures(GLsizei n, const GLuint *textures) {glDeleteTextures(n, textures);}
1248 void wrapglDepthFunc(GLenum func) {glDepthFunc(func);}
1249 void wrapglDepthMask(GLboolean flag) {glDepthMask(flag);}
1250 void wrapglDepthRange(GLclampd near_val, GLclampd far_val) {glDepthRangef((float)near_val, (float)far_val);}
1251 void wrapglDetachShader(GLuint containerObj, GLuint attachedObj) {glDetachShader(containerObj, attachedObj);}
1252 void wrapglDisable(GLenum cap) {glDisable(cap);}
1253 void wrapglDisableClientState(GLenum cap) {Con_Printf("glDisableClientState(cap)\n");}
1254 void wrapglDisableVertexAttribArray(GLuint index) {glDisableVertexAttribArray(index);}
1255 void wrapglDrawArrays(GLenum mode, GLint first, GLsizei count) {glDrawArrays(mode, first, count);}
1256 void wrapglDrawBuffer(GLenum mode) {Con_Printf("glDrawBuffer(mode)\n");}
1257 void wrapglDrawBuffers(GLsizei n, const GLenum *bufs) {Con_Printf("glDrawBuffers(n, bufs)\n");}
1258 void wrapglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {glDrawElements(mode, count, type, indices);}
1259 //void wrapglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {glDrawRangeElements(mode, start, end, count, type, indices);}
1260 //void wrapglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {glDrawRangeElements(mode, start, end, count, type, indices);}
1261 void wrapglEnable(GLenum cap) {glEnable(cap);}
1262 void wrapglEnableClientState(GLenum cap) {Con_Printf("glEnableClientState(cap)\n");}
1263 void wrapglEnableVertexAttribArray(GLuint index) {glEnableVertexAttribArray(index);}
1264 void wrapglEnd(void) {Con_Printf("glEnd()\n");}
1265 //void wrapglEndQuery(GLenum target) {glEndQuery(target);}
1266 void wrapglFinish(void) {glFinish();}
1267 void wrapglFlush(void) {glFlush();}
1268 void wrapglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);}
1269 void wrapglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {glFramebufferTexture2D(target, attachment, textarget, texture, level);}
1270 void wrapglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {Con_Printf("glFramebufferTexture3D()\n");}
1271 void wrapglGenBuffers(GLsizei n, GLuint *buffers) {glGenBuffers(n, buffers);}
1272 void wrapglGenFramebuffers(GLsizei n, GLuint *framebuffers) {glGenFramebuffers(n, framebuffers);}
1273 //void wrapglGenQueries(GLsizei n, GLuint *ids) {glGenQueries(n, ids);}
1274 void wrapglGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {glGenRenderbuffers(n, renderbuffers);}
1275 void wrapglGenTextures(GLsizei n, GLuint *textures) {glGenTextures(n, textures);}
1276 void wrapglGenerateMipmap(GLenum target) {glGenerateMipmap(target);}
1277 void wrapglGetActiveAttrib(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {glGetActiveAttrib(programObj, index, maxLength, length, size, type, name);}
1278 void wrapglGetActiveUniform(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {glGetActiveUniform(programObj, index, maxLength, length, size, type, name);}
1279 void wrapglGetAttachedShaders(GLuint containerObj, GLsizei maxCount, GLsizei *count, GLuint *obj) {glGetAttachedShaders(containerObj, maxCount, count, obj);}
1280 void wrapglGetBooleanv(GLenum pname, GLboolean *params) {glGetBooleanv(pname, params);}
1281 void wrapglGetCompressedTexImage(GLenum target, GLint lod, void *img) {Con_Printf("glGetCompressedTexImage(target, lod, img)\n");}
1282 void wrapglGetDoublev(GLenum pname, GLdouble *params) {Con_Printf("glGetDoublev(pname, params)\n");}
1283 void wrapglGetFloatv(GLenum pname, GLfloat *params) {glGetFloatv(pname, params);}
1284 void wrapglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) {glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);}
1285 void wrapglGetShaderInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {glGetShaderInfoLog(obj, maxLength, length, infoLog);}
1286 void wrapglGetProgramInfoLog(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {glGetProgramInfoLog(obj, maxLength, length, infoLog);}
1287 void wrapglGetIntegerv(GLenum pname, GLint *params) {glGetIntegerv(pname, params);}
1288 void wrapglGetShaderiv(GLuint obj, GLenum pname, GLint *params) {glGetShaderiv(obj, pname, params);}
1289 void wrapglGetProgramiv(GLuint obj, GLenum pname, GLint *params) {glGetProgramiv(obj, pname, params);}
1290 //void wrapglGetQueryObjectiv(GLuint qid, GLenum pname, GLint *params) {glGetQueryObjectiv(qid, pname, params);}
1291 //void wrapglGetQueryObjectuiv(GLuint qid, GLenum pname, GLuint *params) {glGetQueryObjectuiv(qid, pname, params);}
1292 //void wrapglGetQueryiv(GLenum target, GLenum pname, GLint *params) {glGetQueryiv(target, pname, params);}
1293 void wrapglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) {glGetRenderbufferParameteriv(target, pname, params);}
1294 void wrapglGetShaderSource(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *source) {glGetShaderSource(obj, maxLength, length, source);}
1295 void wrapglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {Con_Printf("glGetTexImage(target, level, format, type, pixels)\n");}
1296 void wrapglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {Con_Printf("glGetTexLevelParameterfv(target, level, pname, params)\n");}
1297 void wrapglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {Con_Printf("glGetTexLevelParameteriv(target, level, pname, params)\n");}
1298 void wrapglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {glGetTexParameterfv(target, pname, params);}
1299 void wrapglGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {glGetTexParameteriv(target, pname, params);}
1300 void wrapglGetUniformfv(GLuint programObj, GLint location, GLfloat *params) {glGetUniformfv(programObj, location, params);}
1301 void wrapglGetUniformiv(GLuint programObj, GLint location, GLint *params) {glGetUniformiv(programObj, location, params);}
1302 void wrapglHint(GLenum target, GLenum mode) {glHint(target, mode);}
1303 void wrapglLineWidth(GLfloat width) {glLineWidth(width);}
1304 void wrapglLinkProgram(GLuint programObj) {glLinkProgram(programObj);}
1305 void wrapglLoadIdentity(void) {Con_Printf("glLoadIdentity()\n");}
1306 void wrapglLoadMatrixf(const GLfloat *m) {Con_Printf("glLoadMatrixf(m)\n");}
1307 void wrapglMatrixMode(GLenum mode) {Con_Printf("glMatrixMode(mode)\n");}
1308 void wrapglMultiTexCoord1f(GLenum target, GLfloat s) {Con_Printf("glMultiTexCoord1f(target, s)\n");}
1309 void wrapglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {Con_Printf("glMultiTexCoord2f(target, s, t)\n");}
1310 void wrapglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {Con_Printf("glMultiTexCoord3f(target, s, t, r)\n");}
1311 void wrapglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {Con_Printf("glMultiTexCoord4f(target, s, t, r, q)\n");}
1312 void wrapglNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glNormalPointer(type, stride, ptr)\n");}
1313 void wrapglPixelStorei(GLenum pname, GLint param) {glPixelStorei(pname, param);}
1314 void wrapglPointSize(GLfloat size) {Con_Printf("glPointSize(size)\n");}
1315 void wrapglPolygonMode(GLenum face, GLenum mode) {Con_Printf("glPolygonMode(face, mode)\n");}
1316 void wrapglPolygonOffset(GLfloat factor, GLfloat units) {glPolygonOffset(factor, units);}
1317 void wrapglPolygonStipple(const GLubyte *mask) {Con_Printf("glPolygonStipple(mask)\n");}
1318 void wrapglReadBuffer(GLenum mode) {Con_Printf("glReadBuffer(mode)\n");}
1319 void wrapglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {glReadPixels(x, y, width, height, format, type, pixels);}
1320 void wrapglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {glRenderbufferStorage(target, internalformat, width, height);}
1321 void wrapglScissor(GLint x, GLint y, GLsizei width, GLsizei height) {glScissor(x, y, width, height);}
1322 void wrapglShaderSource(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length) {glShaderSource(shaderObj, count, string, length);}
1323 void wrapglStencilFunc(GLenum func, GLint ref, GLuint mask) {glStencilFunc(func, ref, mask);}
1324 void wrapglStencilFuncSeparate(GLenum func1, GLenum func2, GLint ref, GLuint mask) {Con_Printf("glStencilFuncSeparate(func1, func2, ref, mask)\n");}
1325 void wrapglStencilMask(GLuint mask) {glStencilMask(mask);}
1326 void wrapglStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {glStencilOp(fail, zfail, zpass);}
1327 void wrapglStencilOpSeparate(GLenum e1, GLenum e2, GLenum e3, GLenum e4) {Con_Printf("glStencilOpSeparate(e1, e2, e3, e4)\n");}
1328 void wrapglTexCoord1f(GLfloat s) {Con_Printf("glTexCoord1f(s)\n");}
1329 void wrapglTexCoord2f(GLfloat s, GLfloat t) {Con_Printf("glTexCoord2f(s, t)\n");}
1330 void wrapglTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {Con_Printf("glTexCoord3f(s, t, r)\n");}
1331 void wrapglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {Con_Printf("glTexCoord4f(s, t, r, q)\n");}
1332 void wrapglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glTexCoordPointer(size, type, stride, ptr)\n");}
1333 void wrapglTexEnvf(GLenum target, GLenum pname, GLfloat param) {Con_Printf("glTexEnvf(target, pname, param)\n");}
1334 void wrapglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {Con_Printf("glTexEnvfv(target, pname, params)\n");}
1335 void wrapglTexEnvi(GLenum target, GLenum pname, GLint param) {Con_Printf("glTexEnvi(target, pname, param)\n");}
1336 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);}
1337 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");}
1338 void wrapglTexParameterf(GLenum target, GLenum pname, GLfloat param) {glTexParameterf(target, pname, param);}
1339 void wrapglTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {glTexParameterfv(target, pname, params);}
1340 void wrapglTexParameteri(GLenum target, GLenum pname, GLint param) {glTexParameteri(target, pname, param);}
1341 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);}
1342 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");}
1343 void wrapglUniform1f(GLint location, GLfloat v0) {glUniform1f(location, v0);}
1344 void wrapglUniform1fv(GLint location, GLsizei count, const GLfloat *value) {glUniform1fv(location, count, value);}
1345 void wrapglUniform1i(GLint location, GLint v0) {glUniform1i(location, v0);}
1346 void wrapglUniform1iv(GLint location, GLsizei count, const GLint *value) {glUniform1iv(location, count, value);}
1347 void wrapglUniform2f(GLint location, GLfloat v0, GLfloat v1) {glUniform2f(location, v0, v1);}
1348 void wrapglUniform2fv(GLint location, GLsizei count, const GLfloat *value) {glUniform2fv(location, count, value);}
1349 void wrapglUniform2i(GLint location, GLint v0, GLint v1) {glUniform2i(location, v0, v1);}
1350 void wrapglUniform2iv(GLint location, GLsizei count, const GLint *value) {glUniform2iv(location, count, value);}
1351 void wrapglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {glUniform3f(location, v0, v1, v2);}
1352 void wrapglUniform3fv(GLint location, GLsizei count, const GLfloat *value) {glUniform3fv(location, count, value);}
1353 void wrapglUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {glUniform3i(location, v0, v1, v2);}
1354 void wrapglUniform3iv(GLint location, GLsizei count, const GLint *value) {glUniform3iv(location, count, value);}
1355 void wrapglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {glUniform4f(location, v0, v1, v2, v3);}
1356 void wrapglUniform4fv(GLint location, GLsizei count, const GLfloat *value) {glUniform4fv(location, count, value);}
1357 void wrapglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {glUniform4i(location, v0, v1, v2, v3);}
1358 void wrapglUniform4iv(GLint location, GLsizei count, const GLint *value) {glUniform4iv(location, count, value);}
1359 void wrapglUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix2fv(location, count, transpose, value);}
1360 void wrapglUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix3fv(location, count, transpose, value);}
1361 void wrapglUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {glUniformMatrix4fv(location, count, transpose, value);}
1362 void wrapglUseProgram(GLuint programObj) {glUseProgram(programObj);}
1363 void wrapglValidateProgram(GLuint programObj) {glValidateProgram(programObj);}
1364 void wrapglVertex2f(GLfloat x, GLfloat y) {Con_Printf("glVertex2f(x, y)\n");}
1365 void wrapglVertex3f(GLfloat x, GLfloat y, GLfloat z) {Con_Printf("glVertex3f(x, y, z)\n");}
1366 void wrapglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {Con_Printf("glVertex4f(x, y, z, w)\n");}
1367 void wrapglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {glVertexAttribPointer(index, size, type, normalized, stride, pointer);}
1368 void wrapglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) {Con_Printf("glVertexPointer(size, type, stride, ptr)\n");}
1369 void wrapglViewport(GLint x, GLint y, GLsizei width, GLsizei height) {glViewport(x, y, width, height);}
1370 void wrapglVertexAttrib1f(GLuint index, GLfloat v0) {glVertexAttrib1f(index, v0);}
1371 //void wrapglVertexAttrib1s(GLuint index, GLshort v0) {glVertexAttrib1s(index, v0);}
1372 //void wrapglVertexAttrib1d(GLuint index, GLdouble v0) {glVertexAttrib1d(index, v0);}
1373 void wrapglVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {glVertexAttrib2f(index, v0, v1);}
1374 //void wrapglVertexAttrib2s(GLuint index, GLshort v0, GLshort v1) {glVertexAttrib2s(index, v0, v1);}
1375 //void wrapglVertexAttrib2d(GLuint index, GLdouble v0, GLdouble v1) {glVertexAttrib2d(index, v0, v1);}
1376 void wrapglVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {glVertexAttrib3f(index, v0, v1, v2);}
1377 //void wrapglVertexAttrib3s(GLuint index, GLshort v0, GLshort v1, GLshort v2) {glVertexAttrib3s(index, v0, v1, v2);}
1378 //void wrapglVertexAttrib3d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2) {glVertexAttrib3d(index, v0, v1, v2);}
1379 void wrapglVertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {glVertexAttrib4f(index, v0, v1, v2, v3);}
1380 //void wrapglVertexAttrib4s(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3) {glVertexAttrib4s(index, v0, v1, v2, v3);}
1381 //void wrapglVertexAttrib4d(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {glVertexAttrib4d(index, v0, v1, v2, v3);}
1382 //void wrapglVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {glVertexAttrib4Nub(index, x, y, z, w);}
1383 void wrapglVertexAttrib1fv(GLuint index, const GLfloat *v) {glVertexAttrib1fv(index, v);}
1384 //void wrapglVertexAttrib1sv(GLuint index, const GLshort *v) {glVertexAttrib1sv(index, v);}
1385 //void wrapglVertexAttrib1dv(GLuint index, const GLdouble *v) {glVertexAttrib1dv(index, v);}
1386 void wrapglVertexAttrib2fv(GLuint index, const GLfloat *v) {glVertexAttrib2fv(index, v);}
1387 //void wrapglVertexAttrib2sv(GLuint index, const GLshort *v) {glVertexAttrib2sv(index, v);}
1388 //void wrapglVertexAttrib2dv(GLuint index, const GLdouble *v) {glVertexAttrib2dv(index, v);}
1389 void wrapglVertexAttrib3fv(GLuint index, const GLfloat *v) {glVertexAttrib3fv(index, v);}
1390 //void wrapglVertexAttrib3sv(GLuint index, const GLshort *v) {glVertexAttrib3sv(index, v);}
1391 //void wrapglVertexAttrib3dv(GLuint index, const GLdouble *v) {glVertexAttrib3dv(index, v);}
1392 void wrapglVertexAttrib4fv(GLuint index, const GLfloat *v) {glVertexAttrib4fv(index, v);}
1393 //void wrapglVertexAttrib4sv(GLuint index, const GLshort *v) {glVertexAttrib4sv(index, v);}
1394 //void wrapglVertexAttrib4dv(GLuint index, const GLdouble *v) {glVertexAttrib4dv(index, v);}
1395 //void wrapglVertexAttrib4iv(GLuint index, const GLint *v) {glVertexAttrib4iv(index, v);}
1396 //void wrapglVertexAttrib4bv(GLuint index, const GLbyte *v) {glVertexAttrib4bv(index, v);}
1397 //void wrapglVertexAttrib4ubv(GLuint index, const GLubyte *v) {glVertexAttrib4ubv(index, v);}
1398 //void wrapglVertexAttrib4usv(GLuint index, const GLushort *v) {glVertexAttrib4usv(index, GLushort v);}
1399 //void wrapglVertexAttrib4uiv(GLuint index, const GLuint *v) {glVertexAttrib4uiv(index, v);}
1400 //void wrapglVertexAttrib4Nbv(GLuint index, const GLbyte *v) {glVertexAttrib4Nbv(index, v);}
1401 //void wrapglVertexAttrib4Nsv(GLuint index, const GLshort *v) {glVertexAttrib4Nsv(index, v);}
1402 //void wrapglVertexAttrib4Niv(GLuint index, const GLint *v) {glVertexAttrib4Niv(index, v);}
1403 //void wrapglVertexAttrib4Nubv(GLuint index, const GLubyte *v) {glVertexAttrib4Nubv(index, v);}
1404 //void wrapglVertexAttrib4Nusv(GLuint index, const GLushort *v) {glVertexAttrib4Nusv(index, GLushort v);}
1405 //void wrapglVertexAttrib4Nuiv(GLuint index, const GLuint *v) {glVertexAttrib4Nuiv(index, v);}
1406 //void wrapglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {glGetVertexAttribdv(index, pname, params);}
1407 void wrapglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {glGetVertexAttribfv(index, pname, params);}
1408 void wrapglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {glGetVertexAttribiv(index, pname, params);}
1409 void wrapglGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid **pointer) {glGetVertexAttribPointerv(index, pname, pointer);}
1410
1411 void GLES_Init(void)
1412 {
1413         qglIsBufferARB = wrapglIsBuffer;
1414         qglIsEnabled = wrapglIsEnabled;
1415         qglIsFramebufferEXT = wrapglIsFramebuffer;
1416 //      qglIsQueryARB = wrapglIsQuery;
1417         qglIsRenderbufferEXT = wrapglIsRenderbuffer;
1418 //      qglUnmapBufferARB = wrapglUnmapBuffer;
1419         qglCheckFramebufferStatusEXT = wrapglCheckFramebufferStatus;
1420         qglGetError = wrapglGetError;
1421         qglCreateProgram = wrapglCreateProgram;
1422         qglCreateShader = wrapglCreateShader;
1423 //      qglGetHandleARB = wrapglGetHandle;
1424         qglGetAttribLocation = wrapglGetAttribLocation;
1425         qglGetUniformLocation = wrapglGetUniformLocation;
1426 //      qglMapBufferARB = wrapglMapBuffer;
1427         qglGetString = wrapglGetString;
1428 //      qglActiveStencilFaceEXT = wrapglActiveStencilFace;
1429         qglActiveTexture = wrapglActiveTexture;
1430         qglAlphaFunc = wrapglAlphaFunc;
1431         qglArrayElement = wrapglArrayElement;
1432         qglAttachShader = wrapglAttachShader;
1433         qglBegin = wrapglBegin;
1434 //      qglBeginQueryARB = wrapglBeginQuery;
1435         qglBindAttribLocation = wrapglBindAttribLocation;
1436         qglBindFragDataLocation = wrapglBindFragDataLocation;
1437         qglBindBufferARB = wrapglBindBuffer;
1438         qglBindFramebufferEXT = wrapglBindFramebuffer;
1439         qglBindRenderbufferEXT = wrapglBindRenderbuffer;
1440         qglBindTexture = wrapglBindTexture;
1441         qglBlendEquationEXT = wrapglBlendEquation;
1442         qglBlendFunc = wrapglBlendFunc;
1443         qglBufferDataARB = wrapglBufferData;
1444         qglBufferSubDataARB = wrapglBufferSubData;
1445         qglClear = wrapglClear;
1446         qglClearColor = wrapglClearColor;
1447         qglClearDepth = wrapglClearDepth;
1448         qglClearStencil = wrapglClearStencil;
1449         qglClientActiveTexture = wrapglClientActiveTexture;
1450         qglColor4f = wrapglColor4f;
1451         qglColor4ub = wrapglColor4ub;
1452         qglColorMask = wrapglColorMask;
1453         qglColorPointer = wrapglColorPointer;
1454         qglCompileShader = wrapglCompileShader;
1455         qglCompressedTexImage2DARB = wrapglCompressedTexImage2D;
1456         qglCompressedTexImage3DARB = wrapglCompressedTexImage3D;
1457         qglCompressedTexSubImage2DARB = wrapglCompressedTexSubImage2D;
1458         qglCompressedTexSubImage3DARB = wrapglCompressedTexSubImage3D;
1459         qglCopyTexImage2D = wrapglCopyTexImage2D;
1460         qglCopyTexSubImage2D = wrapglCopyTexSubImage2D;
1461         qglCopyTexSubImage3D = wrapglCopyTexSubImage3D;
1462         qglCullFace = wrapglCullFace;
1463         qglDeleteBuffersARB = wrapglDeleteBuffers;
1464         qglDeleteFramebuffersEXT = wrapglDeleteFramebuffers;
1465         qglDeleteProgram = wrapglDeleteProgram;
1466         qglDeleteShader = wrapglDeleteShader;
1467 //      qglDeleteQueriesARB = wrapglDeleteQueries;
1468         qglDeleteRenderbuffersEXT = wrapglDeleteRenderbuffers;
1469         qglDeleteTextures = wrapglDeleteTextures;
1470         qglDepthFunc = wrapglDepthFunc;
1471         qglDepthMask = wrapglDepthMask;
1472         qglDepthRange = wrapglDepthRange;
1473         qglDetachShader = wrapglDetachShader;
1474         qglDisable = wrapglDisable;
1475         qglDisableClientState = wrapglDisableClientState;
1476         qglDisableVertexAttribArray = wrapglDisableVertexAttribArray;
1477         qglDrawArrays = wrapglDrawArrays;
1478 //      qglDrawBuffer = wrapglDrawBuffer;
1479 //      qglDrawBuffersARB = wrapglDrawBuffers;
1480         qglDrawElements = wrapglDrawElements;
1481 //      qglDrawRangeElements = wrapglDrawRangeElements;
1482         qglEnable = wrapglEnable;
1483         qglEnableClientState = wrapglEnableClientState;
1484         qglEnableVertexAttribArray = wrapglEnableVertexAttribArray;
1485         qglEnd = wrapglEnd;
1486 //      qglEndQueryARB = wrapglEndQuery;
1487         qglFinish = wrapglFinish;
1488         qglFlush = wrapglFlush;
1489         qglFramebufferRenderbufferEXT = wrapglFramebufferRenderbuffer;
1490         qglFramebufferTexture2DEXT = wrapglFramebufferTexture2D;
1491         qglFramebufferTexture3DEXT = wrapglFramebufferTexture3D;
1492         qglGenBuffersARB = wrapglGenBuffers;
1493         qglGenFramebuffersEXT = wrapglGenFramebuffers;
1494 //      qglGenQueriesARB = wrapglGenQueries;
1495         qglGenRenderbuffersEXT = wrapglGenRenderbuffers;
1496         qglGenTextures = wrapglGenTextures;
1497         qglGenerateMipmapEXT = wrapglGenerateMipmap;
1498         qglGetActiveAttrib = wrapglGetActiveAttrib;
1499         qglGetActiveUniform = wrapglGetActiveUniform;
1500         qglGetAttachedShaders = wrapglGetAttachedShaders;
1501         qglGetBooleanv = wrapglGetBooleanv;
1502 //      qglGetCompressedTexImageARB = wrapglGetCompressedTexImage;
1503         qglGetDoublev = wrapglGetDoublev;
1504         qglGetFloatv = wrapglGetFloatv;
1505         qglGetFramebufferAttachmentParameterivEXT = wrapglGetFramebufferAttachmentParameteriv;
1506         qglGetProgramInfoLog = wrapglGetProgramInfoLog;
1507         qglGetShaderInfoLog = wrapglGetShaderInfoLog;
1508         qglGetIntegerv = wrapglGetIntegerv;
1509         qglGetShaderiv = wrapglGetShaderiv;
1510         qglGetProgramiv = wrapglGetProgramiv;
1511 //      qglGetQueryObjectivARB = wrapglGetQueryObjectiv;
1512 //      qglGetQueryObjectuivARB = wrapglGetQueryObjectuiv;
1513 //      qglGetQueryivARB = wrapglGetQueryiv;
1514         qglGetRenderbufferParameterivEXT = wrapglGetRenderbufferParameteriv;
1515         qglGetShaderSource = wrapglGetShaderSource;
1516         qglGetTexImage = wrapglGetTexImage;
1517         qglGetTexLevelParameterfv = wrapglGetTexLevelParameterfv;
1518         qglGetTexLevelParameteriv = wrapglGetTexLevelParameteriv;
1519         qglGetTexParameterfv = wrapglGetTexParameterfv;
1520         qglGetTexParameteriv = wrapglGetTexParameteriv;
1521         qglGetUniformfv = wrapglGetUniformfv;
1522         qglGetUniformiv = wrapglGetUniformiv;
1523         qglHint = wrapglHint;
1524         qglLineWidth = wrapglLineWidth;
1525         qglLinkProgram = wrapglLinkProgram;
1526         qglLoadIdentity = wrapglLoadIdentity;
1527         qglLoadMatrixf = wrapglLoadMatrixf;
1528         qglMatrixMode = wrapglMatrixMode;
1529         qglMultiTexCoord1f = wrapglMultiTexCoord1f;
1530         qglMultiTexCoord2f = wrapglMultiTexCoord2f;
1531         qglMultiTexCoord3f = wrapglMultiTexCoord3f;
1532         qglMultiTexCoord4f = wrapglMultiTexCoord4f;
1533         qglNormalPointer = wrapglNormalPointer;
1534         qglPixelStorei = wrapglPixelStorei;
1535         qglPointSize = wrapglPointSize;
1536         qglPolygonMode = wrapglPolygonMode;
1537         qglPolygonOffset = wrapglPolygonOffset;
1538 //      qglPolygonStipple = wrapglPolygonStipple;
1539         qglReadBuffer = wrapglReadBuffer;
1540         qglReadPixels = wrapglReadPixels;
1541         qglRenderbufferStorageEXT = wrapglRenderbufferStorage;
1542         qglScissor = wrapglScissor;
1543         qglShaderSource = wrapglShaderSource;
1544         qglStencilFunc = wrapglStencilFunc;
1545         qglStencilFuncSeparate = wrapglStencilFuncSeparate;
1546         qglStencilMask = wrapglStencilMask;
1547         qglStencilOp = wrapglStencilOp;
1548         qglStencilOpSeparate = wrapglStencilOpSeparate;
1549         qglTexCoord1f = wrapglTexCoord1f;
1550         qglTexCoord2f = wrapglTexCoord2f;
1551         qglTexCoord3f = wrapglTexCoord3f;
1552         qglTexCoord4f = wrapglTexCoord4f;
1553         qglTexCoordPointer = wrapglTexCoordPointer;
1554         qglTexEnvf = wrapglTexEnvf;
1555         qglTexEnvfv = wrapglTexEnvfv;
1556         qglTexEnvi = wrapglTexEnvi;
1557         qglTexImage2D = wrapglTexImage2D;
1558         qglTexImage3D = wrapglTexImage3D;
1559         qglTexParameterf = wrapglTexParameterf;
1560         qglTexParameterfv = wrapglTexParameterfv;
1561         qglTexParameteri = wrapglTexParameteri;
1562         qglTexSubImage2D = wrapglTexSubImage2D;
1563         qglTexSubImage3D = wrapglTexSubImage3D;
1564         qglUniform1f = wrapglUniform1f;
1565         qglUniform1fv = wrapglUniform1fv;
1566         qglUniform1i = wrapglUniform1i;
1567         qglUniform1iv = wrapglUniform1iv;
1568         qglUniform2f = wrapglUniform2f;
1569         qglUniform2fv = wrapglUniform2fv;
1570         qglUniform2i = wrapglUniform2i;
1571         qglUniform2iv = wrapglUniform2iv;
1572         qglUniform3f = wrapglUniform3f;
1573         qglUniform3fv = wrapglUniform3fv;
1574         qglUniform3i = wrapglUniform3i;
1575         qglUniform3iv = wrapglUniform3iv;
1576         qglUniform4f = wrapglUniform4f;
1577         qglUniform4fv = wrapglUniform4fv;
1578         qglUniform4i = wrapglUniform4i;
1579         qglUniform4iv = wrapglUniform4iv;
1580         qglUniformMatrix2fv = wrapglUniformMatrix2fv;
1581         qglUniformMatrix3fv = wrapglUniformMatrix3fv;
1582         qglUniformMatrix4fv = wrapglUniformMatrix4fv;
1583         qglUseProgram = wrapglUseProgram;
1584         qglValidateProgram = wrapglValidateProgram;
1585         qglVertex2f = wrapglVertex2f;
1586         qglVertex3f = wrapglVertex3f;
1587         qglVertex4f = wrapglVertex4f;
1588         qglVertexAttribPointer = wrapglVertexAttribPointer;
1589         qglVertexPointer = wrapglVertexPointer;
1590         qglViewport = wrapglViewport;
1591         qglVertexAttrib1f = wrapglVertexAttrib1f;
1592 //      qglVertexAttrib1s = wrapglVertexAttrib1s;
1593 //      qglVertexAttrib1d = wrapglVertexAttrib1d;
1594         qglVertexAttrib2f = wrapglVertexAttrib2f;
1595 //      qglVertexAttrib2s = wrapglVertexAttrib2s;
1596 //      qglVertexAttrib2d = wrapglVertexAttrib2d;
1597         qglVertexAttrib3f = wrapglVertexAttrib3f;
1598 //      qglVertexAttrib3s = wrapglVertexAttrib3s;
1599 //      qglVertexAttrib3d = wrapglVertexAttrib3d;
1600         qglVertexAttrib4f = wrapglVertexAttrib4f;
1601 //      qglVertexAttrib4s = wrapglVertexAttrib4s;
1602 //      qglVertexAttrib4d = wrapglVertexAttrib4d;
1603 //      qglVertexAttrib4Nub = wrapglVertexAttrib4Nub;
1604         qglVertexAttrib1fv = wrapglVertexAttrib1fv;
1605 //      qglVertexAttrib1sv = wrapglVertexAttrib1sv;
1606 //      qglVertexAttrib1dv = wrapglVertexAttrib1dv;
1607         qglVertexAttrib2fv = wrapglVertexAttrib2fv;
1608 //      qglVertexAttrib2sv = wrapglVertexAttrib2sv;
1609 //      qglVertexAttrib2dv = wrapglVertexAttrib2dv;
1610         qglVertexAttrib3fv = wrapglVertexAttrib3fv;
1611 //      qglVertexAttrib3sv = wrapglVertexAttrib3sv;
1612 //      qglVertexAttrib3dv = wrapglVertexAttrib3dv;
1613         qglVertexAttrib4fv = wrapglVertexAttrib4fv;
1614 //      qglVertexAttrib4sv = wrapglVertexAttrib4sv;
1615 //      qglVertexAttrib4dv = wrapglVertexAttrib4dv;
1616 //      qglVertexAttrib4iv = wrapglVertexAttrib4iv;
1617 //      qglVertexAttrib4bv = wrapglVertexAttrib4bv;
1618 //      qglVertexAttrib4ubv = wrapglVertexAttrib4ubv;
1619 //      qglVertexAttrib4usv = wrapglVertexAttrib4usv;
1620 //      qglVertexAttrib4uiv = wrapglVertexAttrib4uiv;
1621 //      qglVertexAttrib4Nbv = wrapglVertexAttrib4Nbv;
1622 //      qglVertexAttrib4Nsv = wrapglVertexAttrib4Nsv;
1623 //      qglVertexAttrib4Niv = wrapglVertexAttrib4Niv;
1624 //      qglVertexAttrib4Nubv = wrapglVertexAttrib4Nubv;
1625 //      qglVertexAttrib4Nusv = wrapglVertexAttrib4Nusv;
1626 //      qglVertexAttrib4Nuiv = wrapglVertexAttrib4Nuiv;
1627 //      qglGetVertexAttribdv = wrapglGetVertexAttribdv;
1628         qglGetVertexAttribfv = wrapglGetVertexAttribfv;
1629         qglGetVertexAttribiv = wrapglGetVertexAttribiv;
1630         qglGetVertexAttribPointerv = wrapglGetVertexAttribPointerv;
1631
1632         gl_renderer = (const char *)qglGetString(GL_RENDERER);
1633         gl_vendor = (const char *)qglGetString(GL_VENDOR);
1634         gl_version = (const char *)qglGetString(GL_VERSION);
1635         gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
1636
1637         if (!gl_extensions)
1638                 gl_extensions = "";
1639         if (!gl_platformextensions)
1640                 gl_platformextensions = "";
1641
1642         Con_Printf("GL_VENDOR: %s\n", gl_vendor);
1643         Con_Printf("GL_RENDERER: %s\n", gl_renderer);
1644         Con_Printf("GL_VERSION: %s\n", gl_version);
1645         Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
1646         Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
1647
1648         // LordHavoc: report supported extensions
1649         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
1650
1651         vid.support.gl20shaders = true;
1652         vid.support.amd_texture_texture4 = false;
1653         vid.support.arb_depth_texture = false;
1654         vid.support.arb_draw_buffers = false;
1655         vid.support.arb_multitexture = false;
1656         vid.support.arb_occlusion_query = false;
1657         vid.support.arb_shadow = false;
1658         vid.support.arb_texture_compression = false; // different (vendor-specific) formats than on desktop OpenGL...
1659         vid.support.arb_texture_cube_map = true;
1660         vid.support.arb_texture_env_combine = false;
1661         vid.support.arb_texture_gather = false;
1662         vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
1663         vid.support.arb_vertex_buffer_object = true;
1664         vid.support.ati_separate_stencil = false;
1665         vid.support.ext_blend_minmax = false;
1666         vid.support.ext_blend_subtract = true;
1667         vid.support.ext_draw_range_elements = true;
1668         vid.support.ext_framebuffer_object = false;//true;
1669         vid.support.ext_stencil_two_side = false;
1670         vid.support.ext_texture_3d = false;//SDL_GL_ExtensionSupported("GL_OES_texture_3D"); // iPhoneOS does not support 3D textures, odd...
1671         vid.support.ext_texture_compression_s3tc = false;
1672         vid.support.ext_texture_edge_clamp = true;
1673         vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
1674
1675         qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
1676         if (vid.support.ext_texture_filter_anisotropic)
1677                 qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
1678         if (vid.support.arb_texture_cube_map)
1679                 qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, (GLint*)&vid.maxtexturesize_cubemap);
1680         if (vid.support.ext_texture_3d)
1681                 qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_3d);
1682         Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
1683         Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
1684
1685         // verify that cubemap textures are really supported
1686         if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
1687                 vid.support.arb_texture_cube_map = false;
1688
1689         // verify that 3d textures are really supported
1690         if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
1691         {
1692                 vid.support.ext_texture_3d = false;
1693                 Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
1694         }
1695
1696         vid.texunits = 4;
1697         vid.teximageunits = 8;
1698         vid.texarrayunits = 5;
1699         vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
1700         vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
1701         vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
1702         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" : "");
1703         vid.renderpath = RENDERPATH_GLES2;
1704         vid.useinterleavedarrays = false;
1705
1706         // VorteX: set other info (maybe place them in VID_InitMode?)
1707         extern cvar_t gl_info_vendor;
1708         extern cvar_t gl_info_renderer;
1709         extern cvar_t gl_info_version;
1710         extern cvar_t gl_info_platform;
1711         extern cvar_t gl_info_driver;
1712         Cvar_SetQuick(&gl_info_vendor, gl_vendor);
1713         Cvar_SetQuick(&gl_info_renderer, gl_renderer);
1714         Cvar_SetQuick(&gl_info_version, gl_version);
1715         Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
1716         Cvar_SetQuick(&gl_info_driver, gl_driver);
1717 }
1718 #endif
1719
1720 void *GL_GetProcAddress(const char *name)
1721 {
1722         void *p = NULL;
1723         p = SDL_GL_GetProcAddress(name);
1724         return p;
1725 }
1726
1727 static qboolean vid_sdl_initjoysticksystem = false;
1728
1729 void VID_Init (void)
1730 {
1731 #ifndef __IPHONEOS__
1732 #ifdef MACOSX
1733         Cvar_RegisterVariable(&apple_mouse_noaccel);
1734 #endif
1735 #endif
1736         Cvar_RegisterVariable(&vid_soft);
1737         Cvar_RegisterVariable(&vid_soft_threads);
1738         Cvar_RegisterVariable(&vid_soft_interlace);
1739         Cvar_RegisterVariable(&joy_detected);
1740         Cvar_RegisterVariable(&joy_enable);
1741         Cvar_RegisterVariable(&joy_index);
1742         Cvar_RegisterVariable(&joy_axisforward);
1743         Cvar_RegisterVariable(&joy_axisside);
1744         Cvar_RegisterVariable(&joy_axisup);
1745         Cvar_RegisterVariable(&joy_axispitch);
1746         Cvar_RegisterVariable(&joy_axisyaw);
1747         //Cvar_RegisterVariable(&joy_axisroll);
1748         Cvar_RegisterVariable(&joy_deadzoneforward);
1749         Cvar_RegisterVariable(&joy_deadzoneside);
1750         Cvar_RegisterVariable(&joy_deadzoneup);
1751         Cvar_RegisterVariable(&joy_deadzonepitch);
1752         Cvar_RegisterVariable(&joy_deadzoneyaw);
1753         //Cvar_RegisterVariable(&joy_deadzoneroll);
1754         Cvar_RegisterVariable(&joy_sensitivityforward);
1755         Cvar_RegisterVariable(&joy_sensitivityside);
1756         Cvar_RegisterVariable(&joy_sensitivityup);
1757         Cvar_RegisterVariable(&joy_sensitivitypitch);
1758         Cvar_RegisterVariable(&joy_sensitivityyaw);
1759         //Cvar_RegisterVariable(&joy_sensitivityroll);
1760         Cvar_RegisterVariable(&joy_axiskeyevents);
1761 #ifdef __IPHONEOS__
1762         Cvar_SetValueQuick(&vid_touchscreen, 1);
1763 #endif
1764
1765 #ifdef SDL_R_RESTART
1766         R_RegisterModule("SDL", sdl_start, sdl_shutdown, sdl_newmap, NULL, NULL);
1767 #endif
1768
1769         if (SDL_Init(SDL_INIT_VIDEO) < 0)
1770                 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
1771         vid_sdl_initjoysticksystem = SDL_InitSubSystem(SDL_INIT_JOYSTICK) >= 0;
1772         if (vid_sdl_initjoysticksystem)
1773                 Con_Printf("Failed to init SDL joystick subsystem: %s\n", SDL_GetError());
1774         vid_isfullscreen = false;
1775 }
1776
1777 #if SETVIDEOMODE
1778 // set the icon (we dont use SDL here since it would be too much a PITA)
1779 #ifdef WIN32
1780 #include "resource.h"
1781 #include <SDL_syswm.h>
1782 static void VID_SetCaption(void)
1783 {
1784     SDL_SysWMinfo       info;
1785         HICON                   icon;
1786
1787         // set the caption
1788         SDL_WM_SetCaption( gamename, NULL );
1789
1790         // get the HWND handle
1791     SDL_VERSION( &info.version );
1792         if( !SDL_GetWMInfo( &info ) )
1793                 return;
1794
1795         icon = LoadIcon( GetModuleHandle( NULL ), MAKEINTRESOURCE( IDI_ICON1 ) );
1796 #ifndef _W64 //If Windows 64bit data types don't exist
1797 #ifndef SetClassLongPtr
1798 #define SetClassLongPtr SetClassLong
1799 #endif
1800 #ifndef GCLP_HICON
1801 #define GCLP_HICON GCL_HICON
1802 #endif
1803 #ifndef LONG_PTR
1804 #define LONG_PTR LONG
1805 #endif
1806 #endif
1807         SetClassLongPtr( info.window, GCLP_HICON, (LONG_PTR)icon );
1808 }
1809 static void VID_SetIcon_Pre(void)
1810 {
1811 }
1812 static void VID_SetIcon_Post(void)
1813 {
1814 }
1815 #else
1816 // Adding the OS independent XPM version --blub
1817 #include "darkplaces.xpm"
1818 #include "nexuiz.xpm"
1819 static SDL_Surface *icon = NULL;
1820 static void VID_SetIcon_Pre(void)
1821 {
1822         /*
1823          * Somewhat restricted XPM reader. Only supports XPMs saved by GIMP 2.4 at
1824          * default settings with less than 91 colors and transparency.
1825          */
1826
1827         int width, height, colors, isize, i, j;
1828         int thenone = -1;
1829         static SDL_Color palette[256];
1830         unsigned short palenc[256]; // store color id by char
1831         char *xpm;
1832         char **idata, *data;
1833         const SDL_version *version;
1834
1835         version = SDL_Linked_Version();
1836         // only use non-XPM icon support in SDL v1.3 and higher
1837         // SDL v1.2 does not support "smooth" transparency, and thus is better
1838         // off the xpm way
1839         if(version->major >= 2 || (version->major == 1 && version->minor >= 3))
1840         {
1841                 data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1842                 if(data)
1843                 {
1844                         unsigned int red = 0x00FF0000;
1845                         unsigned int green = 0x0000FF00;
1846                         unsigned int blue = 0x000000FF;
1847                         unsigned int alpha = 0xFF000000;
1848                         width = image_width;
1849                         height = image_height;
1850
1851                         // reallocate with malloc, as this is in tempmempool (do not want)
1852                         xpm = data;
1853                         data = malloc(width * height * 4);
1854                         memcpy(data, xpm, width * height * 4);
1855                         Mem_Free(xpm);
1856                         xpm = NULL;
1857
1858                         icon = SDL_CreateRGBSurface(SDL_SRCALPHA, width, height, 32, LittleLong(red), LittleLong(green), LittleLong(blue), LittleLong(alpha));
1859
1860                         if(icon == NULL) {
1861                                 Con_Printf(     "Failed to create surface for the window Icon!\n"
1862                                                 "%s\n", SDL_GetError());
1863                                 free(data);
1864                                 return;
1865                         }
1866
1867                         icon->pixels = data;
1868                 }
1869         }
1870
1871         // we only get here if non-XPM icon was missing, or SDL version is not
1872         // sufficient for transparent non-XPM icons
1873         if(!icon)
1874         {
1875                 xpm = (char *) FS_LoadFile("darkplaces-icon.xpm", tempmempool, false, NULL);
1876                 idata = NULL;
1877                 if(xpm)
1878                         idata = XPM_DecodeString(xpm);
1879                 if(!idata)
1880                         idata = ENGINE_ICON;
1881                 if(xpm)
1882                         Mem_Free(xpm);
1883
1884                 data = idata[0];
1885
1886                 if(sscanf(data, "%i %i %i %i", &width, &height, &colors, &isize) != 4)
1887                 {
1888                         // NOTE: Only 1-char colornames are supported
1889                         Con_Printf("Sorry, but this does not even look similar to an XPM.\n");
1890                         return;
1891                 }
1892
1893                 if(isize != 1)
1894                 {
1895                         // NOTE: Only 1-char colornames are supported
1896                         Con_Printf("This XPM's palette is either huge or idiotically unoptimized. It's key size is %i\n", isize);
1897                         return;
1898                 }
1899
1900                 for(i = 0; i < colors; ++i)
1901                 {
1902                         unsigned int r, g, b;
1903                         char idx;
1904
1905                         if(sscanf(idata[i+1], "%c c #%02x%02x%02x", &idx, &r, &g, &b) != 4)
1906                         {
1907                                 char foo[2];
1908                                 if(sscanf(idata[i+1], "%c c Non%1[e]", &idx, foo) != 2) // I take the DailyWTF credit for this. --div0
1909                                 {
1910                                         Con_Printf("This XPM's palette looks odd. Can't continue.\n");
1911                                         return;
1912                                 }
1913                                 else
1914                                 {
1915                                         palette[i].r = 255; // color key
1916                                         palette[i].g = 0;
1917                                         palette[i].b = 255;
1918                                         thenone = i; // weeeee
1919                                 }
1920                         }
1921                         else
1922                         {
1923                                 palette[i].r = r - (r == 255 && g == 0 && b == 255); // change 255/0/255 pink to 254/0/255 for color key
1924                                 palette[i].g = g;
1925                                 palette[i].b = b;
1926                         }
1927
1928                         palenc[(unsigned char) idx] = i;
1929                 }
1930
1931                 // allocate the image data
1932                 data = (char*) malloc(width*height);
1933
1934                 for(j = 0; j < height; ++j)
1935                 {
1936                         for(i = 0; i < width; ++i)
1937                         {
1938                                 // casting to the safest possible datatypes ^^
1939                                 data[j * width + i] = palenc[((unsigned char*)idata[colors+j+1])[i]];
1940                         }
1941                 }
1942
1943                 if(icon != NULL)
1944                 {
1945                         // SDL_FreeSurface should free the data too
1946                         // but for completeness' sake...
1947                         if(icon->flags & SDL_PREALLOC)
1948                         {
1949                                 free(icon->pixels);
1950                                 icon->pixels = NULL; // safety
1951                         }
1952                         SDL_FreeSurface(icon);
1953                 }
1954
1955                 icon = SDL_CreateRGBSurface(SDL_SRCCOLORKEY, width, height, 8, 0,0,0,0);// rmask, gmask, bmask, amask); no mask needed
1956                 // 8 bit surfaces get an empty palette allocated according to the docs
1957                 // so it's a palette image for sure :) no endian check necessary for the mask
1958
1959                 if(icon == NULL) {
1960                         Con_Printf(     "Failed to create surface for the window Icon!\n"
1961                                         "%s\n", SDL_GetError());
1962                         free(data);
1963                         return;
1964                 }
1965
1966                 icon->pixels = data;
1967                 SDL_SetPalette(icon, SDL_PHYSPAL|SDL_LOGPAL, palette, 0, colors);
1968                 SDL_SetColorKey(icon, SDL_SRCCOLORKEY, thenone);
1969         }
1970
1971         SDL_WM_SetIcon(icon, NULL);
1972 }
1973 static void VID_SetIcon_Post(void)
1974 {
1975 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
1976 // LordHavoc: info.info.x11.lock_func and accompanying code do not seem to compile with SDL 1.3
1977 #if SDL_VIDEO_DRIVER_X11 && !SDL_VIDEO_DRIVER_QUARTZ
1978         int j;
1979         char *data;
1980         const SDL_version *version;
1981
1982         version = SDL_Linked_Version();
1983         // only use non-XPM icon support in SDL v1.3 and higher
1984         // SDL v1.2 does not support "smooth" transparency, and thus is better
1985         // off the xpm way
1986         if(!(version->major >= 2 || (version->major == 1 && version->minor >= 3)))
1987         {
1988                 // in this case, we did not set the good icon yet
1989                 SDL_SysWMinfo info;
1990                 SDL_VERSION(&info.version);
1991                 if(SDL_GetWMInfo(&info) == 1 && info.subsystem == SDL_SYSWM_X11)
1992                 {
1993                         data = (char *) loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
1994                         if(data)
1995                         {
1996                                 // use _NET_WM_ICON too
1997                                 static long netwm_icon[MAX_NETWM_ICON];
1998                                 int pos = 0;
1999                                 int i = 1;
2000
2001                                 while(data)
2002                                 {
2003                                         if(pos + 2 * image_width * image_height < MAX_NETWM_ICON)
2004                                         {
2005                                                 netwm_icon[pos++] = image_width;
2006                                                 netwm_icon[pos++] = image_height;
2007                                                 for(i = 0; i < image_height; ++i)
2008                                                         for(j = 0; j < image_width; ++j)
2009                                                                 netwm_icon[pos++] = BuffLittleLong((unsigned char *) &data[(i*image_width+j)*4]);
2010                                         }
2011                                         else
2012                                         {
2013                                                 Con_Printf("Skipping NETWM icon #%d because there is no space left\n", i);
2014                                         }
2015                                         ++i;
2016                                         Mem_Free(data);
2017                                         data = (char *) loadimagepixelsbgra(va("darkplaces-icon%d", i), false, false, false, NULL);
2018                                 }
2019
2020                                 info.info.x11.lock_func();
2021                                 {
2022                                         Atom net_wm_icon = XInternAtom(info.info.x11.display, "_NET_WM_ICON", false);
2023                                         XChangeProperty(info.info.x11.display, info.info.x11.wmwindow, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (const unsigned char *) netwm_icon, pos);
2024                                 }
2025                                 info.info.x11.unlock_func();
2026                         }
2027                 }
2028         }
2029 #endif
2030 #endif
2031 }
2032
2033
2034 static void VID_SetCaption(void)
2035 {
2036         SDL_WM_SetCaption( gamename, NULL );
2037 }
2038 #endif
2039 #endif
2040
2041 static void VID_OutputVersion(void)
2042 {
2043         const SDL_version *version;
2044         version = SDL_Linked_Version();
2045         Con_Printf(     "Linked against SDL version %d.%d.%d\n"
2046                                         "Using SDL library version %d.%d.%d\n",
2047                                         SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL,
2048                                         version->major, version->minor, version->patch );
2049 }
2050
2051 qboolean VID_InitModeGL(viddef_mode_t *mode)
2052 {
2053         int i;
2054 #if SETVIDEOMODE
2055         static int notfirstvideomode = false;
2056         int flags = SDL_OPENGL;
2057 #else
2058         int windowflags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
2059 #endif
2060         const char *drivername;
2061
2062         win_half_width = mode->width>>1;
2063         win_half_height = mode->height>>1;
2064
2065         if(vid_resizable.integer)
2066 #if SETVIDEOMODE
2067                 flags |= SDL_RESIZABLE;
2068 #else
2069                 windowflags |= SDL_WINDOW_RESIZABLE;
2070 #endif
2071
2072         VID_OutputVersion();
2073
2074 #if SETVIDEOMODE
2075         /*
2076         SDL 1.2 Hack
2077                 We cant switch from one OpenGL video mode to another.
2078                 Thus we first switch to some stupid 2D mode and then back to OpenGL.
2079         */
2080         if (notfirstvideomode)
2081                 SDL_SetVideoMode( 0, 0, 0, 0 );
2082         notfirstvideomode = true;
2083 #endif
2084
2085         // SDL usually knows best
2086         drivername = NULL;
2087
2088 // 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
2089         i = COM_CheckParm("-gl_driver");
2090         if (i && i < com_argc - 1)
2091                 drivername = com_argv[i + 1];
2092         if (SDL_GL_LoadLibrary(drivername) < 0)
2093         {
2094                 Con_Printf("Unable to load GL driver \"%s\": %s\n", drivername, SDL_GetError());
2095                 return false;
2096         }
2097
2098 #ifdef __IPHONEOS__
2099         // mobile platforms are always fullscreen, we'll get the resolution after opening the window
2100         mode->fullscreen = true;
2101         // hide the menu with SDL_WINDOW_BORDERLESS
2102         windowflags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
2103 #else
2104         if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
2105         {
2106                 VID_Shutdown();
2107                 Con_Print("Required OpenGL function glGetString not found\n");
2108                 return false;
2109         }
2110 #endif
2111
2112         // Knghtbrd: should do platform-specific extension string function here
2113
2114         vid_isfullscreen = false;
2115         if (mode->fullscreen) {
2116 #if SETVIDEOMODE
2117                 flags |= SDL_FULLSCREEN;
2118 #else
2119                 windowflags |= SDL_WINDOW_FULLSCREEN;
2120 #endif
2121                 vid_isfullscreen = true;
2122         }
2123         //flags |= SDL_HWSURFACE;
2124
2125         SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
2126         if (mode->bitsperpixel >= 32)
2127         {
2128                 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 8);
2129                 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 8);
2130                 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 8);
2131                 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8);
2132                 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24);
2133                 SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
2134         }
2135         else
2136         {
2137                 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
2138                 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
2139                 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
2140                 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
2141         }
2142         if (mode->stereobuffer)
2143                 SDL_GL_SetAttribute (SDL_GL_STEREO, 1);
2144         if (mode->samples > 1)
2145         {
2146                 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
2147                 SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, mode->samples);
2148         }
2149 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2150         if (vid_vsync.integer)
2151                 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
2152         else
2153                 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 0);
2154 #else
2155 #ifdef __IPHONEOS__
2156         SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 2);
2157         SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 0);
2158         SDL_GL_SetAttribute (SDL_GL_RETAINED_BACKING, 1);
2159         // FIXME: get proper resolution from OS somehow (iPad for instance...)
2160         mode->width = 320;
2161         mode->height = 480;
2162 #endif
2163 #endif
2164
2165         video_bpp = mode->bitsperpixel;
2166 #if SETVIDEOMODE
2167         video_flags = flags;
2168         VID_SetIcon_Pre();
2169         screen = SDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2170         VID_SetIcon_Post();
2171         if (screen == NULL)
2172         {
2173                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2174                 VID_Shutdown();
2175                 return false;
2176         }
2177         mode->width = screen->w;
2178         mode->height = screen->h;
2179 #else
2180         window_flags = windowflags;
2181         window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2182         if (window == NULL)
2183         {
2184                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2185                 VID_Shutdown();
2186                 return false;
2187         }
2188         SDL_GetWindowSize(window, &mode->width, &mode->height);
2189         context = SDL_GL_CreateContext(window);
2190         if (context == NULL)
2191         {
2192                 Con_Printf("Failed to initialize OpenGL context: %s\n", SDL_GetError());
2193                 VID_Shutdown();
2194                 return false;
2195         }
2196 #endif
2197
2198         vid_softsurface = NULL;
2199         vid.softpixels = NULL;
2200
2201 #if SETVIDEOMODE
2202         // set window title
2203         VID_SetCaption();
2204 #endif
2205         // init keyboard
2206         SDL_EnableUNICODE( SDL_ENABLE );
2207         // enable key repeat since everyone expects it
2208         SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2209
2210 #if !(SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2)
2211         SDL_GL_SetSwapInterval(vid_vsync.integer != 0);
2212         vid_usingvsync = (vid_vsync.integer != 0);
2213 #endif
2214
2215         gl_platform = "SDL";
2216         gl_platformextensions = "";
2217
2218 #ifdef __IPHONEOS__
2219         GLES_Init();
2220 #else
2221         GL_Init();
2222 #endif
2223
2224         vid_numjoysticks = SDL_NumJoysticks();
2225         vid_numjoysticks = bound(0, vid_numjoysticks, MAX_JOYSTICKS);
2226         Cvar_SetValueQuick(&joy_detected, vid_numjoysticks);
2227         Con_Printf("%d SDL joystick(s) found:\n", vid_numjoysticks);
2228         memset(vid_joysticks, 0, sizeof(vid_joysticks));
2229         for (i = 0;i < vid_numjoysticks;i++)
2230         {
2231                 SDL_Joystick *joy;
2232                 joy = vid_joysticks[i] = SDL_JoystickOpen(i);
2233                 if (!joy)
2234                 {
2235                         Con_Printf("joystick #%i: open failed: %s\n", i, SDL_GetError());
2236                         continue;
2237                 }
2238                 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));
2239         }
2240
2241         vid_hidden = false;
2242         vid_activewindow = false;
2243         vid_hasfocus = true;
2244         vid_usingmouse = false;
2245         vid_usinghidecursor = false;
2246
2247 #if SETVIDEOMODE
2248         SDL_WM_GrabInput(SDL_GRAB_OFF);
2249 #endif
2250         return true;
2251 }
2252
2253 extern cvar_t gl_info_extensions;
2254 extern cvar_t gl_info_vendor;
2255 extern cvar_t gl_info_renderer;
2256 extern cvar_t gl_info_version;
2257 extern cvar_t gl_info_platform;
2258 extern cvar_t gl_info_driver;
2259
2260 qboolean VID_InitModeSoft(viddef_mode_t *mode)
2261 {
2262         int i;
2263 #if SETVIDEOMODE
2264         int flags = SDL_HWSURFACE;
2265 #else
2266         int windowflags = SDL_WINDOW_SHOWN;
2267 #endif
2268
2269         win_half_width = mode->width>>1;
2270         win_half_height = mode->height>>1;
2271
2272         if(vid_resizable.integer)
2273 #if SETVIDEOMODE
2274                 flags |= SDL_RESIZABLE;
2275 #else
2276                 windowflags |= SDL_WINDOW_RESIZABLE;
2277 #endif
2278
2279         VID_OutputVersion();
2280
2281         vid_isfullscreen = false;
2282         if (mode->fullscreen) {
2283 #if SETVIDEOMODE
2284                 flags |= SDL_FULLSCREEN;
2285 #else
2286                 windowflags |= SDL_WINDOW_FULLSCREEN;
2287 #endif
2288                 vid_isfullscreen = true;
2289         }
2290
2291         video_bpp = mode->bitsperpixel;
2292 #if SETVIDEOMODE
2293         video_flags = flags;
2294         VID_SetIcon_Pre();
2295         screen = SDL_SetVideoMode(mode->width, mode->height, mode->bitsperpixel, flags);
2296         VID_SetIcon_Post();
2297         if (screen == NULL)
2298         {
2299                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2300                 VID_Shutdown();
2301                 return false;
2302         }
2303         mode->width = screen->w;
2304         mode->height = screen->h;
2305 #else
2306         window_flags = windowflags;
2307         window = SDL_CreateWindow(gamename, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, mode->width, mode->height, windowflags);
2308         if (window == NULL)
2309         {
2310                 Con_Printf("Failed to set video mode to %ix%i: %s\n", mode->width, mode->height, SDL_GetError());
2311                 VID_Shutdown();
2312                 return false;
2313         }
2314         SDL_GetWindowSize(window, &mode->width, &mode->height);
2315 #endif
2316
2317         // create a framebuffer using our specific color format, we let the SDL blit function convert it in VID_Finish
2318         vid_softsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, mode->width, mode->height, 32, 0x00FF0000, 0x0000FF00, 0x00000000FF, 0xFF000000);
2319         if (vid_softsurface == NULL)
2320         {
2321                 Con_Printf("Failed to setup software rasterizer framebuffer %ix%ix32bpp: %s\n", mode->width, mode->height, SDL_GetError());
2322                 VID_Shutdown();
2323                 return false;
2324         }
2325         SDL_SetAlpha(vid_softsurface, 0, 255);
2326
2327         vid.softpixels = (unsigned int *)vid_softsurface->pixels;
2328         vid.softdepthpixels = (unsigned int *)calloc(1, mode->width * mode->height * 4);
2329         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)
2330         {
2331                 Con_Printf("Failed to initialize software rasterizer\n");
2332                 VID_Shutdown();
2333                 return false;
2334         }
2335
2336 #if SETVIDEOMODE
2337         // set window title
2338         VID_SetCaption();
2339 #endif
2340         // init keyboard
2341         SDL_EnableUNICODE( SDL_ENABLE );
2342         // enable key repeat since everyone expects it
2343         SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
2344
2345         gl_platform = "SDLSoft";
2346         gl_platformextensions = "";
2347
2348         gl_renderer = "DarkPlaces-Soft";
2349         gl_vendor = "Forest Hale";
2350         gl_version = "0.0";
2351         gl_extensions = "";
2352
2353         // clear the extension flags
2354         memset(&vid.support, 0, sizeof(vid.support));
2355         Cvar_SetQuick(&gl_info_extensions, "");
2356
2357         vid.forcevbo = false;
2358         vid.support.arb_depth_texture = true;
2359         vid.support.arb_draw_buffers = true;
2360         vid.support.arb_occlusion_query = true;
2361         vid.support.arb_shadow = true;
2362         //vid.support.arb_texture_compression = true;
2363         vid.support.arb_texture_cube_map = true;
2364         vid.support.arb_texture_non_power_of_two = false;
2365         vid.support.arb_vertex_buffer_object = true;
2366         vid.support.ext_blend_subtract = true;
2367         vid.support.ext_draw_range_elements = true;
2368         vid.support.ext_framebuffer_object = true;
2369         vid.support.ext_texture_3d = true;
2370         //vid.support.ext_texture_compression_s3tc = true;
2371         vid.support.ext_texture_filter_anisotropic = true;
2372         vid.support.ati_separate_stencil = true;
2373
2374         vid.maxtexturesize_2d = 16384;
2375         vid.maxtexturesize_3d = 512;
2376         vid.maxtexturesize_cubemap = 16384;
2377         vid.texunits = 4;
2378         vid.teximageunits = 32;
2379         vid.texarrayunits = 8;
2380         vid.max_anisotropy = 1;
2381         vid.maxdrawbuffers = 4;
2382
2383         vid.texunits = bound(4, vid.texunits, MAX_TEXTUREUNITS);
2384         vid.teximageunits = bound(16, vid.teximageunits, MAX_TEXTUREUNITS);
2385         vid.texarrayunits = bound(8, vid.texarrayunits, MAX_TEXTUREUNITS);
2386         Con_DPrintf("Using DarkPlaces Software Rasterizer rendering path\n");
2387         vid.renderpath = RENDERPATH_SOFT;
2388         vid.useinterleavedarrays = false;
2389
2390         Cvar_SetQuick(&gl_info_vendor, gl_vendor);
2391         Cvar_SetQuick(&gl_info_renderer, gl_renderer);
2392         Cvar_SetQuick(&gl_info_version, gl_version);
2393         Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
2394         Cvar_SetQuick(&gl_info_driver, gl_driver);
2395
2396         // LordHavoc: report supported extensions
2397         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2398
2399         // clear to black (loading plaque will be seen over this)
2400         GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
2401
2402         vid_numjoysticks = SDL_NumJoysticks();
2403         vid_numjoysticks = bound(0, vid_numjoysticks, MAX_JOYSTICKS);
2404         Cvar_SetValueQuick(&joy_detected, vid_numjoysticks);
2405         Con_Printf("%d SDL joystick(s) found:\n", vid_numjoysticks);
2406         memset(vid_joysticks, 0, sizeof(vid_joysticks));
2407         for (i = 0;i < vid_numjoysticks;i++)
2408         {
2409                 SDL_Joystick *joy;
2410                 joy = vid_joysticks[i] = SDL_JoystickOpen(i);
2411                 if (!joy)
2412                 {
2413                         Con_Printf("joystick #%i: open failed: %s\n", i, SDL_GetError());
2414                         continue;
2415                 }
2416                 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));
2417         }
2418
2419         vid_hidden = false;
2420         vid_activewindow = false;
2421         vid_hasfocus = true;
2422         vid_usingmouse = false;
2423         vid_usinghidecursor = false;
2424
2425 #if SETVIDEOMODE
2426         SDL_WM_GrabInput(SDL_GRAB_OFF);
2427 #endif
2428         return true;
2429 }
2430
2431 qboolean VID_InitMode(viddef_mode_t *mode)
2432 {
2433         if (!SDL_WasInit(SDL_INIT_VIDEO) && SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
2434                 Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
2435 #ifdef SSE2_PRESENT
2436         if (vid_soft.integer)
2437                 return VID_InitModeSoft(mode);
2438         else
2439 #endif
2440                 return VID_InitModeGL(mode);
2441 }
2442
2443 void VID_Shutdown (void)
2444 {
2445         VID_SetMouse(false, false, false);
2446         VID_RestoreSystemGamma();
2447
2448 #if SETVIDEOMODE
2449 #ifndef WIN32
2450         if (icon)
2451                 SDL_FreeSurface(icon);
2452         icon = NULL;
2453 #endif
2454 #endif
2455
2456         if (vid_softsurface)
2457                 SDL_FreeSurface(vid_softsurface);
2458         vid_softsurface = NULL;
2459         vid.softpixels = NULL;
2460         if (vid.softdepthpixels)
2461                 free(vid.softdepthpixels);
2462         vid.softdepthpixels = NULL;
2463
2464 #if SETVIDEOMODE
2465 #else
2466         SDL_DestroyWindow(window);
2467         window = NULL;
2468 #endif
2469
2470         SDL_QuitSubSystem(SDL_INIT_VIDEO);
2471
2472         gl_driver[0] = 0;
2473         gl_extensions = "";
2474         gl_platform = "";
2475         gl_platformextensions = "";
2476 }
2477
2478 int VID_SetGamma (unsigned short *ramps, int rampsize)
2479 {
2480         return !SDL_SetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2481 }
2482
2483 int VID_GetGamma (unsigned short *ramps, int rampsize)
2484 {
2485         return !SDL_GetGammaRamp (ramps, ramps + rampsize, ramps + rampsize*2);
2486 }
2487
2488 void VID_Finish (void)
2489 {
2490 #if SETVIDEOMODE
2491         Uint8 appstate;
2492
2493         //react on appstate changes
2494         appstate = SDL_GetAppState();
2495
2496         vid_hidden = !(appstate & SDL_APPACTIVE);
2497         vid_hasfocus = (appstate & SDL_APPMOUSEFOCUS) && (appstate & SDL_APPINPUTFOCUS);
2498 #endif
2499         vid_activewindow = !vid_hidden && vid_hasfocus;
2500
2501         VID_UpdateGamma(false, 256);
2502
2503         if (!vid_hidden)
2504         {
2505                 switch(vid.renderpath)
2506                 {
2507                 case RENDERPATH_GL11:
2508                 case RENDERPATH_GL13:
2509                 case RENDERPATH_GL20:
2510                 case RENDERPATH_GLES2:
2511                         CHECKGLERROR
2512                         if (r_speeds.integer == 2 || gl_finish.integer)
2513                         {
2514                                 qglFinish();CHECKGLERROR
2515                         }
2516 #if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION == 2
2517 #else
2518 {
2519         qboolean vid_usevsync;
2520         vid_usevsync = (vid_vsync.integer && !cls.timedemo);
2521         if (vid_usingvsync != vid_usevsync)
2522         {
2523                 if (SDL_GL_SetSwapInterval(vid_usevsync != 0) >= 0)
2524                         Con_DPrintf("Vsync %s\n", vid_usevsync ? "activated" : "deactivated");
2525                 else
2526                         Con_DPrintf("ERROR: can't %s vsync\n", vid_usevsync ? "activate" : "deactivate");
2527         }
2528 }
2529 #endif
2530 #if SETVIDEOMODE
2531                         SDL_GL_SwapBuffers();
2532 #else
2533                         SDL_GL_SwapWindow(window);
2534 #endif
2535                         break;
2536                 case RENDERPATH_SOFT:
2537                         DPSOFTRAST_Finish();
2538 #if SETVIDEOMODE
2539                         SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2540                         SDL_Flip(screen);
2541 #else
2542                         {
2543                                 SDL_Surface *screen = SDL_GetWindowSurface(window);
2544                                 SDL_BlitSurface(vid_softsurface, NULL, screen, NULL);
2545                                 SDL_UpdateWindowSurface(window);
2546                         }
2547 #endif
2548                         break;
2549                 case RENDERPATH_D3D9:
2550                 case RENDERPATH_D3D10:
2551                 case RENDERPATH_D3D11:
2552                         break;
2553                 }
2554         }
2555 }
2556
2557 size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
2558 {
2559         size_t k;
2560         SDL_Rect **vidmodes;
2561         int bpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
2562
2563         k = 0;
2564         for(vidmodes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE); *vidmodes; ++vidmodes)
2565         {
2566                 if(k >= maxcount)
2567                         break;
2568                 modes[k].width = (*vidmodes)->w;
2569                 modes[k].height = (*vidmodes)->h;
2570                 modes[k].bpp = bpp;
2571                 modes[k].refreshrate = 60; // no support for refresh rate in SDL
2572                 modes[k].pixelheight_num = 1;
2573                 modes[k].pixelheight_denom = 1; // SDL does not provide this
2574                 ++k;
2575         }
2576         return k;
2577 }