gl_backend.c

   1
   2 #include "quakedef.h"
   3 #include "cl_collision.h"
   4 #include "dpsoftrast.h"
   5 #ifdef SUPPORTD3D
   6 #include <d3d9.h>
   7 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
   8 extern D3DCAPS9 vid_d3d9caps;
   9 #endif
  10
  11 // on GLES we have to use some proper #define's
  12 #ifndef GL_FRAMEBUFFER
  13 #define GL_FRAMEBUFFER                                   0x8D40
  14 #define GL_DEPTH_ATTACHMENT                              0x8D00
  15 #define GL_COLOR_ATTACHMENT0                             0x8CE0
  16 #define GL_INVALID_FRAMEBUFFER_OPERATION                 0x0506
  17 #endif
  18 #ifndef GL_COLOR_ATTACHMENT1
  19 #define GL_COLOR_ATTACHMENT1                             0x8CE1
  20 #define GL_COLOR_ATTACHMENT2                             0x8CE2
  21 #define GL_COLOR_ATTACHMENT3                             0x8CE3
  22 #define GL_COLOR_ATTACHMENT4                             0x8CE4
  23 #define GL_COLOR_ATTACHMENT5                             0x8CE5
  24 #define GL_COLOR_ATTACHMENT6                             0x8CE6
  25 #define GL_COLOR_ATTACHMENT7                             0x8CE7
  26 #define GL_COLOR_ATTACHMENT8                             0x8CE8
  27 #define GL_COLOR_ATTACHMENT9                             0x8CE9
  28 #define GL_COLOR_ATTACHMENT10                            0x8CEA
  29 #define GL_COLOR_ATTACHMENT11                            0x8CEB
  30 #define GL_COLOR_ATTACHMENT12                            0x8CEC
  31 #define GL_COLOR_ATTACHMENT13                            0x8CED
  32 #define GL_COLOR_ATTACHMENT14                            0x8CEE
  33 #define GL_COLOR_ATTACHMENT15                            0x8CEF
  34 #endif
  35 #ifndef GL_ARRAY_BUFFER
  36 #define GL_ARRAY_BUFFER               0x8892
  37 #define GL_ELEMENT_ARRAY_BUFFER       0x8893
  38 #endif
  39 //#ifndef GL_VERTEX_ARRAY
  40 //#define GL_VERTEX_ARRAY                               0x8074
  41 //#define GL_COLOR_ARRAY                                0x8076
  42 //#define GL_TEXTURE_COORD_ARRAY                        0x8078
  43 //#endif
  44 #ifndef GL_TEXTURE0
  45 #define GL_TEXTURE0                                     0x84C0
  46 #define GL_TEXTURE1                                     0x84C1
  47 #define GL_TEXTURE2                                     0x84C2
  48 #define GL_TEXTURE3                                     0x84C3
  49 #define GL_TEXTURE4                                     0x84C4
  50 #define GL_TEXTURE5                                     0x84C5
  51 #define GL_TEXTURE6                                     0x84C6
  52 #define GL_TEXTURE7                                     0x84C7
  53 #define GL_TEXTURE8                                     0x84C8
  54 #define GL_TEXTURE9                                     0x84C9
  55 #define GL_TEXTURE10                            0x84CA
  56 #define GL_TEXTURE11                            0x84CB
  57 #define GL_TEXTURE12                            0x84CC
  58 #define GL_TEXTURE13                            0x84CD
  59 #define GL_TEXTURE14                            0x84CE
  60 #define GL_TEXTURE15                            0x84CF
  61 #define GL_TEXTURE16                            0x84D0
  62 #define GL_TEXTURE17                            0x84D1
  63 #define GL_TEXTURE18                            0x84D2
  64 #define GL_TEXTURE19                            0x84D3
  65 #define GL_TEXTURE20                            0x84D4
  66 #define GL_TEXTURE21                            0x84D5
  67 #define GL_TEXTURE22                            0x84D6
  68 #define GL_TEXTURE23                            0x84D7
  69 #define GL_TEXTURE24                            0x84D8
  70 #define GL_TEXTURE25                            0x84D9
  71 #define GL_TEXTURE26                            0x84DA
  72 #define GL_TEXTURE27                            0x84DB
  73 #define GL_TEXTURE28                            0x84DC
  74 #define GL_TEXTURE29                            0x84DD
  75 #define GL_TEXTURE30                            0x84DE
  76 #define GL_TEXTURE31                            0x84DF
  77 #endif
  78
  79 #ifndef GL_TEXTURE_3D
  80 #define GL_TEXTURE_3D                           0x806F
  81 #endif
  82 #ifndef GL_TEXTURE_CUBE_MAP
  83 #define GL_TEXTURE_CUBE_MAP                 0x8513
  84 #endif
  85 //#ifndef GL_MODELVIEW
  86 //#define GL_MODELVIEW                          0x1700
  87 //#endif
  88 //#ifndef GL_PROJECTION
  89 //#define GL_PROJECTION                         0x1701
  90 //#endif
  91 //#ifndef GL_DECAL
  92 //#define GL_DECAL                              0x2101
  93 //#endif
  94 //#ifndef GL_INTERPOLATE
  95 //#define GL_INTERPOLATE                                0x8575
  96 //#endif
  97
  98
  99 #define MAX_RENDERTARGETS 4
 100
 101 cvar_t gl_mesh_drawrangeelements = {0, "gl_mesh_drawrangeelements", "1", "use glDrawRangeElements function if available instead of glDrawElements (for performance comparisons or bug testing)"};
 102 cvar_t gl_mesh_testmanualfeeding = {0, "gl_mesh_testmanualfeeding", "0", "use glBegin(GL_TRIANGLES);glTexCoord2f();glVertex3f();glEnd(); primitives instead of glDrawElements (useful to test for driver bugs with glDrawElements)"};
 103 cvar_t gl_paranoid = {0, "gl_paranoid", "0", "enables OpenGL error checking and other tests"};
 104 cvar_t gl_printcheckerror = {0, "gl_printcheckerror", "0", "prints all OpenGL error checks, useful to identify location of driver crashes"};
 105
 106 cvar_t r_render = {0, "r_render", "1", "enables rendering 3D views (you want this on!)"};
 107 cvar_t r_renderview = {0, "r_renderview", "1", "enables rendering 3D views (you want this on!)"};
 108 cvar_t r_waterwarp = {CVAR_SAVE, "r_waterwarp", "1", "warp view while underwater"};
 109 cvar_t gl_polyblend = {CVAR_SAVE, "gl_polyblend", "1", "tints view while underwater, hurt, etc"};
 110 cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1", "enables OpenGL dithering (16bit looks bad with this off)"};
 111 cvar_t gl_vbo = {CVAR_SAVE, "gl_vbo", "3", "make use of GL_ARB_vertex_buffer_object extension to store static geometry in video memory for faster rendering, 0 disables VBO allocation or use, 1 enables VBOs for vertex and triangle data, 2 only for vertex data, 3 for vertex data and triangle data of simple meshes (ones with only one surface)"};
 112 cvar_t gl_vbo_dynamicvertex = {CVAR_SAVE, "gl_vbo_dynamicvertex", "0", "make use of GL_ARB_vertex_buffer_object extension when rendering dynamic (animated/procedural) geometry such as text and particles"};
 113 cvar_t gl_vbo_dynamicindex = {CVAR_SAVE, "gl_vbo_dynamicindex", "0", "make use of GL_ARB_vertex_buffer_object extension when rendering dynamic (animated/procedural) geometry such as text and particles"};
 114 cvar_t gl_fbo = {CVAR_SAVE, "gl_fbo", "1", "make use of GL_ARB_framebuffer_object extension to enable shadowmaps and other features using pixel formats different from the framebuffer"};
 115
 116 cvar_t v_flipped = {0, "v_flipped", "0", "mirror the screen (poor man's left handed mode)"};
 117 qboolean v_flipped_state = false;
 118
 119 r_viewport_t gl_viewport;
 120 matrix4x4_t gl_modelmatrix;
 121 matrix4x4_t gl_viewmatrix;
 122 matrix4x4_t gl_modelviewmatrix;
 123 matrix4x4_t gl_projectionmatrix;
 124 matrix4x4_t gl_modelviewprojectionmatrix;
 125 float gl_modelview16f[16];
 126 float gl_modelviewprojection16f[16];
 127 qboolean gl_modelmatrixchanged;
 128
 129 int gl_maxdrawrangeelementsvertices;
 130 int gl_maxdrawrangeelementsindices;
 131
 132 #ifdef DEBUGGL
 133 int gl_errornumber = 0;
 134
 135 void GL_PrintError(int errornumber, const char *filename, int linenumber)
 136 {
 137         switch(errornumber)
 138         {
 139 #ifdef GL_INVALID_ENUM
 140         case GL_INVALID_ENUM:
 141                 Con_Printf("GL_INVALID_ENUM at %s:%i\n", filename, linenumber);
 142                 break;
 143 #endif
 144 #ifdef GL_INVALID_VALUE
 145         case GL_INVALID_VALUE:
 146                 Con_Printf("GL_INVALID_VALUE at %s:%i\n", filename, linenumber);
 147                 break;
 148 #endif
 149 #ifdef GL_INVALID_OPERATION
 150         case GL_INVALID_OPERATION:
 151                 Con_Printf("GL_INVALID_OPERATION at %s:%i\n", filename, linenumber);
 152                 break;
 153 #endif
 154 #ifdef GL_STACK_OVERFLOW
 155         case GL_STACK_OVERFLOW:
 156                 Con_Printf("GL_STACK_OVERFLOW at %s:%i\n", filename, linenumber);
 157                 break;
 158 #endif
 159 #ifdef GL_STACK_UNDERFLOW
 160         case GL_STACK_UNDERFLOW:
 161                 Con_Printf("GL_STACK_UNDERFLOW at %s:%i\n", filename, linenumber);
 162                 break;
 163 #endif
 164 #ifdef GL_OUT_OF_MEMORY
 165         case GL_OUT_OF_MEMORY:
 166                 Con_Printf("GL_OUT_OF_MEMORY at %s:%i\n", filename, linenumber);
 167                 break;
 168 #endif
 169 #ifdef GL_TABLE_TOO_LARGE
 170         case GL_TABLE_TOO_LARGE:
 171                 Con_Printf("GL_TABLE_TOO_LARGE at %s:%i\n", filename, linenumber);
 172                 break;
 173 #endif
 174 #ifdef GL_INVALID_FRAMEBUFFER_OPERATION
 175         case GL_INVALID_FRAMEBUFFER_OPERATION:
 176                 Con_Printf("GL_INVALID_FRAMEBUFFER_OPERATION at %s:%i\n", filename, linenumber);
 177                 break;
 178 #endif
 179         default:
 180                 Con_Printf("GL UNKNOWN (%i) at %s:%i\n", errornumber, filename, linenumber);
 181                 break;
 182         }
 183 }
 184 #endif
 185
 186 #define BACKENDACTIVECHECK if (!gl_state.active) Sys_Error("GL backend function called when backend is not active");
 187
 188 void SCR_ScreenShot_f (void);
 189
 190 typedef struct gltextureunit_s
 191 {
 192         int pointer_texcoord_components;
 193         int pointer_texcoord_gltype;
 194         size_t pointer_texcoord_stride;
 195         const void *pointer_texcoord_pointer;
 196         const r_meshbuffer_t *pointer_texcoord_vertexbuffer;
 197         size_t pointer_texcoord_offset;
 198
 199         rtexture_t *texture;
 200         int t2d, t3d, tcubemap;
 201         int arrayenabled;
 202         int rgbscale, alphascale;
 203         int combine;
 204         int combinergb, combinealpha;
 205         // texmatrixenabled exists only to avoid unnecessary texmatrix compares
 206         int texmatrixenabled;
 207         matrix4x4_t matrix;
 208 }
 209 gltextureunit_t;
 210
 211 typedef struct gl_state_s
 212 {
 213         int cullface;
 214         int cullfaceenable;
 215         int blendfunc1;
 216         int blendfunc2;
 217         qboolean blend;
 218         GLboolean depthmask;
 219         int colormask; // stored as bottom 4 bits: r g b a (3 2 1 0 order)
 220         int depthtest;
 221         int depthfunc;
 222         float depthrange[2];
 223         float polygonoffset[2];
 224         int alphatest;
 225         int alphafunc;
 226         float alphafuncvalue;
 227         qboolean alphatocoverage;
 228         int scissortest;
 229         unsigned int unit;
 230         unsigned int clientunit;
 231         gltextureunit_t units[MAX_TEXTUREUNITS];
 232         float color4f[4];
 233         int lockrange_first;
 234         int lockrange_count;
 235         int vertexbufferobject;
 236         int elementbufferobject;
 237         int uniformbufferobject;
 238         int framebufferobject;
 239         int defaultframebufferobject; // deal with platforms that use a non-zero default fbo
 240         qboolean pointer_color_enabled;
 241
 242         int pointer_vertex_components;
 243         int pointer_vertex_gltype;
 244         size_t pointer_vertex_stride;
 245         const void *pointer_vertex_pointer;
 246         const r_meshbuffer_t *pointer_vertex_vertexbuffer;
 247         size_t pointer_vertex_offset;
 248
 249         int pointer_color_components;
 250         int pointer_color_gltype;
 251         size_t pointer_color_stride;
 252         const void *pointer_color_pointer;
 253         const r_meshbuffer_t *pointer_color_vertexbuffer;
 254         size_t pointer_color_offset;
 255
 256         void *preparevertices_tempdata;
 257         size_t preparevertices_tempdatamaxsize;
 258         r_vertexgeneric_t *preparevertices_vertexgeneric;
 259         r_vertexmesh_t *preparevertices_vertexmesh;
 260         int preparevertices_numvertices;
 261
 262         qboolean usevbo_staticvertex;
 263         qboolean usevbo_staticindex;
 264         qboolean usevbo_dynamicvertex;
 265         qboolean usevbo_dynamicindex;
 266
 267         memexpandablearray_t meshbufferarray;
 268
 269         qboolean active;
 270
 271 #ifdef SUPPORTD3D
 272 //      rtexture_t *d3drt_depthtexture;
 273 //      rtexture_t *d3drt_colortextures[MAX_RENDERTARGETS];
 274         IDirect3DSurface9 *d3drt_depthsurface;
 275         IDirect3DSurface9 *d3drt_colorsurfaces[MAX_RENDERTARGETS];
 276         IDirect3DSurface9 *d3drt_backbufferdepthsurface;
 277         IDirect3DSurface9 *d3drt_backbuffercolorsurface;
 278         void *d3dvertexbuffer;
 279         void *d3dvertexdata;
 280         int d3dvertexsize;
 281 #endif
 282 }
 283 gl_state_t;
 284
 285 static gl_state_t gl_state;
 286
 287
 288 /*
 289 note: here's strip order for a terrain row:
 290 0--1--2--3--4
 291 |\ |\ |\ |\ |
 292 | \| \| \| \|
 293 A--B--C--D--E
 294 clockwise
 295
 296 A0B, 01B, B1C, 12C, C2D, 23D, D3E, 34E
 297
 298 *elements++ = i + row;
 299 *elements++ = i;
 300 *elements++ = i + row + 1;
 301 *elements++ = i;
 302 *elements++ = i + 1;
 303 *elements++ = i + row + 1;
 304
 305
 306 for (y = 0;y < rows - 1;y++)
 307 {
 308         for (x = 0;x < columns - 1;x++)
 309         {
 310                 i = y * rows + x;
 311                 *elements++ = i + columns;
 312                 *elements++ = i;
 313                 *elements++ = i + columns + 1;
 314                 *elements++ = i;
 315                 *elements++ = i + 1;
 316                 *elements++ = i + columns + 1;
 317         }
 318 }
 319
 320 alternative:
 321 0--1--2--3--4
 322 | /| /|\ | /|
 323 |/ |/ | \|/ |
 324 A--B--C--D--E
 325 counterclockwise
 326
 327 for (y = 0;y < rows - 1;y++)
 328 {
 329         for (x = 0;x < columns - 1;x++)
 330         {
 331                 i = y * rows + x;
 332                 *elements++ = i;
 333                 *elements++ = i + columns;
 334                 *elements++ = i + columns + 1;
 335                 *elements++ = i + columns;
 336                 *elements++ = i + columns + 1;
 337                 *elements++ = i + 1;
 338         }
 339 }
 340 */
 341
 342 int polygonelement3i[(POLYGONELEMENTS_MAXPOINTS-2)*3];
 343 unsigned short polygonelement3s[(POLYGONELEMENTS_MAXPOINTS-2)*3];
 344 int quadelement3i[QUADELEMENTS_MAXQUADS*6];
 345 unsigned short quadelement3s[QUADELEMENTS_MAXQUADS*6];
 346
 347 static void GL_VBOStats_f(void)
 348 {
 349         GL_Mesh_ListVBOs(true);
 350 }
 351
 352 static void GL_Backend_ResetState(void);
 353
 354 static void R_Mesh_InitVertexDeclarations(void);
 355 static void R_Mesh_DestroyVertexDeclarations(void);
 356
 357 static void R_Mesh_SetUseVBO(void)
 358 {
 359         switch(vid.renderpath)
 360         {
 361         case RENDERPATH_GL11:
 362         case RENDERPATH_GL13:
 363         case RENDERPATH_GL20:
 364         case RENDERPATH_GLES1:
 365                 gl_state.usevbo_staticvertex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo;
 366                 gl_state.usevbo_staticindex = (vid.support.arb_vertex_buffer_object && (gl_vbo.integer == 1 || gl_vbo.integer == 3)) || vid.forcevbo;
 367                 gl_state.usevbo_dynamicvertex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicvertex.integer && gl_vbo.integer) || vid.forcevbo;
 368                 gl_state.usevbo_dynamicindex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicindex.integer && gl_vbo.integer) || vid.forcevbo;
 369                 break;
 370         case RENDERPATH_D3D9:
 371                 gl_state.usevbo_staticvertex = gl_state.usevbo_staticindex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo;
 372                 gl_state.usevbo_dynamicvertex = gl_state.usevbo_dynamicindex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicvertex.integer && gl_vbo_dynamicindex.integer && gl_vbo.integer) || vid.forcevbo;
 373                 break;
 374         case RENDERPATH_D3D10:
 375                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 376                 break;
 377         case RENDERPATH_D3D11:
 378                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 379                 break;
 380         case RENDERPATH_SOFT:
 381                 gl_state.usevbo_staticvertex = false;
 382                 gl_state.usevbo_staticindex = false;
 383                 gl_state.usevbo_dynamicvertex = false;
 384                 gl_state.usevbo_dynamicindex = false;
 385                 break;
 386         case RENDERPATH_GLES2:
 387                 gl_state.usevbo_staticvertex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo;
 388                 gl_state.usevbo_staticindex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo;
 389                 gl_state.usevbo_dynamicvertex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicvertex.integer) || vid.forcevbo;
 390                 gl_state.usevbo_dynamicindex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicindex.integer) || vid.forcevbo;
 391                 break;
 392         }
 393 }
 394
 395 static void gl_backend_start(void)
 396 {
 397         memset(&gl_state, 0, sizeof(gl_state));
 398
 399         R_Mesh_InitVertexDeclarations();
 400
 401         R_Mesh_SetUseVBO();
 402         Mem_ExpandableArray_NewArray(&gl_state.meshbufferarray, r_main_mempool, sizeof(r_meshbuffer_t), 128);
 403
 404         Con_DPrintf("OpenGL backend started.\n");
 405
 406         CHECKGLERROR
 407
 408         GL_Backend_ResetState();
 409
 410         switch(vid.renderpath)
 411         {
 412         case RENDERPATH_GL11:
 413         case RENDERPATH_GL13:
 414         case RENDERPATH_GL20:
 415         case RENDERPATH_GLES1:
 416         case RENDERPATH_GLES2:
 417                 // fetch current fbo here (default fbo is not 0 on some GLES devices)
 418                 if (vid.support.ext_framebuffer_object)
 419                         qglGetIntegerv(GL_FRAMEBUFFER_BINDING, &gl_state.defaultframebufferobject);
 420                 break;
 421         case RENDERPATH_D3D9:
 422 #ifdef SUPPORTD3D
 423                 IDirect3DDevice9_GetDepthStencilSurface(vid_d3d9dev, &gl_state.d3drt_backbufferdepthsurface);
 424                 IDirect3DDevice9_GetRenderTarget(vid_d3d9dev, 0, &gl_state.d3drt_backbuffercolorsurface);
 425 #endif
 426                 break;
 427         case RENDERPATH_D3D10:
 428                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 429                 break;
 430         case RENDERPATH_D3D11:
 431                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 432                 break;
 433         case RENDERPATH_SOFT:
 434                 break;
 435         }
 436 }
 437
 438 static void gl_backend_shutdown(void)
 439 {
 440         Con_DPrint("OpenGL Backend shutting down\n");
 441
 442         switch(vid.renderpath)
 443         {
 444         case RENDERPATH_GL11:
 445         case RENDERPATH_GL13:
 446         case RENDERPATH_GL20:
 447         case RENDERPATH_SOFT:
 448         case RENDERPATH_GLES1:
 449         case RENDERPATH_GLES2:
 450                 break;
 451         case RENDERPATH_D3D9:
 452 #ifdef SUPPORTD3D
 453                 IDirect3DSurface9_Release(gl_state.d3drt_backbufferdepthsurface);
 454                 IDirect3DSurface9_Release(gl_state.d3drt_backbuffercolorsurface);
 455 #endif
 456                 break;
 457         case RENDERPATH_D3D10:
 458                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 459                 break;
 460         case RENDERPATH_D3D11:
 461                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 462                 break;
 463         }
 464
 465         if (gl_state.preparevertices_tempdata)
 466                 Mem_Free(gl_state.preparevertices_tempdata);
 467
 468         Mem_ExpandableArray_FreeArray(&gl_state.meshbufferarray);
 469
 470         R_Mesh_DestroyVertexDeclarations();
 471
 472         memset(&gl_state, 0, sizeof(gl_state));
 473 }
 474
 475 static void gl_backend_newmap(void)
 476 {
 477 }
 478
 479 static void gl_backend_devicelost(void)
 480 {
 481         int i, endindex;
 482         r_meshbuffer_t *buffer;
 483 #ifdef SUPPORTD3D
 484         gl_state.d3dvertexbuffer = NULL;
 485 #endif
 486         switch(vid.renderpath)
 487         {
 488         case RENDERPATH_GL11:
 489         case RENDERPATH_GL13:
 490         case RENDERPATH_GL20:
 491         case RENDERPATH_SOFT:
 492         case RENDERPATH_GLES1:
 493         case RENDERPATH_GLES2:
 494                 break;
 495         case RENDERPATH_D3D9:
 496 #ifdef SUPPORTD3D
 497                 IDirect3DSurface9_Release(gl_state.d3drt_backbufferdepthsurface);
 498                 IDirect3DSurface9_Release(gl_state.d3drt_backbuffercolorsurface);
 499 #endif
 500                 break;
 501         case RENDERPATH_D3D10:
 502                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 503                 break;
 504         case RENDERPATH_D3D11:
 505                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 506                 break;
 507         }
 508         endindex = (int)Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray);
 509         for (i = 0;i < endindex;i++)
 510         {
 511                 buffer = (r_meshbuffer_t *) Mem_ExpandableArray_RecordAtIndex(&gl_state.meshbufferarray, i);
 512                 if (!buffer || !buffer->isdynamic)
 513                         continue;
 514                 switch(vid.renderpath)
 515                 {
 516                 case RENDERPATH_GL11:
 517                 case RENDERPATH_GL13:
 518                 case RENDERPATH_GL20:
 519                 case RENDERPATH_SOFT:
 520                 case RENDERPATH_GLES1:
 521                 case RENDERPATH_GLES2:
 522                         break;
 523                 case RENDERPATH_D3D9:
 524 #ifdef SUPPORTD3D
 525                         if (buffer->devicebuffer)
 526                         {
 527                                 if (buffer->isindexbuffer)
 528                                         IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9*)buffer->devicebuffer);
 529                                 else
 530                                         IDirect3DVertexBuffer9_Release((IDirect3DVertexBuffer9*)buffer->devicebuffer);
 531                                 buffer->devicebuffer = NULL;
 532                         }
 533 #endif
 534                         break;
 535                 case RENDERPATH_D3D10:
 536                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 537                         break;
 538                 case RENDERPATH_D3D11:
 539                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 540                         break;
 541                 }
 542         }
 543 }
 544
 545 static void gl_backend_devicerestored(void)
 546 {
 547         switch(vid.renderpath)
 548         {
 549         case RENDERPATH_GL11:
 550         case RENDERPATH_GL13:
 551         case RENDERPATH_GL20:
 552         case RENDERPATH_SOFT:
 553         case RENDERPATH_GLES1:
 554         case RENDERPATH_GLES2:
 555                 break;
 556         case RENDERPATH_D3D9:
 557 #ifdef SUPPORTD3D
 558                 IDirect3DDevice9_GetDepthStencilSurface(vid_d3d9dev, &gl_state.d3drt_backbufferdepthsurface);
 559                 IDirect3DDevice9_GetRenderTarget(vid_d3d9dev, 0, &gl_state.d3drt_backbuffercolorsurface);
 560 #endif
 561                 break;
 562         case RENDERPATH_D3D10:
 563                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 564                 break;
 565         case RENDERPATH_D3D11:
 566                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 567                 break;
 568         }
 569 }
 570
 571 void gl_backend_init(void)
 572 {
 573         int i;
 574
 575         for (i = 0;i < POLYGONELEMENTS_MAXPOINTS - 2;i++)
 576         {
 577                 polygonelement3s[i * 3 + 0] = 0;
 578                 polygonelement3s[i * 3 + 1] = i + 1;
 579                 polygonelement3s[i * 3 + 2] = i + 2;
 580         }
 581         // elements for rendering a series of quads as triangles
 582         for (i = 0;i < QUADELEMENTS_MAXQUADS;i++)
 583         {
 584                 quadelement3s[i * 6 + 0] = i * 4;
 585                 quadelement3s[i * 6 + 1] = i * 4 + 1;
 586                 quadelement3s[i * 6 + 2] = i * 4 + 2;
 587                 quadelement3s[i * 6 + 3] = i * 4;
 588                 quadelement3s[i * 6 + 4] = i * 4 + 2;
 589                 quadelement3s[i * 6 + 5] = i * 4 + 3;
 590         }
 591
 592         for (i = 0;i < (POLYGONELEMENTS_MAXPOINTS - 2)*3;i++)
 593                 polygonelement3i[i] = polygonelement3s[i];
 594         for (i = 0;i < QUADELEMENTS_MAXQUADS*6;i++)
 595                 quadelement3i[i] = quadelement3s[i];
 596
 597         Cvar_RegisterVariable(&r_render);
 598         Cvar_RegisterVariable(&r_renderview);
 599         Cvar_RegisterVariable(&r_waterwarp);
 600         Cvar_RegisterVariable(&gl_polyblend);
 601         Cvar_RegisterVariable(&v_flipped);
 602         Cvar_RegisterVariable(&gl_dither);
 603         Cvar_RegisterVariable(&gl_vbo);
 604         Cvar_RegisterVariable(&gl_vbo_dynamicvertex);
 605         Cvar_RegisterVariable(&gl_vbo_dynamicindex);
 606         Cvar_RegisterVariable(&gl_paranoid);
 607         Cvar_RegisterVariable(&gl_printcheckerror);
 608
 609         Cvar_RegisterVariable(&gl_mesh_drawrangeelements);
 610         Cvar_RegisterVariable(&gl_mesh_testmanualfeeding);
 611
 612         Cmd_AddCommand("gl_vbostats", GL_VBOStats_f, "prints a list of all buffer objects (vertex data and triangle elements) and total video memory used by them");
 613
 614         R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap, gl_backend_devicelost, gl_backend_devicerestored);
 615 }
 616
 617 void GL_SetMirrorState(qboolean state);
 618
 619 void R_Viewport_TransformToScreen(const r_viewport_t *v, const vec4_t in, vec4_t out)
 620 {
 621         vec4_t temp;
 622         float iw;
 623         Matrix4x4_Transform4 (&v->viewmatrix, in, temp);
 624         Matrix4x4_Transform4 (&v->projectmatrix, temp, out);
 625         iw = 1.0f / out[3];
 626         out[0] = v->x + (out[0] * iw + 1.0f) * v->width * 0.5f;
 627
 628         // for an odd reason, inverting this is wrong for R_Shadow_ScissorForBBox (we then get badly scissored lights)
 629         //out[1] = v->y + v->height - (out[1] * iw + 1.0f) * v->height * 0.5f;
 630         out[1] = v->y + (out[1] * iw + 1.0f) * v->height * 0.5f;
 631
 632         out[2] = v->z + (out[2] * iw + 1.0f) * v->depth * 0.5f;
 633 }
 634
 635 void GL_Finish(void)
 636 {
 637         switch(vid.renderpath)
 638         {
 639         case RENDERPATH_GL11:
 640         case RENDERPATH_GL13:
 641         case RENDERPATH_GL20:
 642         case RENDERPATH_GLES1:
 643         case RENDERPATH_GLES2:
 644                 qglFinish();
 645                 break;
 646         case RENDERPATH_D3D9:
 647                 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 648                 break;
 649         case RENDERPATH_D3D10:
 650                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 651                 break;
 652         case RENDERPATH_D3D11:
 653                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
 654                 break;
 655         case RENDERPATH_SOFT:
 656                 DPSOFTRAST_Finish();
 657                 break;
 658         }
 659 }
 660
 661 static int bboxedges[12][2] =
 662 {
 663         // top
 664         {0, 1}, // +X
 665         {0, 2}, // +Y
 666         {1, 3}, // Y, +X
 667         {2, 3}, // X, +Y
 668         // bottom
 669         {4, 5}, // +X
 670         {4, 6}, // +Y
 671         {5, 7}, // Y, +X
 672         {6, 7}, // X, +Y
 673         // verticals
 674         {0, 4}, // +Z
 675         {1, 5}, // X, +Z
 676         {2, 6}, // Y, +Z
 677         {3, 7}, // XY, +Z
 678 };
 679
 680 qboolean R_ScissorForBBox(const float *mins, const float *maxs, int *scissor)
 681 {
 682         int i, ix1, iy1, ix2, iy2;
 683         float x1, y1, x2, y2;
 684         vec4_t v, v2;
 685         float vertex[20][3];
 686         int j, k;
 687         vec4_t plane4f;
 688         int numvertices;
 689         float corner[8][4];
 690         float dist[8];
 691         int sign[8];
 692         float f;
 693
 694         scissor[0] = r_refdef.view.viewport.x;
 695         scissor[1] = r_refdef.view.viewport.y;
 696         scissor[2] = r_refdef.view.viewport.width;
 697         scissor[3] = r_refdef.view.viewport.height;
 698
 699         // if view is inside the box, just say yes it's visible
 700         if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs))
 701                 return false;
 702
 703         // transform all corners that are infront of the nearclip plane
 704         VectorNegate(r_refdef.view.frustum[4].normal, plane4f);
 705         plane4f[3] = r_refdef.view.frustum[4].dist;
 706         numvertices = 0;
 707         for (i = 0;i < 8;i++)
 708         {
 709                 Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1);
 710                 dist[i] = DotProduct4(corner[i], plane4f);
 711                 sign[i] = dist[i] > 0;
 712                 if (!sign[i])
 713                 {
 714                         VectorCopy(corner[i], vertex[numvertices]);
 715                         numvertices++;
 716                 }
 717         }
 718         // if some points are behind the nearclip, add clipped edge points to make
 719         // sure that the scissor boundary is complete
 720         if (numvertices > 0 && numvertices < 8)
 721         {
 722                 // add clipped edge points
 723                 for (i = 0;i < 12;i++)
 724                 {
 725                         j = bboxedges[i][0];
 726                         k = bboxedges[i][1];
 727                         if (sign[j] != sign[k])
 728                         {
 729                                 f = dist[j] / (dist[j] - dist[k]);
 730                                 VectorLerp(corner[j], f, corner[k], vertex[numvertices]);
 731                                 numvertices++;
 732                         }
 733                 }
 734         }
 735
 736         // if we have no points to check, it is behind the view plane
 737         if (!numvertices)
 738                 return true;
 739
 740         // if we have some points to transform, check what screen area is covered
 741         x1 = y1 = x2 = y2 = 0;
 742         v[3] = 1.0f;
 743         //Con_Printf("%i vertices to transform...\n", numvertices);
 744         for (i = 0;i < numvertices;i++)
 745         {
 746                 VectorCopy(vertex[i], v);
 747                 R_Viewport_TransformToScreen(&r_refdef.view.viewport, v, v2);
 748                 //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]);
 749                 if (i)
 750                 {
 751                         if (x1 > v2[0]) x1 = v2[0];
 752                         if (x2 < v2[0]) x2 = v2[0];
 753                         if (y1 > v2[1]) y1 = v2[1];
 754                         if (y2 < v2[1]) y2 = v2[1];
 755                 }
 756                 else
 757                 {
 758                         x1 = x2 = v2[0];
 759                         y1 = y2 = v2[1];
 760                 }
 761         }
 762
 763         // now convert the scissor rectangle to integer screen coordinates
 764         ix1 = (int)(x1 - 1.0f);
 765         //iy1 = vid.height - (int)(y2 - 1.0f);
 766         //iy1 = r_refdef.view.viewport.width + 2 * r_refdef.view.viewport.x - (int)(y2 - 1.0f);
 767         iy1 = (int)(y1 - 1.0f);
 768         ix2 = (int)(x2 + 1.0f);
 769         //iy2 = vid.height - (int)(y1 + 1.0f);
 770         //iy2 = r_refdef.view.viewport.height + 2 * r_refdef.view.viewport.y - (int)(y1 + 1.0f);
 771         iy2 = (int)(y2 + 1.0f);
 772         //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
 773
 774         // clamp it to the screen
 775         if (ix1 < r_refdef.view.viewport.x) ix1 = r_refdef.view.viewport.x;
 776         if (iy1 < r_refdef.view.viewport.y) iy1 = r_refdef.view.viewport.y;
 777         if (ix2 > r_refdef.view.viewport.x + r_refdef.view.viewport.width) ix2 = r_refdef.view.viewport.x + r_refdef.view.viewport.width;
 778         if (iy2 > r_refdef.view.viewport.y + r_refdef.view.viewport.height) iy2 = r_refdef.view.viewport.y + r_refdef.view.viewport.height;
 779
 780         // if it is inside out, it's not visible
 781         if (ix2 <= ix1 || iy2 <= iy1)
 782                 return true;
 783
 784         // the light area is visible, set up the scissor rectangle
 785         scissor[0] = ix1;
 786         scissor[1] = iy1;
 787         scissor[2] = ix2 - ix1;
 788         scissor[3] = iy2 - iy1;
 789
 790         // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one
 791         switch(vid.renderpath)
 792         {
 793         case RENDERPATH_D3D9:
 794         case RENDERPATH_D3D10:
 795         case RENDERPATH_D3D11:
 796                 scissor[1] = vid.height - scissor[1] - scissor[3];
 797                 break;
 798         case RENDERPATH_GL11:
 799         case RENDERPATH_GL13:
 800         case RENDERPATH_GL20:
 801         case RENDERPATH_SOFT:
 802         case RENDERPATH_GLES1:
 803         case RENDERPATH_GLES2:
 804                 break;
 805         }
 806
 807         return false;
 808 }
 809
 810
 811 static void R_Viewport_ApplyNearClipPlaneFloatGL(const r_viewport_t *v, float *m, float normalx, float normaly, float normalz, float dist)
 812 {
 813         float q[4];
 814         float d;
 815         float clipPlane[4], v3[3], v4[3];
 816         float normal[3];
 817
 818         // This is inspired by Oblique Depth Projection from http://www.terathon.com/code/oblique.php
 819
 820         VectorSet(normal, normalx, normaly, normalz);
 821         Matrix4x4_Transform3x3(&v->viewmatrix, normal, clipPlane);
 822         VectorScale(normal, -dist, v3);
 823         Matrix4x4_Transform(&v->viewmatrix, v3, v4);
 824         // FIXME: LordHavoc: I think this can be done more efficiently somehow but I can't remember the technique
 825         clipPlane[3] = -DotProduct(v4, clipPlane);
 826
 827 #if 0
 828 {
 829         // testing code for comparing results
 830         float clipPlane2[4];
 831         VectorCopy4(clipPlane, clipPlane2);
 832         R_EntityMatrix(&identitymatrix);
 833         VectorSet(q, normal[0], normal[1], normal[2], -dist);
 834         qglClipPlane(GL_CLIP_PLANE0, q);
 835         qglGetClipPlane(GL_CLIP_PLANE0, q);
 836         VectorCopy4(q, clipPlane);
 837 }
 838 #endif
 839
 840         // Calculate the clip-space corner point opposite the clipping plane
 841         // as (sgn(clipPlane.x), sgn(clipPlane.y), 1, 1) and
 842         // transform it into camera space by multiplying it
 843         // by the inverse of the projection matrix
 844         q[0] = ((clipPlane[0] < 0.0f ? -1.0f : clipPlane[0] > 0.0f ? 1.0f : 0.0f) + m[8]) / m[0];
 845         q[1] = ((clipPlane[1] < 0.0f ? -1.0f : clipPlane[1] > 0.0f ? 1.0f : 0.0f) + m[9]) / m[5];
 846         q[2] = -1.0f;
 847         q[3] = (1.0f + m[10]) / m[14];
 848
 849         // Calculate the scaled plane vector
 850         d = 2.0f / DotProduct4(clipPlane, q);
 851
 852         // Replace the third row of the projection matrix
 853         m[2] = clipPlane[0] * d;
 854         m[6] = clipPlane[1] * d;
 855         m[10] = clipPlane[2] * d + 1.0f;
 856         m[14] = clipPlane[3] * d;
 857 }
 858
 859 void R_Viewport_InitOrtho(r_viewport_t *v, const matrix4x4_t *cameramatrix, int x, int y, int width, int height, float x1, float y1, float x2, float y2, float nearclip, float farclip, const float *nearplane)
 860 {
 861         float left = x1, right = x2, bottom = y2, top = y1, zNear = nearclip, zFar = farclip;
 862         float m[16];
 863         memset(v, 0, sizeof(*v));
 864         v->type = R_VIEWPORTTYPE_ORTHO;
 865         v->cameramatrix = *cameramatrix;
 866         v->x = x;
 867         v->y = y;
 868         v->z = 0;
 869         v->width = width;
 870         v->height = height;
 871         v->depth = 1;
 872         memset(m, 0, sizeof(m));
 873         m[0]  = 2/(right - left);
 874         m[5]  = 2/(top - bottom);
 875         m[10] = -2/(zFar - zNear);
 876         m[12] = - (right + left)/(right - left);
 877         m[13] = - (top + bottom)/(top - bottom);
 878         m[14] = - (zFar + zNear)/(zFar - zNear);
 879         m[15] = 1;
 880         switch(vid.renderpath)
 881         {
 882         case RENDERPATH_GL11:
 883         case RENDERPATH_GL13:
 884         case RENDERPATH_GL20:
 885         case RENDERPATH_SOFT:
 886         case RENDERPATH_GLES1:
 887         case RENDERPATH_GLES2:
 888                 break;
 889         case RENDERPATH_D3D9:
 890         case RENDERPATH_D3D10:
 891         case RENDERPATH_D3D11:
 892                 m[10] = -1/(zFar - zNear);
 893                 m[14] = -zNear/(zFar-zNear);
 894                 break;
 895         }
 896         v->screentodepth[0] = -farclip / (farclip - nearclip);
 897         v->screentodepth[1] = farclip * nearclip / (farclip - nearclip);
 898
 899         Matrix4x4_Invert_Full(&v->viewmatrix, &v->cameramatrix);
 900
 901         if (nearplane)
 902                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 903
 904         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 905
 906 #if 0
 907         {
 908                 vec4_t test1;
 909                 vec4_t test2;
 910                 Vector4Set(test1, (x1+x2)*0.5f, (y1+y2)*0.5f, 0.0f, 1.0f);
 911                 R_Viewport_TransformToScreen(v, test1, test2);
 912                 Con_Printf("%f %f %f -> %f %f %f\n", test1[0], test1[1], test1[2], test2[0], test2[1], test2[2]);
 913         }
 914 #endif
 915 }
 916
 917 void R_Viewport_InitOrtho3D(r_viewport_t *v, const matrix4x4_t *cameramatrix, int x, int y, int width, int height, float frustumx, float frustumy, float nearclip, float farclip, const float *nearplane)
 918 {
 919         matrix4x4_t tempmatrix, basematrix;
 920         float m[16];
 921         memset(v, 0, sizeof(*v));
 922
 923         v->type = R_VIEWPORTTYPE_PERSPECTIVE;
 924         v->cameramatrix = *cameramatrix;
 925         v->x = x;
 926         v->y = y;
 927         v->z = 0;
 928         v->width = width;
 929         v->height = height;
 930         v->depth = 1;
 931         memset(m, 0, sizeof(m));
 932         m[0]  = 1.0 / frustumx;
 933         m[5]  = 1.0 / frustumy;
 934         m[10] = -2 / (farclip - nearclip);
 935         m[14] = -(farclip + nearclip) / (farclip - nearclip);
 936         m[15] = 1;
 937         v->screentodepth[0] = -farclip / (farclip - nearclip);
 938         v->screentodepth[1] = farclip * nearclip / (farclip - nearclip);
 939
 940         Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix);
 941         Matrix4x4_CreateRotate(&basematrix, -90, 1, 0, 0);
 942         Matrix4x4_ConcatRotate(&basematrix, 90, 0, 0, 1);
 943         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
 944
 945         if (nearplane)
 946                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 947
 948         if(v_flipped.integer)
 949         {
 950                 m[0] = -m[0];
 951                 m[4] = -m[4];
 952                 m[8] = -m[8];
 953                 m[12] = -m[12];
 954         }
 955
 956         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 957 }
 958
 959 void R_Viewport_InitPerspective(r_viewport_t *v, const matrix4x4_t *cameramatrix, int x, int y, int width, int height, float frustumx, float frustumy, float nearclip, float farclip, const float *nearplane)
 960 {
 961         matrix4x4_t tempmatrix, basematrix;
 962         float m[16];
 963         memset(v, 0, sizeof(*v));
 964
 965         v->type = R_VIEWPORTTYPE_PERSPECTIVE;
 966         v->cameramatrix = *cameramatrix;
 967         v->x = x;
 968         v->y = y;
 969         v->z = 0;
 970         v->width = width;
 971         v->height = height;
 972         v->depth = 1;
 973         memset(m, 0, sizeof(m));
 974         m[0]  = 1.0 / frustumx;
 975         m[5]  = 1.0 / frustumy;
 976         m[10] = -(farclip + nearclip) / (farclip - nearclip);
 977         m[11] = -1;
 978         m[14] = -2 * nearclip * farclip / (farclip - nearclip);
 979         v->screentodepth[0] = -farclip / (farclip - nearclip);
 980         v->screentodepth[1] = farclip * nearclip / (farclip - nearclip);
 981
 982         Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix);
 983         Matrix4x4_CreateRotate(&basematrix, -90, 1, 0, 0);
 984         Matrix4x4_ConcatRotate(&basematrix, 90, 0, 0, 1);
 985         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
 986
 987         if (nearplane)
 988                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 989
 990         if(v_flipped.integer)
 991         {
 992                 m[0] = -m[0];
 993                 m[4] = -m[4];
 994                 m[8] = -m[8];
 995                 m[12] = -m[12];
 996         }
 997
 998         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 999 }
1000
1001 void R_Viewport_InitPerspectiveInfinite(r_viewport_t *v, const matrix4x4_t *cameramatrix, int x, int y, int width, int height, float frustumx, float frustumy, float nearclip, const float *nearplane)
1002 {
1003         matrix4x4_t tempmatrix, basematrix;
1004         const float nudge = 1.0 - 1.0 / (1<<23);
1005         float m[16];
1006         memset(v, 0, sizeof(*v));
1007
1008         v->type = R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP;
1009         v->cameramatrix = *cameramatrix;
1010         v->x = x;
1011         v->y = y;
1012         v->z = 0;
1013         v->width = width;
1014         v->height = height;
1015         v->depth = 1;
1016         memset(m, 0, sizeof(m));
1017         m[ 0] = 1.0 / frustumx;
1018         m[ 5] = 1.0 / frustumy;
1019         m[10] = -nudge;
1020         m[11] = -1;
1021         m[14] = -2 * nearclip * nudge;
1022         v->screentodepth[0] = (m[10] + 1) * 0.5 - 1;
1023         v->screentodepth[1] = m[14] * -0.5;
1024
1025         Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix);
1026         Matrix4x4_CreateRotate(&basematrix, -90, 1, 0, 0);
1027         Matrix4x4_ConcatRotate(&basematrix, 90, 0, 0, 1);
1028         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
1029
1030         if (nearplane)
1031                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
1032
1033         if(v_flipped.integer)
1034         {
1035                 m[0] = -m[0];
1036                 m[4] = -m[4];
1037                 m[8] = -m[8];
1038                 m[12] = -m[12];
1039         }
1040
1041         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
1042 }
1043
1044 float cubeviewmatrix[6][16] =
1045 {
1046     // standard cubemap projections
1047     { // +X
1048          0, 0,-1, 0,
1049          0,-1, 0, 0,
1050         -1, 0, 0, 0,
1051          0, 0, 0, 1,
1052     },
1053     { // -X
1054          0, 0, 1, 0,
1055          0,-1, 0, 0,
1056          1, 0, 0, 0,
1057          0, 0, 0, 1,
1058     },
1059     { // +Y
1060          1, 0, 0, 0,
1061          0, 0,-1, 0,
1062          0, 1, 0, 0,
1063          0, 0, 0, 1,
1064     },
1065     { // -Y
1066          1, 0, 0, 0,
1067          0, 0, 1, 0,
1068          0,-1, 0, 0,
1069          0, 0, 0, 1,
1070     },
1071     { // +Z
1072          1, 0, 0, 0,
1073          0,-1, 0, 0,
1074          0, 0,-1, 0,
1075          0, 0, 0, 1,
1076     },
1077     { // -Z
1078         -1, 0, 0, 0,
1079          0,-1, 0, 0,
1080          0, 0, 1, 0,
1081          0, 0, 0, 1,
1082     },
1083 };
1084 float rectviewmatrix[6][16] =
1085 {
1086     // sign-preserving cubemap projections
1087     { // +X
1088          0, 0,-1, 0,
1089          0, 1, 0, 0,
1090          1, 0, 0, 0,
1091          0, 0, 0, 1,
1092     },
1093     { // -X
1094          0, 0, 1, 0,
1095          0, 1, 0, 0,
1096          1, 0, 0, 0,
1097          0, 0, 0, 1,
1098     },
1099     { // +Y
1100          1, 0, 0, 0,
1101          0, 0,-1, 0,
1102          0, 1, 0, 0,
1103          0, 0, 0, 1,
1104     },
1105     { // -Y
1106          1, 0, 0, 0,
1107          0, 0, 1, 0,
1108          0, 1, 0, 0,
1109          0, 0, 0, 1,
1110     },
1111     { // +Z
1112          1, 0, 0, 0,
1113          0, 1, 0, 0,
1114          0, 0,-1, 0,
1115          0, 0, 0, 1,
1116     },
1117     { // -Z
1118          1, 0, 0, 0,
1119          0, 1, 0, 0,
1120          0, 0, 1, 0,
1121          0, 0, 0, 1,
1122     },
1123 };
1124
1125 void R_Viewport_InitCubeSideView(r_viewport_t *v, const matrix4x4_t *cameramatrix, int side, int size, float nearclip, float farclip, const float *nearplane)
1126 {
1127         matrix4x4_t tempmatrix, basematrix;
1128         float m[16];
1129         memset(v, 0, sizeof(*v));
1130         v->type = R_VIEWPORTTYPE_PERSPECTIVECUBESIDE;
1131         v->cameramatrix = *cameramatrix;
1132         v->width = size;
1133         v->height = size;
1134         v->depth = 1;
1135         memset(m, 0, sizeof(m));
1136         m[0] = m[5] = 1.0f;
1137         m[10] = -(farclip + nearclip) / (farclip - nearclip);
1138         m[11] = -1;
1139         m[14] = -2 * nearclip * farclip / (farclip - nearclip);
1140
1141         Matrix4x4_FromArrayFloatGL(&basematrix, cubeviewmatrix[side]);
1142         Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix);
1143         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
1144
1145         if (nearplane)
1146                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
1147
1148         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
1149 }
1150
1151 void R_Viewport_InitRectSideView(r_viewport_t *v, const matrix4x4_t *cameramatrix, int side, int size, int border, float nearclip, float farclip, const float *nearplane, int offsetx, int offsety)
1152 {
1153         matrix4x4_t tempmatrix, basematrix;
1154         float m[16];
1155         memset(v, 0, sizeof(*v));
1156         v->type = R_VIEWPORTTYPE_PERSPECTIVECUBESIDE;
1157         v->cameramatrix = *cameramatrix;
1158         v->x = offsetx + (side & 1) * size;
1159         v->y = offsety + (side >> 1) * size;
1160         v->width = size;
1161         v->height = size;
1162         v->depth = 1;
1163         memset(m, 0, sizeof(m));
1164         m[0] = m[5] = 1.0f * ((float)size - border) / size;
1165         m[10] = -(farclip + nearclip) / (farclip - nearclip);
1166         m[11] = -1;
1167         m[14] = -2 * nearclip * farclip / (farclip - nearclip);
1168
1169         Matrix4x4_FromArrayFloatGL(&basematrix, rectviewmatrix[side]);
1170         Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix);
1171         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
1172
1173         switch(vid.renderpath)
1174         {
1175         case RENDERPATH_GL20:
1176         case RENDERPATH_GL13:
1177         case RENDERPATH_GL11:
1178         case RENDERPATH_SOFT:
1179         case RENDERPATH_GLES1:
1180         case RENDERPATH_GLES2:
1181                 break;
1182         case RENDERPATH_D3D9:
1183                 m[5] *= -1;
1184                 break;
1185         case RENDERPATH_D3D10:
1186                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1187                 break;
1188         case RENDERPATH_D3D11:
1189                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1190                 break;
1191         }
1192
1193         if (nearplane)
1194                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
1195
1196         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
1197 }
1198
1199 void R_SetViewport(const r_viewport_t *v)
1200 {
1201         gl_viewport = *v;
1202
1203         // FIXME: v_flipped_state is evil, this probably breaks somewhere
1204         GL_SetMirrorState(v_flipped.integer && (v->type == R_VIEWPORTTYPE_PERSPECTIVE || v->type == R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP));
1205
1206         // copy over the matrices to our state
1207         gl_viewmatrix = v->viewmatrix;
1208         gl_projectionmatrix = v->projectmatrix;
1209
1210         switch(vid.renderpath)
1211         {
1212         case RENDERPATH_GL13:
1213         case RENDERPATH_GL11:
1214         case RENDERPATH_GLES1:
1215 #ifndef USE_GLES2
1216                 {
1217                         float m[16];
1218                         CHECKGLERROR
1219                         qglViewport(v->x, v->y, v->width, v->height);CHECKGLERROR
1220                         // Load the projection matrix into OpenGL
1221                         qglMatrixMode(GL_PROJECTION);CHECKGLERROR
1222                         Matrix4x4_ToArrayFloatGL(&gl_projectionmatrix, m);
1223                         qglLoadMatrixf(m);CHECKGLERROR
1224                         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
1225                 }
1226 #endif
1227                 break;
1228         case RENDERPATH_D3D9:
1229 #ifdef SUPPORTD3D
1230                 {
1231                         D3DVIEWPORT9 d3dviewport;
1232                         d3dviewport.X = gl_viewport.x;
1233                         d3dviewport.Y = gl_viewport.y;
1234                         d3dviewport.Width = gl_viewport.width;
1235                         d3dviewport.Height = gl_viewport.height;
1236                         d3dviewport.MinZ = gl_state.depthrange[0];
1237                         d3dviewport.MaxZ = gl_state.depthrange[1];
1238                         IDirect3DDevice9_SetViewport(vid_d3d9dev, &d3dviewport);
1239                 }
1240 #endif
1241                 break;
1242         case RENDERPATH_D3D10:
1243                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1244                 break;
1245         case RENDERPATH_D3D11:
1246                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1247                 break;
1248         case RENDERPATH_SOFT:
1249                 DPSOFTRAST_Viewport(v->x, v->y, v->width, v->height);
1250                 break;
1251         case RENDERPATH_GL20:
1252         case RENDERPATH_GLES2:
1253                 CHECKGLERROR
1254                 qglViewport(v->x, v->y, v->width, v->height);CHECKGLERROR
1255                 break;
1256         }
1257
1258         // force an update of the derived matrices
1259         gl_modelmatrixchanged = true;
1260         R_EntityMatrix(&gl_modelmatrix);
1261 }
1262
1263 void R_GetViewport(r_viewport_t *v)
1264 {
1265         *v = gl_viewport;
1266 }
1267
1268 static void GL_BindVBO(int bufferobject)
1269 {
1270         if (gl_state.vertexbufferobject != bufferobject)
1271         {
1272                 gl_state.vertexbufferobject = bufferobject;
1273                 CHECKGLERROR
1274                 qglBindBufferARB(GL_ARRAY_BUFFER, bufferobject);CHECKGLERROR
1275         }
1276 }
1277
1278 static void GL_BindEBO(int bufferobject)
1279 {
1280         if (gl_state.elementbufferobject != bufferobject)
1281         {
1282                 gl_state.elementbufferobject = bufferobject;
1283                 CHECKGLERROR
1284                 qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, bufferobject);CHECKGLERROR
1285         }
1286 }
1287
1288 static void GL_BindUBO(int bufferobject)
1289 {
1290         if (gl_state.uniformbufferobject != bufferobject)
1291         {
1292                 gl_state.uniformbufferobject = bufferobject;
1293 #ifdef GL_UNIFORM_BUFFER
1294                 CHECKGLERROR
1295                 qglBindBufferARB(GL_UNIFORM_BUFFER, bufferobject);CHECKGLERROR
1296 #endif
1297         }
1298 }
1299
1300 static const GLuint drawbuffers[4] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3};
1301 int R_Mesh_CreateFramebufferObject(rtexture_t *depthtexture, rtexture_t *colortexture, rtexture_t *colortexture2, rtexture_t *colortexture3, rtexture_t *colortexture4)
1302 {
1303         switch(vid.renderpath)
1304         {
1305         case RENDERPATH_GL11:
1306         case RENDERPATH_GL13:
1307         case RENDERPATH_GL20:
1308         case RENDERPATH_GLES1:
1309         case RENDERPATH_GLES2:
1310                 if (vid.support.arb_framebuffer_object)
1311                 {
1312                         int temp;
1313                         GLuint status;
1314                         qglGenFramebuffers(1, (GLuint*)&temp);CHECKGLERROR
1315                         R_Mesh_SetRenderTargets(temp, NULL, NULL, NULL, NULL, NULL);
1316                         // GL_ARB_framebuffer_object (GL3-class hardware) - depth stencil attachment
1317 #ifdef USE_GLES2
1318                         // FIXME: separate stencil attachment on GLES
1319                         if (depthtexture  && depthtexture->texnum ) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR
1320                         if (depthtexture  && depthtexture->renderbuffernum ) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR
1321 #else
1322                         if (depthtexture  && depthtexture->texnum )
1323                         {
1324                                 qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR
1325                                 if (depthtexture->glisdepthstencil) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT  , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR
1326                         }
1327                         if (depthtexture  && depthtexture->renderbuffernum )
1328                         {
1329                                 qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR
1330                                 if (depthtexture->glisdepthstencil) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT  , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR
1331                         }
1332 #endif
1333                         if (colortexture  && colortexture->texnum ) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , colortexture->gltexturetypeenum , colortexture->texnum , 0);CHECKGLERROR
1334                         if (colortexture2 && colortexture2->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , colortexture2->gltexturetypeenum, colortexture2->texnum, 0);CHECKGLERROR
1335                         if (colortexture3 && colortexture3->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , colortexture3->gltexturetypeenum, colortexture3->texnum, 0);CHECKGLERROR
1336                         if (colortexture4 && colortexture4->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , colortexture4->gltexturetypeenum, colortexture4->texnum, 0);CHECKGLERROR
1337                         if (colortexture  && colortexture->renderbuffernum ) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_RENDERBUFFER, colortexture->renderbuffernum );CHECKGLERROR
1338                         if (colortexture2 && colortexture2->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , GL_RENDERBUFFER, colortexture2->renderbuffernum);CHECKGLERROR
1339                         if (colortexture3 && colortexture3->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , GL_RENDERBUFFER, colortexture3->renderbuffernum);CHECKGLERROR
1340                         if (colortexture4 && colortexture4->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , GL_RENDERBUFFER, colortexture4->renderbuffernum);CHECKGLERROR
1341
1342 #ifndef USE_GLES2
1343                         if (colortexture4 && qglDrawBuffersARB)
1344                         {
1345                                 qglDrawBuffersARB(4, drawbuffers);CHECKGLERROR
1346                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1347                         }
1348                         else if (colortexture3 && qglDrawBuffersARB)
1349                         {
1350                                 qglDrawBuffersARB(3, drawbuffers);CHECKGLERROR
1351                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1352                         }
1353                         else if (colortexture2 && qglDrawBuffersARB)
1354                         {
1355                                 qglDrawBuffersARB(2, drawbuffers);CHECKGLERROR
1356                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1357                         }
1358                         else if (colortexture && qglDrawBuffer)
1359                         {
1360                                 qglDrawBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR
1361                                 qglReadBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR
1362                         }
1363                         else if (qglDrawBuffer)
1364                         {
1365                                 qglDrawBuffer(GL_NONE);CHECKGLERROR
1366                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1367                         }
1368 #endif
1369                         status = qglCheckFramebufferStatus(GL_FRAMEBUFFER);CHECKGLERROR
1370                         if (status != GL_FRAMEBUFFER_COMPLETE)
1371                         {
1372                                 Con_Printf("R_Mesh_CreateFramebufferObject: glCheckFramebufferStatus returned %i\n", status);
1373                                 gl_state.framebufferobject = 0; // GL unbinds it for us
1374                                 qglDeleteFramebuffers(1, (GLuint*)&temp);
1375                                 temp = 0;
1376                         }
1377                         return temp;
1378                 }
1379                 else if (vid.support.ext_framebuffer_object)
1380                 {
1381                         int temp;
1382                         GLuint status;
1383                         qglGenFramebuffers(1, (GLuint*)&temp);CHECKGLERROR
1384                         R_Mesh_SetRenderTargets(temp, NULL, NULL, NULL, NULL, NULL);
1385                         // GL_EXT_framebuffer_object (GL2-class hardware) - no depth stencil attachment, let it break stencil
1386                         if (depthtexture  && depthtexture->texnum ) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR
1387                         if (depthtexture  && depthtexture->renderbuffernum ) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR
1388                         if (colortexture  && colortexture->texnum ) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , colortexture->gltexturetypeenum , colortexture->texnum , 0);CHECKGLERROR
1389                         if (colortexture2 && colortexture2->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , colortexture2->gltexturetypeenum, colortexture2->texnum, 0);CHECKGLERROR
1390                         if (colortexture3 && colortexture3->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , colortexture3->gltexturetypeenum, colortexture3->texnum, 0);CHECKGLERROR
1391                         if (colortexture4 && colortexture4->texnum) qglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , colortexture4->gltexturetypeenum, colortexture4->texnum, 0);CHECKGLERROR
1392                         if (colortexture  && colortexture->renderbuffernum ) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_RENDERBUFFER, colortexture->renderbuffernum );CHECKGLERROR
1393                         if (colortexture2 && colortexture2->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , GL_RENDERBUFFER, colortexture2->renderbuffernum);CHECKGLERROR
1394                         if (colortexture3 && colortexture3->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , GL_RENDERBUFFER, colortexture3->renderbuffernum);CHECKGLERROR
1395                         if (colortexture4 && colortexture4->renderbuffernum) qglFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , GL_RENDERBUFFER, colortexture4->renderbuffernum);CHECKGLERROR
1396
1397 #ifndef USE_GLES2
1398                         if (colortexture4 && qglDrawBuffersARB)
1399                         {
1400                                 qglDrawBuffersARB(4, drawbuffers);CHECKGLERROR
1401                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1402                         }
1403                         else if (colortexture3 && qglDrawBuffersARB)
1404                         {
1405                                 qglDrawBuffersARB(3, drawbuffers);CHECKGLERROR
1406                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1407                         }
1408                         else if (colortexture2 && qglDrawBuffersARB)
1409                         {
1410                                 qglDrawBuffersARB(2, drawbuffers);CHECKGLERROR
1411                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1412                         }
1413                         else if (colortexture && qglDrawBuffer)
1414                         {
1415                                 qglDrawBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR
1416                                 qglReadBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR
1417                         }
1418                         else if (qglDrawBuffer)
1419                         {
1420                                 qglDrawBuffer(GL_NONE);CHECKGLERROR
1421                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1422                         }
1423 #endif
1424                         status = qglCheckFramebufferStatus(GL_FRAMEBUFFER);CHECKGLERROR
1425                         if (status != GL_FRAMEBUFFER_COMPLETE)
1426                         {
1427                                 Con_Printf("R_Mesh_CreateFramebufferObject: glCheckFramebufferStatus returned %i\n", status);
1428                                 gl_state.framebufferobject = 0; // GL unbinds it for us
1429                                 qglDeleteFramebuffers(1, (GLuint*)&temp);
1430                                 temp = 0;
1431                         }
1432                         return temp;
1433                 }
1434                 return 0;
1435         case RENDERPATH_D3D9:
1436         case RENDERPATH_D3D10:
1437         case RENDERPATH_D3D11:
1438                 return 1;
1439         case RENDERPATH_SOFT:
1440                 return 1;
1441         }
1442         return 0;
1443 }
1444
1445 void R_Mesh_DestroyFramebufferObject(int fbo)
1446 {
1447         switch(vid.renderpath)
1448         {
1449         case RENDERPATH_GL11:
1450         case RENDERPATH_GL13:
1451         case RENDERPATH_GL20:
1452         case RENDERPATH_GLES1:
1453         case RENDERPATH_GLES2:
1454                 if (fbo)
1455                 {
1456                         // GL clears the binding if we delete something bound
1457                         if (gl_state.framebufferobject == fbo)
1458                                 gl_state.framebufferobject = 0;
1459                         qglDeleteFramebuffers(1, (GLuint*)&fbo);
1460                 }
1461                 break;
1462         case RENDERPATH_D3D9:
1463         case RENDERPATH_D3D10:
1464         case RENDERPATH_D3D11:
1465                 break;
1466         case RENDERPATH_SOFT:
1467                 break;
1468         }
1469 }
1470
1471 #ifdef SUPPORTD3D
1472 void R_Mesh_SetRenderTargetsD3D9(IDirect3DSurface9 *depthsurface, IDirect3DSurface9 *colorsurface0, IDirect3DSurface9 *colorsurface1, IDirect3DSurface9 *colorsurface2, IDirect3DSurface9 *colorsurface3)
1473 {
1474         gl_state.framebufferobject = depthsurface != gl_state.d3drt_backbufferdepthsurface || colorsurface0 != gl_state.d3drt_backbuffercolorsurface;
1475         if (gl_state.d3drt_depthsurface != depthsurface)
1476         {
1477                 gl_state.d3drt_depthsurface = depthsurface;
1478                 IDirect3DDevice9_SetDepthStencilSurface(vid_d3d9dev, gl_state.d3drt_depthsurface);
1479         }
1480         if (gl_state.d3drt_colorsurfaces[0] != colorsurface0)
1481         {
1482                 gl_state.d3drt_colorsurfaces[0] = colorsurface0;
1483                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 0, gl_state.d3drt_colorsurfaces[0]);
1484         }
1485         if (gl_state.d3drt_colorsurfaces[1] != colorsurface1)
1486         {
1487                 gl_state.d3drt_colorsurfaces[1] = colorsurface1;
1488                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 1, gl_state.d3drt_colorsurfaces[1]);
1489         }
1490         if (gl_state.d3drt_colorsurfaces[2] != colorsurface2)
1491         {
1492                 gl_state.d3drt_colorsurfaces[2] = colorsurface2;
1493                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 2, gl_state.d3drt_colorsurfaces[2]);
1494         }
1495         if (gl_state.d3drt_colorsurfaces[3] != colorsurface3)
1496         {
1497                 gl_state.d3drt_colorsurfaces[3] = colorsurface3;
1498                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 3, gl_state.d3drt_colorsurfaces[3]);
1499         }
1500 }
1501 #endif
1502
1503 void R_Mesh_SetRenderTargets(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, rtexture_t *colortexture2, rtexture_t *colortexture3, rtexture_t *colortexture4)
1504 {
1505         unsigned int i;
1506         unsigned int j;
1507         rtexture_t *textures[5];
1508         Vector4Set(textures, colortexture, colortexture2, colortexture3, colortexture4);
1509         textures[4] = depthtexture;
1510         // unbind any matching textures immediately, otherwise D3D will complain about a bound texture being used as a render target
1511         for (j = 0;j < 5;j++)
1512                 if (textures[j])
1513                         for (i = 0;i < vid.teximageunits;i++)
1514                                 if (gl_state.units[i].texture == textures[j])
1515                                         R_Mesh_TexBind(i, NULL);
1516         // set up framebuffer object or render targets for the active rendering API
1517         switch(vid.renderpath)
1518         {
1519         case RENDERPATH_GL11:
1520         case RENDERPATH_GL13:
1521         case RENDERPATH_GL20:
1522         case RENDERPATH_GLES1:
1523         case RENDERPATH_GLES2:
1524                 if (gl_state.framebufferobject != fbo)
1525                 {
1526                         gl_state.framebufferobject = fbo;
1527                         qglBindFramebuffer(GL_FRAMEBUFFER, gl_state.framebufferobject ? gl_state.framebufferobject : gl_state.defaultframebufferobject);
1528                 }
1529                 break;
1530         case RENDERPATH_D3D9:
1531 #ifdef SUPPORTD3D
1532                 // set up the new render targets, a NULL depthtexture intentionally binds nothing
1533                 // TODO: optimize: keep surface pointer around in rtexture_t until texture is freed or lost
1534                 if (fbo)
1535                 {
1536                         IDirect3DSurface9 *surfaces[5];
1537                         for (i = 0;i < 5;i++)
1538                         {
1539                                 surfaces[i] = NULL;
1540                                 if (textures[i])
1541                                 {
1542                                         if (textures[i]->d3dsurface)
1543                                                 surfaces[i] = (IDirect3DSurface9 *)textures[i]->d3dsurface;
1544                                         else
1545                                                 IDirect3DTexture9_GetSurfaceLevel((IDirect3DTexture9 *)textures[i]->d3dtexture, 0, &surfaces[i]);
1546                                 }
1547                         }
1548                         // set the render targets for real
1549                         R_Mesh_SetRenderTargetsD3D9(surfaces[4], surfaces[0], surfaces[1], surfaces[2], surfaces[3]);
1550                         // release the texture surface levels (they won't be lost while bound...)
1551                         for (i = 0;i < 5;i++)
1552                                 if (textures[i] && !textures[i]->d3dsurface)
1553                                         IDirect3DSurface9_Release(surfaces[i]);
1554                 }
1555                 else
1556                         R_Mesh_SetRenderTargetsD3D9(gl_state.d3drt_backbufferdepthsurface, gl_state.d3drt_backbuffercolorsurface, NULL, NULL, NULL);
1557 #endif
1558                 break;
1559         case RENDERPATH_D3D10:
1560                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1561                 break;
1562         case RENDERPATH_D3D11:
1563                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1564                 break;
1565         case RENDERPATH_SOFT:
1566                 if (fbo)
1567                 {
1568                         int width, height;
1569                         unsigned int *pointers[5];
1570                         memset(pointers, 0, sizeof(pointers));
1571                         for (i = 0;i < 5;i++)
1572                                 pointers[i] = textures[i] ? (unsigned int *)DPSOFTRAST_Texture_GetPixelPointer(textures[i]->texnum, 0) : NULL;
1573                         width = DPSOFTRAST_Texture_GetWidth(textures[0] ? textures[0]->texnum : textures[4]->texnum, 0);
1574                         height = DPSOFTRAST_Texture_GetHeight(textures[0] ? textures[0]->texnum : textures[4]->texnum, 0);
1575                         DPSOFTRAST_SetRenderTargets(width, height, pointers[4], pointers[0], pointers[1], pointers[2], pointers[3]);
1576                 }
1577                 else
1578                         DPSOFTRAST_SetRenderTargets(vid.width, vid.height, vid.softdepthpixels, vid.softpixels, NULL, NULL, NULL);
1579                 break;
1580         }
1581 }
1582
1583 #ifdef SUPPORTD3D
1584 static int d3dcmpforglfunc(int f)
1585 {
1586         switch(f)
1587         {
1588         case GL_NEVER: return D3DCMP_NEVER;
1589         case GL_LESS: return D3DCMP_LESS;
1590         case GL_EQUAL: return D3DCMP_EQUAL;
1591         case GL_LEQUAL: return D3DCMP_LESSEQUAL;
1592         case GL_GREATER: return D3DCMP_GREATER;
1593         case GL_NOTEQUAL: return D3DCMP_NOTEQUAL;
1594         case GL_GEQUAL: return D3DCMP_GREATEREQUAL;
1595         case GL_ALWAYS: return D3DCMP_ALWAYS;
1596         default: Con_DPrintf("Unknown GL_DepthFunc\n");return D3DCMP_ALWAYS;
1597         }
1598 }
1599
1600 static int d3dstencilopforglfunc(int f)
1601 {
1602         switch(f)
1603         {
1604         case GL_KEEP: return D3DSTENCILOP_KEEP;
1605         case GL_INCR: return D3DSTENCILOP_INCR; // note: GL_INCR is clamped, D3DSTENCILOP_INCR wraps
1606         case GL_DECR: return D3DSTENCILOP_DECR; // note: GL_DECR is clamped, D3DSTENCILOP_DECR wraps
1607         default: Con_DPrintf("Unknown GL_StencilFunc\n");return D3DSTENCILOP_KEEP;
1608         }
1609 }
1610 #endif
1611
1612 static void GL_Backend_ResetState(void)
1613 {
1614         unsigned int i;
1615         gl_state.active = true;
1616         gl_state.depthtest = true;
1617         gl_state.alphatest = false;
1618         gl_state.alphafunc = GL_GEQUAL;
1619         gl_state.alphafuncvalue = 0.5f;
1620         gl_state.alphatocoverage = false;
1621         gl_state.blendfunc1 = GL_ONE;
1622         gl_state.blendfunc2 = GL_ZERO;
1623         gl_state.blend = false;
1624         gl_state.depthmask = GL_TRUE;
1625         gl_state.colormask = 15;
1626         gl_state.color4f[0] = gl_state.color4f[1] = gl_state.color4f[2] = gl_state.color4f[3] = 1;
1627         gl_state.lockrange_first = 0;
1628         gl_state.lockrange_count = 0;
1629         gl_state.cullface = GL_FRONT;
1630         gl_state.cullfaceenable = false;
1631         gl_state.polygonoffset[0] = 0;
1632         gl_state.polygonoffset[1] = 0;
1633         gl_state.framebufferobject = 0;
1634         gl_state.depthfunc = GL_LEQUAL;
1635
1636         switch(vid.renderpath)
1637         {
1638         case RENDERPATH_D3D9:
1639 #ifdef SUPPORTD3D
1640                 {
1641                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_COLORWRITEENABLE, gl_state.colormask);
1642                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_NONE);
1643                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZFUNC, d3dcmpforglfunc(gl_state.depthfunc));
1644                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZENABLE, gl_state.depthtest);
1645                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZWRITEENABLE, gl_state.depthmask);
1646                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SLOPESCALEDEPTHBIAS, gl_state.polygonoffset[0]);
1647                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_DEPTHBIAS, gl_state.polygonoffset[1] * (1.0f / 16777216.0f));
1648                 }
1649 #endif
1650                 break;
1651         case RENDERPATH_D3D10:
1652                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1653                 break;
1654         case RENDERPATH_D3D11:
1655                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1656                 break;
1657         case RENDERPATH_GL11:
1658         case RENDERPATH_GL13:
1659         case RENDERPATH_GLES1:
1660 #ifndef USE_GLES2
1661                 CHECKGLERROR
1662
1663                 qglColorMask(1, 1, 1, 1);CHECKGLERROR
1664                 qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
1665                 qglDisable(GL_ALPHA_TEST);CHECKGLERROR
1666                 if (qglBlendFuncSeparate)
1667                 {
1668                         qglBlendFuncSeparate(gl_state.blendfunc1, gl_state.blendfunc2, GL_ZERO, GL_ONE);CHECKGLERROR // ELUAN: Adreno 225 (and others) compositing workaround
1669                 }
1670                 else
1671                 {
1672                         qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
1673                 }
1674                 qglDisable(GL_BLEND);CHECKGLERROR
1675                 qglCullFace(gl_state.cullface);CHECKGLERROR
1676                 qglDisable(GL_CULL_FACE);CHECKGLERROR
1677                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1678                 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
1679                 qglDepthMask(gl_state.depthmask);CHECKGLERROR
1680                 qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
1681
1682                 if (vid.support.arb_vertex_buffer_object)
1683                 {
1684                         qglBindBufferARB(GL_ARRAY_BUFFER, 0);
1685                         qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
1686                 }
1687
1688                 if (vid.support.ext_framebuffer_object)
1689                 {
1690                         //qglBindRenderbuffer(GL_RENDERBUFFER, 0);
1691                         qglBindFramebuffer(GL_FRAMEBUFFER, 0);
1692                 }
1693
1694                 qglVertexPointer(3, GL_FLOAT, sizeof(float[3]), NULL);CHECKGLERROR
1695                 qglEnableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
1696
1697                 qglColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL);CHECKGLERROR
1698                 qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
1699                 qglColor4f(1, 1, 1, 1);CHECKGLERROR
1700
1701                 if (vid.support.ext_framebuffer_object)
1702                         qglBindFramebuffer(GL_FRAMEBUFFER, gl_state.framebufferobject);
1703
1704                 gl_state.unit = MAX_TEXTUREUNITS;
1705                 gl_state.clientunit = MAX_TEXTUREUNITS;
1706                 for (i = 0;i < vid.texunits;i++)
1707                 {
1708                         GL_ActiveTexture(i);
1709                         GL_ClientActiveTexture(i);
1710                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
1711                         qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
1712                         if (vid.support.ext_texture_3d)
1713                         {
1714                                 qglDisable(GL_TEXTURE_3D);CHECKGLERROR
1715                                 qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
1716                         }
1717                         if (vid.support.arb_texture_cube_map)
1718                         {
1719                                 qglDisable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
1720                                 qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);CHECKGLERROR
1721                         }
1722                         GL_BindVBO(0);
1723                         qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), NULL);CHECKGLERROR
1724                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
1725                         qglMatrixMode(GL_TEXTURE);CHECKGLERROR
1726                         qglLoadIdentity();CHECKGLERROR
1727                         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
1728                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
1729                 }
1730                 CHECKGLERROR
1731 #endif
1732                 break;
1733         case RENDERPATH_SOFT:
1734                 DPSOFTRAST_ColorMask(1,1,1,1);
1735                 DPSOFTRAST_BlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);
1736                 DPSOFTRAST_CullFace(gl_state.cullface);
1737                 DPSOFTRAST_DepthFunc(gl_state.depthfunc);
1738                 DPSOFTRAST_DepthMask(gl_state.depthmask);
1739                 DPSOFTRAST_PolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
1740                 DPSOFTRAST_SetRenderTargets(vid.width, vid.height, vid.softdepthpixels, vid.softpixels, NULL, NULL, NULL);
1741                 DPSOFTRAST_Viewport(0, 0, vid.width, vid.height);
1742                 break;
1743         case RENDERPATH_GL20:
1744         case RENDERPATH_GLES2:
1745                 CHECKGLERROR
1746                 qglColorMask(1, 1, 1, 1);CHECKGLERROR
1747                 qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
1748                 qglDisable(GL_BLEND);CHECKGLERROR
1749                 qglCullFace(gl_state.cullface);CHECKGLERROR
1750                 qglDisable(GL_CULL_FACE);CHECKGLERROR
1751                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1752                 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
1753                 qglDepthMask(gl_state.depthmask);CHECKGLERROR
1754                 qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
1755                 if (vid.support.arb_vertex_buffer_object)
1756                 {
1757                         qglBindBufferARB(GL_ARRAY_BUFFER, 0);
1758                         qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
1759                 }
1760                 if (vid.support.ext_framebuffer_object)
1761                         qglBindFramebuffer(GL_FRAMEBUFFER, gl_state.defaultframebufferobject);
1762                 qglEnableVertexAttribArray(GLSLATTRIB_POSITION);
1763                 qglVertexAttribPointer(GLSLATTRIB_POSITION, 3, GL_FLOAT, false, sizeof(float[3]), NULL);CHECKGLERROR
1764                 qglDisableVertexAttribArray(GLSLATTRIB_COLOR);
1765                 qglVertexAttribPointer(GLSLATTRIB_COLOR, 4, GL_FLOAT, false, sizeof(float[4]), NULL);CHECKGLERROR
1766                 qglVertexAttrib4f(GLSLATTRIB_COLOR, 1, 1, 1, 1);
1767                 gl_state.unit = MAX_TEXTUREUNITS;
1768                 gl_state.clientunit = MAX_TEXTUREUNITS;
1769                 for (i = 0;i < vid.teximageunits;i++)
1770                 {
1771                         GL_ActiveTexture(i);
1772                         qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
1773                         if (vid.support.ext_texture_3d)
1774                         {
1775                                 qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
1776                         }
1777                         if (vid.support.arb_texture_cube_map)
1778                         {
1779                                 qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);CHECKGLERROR
1780                         }
1781                 }
1782                 for (i = 0;i < vid.texarrayunits;i++)
1783                 {
1784                         GL_BindVBO(0);
1785                         qglVertexAttribPointer(i+GLSLATTRIB_TEXCOORD0, 2, GL_FLOAT, false, sizeof(float[2]), NULL);CHECKGLERROR
1786                         qglDisableVertexAttribArray(i+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
1787                 }
1788                 CHECKGLERROR
1789                 break;
1790         }
1791 }
1792
1793 void GL_ActiveTexture(unsigned int num)
1794 {
1795         if (gl_state.unit != num)
1796         {
1797                 gl_state.unit = num;
1798                 switch(vid.renderpath)
1799                 {
1800                 case RENDERPATH_GL11:
1801                 case RENDERPATH_GL13:
1802                 case RENDERPATH_GL20:
1803                 case RENDERPATH_GLES1:
1804                 case RENDERPATH_GLES2:
1805                         if (qglActiveTexture)
1806                         {
1807                                 CHECKGLERROR
1808                                 qglActiveTexture(GL_TEXTURE0 + gl_state.unit);
1809                                 CHECKGLERROR
1810                         }
1811                         break;
1812                 case RENDERPATH_D3D9:
1813                 case RENDERPATH_D3D10:
1814                 case RENDERPATH_D3D11:
1815                         break;
1816                 case RENDERPATH_SOFT:
1817                         break;
1818                 }
1819         }
1820 }
1821
1822 void GL_ClientActiveTexture(unsigned int num)
1823 {
1824         if (gl_state.clientunit != num)
1825         {
1826                 gl_state.clientunit = num;
1827                 switch(vid.renderpath)
1828                 {
1829                 case RENDERPATH_GL11:
1830                 case RENDERPATH_GL13:
1831                 case RENDERPATH_GLES1:
1832 #ifndef USE_GLES2
1833                         if (qglActiveTexture)
1834                         {
1835                                 CHECKGLERROR
1836                                 qglClientActiveTexture(GL_TEXTURE0 + gl_state.clientunit);
1837                                 CHECKGLERROR
1838                         }
1839 #endif
1840                         break;
1841                 case RENDERPATH_D3D9:
1842                 case RENDERPATH_D3D10:
1843                 case RENDERPATH_D3D11:
1844                         break;
1845                 case RENDERPATH_SOFT:
1846                         break;
1847                 case RENDERPATH_GL20:
1848                 case RENDERPATH_GLES2:
1849                         break;
1850                 }
1851         }
1852 }
1853
1854 void GL_BlendFunc(int blendfunc1, int blendfunc2)
1855 {
1856         if (gl_state.blendfunc1 != blendfunc1 || gl_state.blendfunc2 != blendfunc2)
1857         {
1858                 qboolean blendenable;
1859                 gl_state.blendfunc1 = blendfunc1;
1860                 gl_state.blendfunc2 = blendfunc2;
1861                 blendenable = (gl_state.blendfunc1 != GL_ONE || gl_state.blendfunc2 != GL_ZERO);
1862                 switch(vid.renderpath)
1863                 {
1864                 case RENDERPATH_GL11:
1865                 case RENDERPATH_GL13:
1866                 case RENDERPATH_GL20:
1867                 case RENDERPATH_GLES1:
1868                 case RENDERPATH_GLES2:
1869                         CHECKGLERROR
1870                         if (qglBlendFuncSeparate)
1871                         {
1872                                 qglBlendFuncSeparate(gl_state.blendfunc1, gl_state.blendfunc2, GL_ZERO, GL_ONE);CHECKGLERROR // ELUAN: Adreno 225 (and others) compositing workaround
1873                         }
1874                         else
1875                         {
1876                                 qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
1877                         }
1878                         if (gl_state.blend != blendenable)
1879                         {
1880                                 gl_state.blend = blendenable;
1881                                 if (!gl_state.blend)
1882                                 {
1883                                         qglDisable(GL_BLEND);CHECKGLERROR
1884                                 }
1885                                 else
1886                                 {
1887                                         qglEnable(GL_BLEND);CHECKGLERROR
1888                                 }
1889                         }
1890                         break;
1891                 case RENDERPATH_D3D9:
1892 #ifdef SUPPORTD3D
1893                         {
1894                                 int i;
1895                                 int glblendfunc[2];
1896                                 D3DBLEND d3dblendfunc[2];
1897                                 glblendfunc[0] = gl_state.blendfunc1;
1898                                 glblendfunc[1] = gl_state.blendfunc2;
1899                                 for (i = 0;i < 2;i++)
1900                                 {
1901                                         switch(glblendfunc[i])
1902                                         {
1903                                         case GL_ZERO: d3dblendfunc[i] = D3DBLEND_ZERO;break;
1904                                         case GL_ONE: d3dblendfunc[i] = D3DBLEND_ONE;break;
1905                                         case GL_SRC_COLOR: d3dblendfunc[i] = D3DBLEND_SRCCOLOR;break;
1906                                         case GL_ONE_MINUS_SRC_COLOR: d3dblendfunc[i] = D3DBLEND_INVSRCCOLOR;break;
1907                                         case GL_SRC_ALPHA: d3dblendfunc[i] = D3DBLEND_SRCALPHA;break;
1908                                         case GL_ONE_MINUS_SRC_ALPHA: d3dblendfunc[i] = D3DBLEND_INVSRCALPHA;break;
1909                                         case GL_DST_ALPHA: d3dblendfunc[i] = D3DBLEND_DESTALPHA;break;
1910                                         case GL_ONE_MINUS_DST_ALPHA: d3dblendfunc[i] = D3DBLEND_INVDESTALPHA;break;
1911                                         case GL_DST_COLOR: d3dblendfunc[i] = D3DBLEND_DESTCOLOR;break;
1912                                         case GL_ONE_MINUS_DST_COLOR: d3dblendfunc[i] = D3DBLEND_INVDESTCOLOR;break;
1913                                         }
1914                                 }
1915                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SRCBLEND, d3dblendfunc[0]);
1916                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_DESTBLEND, d3dblendfunc[1]);
1917                                 if (gl_state.blend != blendenable)
1918                                 {
1919                                         gl_state.blend = blendenable;
1920                                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHABLENDENABLE, gl_state.blend);
1921                                 }
1922                         }
1923 #endif
1924                         break;
1925                 case RENDERPATH_D3D10:
1926                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1927                         break;
1928                 case RENDERPATH_D3D11:
1929                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1930                         break;
1931                 case RENDERPATH_SOFT:
1932                         DPSOFTRAST_BlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);
1933                         break;
1934                 }
1935         }
1936 }
1937
1938 void GL_DepthMask(int state)
1939 {
1940         if (gl_state.depthmask != state)
1941         {
1942                 gl_state.depthmask = state;
1943                 switch(vid.renderpath)
1944                 {
1945                 case RENDERPATH_GL11:
1946                 case RENDERPATH_GL13:
1947                 case RENDERPATH_GL20:
1948                 case RENDERPATH_GLES1:
1949                 case RENDERPATH_GLES2:
1950                         CHECKGLERROR
1951                         qglDepthMask(gl_state.depthmask);CHECKGLERROR
1952                         break;
1953                 case RENDERPATH_D3D9:
1954 #ifdef SUPPORTD3D
1955                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZWRITEENABLE, gl_state.depthmask);
1956 #endif
1957                         break;
1958                 case RENDERPATH_D3D10:
1959                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1960                         break;
1961                 case RENDERPATH_D3D11:
1962                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1963                         break;
1964                 case RENDERPATH_SOFT:
1965                         DPSOFTRAST_DepthMask(gl_state.depthmask);
1966                         break;
1967                 }
1968         }
1969 }
1970
1971 void GL_DepthTest(int state)
1972 {
1973         if (gl_state.depthtest != state)
1974         {
1975                 gl_state.depthtest = state;
1976                 switch(vid.renderpath)
1977                 {
1978                 case RENDERPATH_GL11:
1979                 case RENDERPATH_GL13:
1980                 case RENDERPATH_GL20:
1981                 case RENDERPATH_GLES1:
1982                 case RENDERPATH_GLES2:
1983                         CHECKGLERROR
1984                         if (gl_state.depthtest)
1985                         {
1986                                 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
1987                         }
1988                         else
1989                         {
1990                                 qglDisable(GL_DEPTH_TEST);CHECKGLERROR
1991                         }
1992                         break;
1993                 case RENDERPATH_D3D9:
1994 #ifdef SUPPORTD3D
1995                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZENABLE, gl_state.depthtest);
1996 #endif
1997                         break;
1998                 case RENDERPATH_D3D10:
1999                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2000                         break;
2001                 case RENDERPATH_D3D11:
2002                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2003                         break;
2004                 case RENDERPATH_SOFT:
2005                         DPSOFTRAST_DepthTest(gl_state.depthtest);
2006                         break;
2007                 }
2008         }
2009 }
2010
2011 void GL_DepthFunc(int state)
2012 {
2013         if (gl_state.depthfunc != state)
2014         {
2015                 gl_state.depthfunc = state;
2016                 switch(vid.renderpath)
2017                 {
2018                 case RENDERPATH_GL11:
2019                 case RENDERPATH_GL13:
2020                 case RENDERPATH_GL20:
2021                 case RENDERPATH_GLES1:
2022                 case RENDERPATH_GLES2:
2023                         CHECKGLERROR
2024                         qglDepthFunc(gl_state.depthfunc);CHECKGLERROR
2025                         break;
2026                 case RENDERPATH_D3D9:
2027 #ifdef SUPPORTD3D
2028                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZFUNC, d3dcmpforglfunc(gl_state.depthfunc));
2029 #endif
2030                         break;
2031                 case RENDERPATH_D3D10:
2032                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2033                         break;
2034                 case RENDERPATH_D3D11:
2035                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2036                         break;
2037                 case RENDERPATH_SOFT:
2038                         DPSOFTRAST_DepthFunc(gl_state.depthfunc);
2039                         break;
2040                 }
2041         }
2042 }
2043
2044 void GL_DepthRange(float nearfrac, float farfrac)
2045 {
2046         if (gl_state.depthrange[0] != nearfrac || gl_state.depthrange[1] != farfrac)
2047         {
2048                 gl_state.depthrange[0] = nearfrac;
2049                 gl_state.depthrange[1] = farfrac;
2050                 switch(vid.renderpath)
2051                 {
2052                 case RENDERPATH_GL11:
2053                 case RENDERPATH_GL13:
2054                 case RENDERPATH_GL20:
2055                 case RENDERPATH_GLES1:
2056                 case RENDERPATH_GLES2:
2057 #ifdef USE_GLES2
2058                         qglDepthRangef(gl_state.depthrange[0], gl_state.depthrange[1]);
2059 #else
2060                         qglDepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);
2061 #endif
2062                         break;
2063                 case RENDERPATH_D3D9:
2064 #ifdef SUPPORTD3D
2065                         {
2066                                 D3DVIEWPORT9 d3dviewport;
2067                                 d3dviewport.X = gl_viewport.x;
2068                                 d3dviewport.Y = gl_viewport.y;
2069                                 d3dviewport.Width = gl_viewport.width;
2070                                 d3dviewport.Height = gl_viewport.height;
2071                                 d3dviewport.MinZ = gl_state.depthrange[0];
2072                                 d3dviewport.MaxZ = gl_state.depthrange[1];
2073                                 IDirect3DDevice9_SetViewport(vid_d3d9dev, &d3dviewport);
2074                         }
2075 #endif
2076                         break;
2077                 case RENDERPATH_D3D10:
2078                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2079                         break;
2080                 case RENDERPATH_D3D11:
2081                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2082                         break;
2083                 case RENDERPATH_SOFT:
2084                         DPSOFTRAST_DepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);
2085                         break;
2086                 }
2087         }
2088 }
2089
2090 void R_SetStencilSeparate(qboolean enable, int writemask, int frontfail, int frontzfail, int frontzpass, int backfail, int backzfail, int backzpass, int frontcompare, int backcompare, int comparereference, int comparemask)
2091 {
2092         switch (vid.renderpath)
2093         {
2094         case RENDERPATH_GL11:
2095         case RENDERPATH_GL13:
2096         case RENDERPATH_GL20:
2097         case RENDERPATH_GLES1:
2098         case RENDERPATH_GLES2:
2099                 CHECKGLERROR
2100                 if (enable)
2101                 {
2102                         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2103                 }
2104                 else
2105                 {
2106                         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2107                 }
2108                 if (vid.support.ati_separate_stencil)
2109                 {
2110                         qglStencilMask(writemask);CHECKGLERROR
2111                         qglStencilOpSeparate(GL_FRONT, frontfail, frontzfail, frontzpass);CHECKGLERROR
2112                         qglStencilOpSeparate(GL_BACK, backfail, backzfail, backzpass);CHECKGLERROR
2113                         qglStencilFuncSeparate(GL_FRONT, frontcompare, comparereference, comparereference);CHECKGLERROR
2114                         qglStencilFuncSeparate(GL_BACK, backcompare, comparereference, comparereference);CHECKGLERROR
2115                 }
2116                 else if (vid.support.ext_stencil_two_side)
2117                 {
2118 #if defined(GL_STENCIL_TEST_TWO_SIDE_EXT) && !defined(USE_GLES2)
2119                         qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2120                         qglActiveStencilFaceEXT(GL_FRONT);CHECKGLERROR
2121                         qglStencilMask(writemask);CHECKGLERROR
2122                         qglStencilOp(frontfail, frontzfail, frontzpass);CHECKGLERROR
2123                         qglStencilFunc(frontcompare, comparereference, comparemask);CHECKGLERROR
2124                         qglActiveStencilFaceEXT(GL_BACK);CHECKGLERROR
2125                         qglStencilMask(writemask);CHECKGLERROR
2126                         qglStencilOp(backfail, backzfail, backzpass);CHECKGLERROR
2127                         qglStencilFunc(backcompare, comparereference, comparemask);CHECKGLERROR
2128 #endif
2129                 }
2130                 break;
2131         case RENDERPATH_D3D9:
2132 #ifdef SUPPORTD3D
2133                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_TWOSIDEDSTENCILMODE, true);
2134                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILENABLE, enable);
2135                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILWRITEMASK, writemask);
2136                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFAIL, d3dstencilopforglfunc(frontfail));
2137                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILZFAIL, d3dstencilopforglfunc(frontzfail));
2138                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILPASS, d3dstencilopforglfunc(frontzpass));
2139                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFUNC, d3dcmpforglfunc(frontcompare));
2140                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILFAIL, d3dstencilopforglfunc(backfail));
2141                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILZFAIL, d3dstencilopforglfunc(backzfail));
2142                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILPASS, d3dstencilopforglfunc(backzpass));
2143                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILFUNC, d3dcmpforglfunc(backcompare));
2144                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILREF, comparereference);
2145                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILMASK, comparemask);
2146 #endif
2147                 break;
2148         case RENDERPATH_D3D10:
2149                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2150                 break;
2151         case RENDERPATH_D3D11:
2152                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2153                 break;
2154         case RENDERPATH_SOFT:
2155                 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2156                 break;
2157         }
2158 }
2159
2160 void R_SetStencil(qboolean enable, int writemask, int fail, int zfail, int zpass, int compare, int comparereference, int comparemask)
2161 {
2162         switch (vid.renderpath)
2163         {
2164         case RENDERPATH_GL11:
2165         case RENDERPATH_GL13:
2166         case RENDERPATH_GL20:
2167         case RENDERPATH_GLES1:
2168         case RENDERPATH_GLES2:
2169                 CHECKGLERROR
2170                 if (enable)
2171                 {
2172                         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2173                 }
2174                 else
2175                 {
2176                         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2177                 }
2178                 if (vid.support.ext_stencil_two_side)
2179                 {
2180 #ifdef GL_STENCIL_TEST_TWO_SIDE_EXT
2181                         qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2182 #endif
2183                 }
2184                 qglStencilMask(writemask);CHECKGLERROR
2185                 qglStencilOp(fail, zfail, zpass);CHECKGLERROR
2186                 qglStencilFunc(compare, comparereference, comparemask);CHECKGLERROR
2187                 CHECKGLERROR
2188                 break;
2189         case RENDERPATH_D3D9:
2190 #ifdef SUPPORTD3D
2191                 if (vid.support.ati_separate_stencil)
2192                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_TWOSIDEDSTENCILMODE, true);
2193                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILENABLE, enable);
2194                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILWRITEMASK, writemask);
2195                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFAIL, d3dstencilopforglfunc(fail));
2196                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILZFAIL, d3dstencilopforglfunc(zfail));
2197                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILPASS, d3dstencilopforglfunc(zpass));
2198                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFUNC, d3dcmpforglfunc(compare));
2199                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILREF, comparereference);
2200                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILMASK, comparemask);
2201 #endif
2202                 break;
2203         case RENDERPATH_D3D10:
2204                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2205                 break;
2206         case RENDERPATH_D3D11:
2207                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2208                 break;
2209         case RENDERPATH_SOFT:
2210                 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2211                 break;
2212         }
2213 }
2214
2215 void GL_PolygonOffset(float planeoffset, float depthoffset)
2216 {
2217         if (gl_state.polygonoffset[0] != planeoffset || gl_state.polygonoffset[1] != depthoffset)
2218         {
2219                 gl_state.polygonoffset[0] = planeoffset;
2220                 gl_state.polygonoffset[1] = depthoffset;
2221                 switch(vid.renderpath)
2222                 {
2223                 case RENDERPATH_GL11:
2224                 case RENDERPATH_GL13:
2225                 case RENDERPATH_GL20:
2226                 case RENDERPATH_GLES1:
2227                 case RENDERPATH_GLES2:
2228                         qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
2229                         break;
2230                 case RENDERPATH_D3D9:
2231 #ifdef SUPPORTD3D
2232                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SLOPESCALEDEPTHBIAS, gl_state.polygonoffset[0]);
2233                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_DEPTHBIAS, gl_state.polygonoffset[1] * (1.0f / 16777216.0f));
2234 #endif
2235                         break;
2236                 case RENDERPATH_D3D10:
2237                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2238                         break;
2239                 case RENDERPATH_D3D11:
2240                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2241                         break;
2242                 case RENDERPATH_SOFT:
2243                         DPSOFTRAST_PolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
2244                         break;
2245                 }
2246         }
2247 }
2248
2249 void GL_SetMirrorState(qboolean state)
2250 {
2251         if (v_flipped_state != state)
2252         {
2253                 v_flipped_state = state;
2254                 if (gl_state.cullface == GL_BACK)
2255                         gl_state.cullface = GL_FRONT;
2256                 else if (gl_state.cullface == GL_FRONT)
2257                         gl_state.cullface = GL_BACK;
2258                 else
2259                         return;
2260                 switch(vid.renderpath)
2261                 {
2262                 case RENDERPATH_GL11:
2263                 case RENDERPATH_GL13:
2264                 case RENDERPATH_GL20:
2265                 case RENDERPATH_GLES1:
2266                 case RENDERPATH_GLES2:
2267                         qglCullFace(gl_state.cullface);CHECKGLERROR
2268                         break;
2269                 case RENDERPATH_D3D9:
2270 #ifdef SUPPORTD3D
2271                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, gl_state.cullface == GL_FRONT ? D3DCULL_CCW : D3DCULL_CW);
2272 #endif
2273                         break;
2274                 case RENDERPATH_D3D10:
2275                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2276                         break;
2277                 case RENDERPATH_D3D11:
2278                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2279                         break;
2280                 case RENDERPATH_SOFT:
2281                         DPSOFTRAST_CullFace(gl_state.cullface);
2282                         break;
2283                 }
2284         }
2285 }
2286
2287 void GL_CullFace(int state)
2288 {
2289         if(v_flipped_state)
2290         {
2291                 if(state == GL_FRONT)
2292                         state = GL_BACK;
2293                 else if(state == GL_BACK)
2294                         state = GL_FRONT;
2295         }
2296
2297         switch(vid.renderpath)
2298         {
2299         case RENDERPATH_GL11:
2300         case RENDERPATH_GL13:
2301         case RENDERPATH_GL20:
2302         case RENDERPATH_GLES1:
2303         case RENDERPATH_GLES2:
2304                 CHECKGLERROR
2305
2306                 if (state != GL_NONE)
2307                 {
2308                         if (!gl_state.cullfaceenable)
2309                         {
2310                                 gl_state.cullfaceenable = true;
2311                                 qglEnable(GL_CULL_FACE);CHECKGLERROR
2312                         }
2313                         if (gl_state.cullface != state)
2314                         {
2315                                 gl_state.cullface = state;
2316                                 qglCullFace(gl_state.cullface);CHECKGLERROR
2317                         }
2318                 }
2319                 else
2320                 {
2321                         if (gl_state.cullfaceenable)
2322                         {
2323                                 gl_state.cullfaceenable = false;
2324                                 qglDisable(GL_CULL_FACE);CHECKGLERROR
2325                         }
2326                 }
2327                 break;
2328         case RENDERPATH_D3D9:
2329 #ifdef SUPPORTD3D
2330                 if (gl_state.cullface != state)
2331                 {
2332                         gl_state.cullface = state;
2333                         switch(gl_state.cullface)
2334                         {
2335                         case GL_NONE:
2336                                 gl_state.cullfaceenable = false;
2337                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_NONE);
2338                                 break;
2339                         case GL_FRONT:
2340                                 gl_state.cullfaceenable = true;
2341                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_CCW);
2342                                 break;
2343                         case GL_BACK:
2344                                 gl_state.cullfaceenable = true;
2345                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_CW);
2346                                 break;
2347                         }
2348                 }
2349 #endif
2350                 break;
2351         case RENDERPATH_D3D10:
2352                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2353                 break;
2354         case RENDERPATH_D3D11:
2355                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2356                 break;
2357         case RENDERPATH_SOFT:
2358                 if (gl_state.cullface != state)
2359                 {
2360                         gl_state.cullface = state;
2361                         gl_state.cullfaceenable = state != GL_NONE ? true : false;
2362                         DPSOFTRAST_CullFace(gl_state.cullface);
2363                 }
2364                 break;
2365         }
2366 }
2367
2368 void GL_AlphaTest(int state)
2369 {
2370         if (gl_state.alphatest != state)
2371         {
2372                 gl_state.alphatest = state;
2373                 switch(vid.renderpath)
2374                 {
2375                 case RENDERPATH_GL11:
2376                 case RENDERPATH_GL13:
2377                 case RENDERPATH_GLES1:
2378 #ifdef GL_ALPHA_TEST
2379                         // only fixed function uses alpha test, other paths use pixel kill capability in shaders
2380                         CHECKGLERROR
2381                         if (gl_state.alphatest)
2382                         {
2383                                 qglEnable(GL_ALPHA_TEST);CHECKGLERROR
2384                         }
2385                         else
2386                         {
2387                                 qglDisable(GL_ALPHA_TEST);CHECKGLERROR
2388                         }
2389 #endif
2390                         break;
2391                 case RENDERPATH_D3D9:
2392                 case RENDERPATH_D3D10:
2393                 case RENDERPATH_D3D11:
2394                 case RENDERPATH_SOFT:
2395                 case RENDERPATH_GL20:
2396                 case RENDERPATH_GLES2:
2397                         break;
2398                 }
2399         }
2400 }
2401
2402 void GL_AlphaToCoverage(qboolean state)
2403 {
2404         if (gl_state.alphatocoverage != state)
2405         {
2406                 gl_state.alphatocoverage = state;
2407                 switch(vid.renderpath)
2408                 {
2409                 case RENDERPATH_GL11:
2410                 case RENDERPATH_GL13:
2411                 case RENDERPATH_GLES1:
2412                 case RENDERPATH_GLES2:
2413                 case RENDERPATH_D3D9:
2414                 case RENDERPATH_D3D10:
2415                 case RENDERPATH_D3D11:
2416                 case RENDERPATH_SOFT:
2417                         break;
2418                 case RENDERPATH_GL20:
2419 #ifdef GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
2420                         // alpha to coverage turns the alpha value of the pixel into 0%, 25%, 50%, 75% or 100% by masking the multisample fragments accordingly
2421                         CHECKGLERROR
2422                         if (gl_state.alphatocoverage)
2423                         {
2424                                 qglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
2425 //                              qglEnable(GL_MULTISAMPLE_ARB);CHECKGLERROR
2426                         }
2427                         else
2428                         {
2429                                 qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
2430 //                              qglDisable(GL_MULTISAMPLE_ARB);CHECKGLERROR
2431                         }
2432 #endif
2433                         break;
2434                 }
2435         }
2436 }
2437
2438 void GL_ColorMask(int r, int g, int b, int a)
2439 {
2440         // NOTE: this matches D3DCOLORWRITEENABLE_RED, GREEN, BLUE, ALPHA
2441         int state = (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0) | (a ? 8 : 0);
2442         if (gl_state.colormask != state)
2443         {
2444                 gl_state.colormask = state;
2445                 switch(vid.renderpath)
2446                 {
2447                 case RENDERPATH_GL11:
2448                 case RENDERPATH_GL13:
2449                 case RENDERPATH_GL20:
2450                 case RENDERPATH_GLES1:
2451                 case RENDERPATH_GLES2:
2452                         CHECKGLERROR
2453                         qglColorMask((GLboolean)r, (GLboolean)g, (GLboolean)b, (GLboolean)a);CHECKGLERROR
2454                         break;
2455                 case RENDERPATH_D3D9:
2456 #ifdef SUPPORTD3D
2457                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_COLORWRITEENABLE, state);
2458 #endif
2459                         break;
2460                 case RENDERPATH_D3D10:
2461                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2462                         break;
2463                 case RENDERPATH_D3D11:
2464                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2465                         break;
2466                 case RENDERPATH_SOFT:
2467                         DPSOFTRAST_ColorMask(r, g, b, a);
2468                         break;
2469                 }
2470         }
2471 }
2472
2473 void GL_Color(float cr, float cg, float cb, float ca)
2474 {
2475         if (gl_state.pointer_color_enabled || gl_state.color4f[0] != cr || gl_state.color4f[1] != cg || gl_state.color4f[2] != cb || gl_state.color4f[3] != ca)
2476         {
2477                 gl_state.color4f[0] = cr;
2478                 gl_state.color4f[1] = cg;
2479                 gl_state.color4f[2] = cb;
2480                 gl_state.color4f[3] = ca;
2481                 switch(vid.renderpath)
2482                 {
2483                 case RENDERPATH_GL11:
2484                 case RENDERPATH_GL13:
2485                 case RENDERPATH_GLES1:
2486 #ifndef USE_GLES2
2487                         CHECKGLERROR
2488                         qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);
2489                         CHECKGLERROR
2490 #endif
2491                         break;
2492                 case RENDERPATH_D3D9:
2493                 case RENDERPATH_D3D10:
2494                 case RENDERPATH_D3D11:
2495                         // no equivalent in D3D
2496                         break;
2497                 case RENDERPATH_SOFT:
2498                         DPSOFTRAST_Color4f(cr, cg, cb, ca);
2499                         break;
2500                 case RENDERPATH_GL20:
2501                 case RENDERPATH_GLES2:
2502                         qglVertexAttrib4f(GLSLATTRIB_COLOR, cr, cg, cb, ca);
2503                         break;
2504                 }
2505         }
2506 }
2507
2508 void GL_Scissor (int x, int y, int width, int height)
2509 {
2510         switch(vid.renderpath)
2511         {
2512         case RENDERPATH_GL11:
2513         case RENDERPATH_GL13:
2514         case RENDERPATH_GL20:
2515         case RENDERPATH_GLES1:
2516         case RENDERPATH_GLES2:
2517                 CHECKGLERROR
2518                 qglScissor(x, y,width,height);
2519                 CHECKGLERROR
2520                 break;
2521         case RENDERPATH_D3D9:
2522 #ifdef SUPPORTD3D
2523                 {
2524                         RECT d3drect;
2525                         d3drect.left = x;
2526                         d3drect.top = y;
2527                         d3drect.right = x + width;
2528                         d3drect.bottom = y + height;
2529                         IDirect3DDevice9_SetScissorRect(vid_d3d9dev, &d3drect);
2530                 }
2531 #endif
2532                 break;
2533         case RENDERPATH_D3D10:
2534                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2535                 break;
2536         case RENDERPATH_D3D11:
2537                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2538                 break;
2539         case RENDERPATH_SOFT:
2540                 DPSOFTRAST_Scissor(x, y, width, height);
2541                 break;
2542         }
2543 }
2544
2545 void GL_ScissorTest(int state)
2546 {
2547         if (gl_state.scissortest != state)
2548         {
2549                 gl_state.scissortest = state;
2550                 switch(vid.renderpath)
2551                 {
2552                 case RENDERPATH_GL11:
2553                 case RENDERPATH_GL13:
2554                 case RENDERPATH_GL20:
2555                 case RENDERPATH_GLES1:
2556                 case RENDERPATH_GLES2:
2557                         CHECKGLERROR
2558                         if(gl_state.scissortest)
2559                                 qglEnable(GL_SCISSOR_TEST);
2560                         else
2561                                 qglDisable(GL_SCISSOR_TEST);
2562                         CHECKGLERROR
2563                         break;
2564                 case RENDERPATH_D3D9:
2565 #ifdef SUPPORTD3D
2566                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SCISSORTESTENABLE, gl_state.scissortest);
2567 #endif
2568                         break;
2569                 case RENDERPATH_D3D10:
2570                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2571                         break;
2572                 case RENDERPATH_D3D11:
2573                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2574                         break;
2575                 case RENDERPATH_SOFT:
2576                         DPSOFTRAST_ScissorTest(gl_state.scissortest);
2577                         break;
2578                 }
2579         }
2580 }
2581
2582 void GL_Clear(int mask, const float *colorvalue, float depthvalue, int stencilvalue)
2583 {
2584         // opaque black - if you want transparent black, you'll need to pass in a colorvalue
2585         static const float blackcolor[4] = {0.0f, 0.0f, 0.0f, 1.0f};
2586         // prevent warnings when trying to clear a buffer that does not exist
2587         if (!colorvalue)
2588                 colorvalue = blackcolor;
2589         if (!vid.stencil)
2590         {
2591                 mask &= ~GL_STENCIL_BUFFER_BIT;
2592                 stencilvalue = 0;
2593         }
2594         switch(vid.renderpath)
2595         {
2596         case RENDERPATH_GL11:
2597         case RENDERPATH_GL13:
2598         case RENDERPATH_GL20:
2599         case RENDERPATH_GLES1:
2600         case RENDERPATH_GLES2:
2601                 CHECKGLERROR
2602                 if (mask & GL_COLOR_BUFFER_BIT)
2603                 {
2604                         qglClearColor(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]);CHECKGLERROR
2605                 }
2606                 if (mask & GL_DEPTH_BUFFER_BIT)
2607                 {
2608 #ifdef USE_GLES2
2609                         qglClearDepthf(depthvalue);CHECKGLERROR
2610 #else
2611                         qglClearDepth(depthvalue);CHECKGLERROR
2612 #endif
2613                 }
2614                 if (mask & GL_STENCIL_BUFFER_BIT)
2615                 {
2616                         qglClearStencil(stencilvalue);CHECKGLERROR
2617                 }
2618                 qglClear(mask);CHECKGLERROR
2619                 break;
2620         case RENDERPATH_D3D9:
2621 #ifdef SUPPORTD3D
2622                 IDirect3DDevice9_Clear(vid_d3d9dev, 0, NULL, ((mask & GL_COLOR_BUFFER_BIT) ? D3DCLEAR_TARGET : 0) | ((mask & GL_STENCIL_BUFFER_BIT) ? D3DCLEAR_STENCIL : 0) | ((mask & GL_DEPTH_BUFFER_BIT) ? D3DCLEAR_ZBUFFER : 0), D3DCOLOR_COLORVALUE(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]), depthvalue, stencilvalue);
2623 #endif
2624                 break;
2625         case RENDERPATH_D3D10:
2626                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2627                 break;
2628         case RENDERPATH_D3D11:
2629                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2630                 break;
2631         case RENDERPATH_SOFT:
2632                 if (mask & GL_COLOR_BUFFER_BIT)
2633                         DPSOFTRAST_ClearColor(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]);
2634                 if (mask & GL_DEPTH_BUFFER_BIT)
2635                         DPSOFTRAST_ClearDepth(depthvalue);
2636                 break;
2637         }
2638 }
2639
2640 void GL_ReadPixelsBGRA(int x, int y, int width, int height, unsigned char *outpixels)
2641 {
2642         switch(vid.renderpath)
2643         {
2644         case RENDERPATH_GL11:
2645         case RENDERPATH_GL13:
2646         case RENDERPATH_GL20:
2647         case RENDERPATH_GLES1:
2648         case RENDERPATH_GLES2:
2649                 CHECKGLERROR
2650 #ifndef GL_BGRA
2651                 {
2652                         int i;
2653                         int r;
2654                 //      int g;
2655                         int b;
2656                 //      int a;
2657                         qglReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, outpixels);CHECKGLERROR
2658                         for (i = 0;i < width * height * 4;i += 4)
2659                         {
2660                                 r = outpixels[i+0];
2661                 //              g = outpixels[i+1];
2662                                 b = outpixels[i+2];
2663                 //              a = outpixels[i+3];
2664                                 outpixels[i+0] = b;
2665                 //              outpixels[i+1] = g;
2666                                 outpixels[i+2] = r;
2667                 //              outpixels[i+3] = a;
2668                         }
2669                 }
2670 #else
2671                 qglReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_BYTE, outpixels);CHECKGLERROR
2672 #endif
2673                         break;
2674         case RENDERPATH_D3D9:
2675 #ifdef SUPPORTD3D
2676                 {
2677                         // LordHavoc: we can't directly download the backbuffer because it may be
2678                         // multisampled, and it may not be lockable, so we blit it to a lockable
2679                         // surface of the same dimensions (but without multisample) to resolve the
2680                         // multisample buffer to a normal image, and then lock that...
2681                         IDirect3DSurface9 *stretchsurface = NULL;
2682                         if (!FAILED(IDirect3DDevice9_CreateRenderTarget(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &stretchsurface, NULL)))
2683                         {
2684                                 D3DLOCKED_RECT lockedrect;
2685                                 if (!FAILED(IDirect3DDevice9_StretchRect(vid_d3d9dev, gl_state.d3drt_backbuffercolorsurface, NULL, stretchsurface, NULL, D3DTEXF_POINT)))
2686                                 {
2687                                         if (!FAILED(IDirect3DSurface9_LockRect(stretchsurface, &lockedrect, NULL, D3DLOCK_READONLY)))
2688                                         {
2689                                                 int line;
2690                                                 unsigned char *row = (unsigned char *)lockedrect.pBits + x * 4 + lockedrect.Pitch * (vid.height - 1 - y);
2691                                                 for (line = 0;line < height;line++, row -= lockedrect.Pitch)
2692                                                         memcpy(outpixels + line * width * 4, row, width * 4);
2693                                                 IDirect3DSurface9_UnlockRect(stretchsurface);
2694                                         }
2695                                 }
2696                                 IDirect3DSurface9_Release(stretchsurface);
2697                         }
2698                         // code scraps
2699                         //IDirect3DSurface9 *syssurface = NULL;
2700                         //if (!FAILED(IDirect3DDevice9_CreateRenderTarget(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, FALSE, &stretchsurface, NULL)))
2701                         //if (!FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &syssurface, NULL)))
2702                         //IDirect3DDevice9_GetRenderTargetData(vid_d3d9dev, gl_state.d3drt_backbuffercolorsurface, syssurface);
2703                         //if (!FAILED(IDirect3DDevice9_GetFrontBufferData(vid_d3d9dev, 0, syssurface)))
2704                         //if (!FAILED(IDirect3DSurface9_LockRect(syssurface, &lockedrect, NULL, D3DLOCK_READONLY)))
2705                         //IDirect3DSurface9_UnlockRect(syssurface);
2706                         //IDirect3DSurface9_Release(syssurface);
2707                 }
2708 #endif
2709                 break;
2710         case RENDERPATH_D3D10:
2711                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2712                 break;
2713         case RENDERPATH_D3D11:
2714                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2715                 break;
2716         case RENDERPATH_SOFT:
2717                 DPSOFTRAST_GetPixelsBGRA(x, y, width, height, outpixels);
2718                 break;
2719         }
2720 }
2721
2722 // called at beginning of frame
2723 void R_Mesh_Start(void)
2724 {
2725         BACKENDACTIVECHECK
2726         R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL);
2727         R_Mesh_SetUseVBO();
2728         if (gl_printcheckerror.integer && !gl_paranoid.integer)
2729         {
2730                 Con_Printf("WARNING: gl_printcheckerror is on but gl_paranoid is off, turning it on...\n");
2731                 Cvar_SetValueQuick(&gl_paranoid, 1);
2732         }
2733 }
2734
2735 static qboolean GL_Backend_CompileShader(int programobject, GLenum shadertypeenum, const char *shadertype, int numstrings, const char **strings)
2736 {
2737         int shaderobject;
2738         int shadercompiled;
2739         char compilelog[MAX_INPUTLINE];
2740         shaderobject = qglCreateShader(shadertypeenum);CHECKGLERROR
2741         if (!shaderobject)
2742                 return false;
2743         qglShaderSource(shaderobject, numstrings, strings, NULL);CHECKGLERROR
2744         qglCompileShader(shaderobject);CHECKGLERROR
2745         qglGetShaderiv(shaderobject, GL_COMPILE_STATUS, &shadercompiled);CHECKGLERROR
2746         qglGetShaderInfoLog(shaderobject, sizeof(compilelog), NULL, compilelog);CHECKGLERROR
2747         if (compilelog[0] && ((strstr(compilelog, "error") || strstr(compilelog, "ERROR") || strstr(compilelog, "Error")) || ((strstr(compilelog, "WARNING") || strstr(compilelog, "warning") || strstr(compilelog, "Warning")) && developer.integer) || developer_extra.integer))
2748         {
2749                 int i, j, pretextlines = 0;
2750                 for (i = 0;i < numstrings - 1;i++)
2751                         for (j = 0;strings[i][j];j++)
2752                                 if (strings[i][j] == '\n')
2753                                         pretextlines++;
2754                 Con_Printf("%s shader compile log:\n%s\n(line offset for any above warnings/errors: %i)\n", shadertype, compilelog, pretextlines);
2755         }
2756         if (!shadercompiled)
2757         {
2758                 qglDeleteShader(shaderobject);CHECKGLERROR
2759                 return false;
2760         }
2761         qglAttachShader(programobject, shaderobject);CHECKGLERROR
2762         qglDeleteShader(shaderobject);CHECKGLERROR
2763         return true;
2764 }
2765
2766 unsigned int GL_Backend_CompileProgram(int vertexstrings_count, const char **vertexstrings_list, int geometrystrings_count, const char **geometrystrings_list, int fragmentstrings_count, const char **fragmentstrings_list)
2767 {
2768         GLint programlinked;
2769         GLuint programobject = 0;
2770         char linklog[MAX_INPUTLINE];
2771         CHECKGLERROR
2772
2773         programobject = qglCreateProgram();CHECKGLERROR
2774         if (!programobject)
2775                 return 0;
2776
2777         qglBindAttribLocation(programobject, GLSLATTRIB_POSITION , "Attrib_Position" );
2778         qglBindAttribLocation(programobject, GLSLATTRIB_COLOR    , "Attrib_Color"    );
2779         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD0, "Attrib_TexCoord0");
2780         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD1, "Attrib_TexCoord1");
2781         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD2, "Attrib_TexCoord2");
2782         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD3, "Attrib_TexCoord3");
2783         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD4, "Attrib_TexCoord4");
2784         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD5, "Attrib_TexCoord5");
2785         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD6, "Attrib_SkeletalIndex");
2786         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD7, "Attrib_SkeletalWeight");
2787 #ifndef USE_GLES2
2788         if(vid.support.gl20shaders130)
2789                 qglBindFragDataLocation(programobject, 0, "dp_FragColor");
2790 #endif
2791
2792         if (vertexstrings_count && !GL_Backend_CompileShader(programobject, GL_VERTEX_SHADER, "vertex", vertexstrings_count, vertexstrings_list))
2793                 goto cleanup;
2794
2795 #if defined(GL_GEOMETRY_SHADER) && !defined(USE_GLES2)
2796         if (geometrystrings_count && !GL_Backend_CompileShader(programobject, GL_GEOMETRY_SHADER, "geometry", geometrystrings_count, geometrystrings_list))
2797                 goto cleanup;
2798 #endif
2799
2800         if (fragmentstrings_count && !GL_Backend_CompileShader(programobject, GL_FRAGMENT_SHADER, "fragment", fragmentstrings_count, fragmentstrings_list))
2801                 goto cleanup;
2802
2803         qglLinkProgram(programobject);CHECKGLERROR
2804         qglGetProgramiv(programobject, GL_LINK_STATUS, &programlinked);CHECKGLERROR
2805         qglGetProgramInfoLog(programobject, sizeof(linklog), NULL, linklog);CHECKGLERROR
2806
2807         if (linklog[0])
2808         {
2809
2810                 if (strstr(linklog, "error") || strstr(linklog, "ERROR") || strstr(linklog, "Error") || strstr(linklog, "WARNING") || strstr(linklog, "warning") || strstr(linklog, "Warning") || developer_extra.integer)
2811                         Con_DPrintf("program link log:\n%s\n", linklog);
2812
2813                 // software vertex shader is ok but software fragment shader is WAY
2814                 // too slow, fail program if so.
2815                 // NOTE: this string might be ATI specific, but that's ok because the
2816                 // ATI R300 chip (Radeon 9500-9800/X300) is the most likely to use a
2817                 // software fragment shader due to low instruction and dependent
2818                 // texture limits.
2819                 if (strstr(linklog, "fragment shader will run in software"))
2820                         programlinked = false;
2821         }
2822
2823         if (!programlinked)
2824                 goto cleanup;
2825
2826         return programobject;
2827 cleanup:
2828         qglDeleteProgram(programobject);CHECKGLERROR
2829         return 0;
2830 }
2831
2832 void GL_Backend_FreeProgram(unsigned int prog)
2833 {
2834         CHECKGLERROR
2835         qglDeleteProgram(prog);
2836         CHECKGLERROR
2837 }
2838
2839 // renders triangles using vertices from the active arrays
2840 int paranoidblah = 0;
2841 void R_Mesh_Draw(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const r_meshbuffer_t *element3i_indexbuffer, int element3i_bufferoffset, const unsigned short *element3s, const r_meshbuffer_t *element3s_indexbuffer, int element3s_bufferoffset)
2842 {
2843         unsigned int numelements = numtriangles * 3;
2844         int bufferobject3i;
2845         size_t bufferoffset3i;
2846         int bufferobject3s;
2847         size_t bufferoffset3s;
2848         if (numvertices < 3 || numtriangles < 1)
2849         {
2850                 if (numvertices < 0 || numtriangles < 0 || developer_extra.integer)
2851                         Con_DPrintf("R_Mesh_Draw(%d, %d, %d, %d, %8p, %8p, %8x, %8p, %8p, %8x);\n", firstvertex, numvertices, firsttriangle, numtriangles, (void *)element3i, (void *)element3i_indexbuffer, (int)element3i_bufferoffset, (void *)element3s, (void *)element3s_indexbuffer, (int)element3s_bufferoffset);
2852                 return;
2853         }
2854         // adjust the pointers for firsttriangle
2855         if (element3i)
2856                 element3i += firsttriangle * 3;
2857         if (element3i_indexbuffer)
2858                 element3i_bufferoffset += firsttriangle * 3 * sizeof(*element3i);
2859         if (element3s)
2860                 element3s += firsttriangle * 3;
2861         if (element3s_indexbuffer)
2862                 element3s_bufferoffset += firsttriangle * 3 * sizeof(*element3s);
2863         switch(vid.renderpath)
2864         {
2865         case RENDERPATH_GL11:
2866         case RENDERPATH_GL13:
2867         case RENDERPATH_GL20:
2868         case RENDERPATH_GLES1:
2869         case RENDERPATH_GLES2:
2870                 // check if the user specified to ignore static index buffers
2871                 if (!gl_state.usevbo_staticindex || (gl_vbo.integer == 3 && !vid.forcevbo && (element3i_bufferoffset || element3s_bufferoffset)))
2872                 {
2873                         element3i_indexbuffer = NULL;
2874                         element3s_indexbuffer = NULL;
2875                 }
2876                 break;
2877         case RENDERPATH_D3D9:
2878         case RENDERPATH_D3D10:
2879         case RENDERPATH_D3D11:
2880                 break;
2881         case RENDERPATH_SOFT:
2882                 break;
2883         }
2884         // upload a dynamic index buffer if needed
2885         if (element3s)
2886         {
2887                 if (!element3s_indexbuffer && gl_state.usevbo_dynamicindex)
2888                         element3s_indexbuffer = R_BufferData_Store(numelements * sizeof(*element3s), (void *)element3s, R_BUFFERDATA_INDEX16, &element3s_bufferoffset);
2889         }
2890         else if (element3i)
2891         {
2892                 if (!element3i_indexbuffer && gl_state.usevbo_dynamicindex)
2893                         element3i_indexbuffer = R_BufferData_Store(numelements * sizeof(*element3i), (void *)element3i, R_BUFFERDATA_INDEX32, &element3i_bufferoffset);
2894         }
2895         bufferobject3i = element3i_indexbuffer ? element3i_indexbuffer->bufferobject : 0;
2896         bufferoffset3i = element3i_bufferoffset;
2897         bufferobject3s = element3s_indexbuffer ? element3s_indexbuffer->bufferobject : 0;
2898         bufferoffset3s = element3s_bufferoffset;
2899         r_refdef.stats[r_stat_draws]++;
2900         r_refdef.stats[r_stat_draws_vertices] += numvertices;
2901         r_refdef.stats[r_stat_draws_elements] += numelements;
2902         if (gl_paranoid.integer)
2903         {
2904                 unsigned int i;
2905                 // LordHavoc: disabled this - it needs to be updated to handle components and gltype and stride in each array
2906 #if 0
2907                 unsigned int j, size;
2908                 const int *p;
2909                 // note: there's no validation done here on buffer objects because it
2910                 // is somewhat difficult to get at the data, and gl_paranoid can be
2911                 // used without buffer objects if the need arises
2912                 // (the data could be gotten using glMapBuffer but it would be very
2913                 //  slow due to uncachable video memory reads)
2914                 if (!qglIsEnabled(GL_VERTEX_ARRAY))
2915                         Con_Print("R_Mesh_Draw: vertex array not enabled\n");
2916                 CHECKGLERROR
2917                 if (gl_state.pointer_vertex_pointer)
2918                         for (j = 0, size = numvertices * 3, p = (int *)((float *)gl_state.pointer_vertex + firstvertex * 3);j < size;j++, p++)
2919                                 paranoidblah += *p;
2920                 if (gl_state.pointer_color_enabled)
2921                 {
2922                         if (!qglIsEnabled(GL_COLOR_ARRAY))
2923                                 Con_Print("R_Mesh_Draw: color array set but not enabled\n");
2924                         CHECKGLERROR
2925                         if (gl_state.pointer_color && gl_state.pointer_color_enabled)
2926                                 for (j = 0, size = numvertices * 4, p = (int *)((float *)gl_state.pointer_color + firstvertex * 4);j < size;j++, p++)
2927                                         paranoidblah += *p;
2928                 }
2929                 for (i = 0;i < vid.texarrayunits;i++)
2930                 {
2931                         if (gl_state.units[i].arrayenabled)
2932                         {
2933                                 GL_ClientActiveTexture(i);
2934                                 if (!qglIsEnabled(GL_TEXTURE_COORD_ARRAY))
2935                                         Con_Print("R_Mesh_Draw: texcoord array set but not enabled\n");
2936                                 CHECKGLERROR
2937                                 if (gl_state.units[i].pointer_texcoord && gl_state.units[i].arrayenabled)
2938                                         for (j = 0, size = numvertices * gl_state.units[i].arraycomponents, p = (int *)((float *)gl_state.units[i].pointer_texcoord + firstvertex * gl_state.units[i].arraycomponents);j < size;j++, p++)
2939                                                 paranoidblah += *p;
2940                         }
2941                 }
2942 #endif
2943                 if (element3i)
2944                 {
2945                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2946                         {
2947                                 if (element3i[i] < firstvertex || element3i[i] >= firstvertex + numvertices)
2948                                 {
2949                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3i array\n", element3i[i], firstvertex, firstvertex + numvertices);
2950                                         return;
2951                                 }
2952                         }
2953                 }
2954                 if (element3s)
2955                 {
2956                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2957                         {
2958                                 if (element3s[i] < firstvertex || element3s[i] >= firstvertex + numvertices)
2959                                 {
2960                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3s array\n", element3s[i], firstvertex, firstvertex + numvertices);
2961                                         return;
2962                                 }
2963                         }
2964                 }
2965         }
2966         if (r_render.integer || r_refdef.draw2dstage)
2967         {
2968                 switch(vid.renderpath)
2969                 {
2970                 case RENDERPATH_GL11:
2971                 case RENDERPATH_GL13:
2972                 case RENDERPATH_GL20:
2973                         CHECKGLERROR
2974                         if (gl_mesh_testmanualfeeding.integer)
2975                         {
2976 #ifndef USE_GLES2
2977                                 unsigned int i, j, element;
2978                                 const GLfloat *p;
2979                                 qglBegin(GL_TRIANGLES);
2980                                 if(vid.renderpath == RENDERPATH_GL20)
2981                                 {
2982                                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2983                                         {
2984                                                 if (element3i)
2985                                                         element = element3i[i];
2986                                                 else if (element3s)
2987                                                         element = element3s[i];
2988                                                 else
2989                                                         element = firstvertex + i;
2990                                                 for (j = 0;j < vid.texarrayunits;j++)
2991                                                 {
2992                                                         if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
2993                                                         {
2994                                                                 if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
2995                                                                 {
2996                                                                         p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2997                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
2998                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2], p[3]);
2999                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
3000                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2]);
3001                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
3002                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1]);
3003                                                                         else
3004                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, p[0]);
3005                                                                 }
3006                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == (int)(GL_SHORT | 0x80000000))
3007                                                                 {
3008                                                                         const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
3009                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
3010                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2], s[3]);
3011                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
3012                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2]);
3013                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
3014                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1]);
3015                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
3016                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, s[0]);
3017                                                                 }
3018                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
3019                                                                 {
3020                                                                         const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
3021                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
3022                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 127.0f), sb[1] * (1.0f / 127.0f), sb[2] * (1.0f / 127.0f), sb[3] * (1.0f / 127.0f));
3023                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
3024                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 127.0f), sb[1] * (1.0f / 127.0f), sb[2] * (1.0f / 127.0f));
3025                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
3026                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 127.0f), sb[1] * (1.0f / 127.0f));
3027                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
3028                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 127.0f));
3029                                                                 }
3030                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_UNSIGNED_BYTE)
3031                                                                 {
3032                                                                         const GLubyte *sb = (const GLubyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
3033                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
3034                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 255.0f), sb[1] * (1.0f / 255.0f), sb[2] * (1.0f / 255.0f), sb[3] * (1.0f / 255.0f));
3035                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
3036                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 255.0f), sb[1] * (1.0f / 255.0f), sb[2] * (1.0f / 255.0f));
3037                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
3038                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 255.0f), sb[1] * (1.0f / 255.0f));
3039                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
3040                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, sb[0] * (1.0f / 255.0f));
3041                                                                 }
3042                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == (int)(GL_UNSIGNED_BYTE | 0x80000000))
3043                                                                 {
3044                                                                         const GLubyte *sb = (const GLubyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
3045                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
3046                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2], sb[3]);
3047                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
3048                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2]);
3049                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
3050                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1]);
3051                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
3052                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, sb[0]);
3053                                                                 }
3054                                                         }
3055                                                 }
3056                                                 if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
3057                                                 {
3058                                                         if (gl_state.pointer_color_gltype == GL_FLOAT)
3059                                                         {
3060                                                                 p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3061                                                                 qglVertexAttrib4f(GLSLATTRIB_COLOR, p[0], p[1], p[2], p[3]);
3062                                                         }
3063                                                         else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
3064                                                         {
3065                                                                 const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3066                                                                 qglVertexAttrib4Nub(GLSLATTRIB_COLOR, ub[0], ub[1], ub[2], ub[3]);
3067                                                         }
3068                                                 }
3069                                                 if (gl_state.pointer_vertex_gltype == GL_FLOAT)
3070                                                 {
3071                                                         p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
3072                                                         if (gl_state.pointer_vertex_components == 4)
3073                                                                 qglVertexAttrib4f(GLSLATTRIB_POSITION, p[0], p[1], p[2], p[3]);
3074                                                         else if (gl_state.pointer_vertex_components == 3)
3075                                                                 qglVertexAttrib3f(GLSLATTRIB_POSITION, p[0], p[1], p[2]);
3076                                                         else
3077                                                                 qglVertexAttrib2f(GLSLATTRIB_POSITION, p[0], p[1]);
3078                                                 }
3079                                         }
3080                                 }
3081                                 else
3082                                 {
3083                                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
3084                                         {
3085                                                 if (element3i)
3086                                                         element = element3i[i];
3087                                                 else if (element3s)
3088                                                         element = element3s[i];
3089                                                 else
3090                                                         element = firstvertex + i;
3091                                                 for (j = 0;j < vid.texarrayunits;j++)
3092                                                 {
3093                                                         if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
3094                                                         {
3095                                                                 if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
3096                                                                 {
3097                                                                         p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
3098                                                                         if (vid.texarrayunits > 1)
3099                                                                         {
3100                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
3101                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, p[0], p[1], p[2], p[3]);
3102                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
3103                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, p[0], p[1], p[2]);
3104                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
3105                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, p[0], p[1]);
3106                                                                                 else
3107                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, p[0]);
3108                                                                         }
3109                                                                         else
3110                                                                         {
3111                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
3112                                                                                         qglTexCoord4f(p[0], p[1], p[2], p[3]);
3113                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
3114                                                                                         qglTexCoord3f(p[0], p[1], p[2]);
3115                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
3116                                                                                         qglTexCoord2f(p[0], p[1]);
3117                                                                                 else
3118                                                                                         qglTexCoord1f(p[0]);
3119                                                                         }
3120                                                                 }
3121                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
3122                                                                 {
3123                                                                         const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
3124                                                                         if (vid.texarrayunits > 1)
3125                                                                         {
3126                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
3127                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, s[0], s[1], s[2], s[3]);
3128                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
3129                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, s[0], s[1], s[2]);
3130                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
3131                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, s[0], s[1]);
3132                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
3133                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, s[0]);
3134                                                                         }
3135                                                                         else
3136                                                                         {
3137                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
3138                                                                                         qglTexCoord4f(s[0], s[1], s[2], s[3]);
3139                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
3140                                                                                         qglTexCoord3f(s[0], s[1], s[2]);
3141                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
3142                                                                                         qglTexCoord2f(s[0], s[1]);
3143                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
3144                                                                                         qglTexCoord1f(s[0]);
3145                                                                         }
3146                                                                 }
3147                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
3148                                                                 {
3149                                                                         const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
3150                                                                         if (vid.texarrayunits > 1)
3151                                                                         {
3152                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
3153                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, sb[0], sb[1], sb[2], sb[3]);
3154                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
3155                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, sb[0], sb[1], sb[2]);
3156                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
3157                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, sb[0], sb[1]);
3158                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
3159                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, sb[0]);
3160                                                                         }
3161                                                                         else
3162                                                                         {
3163                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
3164                                                                                         qglTexCoord4f(sb[0], sb[1], sb[2], sb[3]);
3165                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
3166                                                                                         qglTexCoord3f(sb[0], sb[1], sb[2]);
3167                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
3168                                                                                         qglTexCoord2f(sb[0], sb[1]);
3169                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
3170                                                                                         qglTexCoord1f(sb[0]);
3171                                                                         }
3172                                                                 }
3173                                                         }
3174                                                 }
3175                                                 if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
3176                                                 {
3177                                                         if (gl_state.pointer_color_gltype == GL_FLOAT)
3178                                                         {
3179                                                                 p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3180                                                                 qglColor4f(p[0], p[1], p[2], p[3]);
3181                                                         }
3182                                                         else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
3183                                                         {
3184                                                                 const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3185                                                                 qglColor4ub(ub[0], ub[1], ub[2], ub[3]);
3186                                                         }
3187                                                 }
3188                                                 if (gl_state.pointer_vertex_gltype == GL_FLOAT)
3189                                                 {
3190                                                         p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
3191                                                         if (gl_state.pointer_vertex_components == 4)
3192                                                                 qglVertex4f(p[0], p[1], p[2], p[3]);
3193                                                         else if (gl_state.pointer_vertex_components == 3)
3194                                                                 qglVertex3f(p[0], p[1], p[2]);
3195                                                         else
3196                                                                 qglVertex2f(p[0], p[1]);
3197                                                 }
3198                                         }
3199                                 }
3200                                 qglEnd();
3201                                 CHECKGLERROR
3202 #endif
3203                         }
3204                         else if (bufferobject3s)
3205                         {
3206                                 GL_BindEBO(bufferobject3s);
3207 #ifndef USE_GLES2
3208                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3209                                 {
3210                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s);
3211                                         CHECKGLERROR
3212                                 }
3213                                 else
3214 #endif
3215                                 {
3216                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s);
3217                                         CHECKGLERROR
3218                                 }
3219                         }
3220                         else if (bufferobject3i)
3221                         {
3222                                 GL_BindEBO(bufferobject3i);
3223 #ifndef USE_GLES2
3224                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3225                                 {
3226                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i);
3227                                         CHECKGLERROR
3228                                 }
3229                                 else
3230 #endif
3231                                 {
3232                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i);
3233                                         CHECKGLERROR
3234                                 }
3235                         }
3236                         else if (element3s)
3237                         {
3238                                 GL_BindEBO(0);
3239 #ifndef USE_GLES2
3240                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3241                                 {
3242                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, element3s);
3243                                         CHECKGLERROR
3244                                 }
3245                                 else
3246 #endif
3247                                 {
3248                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s);
3249                                         CHECKGLERROR
3250                                 }
3251                         }
3252                         else if (element3i)
3253                         {
3254                                 GL_BindEBO(0);
3255 #ifndef USE_GLES2
3256                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3257                                 {
3258                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, element3i);
3259                                         CHECKGLERROR
3260                                 }
3261                                 else
3262 #endif
3263                                 {
3264                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i);
3265                                         CHECKGLERROR
3266                                 }
3267                         }
3268                         else
3269                         {
3270                                 qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);
3271                                 CHECKGLERROR
3272                         }
3273                         break;
3274                 case RENDERPATH_D3D9:
3275 #ifdef SUPPORTD3D
3276                         if (gl_state.d3dvertexbuffer && ((element3s && element3s_indexbuffer) || (element3i && element3i_indexbuffer)))
3277                         {
3278                                 if (element3s_indexbuffer)
3279                                 {
3280                                         IDirect3DDevice9_SetIndices(vid_d3d9dev, (IDirect3DIndexBuffer9 *)element3s_indexbuffer->devicebuffer);
3281                                         IDirect3DDevice9_DrawIndexedPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, 0, firstvertex, numvertices, element3s_bufferoffset>>1, numtriangles);
3282                                 }
3283                                 else if (element3i_indexbuffer)
3284                                 {
3285                                         IDirect3DDevice9_SetIndices(vid_d3d9dev, (IDirect3DIndexBuffer9 *)element3i_indexbuffer->devicebuffer);
3286                                         IDirect3DDevice9_DrawIndexedPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, 0, firstvertex, numvertices, element3i_bufferoffset>>2, numtriangles);
3287                                 }
3288                                 else
3289                                         IDirect3DDevice9_DrawPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices);
3290                         }
3291                         else
3292                         {
3293                                 if (element3s)
3294                                         IDirect3DDevice9_DrawIndexedPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices, numtriangles, element3s, D3DFMT_INDEX16, gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3295                                 else if (element3i)
3296                                         IDirect3DDevice9_DrawIndexedPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices, numtriangles, element3i, D3DFMT_INDEX32, gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3297                                 else
3298                                         IDirect3DDevice9_DrawPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, numvertices, (void *)gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3299                         }
3300 #endif
3301                         break;
3302                 case RENDERPATH_D3D10:
3303                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3304                         break;
3305                 case RENDERPATH_D3D11:
3306                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3307                         break;
3308                 case RENDERPATH_SOFT:
3309                         DPSOFTRAST_DrawTriangles(firstvertex, numvertices, numtriangles, element3i, element3s);
3310                         break;
3311                 case RENDERPATH_GLES1:
3312                 case RENDERPATH_GLES2:
3313                         // GLES does not have glDrawRangeElements so this is a bit shorter than the GL20 path
3314                         if (bufferobject3s)
3315                         {
3316                                 GL_BindEBO(bufferobject3s);
3317                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s);
3318                                 CHECKGLERROR
3319                         }
3320                         else if (bufferobject3i)
3321                         {
3322                                 GL_BindEBO(bufferobject3i);
3323                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i);
3324                                 CHECKGLERROR
3325                         }
3326                         else if (element3s)
3327                         {
3328                                 GL_BindEBO(0);
3329                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s);
3330                                 CHECKGLERROR
3331                         }
3332                         else if (element3i)
3333                         {
3334                                 GL_BindEBO(0);
3335                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i);
3336                                 CHECKGLERROR
3337                         }
3338                         else
3339                         {
3340                                 qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);
3341                                 CHECKGLERROR
3342                         }
3343                         break;
3344                 }
3345         }
3346 }
3347
3348 // restores backend state, used when done with 3D rendering
3349 void R_Mesh_Finish(void)
3350 {
3351         R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL);
3352 }
3353
3354 r_meshbuffer_t *R_Mesh_CreateMeshBuffer(const void *data, size_t size, const char *name, qboolean isindexbuffer, qboolean isuniformbuffer, qboolean isdynamic, qboolean isindex16)
3355 {
3356         r_meshbuffer_t *buffer;
3357         if (isuniformbuffer)
3358         {
3359                 if (!vid.support.arb_uniform_buffer_object)
3360                         return NULL;
3361         }
3362         else
3363         {
3364                 if (!vid.support.arb_vertex_buffer_object)
3365                         return NULL;
3366                 if (!isdynamic && !(isindexbuffer ? gl_state.usevbo_staticindex : gl_state.usevbo_staticvertex))
3367                         return NULL;
3368         }
3369         buffer = (r_meshbuffer_t *)Mem_ExpandableArray_AllocRecord(&gl_state.meshbufferarray);
3370         memset(buffer, 0, sizeof(*buffer));
3371         buffer->bufferobject = 0;
3372         buffer->devicebuffer = NULL;
3373         buffer->size = size;
3374         buffer->isindexbuffer = isindexbuffer;
3375         buffer->isuniformbuffer = isuniformbuffer;
3376         buffer->isdynamic = isdynamic;
3377         buffer->isindex16 = isindex16;
3378         strlcpy(buffer->name, name, sizeof(buffer->name));
3379         R_Mesh_UpdateMeshBuffer(buffer, data, size, false, 0);
3380         return buffer;
3381 }
3382
3383 void R_Mesh_UpdateMeshBuffer(r_meshbuffer_t *buffer, const void *data, size_t size, qboolean subdata, size_t offset)
3384 {
3385         if (!buffer)
3386                 return;
3387         if (buffer->isindexbuffer)
3388         {
3389                 r_refdef.stats[r_stat_indexbufferuploadcount]++;
3390                 r_refdef.stats[r_stat_indexbufferuploadsize] += (int)size;
3391         }
3392         else
3393         {
3394                 r_refdef.stats[r_stat_vertexbufferuploadcount]++;
3395                 r_refdef.stats[r_stat_vertexbufferuploadsize] += (int)size;
3396         }
3397         if (!subdata)
3398                 buffer->size = size;
3399         switch(vid.renderpath)
3400         {
3401         case RENDERPATH_GL11:
3402         case RENDERPATH_GL13:
3403         case RENDERPATH_GL20:
3404         case RENDERPATH_GLES1:
3405         case RENDERPATH_GLES2:
3406                 if (!buffer->bufferobject)
3407                         qglGenBuffersARB(1, (GLuint *)&buffer->bufferobject);
3408                 if (buffer->isuniformbuffer)
3409                         GL_BindUBO(buffer->bufferobject);
3410                 else if (buffer->isindexbuffer)
3411                         GL_BindEBO(buffer->bufferobject);
3412                 else
3413                         GL_BindVBO(buffer->bufferobject);
3414
3415                 {
3416                         int buffertype;
3417                         buffertype = buffer->isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER;
3418 #ifdef GL_UNIFORM_BUFFER
3419                         if (buffer->isuniformbuffer)
3420                                 buffertype = GL_UNIFORM_BUFFER;
3421 #endif
3422                         if (subdata)
3423                                 qglBufferSubDataARB(buffertype, offset, size, data);
3424                         else
3425                                 qglBufferDataARB(buffertype, size, data, buffer->isdynamic ? GL_STREAM_DRAW : GL_STATIC_DRAW);
3426                 }
3427                 if (buffer->isuniformbuffer)
3428                         GL_BindUBO(0);
3429                 break;
3430         case RENDERPATH_D3D9:
3431 #ifdef SUPPORTD3D
3432                 {
3433                         int result;
3434                         void *datapointer = NULL;
3435                         if (buffer->isindexbuffer)
3436                         {
3437                                 IDirect3DIndexBuffer9 *d3d9indexbuffer = (IDirect3DIndexBuffer9 *)buffer->devicebuffer;
3438                                 if (offset+size > buffer->size || !buffer->devicebuffer)
3439                                 {
3440                                         if (buffer->devicebuffer)
3441                                                 IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9*)buffer->devicebuffer);
3442                                         buffer->devicebuffer = NULL;
3443                                         if (FAILED(result = IDirect3DDevice9_CreateIndexBuffer(vid_d3d9dev, (unsigned int)(offset+size), buffer->isdynamic ? D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC : 0, buffer->isindex16 ? D3DFMT_INDEX16 : D3DFMT_INDEX32, buffer->isdynamic ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED, &d3d9indexbuffer, NULL)))
3444                                                 Sys_Error("IDirect3DDevice9_CreateIndexBuffer(%p, %d, %x, %x, %x, %p, NULL) returned %x\n", vid_d3d9dev, (int)size, buffer->isdynamic ? (int)D3DUSAGE_DYNAMIC : 0, buffer->isindex16 ? (int)D3DFMT_INDEX16 : (int)D3DFMT_INDEX32, buffer->isdynamic ? (int)D3DPOOL_DEFAULT : (int)D3DPOOL_MANAGED, &d3d9indexbuffer, (int)result);
3445                                         buffer->devicebuffer = (void *)d3d9indexbuffer;
3446                                         buffer->size = offset+size;
3447                                 }
3448                                 if (!FAILED(IDirect3DIndexBuffer9_Lock(d3d9indexbuffer, (unsigned int)offset, (unsigned int)size, &datapointer, buffer->isdynamic ? D3DLOCK_DISCARD : 0)))
3449                                 {
3450                                         if (data)
3451                                                 memcpy(datapointer, data, size);
3452                                         else
3453                                                 memset(datapointer, 0, size);
3454                                         IDirect3DIndexBuffer9_Unlock(d3d9indexbuffer);
3455                                 }
3456                         }
3457                         else
3458                         {
3459                                 IDirect3DVertexBuffer9 *d3d9vertexbuffer = (IDirect3DVertexBuffer9 *)buffer->devicebuffer;
3460                                 if (offset+size > buffer->size || !buffer->devicebuffer)
3461                                 {
3462                                         if (buffer->devicebuffer)
3463                                                 IDirect3DVertexBuffer9_Release((IDirect3DVertexBuffer9*)buffer->devicebuffer);
3464                                         buffer->devicebuffer = NULL;
3465                                         if (FAILED(result = IDirect3DDevice9_CreateVertexBuffer(vid_d3d9dev, (unsigned int)(offset+size), buffer->isdynamic ? D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC : 0, 0, buffer->isdynamic ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED, &d3d9vertexbuffer, NULL)))
3466                                                 Sys_Error("IDirect3DDevice9_CreateVertexBuffer(%p, %d, %x, %x, %x, %p, NULL) returned %x\n", vid_d3d9dev, (int)size, buffer->isdynamic ? (int)D3DUSAGE_DYNAMIC : 0, 0, buffer->isdynamic ? (int)D3DPOOL_DEFAULT : (int)D3DPOOL_MANAGED, &d3d9vertexbuffer, (int)result);
3467                                         buffer->devicebuffer = (void *)d3d9vertexbuffer;
3468                                         buffer->size = offset+size;
3469                                 }
3470                                 if (!FAILED(IDirect3DVertexBuffer9_Lock(d3d9vertexbuffer, (unsigned int)offset, (unsigned int)size, &datapointer, buffer->isdynamic ? D3DLOCK_DISCARD : 0)))
3471                                 {
3472                                         if (data)
3473                                                 memcpy(datapointer, data, size);
3474                                         else
3475                                                 memset(datapointer, 0, size);
3476                                         IDirect3DVertexBuffer9_Unlock(d3d9vertexbuffer);
3477                                 }
3478                         }
3479                 }
3480 #endif
3481                 break;
3482         case RENDERPATH_D3D10:
3483                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3484                 break;
3485         case RENDERPATH_D3D11:
3486                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3487                 break;
3488         case RENDERPATH_SOFT:
3489                 break;
3490         }
3491 }
3492
3493 void R_Mesh_DestroyMeshBuffer(r_meshbuffer_t *buffer)
3494 {
3495         if (!buffer)
3496                 return;
3497         switch(vid.renderpath)
3498         {
3499         case RENDERPATH_GL11:
3500         case RENDERPATH_GL13:
3501         case RENDERPATH_GL20:
3502         case RENDERPATH_GLES1:
3503         case RENDERPATH_GLES2:
3504                 // GL clears the binding if we delete something bound
3505                 if (gl_state.uniformbufferobject == buffer->bufferobject)
3506                         gl_state.uniformbufferobject = 0;
3507                 if (gl_state.vertexbufferobject == buffer->bufferobject)
3508                         gl_state.vertexbufferobject = 0;
3509                 if (gl_state.elementbufferobject == buffer->bufferobject)
3510                         gl_state.elementbufferobject = 0;
3511                 qglDeleteBuffersARB(1, (GLuint *)&buffer->bufferobject);
3512                 break;
3513         case RENDERPATH_D3D9:
3514 #ifdef SUPPORTD3D
3515                 if (gl_state.d3dvertexbuffer == (void *)buffer)
3516                         gl_state.d3dvertexbuffer = NULL;
3517                 if (buffer->devicebuffer)
3518                 {
3519                         if (buffer->isindexbuffer)
3520                                 IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9 *)buffer->devicebuffer);
3521                         else
3522                                 IDirect3DVertexBuffer9_Release((IDirect3DVertexBuffer9 *)buffer->devicebuffer);
3523                         buffer->devicebuffer = NULL;
3524                 }
3525 #endif
3526                 break;
3527         case RENDERPATH_D3D10:
3528                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3529                 break;
3530         case RENDERPATH_D3D11:
3531                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3532                 break;
3533         case RENDERPATH_SOFT:
3534                 break;
3535         }
3536         Mem_ExpandableArray_FreeRecord(&gl_state.meshbufferarray, (void *)buffer);
3537 }
3538
3539 static const char *buffertypename[R_BUFFERDATA_COUNT] = {"vertex", "index16", "index32", "uniform"};
3540 void GL_Mesh_ListVBOs(qboolean printeach)
3541 {
3542         int i, endindex;
3543         int type;
3544         int isdynamic;
3545         int index16count, index16mem;
3546         int index32count, index32mem;
3547         int vertexcount, vertexmem;
3548         int uniformcount, uniformmem;
3549         int totalcount, totalmem;
3550         size_t bufferstat[R_BUFFERDATA_COUNT][2][2];
3551         r_meshbuffer_t *buffer;
3552         memset(bufferstat, 0, sizeof(bufferstat));
3553         endindex = (int)Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray);
3554         for (i = 0;i < endindex;i++)
3555         {
3556                 buffer = (r_meshbuffer_t *) Mem_ExpandableArray_RecordAtIndex(&gl_state.meshbufferarray, i);
3557                 if (!buffer)
3558                         continue;
3559                 if (buffer->isuniformbuffer)
3560                         type = R_BUFFERDATA_UNIFORM;
3561                 else if (buffer->isindexbuffer && buffer->isindex16)
3562                         type = R_BUFFERDATA_INDEX16;
3563                 else if (buffer->isindexbuffer)
3564                         type = R_BUFFERDATA_INDEX32;
3565                 else
3566                         type = R_BUFFERDATA_VERTEX;
3567                 isdynamic = buffer->isdynamic;
3568                 bufferstat[type][isdynamic][0]++;
3569                 bufferstat[type][isdynamic][1] += buffer->size;
3570                 if (printeach)
3571                         Con_Printf("buffer #%i %s = %i bytes (%s %s)\n", i, buffer->name, (int)buffer->size, isdynamic ? "dynamic" : "static", buffertypename[type]);
3572         }
3573         index16count   = (int)(bufferstat[R_BUFFERDATA_INDEX16][0][0] + bufferstat[R_BUFFERDATA_INDEX16][1][0]);
3574         index16mem     = (int)(bufferstat[R_BUFFERDATA_INDEX16][0][1] + bufferstat[R_BUFFERDATA_INDEX16][1][1]);
3575         index32count   = (int)(bufferstat[R_BUFFERDATA_INDEX32][0][0] + bufferstat[R_BUFFERDATA_INDEX32][1][0]);
3576         index32mem     = (int)(bufferstat[R_BUFFERDATA_INDEX32][0][1] + bufferstat[R_BUFFERDATA_INDEX32][1][1]);
3577         vertexcount  = (int)(bufferstat[R_BUFFERDATA_VERTEX ][0][0] + bufferstat[R_BUFFERDATA_VERTEX ][1][0]);
3578         vertexmem    = (int)(bufferstat[R_BUFFERDATA_VERTEX ][0][1] + bufferstat[R_BUFFERDATA_VERTEX ][1][1]);
3579         uniformcount = (int)(bufferstat[R_BUFFERDATA_UNIFORM][0][0] + bufferstat[R_BUFFERDATA_UNIFORM][1][0]);
3580         uniformmem   = (int)(bufferstat[R_BUFFERDATA_UNIFORM][0][1] + bufferstat[R_BUFFERDATA_UNIFORM][1][1]);
3581         totalcount = index16count + index32count + vertexcount + uniformcount;
3582         totalmem = index16mem + index32mem + vertexmem + uniformmem;
3583         Con_Printf("%i 16bit indexbuffers totalling %i bytes (%.3f MB)\n%i 32bit indexbuffers totalling %i bytes (%.3f MB)\n%i vertexbuffers totalling %i bytes (%.3f MB)\n%i uniformbuffers totalling %i bytes (%.3f MB)\ncombined %i buffers totalling %i bytes (%.3fMB)\n", index16count, index16mem, index16mem / 10248576.0, index32count, index32mem, index32mem / 10248576.0, vertexcount, vertexmem, vertexmem / 10248576.0, uniformcount, uniformmem, uniformmem / 10248576.0, totalcount, totalmem, totalmem / 10248576.0);
3584 }
3585
3586
3587
3588 void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
3589 {
3590         switch(vid.renderpath)
3591         {
3592         case RENDERPATH_GL11:
3593         case RENDERPATH_GL13:
3594         case RENDERPATH_GLES1:
3595 #ifndef USE_GLES2
3596                 if (gl_state.pointer_vertex_components != components || gl_state.pointer_vertex_gltype != gltype || gl_state.pointer_vertex_stride != stride || gl_state.pointer_vertex_pointer != pointer || gl_state.pointer_vertex_vertexbuffer != vertexbuffer || gl_state.pointer_vertex_offset != bufferoffset)
3597                 {
3598                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3599                         gl_state.pointer_vertex_components = components;
3600                         gl_state.pointer_vertex_gltype = gltype;
3601                         gl_state.pointer_vertex_stride = stride;
3602                         gl_state.pointer_vertex_pointer = pointer;
3603                         gl_state.pointer_vertex_vertexbuffer = vertexbuffer;
3604                         gl_state.pointer_vertex_offset = bufferoffset;
3605                         CHECKGLERROR
3606                         GL_BindVBO(bufferobject);
3607                         qglVertexPointer(components, gltype, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3608                 }
3609 #endif
3610                 break;
3611         case RENDERPATH_GL20:
3612         case RENDERPATH_GLES2:
3613                 if (gl_state.pointer_vertex_components != components || gl_state.pointer_vertex_gltype != gltype || gl_state.pointer_vertex_stride != stride || gl_state.pointer_vertex_pointer != pointer || gl_state.pointer_vertex_vertexbuffer != vertexbuffer || gl_state.pointer_vertex_offset != bufferoffset)
3614                 {
3615                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3616                         gl_state.pointer_vertex_components = components;
3617                         gl_state.pointer_vertex_gltype = gltype;
3618                         gl_state.pointer_vertex_stride = stride;
3619                         gl_state.pointer_vertex_pointer = pointer;
3620                         gl_state.pointer_vertex_vertexbuffer = vertexbuffer;
3621                         gl_state.pointer_vertex_offset = bufferoffset;
3622                         CHECKGLERROR
3623                         GL_BindVBO(bufferobject);
3624                         // LordHavoc: special flag added to gltype for unnormalized types
3625                         qglVertexAttribPointer(GLSLATTRIB_POSITION, components, gltype & ~0x80000000, (gltype & 0x80000000) == 0, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3626                 }
3627                 break;
3628         case RENDERPATH_D3D9:
3629         case RENDERPATH_D3D10:
3630         case RENDERPATH_D3D11:
3631         case RENDERPATH_SOFT:
3632                 break;
3633         }
3634 }
3635
3636 void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
3637 {
3638         // note: vertexbuffer may be non-NULL even if pointer is NULL, so check
3639         // the pointer only.
3640         switch(vid.renderpath)
3641         {
3642         case RENDERPATH_GL11:
3643         case RENDERPATH_GL13:
3644         case RENDERPATH_GLES1:
3645 #ifndef USE_GLES2
3646                 CHECKGLERROR
3647                 if (pointer)
3648                 {
3649                         // caller wants color array enabled
3650                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3651                         if (!gl_state.pointer_color_enabled)
3652                         {
3653                                 gl_state.pointer_color_enabled = true;
3654                                 CHECKGLERROR
3655                                 qglEnableClientState(GL_COLOR_ARRAY);CHECKGLERROR
3656                         }
3657                         if (gl_state.pointer_color_components != components || gl_state.pointer_color_gltype != gltype || gl_state.pointer_color_stride != stride || gl_state.pointer_color_pointer != pointer || gl_state.pointer_color_vertexbuffer != vertexbuffer || gl_state.pointer_color_offset != bufferoffset)
3658                         {
3659                                 gl_state.pointer_color_components = components;
3660                                 gl_state.pointer_color_gltype = gltype;
3661                                 gl_state.pointer_color_stride = stride;
3662                                 gl_state.pointer_color_pointer = pointer;
3663                                 gl_state.pointer_color_vertexbuffer = vertexbuffer;
3664                                 gl_state.pointer_color_offset = bufferoffset;
3665                                 CHECKGLERROR
3666                                 GL_BindVBO(bufferobject);
3667                                 qglColorPointer(components, gltype, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3668                         }
3669                 }
3670                 else
3671                 {
3672                         // caller wants color array disabled
3673                         if (gl_state.pointer_color_enabled)
3674                         {
3675                                 gl_state.pointer_color_enabled = false;
3676                                 CHECKGLERROR
3677                                 qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
3678                                 // when color array is on the glColor gets trashed, set it again
3679                                 qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
3680                         }
3681                 }
3682 #endif
3683                 break;
3684         case RENDERPATH_GL20:
3685         case RENDERPATH_GLES2:
3686                 CHECKGLERROR
3687                 if (pointer)
3688                 {
3689                         // caller wants color array enabled
3690                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3691                         if (!gl_state.pointer_color_enabled)
3692                         {
3693                                 gl_state.pointer_color_enabled = true;
3694                                 CHECKGLERROR
3695                                 qglEnableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
3696                         }
3697                         if (gl_state.pointer_color_components != components || gl_state.pointer_color_gltype != gltype || gl_state.pointer_color_stride != stride || gl_state.pointer_color_pointer != pointer || gl_state.pointer_color_vertexbuffer != vertexbuffer || gl_state.pointer_color_offset != bufferoffset)
3698                         {
3699                                 gl_state.pointer_color_components = components;
3700                                 gl_state.pointer_color_gltype = gltype;
3701                                 gl_state.pointer_color_stride = stride;
3702                                 gl_state.pointer_color_pointer = pointer;
3703                                 gl_state.pointer_color_vertexbuffer = vertexbuffer;
3704                                 gl_state.pointer_color_offset = bufferoffset;
3705                                 CHECKGLERROR
3706                                 GL_BindVBO(bufferobject);
3707                                 // LordHavoc: special flag added to gltype for unnormalized types
3708                                 qglVertexAttribPointer(GLSLATTRIB_COLOR, components, gltype & ~0x80000000, (gltype & 0x80000000) == 0, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3709                         }
3710                 }
3711                 else
3712                 {
3713                         // caller wants color array disabled
3714                         if (gl_state.pointer_color_enabled)
3715                         {
3716                                 gl_state.pointer_color_enabled = false;
3717                                 CHECKGLERROR
3718                                 qglDisableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
3719                                 // when color array is on the glColor gets trashed, set it again
3720                                 qglVertexAttrib4f(GLSLATTRIB_COLOR, gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
3721                         }
3722                 }
3723                 break;
3724         case RENDERPATH_D3D9:
3725         case RENDERPATH_D3D10:
3726         case RENDERPATH_D3D11:
3727         case RENDERPATH_SOFT:
3728                 break;
3729         }
3730 }
3731
3732 void R_Mesh_TexCoordPointer(unsigned int unitnum, int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
3733 {
3734         gltextureunit_t *unit = gl_state.units + unitnum;
3735         // update array settings
3736         // note: there is no need to check bufferobject here because all cases
3737         // that involve a valid bufferobject also supply a texcoord array
3738         switch(vid.renderpath)
3739         {
3740         case RENDERPATH_GL11:
3741         case RENDERPATH_GL13:
3742         case RENDERPATH_GLES1:
3743 #ifndef USE_GLES2
3744                 CHECKGLERROR
3745                 if (pointer)
3746                 {
3747                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3748                         // texture array unit is enabled, enable the array
3749                         if (!unit->arrayenabled)
3750                         {
3751                                 unit->arrayenabled = true;
3752                                 GL_ClientActiveTexture(unitnum);
3753                                 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
3754                         }
3755                         // texcoord array
3756                         if (unit->pointer_texcoord_components != components || unit->pointer_texcoord_gltype != gltype || unit->pointer_texcoord_stride != stride || unit->pointer_texcoord_pointer != pointer || unit->pointer_texcoord_vertexbuffer != vertexbuffer || unit->pointer_texcoord_offset != bufferoffset)
3757                         {
3758                                 unit->pointer_texcoord_components = components;
3759                                 unit->pointer_texcoord_gltype = gltype;
3760                                 unit->pointer_texcoord_stride = stride;
3761                                 unit->pointer_texcoord_pointer = pointer;
3762                                 unit->pointer_texcoord_vertexbuffer = vertexbuffer;
3763                                 unit->pointer_texcoord_offset = bufferoffset;
3764                                 GL_ClientActiveTexture(unitnum);
3765                                 GL_BindVBO(bufferobject);
3766                                 qglTexCoordPointer(components, gltype, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3767                         }
3768                 }
3769                 else
3770                 {
3771                         // texture array unit is disabled, disable the array
3772                         if (unit->arrayenabled)
3773                         {
3774                                 unit->arrayenabled = false;
3775                                 GL_ClientActiveTexture(unitnum);
3776                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
3777                         }
3778                 }
3779 #endif
3780                 break;
3781         case RENDERPATH_GL20:
3782         case RENDERPATH_GLES2:
3783                 CHECKGLERROR
3784                 if (pointer)
3785                 {
3786                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3787                         // texture array unit is enabled, enable the array
3788                         if (!unit->arrayenabled)
3789                         {
3790                                 unit->arrayenabled = true;
3791                                 qglEnableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
3792                         }
3793                         // texcoord array
3794                         if (unit->pointer_texcoord_components != components || unit->pointer_texcoord_gltype != gltype || unit->pointer_texcoord_stride != stride || unit->pointer_texcoord_pointer != pointer || unit->pointer_texcoord_vertexbuffer != vertexbuffer || unit->pointer_texcoord_offset != bufferoffset)
3795                         {
3796                                 unit->pointer_texcoord_components = components;
3797                                 unit->pointer_texcoord_gltype = gltype;
3798                                 unit->pointer_texcoord_stride = stride;
3799                                 unit->pointer_texcoord_pointer = pointer;
3800                                 unit->pointer_texcoord_vertexbuffer = vertexbuffer;
3801                                 unit->pointer_texcoord_offset = bufferoffset;
3802                                 GL_BindVBO(bufferobject);
3803                                 // LordHavoc: special flag added to gltype for unnormalized types
3804                                 qglVertexAttribPointer(unitnum+GLSLATTRIB_TEXCOORD0, components, gltype & ~0x80000000, (gltype & 0x80000000) == 0, (GLsizei)stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3805                         }
3806                 }
3807                 else
3808                 {
3809                         // texture array unit is disabled, disable the array
3810                         if (unit->arrayenabled)
3811                         {
3812                                 unit->arrayenabled = false;
3813                                 qglDisableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
3814                         }
3815                 }
3816                 break;
3817         case RENDERPATH_D3D9:
3818         case RENDERPATH_D3D10:
3819         case RENDERPATH_D3D11:
3820         case RENDERPATH_SOFT:
3821                 break;
3822         }
3823 }
3824
3825 int R_Mesh_TexBound(unsigned int unitnum, int id)
3826 {
3827         gltextureunit_t *unit = gl_state.units + unitnum;
3828         if (unitnum >= vid.teximageunits)
3829                 return 0;
3830         if (id == GL_TEXTURE_2D)
3831                 return unit->t2d;
3832         if (id == GL_TEXTURE_3D)
3833                 return unit->t3d;
3834         if (id == GL_TEXTURE_CUBE_MAP)
3835                 return unit->tcubemap;
3836         return 0;
3837 }
3838
3839 void R_Mesh_CopyToTexture(rtexture_t *tex, int tx, int ty, int sx, int sy, int width, int height)
3840 {
3841         switch(vid.renderpath)
3842         {
3843         case RENDERPATH_GL11:
3844         case RENDERPATH_GL13:
3845         case RENDERPATH_GL20:
3846         case RENDERPATH_GLES1:
3847         case RENDERPATH_GLES2:
3848                 R_Mesh_TexBind(0, tex);
3849                 GL_ActiveTexture(0);CHECKGLERROR
3850                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, sx, sy, width, height);CHECKGLERROR
3851                 break;
3852         case RENDERPATH_D3D9:
3853 #ifdef SUPPORTD3D
3854                 {
3855                         IDirect3DSurface9 *currentsurface = NULL;
3856                         IDirect3DSurface9 *texturesurface = NULL;
3857                         RECT sourcerect;
3858                         RECT destrect;
3859                         sourcerect.left = sx;
3860                         sourcerect.top = sy;
3861                         sourcerect.right = sx + width;
3862                         sourcerect.bottom = sy + height;
3863                         destrect.left = tx;
3864                         destrect.top = ty;
3865                         destrect.right = tx + width;
3866                         destrect.bottom = ty + height;
3867                         if (!FAILED(IDirect3DTexture9_GetSurfaceLevel(((IDirect3DTexture9 *)tex->d3dtexture), 0, &texturesurface)))
3868                         {
3869                                 if (!FAILED(IDirect3DDevice9_GetRenderTarget(vid_d3d9dev, 0, &currentsurface)))
3870                                 {
3871                                         IDirect3DDevice9_StretchRect(vid_d3d9dev, currentsurface, &sourcerect, texturesurface, &destrect, D3DTEXF_NONE);
3872                                         IDirect3DSurface9_Release(currentsurface);
3873                                 }
3874                                 IDirect3DSurface9_Release(texturesurface);
3875                         }
3876                 }
3877 #endif
3878                 break;
3879         case RENDERPATH_D3D10:
3880                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3881                 break;
3882         case RENDERPATH_D3D11:
3883                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3884                 break;
3885         case RENDERPATH_SOFT:
3886                 DPSOFTRAST_CopyRectangleToTexture(tex->texnum, 0, tx, ty, sx, sy, width, height);
3887                 break;
3888         }
3889 }
3890
3891 #ifdef SUPPORTD3D
3892 int d3drswrap[16] = {D3DRS_WRAP0, D3DRS_WRAP1, D3DRS_WRAP2, D3DRS_WRAP3, D3DRS_WRAP4, D3DRS_WRAP5, D3DRS_WRAP6, D3DRS_WRAP7, D3DRS_WRAP8, D3DRS_WRAP9, D3DRS_WRAP10, D3DRS_WRAP11, D3DRS_WRAP12, D3DRS_WRAP13, D3DRS_WRAP14, D3DRS_WRAP15};
3893 #endif
3894
3895 void R_Mesh_ClearBindingsForTexture(int texnum)
3896 {
3897         gltextureunit_t *unit;
3898         unsigned int unitnum;
3899         // this doesn't really unbind the texture, but it does prevent a mistaken "do nothing" behavior on the next time this same texnum is bound on the same unit as the same type (this mainly affects r_shadow_bouncegrid because 3D textures are so rarely used)
3900         for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
3901         {
3902                 unit = gl_state.units + unitnum;
3903                 if (unit->t2d == texnum)
3904                         unit->t2d = -1;
3905                 if (unit->t3d == texnum)
3906                         unit->t3d = -1;
3907                 if (unit->tcubemap == texnum)
3908                         unit->tcubemap = -1;
3909         }
3910 }
3911
3912 void R_Mesh_TexBind(unsigned int unitnum, rtexture_t *tex)
3913 {
3914         gltextureunit_t *unit = gl_state.units + unitnum;
3915         int tex2d, tex3d, texcubemap, texnum;
3916         if (unitnum >= vid.teximageunits)
3917                 return;
3918         if (unit->texture == tex)
3919                 return;
3920         switch(vid.renderpath)
3921         {
3922         case RENDERPATH_GL20:
3923         case RENDERPATH_GLES2:
3924                 if (!tex)
3925                 {
3926                         tex = r_texture_white;
3927                         // not initialized enough yet...
3928                         if (!tex)
3929                                 return;
3930                 }
3931                 unit->texture = tex;
3932                 texnum = R_GetTexture(tex);
3933                 switch(tex->gltexturetypeenum)
3934                 {
3935                 case GL_TEXTURE_2D: if (unit->t2d != texnum) {GL_ActiveTexture(unitnum);unit->t2d = texnum;qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR}break;
3936                 case GL_TEXTURE_3D: if (unit->t3d != texnum) {GL_ActiveTexture(unitnum);unit->t3d = texnum;qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR}break;
3937                 case GL_TEXTURE_CUBE_MAP: if (unit->tcubemap != texnum) {GL_ActiveTexture(unitnum);unit->tcubemap = texnum;qglBindTexture(GL_TEXTURE_CUBE_MAP, unit->tcubemap);CHECKGLERROR}break;
3938                 }
3939                 break;
3940         case RENDERPATH_GL11:
3941         case RENDERPATH_GL13:
3942         case RENDERPATH_GLES1:
3943                 unit->texture = tex;
3944                 tex2d = 0;
3945                 tex3d = 0;
3946                 texcubemap = 0;
3947                 if (tex)
3948                 {
3949                         texnum = R_GetTexture(tex);
3950                         switch(tex->gltexturetypeenum)
3951                         {
3952                         case GL_TEXTURE_2D:
3953                                 tex2d = texnum;
3954                                 break;
3955                         case GL_TEXTURE_3D:
3956                                 tex3d = texnum;
3957                                 break;
3958                         case GL_TEXTURE_CUBE_MAP:
3959                                 texcubemap = texnum;
3960                                 break;
3961                         }
3962                 }
3963                 // update 2d texture binding
3964                 if (unit->t2d != tex2d)
3965                 {
3966                         GL_ActiveTexture(unitnum);
3967                         if (tex2d)
3968                         {
3969                                 if (unit->t2d == 0)
3970                                 {
3971                                         qglEnable(GL_TEXTURE_2D);CHECKGLERROR
3972                                 }
3973                         }
3974                         else
3975                         {
3976                                 if (unit->t2d)
3977                                 {
3978                                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
3979                                 }
3980                         }
3981                         unit->t2d = tex2d;
3982                         qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
3983                 }
3984                 // update 3d texture binding
3985                 if (unit->t3d != tex3d)
3986                 {
3987                         GL_ActiveTexture(unitnum);
3988                         if (tex3d)
3989                         {
3990                                 if (unit->t3d == 0)
3991                                 {
3992                                         qglEnable(GL_TEXTURE_3D);CHECKGLERROR
3993                                 }
3994                         }
3995                         else
3996                         {
3997                                 if (unit->t3d)
3998                                 {
3999                                         qglDisable(GL_TEXTURE_3D);CHECKGLERROR
4000                                 }
4001                         }
4002                         unit->t3d = tex3d;
4003                         qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
4004                 }
4005                 // update cubemap texture binding
4006                 if (unit->tcubemap != texcubemap)
4007                 {
4008                         GL_ActiveTexture(unitnum);
4009                         if (texcubemap)
4010                         {
4011                                 if (unit->tcubemap == 0)
4012                                 {
4013                                         qglEnable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
4014                                 }
4015                         }
4016                         else
4017                         {
4018                                 if (unit->tcubemap)
4019                                 {
4020                                         qglDisable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
4021                                 }
4022                         }
4023                         unit->tcubemap = texcubemap;
4024                         qglBindTexture(GL_TEXTURE_CUBE_MAP, unit->tcubemap);CHECKGLERROR
4025                 }
4026                 break;
4027         case RENDERPATH_D3D9:
4028 #ifdef SUPPORTD3D
4029                 {
4030                         extern cvar_t gl_texture_anisotropy;
4031                         if (!tex)
4032                         {
4033                                 tex = r_texture_white;
4034                                 // not initialized enough yet...
4035                                 if (!tex)
4036                                         return;
4037                         }
4038                         // upload texture if needed
4039                         R_GetTexture(tex);
4040                         if (unit->texture == tex)
4041                                 return;
4042                         unit->texture = tex;
4043                         IDirect3DDevice9_SetTexture(vid_d3d9dev, unitnum, (IDirect3DBaseTexture9*)tex->d3dtexture);
4044                         //IDirect3DDevice9_SetRenderState(vid_d3d9dev, d3drswrap[unitnum], (tex->flags & TEXF_CLAMP) ? (D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2) : 0);
4045                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSU, tex->d3daddressu);
4046                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSV, tex->d3daddressv);
4047                         if (tex->d3daddressw)
4048                                 IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSW,  tex->d3daddressw);
4049                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAGFILTER, tex->d3dmagfilter);
4050                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MINFILTER, tex->d3dminfilter);
4051                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MIPFILTER, tex->d3dmipfilter);
4052                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MIPMAPLODBIAS, tex->d3dmipmaplodbias);
4053                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAXMIPLEVEL, tex->d3dmaxmiplevelfilter);
4054                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAXANISOTROPY, gl_texture_anisotropy.integer);
4055                 }
4056 #endif
4057                 break;
4058         case RENDERPATH_D3D10:
4059                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4060                 break;
4061         case RENDERPATH_D3D11:
4062                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4063                 break;
4064         case RENDERPATH_SOFT:
4065                 if (!tex)
4066                 {
4067                         tex = r_texture_white;
4068                         // not initialized enough yet...
4069                         if (!tex)
4070                                 return;
4071                 }
4072                 texnum = R_GetTexture(tex);
4073                 if (unit->texture == tex)
4074                         return;
4075                 unit->texture = tex;
4076                 DPSOFTRAST_SetTexture(unitnum, texnum);
4077                 break;
4078         }
4079 }
4080
4081 void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix)
4082 {
4083         switch(vid.renderpath)
4084         {
4085         case RENDERPATH_GL11:
4086         case RENDERPATH_GL13:
4087         case RENDERPATH_GL20:
4088         case RENDERPATH_GLES1:
4089         case RENDERPATH_GLES2:
4090 #ifdef GL_MODELVIEW
4091                 if (matrix && matrix->m[3][3])
4092                 {
4093                         gltextureunit_t *unit = gl_state.units + unitnum;
4094                         // texmatrix specified, check if it is different
4095                         if (!unit->texmatrixenabled || memcmp(&unit->matrix, matrix, sizeof(matrix4x4_t)))
4096                         {
4097                                 float glmatrix[16];
4098                                 unit->texmatrixenabled = true;
4099                                 unit->matrix = *matrix;
4100                                 CHECKGLERROR
4101                                 Matrix4x4_ToArrayFloatGL(&unit->matrix, glmatrix);
4102                                 GL_ActiveTexture(unitnum);
4103                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
4104                                 qglLoadMatrixf(glmatrix);CHECKGLERROR
4105                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
4106                         }
4107                 }
4108                 else
4109                 {
4110                         // no texmatrix specified, revert to identity
4111                         gltextureunit_t *unit = gl_state.units + unitnum;
4112                         if (unit->texmatrixenabled)
4113                         {
4114                                 unit->texmatrixenabled = false;
4115                                 unit->matrix = identitymatrix;
4116                                 CHECKGLERROR
4117                                 GL_ActiveTexture(unitnum);
4118                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
4119                                 qglLoadIdentity();CHECKGLERROR
4120                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
4121                         }
4122                 }
4123 #endif
4124                 break;
4125         case RENDERPATH_D3D9:
4126         case RENDERPATH_D3D10:
4127         case RENDERPATH_D3D11:
4128                 break;
4129         case RENDERPATH_SOFT:
4130                 break;
4131         }
4132 }
4133
4134 void R_Mesh_TexCombine(unsigned int unitnum, int combinergb, int combinealpha, int rgbscale, int alphascale)
4135 {
4136 #if defined(GL_TEXTURE_ENV) && !defined(USE_GLES2)
4137         gltextureunit_t *unit = gl_state.units + unitnum;
4138         CHECKGLERROR
4139         switch(vid.renderpath)
4140         {
4141         case RENDERPATH_GL20:
4142         case RENDERPATH_GLES2:
4143                 // do nothing
4144                 break;
4145         case RENDERPATH_GL13:
4146         case RENDERPATH_GLES1:
4147                 // GL_ARB_texture_env_combine
4148                 if (!combinergb)
4149                         combinergb = GL_MODULATE;
4150                 if (!combinealpha)
4151                         combinealpha = GL_MODULATE;
4152                 if (!rgbscale)
4153                         rgbscale = 1;
4154                 if (!alphascale)
4155                         alphascale = 1;
4156                 if (combinergb != combinealpha || rgbscale != 1 || alphascale != 1)
4157                 {
4158                         if (combinergb == GL_DECAL)
4159                                 combinergb = GL_INTERPOLATE;
4160                         if (unit->combine != GL_COMBINE)
4161                         {
4162                                 unit->combine = GL_COMBINE;
4163                                 GL_ActiveTexture(unitnum);
4164                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);CHECKGLERROR
4165                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);CHECKGLERROR // for GL_INTERPOLATE mode
4166                         }
4167                         if (unit->combinergb != combinergb)
4168                         {
4169                                 unit->combinergb = combinergb;
4170                                 GL_ActiveTexture(unitnum);
4171                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, unit->combinergb);CHECKGLERROR
4172                         }
4173                         if (unit->combinealpha != combinealpha)
4174                         {
4175                                 unit->combinealpha = combinealpha;
4176                                 GL_ActiveTexture(unitnum);
4177                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, unit->combinealpha);CHECKGLERROR
4178                         }
4179                         if (unit->rgbscale != rgbscale)
4180                         {
4181                                 unit->rgbscale = rgbscale;
4182                                 GL_ActiveTexture(unitnum);
4183                                 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, unit->rgbscale);CHECKGLERROR
4184                         }
4185                         if (unit->alphascale != alphascale)
4186                         {
4187                                 unit->alphascale = alphascale;
4188                                 GL_ActiveTexture(unitnum);
4189                                 qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, unit->alphascale);CHECKGLERROR
4190                         }
4191                 }
4192                 else
4193                 {
4194                         if (unit->combine != combinergb)
4195                         {
4196                                 unit->combine = combinergb;
4197                                 GL_ActiveTexture(unitnum);
4198                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
4199                         }
4200                 }
4201                 break;
4202         case RENDERPATH_GL11:
4203                 // normal GL texenv
4204                 if (!combinergb)
4205                         combinergb = GL_MODULATE;
4206                 if (unit->combine != combinergb)
4207                 {
4208                         unit->combine = combinergb;
4209                         GL_ActiveTexture(unitnum);
4210                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
4211                 }
4212                 break;
4213         case RENDERPATH_D3D9:
4214         case RENDERPATH_D3D10:
4215         case RENDERPATH_D3D11:
4216                 break;
4217         case RENDERPATH_SOFT:
4218                 break;
4219         }
4220 #endif
4221 }
4222
4223 void R_Mesh_ResetTextureState(void)
4224 {
4225         unsigned int unitnum;
4226
4227         BACKENDACTIVECHECK
4228
4229         for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
4230                 R_Mesh_TexBind(unitnum, NULL);
4231         for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++)
4232                 R_Mesh_TexCoordPointer(unitnum, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4233         switch(vid.renderpath)
4234         {
4235         case RENDERPATH_GL20:
4236         case RENDERPATH_GLES2:
4237         case RENDERPATH_D3D9:
4238         case RENDERPATH_D3D10:
4239         case RENDERPATH_D3D11:
4240         case RENDERPATH_SOFT:
4241                 break;
4242         case RENDERPATH_GL11:
4243         case RENDERPATH_GL13:
4244         case RENDERPATH_GLES1:
4245                 for (unitnum = 0;unitnum < vid.texunits;unitnum++)
4246                 {
4247                         R_Mesh_TexCombine(unitnum, GL_MODULATE, GL_MODULATE, 1, 1);
4248                         R_Mesh_TexMatrix(unitnum, NULL);
4249                 }
4250                 break;
4251         }
4252 }
4253
4254
4255
4256 #ifdef SUPPORTD3D
4257 //#define r_vertex3f_d3d9fvf (D3DFVF_XYZ)
4258 //#define r_vertexgeneric_d3d9fvf (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)
4259 //#define r_vertexmesh_d3d9fvf (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX5 | D3DFVF_TEXCOORDSIZE1(3) | D3DFVF_TEXCOORDSIZE2(3) | D3DFVF_TEXCOORDSIZE3(3))
4260
4261 D3DVERTEXELEMENT9 r_vertex3f_d3d9elements[] =
4262 {
4263         {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4264         D3DDECL_END()
4265 };
4266
4267 D3DVERTEXELEMENT9 r_vertexgeneric_d3d9elements[] =
4268 {
4269         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->vertex3f  ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4270         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->color4f   ), D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
4271         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->texcoord2f), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
4272         D3DDECL_END()
4273 };
4274
4275 D3DVERTEXELEMENT9 r_vertexmesh_d3d9elements[] =
4276 {
4277         {0, (int)((size_t)&((r_vertexmesh_t *)0)->vertex3f          ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4278         {0, (int)((size_t)&((r_vertexmesh_t *)0)->color4f           ), D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
4279         {0, (int)((size_t)&((r_vertexmesh_t *)0)->texcoordtexture2f ), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
4280         {0, (int)((size_t)&((r_vertexmesh_t *)0)->svector3f         ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
4281         {0, (int)((size_t)&((r_vertexmesh_t *)0)->tvector3f         ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 2},
4282         {0, (int)((size_t)&((r_vertexmesh_t *)0)->normal3f          ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 3},
4283         {0, (int)((size_t)&((r_vertexmesh_t *)0)->texcoordlightmap2f), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 4},
4284         {0, (int)((size_t)&((r_vertexmesh_t *)0)->skeletalindex4ub  ), D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 6},
4285         {0, (int)((size_t)&((r_vertexmesh_t *)0)->skeletalweight4ub ), D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 7},
4286         D3DDECL_END()
4287 };
4288
4289 IDirect3DVertexDeclaration9 *r_vertex3f_d3d9decl;
4290 IDirect3DVertexDeclaration9 *r_vertexgeneric_d3d9decl;
4291 IDirect3DVertexDeclaration9 *r_vertexmesh_d3d9decl;
4292 #endif
4293
4294 static void R_Mesh_InitVertexDeclarations(void)
4295 {
4296 #ifdef SUPPORTD3D
4297         r_vertex3f_d3d9decl = NULL;
4298         r_vertexgeneric_d3d9decl = NULL;
4299         r_vertexmesh_d3d9decl = NULL;
4300         switch(vid.renderpath)
4301         {
4302         case RENDERPATH_GL20:
4303         case RENDERPATH_GL13:
4304         case RENDERPATH_GL11:
4305         case RENDERPATH_GLES1:
4306         case RENDERPATH_GLES2:
4307                 break;
4308         case RENDERPATH_D3D9:
4309                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertex3f_d3d9elements, &r_vertex3f_d3d9decl);
4310                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertexgeneric_d3d9elements, &r_vertexgeneric_d3d9decl);
4311                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertexmesh_d3d9elements, &r_vertexmesh_d3d9decl);
4312                 break;
4313         case RENDERPATH_D3D10:
4314                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4315                 break;
4316         case RENDERPATH_D3D11:
4317                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4318                 break;
4319         case RENDERPATH_SOFT:
4320                 break;
4321         }
4322 #endif
4323 }
4324
4325 static void R_Mesh_DestroyVertexDeclarations(void)
4326 {
4327 #ifdef SUPPORTD3D
4328         if (r_vertex3f_d3d9decl)
4329                 IDirect3DVertexDeclaration9_Release(r_vertex3f_d3d9decl);
4330         r_vertex3f_d3d9decl = NULL;
4331         if (r_vertexgeneric_d3d9decl)
4332                 IDirect3DVertexDeclaration9_Release(r_vertexgeneric_d3d9decl);
4333         r_vertexgeneric_d3d9decl = NULL;
4334         if (r_vertexmesh_d3d9decl)
4335                 IDirect3DVertexDeclaration9_Release(r_vertexmesh_d3d9decl);
4336         r_vertexmesh_d3d9decl = NULL;
4337 #endif
4338 }
4339
4340 void R_Mesh_PrepareVertices_Vertex3f(int numvertices, const float *vertex3f, const r_meshbuffer_t *vertexbuffer, int bufferoffset)
4341 {
4342         // upload temporary vertexbuffer for this rendering
4343         if (!gl_state.usevbo_staticvertex)
4344                 vertexbuffer = NULL;
4345         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4346                 vertexbuffer = R_BufferData_Store(numvertices * sizeof(float[3]), (void *)vertex3f, R_BUFFERDATA_VERTEX, &bufferoffset);
4347         switch(vid.renderpath)
4348         {
4349         case RENDERPATH_GL20:
4350         case RENDERPATH_GLES2:
4351                 if (vertexbuffer)
4352                 {
4353                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, bufferoffset);
4354                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4355                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4356                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4357                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4358                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4359                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4360                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4361                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4362                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4363                 }
4364                 else
4365                 {
4366                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4367                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4368                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4369                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4370                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4371                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4372                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4373                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4374                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4375                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4376                 }
4377                 break;
4378         case RENDERPATH_GL13:
4379         case RENDERPATH_GLES1:
4380                 if (vertexbuffer)
4381                 {
4382                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, bufferoffset);
4383                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4384                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4385                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4386                 }
4387                 else
4388                 {
4389                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4390                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4391                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4392                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4393                 }
4394                 break;
4395         case RENDERPATH_GL11:
4396                 if (vertexbuffer)
4397                 {
4398                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, bufferoffset);
4399                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4400                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4401                 }
4402                 else
4403                 {
4404                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4405                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4406                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4407                 }
4408                 break;
4409         case RENDERPATH_D3D9:
4410 #ifdef SUPPORTD3D
4411                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertex3f_d3d9decl);
4412                 if (vertexbuffer)
4413                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, bufferoffset, sizeof(float[3]));
4414                 else
4415                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4416                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4417                 gl_state.d3dvertexdata = (void *)vertex3f;
4418                 gl_state.d3dvertexsize = sizeof(float[3]);
4419 #endif
4420                 break;
4421         case RENDERPATH_D3D10:
4422                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4423                 break;
4424         case RENDERPATH_D3D11:
4425                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4426                 break;
4427         case RENDERPATH_SOFT:
4428                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4429                 DPSOFTRAST_SetColorPointer(NULL, 0);
4430                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), NULL);
4431                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(float[2]), NULL);
4432                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(float[2]), NULL);
4433                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(float[2]), NULL);
4434                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), NULL);
4435                 break;
4436         }
4437 }
4438
4439
4440
4441 r_vertexgeneric_t *R_Mesh_PrepareVertices_Generic_Lock(int numvertices)
4442 {
4443         size_t size;
4444         size = sizeof(r_vertexgeneric_t) * numvertices;
4445         if (gl_state.preparevertices_tempdatamaxsize < size)
4446         {
4447                 gl_state.preparevertices_tempdatamaxsize = size;
4448                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
4449         }
4450         gl_state.preparevertices_vertexgeneric = (r_vertexgeneric_t *)gl_state.preparevertices_tempdata;
4451         gl_state.preparevertices_numvertices = numvertices;
4452         return gl_state.preparevertices_vertexgeneric;
4453 }
4454
4455 qboolean R_Mesh_PrepareVertices_Generic_Unlock(void)
4456 {
4457         R_Mesh_PrepareVertices_Generic(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexgeneric, NULL, 0);
4458         gl_state.preparevertices_vertexgeneric = NULL;
4459         gl_state.preparevertices_numvertices = 0;
4460         return true;
4461 }
4462
4463 void R_Mesh_PrepareVertices_Generic_Arrays(int numvertices, const float *vertex3f, const float *color4f, const float *texcoord2f)
4464 {
4465         int i;
4466         r_vertexgeneric_t *vertex;
4467         switch(vid.renderpath)
4468         {
4469         case RENDERPATH_GL20:
4470         case RENDERPATH_GLES2:
4471                 if (gl_state.usevbo_dynamicvertex)
4472                 {
4473                         r_meshbuffer_t *buffer_vertex3f = NULL;
4474                         r_meshbuffer_t *buffer_color4f = NULL;
4475                         r_meshbuffer_t *buffer_texcoord2f = NULL;
4476                         int bufferoffset_vertex3f = 0;
4477                         int bufferoffset_color4f = 0;
4478                         int bufferoffset_texcoord2f = 0;
4479                         buffer_color4f    = R_BufferData_Store(numvertices * sizeof(float[4]), color4f   , R_BUFFERDATA_VERTEX, &bufferoffset_color4f   );
4480                         buffer_vertex3f   = R_BufferData_Store(numvertices * sizeof(float[3]), vertex3f  , R_BUFFERDATA_VERTEX, &bufferoffset_vertex3f  );
4481                         buffer_texcoord2f = R_BufferData_Store(numvertices * sizeof(float[2]), texcoord2f, R_BUFFERDATA_VERTEX, &bufferoffset_texcoord2f);
4482                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(float[3])        , vertex3f          , buffer_vertex3f          , bufferoffset_vertex3f          );
4483                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(float[4])        , color4f           , buffer_color4f           , bufferoffset_color4f           );
4484                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(float[2])        , texcoord2f        , buffer_texcoord2f        , bufferoffset_texcoord2f        );
4485                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(float[3])        , NULL              , NULL                     , 0                              );
4486                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(float[3])        , NULL              , NULL                     , 0                              );
4487                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(float[3])        , NULL              , NULL                     , 0                              );
4488                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(float[2])        , NULL              , NULL                     , 0                              );
4489                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT        , sizeof(float[2])        , NULL              , NULL                     , 0                              );
4490                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL              , NULL                     , 0                              );
4491                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL              , NULL                     , 0                              );
4492                 }
4493                 else if (!vid.useinterleavedarrays)
4494                 {
4495                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4496                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4497                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
4498                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4499                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4500                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4501                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4502                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4503                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4504                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4505                         return;
4506                 }
4507                 break;
4508         case RENDERPATH_GL11:
4509         case RENDERPATH_GL13:
4510         case RENDERPATH_GLES1:
4511                 if (!vid.useinterleavedarrays)
4512                 {
4513                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4514                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4515                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
4516                         if (vid.texunits >= 2)
4517                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4518                         if (vid.texunits >= 3)
4519                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4520                         return;
4521                 }
4522                 break;
4523         case RENDERPATH_D3D9:
4524         case RENDERPATH_D3D10:
4525         case RENDERPATH_D3D11:
4526                 break;
4527         case RENDERPATH_SOFT:
4528                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4529                 DPSOFTRAST_SetColorPointer(color4f, sizeof(float[4]));
4530                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), texcoord2f);
4531                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(float[2]), NULL);
4532                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(float[2]), NULL);
4533                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(float[2]), NULL);
4534                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), NULL);
4535                 return;
4536         }
4537
4538         // no quick path for this case, convert to vertex structs
4539         vertex = R_Mesh_PrepareVertices_Generic_Lock(numvertices);
4540         for (i = 0;i < numvertices;i++)
4541                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
4542         if (color4f)
4543         {
4544                 for (i = 0;i < numvertices;i++)
4545                         Vector4Copy(color4f + 4*i, vertex[i].color4f);
4546         }
4547         else
4548         {
4549                 for (i = 0;i < numvertices;i++)
4550                         Vector4Copy(gl_state.color4f, vertex[i].color4f);
4551         }
4552         if (texcoord2f)
4553                 for (i = 0;i < numvertices;i++)
4554                         Vector2Copy(texcoord2f + 2*i, vertex[i].texcoord2f);
4555         R_Mesh_PrepareVertices_Generic_Unlock();
4556         R_Mesh_PrepareVertices_Generic(numvertices, vertex, NULL, 0);
4557 }
4558
4559 void R_Mesh_PrepareVertices_Generic(int numvertices, const r_vertexgeneric_t *vertex, const r_meshbuffer_t *vertexbuffer, int bufferoffset)
4560 {
4561         // upload temporary vertexbuffer for this rendering
4562         if (!gl_state.usevbo_staticvertex)
4563                 vertexbuffer = NULL;
4564         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4565                 vertexbuffer = R_BufferData_Store(numvertices * sizeof(*vertex), (void *)vertex, R_BUFFERDATA_VERTEX, &bufferoffset);
4566         switch(vid.renderpath)
4567         {
4568         case RENDERPATH_GL20:
4569         case RENDERPATH_GLES2:
4570                 if (vertexbuffer)
4571                 {
4572                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4573                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4574                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4575                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4576                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4577                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4578                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4579                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4580                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4581                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4582                 }
4583                 else
4584                 {
4585                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4586                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4587                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4588                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4589                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4590                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4591                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4592                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4593                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4594                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4595                 }
4596                 break;
4597         case RENDERPATH_GL13:
4598         case RENDERPATH_GLES1:
4599                 if (vertexbuffer)
4600                 {
4601                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4602                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4603                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4604                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4605                 }
4606                 else
4607                 {
4608                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4609                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4610                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4611                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4612                 }
4613                 break;
4614         case RENDERPATH_GL11:
4615                 if (vertexbuffer)
4616                 {
4617                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4618                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4619                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4620                 }
4621                 else
4622                 {
4623                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4624                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4625                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4626                 }
4627                 break;
4628         case RENDERPATH_D3D9:
4629 #ifdef SUPPORTD3D
4630                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertexgeneric_d3d9decl);
4631                 if (vertexbuffer)
4632                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, bufferoffset, sizeof(*vertex));
4633                 else
4634                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4635                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4636                 gl_state.d3dvertexdata = (void *)vertex;
4637                 gl_state.d3dvertexsize = sizeof(*vertex);
4638 #endif
4639                 break;
4640         case RENDERPATH_D3D10:
4641                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4642                 break;
4643         case RENDERPATH_D3D11:
4644                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4645                 break;
4646         case RENDERPATH_SOFT:
4647                 DPSOFTRAST_SetVertexPointer(vertex->vertex3f, sizeof(*vertex));
4648                 DPSOFTRAST_SetColorPointer(vertex->color4f, sizeof(*vertex));
4649                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(*vertex), vertex->texcoord2f);
4650                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(*vertex), NULL);
4651                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(*vertex), NULL);
4652                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(*vertex), NULL);
4653                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(*vertex), NULL);
4654                 break;
4655         }
4656 }
4657
4658
4659
4660 r_vertexmesh_t *R_Mesh_PrepareVertices_Mesh_Lock(int numvertices)
4661 {
4662         size_t size;
4663         size = sizeof(r_vertexmesh_t) * numvertices;
4664         if (gl_state.preparevertices_tempdatamaxsize < size)
4665         {
4666                 gl_state.preparevertices_tempdatamaxsize = size;
4667                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
4668         }
4669         gl_state.preparevertices_vertexmesh = (r_vertexmesh_t *)gl_state.preparevertices_tempdata;
4670         gl_state.preparevertices_numvertices = numvertices;
4671         return gl_state.preparevertices_vertexmesh;
4672 }
4673
4674 qboolean R_Mesh_PrepareVertices_Mesh_Unlock(void)
4675 {
4676         R_Mesh_PrepareVertices_Mesh(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexmesh, NULL, 0);
4677         gl_state.preparevertices_vertexmesh = NULL;
4678         gl_state.preparevertices_numvertices = 0;
4679         return true;
4680 }
4681
4682 void R_Mesh_PrepareVertices_Mesh_Arrays(int numvertices, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const float *color4f, const float *texcoordtexture2f, const float *texcoordlightmap2f)
4683 {
4684         int i;
4685         r_vertexmesh_t *vertex;
4686         switch(vid.renderpath)
4687         {
4688         case RENDERPATH_GL20:
4689         case RENDERPATH_GLES2:
4690                 if (gl_state.usevbo_dynamicvertex)
4691                 {
4692                         r_meshbuffer_t *buffer_vertex3f = NULL;
4693                         r_meshbuffer_t *buffer_color4f = NULL;
4694                         r_meshbuffer_t *buffer_texcoordtexture2f = NULL;
4695                         r_meshbuffer_t *buffer_svector3f = NULL;
4696                         r_meshbuffer_t *buffer_tvector3f = NULL;
4697                         r_meshbuffer_t *buffer_normal3f = NULL;
4698                         r_meshbuffer_t *buffer_texcoordlightmap2f = NULL;
4699                         int bufferoffset_vertex3f = 0;
4700                         int bufferoffset_color4f = 0;
4701                         int bufferoffset_texcoordtexture2f = 0;
4702                         int bufferoffset_svector3f = 0;
4703                         int bufferoffset_tvector3f = 0;
4704                         int bufferoffset_normal3f = 0;
4705                         int bufferoffset_texcoordlightmap2f = 0;
4706                         buffer_color4f            = R_BufferData_Store(numvertices * sizeof(float[4]), color4f           , R_BUFFERDATA_VERTEX, &bufferoffset_color4f           );
4707                         buffer_vertex3f           = R_BufferData_Store(numvertices * sizeof(float[3]), vertex3f          , R_BUFFERDATA_VERTEX, &bufferoffset_vertex3f          );
4708                         buffer_svector3f          = R_BufferData_Store(numvertices * sizeof(float[3]), svector3f         , R_BUFFERDATA_VERTEX, &bufferoffset_svector3f         );
4709                         buffer_tvector3f          = R_BufferData_Store(numvertices * sizeof(float[3]), tvector3f         , R_BUFFERDATA_VERTEX, &bufferoffset_tvector3f         );
4710                         buffer_normal3f           = R_BufferData_Store(numvertices * sizeof(float[3]), normal3f          , R_BUFFERDATA_VERTEX, &bufferoffset_normal3f          );
4711                         buffer_texcoordtexture2f  = R_BufferData_Store(numvertices * sizeof(float[2]), texcoordtexture2f , R_BUFFERDATA_VERTEX, &bufferoffset_texcoordtexture2f );
4712                         buffer_texcoordlightmap2f = R_BufferData_Store(numvertices * sizeof(float[2]), texcoordlightmap2f, R_BUFFERDATA_VERTEX, &bufferoffset_texcoordlightmap2f);
4713                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(float[3])        , vertex3f          , buffer_vertex3f          , bufferoffset_vertex3f          );
4714                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(float[4])        , color4f           , buffer_color4f           , bufferoffset_color4f           );
4715                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(float[2])        , texcoordtexture2f , buffer_texcoordtexture2f , bufferoffset_texcoordtexture2f );
4716                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(float[3])        , svector3f         , buffer_svector3f         , bufferoffset_svector3f         );
4717                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(float[3])        , tvector3f         , buffer_tvector3f         , bufferoffset_tvector3f         );
4718                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(float[3])        , normal3f          , buffer_normal3f          , bufferoffset_normal3f          );
4719                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(float[2])        , texcoordlightmap2f, buffer_texcoordlightmap2f, bufferoffset_texcoordlightmap2f);
4720                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT        , sizeof(float[2])        , NULL              , NULL                     , 0                              );
4721                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL              , NULL                     , 0                              );
4722                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL              , NULL                     , 0                              );
4723                 }
4724                 else if (!vid.useinterleavedarrays)
4725                 {
4726                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4727                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4728                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
4729                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), svector3f, NULL, 0);
4730                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), tvector3f, NULL, 0);
4731                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), normal3f, NULL, 0);
4732                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
4733                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4734                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4735                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), NULL, NULL, 0);
4736                         return;
4737                 }
4738                 break;
4739         case RENDERPATH_GL11:
4740         case RENDERPATH_GL13:
4741         case RENDERPATH_GLES1:
4742                 if (!vid.useinterleavedarrays)
4743                 {
4744                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4745                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4746                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
4747                         if (vid.texunits >= 2)
4748                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
4749                         if (vid.texunits >= 3)
4750                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4751                         return;
4752                 }
4753                 break;
4754         case RENDERPATH_D3D9:
4755         case RENDERPATH_D3D10:
4756         case RENDERPATH_D3D11:
4757                 break;
4758         case RENDERPATH_SOFT:
4759                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4760                 DPSOFTRAST_SetColorPointer(color4f, sizeof(float[4]));
4761                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), texcoordtexture2f);
4762                 DPSOFTRAST_SetTexCoordPointer(1, 3, sizeof(float[3]), svector3f);
4763                 DPSOFTRAST_SetTexCoordPointer(2, 3, sizeof(float[3]), tvector3f);
4764                 DPSOFTRAST_SetTexCoordPointer(3, 3, sizeof(float[3]), normal3f);
4765                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), texcoordlightmap2f);
4766                 return;
4767         }
4768
4769         vertex = R_Mesh_PrepareVertices_Mesh_Lock(numvertices);
4770         for (i = 0;i < numvertices;i++)
4771                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
4772         if (svector3f)
4773                 for (i = 0;i < numvertices;i++)
4774                         VectorCopy(svector3f + 3*i, vertex[i].svector3f);
4775         if (tvector3f)
4776                 for (i = 0;i < numvertices;i++)
4777                         VectorCopy(tvector3f + 3*i, vertex[i].tvector3f);
4778         if (normal3f)
4779                 for (i = 0;i < numvertices;i++)
4780                         VectorCopy(normal3f + 3*i, vertex[i].normal3f);
4781         if (color4f)
4782         {
4783                 for (i = 0;i < numvertices;i++)
4784                         Vector4Copy(color4f + 4*i, vertex[i].color4f);
4785         }
4786         else
4787         {
4788                 for (i = 0;i < numvertices;i++)
4789                         Vector4Copy(gl_state.color4f, vertex[i].color4f);
4790         }
4791         if (texcoordtexture2f)
4792                 for (i = 0;i < numvertices;i++)
4793                         Vector2Copy(texcoordtexture2f + 2*i, vertex[i].texcoordtexture2f);
4794         if (texcoordlightmap2f)
4795                 for (i = 0;i < numvertices;i++)
4796                         Vector2Copy(texcoordlightmap2f + 2*i, vertex[i].texcoordlightmap2f);
4797         R_Mesh_PrepareVertices_Mesh_Unlock();
4798         R_Mesh_PrepareVertices_Mesh(numvertices, vertex, NULL, 0);
4799 }
4800
4801 void R_Mesh_PrepareVertices_Mesh(int numvertices, const r_vertexmesh_t *vertex, const r_meshbuffer_t *vertexbuffer, int bufferoffset)
4802 {
4803         // upload temporary vertexbuffer for this rendering
4804         if (!gl_state.usevbo_staticvertex)
4805                 vertexbuffer = NULL;
4806         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4807                 vertexbuffer = R_BufferData_Store(numvertices * sizeof(*vertex), (void *)vertex, R_BUFFERDATA_VERTEX, &bufferoffset);
4808         switch(vid.renderpath)
4809         {
4810         case RENDERPATH_GL20:
4811         case RENDERPATH_GLES2:
4812                 if (vertexbuffer)
4813                 {
4814                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4815                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4816                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4817                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->svector3f          - (unsigned char *)vertex));
4818                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->tvector3f          - (unsigned char *)vertex));
4819                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->normal3f           - (unsigned char *)vertex));
4820                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
4821                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT        , sizeof(*vertex), NULL, NULL, 0);
4822                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE | 0x80000000, sizeof(*vertex), vertex->skeletalindex4ub  , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->skeletalindex4ub   - (unsigned char *)vertex));
4823                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->skeletalweight4ub , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->skeletalweight4ub  - (unsigned char *)vertex));
4824                 }
4825                 else
4826                 {
4827                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4828                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4829                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4830                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , NULL, 0);
4831                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , NULL, 0);
4832                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , NULL, 0);
4833                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
4834                         R_Mesh_TexCoordPointer(5, 2, GL_FLOAT        , sizeof(*vertex), NULL, NULL, 0);
4835                         R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE | 0x80000000, sizeof(*vertex), vertex->skeletalindex4ub  , NULL, 0);
4836                         R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->skeletalweight4ub , NULL, 0);
4837                 }
4838                 break;
4839         case RENDERPATH_GL13:
4840         case RENDERPATH_GLES1:
4841                 if (vertexbuffer)
4842                 {
4843                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4844                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4845                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4846                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
4847                 }
4848                 else
4849                 {
4850                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4851                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4852                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4853                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
4854                 }
4855                 break;
4856         case RENDERPATH_GL11:
4857                 if (vertexbuffer)
4858                 {
4859                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4860                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4861                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, bufferoffset + (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4862                 }
4863                 else
4864                 {
4865                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4866                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4867                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4868                 }
4869                 break;
4870         case RENDERPATH_D3D9:
4871 #ifdef SUPPORTD3D
4872                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertexmesh_d3d9decl);
4873                 if (vertexbuffer)
4874                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, bufferoffset, sizeof(*vertex));
4875                 else
4876                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4877                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4878                 gl_state.d3dvertexdata = (void *)vertex;
4879                 gl_state.d3dvertexsize = sizeof(*vertex);
4880 #endif
4881                 break;
4882         case RENDERPATH_D3D10:
4883                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4884                 break;
4885         case RENDERPATH_D3D11:
4886                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4887                 break;
4888         case RENDERPATH_SOFT:
4889                 DPSOFTRAST_SetVertexPointer(vertex->vertex3f, sizeof(*vertex));
4890                 DPSOFTRAST_SetColorPointer(vertex->color4f, sizeof(*vertex));
4891                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(*vertex), vertex->texcoordtexture2f);
4892                 DPSOFTRAST_SetTexCoordPointer(1, 3, sizeof(*vertex), vertex->svector3f);
4893                 DPSOFTRAST_SetTexCoordPointer(2, 3, sizeof(*vertex), vertex->tvector3f);
4894                 DPSOFTRAST_SetTexCoordPointer(3, 3, sizeof(*vertex), vertex->normal3f);
4895                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(*vertex), vertex->texcoordlightmap2f);
4896                 break;
4897         }
4898 }
4899
4900 void GL_BlendEquationSubtract(qboolean negated)
4901 {
4902         if(negated)
4903         {
4904                 switch(vid.renderpath)
4905                 {
4906                 case RENDERPATH_GL11:
4907                 case RENDERPATH_GL13:
4908                 case RENDERPATH_GL20:
4909                 case RENDERPATH_GLES1:
4910                 case RENDERPATH_GLES2:
4911                         qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT);
4912                         break;
4913                 case RENDERPATH_D3D9:
4914 #ifdef SUPPORTD3D
4915                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
4916 #endif
4917                         break;
4918                 case RENDERPATH_D3D10:
4919                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4920                         break;
4921                 case RENDERPATH_D3D11:
4922                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4923                         break;
4924                 case RENDERPATH_SOFT:
4925                         DPSOFTRAST_BlendSubtract(true);
4926                         break;
4927                 }
4928         }
4929         else
4930         {
4931                 switch(vid.renderpath)
4932                 {
4933                 case RENDERPATH_GL11:
4934                 case RENDERPATH_GL13:
4935                 case RENDERPATH_GL20:
4936                 case RENDERPATH_GLES1:
4937                 case RENDERPATH_GLES2:
4938                         qglBlendEquationEXT(GL_FUNC_ADD);
4939                         break;
4940                 case RENDERPATH_D3D9:
4941 #ifdef SUPPORTD3D
4942                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
4943 #endif
4944                         break;
4945                 case RENDERPATH_D3D10:
4946                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4947                         break;
4948                 case RENDERPATH_D3D11:
4949                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4950                         break;
4951                 case RENDERPATH_SOFT:
4952                         DPSOFTRAST_BlendSubtract(false);
4953                         break;
4954                 }
4955         }
4956 }