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