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