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