Revert "Make cdda optional, server does not need to play music" because it
[xonotic/darkplaces.git] / vid_shared.c
1
2 #include "quakedef.h"
3 #include "cdaudio.h"
4 #include "image.h"
5
6 #ifdef SUPPORTD3D
7 #include <d3d9.h>
8 #ifdef _MSC_VER
9 #pragma comment(lib, "d3d9.lib")
10 #endif
11
12 LPDIRECT3DDEVICE9 vid_d3d9dev;
13 #endif
14
15 #ifdef WIN32
16 //#include <XInput.h>
17 #define XINPUT_GAMEPAD_DPAD_UP          0x0001
18 #define XINPUT_GAMEPAD_DPAD_DOWN        0x0002
19 #define XINPUT_GAMEPAD_DPAD_LEFT        0x0004
20 #define XINPUT_GAMEPAD_DPAD_RIGHT       0x0008
21 #define XINPUT_GAMEPAD_START            0x0010
22 #define XINPUT_GAMEPAD_BACK             0x0020
23 #define XINPUT_GAMEPAD_LEFT_THUMB       0x0040
24 #define XINPUT_GAMEPAD_RIGHT_THUMB      0x0080
25 #define XINPUT_GAMEPAD_LEFT_SHOULDER    0x0100
26 #define XINPUT_GAMEPAD_RIGHT_SHOULDER   0x0200
27 #define XINPUT_GAMEPAD_A                0x1000
28 #define XINPUT_GAMEPAD_B                0x2000
29 #define XINPUT_GAMEPAD_X                0x4000
30 #define XINPUT_GAMEPAD_Y                0x8000
31 #define XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE  7849
32 #define XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE 8689
33 #define XINPUT_GAMEPAD_TRIGGER_THRESHOLD    30
34 #define XUSER_INDEX_ANY                 0x000000FF
35
36 typedef struct xinput_gamepad_s
37 {
38         WORD wButtons;
39         BYTE bLeftTrigger;
40         BYTE bRightTrigger;
41         SHORT sThumbLX;
42         SHORT sThumbLY;
43         SHORT sThumbRX;
44         SHORT sThumbRY;
45 }
46 xinput_gamepad_t;
47
48 typedef struct xinput_state_s
49 {
50         DWORD dwPacketNumber;
51         xinput_gamepad_t Gamepad;
52 }
53 xinput_state_t;
54
55 typedef struct xinput_keystroke_s
56 {
57     WORD    VirtualKey;
58     WCHAR   Unicode;
59     WORD    Flags;
60     BYTE    UserIndex;
61     BYTE    HidCode;
62 }
63 xinput_keystroke_t;
64
65 DWORD (WINAPI *qXInputGetState)(DWORD index, xinput_state_t *state);
66 DWORD (WINAPI *qXInputGetKeystroke)(DWORD index, DWORD reserved, xinput_keystroke_t *keystroke);
67
68 qboolean vid_xinputinitialized = false;
69 int vid_xinputindex = -1;
70 #endif
71
72 // global video state
73 viddef_t vid;
74
75 // AK FIXME -> input_dest
76 qboolean in_client_mouse = true;
77
78 // AK where should it be placed ?
79 float in_mouse_x, in_mouse_y;
80 float in_windowmouse_x, in_windowmouse_y;
81
82 // LordHavoc: if window is hidden, don't update screen
83 qboolean vid_hidden = true;
84 // LordHavoc: if window is not the active window, don't hog as much CPU time,
85 // let go of the mouse, turn off sound, and restore system gamma ramps...
86 qboolean vid_activewindow = true;
87
88 vid_joystate_t vid_joystate;
89
90 #ifdef WIN32
91 cvar_t joy_xinputavailable = {CVAR_READONLY, "joy_xinputavailable", "0", "indicates which devices are being reported by the Windows XInput API (first controller = 1, second = 2, third = 4, fourth = 8, added together)"};
92 #endif
93 cvar_t joy_active = {CVAR_READONLY, "joy_active", "0", "indicates that a joystick is active (detected and enabled)"};
94 cvar_t joy_detected = {CVAR_READONLY, "joy_detected", "0", "number of joysticks detected by engine"};
95 cvar_t joy_enable = {CVAR_SAVE, "joy_enable", "0", "enables joystick support"};
96 cvar_t joy_index = {0, "joy_index", "0", "selects which joystick to use if you have multiple (0 uses the first controller, 1 uses the second, ...)"};
97 cvar_t joy_axisforward = {0, "joy_axisforward", "1", "which joystick axis to query for forward/backward movement"};
98 cvar_t joy_axisside = {0, "joy_axisside", "0", "which joystick axis to query for right/left movement"};
99 cvar_t joy_axisup = {0, "joy_axisup", "-1", "which joystick axis to query for up/down movement"};
100 cvar_t joy_axispitch = {0, "joy_axispitch", "3", "which joystick axis to query for looking up/down"};
101 cvar_t joy_axisyaw = {0, "joy_axisyaw", "2", "which joystick axis to query for looking right/left"};
102 cvar_t joy_axisroll = {0, "joy_axisroll", "-1", "which joystick axis to query for tilting head right/left"};
103 cvar_t joy_deadzoneforward = {0, "joy_deadzoneforward", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
104 cvar_t joy_deadzoneside = {0, "joy_deadzoneside", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
105 cvar_t joy_deadzoneup = {0, "joy_deadzoneup", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
106 cvar_t joy_deadzonepitch = {0, "joy_deadzonepitch", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
107 cvar_t joy_deadzoneyaw = {0, "joy_deadzoneyaw", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
108 cvar_t joy_deadzoneroll = {0, "joy_deadzoneroll", "0", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
109 cvar_t joy_sensitivityforward = {0, "joy_sensitivityforward", "-1", "movement multiplier"};
110 cvar_t joy_sensitivityside = {0, "joy_sensitivityside", "1", "movement multiplier"};
111 cvar_t joy_sensitivityup = {0, "joy_sensitivityup", "1", "movement multiplier"};
112 cvar_t joy_sensitivitypitch = {0, "joy_sensitivitypitch", "1", "movement multiplier"};
113 cvar_t joy_sensitivityyaw = {0, "joy_sensitivityyaw", "-1", "movement multiplier"};
114 cvar_t joy_sensitivityroll = {0, "joy_sensitivityroll", "1", "movement multiplier"};
115 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"};
116 cvar_t joy_axiskeyevents_deadzone = {CVAR_SAVE, "joy_axiskeyevents_deadzone", "0.5", "deadzone value for axes"};
117 cvar_t joy_x360_axisforward = {0, "joy_x360_axisforward", "1", "which joystick axis to query for forward/backward movement"};
118 cvar_t joy_x360_axisside = {0, "joy_x360_axisside", "0", "which joystick axis to query for right/left movement"};
119 cvar_t joy_x360_axisup = {0, "joy_x360_axisup", "-1", "which joystick axis to query for up/down movement"};
120 cvar_t joy_x360_axispitch = {0, "joy_x360_axispitch", "3", "which joystick axis to query for looking up/down"};
121 cvar_t joy_x360_axisyaw = {0, "joy_x360_axisyaw", "2", "which joystick axis to query for looking right/left"};
122 cvar_t joy_x360_axisroll = {0, "joy_x360_axisroll", "-1", "which joystick axis to query for tilting head right/left"};
123 cvar_t joy_x360_deadzoneforward = {0, "joy_x360_deadzoneforward", "0.266", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
124 cvar_t joy_x360_deadzoneside = {0, "joy_x360_deadzoneside", "0.266", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
125 cvar_t joy_x360_deadzoneup = {0, "joy_x360_deadzoneup", "0.266", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
126 cvar_t joy_x360_deadzonepitch = {0, "joy_x360_deadzonepitch", "0.266", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
127 cvar_t joy_x360_deadzoneyaw = {0, "joy_x360_deadzoneyaw", "0.266", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
128 cvar_t joy_x360_deadzoneroll = {0, "joy_x360_deadzoneroll", "0.266", "deadzone tolerance, suggested values are in the range 0 to 0.01"};
129 cvar_t joy_x360_sensitivityforward = {0, "joy_x360_sensitivityforward", "1", "movement multiplier"};
130 cvar_t joy_x360_sensitivityside = {0, "joy_x360_sensitivityside", "1", "movement multiplier"};
131 cvar_t joy_x360_sensitivityup = {0, "joy_x360_sensitivityup", "1", "movement multiplier"};
132 cvar_t joy_x360_sensitivitypitch = {0, "joy_x360_sensitivitypitch", "-1", "movement multiplier"};
133 cvar_t joy_x360_sensitivityyaw = {0, "joy_x360_sensitivityyaw", "-1", "movement multiplier"};
134 cvar_t joy_x360_sensitivityroll = {0, "joy_x360_sensitivityroll", "1", "movement multiplier"};
135
136 // cvars for DPSOFTRAST
137 cvar_t vid_soft = {CVAR_SAVE, "vid_soft", "0", "enables use of the DarkPlaces Software Rasterizer rather than OpenGL or Direct3D"};
138 cvar_t vid_soft_threads = {CVAR_SAVE, "vid_soft_threads", "8", "the number of threads the DarkPlaces Software Rasterizer should use"}; 
139 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"};
140
141 // we don't know until we try it!
142 cvar_t vid_hardwaregammasupported = {CVAR_READONLY,"vid_hardwaregammasupported","1", "indicates whether hardware gamma is supported (updated by attempts to set hardware gamma ramps)"};
143
144 // VorteX: more info cvars, mostly set in VID_CheckExtensions
145 cvar_t gl_info_vendor = {CVAR_READONLY, "gl_info_vendor", "", "indicates brand of graphics chip"};
146 cvar_t gl_info_renderer = {CVAR_READONLY, "gl_info_renderer", "", "indicates graphics chip model and other information"};
147 cvar_t gl_info_version = {CVAR_READONLY, "gl_info_version", "", "indicates version of current renderer. begins with 1.0.0, 1.1.0, 1.2.0, 1.3.1 etc."};
148 cvar_t gl_info_extensions = {CVAR_READONLY, "gl_info_extensions", "", "indicates extension list found by engine, space separated."};
149 cvar_t gl_info_platform = {CVAR_READONLY, "gl_info_platform", "", "indicates GL platform: WGL, GLX, or AGL."};
150 cvar_t gl_info_driver = {CVAR_READONLY, "gl_info_driver", "", "name of driver library (opengl32.dll, libGL.so.1, or whatever)."};
151
152 // whether hardware gamma ramps are currently in effect
153 qboolean vid_usinghwgamma = false;
154
155 int vid_gammarampsize = 0;
156 unsigned short *vid_gammaramps = NULL;
157 unsigned short *vid_systemgammaramps = NULL;
158
159 cvar_t vid_fullscreen = {CVAR_SAVE, "vid_fullscreen", "1", "use fullscreen (1) or windowed (0)"};
160 cvar_t vid_width = {CVAR_SAVE, "vid_width", "640", "resolution"};
161 cvar_t vid_height = {CVAR_SAVE, "vid_height", "480", "resolution"};
162 cvar_t vid_bitsperpixel = {CVAR_SAVE, "vid_bitsperpixel", "32", "how many bits per pixel to render at (32 or 16, 32 is recommended)"};
163 cvar_t vid_samples = {CVAR_SAVE, "vid_samples", "1", "how many anti-aliasing samples per pixel to request from the graphics driver (4 is recommended, 1 is faster)"};
164 cvar_t vid_refreshrate = {CVAR_SAVE, "vid_refreshrate", "60", "refresh rate to use, in hz (higher values flicker less, if supported by your monitor)"};
165 cvar_t vid_userefreshrate = {CVAR_SAVE, "vid_userefreshrate", "0", "set this to 1 to make vid_refreshrate used, or to 0 to let the engine choose a sane default"};
166 cvar_t vid_stereobuffer = {CVAR_SAVE, "vid_stereobuffer", "0", "enables 'quad-buffered' stereo rendering for stereo shutterglasses, HMD (head mounted display) devices, or polarized stereo LCDs, if supported by your drivers"};
167 // the density cvars are completely optional, set and use when something needs to have a density-independent size.
168 // TODO: set them when changing resolution, setting them from the commandline will be independent from the resolution - use only if you have a native fixed resolution.
169 // values for the Samsung Galaxy SIII, Snapdragon version: 2.000000 density, 304.799988 xdpi, 303.850464 ydpi
170 cvar_t vid_touchscreen_density = {0, "vid_touchscreen_density", "2.0", "Standard quantized screen density multiplier (see Android documentation for DisplayMetrics), similar values are given on iPhoneOS"};
171 cvar_t vid_touchscreen_xdpi = {0, "vid_touchscreen_xdpi", "300", "Horizontal DPI of the screen (only valid on Android currently)"};
172 cvar_t vid_touchscreen_ydpi = {0, "vid_touchscreen_ydpi", "300", "Vertical DPI of the screen (only valid on Android currently)"};
173
174 cvar_t vid_vsync = {CVAR_SAVE, "vid_vsync", "0", "sync to vertical blank, prevents 'tearing' (seeing part of one frame and part of another on the screen at the same time), automatically disabled when doing timedemo benchmarks"};
175 cvar_t vid_mouse = {CVAR_SAVE, "vid_mouse", "1", "whether to use the mouse in windowed mode (fullscreen always does)"};
176 cvar_t vid_grabkeyboard = {CVAR_SAVE, "vid_grabkeyboard", "0", "whether to grab the keyboard when mouse is active (prevents use of volume control keys, music player keys, etc on some keyboards)"};
177 cvar_t vid_minwidth = {0, "vid_minwidth", "0", "minimum vid_width that is acceptable (to be set in default.cfg in mods)"};
178 cvar_t vid_minheight = {0, "vid_minheight", "0", "minimum vid_height that is acceptable (to be set in default.cfg in mods)"};
179 cvar_t vid_gl13 = {0, "vid_gl13", "1", "enables faster rendering using OpenGL 1.3 features (such as GL_ARB_texture_env_combine extension)"};
180 cvar_t vid_gl20 = {0, "vid_gl20", "1", "enables faster rendering using OpenGL 2.0 features (such as GL_ARB_fragment_shader extension)"};
181 cvar_t gl_finish = {0, "gl_finish", "0", "make the cpu wait for the graphics processor at the end of each rendered frame (can help with strange input or video lag problems on some machines)"};
182 cvar_t vid_sRGB = {CVAR_SAVE, "vid_sRGB", "0", "if hardware is capable, modify rendering to be gamma corrected for the sRGB color standard (computer monitors, TVs), recommended"};
183 cvar_t vid_sRGB_fallback = {CVAR_SAVE, "vid_sRGB_fallback", "0", "do an approximate sRGB fallback if not properly supported by hardware (2: also use the fallback if framebuffer is 8bit, 3: always use the fallback even if sRGB is supported)"};
184
185 cvar_t vid_touchscreen = {0, "vid_touchscreen", "0", "Use touchscreen-style input (no mouse grab, track mouse motion only while button is down, screen areas for mimicing joystick axes and buttons"};
186 cvar_t vid_touchscreen_showkeyboard = {0, "vid_touchscreen_showkeyboard", "0", "shows the platform's screen keyboard for text entry, can be set by csqc or menu qc if it wants to receive text input, does nothing if the platform has no screen keyboard"};
187 cvar_t vid_touchscreen_supportshowkeyboard = {CVAR_READONLY, "vid_touchscreen_supportshowkeyboard", "0", "indicates if the platform supports a virtual keyboard"};
188 cvar_t vid_stick_mouse = {CVAR_SAVE, "vid_stick_mouse", "0", "have the mouse stuck in the center of the screen" };
189 cvar_t vid_resizable = {CVAR_SAVE, "vid_resizable", "0", "0: window not resizable, 1: resizable, 2: window can be resized but the framebuffer isn't adjusted" };
190
191 cvar_t v_gamma = {CVAR_SAVE, "v_gamma", "1", "inverse gamma correction value, a brightness effect that does not affect white or black, and tends to make the image grey and dull"};
192 cvar_t v_contrast = {CVAR_SAVE, "v_contrast", "1", "brightness of white (values above 1 give a brighter image with increased color saturation, unlike v_gamma)"};
193 cvar_t v_brightness = {CVAR_SAVE, "v_brightness", "0", "brightness of black, useful for monitors that are too dark"};
194 cvar_t v_contrastboost = {CVAR_SAVE, "v_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"};
195 cvar_t v_color_enable = {CVAR_SAVE, "v_color_enable", "0", "enables black-grey-white color correction curve controls"};
196 cvar_t v_color_black_r = {CVAR_SAVE, "v_color_black_r", "0", "desired color of black"};
197 cvar_t v_color_black_g = {CVAR_SAVE, "v_color_black_g", "0", "desired color of black"};
198 cvar_t v_color_black_b = {CVAR_SAVE, "v_color_black_b", "0", "desired color of black"};
199 cvar_t v_color_grey_r = {CVAR_SAVE, "v_color_grey_r", "0.5", "desired color of grey"};
200 cvar_t v_color_grey_g = {CVAR_SAVE, "v_color_grey_g", "0.5", "desired color of grey"};
201 cvar_t v_color_grey_b = {CVAR_SAVE, "v_color_grey_b", "0.5", "desired color of grey"};
202 cvar_t v_color_white_r = {CVAR_SAVE, "v_color_white_r", "1", "desired color of white"};
203 cvar_t v_color_white_g = {CVAR_SAVE, "v_color_white_g", "1", "desired color of white"};
204 cvar_t v_color_white_b = {CVAR_SAVE, "v_color_white_b", "1", "desired color of white"};
205 cvar_t v_hwgamma = {CVAR_SAVE, "v_hwgamma", "0", "enables use of hardware gamma correction ramps if available (note: does not work very well on Windows2000 and above), values are 0 = off, 1 = attempt to use hardware gamma, 2 = use hardware gamma whether it works or not"};
206 cvar_t v_glslgamma = {CVAR_SAVE, "v_glslgamma", "1", "enables use of GLSL to apply gamma correction ramps if available (note: overrides v_hwgamma)"};
207 cvar_t v_glslgamma_2d = {CVAR_SAVE, "v_glslgamma_2d", "0", "applies GLSL gamma to 2d pictures (HUD, fonts)"};
208 cvar_t v_psycho = {0, "v_psycho", "0", "easter egg"};
209
210 // brand of graphics chip
211 const char *gl_vendor;
212 // graphics chip model and other information
213 const char *gl_renderer;
214 // begins with 1.0.0, 1.1.0, 1.2.0, 1.2.1, 1.3.0, 1.3.1, or 1.4.0
215 const char *gl_version;
216 // extensions list, space separated
217 const char *gl_extensions;
218 // WGL, GLX, or AGL
219 const char *gl_platform;
220 // another extensions list, containing platform-specific extensions that are
221 // not in the main list
222 const char *gl_platformextensions;
223 // name of driver library (opengl32.dll, libGL.so.1, or whatever)
224 char gl_driver[256];
225
226 #ifndef USE_GLES2
227 // GL_ARB_multitexture
228 void (GLAPIENTRY *qglMultiTexCoord1f) (GLenum, GLfloat);
229 void (GLAPIENTRY *qglMultiTexCoord2f) (GLenum, GLfloat, GLfloat);
230 void (GLAPIENTRY *qglMultiTexCoord3f) (GLenum, GLfloat, GLfloat, GLfloat);
231 void (GLAPIENTRY *qglMultiTexCoord4f) (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
232 void (GLAPIENTRY *qglActiveTexture) (GLenum);
233 void (GLAPIENTRY *qglClientActiveTexture) (GLenum);
234
235 // general GL functions
236
237 void (GLAPIENTRY *qglClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
238
239 void (GLAPIENTRY *qglClear)(GLbitfield mask);
240
241 void (GLAPIENTRY *qglAlphaFunc)(GLenum func, GLclampf ref);
242 void (GLAPIENTRY *qglBlendFunc)(GLenum sfactor, GLenum dfactor);
243 void (GLAPIENTRY *qglCullFace)(GLenum mode);
244
245 void (GLAPIENTRY *qglDrawBuffer)(GLenum mode);
246 void (GLAPIENTRY *qglReadBuffer)(GLenum mode);
247 void (GLAPIENTRY *qglEnable)(GLenum cap);
248 void (GLAPIENTRY *qglDisable)(GLenum cap);
249 GLboolean (GLAPIENTRY *qglIsEnabled)(GLenum cap);
250
251 void (GLAPIENTRY *qglEnableClientState)(GLenum cap);
252 void (GLAPIENTRY *qglDisableClientState)(GLenum cap);
253
254 void (GLAPIENTRY *qglGetBooleanv)(GLenum pname, GLboolean *params);
255 void (GLAPIENTRY *qglGetDoublev)(GLenum pname, GLdouble *params);
256 void (GLAPIENTRY *qglGetFloatv)(GLenum pname, GLfloat *params);
257 void (GLAPIENTRY *qglGetIntegerv)(GLenum pname, GLint *params);
258
259 GLenum (GLAPIENTRY *qglGetError)(void);
260 const GLubyte* (GLAPIENTRY *qglGetString)(GLenum name);
261 void (GLAPIENTRY *qglFinish)(void);
262 void (GLAPIENTRY *qglFlush)(void);
263
264 void (GLAPIENTRY *qglClearDepth)(GLclampd depth);
265 void (GLAPIENTRY *qglDepthFunc)(GLenum func);
266 void (GLAPIENTRY *qglDepthMask)(GLboolean flag);
267 void (GLAPIENTRY *qglDepthRange)(GLclampd near_val, GLclampd far_val);
268 void (GLAPIENTRY *qglDepthRangef)(GLclampf near_val, GLclampf far_val);
269 void (GLAPIENTRY *qglColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
270
271 void (GLAPIENTRY *qglDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
272 void (GLAPIENTRY *qglDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
273 void (GLAPIENTRY *qglDrawArrays)(GLenum mode, GLint first, GLsizei count);
274 void (GLAPIENTRY *qglVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
275 void (GLAPIENTRY *qglNormalPointer)(GLenum type, GLsizei stride, const GLvoid *ptr);
276 void (GLAPIENTRY *qglColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
277 void (GLAPIENTRY *qglTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
278 void (GLAPIENTRY *qglArrayElement)(GLint i);
279
280 void (GLAPIENTRY *qglColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
281 void (GLAPIENTRY *qglColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
282 void (GLAPIENTRY *qglTexCoord1f)(GLfloat s);
283 void (GLAPIENTRY *qglTexCoord2f)(GLfloat s, GLfloat t);
284 void (GLAPIENTRY *qglTexCoord3f)(GLfloat s, GLfloat t, GLfloat r);
285 void (GLAPIENTRY *qglTexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
286 void (GLAPIENTRY *qglVertex2f)(GLfloat x, GLfloat y);
287 void (GLAPIENTRY *qglVertex3f)(GLfloat x, GLfloat y, GLfloat z);
288 void (GLAPIENTRY *qglVertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
289 void (GLAPIENTRY *qglBegin)(GLenum mode);
290 void (GLAPIENTRY *qglEnd)(void);
291
292 void (GLAPIENTRY *qglMatrixMode)(GLenum mode);
293 //void (GLAPIENTRY *qglOrtho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
294 //void (GLAPIENTRY *qglFrustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
295 void (GLAPIENTRY *qglViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
296 //void (GLAPIENTRY *qglPushMatrix)(void);
297 //void (GLAPIENTRY *qglPopMatrix)(void);
298 void (GLAPIENTRY *qglLoadIdentity)(void);
299 //void (GLAPIENTRY *qglLoadMatrixd)(const GLdouble *m);
300 void (GLAPIENTRY *qglLoadMatrixf)(const GLfloat *m);
301 //void (GLAPIENTRY *qglMultMatrixd)(const GLdouble *m);
302 //void (GLAPIENTRY *qglMultMatrixf)(const GLfloat *m);
303 //void (GLAPIENTRY *qglRotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
304 //void (GLAPIENTRY *qglRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
305 //void (GLAPIENTRY *qglScaled)(GLdouble x, GLdouble y, GLdouble z);
306 //void (GLAPIENTRY *qglScalef)(GLfloat x, GLfloat y, GLfloat z);
307 //void (GLAPIENTRY *qglTranslated)(GLdouble x, GLdouble y, GLdouble z);
308 //void (GLAPIENTRY *qglTranslatef)(GLfloat x, GLfloat y, GLfloat z);
309
310 void (GLAPIENTRY *qglReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
311
312 void (GLAPIENTRY *qglStencilFunc)(GLenum func, GLint ref, GLuint mask);
313 void (GLAPIENTRY *qglStencilMask)(GLuint mask);
314 void (GLAPIENTRY *qglStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
315 void (GLAPIENTRY *qglClearStencil)(GLint s);
316
317 void (GLAPIENTRY *qglTexEnvf)(GLenum target, GLenum pname, GLfloat param);
318 void (GLAPIENTRY *qglTexEnvfv)(GLenum target, GLenum pname, const GLfloat *params);
319 void (GLAPIENTRY *qglTexEnvi)(GLenum target, GLenum pname, GLint param);
320 void (GLAPIENTRY *qglTexParameterf)(GLenum target, GLenum pname, GLfloat param);
321 void (GLAPIENTRY *qglTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
322 void (GLAPIENTRY *qglTexParameteri)(GLenum target, GLenum pname, GLint param);
323 void (GLAPIENTRY *qglGetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
324 void (GLAPIENTRY *qglGetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
325 void (GLAPIENTRY *qglGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
326 void (GLAPIENTRY *qglGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
327 void (GLAPIENTRY *qglGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
328 void (GLAPIENTRY *qglHint)(GLenum target, GLenum mode);
329
330 void (GLAPIENTRY *qglGenTextures)(GLsizei n, GLuint *textures);
331 void (GLAPIENTRY *qglDeleteTextures)(GLsizei n, const GLuint *textures);
332 void (GLAPIENTRY *qglBindTexture)(GLenum target, GLuint texture);
333 //void (GLAPIENTRY *qglPrioritizeTextures)(GLsizei n, const GLuint *textures, const GLclampf *priorities);
334 //GLboolean (GLAPIENTRY *qglAreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences);
335 //GLboolean (GLAPIENTRY *qglIsTexture)(GLuint texture);
336 //void (GLAPIENTRY *qglPixelStoref)(GLenum pname, GLfloat param);
337 void (GLAPIENTRY *qglPixelStorei)(GLenum pname, GLint param);
338
339 //void (GLAPIENTRY *qglTexImage1D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
340 void (GLAPIENTRY *qglTexImage2D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
341 //void (GLAPIENTRY *qglTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
342 void (GLAPIENTRY *qglTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
343 //void (GLAPIENTRY *qglCopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
344 void (GLAPIENTRY *qglCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
345 //void (GLAPIENTRY *qglCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
346 void (GLAPIENTRY *qglCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
347
348
349 void (GLAPIENTRY *qglDrawRangeElementsEXT)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
350
351 //void (GLAPIENTRY *qglColorTableEXT)(int, int, int, int, int, const void *);
352
353 void (GLAPIENTRY *qglTexImage3D)(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
354 void (GLAPIENTRY *qglTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
355 void (GLAPIENTRY *qglCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
356
357 void (GLAPIENTRY *qglScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
358
359 void (GLAPIENTRY *qglPolygonOffset)(GLfloat factor, GLfloat units);
360 void (GLAPIENTRY *qglPolygonMode)(GLenum face, GLenum mode);
361 void (GLAPIENTRY *qglPolygonStipple)(const GLubyte *mask);
362
363 //void (GLAPIENTRY *qglClipPlane)(GLenum plane, const GLdouble *equation);
364 //void (GLAPIENTRY *qglGetClipPlane)(GLenum plane, GLdouble *equation);
365
366 //[515]: added on 29.07.2005
367 void (GLAPIENTRY *qglLineWidth)(GLfloat width);
368 void (GLAPIENTRY *qglPointSize)(GLfloat size);
369
370 void (GLAPIENTRY *qglBlendEquationEXT)(GLenum);
371
372 void (GLAPIENTRY *qglStencilOpSeparate)(GLenum, GLenum, GLenum, GLenum);
373 void (GLAPIENTRY *qglStencilFuncSeparate)(GLenum, GLenum, GLint, GLuint);
374 void (GLAPIENTRY *qglActiveStencilFaceEXT)(GLenum);
375
376 void (GLAPIENTRY *qglDeleteShader)(GLuint obj);
377 void (GLAPIENTRY *qglDeleteProgram)(GLuint obj);
378 //GLuint (GLAPIENTRY *qglGetHandle)(GLenum pname);
379 void (GLAPIENTRY *qglDetachShader)(GLuint containerObj, GLuint attachedObj);
380 GLuint (GLAPIENTRY *qglCreateShader)(GLenum shaderType);
381 void (GLAPIENTRY *qglShaderSource)(GLuint shaderObj, GLsizei count, const GLchar **string, const GLint *length);
382 void (GLAPIENTRY *qglCompileShader)(GLuint shaderObj);
383 GLuint (GLAPIENTRY *qglCreateProgram)(void);
384 void (GLAPIENTRY *qglAttachShader)(GLuint containerObj, GLuint obj);
385 void (GLAPIENTRY *qglLinkProgram)(GLuint programObj);
386 void (GLAPIENTRY *qglUseProgram)(GLuint programObj);
387 void (GLAPIENTRY *qglValidateProgram)(GLuint programObj);
388 void (GLAPIENTRY *qglUniform1f)(GLint location, GLfloat v0);
389 void (GLAPIENTRY *qglUniform2f)(GLint location, GLfloat v0, GLfloat v1);
390 void (GLAPIENTRY *qglUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
391 void (GLAPIENTRY *qglUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
392 void (GLAPIENTRY *qglUniform1i)(GLint location, GLint v0);
393 void (GLAPIENTRY *qglUniform2i)(GLint location, GLint v0, GLint v1);
394 void (GLAPIENTRY *qglUniform3i)(GLint location, GLint v0, GLint v1, GLint v2);
395 void (GLAPIENTRY *qglUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
396 void (GLAPIENTRY *qglUniform1fv)(GLint location, GLsizei count, const GLfloat *value);
397 void (GLAPIENTRY *qglUniform2fv)(GLint location, GLsizei count, const GLfloat *value);
398 void (GLAPIENTRY *qglUniform3fv)(GLint location, GLsizei count, const GLfloat *value);
399 void (GLAPIENTRY *qglUniform4fv)(GLint location, GLsizei count, const GLfloat *value);
400 void (GLAPIENTRY *qglUniform1iv)(GLint location, GLsizei count, const GLint *value);
401 void (GLAPIENTRY *qglUniform2iv)(GLint location, GLsizei count, const GLint *value);
402 void (GLAPIENTRY *qglUniform3iv)(GLint location, GLsizei count, const GLint *value);
403 void (GLAPIENTRY *qglUniform4iv)(GLint location, GLsizei count, const GLint *value);
404 void (GLAPIENTRY *qglUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
405 void (GLAPIENTRY *qglUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
406 void (GLAPIENTRY *qglUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
407 void (GLAPIENTRY *qglGetShaderiv)(GLuint obj, GLenum pname, GLint *params);
408 void (GLAPIENTRY *qglGetProgramiv)(GLuint obj, GLenum pname, GLint *params);
409 void (GLAPIENTRY *qglGetShaderInfoLog)(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog);
410 void (GLAPIENTRY *qglGetProgramInfoLog)(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *infoLog);
411 void (GLAPIENTRY *qglGetAttachedShaders)(GLuint containerObj, GLsizei maxCount, GLsizei *count, GLuint *obj);
412 GLint (GLAPIENTRY *qglGetUniformLocation)(GLuint programObj, const GLchar *name);
413 void (GLAPIENTRY *qglGetActiveUniform)(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
414 void (GLAPIENTRY *qglGetUniformfv)(GLuint programObj, GLint location, GLfloat *params);
415 void (GLAPIENTRY *qglGetUniformiv)(GLuint programObj, GLint location, GLint *params);
416 void (GLAPIENTRY *qglGetShaderSource)(GLuint obj, GLsizei maxLength, GLsizei *length, GLchar *source);
417
418 void (GLAPIENTRY *qglVertexAttrib1f)(GLuint index, GLfloat v0);
419 void (GLAPIENTRY *qglVertexAttrib1s)(GLuint index, GLshort v0);
420 void (GLAPIENTRY *qglVertexAttrib1d)(GLuint index, GLdouble v0);
421 void (GLAPIENTRY *qglVertexAttrib2f)(GLuint index, GLfloat v0, GLfloat v1);
422 void (GLAPIENTRY *qglVertexAttrib2s)(GLuint index, GLshort v0, GLshort v1);
423 void (GLAPIENTRY *qglVertexAttrib2d)(GLuint index, GLdouble v0, GLdouble v1);
424 void (GLAPIENTRY *qglVertexAttrib3f)(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2);
425 void (GLAPIENTRY *qglVertexAttrib3s)(GLuint index, GLshort v0, GLshort v1, GLshort v2);
426 void (GLAPIENTRY *qglVertexAttrib3d)(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2);
427 void (GLAPIENTRY *qglVertexAttrib4f)(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
428 void (GLAPIENTRY *qglVertexAttrib4s)(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3);
429 void (GLAPIENTRY *qglVertexAttrib4d)(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
430 void (GLAPIENTRY *qglVertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
431 void (GLAPIENTRY *qglVertexAttrib1fv)(GLuint index, const GLfloat *v);
432 void (GLAPIENTRY *qglVertexAttrib1sv)(GLuint index, const GLshort *v);
433 void (GLAPIENTRY *qglVertexAttrib1dv)(GLuint index, const GLdouble *v);
434 void (GLAPIENTRY *qglVertexAttrib2fv)(GLuint index, const GLfloat *v);
435 void (GLAPIENTRY *qglVertexAttrib2sv)(GLuint index, const GLshort *v);
436 void (GLAPIENTRY *qglVertexAttrib2dv)(GLuint index, const GLdouble *v);
437 void (GLAPIENTRY *qglVertexAttrib3fv)(GLuint index, const GLfloat *v);
438 void (GLAPIENTRY *qglVertexAttrib3sv)(GLuint index, const GLshort *v);
439 void (GLAPIENTRY *qglVertexAttrib3dv)(GLuint index, const GLdouble *v);
440 void (GLAPIENTRY *qglVertexAttrib4fv)(GLuint index, const GLfloat *v);
441 void (GLAPIENTRY *qglVertexAttrib4sv)(GLuint index, const GLshort *v);
442 void (GLAPIENTRY *qglVertexAttrib4dv)(GLuint index, const GLdouble *v);
443 void (GLAPIENTRY *qglVertexAttrib4iv)(GLuint index, const GLint *v);
444 void (GLAPIENTRY *qglVertexAttrib4bv)(GLuint index, const GLbyte *v);
445 void (GLAPIENTRY *qglVertexAttrib4ubv)(GLuint index, const GLubyte *v);
446 void (GLAPIENTRY *qglVertexAttrib4usv)(GLuint index, const GLushort *v);
447 void (GLAPIENTRY *qglVertexAttrib4uiv)(GLuint index, const GLuint *v);
448 void (GLAPIENTRY *qglVertexAttrib4Nbv)(GLuint index, const GLbyte *v);
449 void (GLAPIENTRY *qglVertexAttrib4Nsv)(GLuint index, const GLshort *v);
450 void (GLAPIENTRY *qglVertexAttrib4Niv)(GLuint index, const GLint *v);
451 void (GLAPIENTRY *qglVertexAttrib4Nubv)(GLuint index, const GLubyte *v);
452 void (GLAPIENTRY *qglVertexAttrib4Nusv)(GLuint index, const GLushort *v);
453 void (GLAPIENTRY *qglVertexAttrib4Nuiv)(GLuint index, const GLuint *v);
454 void (GLAPIENTRY *qglVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
455 void (GLAPIENTRY *qglEnableVertexAttribArray)(GLuint index);
456 void (GLAPIENTRY *qglDisableVertexAttribArray)(GLuint index);
457 void (GLAPIENTRY *qglBindAttribLocation)(GLuint programObj, GLuint index, const GLchar *name);
458 void (GLAPIENTRY *qglBindFragDataLocation)(GLuint programObj, GLuint index, const GLchar *name);
459 void (GLAPIENTRY *qglGetActiveAttrib)(GLuint programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
460 GLint (GLAPIENTRY *qglGetAttribLocation)(GLuint programObj, const GLchar *name);
461 void (GLAPIENTRY *qglGetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params);
462 void (GLAPIENTRY *qglGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params);
463 void (GLAPIENTRY *qglGetVertexAttribiv)(GLuint index, GLenum pname, GLint *params);
464 void (GLAPIENTRY *qglGetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid **pointer);
465
466 //GL_ARB_vertex_buffer_object
467 void (GLAPIENTRY *qglBindBufferARB) (GLenum target, GLuint buffer);
468 void (GLAPIENTRY *qglDeleteBuffersARB) (GLsizei n, const GLuint *buffers);
469 void (GLAPIENTRY *qglGenBuffersARB) (GLsizei n, GLuint *buffers);
470 GLboolean (GLAPIENTRY *qglIsBufferARB) (GLuint buffer);
471 GLvoid* (GLAPIENTRY *qglMapBufferARB) (GLenum target, GLenum access);
472 GLboolean (GLAPIENTRY *qglUnmapBufferARB) (GLenum target);
473 void (GLAPIENTRY *qglBufferDataARB) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
474 void (GLAPIENTRY *qglBufferSubDataARB) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data);
475
476 //GL_ARB_framebuffer_object
477 GLboolean (GLAPIENTRY *qglIsRenderbuffer)(GLuint renderbuffer);
478 GLvoid (GLAPIENTRY *qglBindRenderbuffer)(GLenum target, GLuint renderbuffer);
479 GLvoid (GLAPIENTRY *qglDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers);
480 GLvoid (GLAPIENTRY *qglGenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
481 GLvoid (GLAPIENTRY *qglRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
482 GLvoid (GLAPIENTRY *qglRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
483 GLvoid (GLAPIENTRY *qglGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params);
484 GLboolean (GLAPIENTRY *qglIsFramebuffer)(GLuint framebuffer);
485 GLvoid (GLAPIENTRY *qglBindFramebuffer)(GLenum target, GLuint framebuffer);
486 GLvoid (GLAPIENTRY *qglDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
487 GLvoid (GLAPIENTRY *qglGenFramebuffers)(GLsizei n, GLuint *framebuffers);
488 GLenum (GLAPIENTRY *qglCheckFramebufferStatus)(GLenum target);
489 GLvoid (GLAPIENTRY *qglFramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
490 GLvoid (GLAPIENTRY *qglFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
491 GLvoid (GLAPIENTRY *qglFramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer);
492 GLvoid (GLAPIENTRY *qglFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
493 GLvoid (GLAPIENTRY *qglFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
494 GLvoid (GLAPIENTRY *qglGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
495 GLvoid (GLAPIENTRY *qglBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
496 GLvoid (GLAPIENTRY *qglGenerateMipmap)(GLenum target);
497
498 void (GLAPIENTRY *qglDrawBuffersARB)(GLsizei n, const GLenum *bufs);
499
500 void (GLAPIENTRY *qglCompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
501 void (GLAPIENTRY *qglCompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border,  GLsizei imageSize, const void *data);
502 //void (GLAPIENTRY *qglCompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
503 void (GLAPIENTRY *qglCompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
504 void (GLAPIENTRY *qglCompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
505 //void (GLAPIENTRY *qglCompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
506 void (GLAPIENTRY *qglGetCompressedTexImageARB)(GLenum target, GLint lod, void *img);
507
508 void (GLAPIENTRY *qglGenQueriesARB)(GLsizei n, GLuint *ids);
509 void (GLAPIENTRY *qglDeleteQueriesARB)(GLsizei n, const GLuint *ids);
510 GLboolean (GLAPIENTRY *qglIsQueryARB)(GLuint qid);
511 void (GLAPIENTRY *qglBeginQueryARB)(GLenum target, GLuint qid);
512 void (GLAPIENTRY *qglEndQueryARB)(GLenum target);
513 void (GLAPIENTRY *qglGetQueryivARB)(GLenum target, GLenum pname, GLint *params);
514 void (GLAPIENTRY *qglGetQueryObjectivARB)(GLuint qid, GLenum pname, GLint *params);
515 void (GLAPIENTRY *qglGetQueryObjectuivARB)(GLuint qid, GLenum pname, GLuint *params);
516
517 void (GLAPIENTRY *qglSampleCoverageARB)(GLclampf value, GLboolean invert);
518
519 void (GLAPIENTRY *qglGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar** uniformNames, GLuint* uniformIndices);
520 void (GLAPIENTRY *qglGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params);
521 void (GLAPIENTRY *qglGetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName);
522 GLuint (GLAPIENTRY *qglGetUniformBlockIndex)(GLuint program, const GLchar* uniformBlockName);
523 void (GLAPIENTRY *qglGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname,  GLint* params);
524 void (GLAPIENTRY *qglGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName);
525 void (GLAPIENTRY *qglBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptrARB offset, GLsizeiptrARB size);
526 void (GLAPIENTRY *qglBindBufferBase)(GLenum target, GLuint index, GLuint buffer);
527 void (GLAPIENTRY *qglGetIntegeri_v)(GLenum target, GLuint index, GLint* data);
528 void (GLAPIENTRY *qglUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
529
530 void (GLAPIENTRY *qglBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
531 #endif
532
533 #if _MSC_VER >= 1400
534 #define sscanf sscanf_s
535 #endif
536
537 qboolean GL_CheckExtension(const char *minglver_or_ext, const dllfunction_t *funcs, const char *disableparm, int silent)
538 {
539         int failed = false;
540         const dllfunction_t *func;
541         struct { int major, minor; } min_version, curr_version;
542         char extstr[MAX_INPUTLINE];
543         int ext;
544
545         if(sscanf(minglver_or_ext, "%d.%d", &min_version.major, &min_version.minor) == 2)
546                 ext = 0; // opengl version
547         else if(minglver_or_ext[0] != toupper(minglver_or_ext[0]))
548                 ext = -1; // pseudo name
549         else
550                 ext = 1; // extension name
551
552         if (ext)
553                 Con_DPrintf("checking for %s...  ", minglver_or_ext);
554         else
555                 Con_DPrintf("checking for OpenGL %s core features...  ", minglver_or_ext);
556
557         for (func = funcs;func && func->name;func++)
558                 *func->funcvariable = NULL;
559
560         if (disableparm && (COM_CheckParm(disableparm) || COM_CheckParm("-safe")))
561         {
562                 Con_DPrint("disabled by commandline\n");
563                 return false;
564         }
565
566         if (ext == 1) // opengl extension
567         {
568                 if (!strstr(gl_extensions ? gl_extensions : "", minglver_or_ext) && !strstr(gl_platformextensions ? gl_platformextensions : "", minglver_or_ext))
569                 {
570                         Con_DPrint("not detected\n");
571                         return false;
572                 }
573         }
574
575         if(ext == 0) // opengl version
576         {
577                 if (sscanf(gl_version, "%d.%d", &curr_version.major, &curr_version.minor) < 2)
578                         curr_version.major = curr_version.minor = 1;
579
580                 if (curr_version.major < min_version.major || (curr_version.major == min_version.major && curr_version.minor < min_version.minor))
581                 {
582                         Con_DPrintf("not detected (OpenGL %d.%d loaded)\n", curr_version.major, curr_version.minor);
583                         return false;
584                 }
585         }
586
587         for (func = funcs;func && func->name != NULL;func++)
588         {
589                 // Con_DPrintf("\n    %s...  ", func->name);
590
591                 // functions are cleared before all the extensions are evaluated
592                 if (!(*func->funcvariable = (void *) GL_GetProcAddress(func->name)))
593                 {
594                         if (ext && !silent)
595                                 Con_DPrintf("%s is missing function \"%s\" - broken driver!\n", minglver_or_ext, func->name);
596                         if (!ext)
597                                 Con_Printf("OpenGL %s core features are missing function \"%s\" - broken driver!\n", minglver_or_ext, func->name);
598                         failed = true;
599                 }
600         }
601         // delay the return so it prints all missing functions
602         if (failed)
603                 return false;
604         // VorteX: add to found extension list
605         dpsnprintf(extstr, sizeof(extstr), "%s %s ", gl_info_extensions.string, minglver_or_ext);
606         Cvar_SetQuick(&gl_info_extensions, extstr);
607
608         Con_DPrint("enabled\n");
609         return true;
610 }
611
612 #ifndef USE_GLES2
613 static dllfunction_t opengl110funcs[] =
614 {
615         {"glClearColor", (void **) &qglClearColor},
616         {"glClear", (void **) &qglClear},
617         {"glAlphaFunc", (void **) &qglAlphaFunc},
618         {"glBlendFunc", (void **) &qglBlendFunc},
619         {"glCullFace", (void **) &qglCullFace},
620         {"glDrawBuffer", (void **) &qglDrawBuffer},
621         {"glReadBuffer", (void **) &qglReadBuffer},
622         {"glEnable", (void **) &qglEnable},
623         {"glDisable", (void **) &qglDisable},
624         {"glIsEnabled", (void **) &qglIsEnabled},
625         {"glEnableClientState", (void **) &qglEnableClientState},
626         {"glDisableClientState", (void **) &qglDisableClientState},
627         {"glGetBooleanv", (void **) &qglGetBooleanv},
628         {"glGetDoublev", (void **) &qglGetDoublev},
629         {"glGetFloatv", (void **) &qglGetFloatv},
630         {"glGetIntegerv", (void **) &qglGetIntegerv},
631         {"glGetError", (void **) &qglGetError},
632         {"glGetString", (void **) &qglGetString},
633         {"glFinish", (void **) &qglFinish},
634         {"glFlush", (void **) &qglFlush},
635         {"glClearDepth", (void **) &qglClearDepth},
636         {"glDepthFunc", (void **) &qglDepthFunc},
637         {"glDepthMask", (void **) &qglDepthMask},
638         {"glDepthRange", (void **) &qglDepthRange},
639         {"glDrawElements", (void **) &qglDrawElements},
640         {"glDrawArrays", (void **) &qglDrawArrays},
641         {"glColorMask", (void **) &qglColorMask},
642         {"glVertexPointer", (void **) &qglVertexPointer},
643         {"glNormalPointer", (void **) &qglNormalPointer},
644         {"glColorPointer", (void **) &qglColorPointer},
645         {"glTexCoordPointer", (void **) &qglTexCoordPointer},
646         {"glArrayElement", (void **) &qglArrayElement},
647         {"glColor4ub", (void **) &qglColor4ub},
648         {"glColor4f", (void **) &qglColor4f},
649         {"glTexCoord1f", (void **) &qglTexCoord1f},
650         {"glTexCoord2f", (void **) &qglTexCoord2f},
651         {"glTexCoord3f", (void **) &qglTexCoord3f},
652         {"glTexCoord4f", (void **) &qglTexCoord4f},
653         {"glVertex2f", (void **) &qglVertex2f},
654         {"glVertex3f", (void **) &qglVertex3f},
655         {"glVertex4f", (void **) &qglVertex4f},
656         {"glBegin", (void **) &qglBegin},
657         {"glEnd", (void **) &qglEnd},
658 //[515]: added on 29.07.2005
659         {"glLineWidth", (void**) &qglLineWidth},
660         {"glPointSize", (void**) &qglPointSize},
661 //
662         {"glMatrixMode", (void **) &qglMatrixMode},
663 //      {"glOrtho", (void **) &qglOrtho},
664 //      {"glFrustum", (void **) &qglFrustum},
665         {"glViewport", (void **) &qglViewport},
666 //      {"glPushMatrix", (void **) &qglPushMatrix},
667 //      {"glPopMatrix", (void **) &qglPopMatrix},
668         {"glLoadIdentity", (void **) &qglLoadIdentity},
669 //      {"glLoadMatrixd", (void **) &qglLoadMatrixd},
670         {"glLoadMatrixf", (void **) &qglLoadMatrixf},
671 //      {"glMultMatrixd", (void **) &qglMultMatrixd},
672 //      {"glMultMatrixf", (void **) &qglMultMatrixf},
673 //      {"glRotated", (void **) &qglRotated},
674 //      {"glRotatef", (void **) &qglRotatef},
675 //      {"glScaled", (void **) &qglScaled},
676 //      {"glScalef", (void **) &qglScalef},
677 //      {"glTranslated", (void **) &qglTranslated},
678 //      {"glTranslatef", (void **) &qglTranslatef},
679         {"glReadPixels", (void **) &qglReadPixels},
680         {"glStencilFunc", (void **) &qglStencilFunc},
681         {"glStencilMask", (void **) &qglStencilMask},
682         {"glStencilOp", (void **) &qglStencilOp},
683         {"glClearStencil", (void **) &qglClearStencil},
684         {"glTexEnvf", (void **) &qglTexEnvf},
685         {"glTexEnvfv", (void **) &qglTexEnvfv},
686         {"glTexEnvi", (void **) &qglTexEnvi},
687         {"glTexParameterf", (void **) &qglTexParameterf},
688         {"glTexParameterfv", (void **) &qglTexParameterfv},
689         {"glTexParameteri", (void **) &qglTexParameteri},
690         {"glGetTexImage", (void **) &qglGetTexImage},
691         {"glGetTexParameterfv", (void **) &qglGetTexParameterfv},
692         {"glGetTexParameteriv", (void **) &qglGetTexParameteriv},
693         {"glGetTexLevelParameterfv", (void **) &qglGetTexLevelParameterfv},
694         {"glGetTexLevelParameteriv", (void **) &qglGetTexLevelParameteriv},
695         {"glHint", (void **) &qglHint},
696 //      {"glPixelStoref", (void **) &qglPixelStoref},
697         {"glPixelStorei", (void **) &qglPixelStorei},
698         {"glGenTextures", (void **) &qglGenTextures},
699         {"glDeleteTextures", (void **) &qglDeleteTextures},
700         {"glBindTexture", (void **) &qglBindTexture},
701 //      {"glPrioritizeTextures", (void **) &qglPrioritizeTextures},
702 //      {"glAreTexturesResident", (void **) &qglAreTexturesResident},
703 //      {"glIsTexture", (void **) &qglIsTexture},
704 //      {"glTexImage1D", (void **) &qglTexImage1D},
705         {"glTexImage2D", (void **) &qglTexImage2D},
706 //      {"glTexSubImage1D", (void **) &qglTexSubImage1D},
707         {"glTexSubImage2D", (void **) &qglTexSubImage2D},
708 //      {"glCopyTexImage1D", (void **) &qglCopyTexImage1D},
709         {"glCopyTexImage2D", (void **) &qglCopyTexImage2D},
710 //      {"glCopyTexSubImage1D", (void **) &qglCopyTexSubImage1D},
711         {"glCopyTexSubImage2D", (void **) &qglCopyTexSubImage2D},
712         {"glScissor", (void **) &qglScissor},
713         {"glPolygonOffset", (void **) &qglPolygonOffset},
714         {"glPolygonMode", (void **) &qglPolygonMode},
715         {"glPolygonStipple", (void **) &qglPolygonStipple},
716 //      {"glClipPlane", (void **) &qglClipPlane},
717 //      {"glGetClipPlane", (void **) &qglGetClipPlane},
718         {NULL, NULL}
719 };
720
721 static dllfunction_t drawrangeelementsfuncs[] =
722 {
723         {"glDrawRangeElements", (void **) &qglDrawRangeElements},
724         {NULL, NULL}
725 };
726
727 static dllfunction_t drawrangeelementsextfuncs[] =
728 {
729         {"glDrawRangeElementsEXT", (void **) &qglDrawRangeElementsEXT},
730         {NULL, NULL}
731 };
732
733 static dllfunction_t multitexturefuncs[] =
734 {
735         {"glMultiTexCoord1fARB", (void **) &qglMultiTexCoord1f},
736         {"glMultiTexCoord2fARB", (void **) &qglMultiTexCoord2f},
737         {"glMultiTexCoord3fARB", (void **) &qglMultiTexCoord3f},
738         {"glMultiTexCoord4fARB", (void **) &qglMultiTexCoord4f},
739         {"glActiveTextureARB", (void **) &qglActiveTexture},
740         {"glClientActiveTextureARB", (void **) &qglClientActiveTexture},
741         {NULL, NULL}
742 };
743
744 static dllfunction_t texture3dextfuncs[] =
745 {
746         {"glTexImage3DEXT", (void **) &qglTexImage3D},
747         {"glTexSubImage3DEXT", (void **) &qglTexSubImage3D},
748         {"glCopyTexSubImage3DEXT", (void **) &qglCopyTexSubImage3D},
749         {NULL, NULL}
750 };
751
752 static dllfunction_t atiseparatestencilfuncs[] =
753 {
754         {"glStencilOpSeparateATI", (void **) &qglStencilOpSeparate},
755         {"glStencilFuncSeparateATI", (void **) &qglStencilFuncSeparate},
756         {NULL, NULL}
757 };
758
759 static dllfunction_t gl2separatestencilfuncs[] =
760 {
761         {"glStencilOpSeparate", (void **) &qglStencilOpSeparate},
762         {"glStencilFuncSeparate", (void **) &qglStencilFuncSeparate},
763         {NULL, NULL}
764 };
765
766 static dllfunction_t stenciltwosidefuncs[] =
767 {
768         {"glActiveStencilFaceEXT", (void **) &qglActiveStencilFaceEXT},
769         {NULL, NULL}
770 };
771
772 static dllfunction_t blendequationfuncs[] =
773 {
774         {"glBlendEquationEXT", (void **) &qglBlendEquationEXT},
775         {NULL, NULL}
776 };
777
778 static dllfunction_t gl20shaderfuncs[] =
779 {
780         {"glDeleteShader", (void **) &qglDeleteShader},
781         {"glDeleteProgram", (void **) &qglDeleteProgram},
782 //      {"glGetHandle", (void **) &qglGetHandle},
783         {"glDetachShader", (void **) &qglDetachShader},
784         {"glCreateShader", (void **) &qglCreateShader},
785         {"glShaderSource", (void **) &qglShaderSource},
786         {"glCompileShader", (void **) &qglCompileShader},
787         {"glCreateProgram", (void **) &qglCreateProgram},
788         {"glAttachShader", (void **) &qglAttachShader},
789         {"glLinkProgram", (void **) &qglLinkProgram},
790         {"glUseProgram", (void **) &qglUseProgram},
791         {"glValidateProgram", (void **) &qglValidateProgram},
792         {"glUniform1f", (void **) &qglUniform1f},
793         {"glUniform2f", (void **) &qglUniform2f},
794         {"glUniform3f", (void **) &qglUniform3f},
795         {"glUniform4f", (void **) &qglUniform4f},
796         {"glUniform1i", (void **) &qglUniform1i},
797         {"glUniform2i", (void **) &qglUniform2i},
798         {"glUniform3i", (void **) &qglUniform3i},
799         {"glUniform4i", (void **) &qglUniform4i},
800         {"glUniform1fv", (void **) &qglUniform1fv},
801         {"glUniform2fv", (void **) &qglUniform2fv},
802         {"glUniform3fv", (void **) &qglUniform3fv},
803         {"glUniform4fv", (void **) &qglUniform4fv},
804         {"glUniform1iv", (void **) &qglUniform1iv},
805         {"glUniform2iv", (void **) &qglUniform2iv},
806         {"glUniform3iv", (void **) &qglUniform3iv},
807         {"glUniform4iv", (void **) &qglUniform4iv},
808         {"glUniformMatrix2fv", (void **) &qglUniformMatrix2fv},
809         {"glUniformMatrix3fv", (void **) &qglUniformMatrix3fv},
810         {"glUniformMatrix4fv", (void **) &qglUniformMatrix4fv},
811         {"glGetShaderiv", (void **) &qglGetShaderiv},
812         {"glGetProgramiv", (void **) &qglGetProgramiv},
813         {"glGetShaderInfoLog", (void **) &qglGetShaderInfoLog},
814         {"glGetProgramInfoLog", (void **) &qglGetProgramInfoLog},
815         {"glGetAttachedShaders", (void **) &qglGetAttachedShaders},
816         {"glGetUniformLocation", (void **) &qglGetUniformLocation},
817         {"glGetActiveUniform", (void **) &qglGetActiveUniform},
818         {"glGetUniformfv", (void **) &qglGetUniformfv},
819         {"glGetUniformiv", (void **) &qglGetUniformiv},
820         {"glGetShaderSource", (void **) &qglGetShaderSource},
821         {"glVertexAttrib1f", (void **) &qglVertexAttrib1f},
822         {"glVertexAttrib1s", (void **) &qglVertexAttrib1s},
823         {"glVertexAttrib1d", (void **) &qglVertexAttrib1d},
824         {"glVertexAttrib2f", (void **) &qglVertexAttrib2f},
825         {"glVertexAttrib2s", (void **) &qglVertexAttrib2s},
826         {"glVertexAttrib2d", (void **) &qglVertexAttrib2d},
827         {"glVertexAttrib3f", (void **) &qglVertexAttrib3f},
828         {"glVertexAttrib3s", (void **) &qglVertexAttrib3s},
829         {"glVertexAttrib3d", (void **) &qglVertexAttrib3d},
830         {"glVertexAttrib4f", (void **) &qglVertexAttrib4f},
831         {"glVertexAttrib4s", (void **) &qglVertexAttrib4s},
832         {"glVertexAttrib4d", (void **) &qglVertexAttrib4d},
833         {"glVertexAttrib4Nub", (void **) &qglVertexAttrib4Nub},
834         {"glVertexAttrib1fv", (void **) &qglVertexAttrib1fv},
835         {"glVertexAttrib1sv", (void **) &qglVertexAttrib1sv},
836         {"glVertexAttrib1dv", (void **) &qglVertexAttrib1dv},
837         {"glVertexAttrib2fv", (void **) &qglVertexAttrib1fv},
838         {"glVertexAttrib2sv", (void **) &qglVertexAttrib1sv},
839         {"glVertexAttrib2dv", (void **) &qglVertexAttrib1dv},
840         {"glVertexAttrib3fv", (void **) &qglVertexAttrib1fv},
841         {"glVertexAttrib3sv", (void **) &qglVertexAttrib1sv},
842         {"glVertexAttrib3dv", (void **) &qglVertexAttrib1dv},
843         {"glVertexAttrib4fv", (void **) &qglVertexAttrib1fv},
844         {"glVertexAttrib4sv", (void **) &qglVertexAttrib1sv},
845         {"glVertexAttrib4dv", (void **) &qglVertexAttrib1dv},
846 //      {"glVertexAttrib4iv", (void **) &qglVertexAttrib1iv},
847 //      {"glVertexAttrib4bv", (void **) &qglVertexAttrib1bv},
848 //      {"glVertexAttrib4ubv", (void **) &qglVertexAttrib1ubv},
849 //      {"glVertexAttrib4usv", (void **) &qglVertexAttrib1usv},
850 //      {"glVertexAttrib4uiv", (void **) &qglVertexAttrib1uiv},
851 //      {"glVertexAttrib4Nbv", (void **) &qglVertexAttrib1Nbv},
852 //      {"glVertexAttrib4Nsv", (void **) &qglVertexAttrib1Nsv},
853 //      {"glVertexAttrib4Niv", (void **) &qglVertexAttrib1Niv},
854 //      {"glVertexAttrib4Nubv", (void **) &qglVertexAttrib1Nubv},
855 //      {"glVertexAttrib4Nusv", (void **) &qglVertexAttrib1Nusv},
856 //      {"glVertexAttrib4Nuiv", (void **) &qglVertexAttrib1Nuiv},
857         {"glVertexAttribPointer", (void **) &qglVertexAttribPointer},
858         {"glEnableVertexAttribArray", (void **) &qglEnableVertexAttribArray},
859         {"glDisableVertexAttribArray", (void **) &qglDisableVertexAttribArray},
860         {"glBindAttribLocation", (void **) &qglBindAttribLocation},
861         {"glGetActiveAttrib", (void **) &qglGetActiveAttrib},
862         {"glGetAttribLocation", (void **) &qglGetAttribLocation},
863         {"glGetVertexAttribdv", (void **) &qglGetVertexAttribdv},
864         {"glGetVertexAttribfv", (void **) &qglGetVertexAttribfv},
865         {"glGetVertexAttribiv", (void **) &qglGetVertexAttribiv},
866         {"glGetVertexAttribPointerv", (void **) &qglGetVertexAttribPointerv},
867         {NULL, NULL}
868 };
869
870 static dllfunction_t glsl130funcs[] =
871 {
872         {"glBindFragDataLocation", (void **) &qglBindFragDataLocation},
873         {NULL, NULL}
874 };
875
876 static dllfunction_t vbofuncs[] =
877 {
878         {"glBindBufferARB"    , (void **) &qglBindBufferARB},
879         {"glDeleteBuffersARB" , (void **) &qglDeleteBuffersARB},
880         {"glGenBuffersARB"    , (void **) &qglGenBuffersARB},
881         {"glIsBufferARB"      , (void **) &qglIsBufferARB},
882         {"glMapBufferARB"     , (void **) &qglMapBufferARB},
883         {"glUnmapBufferARB"   , (void **) &qglUnmapBufferARB},
884         {"glBufferDataARB"    , (void **) &qglBufferDataARB},
885         {"glBufferSubDataARB" , (void **) &qglBufferSubDataARB},
886         {NULL, NULL}
887 };
888
889 static dllfunction_t ubofuncs[] =
890 {
891         {"glGetUniformIndices"        , (void **) &qglGetUniformIndices},
892         {"glGetActiveUniformsiv"      , (void **) &qglGetActiveUniformsiv},
893         {"glGetActiveUniformName"     , (void **) &qglGetActiveUniformName},
894         {"glGetUniformBlockIndex"     , (void **) &qglGetUniformBlockIndex},
895         {"glGetActiveUniformBlockiv"  , (void **) &qglGetActiveUniformBlockiv},
896         {"glGetActiveUniformBlockName", (void **) &qglGetActiveUniformBlockName},
897         {"glBindBufferRange"          , (void **) &qglBindBufferRange},
898         {"glBindBufferBase"           , (void **) &qglBindBufferBase},
899         {"glGetIntegeri_v"            , (void **) &qglGetIntegeri_v},
900         {"glUniformBlockBinding"      , (void **) &qglUniformBlockBinding},
901         {NULL, NULL}
902 };
903
904 static dllfunction_t arbfbofuncs[] =
905 {
906         {"glIsRenderbuffer"                      , (void **) &qglIsRenderbuffer},
907         {"glBindRenderbuffer"                    , (void **) &qglBindRenderbuffer},
908         {"glDeleteRenderbuffers"                 , (void **) &qglDeleteRenderbuffers},
909         {"glGenRenderbuffers"                    , (void **) &qglGenRenderbuffers},
910         {"glRenderbufferStorage"                 , (void **) &qglRenderbufferStorage},
911         {"glRenderbufferStorageMultisample"      , (void **) &qglRenderbufferStorageMultisample}, // not in GL_EXT_framebuffer_object
912         {"glGetRenderbufferParameteriv"          , (void **) &qglGetRenderbufferParameteriv},
913         {"glIsFramebuffer"                       , (void **) &qglIsFramebuffer},
914         {"glBindFramebuffer"                     , (void **) &qglBindFramebuffer},
915         {"glDeleteFramebuffers"                  , (void **) &qglDeleteFramebuffers},
916         {"glGenFramebuffers"                     , (void **) &qglGenFramebuffers},
917         {"glCheckFramebufferStatus"              , (void **) &qglCheckFramebufferStatus},
918         {"glFramebufferTexture1D"                , (void **) &qglFramebufferTexture1D},
919         {"glFramebufferTexture2D"                , (void **) &qglFramebufferTexture2D},
920         {"glFramebufferTexture3D"                , (void **) &qglFramebufferTexture3D},
921         {"glFramebufferTextureLayer"             , (void **) &qglFramebufferTextureLayer}, // not in GL_EXT_framebuffer_object
922         {"glFramebufferRenderbuffer"             , (void **) &qglFramebufferRenderbuffer},
923         {"glGetFramebufferAttachmentParameteriv" , (void **) &qglGetFramebufferAttachmentParameteriv},
924         {"glBlitFramebuffer"                     , (void **) &qglBlitFramebuffer}, // not in GL_EXT_framebuffer_object
925         {"glGenerateMipmap"                      , (void **) &qglGenerateMipmap},
926         {NULL, NULL}
927 };
928
929 static dllfunction_t extfbofuncs[] =
930 {
931         {"glIsRenderbufferEXT"                      , (void **) &qglIsRenderbuffer},
932         {"glBindRenderbufferEXT"                    , (void **) &qglBindRenderbuffer},
933         {"glDeleteRenderbuffersEXT"                 , (void **) &qglDeleteRenderbuffers},
934         {"glGenRenderbuffersEXT"                    , (void **) &qglGenRenderbuffers},
935         {"glRenderbufferStorageEXT"                 , (void **) &qglRenderbufferStorage},
936         {"glGetRenderbufferParameterivEXT"          , (void **) &qglGetRenderbufferParameteriv},
937         {"glIsFramebufferEXT"                       , (void **) &qglIsFramebuffer},
938         {"glBindFramebufferEXT"                     , (void **) &qglBindFramebuffer},
939         {"glDeleteFramebuffersEXT"                  , (void **) &qglDeleteFramebuffers},
940         {"glGenFramebuffersEXT"                     , (void **) &qglGenFramebuffers},
941         {"glCheckFramebufferStatusEXT"              , (void **) &qglCheckFramebufferStatus},
942         {"glFramebufferTexture1DEXT"                , (void **) &qglFramebufferTexture1D},
943         {"glFramebufferTexture2DEXT"                , (void **) &qglFramebufferTexture2D},
944         {"glFramebufferTexture3DEXT"                , (void **) &qglFramebufferTexture3D},
945         {"glFramebufferRenderbufferEXT"             , (void **) &qglFramebufferRenderbuffer},
946         {"glGetFramebufferAttachmentParameterivEXT" , (void **) &qglGetFramebufferAttachmentParameteriv},
947         {"glGenerateMipmapEXT"                      , (void **) &qglGenerateMipmap},
948         {NULL, NULL}
949 };
950
951 static dllfunction_t texturecompressionfuncs[] =
952 {
953         {"glCompressedTexImage3DARB",    (void **) &qglCompressedTexImage3DARB},
954         {"glCompressedTexImage2DARB",    (void **) &qglCompressedTexImage2DARB},
955 //      {"glCompressedTexImage1DARB",    (void **) &qglCompressedTexImage1DARB},
956         {"glCompressedTexSubImage3DARB", (void **) &qglCompressedTexSubImage3DARB},
957         {"glCompressedTexSubImage2DARB", (void **) &qglCompressedTexSubImage2DARB},
958 //      {"glCompressedTexSubImage1DARB", (void **) &qglCompressedTexSubImage1DARB},
959         {"glGetCompressedTexImageARB",   (void **) &qglGetCompressedTexImageARB},
960         {NULL, NULL}
961 };
962
963 static dllfunction_t occlusionqueryfuncs[] =
964 {
965         {"glGenQueriesARB",              (void **) &qglGenQueriesARB},
966         {"glDeleteQueriesARB",           (void **) &qglDeleteQueriesARB},
967         {"glIsQueryARB",                 (void **) &qglIsQueryARB},
968         {"glBeginQueryARB",              (void **) &qglBeginQueryARB},
969         {"glEndQueryARB",                (void **) &qglEndQueryARB},
970         {"glGetQueryivARB",              (void **) &qglGetQueryivARB},
971         {"glGetQueryObjectivARB",        (void **) &qglGetQueryObjectivARB},
972         {"glGetQueryObjectuivARB",       (void **) &qglGetQueryObjectuivARB},
973         {NULL, NULL}
974 };
975
976 static dllfunction_t drawbuffersfuncs[] =
977 {
978         {"glDrawBuffersARB",             (void **) &qglDrawBuffersARB},
979         {NULL, NULL}
980 };
981
982 static dllfunction_t multisamplefuncs[] =
983 {
984         {"glSampleCoverageARB",          (void **) &qglSampleCoverageARB},
985         {NULL, NULL}
986 };
987
988 static dllfunction_t blendfuncseparatefuncs[] =
989 {
990         {"glBlendFuncSeparateEXT", (void **) &qglBlendFuncSeparate},
991         {NULL, NULL}
992 };
993
994 #endif
995
996 void VID_ClearExtensions(void)
997 {
998         // VorteX: reset extensions info cvar, it got filled by GL_CheckExtension
999         Cvar_SetQuick(&gl_info_extensions, "");
1000
1001         // clear the extension flags
1002         memset(&vid.support, 0, sizeof(vid.support));
1003         vid.renderpath = RENDERPATH_GL11;
1004         vid.sRGBcapable2D = false;
1005         vid.sRGBcapable3D = false;
1006         vid.useinterleavedarrays = false;
1007         vid.forcevbo = false;
1008         vid.maxtexturesize_2d = 0;
1009         vid.maxtexturesize_3d = 0;
1010         vid.maxtexturesize_cubemap = 0;
1011         vid.texunits = 1;
1012         vid.teximageunits = 1;
1013         vid.texarrayunits = 1;
1014         vid.max_anisotropy = 1;
1015         vid.maxdrawbuffers = 1;
1016
1017 #ifndef USE_GLES2
1018         // this is a complete list of all functions that are directly checked in the renderer
1019         qglDrawRangeElements = NULL;
1020         qglDrawBuffer = NULL;
1021         qglPolygonStipple = NULL;
1022         qglFlush = NULL;
1023         qglActiveTexture = NULL;
1024         qglGetCompressedTexImageARB = NULL;
1025         qglFramebufferTexture2D = NULL;
1026         qglDrawBuffersARB = NULL;
1027 #endif
1028 }
1029
1030 #ifndef USE_GLES2
1031 void VID_CheckExtensions(void)
1032 {
1033         if (!GL_CheckExtension("glbase", opengl110funcs, NULL, false))
1034                 Sys_Error("OpenGL 1.1.0 functions not found");
1035         vid.support.gl20shaders = GL_CheckExtension("2.0", gl20shaderfuncs, "-noshaders", true);
1036
1037         CHECKGLERROR
1038
1039         Con_DPrint("Checking OpenGL extensions...\n");
1040
1041         if (vid.support.gl20shaders)
1042         {
1043                 char *s;
1044                 // detect what GLSL version is available, to enable features like r_glsl_skeletal and higher quality reliefmapping
1045                 vid.support.glshaderversion = 100;
1046                 s = (char *) qglGetString(GL_SHADING_LANGUAGE_VERSION);
1047                 if (s)
1048                         vid.support.glshaderversion = (int)(atof(s) * 100.0f + 0.5f);
1049                 if (vid.support.glshaderversion < 100)
1050                         vid.support.glshaderversion = 100;
1051                 Con_DPrintf("Detected GLSL #version %i\n", vid.support.glshaderversion);
1052                 // get the glBindFragDataLocation function
1053                 if (vid.support.glshaderversion >= 130)
1054                         vid.support.gl20shaders130 = GL_CheckExtension("glshaders130", glsl130funcs, "-noglsl130", true);
1055         }
1056
1057         // GL drivers generally prefer GL_BGRA
1058         vid.forcetextype = GL_BGRA;
1059
1060         vid.support.amd_texture_texture4 = GL_CheckExtension("GL_AMD_texture_texture4", NULL, "-notexture4", false);
1061         vid.support.arb_depth_texture = GL_CheckExtension("GL_ARB_depth_texture", NULL, "-nodepthtexture", false);
1062         vid.support.arb_draw_buffers = GL_CheckExtension("GL_ARB_draw_buffers", drawbuffersfuncs, "-nodrawbuffers", false);
1063         vid.support.arb_multitexture = GL_CheckExtension("GL_ARB_multitexture", multitexturefuncs, "-nomtex", false);
1064         vid.support.arb_occlusion_query = GL_CheckExtension("GL_ARB_occlusion_query", occlusionqueryfuncs, "-noocclusionquery", false);
1065         vid.support.arb_shadow = GL_CheckExtension("GL_ARB_shadow", NULL, "-noshadow", false);
1066         vid.support.arb_texture_compression = GL_CheckExtension("GL_ARB_texture_compression", texturecompressionfuncs, "-notexturecompression", false);
1067         vid.support.arb_texture_cube_map = GL_CheckExtension("GL_ARB_texture_cube_map", NULL, "-nocubemap", false);
1068         vid.support.arb_texture_env_combine = GL_CheckExtension("GL_ARB_texture_env_combine", NULL, "-nocombine", false) || GL_CheckExtension("GL_EXT_texture_env_combine", NULL, "-nocombine", false);
1069         vid.support.arb_texture_gather = GL_CheckExtension("GL_ARB_texture_gather", NULL, "-notexturegather", false);
1070 #ifndef __APPLE__
1071         // LordHavoc: too many bugs on OSX!
1072         vid.support.arb_texture_non_power_of_two = GL_CheckExtension("GL_ARB_texture_non_power_of_two", NULL, "-notexturenonpoweroftwo", false);
1073 #endif
1074         vid.support.arb_vertex_buffer_object = GL_CheckExtension("GL_ARB_vertex_buffer_object", vbofuncs, "-novbo", false);
1075         vid.support.arb_uniform_buffer_object = GL_CheckExtension("GL_ARB_uniform_buffer_object", ubofuncs, "-noubo", false);
1076         vid.support.ati_separate_stencil = GL_CheckExtension("separatestencil", gl2separatestencilfuncs, "-noseparatestencil", true) || GL_CheckExtension("GL_ATI_separate_stencil", atiseparatestencilfuncs, "-noseparatestencil", false);
1077         vid.support.ext_blend_minmax = GL_CheckExtension("GL_EXT_blend_minmax", blendequationfuncs, "-noblendminmax", false);
1078         vid.support.ext_blend_subtract = GL_CheckExtension("GL_EXT_blend_subtract", blendequationfuncs, "-noblendsubtract", false);
1079         vid.support.ext_blend_func_separate = GL_CheckExtension("GL_EXT_blend_func_separate", blendfuncseparatefuncs, "-noblendfuncseparate", false);
1080         vid.support.ext_draw_range_elements = GL_CheckExtension("drawrangeelements", drawrangeelementsfuncs, "-nodrawrangeelements", true) || GL_CheckExtension("GL_EXT_draw_range_elements", drawrangeelementsextfuncs, "-nodrawrangeelements", false);
1081         vid.support.arb_framebuffer_object = GL_CheckExtension("GL_ARB_framebuffer_object", arbfbofuncs, "-nofbo", false);
1082         if (vid.support.arb_framebuffer_object)
1083                 vid.support.ext_framebuffer_object = true;
1084         else
1085                 vid.support.ext_framebuffer_object = GL_CheckExtension("GL_EXT_framebuffer_object", extfbofuncs, "-nofbo", false);
1086
1087         vid.support.ext_packed_depth_stencil = GL_CheckExtension("GL_EXT_packed_depth_stencil", NULL, "-nopackeddepthstencil", false);
1088         vid.support.ext_stencil_two_side = GL_CheckExtension("GL_EXT_stencil_two_side", stenciltwosidefuncs, "-nostenciltwoside", false);
1089         vid.support.ext_texture_3d = GL_CheckExtension("GL_EXT_texture3D", texture3dextfuncs, "-notexture3d", false);
1090         vid.support.ext_texture_compression_s3tc = GL_CheckExtension("GL_EXT_texture_compression_s3tc", NULL, "-nos3tc", false);
1091         vid.support.ext_texture_edge_clamp = GL_CheckExtension("GL_EXT_texture_edge_clamp", NULL, "-noedgeclamp", false) || GL_CheckExtension("GL_SGIS_texture_edge_clamp", NULL, "-noedgeclamp", false);
1092         vid.support.ext_texture_filter_anisotropic = GL_CheckExtension("GL_EXT_texture_filter_anisotropic", NULL, "-noanisotropy", false);
1093         vid.support.ext_texture_srgb = GL_CheckExtension("GL_EXT_texture_sRGB", NULL, "-nosrgb", false);
1094         vid.support.arb_multisample = GL_CheckExtension("GL_ARB_multisample", multisamplefuncs, "-nomultisample", false);
1095         vid.allowalphatocoverage = false;
1096
1097 // COMMANDLINEOPTION: GL: -noshaders disables use of OpenGL 2.0 shaders (which allow pixel shader effects, can improve per pixel lighting performance and capabilities)
1098 // COMMANDLINEOPTION: GL: -noanisotropy disables GL_EXT_texture_filter_anisotropic (allows higher quality texturing)
1099 // COMMANDLINEOPTION: GL: -noblendminmax disables GL_EXT_blend_minmax
1100 // COMMANDLINEOPTION: GL: -noblendsubtract disables GL_EXT_blend_subtract
1101 // COMMANDLINEOPTION: GL: -nocombine disables GL_ARB_texture_env_combine or GL_EXT_texture_env_combine (required for bumpmapping and faster map rendering)
1102 // COMMANDLINEOPTION: GL: -nocubemap disables GL_ARB_texture_cube_map (required for bumpmapping)
1103 // COMMANDLINEOPTION: GL: -nodepthtexture disables use of GL_ARB_depth_texture (required for shadowmapping)
1104 // COMMANDLINEOPTION: GL: -nodrawbuffers disables use of GL_ARB_draw_buffers (required for r_shadow_deferredprepass)
1105 // COMMANDLINEOPTION: GL: -nodrawrangeelements disables GL_EXT_draw_range_elements (renders faster)
1106 // COMMANDLINEOPTION: GL: -noedgeclamp disables GL_EXT_texture_edge_clamp or GL_SGIS_texture_edge_clamp (recommended, some cards do not support the other texture clamp method)
1107 // COMMANDLINEOPTION: GL: -nofbo disables GL_EXT_framebuffer_object (which accelerates rendering), only used if GL_ARB_fragment_shader is also available
1108 // COMMANDLINEOPTION: GL: -nomtex disables GL_ARB_multitexture (required for faster map rendering)
1109 // COMMANDLINEOPTION: GL: -noocclusionquery disables GL_ARB_occlusion_query (which allows coronas to fade according to visibility, and potentially used for rendering optimizations)
1110 // COMMANDLINEOPTION: GL: -nos3tc disables GL_EXT_texture_compression_s3tc (which allows use of .dds texture caching)
1111 // COMMANDLINEOPTION: GL: -noseparatestencil disables use of OpenGL2.0 glStencilOpSeparate and GL_ATI_separate_stencil extensions (which accelerate shadow rendering)
1112 // COMMANDLINEOPTION: GL: -noshadow disables use of GL_ARB_shadow (required for hardware shadowmap filtering)
1113 // COMMANDLINEOPTION: GL: -nostenciltwoside disables GL_EXT_stencil_two_side (which accelerate shadow rendering)
1114 // COMMANDLINEOPTION: GL: -notexture3d disables GL_EXT_texture3D (required for spherical lights, otherwise they render as a column)
1115 // COMMANDLINEOPTION: GL: -notexture4 disables GL_AMD_texture_texture4 (which provides fetch4 sampling)
1116 // COMMANDLINEOPTION: GL: -notexturecompression disables GL_ARB_texture_compression (which saves video memory if it is supported, but can also degrade image quality, see gl_texturecompression cvar documentation for more information)
1117 // COMMANDLINEOPTION: GL: -notexturegather disables GL_ARB_texture_gather (which provides fetch4 sampling)
1118 // COMMANDLINEOPTION: GL: -notexturenonpoweroftwo disables GL_ARB_texture_non_power_of_two (which saves video memory if it is supported, but crashes on some buggy drivers)
1119 // COMMANDLINEOPTION: GL: -novbo disables GL_ARB_vertex_buffer_object (which accelerates rendering)
1120 // COMMANDLINEOPTION: GL: -nosrgb disables GL_EXT_texture_sRGB (which is used for higher quality non-linear texture gamma)
1121 // COMMANDLINEOPTION: GL: -nomultisample disables GL_ARB_multisample
1122
1123         if (vid.support.arb_draw_buffers)
1124                 qglGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, (GLint*)&vid.maxdrawbuffers);
1125
1126         // disable non-power-of-two textures on Radeon X1600 and other cards that do not accelerate it with some filtering modes / repeat modes that we use
1127         // we detect these cards by checking if the hardware supports vertex texture fetch (Geforce6 does, Radeon X1600 does not, all GL3-class hardware does)
1128         if(vid.support.arb_texture_non_power_of_two && vid.support.gl20shaders)
1129         {
1130                 int val = 0;
1131                 qglGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &val);CHECKGLERROR
1132                 if (val < 1)
1133                         vid.support.arb_texture_non_power_of_two = false;
1134         }
1135
1136         // we don't care if it's an extension or not, they are identical functions, so keep it simple in the rendering code
1137         if (qglDrawRangeElements == NULL)
1138                 qglDrawRangeElements = qglDrawRangeElementsEXT;
1139
1140         qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
1141         if (vid.support.ext_texture_filter_anisotropic)
1142                 qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
1143         if (vid.support.arb_texture_cube_map)
1144                 qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_cubemap);
1145         if (vid.support.ext_texture_3d)
1146                 qglGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_3d);
1147
1148         // verify that 3d textures are really supported
1149         if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
1150         {
1151                 vid.support.ext_texture_3d = false;
1152                 Con_Printf("GL_EXT_texture3D reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
1153         }
1154
1155         vid.texunits = vid.teximageunits = vid.texarrayunits = 1;
1156         if (vid.support.arb_multitexture)
1157                 qglGetIntegerv(GL_MAX_TEXTURE_UNITS, (GLint*)&vid.texunits);
1158         if (vid_gl20.integer && vid.support.gl20shaders)
1159         {
1160                 qglGetIntegerv(GL_MAX_TEXTURE_UNITS, (GLint*)&vid.texunits);
1161                 qglGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, (int *)&vid.teximageunits);CHECKGLERROR
1162                 qglGetIntegerv(GL_MAX_TEXTURE_COORDS, (int *)&vid.texarrayunits);CHECKGLERROR
1163                 vid.texunits = bound(4, vid.texunits, MAX_TEXTUREUNITS);
1164                 vid.teximageunits = bound(16, vid.teximageunits, MAX_TEXTUREUNITS);
1165                 vid.texarrayunits = bound(8, vid.texarrayunits, MAX_TEXTUREUNITS);
1166                 Con_DPrintf("Using GL2.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" : "");
1167                 vid.renderpath = RENDERPATH_GL20;
1168                 vid.sRGBcapable2D = false;
1169                 vid.sRGBcapable3D = true;
1170                 vid.useinterleavedarrays = false;
1171                 Con_Printf("vid.support.arb_multisample %i\n", vid.support.arb_multisample);
1172                 Con_Printf("vid.support.gl20shaders %i\n", vid.support.gl20shaders);
1173                 vid.allowalphatocoverage = true; // but see below, it may get turned to false again if GL_SAMPLES_ARB is <= 1
1174         }
1175         else if (vid.support.arb_texture_env_combine && vid.texunits >= 2 && vid_gl13.integer)
1176         {
1177                 qglGetIntegerv(GL_MAX_TEXTURE_UNITS, (GLint*)&vid.texunits);
1178                 vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
1179                 vid.teximageunits = vid.texunits;
1180                 vid.texarrayunits = vid.texunits;
1181                 Con_DPrintf("Using GL1.3 rendering path - %i texture units, single pass rendering\n", vid.texunits);
1182                 vid.renderpath = RENDERPATH_GL13;
1183                 vid.sRGBcapable2D = false;
1184                 vid.sRGBcapable3D = false;
1185                 vid.useinterleavedarrays = false;
1186         }
1187         else
1188         {
1189                 vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
1190                 vid.teximageunits = vid.texunits;
1191                 vid.texarrayunits = vid.texunits;
1192                 Con_DPrintf("Using GL1.1 rendering path - %i texture units, two pass rendering\n", vid.texunits);
1193                 vid.renderpath = RENDERPATH_GL11;
1194                 vid.sRGBcapable2D = false;
1195                 vid.sRGBcapable3D = false;
1196                 vid.useinterleavedarrays = false;
1197         }
1198
1199         // enable multisample antialiasing if possible
1200         if(vid.support.arb_multisample)
1201         {
1202                 int samples = 0;
1203                 qglGetIntegerv(GL_SAMPLES_ARB, &samples);
1204                 vid.samples = samples;
1205                 if (samples > 1)
1206                         qglEnable(GL_MULTISAMPLE_ARB);
1207                 else
1208                         vid.allowalphatocoverage = false;
1209         }
1210         else
1211         {
1212                 vid.allowalphatocoverage = false;
1213                 vid.samples = 1;
1214         }
1215
1216         // VorteX: set other info (maybe place them in VID_InitMode?)
1217         Cvar_SetQuick(&gl_info_vendor, gl_vendor);
1218         Cvar_SetQuick(&gl_info_renderer, gl_renderer);
1219         Cvar_SetQuick(&gl_info_version, gl_version);
1220         Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
1221         Cvar_SetQuick(&gl_info_driver, gl_driver);
1222 }
1223 #endif
1224
1225 float VID_JoyState_GetAxis(const vid_joystate_t *joystate, int axis, float sensitivity, float deadzone)
1226 {
1227         float value;
1228         value = (axis >= 0 && axis < MAXJOYAXIS) ? joystate->axis[axis] : 0.0f;
1229         value = value > deadzone ? (value - deadzone) : (value < -deadzone ? (value + deadzone) : 0.0f);
1230         value *= deadzone > 0 ? (1.0f / (1.0f - deadzone)) : 1.0f;
1231         value = bound(-1, value, 1);
1232         return value * sensitivity;
1233 }
1234
1235 qboolean VID_JoyBlockEmulatedKeys(int keycode)
1236 {
1237         int j;
1238         vid_joystate_t joystate;
1239
1240         if (!joy_axiskeyevents.integer)
1241                 return false;
1242         if (vid_joystate.is360)
1243                 return false;
1244         if (keycode != K_UPARROW && keycode != K_DOWNARROW && keycode != K_RIGHTARROW && keycode != K_LEFTARROW)
1245                 return false;
1246
1247         // block system-generated key events for arrow keys if we're emulating the arrow keys ourselves
1248         VID_BuildJoyState(&joystate);
1249         for (j = 32;j < 36;j++)
1250                 if (vid_joystate.button[j] || joystate.button[j])
1251                         return true;
1252
1253         return false;
1254 }
1255
1256 void VID_Shared_BuildJoyState_Begin(vid_joystate_t *joystate)
1257 {
1258 #ifdef WIN32
1259         xinput_state_t xinputstate;
1260 #endif
1261         memset(joystate, 0, sizeof(*joystate));
1262 #ifdef WIN32
1263         if (vid_xinputindex >= 0 && qXInputGetState && qXInputGetState(vid_xinputindex, &xinputstate) == S_OK)
1264         {
1265                 joystate->is360 = true;
1266                 joystate->button[ 0] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_UP) != 0;
1267                 joystate->button[ 1] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN) != 0;
1268                 joystate->button[ 2] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT) != 0;
1269                 joystate->button[ 3] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT) != 0;
1270                 joystate->button[ 4] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_START) != 0;
1271                 joystate->button[ 5] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_BACK) != 0;
1272                 joystate->button[ 6] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_THUMB) != 0;
1273                 joystate->button[ 7] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_THUMB) != 0;
1274                 joystate->button[ 8] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER) != 0;
1275                 joystate->button[ 9] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER) != 0;
1276                 joystate->button[10] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_A) != 0;
1277                 joystate->button[11] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_B) != 0;
1278                 joystate->button[12] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_X) != 0;
1279                 joystate->button[13] = (xinputstate.Gamepad.wButtons & XINPUT_GAMEPAD_Y) != 0;
1280                 joystate->button[14] = xinputstate.Gamepad.bLeftTrigger >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
1281                 joystate->button[15] = xinputstate.Gamepad.bRightTrigger >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
1282                 joystate->button[16] = xinputstate.Gamepad.sThumbLY < -16384;
1283                 joystate->button[17] = xinputstate.Gamepad.sThumbLY >  16384;
1284                 joystate->button[18] = xinputstate.Gamepad.sThumbLX < -16384;
1285                 joystate->button[19] = xinputstate.Gamepad.sThumbLX >  16384;
1286                 joystate->button[20] = xinputstate.Gamepad.sThumbRY < -16384;
1287                 joystate->button[21] = xinputstate.Gamepad.sThumbRY >  16384;
1288                 joystate->button[22] = xinputstate.Gamepad.sThumbRX < -16384;
1289                 joystate->button[23] = xinputstate.Gamepad.sThumbRX >  16384;
1290                 joystate->axis[ 4] = xinputstate.Gamepad.bLeftTrigger * (1.0f / 255.0f);
1291                 joystate->axis[ 5] = xinputstate.Gamepad.bRightTrigger * (1.0f / 255.0f);
1292                 joystate->axis[ 0] = xinputstate.Gamepad.sThumbLX * (1.0f / 32767.0f);
1293                 joystate->axis[ 1] = xinputstate.Gamepad.sThumbLY * (1.0f / 32767.0f);
1294                 joystate->axis[ 2] = xinputstate.Gamepad.sThumbRX * (1.0f / 32767.0f);
1295                 joystate->axis[ 3] = xinputstate.Gamepad.sThumbRY * (1.0f / 32767.0f);
1296         }
1297 #endif
1298 }
1299
1300 void VID_Shared_BuildJoyState_Finish(vid_joystate_t *joystate)
1301 {
1302         float f, r;
1303         if (joystate->is360)
1304                 return;
1305         // emulate key events for thumbstick
1306         f = VID_JoyState_GetAxis(joystate, joy_axisforward.integer, 1, joy_axiskeyevents_deadzone.value) * joy_sensitivityforward.value;
1307         r = VID_JoyState_GetAxis(joystate, joy_axisside.integer   , 1, joy_axiskeyevents_deadzone.value) * joy_sensitivityside.value;
1308 #if MAXJOYBUTTON != 36
1309 #error this code must be updated if MAXJOYBUTTON changes!
1310 #endif
1311         joystate->button[32] = f > 0.0f;
1312         joystate->button[33] = f < 0.0f;
1313         joystate->button[34] = r > 0.0f;
1314         joystate->button[35] = r < 0.0f;
1315 }
1316
1317 static void VID_KeyEventForButton(qboolean oldbutton, qboolean newbutton, int key, double *timer)
1318 {
1319         if (oldbutton)
1320         {
1321                 if (newbutton)
1322                 {
1323                         if (realtime >= *timer)
1324                         {
1325                                 Key_Event(key, 0, true);
1326                                 *timer = realtime + 0.1;
1327                         }
1328                 }
1329                 else
1330                 {
1331                         Key_Event(key, 0, false);
1332                         *timer = 0;
1333                 }
1334         }
1335         else
1336         {
1337                 if (newbutton)
1338                 {
1339                         Key_Event(key, 0, true);
1340                         *timer = realtime + 0.5;
1341                 }
1342         }
1343 }
1344
1345 #if MAXJOYBUTTON != 36
1346 #error this code must be updated if MAXJOYBUTTON changes!
1347 #endif
1348 static int joybuttonkey[MAXJOYBUTTON][2] =
1349 {
1350         {K_JOY1, K_ENTER}, {K_JOY2, K_ESCAPE}, {K_JOY3, 0}, {K_JOY4, 0}, {K_JOY5, 0}, {K_JOY6, 0}, {K_JOY7, 0}, {K_JOY8, 0}, {K_JOY9, 0}, {K_JOY10, 0}, {K_JOY11, 0}, {K_JOY12, 0}, {K_JOY13, 0}, {K_JOY14, 0}, {K_JOY15, 0}, {K_JOY16, 0},
1351         {K_AUX1, 0}, {K_AUX2, 0}, {K_AUX3, 0}, {K_AUX4, 0}, {K_AUX5, 0}, {K_AUX6, 0}, {K_AUX7, 0}, {K_AUX8, 0}, {K_AUX9, 0}, {K_AUX10, 0}, {K_AUX11, 0}, {K_AUX12, 0}, {K_AUX13, 0}, {K_AUX14, 0}, {K_AUX15, 0}, {K_AUX16, 0},
1352         {K_JOY_UP, K_UPARROW}, {K_JOY_DOWN, K_DOWNARROW}, {K_JOY_RIGHT, K_RIGHTARROW}, {K_JOY_LEFT, K_LEFTARROW},
1353 };
1354
1355 static int joybuttonkey360[][2] =
1356 {
1357         {K_X360_DPAD_UP, K_UPARROW},
1358         {K_X360_DPAD_DOWN, K_DOWNARROW},
1359         {K_X360_DPAD_LEFT, K_LEFTARROW},
1360         {K_X360_DPAD_RIGHT, K_RIGHTARROW},
1361         {K_X360_START, K_ESCAPE},
1362         {K_X360_BACK, K_ESCAPE},
1363         {K_X360_LEFT_THUMB, 0},
1364         {K_X360_RIGHT_THUMB, 0},
1365         {K_X360_LEFT_SHOULDER, 0},
1366         {K_X360_RIGHT_SHOULDER, 0},
1367         {K_X360_A, K_ENTER},
1368         {K_X360_B, K_ESCAPE},
1369         {K_X360_X, 0},
1370         {K_X360_Y, 0},
1371         {K_X360_LEFT_TRIGGER, 0},
1372         {K_X360_RIGHT_TRIGGER, 0},
1373         {K_X360_LEFT_THUMB_DOWN, K_DOWNARROW},
1374         {K_X360_LEFT_THUMB_UP, K_UPARROW},
1375         {K_X360_LEFT_THUMB_LEFT, K_LEFTARROW},
1376         {K_X360_LEFT_THUMB_RIGHT, K_RIGHTARROW},
1377         {K_X360_RIGHT_THUMB_DOWN, 0},
1378         {K_X360_RIGHT_THUMB_UP, 0},
1379         {K_X360_RIGHT_THUMB_LEFT, 0},
1380         {K_X360_RIGHT_THUMB_RIGHT, 0},
1381 };
1382
1383 double vid_joybuttontimer[MAXJOYBUTTON];
1384 void VID_ApplyJoyState(vid_joystate_t *joystate)
1385 {
1386         int j;
1387         int c = joy_axiskeyevents.integer != 0;
1388         if (joystate->is360)
1389         {
1390 #if 0
1391                 // keystrokes (chatpad)
1392                 // DOES NOT WORK - no driver support in xinput1_3.dll :(
1393                 xinput_keystroke_t keystroke;
1394                 while (qXInputGetKeystroke && qXInputGetKeystroke(XUSER_INDEX_ANY, 0, &keystroke) == S_OK)
1395                         Con_Printf("XInput KeyStroke: VirtualKey %i, Unicode %i, Flags %x, UserIndex %i, HidCode %i\n", keystroke.VirtualKey, keystroke.Unicode, keystroke.Flags, keystroke.UserIndex, keystroke.HidCode);
1396 #endif
1397
1398                 // emit key events for buttons
1399                 for (j = 0;j < (int)(sizeof(joybuttonkey360)/sizeof(joybuttonkey360[0]));j++)
1400                         VID_KeyEventForButton(vid_joystate.button[j] != 0, joystate->button[j] != 0, joybuttonkey360[j][c], &vid_joybuttontimer[j]);
1401
1402                 // axes
1403                 cl.cmd.forwardmove += VID_JoyState_GetAxis(joystate, joy_x360_axisforward.integer, joy_x360_sensitivityforward.value, joy_x360_deadzoneforward.value) * cl_forwardspeed.value;
1404                 cl.cmd.sidemove    += VID_JoyState_GetAxis(joystate, joy_x360_axisside.integer, joy_x360_sensitivityside.value, joy_x360_deadzoneside.value) * cl_sidespeed.value;
1405                 cl.cmd.upmove      += VID_JoyState_GetAxis(joystate, joy_x360_axisup.integer, joy_x360_sensitivityup.value, joy_x360_deadzoneup.value) * cl_upspeed.value;
1406                 cl.viewangles[0]   += VID_JoyState_GetAxis(joystate, joy_x360_axispitch.integer, joy_x360_sensitivitypitch.value, joy_x360_deadzonepitch.value) * cl.realframetime * cl_pitchspeed.value;
1407                 cl.viewangles[1]   += VID_JoyState_GetAxis(joystate, joy_x360_axisyaw.integer, joy_x360_sensitivityyaw.value, joy_x360_deadzoneyaw.value) * cl.realframetime * cl_yawspeed.value;
1408                 //cl.viewangles[2]   += VID_JoyState_GetAxis(joystate, joy_x360_axisroll.integer, joy_x360_sensitivityroll.value, joy_x360_deadzoneroll.value) * cl.realframetime * cl_rollspeed.value;
1409         }
1410         else
1411         {
1412                 // emit key events for buttons
1413                 for (j = 0;j < MAXJOYBUTTON;j++)
1414                         VID_KeyEventForButton(vid_joystate.button[j] != 0, joystate->button[j] != 0, joybuttonkey[j][c], &vid_joybuttontimer[j]);
1415
1416                 // axes
1417                 cl.cmd.forwardmove += VID_JoyState_GetAxis(joystate, joy_axisforward.integer, joy_sensitivityforward.value, joy_deadzoneforward.value) * cl_forwardspeed.value;
1418                 cl.cmd.sidemove    += VID_JoyState_GetAxis(joystate, joy_axisside.integer, joy_sensitivityside.value, joy_deadzoneside.value) * cl_sidespeed.value;
1419                 cl.cmd.upmove      += VID_JoyState_GetAxis(joystate, joy_axisup.integer, joy_sensitivityup.value, joy_deadzoneup.value) * cl_upspeed.value;
1420                 cl.viewangles[0]   += VID_JoyState_GetAxis(joystate, joy_axispitch.integer, joy_sensitivitypitch.value, joy_deadzonepitch.value) * cl.realframetime * cl_pitchspeed.value;
1421                 cl.viewangles[1]   += VID_JoyState_GetAxis(joystate, joy_axisyaw.integer, joy_sensitivityyaw.value, joy_deadzoneyaw.value) * cl.realframetime * cl_yawspeed.value;
1422                 //cl.viewangles[2]   += VID_JoyState_GetAxis(joystate, joy_axisroll.integer, joy_sensitivityroll.value, joy_deadzoneroll.value) * cl.realframetime * cl_rollspeed.value;
1423         }
1424
1425         vid_joystate = *joystate;
1426 }
1427
1428 int VID_Shared_SetJoystick(int index)
1429 {
1430 #ifdef WIN32
1431         int i;
1432         int xinputcount = 0;
1433         int xinputindex = -1;
1434         int xinputavailable = 0;
1435         xinput_state_t state;
1436         // detect available XInput controllers
1437         for (i = 0;i < 4;i++)
1438         {
1439                 if (qXInputGetState && qXInputGetState(i, &state) == S_OK)
1440                 {
1441                         xinputavailable |= 1<<i;
1442                         if (index == xinputcount)
1443                                 xinputindex = i;
1444                         xinputcount++;
1445                 }
1446         }
1447         if (joy_xinputavailable.integer != xinputavailable)
1448                 Cvar_SetValueQuick(&joy_xinputavailable, xinputavailable);
1449         if (vid_xinputindex != xinputindex)
1450         {
1451                 vid_xinputindex = xinputindex;
1452                 if (xinputindex >= 0)
1453                         Con_Printf("Joystick %i opened (XInput Device %i)\n", index, xinputindex);
1454         }
1455         return xinputcount;
1456 #else
1457         return 0;
1458 #endif
1459 }
1460
1461
1462 static void Force_CenterView_f (void)
1463 {
1464         cl.viewangles[PITCH] = 0;
1465 }
1466
1467 static int gamma_forcenextframe = false;
1468 static float cachegamma, cachebrightness, cachecontrast, cacheblack[3], cachegrey[3], cachewhite[3], cachecontrastboost;
1469 static int cachecolorenable, cachehwgamma;
1470
1471 unsigned int vid_gammatables_serial = 0; // so other subsystems can poll if gamma parameters have changed
1472 qboolean vid_gammatables_trivial = true;
1473 void VID_BuildGammaTables(unsigned short *ramps, int rampsize)
1474 {
1475         if (cachecolorenable)
1476         {
1477                 BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[0]), cachewhite[0], cacheblack[0], cachecontrastboost, ramps, rampsize);
1478                 BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[1]), cachewhite[1], cacheblack[1], cachecontrastboost, ramps + rampsize, rampsize);
1479                 BuildGammaTable16(1.0f, invpow(0.5, 1 - cachegrey[2]), cachewhite[2], cacheblack[2], cachecontrastboost, ramps + rampsize*2, rampsize);
1480         }
1481         else
1482         {
1483                 BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, cachecontrastboost, ramps, rampsize);
1484                 BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, cachecontrastboost, ramps + rampsize, rampsize);
1485                 BuildGammaTable16(1.0f, cachegamma, cachecontrast, cachebrightness, cachecontrastboost, ramps + rampsize*2, rampsize);
1486         }
1487
1488         if(vid.sRGB2D || vid.sRGB3D)
1489         {
1490                 int i;
1491                 for(i = 0; i < 3*rampsize; ++i)
1492                         ramps[i] = (int)floor(bound(0.0f, Image_sRGBFloatFromLinearFloat(ramps[i] / 65535.0f), 1.0f) * 65535.0f + 0.5f);
1493         }
1494
1495         // LordHavoc: this code came from Ben Winslow and Zinx Verituse, I have
1496         // immensely butchered it to work with variable framerates and fit in with
1497         // the rest of darkplaces.
1498         if (v_psycho.integer)
1499         {
1500                 int x, y;
1501                 float t;
1502                 static float n[3], nd[3], nt[3];
1503                 static int init = true;
1504                 unsigned short *ramp;
1505                 gamma_forcenextframe = true;
1506                 if (init)
1507                 {
1508                         init = false;
1509                         for (x = 0;x < 3;x++)
1510                         {
1511                                 n[x] = lhrandom(0, 1);
1512                                 nd[x] = (rand()&1)?-0.25:0.25;
1513                                 nt[x] = lhrandom(1, 8.2);
1514                         }
1515                 }
1516
1517                 for (x = 0;x < 3;x++)
1518                 {
1519                         nt[x] -= cl.realframetime;
1520                         if (nt[x] < 0)
1521                         {
1522                                 nd[x] = -nd[x];
1523                                 nt[x] += lhrandom(1, 8.2);
1524                         }
1525                         n[x] += nd[x] * cl.realframetime;
1526                         n[x] -= floor(n[x]);
1527                 }
1528
1529                 for (x = 0, ramp = ramps;x < 3;x++)
1530                         for (y = 0, t = n[x] - 0.75f;y < rampsize;y++, t += 0.75f * (2.0f / rampsize))
1531                                 *ramp++ = (unsigned short)(cos(t*(M_PI*2.0)) * 32767.0f + 32767.0f);
1532         }
1533 }
1534
1535 void VID_UpdateGamma(qboolean force, int rampsize)
1536 {
1537         cvar_t *c;
1538         float f;
1539         int wantgamma;
1540         qboolean gamma_changed = false;
1541
1542         // LordHavoc: don't mess with gamma tables if running dedicated
1543         if (cls.state == ca_dedicated)
1544                 return;
1545
1546         wantgamma = v_hwgamma.integer;
1547         switch(vid.renderpath)
1548         {
1549         case RENDERPATH_GL20:
1550         case RENDERPATH_D3D9:
1551         case RENDERPATH_D3D10:
1552         case RENDERPATH_D3D11:
1553         case RENDERPATH_SOFT:
1554         case RENDERPATH_GLES2:
1555                 if (v_glslgamma.integer)
1556                         wantgamma = 0;
1557                 break;
1558         case RENDERPATH_GL11:
1559         case RENDERPATH_GL13:
1560         case RENDERPATH_GLES1:
1561                 break;
1562         }
1563         if(!vid_activewindow)
1564                 wantgamma = 0;
1565 #define BOUNDCVAR(cvar, m1, m2) c = &(cvar);f = bound(m1, c->value, m2);if (c->value != f) Cvar_SetValueQuick(c, f);
1566         BOUNDCVAR(v_gamma, 0.1, 5);
1567         BOUNDCVAR(v_contrast, 0.2, 5);
1568         BOUNDCVAR(v_brightness, -v_contrast.value * 0.8, 0.8);
1569         //BOUNDCVAR(v_contrastboost, 0.0625, 16);
1570         BOUNDCVAR(v_color_black_r, 0, 0.8);
1571         BOUNDCVAR(v_color_black_g, 0, 0.8);
1572         BOUNDCVAR(v_color_black_b, 0, 0.8);
1573         BOUNDCVAR(v_color_grey_r, 0, 0.95);
1574         BOUNDCVAR(v_color_grey_g, 0, 0.95);
1575         BOUNDCVAR(v_color_grey_b, 0, 0.95);
1576         BOUNDCVAR(v_color_white_r, 1, 5);
1577         BOUNDCVAR(v_color_white_g, 1, 5);
1578         BOUNDCVAR(v_color_white_b, 1, 5);
1579 #undef BOUNDCVAR
1580
1581         // set vid_gammatables_trivial to true if the current settings would generate the identity gamma table
1582         vid_gammatables_trivial = false;
1583         if(v_psycho.integer == 0)
1584         if(v_contrastboost.value == 1)
1585         if(!vid.sRGB2D)
1586         if(!vid.sRGB3D)
1587         {
1588                 if(v_color_enable.integer)
1589                 {
1590                         if(v_color_black_r.value == 0)
1591                         if(v_color_black_g.value == 0)
1592                         if(v_color_black_b.value == 0)
1593                         if(fabs(v_color_grey_r.value - 0.5) < 1e-6)
1594                         if(fabs(v_color_grey_g.value - 0.5) < 1e-6)
1595                         if(fabs(v_color_grey_b.value - 0.5) < 1e-6)
1596                         if(v_color_white_r.value == 1)
1597                         if(v_color_white_g.value == 1)
1598                         if(v_color_white_b.value == 1)
1599                                 vid_gammatables_trivial = true;
1600                 }
1601                 else
1602                 {
1603                         if(v_gamma.value == 1)
1604                         if(v_contrast.value == 1)
1605                         if(v_brightness.value == 0)
1606                                 vid_gammatables_trivial = true;
1607                 }
1608         }
1609
1610 #define GAMMACHECK(cache, value) if (cache != (value)) gamma_changed = true;cache = (value)
1611         if(v_psycho.integer)
1612                 gamma_changed = true;
1613         GAMMACHECK(cachegamma      , v_gamma.value);
1614         GAMMACHECK(cachecontrast   , v_contrast.value);
1615         GAMMACHECK(cachebrightness , v_brightness.value);
1616         GAMMACHECK(cachecontrastboost, v_contrastboost.value);
1617         GAMMACHECK(cachecolorenable, v_color_enable.integer);
1618         GAMMACHECK(cacheblack[0]   , v_color_black_r.value);
1619         GAMMACHECK(cacheblack[1]   , v_color_black_g.value);
1620         GAMMACHECK(cacheblack[2]   , v_color_black_b.value);
1621         GAMMACHECK(cachegrey[0]    , v_color_grey_r.value);
1622         GAMMACHECK(cachegrey[1]    , v_color_grey_g.value);
1623         GAMMACHECK(cachegrey[2]    , v_color_grey_b.value);
1624         GAMMACHECK(cachewhite[0]   , v_color_white_r.value);
1625         GAMMACHECK(cachewhite[1]   , v_color_white_g.value);
1626         GAMMACHECK(cachewhite[2]   , v_color_white_b.value);
1627
1628         if(gamma_changed)
1629                 ++vid_gammatables_serial;
1630
1631         GAMMACHECK(cachehwgamma    , wantgamma);
1632 #undef GAMMACHECK
1633
1634         if (!force && !gamma_forcenextframe && !gamma_changed)
1635                 return;
1636
1637         gamma_forcenextframe = false;
1638
1639         if (cachehwgamma)
1640         {
1641                 if (!vid_usinghwgamma)
1642                 {
1643                         vid_usinghwgamma = true;
1644                         if (vid_gammarampsize != rampsize || !vid_gammaramps)
1645                         {
1646                                 vid_gammarampsize = rampsize;
1647                                 if (vid_gammaramps)
1648                                         Z_Free(vid_gammaramps);
1649                                 vid_gammaramps = (unsigned short *)Z_Malloc(6 * vid_gammarampsize * sizeof(unsigned short));
1650                                 vid_systemgammaramps = vid_gammaramps + 3 * vid_gammarampsize;
1651                         }
1652                         VID_GetGamma(vid_systemgammaramps, vid_gammarampsize);
1653                 }
1654
1655                 VID_BuildGammaTables(vid_gammaramps, vid_gammarampsize);
1656
1657                 // set vid_hardwaregammasupported to true if VID_SetGamma succeeds, OR if vid_hwgamma is >= 2 (forced gamma - ignores driver return value)
1658                 Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_SetGamma(vid_gammaramps, vid_gammarampsize) || cachehwgamma >= 2);
1659                 // if custom gamma ramps failed (Windows stupidity), restore to system gamma
1660                 if(!vid_hardwaregammasupported.integer)
1661                 {
1662                         if (vid_usinghwgamma)
1663                         {
1664                                 vid_usinghwgamma = false;
1665                                 VID_SetGamma(vid_systemgammaramps, vid_gammarampsize);
1666                         }
1667                 }
1668         }
1669         else
1670         {
1671                 if (vid_usinghwgamma)
1672                 {
1673                         vid_usinghwgamma = false;
1674                         VID_SetGamma(vid_systemgammaramps, vid_gammarampsize);
1675                 }
1676         }
1677 }
1678
1679 void VID_RestoreSystemGamma(void)
1680 {
1681         if (vid_usinghwgamma)
1682         {
1683                 vid_usinghwgamma = false;
1684                 Cvar_SetValueQuick(&vid_hardwaregammasupported, VID_SetGamma(vid_systemgammaramps, vid_gammarampsize));
1685                 // force gamma situation to be reexamined next frame
1686                 gamma_forcenextframe = true;
1687         }
1688 }
1689
1690 #ifdef WIN32
1691 static dllfunction_t xinputdllfuncs[] =
1692 {
1693         {"XInputGetState", (void **) &qXInputGetState},
1694         {"XInputGetKeystroke", (void **) &qXInputGetKeystroke},
1695         {NULL, NULL}
1696 };
1697 static const char* xinputdllnames [] =
1698 {
1699         "xinput1_3.dll",
1700         "xinput1_2.dll",
1701         "xinput1_1.dll",
1702         NULL
1703 };
1704 static dllhandle_t xinputdll_dll = NULL;
1705 #endif
1706
1707 void VID_Shared_Init(void)
1708 {
1709 #ifdef SSE_POSSIBLE
1710         if (Sys_HaveSSE2())
1711         {
1712                 Con_Printf("DPSOFTRAST available (SSE2 instructions detected)\n");
1713                 Cvar_RegisterVariable(&vid_soft);
1714                 Cvar_RegisterVariable(&vid_soft_threads);
1715                 Cvar_RegisterVariable(&vid_soft_interlace);
1716         }
1717         else
1718                 Con_Printf("DPSOFTRAST not available (SSE2 disabled or not detected)\n");
1719 #else
1720         Con_Printf("DPSOFTRAST not available (SSE2 not compiled in)\n");
1721 #endif
1722
1723         Cvar_RegisterVariable(&vid_hardwaregammasupported);
1724         Cvar_RegisterVariable(&gl_info_vendor);
1725         Cvar_RegisterVariable(&gl_info_renderer);
1726         Cvar_RegisterVariable(&gl_info_version);
1727         Cvar_RegisterVariable(&gl_info_extensions);
1728         Cvar_RegisterVariable(&gl_info_platform);
1729         Cvar_RegisterVariable(&gl_info_driver);
1730         Cvar_RegisterVariable(&v_gamma);
1731         Cvar_RegisterVariable(&v_brightness);
1732         Cvar_RegisterVariable(&v_contrastboost);
1733         Cvar_RegisterVariable(&v_contrast);
1734
1735         Cvar_RegisterVariable(&v_color_enable);
1736         Cvar_RegisterVariable(&v_color_black_r);
1737         Cvar_RegisterVariable(&v_color_black_g);
1738         Cvar_RegisterVariable(&v_color_black_b);
1739         Cvar_RegisterVariable(&v_color_grey_r);
1740         Cvar_RegisterVariable(&v_color_grey_g);
1741         Cvar_RegisterVariable(&v_color_grey_b);
1742         Cvar_RegisterVariable(&v_color_white_r);
1743         Cvar_RegisterVariable(&v_color_white_g);
1744         Cvar_RegisterVariable(&v_color_white_b);
1745
1746         Cvar_RegisterVariable(&v_hwgamma);
1747         Cvar_RegisterVariable(&v_glslgamma);
1748         Cvar_RegisterVariable(&v_glslgamma_2d);
1749
1750         Cvar_RegisterVariable(&v_psycho);
1751
1752         Cvar_RegisterVariable(&vid_fullscreen);
1753         Cvar_RegisterVariable(&vid_width);
1754         Cvar_RegisterVariable(&vid_height);
1755         Cvar_RegisterVariable(&vid_bitsperpixel);
1756         Cvar_RegisterVariable(&vid_samples);
1757         Cvar_RegisterVariable(&vid_refreshrate);
1758         Cvar_RegisterVariable(&vid_userefreshrate);
1759         Cvar_RegisterVariable(&vid_stereobuffer);
1760         Cvar_RegisterVariable(&vid_touchscreen_density);
1761         Cvar_RegisterVariable(&vid_touchscreen_xdpi);
1762         Cvar_RegisterVariable(&vid_touchscreen_ydpi);
1763         Cvar_RegisterVariable(&vid_vsync);
1764         Cvar_RegisterVariable(&vid_mouse);
1765         Cvar_RegisterVariable(&vid_grabkeyboard);
1766         Cvar_RegisterVariable(&vid_touchscreen);
1767         Cvar_RegisterVariable(&vid_touchscreen_showkeyboard);
1768         Cvar_RegisterVariable(&vid_touchscreen_supportshowkeyboard);
1769         Cvar_RegisterVariable(&vid_stick_mouse);
1770         Cvar_RegisterVariable(&vid_resizable);
1771         Cvar_RegisterVariable(&vid_minwidth);
1772         Cvar_RegisterVariable(&vid_minheight);
1773         Cvar_RegisterVariable(&vid_gl13);
1774         Cvar_RegisterVariable(&vid_gl20);
1775         Cvar_RegisterVariable(&gl_finish);
1776         Cvar_RegisterVariable(&vid_sRGB);
1777         Cvar_RegisterVariable(&vid_sRGB_fallback);
1778
1779         Cvar_RegisterVariable(&joy_active);
1780 #ifdef WIN32
1781         Cvar_RegisterVariable(&joy_xinputavailable);
1782 #endif
1783         Cvar_RegisterVariable(&joy_detected);
1784         Cvar_RegisterVariable(&joy_enable);
1785         Cvar_RegisterVariable(&joy_index);
1786         Cvar_RegisterVariable(&joy_axisforward);
1787         Cvar_RegisterVariable(&joy_axisside);
1788         Cvar_RegisterVariable(&joy_axisup);
1789         Cvar_RegisterVariable(&joy_axispitch);
1790         Cvar_RegisterVariable(&joy_axisyaw);
1791         //Cvar_RegisterVariable(&joy_axisroll);
1792         Cvar_RegisterVariable(&joy_deadzoneforward);
1793         Cvar_RegisterVariable(&joy_deadzoneside);
1794         Cvar_RegisterVariable(&joy_deadzoneup);
1795         Cvar_RegisterVariable(&joy_deadzonepitch);
1796         Cvar_RegisterVariable(&joy_deadzoneyaw);
1797         //Cvar_RegisterVariable(&joy_deadzoneroll);
1798         Cvar_RegisterVariable(&joy_sensitivityforward);
1799         Cvar_RegisterVariable(&joy_sensitivityside);
1800         Cvar_RegisterVariable(&joy_sensitivityup);
1801         Cvar_RegisterVariable(&joy_sensitivitypitch);
1802         Cvar_RegisterVariable(&joy_sensitivityyaw);
1803         //Cvar_RegisterVariable(&joy_sensitivityroll);
1804         Cvar_RegisterVariable(&joy_axiskeyevents);
1805         Cvar_RegisterVariable(&joy_axiskeyevents_deadzone);
1806         Cvar_RegisterVariable(&joy_x360_axisforward);
1807         Cvar_RegisterVariable(&joy_x360_axisside);
1808         Cvar_RegisterVariable(&joy_x360_axisup);
1809         Cvar_RegisterVariable(&joy_x360_axispitch);
1810         Cvar_RegisterVariable(&joy_x360_axisyaw);
1811         //Cvar_RegisterVariable(&joy_x360_axisroll);
1812         Cvar_RegisterVariable(&joy_x360_deadzoneforward);
1813         Cvar_RegisterVariable(&joy_x360_deadzoneside);
1814         Cvar_RegisterVariable(&joy_x360_deadzoneup);
1815         Cvar_RegisterVariable(&joy_x360_deadzonepitch);
1816         Cvar_RegisterVariable(&joy_x360_deadzoneyaw);
1817         //Cvar_RegisterVariable(&joy_x360_deadzoneroll);
1818         Cvar_RegisterVariable(&joy_x360_sensitivityforward);
1819         Cvar_RegisterVariable(&joy_x360_sensitivityside);
1820         Cvar_RegisterVariable(&joy_x360_sensitivityup);
1821         Cvar_RegisterVariable(&joy_x360_sensitivitypitch);
1822         Cvar_RegisterVariable(&joy_x360_sensitivityyaw);
1823         //Cvar_RegisterVariable(&joy_x360_sensitivityroll);
1824
1825 #ifdef WIN32
1826         Sys_LoadLibrary(xinputdllnames, &xinputdll_dll, xinputdllfuncs);
1827 #endif
1828
1829         Cmd_AddCommand("force_centerview", Force_CenterView_f, "recenters view (stops looking up/down)");
1830         Cmd_AddCommand("vid_restart", VID_Restart_f, "restarts video system (closes and reopens the window, restarts renderer)");
1831 }
1832
1833 static int VID_Mode(int fullscreen, int width, int height, int bpp, float refreshrate, int stereobuffer, int samples)
1834 {
1835         viddef_mode_t mode;
1836         char vabuf[1024];
1837
1838         memset(&mode, 0, sizeof(mode));
1839         mode.fullscreen = fullscreen != 0;
1840         mode.width = width;
1841         mode.height = height;
1842         mode.bitsperpixel = bpp;
1843         mode.refreshrate = vid_userefreshrate.integer ? max(1, refreshrate) : 0;
1844         mode.userefreshrate = vid_userefreshrate.integer != 0;
1845         mode.stereobuffer = stereobuffer != 0;
1846         mode.samples = samples;
1847         cl_ignoremousemoves = 2;
1848         VID_ClearExtensions();
1849
1850         vid.samples = vid.mode.samples;
1851         if (VID_InitMode(&mode))
1852         {
1853                 // accept the (possibly modified) mode
1854                 vid.mode = mode;
1855                 vid.fullscreen     = vid.mode.fullscreen;
1856                 vid.width          = vid.mode.width;
1857                 vid.height         = vid.mode.height;
1858                 vid.bitsperpixel   = vid.mode.bitsperpixel;
1859                 vid.refreshrate    = vid.mode.refreshrate;
1860                 vid.userefreshrate = vid.mode.userefreshrate;
1861                 vid.stereobuffer   = vid.mode.stereobuffer;
1862                 vid.stencil        = vid.mode.bitsperpixel > 16;
1863                 vid.sRGB2D         = vid_sRGB.integer >= 1 && vid.sRGBcapable2D;
1864                 vid.sRGB3D         = vid_sRGB.integer >= 1 && vid.sRGBcapable3D;
1865
1866                 switch(vid.renderpath)
1867                 {
1868                 case RENDERPATH_GL11:
1869                 case RENDERPATH_GL13:
1870                 case RENDERPATH_GL20:
1871 #ifdef GL_STEREO
1872                         {
1873                                 GLboolean stereo;
1874                                 qglGetBooleanv(GL_STEREO, &stereo);
1875                                 vid.stereobuffer = stereo != 0;
1876                         }
1877 #endif
1878                         break;
1879                 default:
1880                         vid.stereobuffer = false;
1881                         break;
1882                 }
1883
1884                 if(
1885                         (vid_sRGB_fallback.integer >= 3) // force fallback
1886                         ||
1887                         (vid_sRGB_fallback.integer >= 2 && // fallback if framebuffer is 8bit
1888                                 !(r_viewfbo.integer >= 2 && vid.support.ext_framebuffer_object && vid.support.arb_texture_non_power_of_two && vid.samples < 2))
1889                 )
1890                         vid.sRGB2D = vid.sRGB3D = false;
1891
1892                 if(vid.samples != vid.mode.samples)
1893                         Con_Printf("NOTE: requested %dx AA, got %dx AA\n", vid.mode.samples, vid.samples);
1894
1895                 Con_Printf("Video Mode: %s %dx%dx%dx%.2fhz%s%s\n", mode.fullscreen ? "fullscreen" : "window", mode.width, mode.height, mode.bitsperpixel, mode.refreshrate, mode.stereobuffer ? " stereo" : "", mode.samples > 1 ? va(vabuf, sizeof(vabuf), " (%ix AA)", mode.samples) : "");
1896
1897                 Cvar_SetValueQuick(&vid_fullscreen, vid.mode.fullscreen);
1898                 Cvar_SetValueQuick(&vid_width, vid.mode.width);
1899                 Cvar_SetValueQuick(&vid_height, vid.mode.height);
1900                 Cvar_SetValueQuick(&vid_bitsperpixel, vid.mode.bitsperpixel);
1901                 Cvar_SetValueQuick(&vid_samples, vid.mode.samples);
1902                 if(vid_userefreshrate.integer)
1903                         Cvar_SetValueQuick(&vid_refreshrate, vid.mode.refreshrate);
1904                 Cvar_SetValueQuick(&vid_stereobuffer, vid.stereobuffer ? 1 : 0);
1905
1906                 if (vid_touchscreen.integer)
1907                 {
1908                         in_windowmouse_x = vid_width.value / 2.f;
1909                         in_windowmouse_y = vid_height.value / 2.f;
1910                 }
1911
1912                 return true;
1913         }
1914         else
1915                 return false;
1916 }
1917
1918 static void VID_OpenSystems(void)
1919 {
1920         R_Modules_Start();
1921         S_Startup();
1922 }
1923
1924 static void VID_CloseSystems(void)
1925 {
1926         S_Shutdown();
1927         R_Modules_Shutdown();
1928 }
1929
1930 qboolean vid_commandlinecheck = true;
1931 extern qboolean vid_opened;
1932
1933 void VID_Restart_f(void)
1934 {
1935         char vabuf[1024];
1936         char vabuf2[1024];
1937         // don't crash if video hasn't started yet
1938         if (vid_commandlinecheck)
1939                 return;
1940
1941         if (!vid_opened)
1942         {
1943                 SCR_BeginLoadingPlaque(false);
1944                 return;
1945         }
1946
1947         Con_Printf("VID_Restart: changing from %s %dx%dx%dbpp%s%s, to %s %dx%dx%dbpp%s%s.\n",
1948                 vid.mode.fullscreen ? "fullscreen" : "window", vid.mode.width, vid.mode.height, vid.mode.bitsperpixel, vid.mode.fullscreen && vid.mode.userefreshrate ? va(vabuf, sizeof(vabuf), "x%.2fhz", vid.mode.refreshrate) : "", vid.mode.samples > 1 ? va(vabuf2, sizeof(vabuf2), " (%ix AA)", vid.mode.samples) : "",
1949                 vid_fullscreen.integer ? "fullscreen" : "window", vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, vid_fullscreen.integer && vid_userefreshrate.integer ? va(vabuf, sizeof(vabuf), "x%.2fhz", vid_refreshrate.value) : "", vid_samples.integer > 1 ? va(vabuf2, sizeof(vabuf2), " (%ix AA)", vid_samples.integer) : "");
1950         VID_CloseSystems();
1951         VID_Shutdown();
1952         if (!VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, vid_refreshrate.value, vid_stereobuffer.integer, vid_samples.integer))
1953         {
1954                 Con_Print("Video mode change failed\n");
1955                 if (!VID_Mode(vid.mode.fullscreen, vid.mode.width, vid.mode.height, vid.mode.bitsperpixel, vid.mode.refreshrate, vid.mode.stereobuffer, vid.mode.samples))
1956                         Sys_Error("Unable to restore to last working video mode");
1957         }
1958         VID_OpenSystems();
1959 }
1960
1961 const char *vidfallbacks[][2] =
1962 {
1963         {"vid_stereobuffer", "0"},
1964         {"vid_samples", "1"},
1965         {"vid_userefreshrate", "0"},
1966         {"vid_width", "640"},
1967         {"vid_height", "480"},
1968         {"vid_bitsperpixel", "16"},
1969         {NULL, NULL}
1970 };
1971
1972 // this is only called once by Host_StartVideo and again on each FS_GameDir_f
1973 void VID_Start(void)
1974 {
1975         int i, width, height, success;
1976         if (vid_commandlinecheck)
1977         {
1978                 // interpret command-line parameters
1979                 vid_commandlinecheck = false;
1980 // COMMANDLINEOPTION: Video: -window performs +vid_fullscreen 0
1981                 if (COM_CheckParm("-window") || COM_CheckParm("-safe"))
1982                         Cvar_SetValueQuick(&vid_fullscreen, false);
1983 // COMMANDLINEOPTION: Video: -fullscreen performs +vid_fullscreen 1
1984                 if (COM_CheckParm("-fullscreen"))
1985                         Cvar_SetValueQuick(&vid_fullscreen, true);
1986                 width = 0;
1987                 height = 0;
1988 // COMMANDLINEOPTION: Video: -width <pixels> performs +vid_width <pixels> and also +vid_height <pixels*3/4> if only -width is specified (example: -width 1024 sets 1024x768 mode)
1989                 if ((i = COM_CheckParm("-width")) != 0)
1990                         width = atoi(com_argv[i+1]);
1991 // COMMANDLINEOPTION: Video: -height <pixels> performs +vid_height <pixels> and also +vid_width <pixels*4/3> if only -height is specified (example: -height 768 sets 1024x768 mode)
1992                 if ((i = COM_CheckParm("-height")) != 0)
1993                         height = atoi(com_argv[i+1]);
1994                 if (width == 0)
1995                         width = height * 4 / 3;
1996                 if (height == 0)
1997                         height = width * 3 / 4;
1998                 if (width)
1999                         Cvar_SetValueQuick(&vid_width, width);
2000                 if (height)
2001                         Cvar_SetValueQuick(&vid_height, height);
2002 // COMMANDLINEOPTION: Video: -bpp <bits> performs +vid_bitsperpixel <bits> (example -bpp 32 or -bpp 16)
2003                 if ((i = COM_CheckParm("-bpp")) != 0)
2004                         Cvar_SetQuick(&vid_bitsperpixel, com_argv[i+1]);
2005 // COMMANDLINEOPTION: Video: -density <multiplier> performs +vid_touchscreen_density <multiplier> (example -density 1 or -density 1.5)
2006                 if ((i = COM_CheckParm("-density")) != 0)
2007                         Cvar_SetQuick(&vid_touchscreen_density, com_argv[i+1]);
2008 // COMMANDLINEOPTION: Video: -xdpi <dpi> performs +vid_touchscreen_xdpi <dpi> (example -xdpi 160 or -xdpi 320)
2009                 if ((i = COM_CheckParm("-touchscreen_xdpi")) != 0)
2010                         Cvar_SetQuick(&vid_touchscreen_xdpi, com_argv[i+1]);
2011 // COMMANDLINEOPTION: Video: -ydpi <dpi> performs +vid_touchscreen_ydpi <dpi> (example -ydpi 160 or -ydpi 320)
2012                 if ((i = COM_CheckParm("-touchscreen_ydpi")) != 0)
2013                         Cvar_SetQuick(&vid_touchscreen_ydpi, com_argv[i+1]);
2014         }
2015
2016         success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, vid_refreshrate.value, vid_stereobuffer.integer, vid_samples.integer);
2017         if (!success)
2018         {
2019                 Con_Print("Desired video mode fail, trying fallbacks...\n");
2020                 for (i = 0;!success && vidfallbacks[i][0] != NULL;i++)
2021                 {
2022                         Cvar_Set(vidfallbacks[i][0], vidfallbacks[i][1]);
2023                         success = VID_Mode(vid_fullscreen.integer, vid_width.integer, vid_height.integer, vid_bitsperpixel.integer, vid_refreshrate.value, vid_stereobuffer.integer, vid_samples.integer);
2024                 }
2025                 if (!success)
2026                         Sys_Error("Video modes failed");
2027         }
2028         VID_OpenSystems();
2029 }
2030
2031 void VID_Stop(void)
2032 {
2033         VID_CloseSystems();
2034         VID_Shutdown();
2035 }
2036
2037 static int VID_SortModes_Compare(const void *a_, const void *b_)
2038 {
2039         vid_mode_t *a = (vid_mode_t *) a_;
2040         vid_mode_t *b = (vid_mode_t *) b_;
2041         if(a->width > b->width)
2042                 return +1;
2043         if(a->width < b->width)
2044                 return -1;
2045         if(a->height > b->height)
2046                 return +1;
2047         if(a->height < b->height)
2048                 return -1;
2049         if(a->refreshrate > b->refreshrate)
2050                 return +1;
2051         if(a->refreshrate < b->refreshrate)
2052                 return -1;
2053         if(a->bpp > b->bpp)
2054                 return +1;
2055         if(a->bpp < b->bpp)
2056                 return -1;
2057         if(a->pixelheight_num * b->pixelheight_denom > a->pixelheight_denom * b->pixelheight_num)
2058                 return +1;
2059         if(a->pixelheight_num * b->pixelheight_denom < a->pixelheight_denom * b->pixelheight_num)
2060                 return -1;
2061         return 0;
2062 }
2063 size_t VID_SortModes(vid_mode_t *modes, size_t count, qboolean usebpp, qboolean userefreshrate, qboolean useaspect)
2064 {
2065         size_t i;
2066         if(count == 0)
2067                 return 0;
2068         // 1. sort them
2069         qsort(modes, count, sizeof(*modes), VID_SortModes_Compare);
2070         // 2. remove duplicates
2071         for(i = 0; i < count; ++i)
2072         {
2073                 if(modes[i].width && modes[i].height)
2074                 {
2075                         if(i == 0)
2076                                 continue;
2077                         if(modes[i].width != modes[i-1].width)
2078                                 continue;
2079                         if(modes[i].height != modes[i-1].height)
2080                                 continue;
2081                         if(userefreshrate)
2082                                 if(modes[i].refreshrate != modes[i-1].refreshrate)
2083                                         continue;
2084                         if(usebpp)
2085                                 if(modes[i].bpp != modes[i-1].bpp)
2086                                         continue;
2087                         if(useaspect)
2088                                 if(modes[i].pixelheight_num * modes[i-1].pixelheight_denom != modes[i].pixelheight_denom * modes[i-1].pixelheight_num)
2089                                         continue;
2090                 }
2091                 // a dupe, or a bogus mode!
2092                 if(i < count-1)
2093                         memmove(&modes[i], &modes[i+1], sizeof(*modes) * (count-1 - i));
2094                 --i; // check this index again, as mode i+1 is now here
2095                 --count;
2096         }
2097         return count;
2098 }
2099
2100 void VID_Soft_SharedSetup(void)
2101 {
2102         gl_platform = "DPSOFTRAST";
2103         gl_platformextensions = "";
2104
2105         gl_renderer = "DarkPlaces-Soft";
2106         gl_vendor = "Forest Hale";
2107         gl_version = "0.0";
2108         gl_extensions = "";
2109
2110         // clear the extension flags
2111         memset(&vid.support, 0, sizeof(vid.support));
2112         Cvar_SetQuick(&gl_info_extensions, "");
2113
2114         // DPSOFTRAST requires BGRA
2115         vid.forcetextype = TEXTYPE_BGRA;
2116
2117         vid.forcevbo = false;
2118         vid.support.arb_depth_texture = true;
2119         vid.support.arb_draw_buffers = true;
2120         vid.support.arb_occlusion_query = true;
2121         vid.support.arb_shadow = true;
2122         //vid.support.arb_texture_compression = true;
2123         vid.support.arb_texture_cube_map = true;
2124         vid.support.arb_texture_non_power_of_two = false;
2125         vid.support.arb_vertex_buffer_object = true;
2126         vid.support.ext_blend_subtract = true;
2127         vid.support.ext_draw_range_elements = true;
2128         vid.support.ext_framebuffer_object = true;
2129
2130         vid.support.ext_texture_3d = true;
2131         //vid.support.ext_texture_compression_s3tc = true;
2132         vid.support.ext_texture_filter_anisotropic = true;
2133         vid.support.ati_separate_stencil = true;
2134         vid.support.ext_texture_srgb = false;
2135
2136         vid.maxtexturesize_2d = 16384;
2137         vid.maxtexturesize_3d = 512;
2138         vid.maxtexturesize_cubemap = 16384;
2139         vid.texunits = 4;
2140         vid.teximageunits = 32;
2141         vid.texarrayunits = 8;
2142         vid.max_anisotropy = 1;
2143         vid.maxdrawbuffers = 4;
2144
2145         vid.texunits = bound(4, vid.texunits, MAX_TEXTUREUNITS);
2146         vid.teximageunits = bound(16, vid.teximageunits, MAX_TEXTUREUNITS);
2147         vid.texarrayunits = bound(8, vid.texarrayunits, MAX_TEXTUREUNITS);
2148         Con_DPrintf("Using DarkPlaces Software Rasterizer rendering path\n");
2149         vid.renderpath = RENDERPATH_SOFT;
2150         vid.sRGBcapable2D = false;
2151         vid.sRGBcapable3D = false;
2152         vid.useinterleavedarrays = false;
2153
2154         Cvar_SetQuick(&gl_info_vendor, gl_vendor);
2155         Cvar_SetQuick(&gl_info_renderer, gl_renderer);
2156         Cvar_SetQuick(&gl_info_version, gl_version);
2157         Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
2158         Cvar_SetQuick(&gl_info_driver, gl_driver);
2159
2160         // LordHavoc: report supported extensions
2161         Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2162
2163         // clear to black (loading plaque will be seen over this)
2164         GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
2165 }