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.ext_framebuffer_object)
1263                 {
1264                         int temp;
1265                         GLuint status;
1266                         qglGenFramebuffersEXT(1, (GLuint*)&temp);CHECKGLERROR
1267                         R_Mesh_SetRenderTargets(temp, NULL, NULL, NULL, NULL, NULL);
1268                         if (depthtexture  && depthtexture->texnum ) qglFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR
1269                 //      if (depthtexture  && depthtexture->texnum ) qglFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, depthtexture->gltexturetypeenum , depthtexture->texnum , 0);CHECKGLERROR
1270                         if (colortexture  && colortexture->texnum ) qglFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , colortexture->gltexturetypeenum , colortexture->texnum , 0);CHECKGLERROR
1271                         if (colortexture2 && colortexture2->texnum) qglFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , colortexture2->gltexturetypeenum, colortexture2->texnum, 0);CHECKGLERROR
1272                         if (colortexture3 && colortexture3->texnum) qglFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , colortexture3->gltexturetypeenum, colortexture3->texnum, 0);CHECKGLERROR
1273                         if (colortexture4 && colortexture4->texnum) qglFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , colortexture4->gltexturetypeenum, colortexture4->texnum, 0);CHECKGLERROR
1274                         if (depthtexture  && depthtexture->renderbuffernum ) qglFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT  , GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR
1275                         if (depthtexture  && depthtexture->renderbuffernum ) qglFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depthtexture->renderbuffernum );CHECKGLERROR
1276                         if (colortexture  && colortexture->renderbuffernum ) qglFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 , GL_RENDERBUFFER, colortexture->renderbuffernum );CHECKGLERROR
1277                         if (colortexture2 && colortexture2->renderbuffernum) qglFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1 , GL_RENDERBUFFER, colortexture2->renderbuffernum);CHECKGLERROR
1278                         if (colortexture3 && colortexture3->renderbuffernum) qglFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2 , GL_RENDERBUFFER, colortexture3->renderbuffernum);CHECKGLERROR
1279                         if (colortexture4 && colortexture4->renderbuffernum) qglFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3 , GL_RENDERBUFFER, colortexture4->renderbuffernum);CHECKGLERROR
1280
1281                         if (colortexture4 && qglDrawBuffersARB)
1282                         {
1283                                 qglDrawBuffersARB(4, drawbuffers);CHECKGLERROR
1284                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1285                         }
1286                         else if (colortexture3 && qglDrawBuffersARB)
1287                         {
1288                                 qglDrawBuffersARB(3, drawbuffers);CHECKGLERROR
1289                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1290                         }
1291                         else if (colortexture2 && qglDrawBuffersARB)
1292                         {
1293                                 qglDrawBuffersARB(2, drawbuffers);CHECKGLERROR
1294                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1295                         }
1296                         else if (colortexture && qglDrawBuffer)
1297                         {
1298                                 qglDrawBuffer(drawbuffers[0]);CHECKGLERROR
1299                                 qglReadBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR
1300                         }
1301                         else if (qglDrawBuffer)
1302                         {
1303                                 qglDrawBuffer(GL_NONE);CHECKGLERROR
1304                                 qglReadBuffer(GL_NONE);CHECKGLERROR
1305                         }
1306                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER);CHECKGLERROR
1307                         if (status != GL_FRAMEBUFFER_COMPLETE)
1308                         {
1309                                 Con_Printf("R_Mesh_CreateFramebufferObject: glCheckFramebufferStatusEXT returned %i\n", status);
1310                                 qglDeleteFramebuffersEXT(1, (GLuint*)&temp);
1311                                 temp = 0;
1312                         }
1313                         return temp;
1314                 }
1315                 return 0;
1316         case RENDERPATH_D3D9:
1317         case RENDERPATH_D3D10:
1318         case RENDERPATH_D3D11:
1319                 return 1;
1320         case RENDERPATH_SOFT:
1321                 return 1;
1322         }
1323         return 0;
1324 }
1325
1326 void R_Mesh_DestroyFramebufferObject(int fbo)
1327 {
1328         switch(vid.renderpath)
1329         {
1330         case RENDERPATH_GL11:
1331         case RENDERPATH_GL13:
1332         case RENDERPATH_GL20:
1333         case RENDERPATH_GLES1:
1334         case RENDERPATH_GLES2:
1335                 if (fbo)
1336                         qglDeleteFramebuffersEXT(1, (GLuint*)&fbo);
1337                 break;
1338         case RENDERPATH_D3D9:
1339         case RENDERPATH_D3D10:
1340         case RENDERPATH_D3D11:
1341                 break;
1342         case RENDERPATH_SOFT:
1343                 break;
1344         }
1345 }
1346
1347 #ifdef SUPPORTD3D
1348 void R_Mesh_SetRenderTargetsD3D9(IDirect3DSurface9 *depthsurface, IDirect3DSurface9 *colorsurface0, IDirect3DSurface9 *colorsurface1, IDirect3DSurface9 *colorsurface2, IDirect3DSurface9 *colorsurface3)
1349 {
1350         gl_state.framebufferobject = depthsurface != gl_state.d3drt_backbufferdepthsurface || colorsurface0 != gl_state.d3drt_backbuffercolorsurface;
1351         if (gl_state.d3drt_depthsurface != depthsurface)
1352         {
1353                 gl_state.d3drt_depthsurface = depthsurface;
1354                 IDirect3DDevice9_SetDepthStencilSurface(vid_d3d9dev, gl_state.d3drt_depthsurface);
1355         }
1356         if (gl_state.d3drt_colorsurfaces[0] != colorsurface0)
1357         {
1358                 gl_state.d3drt_colorsurfaces[0] = colorsurface0;
1359                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 0, gl_state.d3drt_colorsurfaces[0]);
1360         }
1361         if (gl_state.d3drt_colorsurfaces[1] != colorsurface1)
1362         {
1363                 gl_state.d3drt_colorsurfaces[1] = colorsurface1;
1364                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 1, gl_state.d3drt_colorsurfaces[1]);
1365         }
1366         if (gl_state.d3drt_colorsurfaces[2] != colorsurface2)
1367         {
1368                 gl_state.d3drt_colorsurfaces[2] = colorsurface2;
1369                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 2, gl_state.d3drt_colorsurfaces[2]);
1370         }
1371         if (gl_state.d3drt_colorsurfaces[3] != colorsurface3)
1372         {
1373                 gl_state.d3drt_colorsurfaces[3] = colorsurface3;
1374                 IDirect3DDevice9_SetRenderTarget(vid_d3d9dev, 3, gl_state.d3drt_colorsurfaces[3]);
1375         }
1376 }
1377 #endif
1378
1379 void R_Mesh_SetRenderTargets(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, rtexture_t *colortexture2, rtexture_t *colortexture3, rtexture_t *colortexture4)
1380 {
1381         unsigned int i;
1382         unsigned int j;
1383         rtexture_t *textures[5];
1384         Vector4Set(textures, colortexture, colortexture2, colortexture3, colortexture4);
1385         textures[4] = depthtexture;
1386         // unbind any matching textures immediately, otherwise D3D will complain about a bound texture being used as a render target
1387         for (j = 0;j < 5;j++)
1388                 if (textures[j])
1389                         for (i = 0;i < vid.teximageunits;i++)
1390                                 if (gl_state.units[i].texture == textures[j])
1391                                         R_Mesh_TexBind(i, NULL);
1392         // set up framebuffer object or render targets for the active rendering API
1393         switch(vid.renderpath)
1394         {
1395         case RENDERPATH_GL11:
1396         case RENDERPATH_GL13:
1397         case RENDERPATH_GL20:
1398         case RENDERPATH_GLES1:
1399         case RENDERPATH_GLES2:
1400                 if (gl_state.framebufferobject != fbo)
1401                 {
1402                         gl_state.framebufferobject = fbo;
1403                         qglBindFramebufferEXT(GL_FRAMEBUFFER, gl_state.framebufferobject ? gl_state.framebufferobject : gl_state.defaultframebufferobject);
1404                 }
1405                 break;
1406         case RENDERPATH_D3D9:
1407 #ifdef SUPPORTD3D
1408                 // set up the new render targets, a NULL depthtexture intentionally binds nothing
1409                 // TODO: optimize: keep surface pointer around in rtexture_t until texture is freed or lost
1410                 if (fbo)
1411                 {
1412                         IDirect3DSurface9 *surfaces[5];
1413                         for (i = 0;i < 5;i++)
1414                         {
1415                                 surfaces[i] = NULL;
1416                                 if (textures[i])
1417                                 {
1418                                         if (textures[i]->d3dsurface)
1419                                                 surfaces[i] = (IDirect3DSurface9 *)textures[i]->d3dsurface;
1420                                         else
1421                                                 IDirect3DTexture9_GetSurfaceLevel((IDirect3DTexture9 *)textures[i]->d3dtexture, 0, &surfaces[i]);
1422                                 }
1423                         }
1424                         // set the render targets for real
1425                         R_Mesh_SetRenderTargetsD3D9(surfaces[4], surfaces[0], surfaces[1], surfaces[2], surfaces[3]);
1426                         // release the texture surface levels (they won't be lost while bound...)
1427                         for (i = 0;i < 5;i++)
1428                                 if (textures[i] && !textures[i]->d3dsurface)
1429                                         IDirect3DSurface9_Release(surfaces[i]);
1430                 }
1431                 else
1432                         R_Mesh_SetRenderTargetsD3D9(gl_state.d3drt_backbufferdepthsurface, gl_state.d3drt_backbuffercolorsurface, NULL, NULL, NULL);
1433 #endif
1434                 break;
1435         case RENDERPATH_D3D10:
1436                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1437                 break;
1438         case RENDERPATH_D3D11:
1439                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1440                 break;
1441         case RENDERPATH_SOFT:
1442                 if (fbo)
1443                 {
1444                         int width, height;
1445                         unsigned int *pointers[5];
1446                         memset(pointers, 0, sizeof(pointers));
1447                         for (i = 0;i < 5;i++)
1448                                 pointers[i] = textures[i] ? (unsigned int *)DPSOFTRAST_Texture_GetPixelPointer(textures[i]->texnum, 0) : NULL;
1449                         width = DPSOFTRAST_Texture_GetWidth(textures[0] ? textures[0]->texnum : textures[4]->texnum, 0);
1450                         height = DPSOFTRAST_Texture_GetHeight(textures[0] ? textures[0]->texnum : textures[4]->texnum, 0);
1451                         DPSOFTRAST_SetRenderTargets(width, height, pointers[4], pointers[0], pointers[1], pointers[2], pointers[3]);
1452                 }
1453                 else
1454                         DPSOFTRAST_SetRenderTargets(vid.width, vid.height, vid.softdepthpixels, vid.softpixels, NULL, NULL, NULL);
1455                 break;
1456         }
1457 }
1458
1459 #ifdef SUPPORTD3D
1460 static int d3dcmpforglfunc(int f)
1461 {
1462         switch(f)
1463         {
1464         case GL_NEVER: return D3DCMP_NEVER;
1465         case GL_LESS: return D3DCMP_LESS;
1466         case GL_EQUAL: return D3DCMP_EQUAL;
1467         case GL_LEQUAL: return D3DCMP_LESSEQUAL;
1468         case GL_GREATER: return D3DCMP_GREATER;
1469         case GL_NOTEQUAL: return D3DCMP_NOTEQUAL;
1470         case GL_GEQUAL: return D3DCMP_GREATEREQUAL;
1471         case GL_ALWAYS: return D3DCMP_ALWAYS;
1472         default: Con_DPrintf("Unknown GL_DepthFunc\n");return D3DCMP_ALWAYS;
1473         }
1474 }
1475
1476 static int d3dstencilopforglfunc(int f)
1477 {
1478         switch(f)
1479         {
1480         case GL_KEEP: return D3DSTENCILOP_KEEP;
1481         case GL_INCR: return D3DSTENCILOP_INCR; // note: GL_INCR is clamped, D3DSTENCILOP_INCR wraps
1482         case GL_DECR: return D3DSTENCILOP_DECR; // note: GL_DECR is clamped, D3DSTENCILOP_DECR wraps
1483         default: Con_DPrintf("Unknown GL_StencilFunc\n");return D3DSTENCILOP_KEEP;
1484         }
1485 }
1486 #endif
1487
1488 extern cvar_t r_transparent_alphatocoverage;
1489
1490 static void GL_Backend_ResetState(void)
1491 {
1492         unsigned int i;
1493         gl_state.active = true;
1494         gl_state.depthtest = true;
1495         gl_state.alphatest = false;
1496         gl_state.alphafunc = GL_GEQUAL;
1497         gl_state.alphafuncvalue = 0.5f;
1498         gl_state.alphatocoverage = false;
1499         gl_state.blendfunc1 = GL_ONE;
1500         gl_state.blendfunc2 = GL_ZERO;
1501         gl_state.blend = false;
1502         gl_state.depthmask = GL_TRUE;
1503         gl_state.colormask = 15;
1504         gl_state.color4f[0] = gl_state.color4f[1] = gl_state.color4f[2] = gl_state.color4f[3] = 1;
1505         gl_state.lockrange_first = 0;
1506         gl_state.lockrange_count = 0;
1507         gl_state.cullface = GL_FRONT;
1508         gl_state.cullfaceenable = false;
1509         gl_state.polygonoffset[0] = 0;
1510         gl_state.polygonoffset[1] = 0;
1511         gl_state.framebufferobject = 0;
1512         gl_state.depthfunc = GL_LEQUAL;
1513
1514         switch(vid.renderpath)
1515         {
1516         case RENDERPATH_D3D9:
1517 #ifdef SUPPORTD3D
1518                 {
1519                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_COLORWRITEENABLE, gl_state.colormask);
1520                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_NONE);
1521                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZFUNC, d3dcmpforglfunc(gl_state.depthfunc));
1522                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZENABLE, gl_state.depthtest);
1523                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZWRITEENABLE, gl_state.depthmask);
1524                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SLOPESCALEDEPTHBIAS, gl_state.polygonoffset[0]);
1525                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_DEPTHBIAS, gl_state.polygonoffset[1] * (1.0f / 16777216.0f));
1526                 }
1527 #endif
1528                 break;
1529         case RENDERPATH_D3D10:
1530                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1531                 break;
1532         case RENDERPATH_D3D11:
1533                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1534                 break;
1535         case RENDERPATH_GL11:
1536         case RENDERPATH_GL13:
1537         case RENDERPATH_GLES1:
1538 #ifdef GL_ALPHA_TEST
1539                 CHECKGLERROR
1540
1541                 qglColorMask(1, 1, 1, 1);CHECKGLERROR
1542                 qglAlphaFunc(gl_state.alphafunc, gl_state.alphafuncvalue);CHECKGLERROR
1543                 qglDisable(GL_ALPHA_TEST);CHECKGLERROR
1544                 qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
1545                 qglDisable(GL_BLEND);CHECKGLERROR
1546                 qglCullFace(gl_state.cullface);CHECKGLERROR
1547                 qglDisable(GL_CULL_FACE);CHECKGLERROR
1548                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1549                 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
1550                 qglDepthMask(gl_state.depthmask);CHECKGLERROR
1551                 qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
1552
1553                 if (vid.support.arb_vertex_buffer_object)
1554                 {
1555                         qglBindBufferARB(GL_ARRAY_BUFFER, 0);
1556                         qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
1557                 }
1558
1559                 if (vid.support.ext_framebuffer_object)
1560                 {
1561                         //qglBindRenderbufferEXT(GL_RENDERBUFFER, 0);
1562                         qglBindFramebufferEXT(GL_FRAMEBUFFER, 0);
1563                 }
1564
1565                 qglVertexPointer(3, GL_FLOAT, sizeof(float[3]), NULL);CHECKGLERROR
1566                 qglEnableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
1567
1568                 qglColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL);CHECKGLERROR
1569                 qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
1570                 qglColor4f(1, 1, 1, 1);CHECKGLERROR
1571
1572                 if (vid.support.ext_framebuffer_object)
1573                         qglBindFramebufferEXT(GL_FRAMEBUFFER, gl_state.framebufferobject);
1574
1575                 gl_state.unit = MAX_TEXTUREUNITS;
1576                 gl_state.clientunit = MAX_TEXTUREUNITS;
1577                 for (i = 0;i < vid.texunits;i++)
1578                 {
1579                         GL_ActiveTexture(i);
1580                         GL_ClientActiveTexture(i);
1581                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
1582                         qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
1583                         if (vid.support.ext_texture_3d)
1584                         {
1585                                 qglDisable(GL_TEXTURE_3D);CHECKGLERROR
1586                                 qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
1587                         }
1588                         if (vid.support.arb_texture_cube_map)
1589                         {
1590                                 qglDisable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
1591                                 qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);CHECKGLERROR
1592                         }
1593                         GL_BindVBO(0);
1594                         qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), NULL);CHECKGLERROR
1595                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
1596                         qglMatrixMode(GL_TEXTURE);CHECKGLERROR
1597                         qglLoadIdentity();CHECKGLERROR
1598                         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
1599                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
1600                 }
1601                 CHECKGLERROR
1602 #endif
1603                 break;
1604         case RENDERPATH_SOFT:
1605                 DPSOFTRAST_ColorMask(1,1,1,1);
1606                 DPSOFTRAST_BlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);
1607                 DPSOFTRAST_CullFace(gl_state.cullface);
1608                 DPSOFTRAST_DepthFunc(gl_state.depthfunc);
1609                 DPSOFTRAST_DepthMask(gl_state.depthmask);
1610                 DPSOFTRAST_PolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
1611                 DPSOFTRAST_SetRenderTargets(vid.width, vid.height, vid.softdepthpixels, vid.softpixels, NULL, NULL, NULL);
1612                 DPSOFTRAST_Viewport(0, 0, vid.width, vid.height);
1613                 break;
1614         case RENDERPATH_GL20:
1615         case RENDERPATH_GLES2:
1616                 CHECKGLERROR
1617                 qglColorMask(1, 1, 1, 1);CHECKGLERROR
1618                 qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
1619                 qglDisable(GL_BLEND);CHECKGLERROR
1620                 qglCullFace(gl_state.cullface);CHECKGLERROR
1621                 qglDisable(GL_CULL_FACE);CHECKGLERROR
1622                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1623                 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
1624                 qglDepthMask(gl_state.depthmask);CHECKGLERROR
1625                 qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
1626                 if (vid.support.arb_vertex_buffer_object)
1627                 {
1628                         qglBindBufferARB(GL_ARRAY_BUFFER, 0);
1629                         qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
1630                 }
1631                 if (vid.support.ext_framebuffer_object)
1632                         qglBindFramebufferEXT(GL_FRAMEBUFFER, gl_state.defaultframebufferobject);
1633                 qglEnableVertexAttribArray(GLSLATTRIB_POSITION);
1634                 qglVertexAttribPointer(GLSLATTRIB_POSITION, 3, GL_FLOAT, false, sizeof(float[3]), NULL);CHECKGLERROR
1635                 qglDisableVertexAttribArray(GLSLATTRIB_COLOR);
1636                 qglVertexAttribPointer(GLSLATTRIB_COLOR, 4, GL_FLOAT, false, sizeof(float[4]), NULL);CHECKGLERROR
1637                 qglVertexAttrib4f(GLSLATTRIB_COLOR, 1, 1, 1, 1);
1638                 gl_state.unit = MAX_TEXTUREUNITS;
1639                 gl_state.clientunit = MAX_TEXTUREUNITS;
1640                 for (i = 0;i < vid.teximageunits;i++)
1641                 {
1642                         GL_ActiveTexture(i);
1643                         qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
1644                         if (vid.support.ext_texture_3d)
1645                         {
1646                                 qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
1647                         }
1648                         if (vid.support.arb_texture_cube_map)
1649                         {
1650                                 qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);CHECKGLERROR
1651                         }
1652                 }
1653                 for (i = 0;i < vid.texarrayunits;i++)
1654                 {
1655                         GL_BindVBO(0);
1656                         qglVertexAttribPointer(i+GLSLATTRIB_TEXCOORD0, 2, GL_FLOAT, false, sizeof(float[2]), NULL);CHECKGLERROR
1657                         qglDisableVertexAttribArray(i+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
1658                 }
1659                 CHECKGLERROR
1660                 break;
1661         }
1662 }
1663
1664 void GL_ActiveTexture(unsigned int num)
1665 {
1666         if (gl_state.unit != num)
1667         {
1668                 gl_state.unit = num;
1669                 switch(vid.renderpath)
1670                 {
1671                 case RENDERPATH_GL11:
1672                 case RENDERPATH_GL13:
1673                 case RENDERPATH_GL20:
1674                 case RENDERPATH_GLES1:
1675                 case RENDERPATH_GLES2:
1676                         if (qglActiveTexture)
1677                         {
1678                                 CHECKGLERROR
1679                                 qglActiveTexture(GL_TEXTURE0 + gl_state.unit);
1680                                 CHECKGLERROR
1681                         }
1682                         break;
1683                 case RENDERPATH_D3D9:
1684                 case RENDERPATH_D3D10:
1685                 case RENDERPATH_D3D11:
1686                         break;
1687                 case RENDERPATH_SOFT:
1688                         break;
1689                 }
1690         }
1691 }
1692
1693 void GL_ClientActiveTexture(unsigned int num)
1694 {
1695         if (gl_state.clientunit != num)
1696         {
1697                 gl_state.clientunit = num;
1698                 switch(vid.renderpath)
1699                 {
1700                 case RENDERPATH_GL11:
1701                 case RENDERPATH_GL13:
1702                 case RENDERPATH_GLES1:
1703                         if (qglActiveTexture)
1704                         {
1705                                 CHECKGLERROR
1706                                 qglClientActiveTexture(GL_TEXTURE0 + gl_state.clientunit);
1707                                 CHECKGLERROR
1708                         }
1709                         break;
1710                 case RENDERPATH_D3D9:
1711                 case RENDERPATH_D3D10:
1712                 case RENDERPATH_D3D11:
1713                         break;
1714                 case RENDERPATH_SOFT:
1715                         break;
1716                 case RENDERPATH_GL20:
1717                 case RENDERPATH_GLES2:
1718                         break;
1719                 }
1720         }
1721 }
1722
1723 void GL_BlendFunc(int blendfunc1, int blendfunc2)
1724 {
1725         if (gl_state.blendfunc1 != blendfunc1 || gl_state.blendfunc2 != blendfunc2)
1726         {
1727                 qboolean blendenable;
1728                 gl_state.blendfunc1 = blendfunc1;
1729                 gl_state.blendfunc2 = blendfunc2;
1730                 blendenable = (gl_state.blendfunc1 != GL_ONE || gl_state.blendfunc2 != GL_ZERO);
1731                 switch(vid.renderpath)
1732                 {
1733                 case RENDERPATH_GL11:
1734                 case RENDERPATH_GL13:
1735                 case RENDERPATH_GL20:
1736                 case RENDERPATH_GLES1:
1737                 case RENDERPATH_GLES2:
1738                         CHECKGLERROR
1739                         qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
1740                         if (gl_state.blend != blendenable)
1741                         {
1742                                 gl_state.blend = blendenable;
1743                                 if (!gl_state.blend)
1744                                 {
1745                                         qglDisable(GL_BLEND);CHECKGLERROR
1746                                 }
1747                                 else
1748                                 {
1749                                         qglEnable(GL_BLEND);CHECKGLERROR
1750                                 }
1751                         }
1752                         break;
1753                 case RENDERPATH_D3D9:
1754 #ifdef SUPPORTD3D
1755                         {
1756                                 int i;
1757                                 int glblendfunc[2];
1758                                 D3DBLEND d3dblendfunc[2];
1759                                 glblendfunc[0] = gl_state.blendfunc1;
1760                                 glblendfunc[1] = gl_state.blendfunc2;
1761                                 for (i = 0;i < 2;i++)
1762                                 {
1763                                         switch(glblendfunc[i])
1764                                         {
1765                                         case GL_ZERO: d3dblendfunc[i] = D3DBLEND_ZERO;break;
1766                                         case GL_ONE: d3dblendfunc[i] = D3DBLEND_ONE;break;
1767                                         case GL_SRC_COLOR: d3dblendfunc[i] = D3DBLEND_SRCCOLOR;break;
1768                                         case GL_ONE_MINUS_SRC_COLOR: d3dblendfunc[i] = D3DBLEND_INVSRCCOLOR;break;
1769                                         case GL_SRC_ALPHA: d3dblendfunc[i] = D3DBLEND_SRCALPHA;break;
1770                                         case GL_ONE_MINUS_SRC_ALPHA: d3dblendfunc[i] = D3DBLEND_INVSRCALPHA;break;
1771                                         case GL_DST_ALPHA: d3dblendfunc[i] = D3DBLEND_DESTALPHA;break;
1772                                         case GL_ONE_MINUS_DST_ALPHA: d3dblendfunc[i] = D3DBLEND_INVDESTALPHA;break;
1773                                         case GL_DST_COLOR: d3dblendfunc[i] = D3DBLEND_DESTCOLOR;break;
1774                                         case GL_ONE_MINUS_DST_COLOR: d3dblendfunc[i] = D3DBLEND_INVDESTCOLOR;break;
1775                                         }
1776                                 }
1777                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SRCBLEND, d3dblendfunc[0]);
1778                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_DESTBLEND, d3dblendfunc[1]);
1779                                 if (gl_state.blend != blendenable)
1780                                 {
1781                                         gl_state.blend = blendenable;
1782                                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ALPHABLENDENABLE, gl_state.blend);
1783                                 }
1784                         }
1785 #endif
1786                         break;
1787                 case RENDERPATH_D3D10:
1788                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1789                         break;
1790                 case RENDERPATH_D3D11:
1791                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1792                         break;
1793                 case RENDERPATH_SOFT:
1794                         DPSOFTRAST_BlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);
1795                         break;
1796                 }
1797         }
1798 }
1799
1800 void GL_DepthMask(int state)
1801 {
1802         if (gl_state.depthmask != state)
1803         {
1804                 gl_state.depthmask = state;
1805                 switch(vid.renderpath)
1806                 {
1807                 case RENDERPATH_GL11:
1808                 case RENDERPATH_GL13:
1809                 case RENDERPATH_GL20:
1810                 case RENDERPATH_GLES1:
1811                 case RENDERPATH_GLES2:
1812                         CHECKGLERROR
1813                         qglDepthMask(gl_state.depthmask);CHECKGLERROR
1814                         break;
1815                 case RENDERPATH_D3D9:
1816 #ifdef SUPPORTD3D
1817                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZWRITEENABLE, gl_state.depthmask);
1818 #endif
1819                         break;
1820                 case RENDERPATH_D3D10:
1821                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1822                         break;
1823                 case RENDERPATH_D3D11:
1824                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1825                         break;
1826                 case RENDERPATH_SOFT:
1827                         DPSOFTRAST_DepthMask(gl_state.depthmask);
1828                         break;
1829                 }
1830         }
1831 }
1832
1833 void GL_DepthTest(int state)
1834 {
1835         if (gl_state.depthtest != state)
1836         {
1837                 gl_state.depthtest = state;
1838                 switch(vid.renderpath)
1839                 {
1840                 case RENDERPATH_GL11:
1841                 case RENDERPATH_GL13:
1842                 case RENDERPATH_GL20:
1843                 case RENDERPATH_GLES1:
1844                 case RENDERPATH_GLES2:
1845                         CHECKGLERROR
1846                         if (gl_state.depthtest)
1847                         {
1848                                 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
1849                         }
1850                         else
1851                         {
1852                                 qglDisable(GL_DEPTH_TEST);CHECKGLERROR
1853                         }
1854                         break;
1855                 case RENDERPATH_D3D9:
1856 #ifdef SUPPORTD3D
1857                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZENABLE, gl_state.depthtest);
1858 #endif
1859                         break;
1860                 case RENDERPATH_D3D10:
1861                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1862                         break;
1863                 case RENDERPATH_D3D11:
1864                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1865                         break;
1866                 case RENDERPATH_SOFT:
1867                         DPSOFTRAST_DepthTest(gl_state.depthtest);
1868                         break;
1869                 }
1870         }
1871 }
1872
1873 void GL_DepthFunc(int state)
1874 {
1875         if (gl_state.depthfunc != state)
1876         {
1877                 gl_state.depthfunc = state;
1878                 switch(vid.renderpath)
1879                 {
1880                 case RENDERPATH_GL11:
1881                 case RENDERPATH_GL13:
1882                 case RENDERPATH_GL20:
1883                 case RENDERPATH_GLES1:
1884                 case RENDERPATH_GLES2:
1885                         CHECKGLERROR
1886                         qglDepthFunc(gl_state.depthfunc);CHECKGLERROR
1887                         break;
1888                 case RENDERPATH_D3D9:
1889 #ifdef SUPPORTD3D
1890                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_ZFUNC, d3dcmpforglfunc(gl_state.depthfunc));
1891 #endif
1892                         break;
1893                 case RENDERPATH_D3D10:
1894                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1895                         break;
1896                 case RENDERPATH_D3D11:
1897                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1898                         break;
1899                 case RENDERPATH_SOFT:
1900                         DPSOFTRAST_DepthFunc(gl_state.depthfunc);
1901                         break;
1902                 }
1903         }
1904 }
1905
1906 void GL_DepthRange(float nearfrac, float farfrac)
1907 {
1908         if (gl_state.depthrange[0] != nearfrac || gl_state.depthrange[1] != farfrac)
1909         {
1910                 gl_state.depthrange[0] = nearfrac;
1911                 gl_state.depthrange[1] = farfrac;
1912                 switch(vid.renderpath)
1913                 {
1914                 case RENDERPATH_GL11:
1915                 case RENDERPATH_GL13:
1916                 case RENDERPATH_GL20:
1917                 case RENDERPATH_GLES1:
1918                 case RENDERPATH_GLES2:
1919 #ifdef USE_GLES2
1920                         qglDepthRangef(gl_state.depthrange[0], gl_state.depthrange[1]);
1921 #else
1922                         qglDepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);
1923 #endif
1924                         break;
1925                 case RENDERPATH_D3D9:
1926 #ifdef SUPPORTD3D
1927                         {
1928                                 D3DVIEWPORT9 d3dviewport;
1929                                 d3dviewport.X = gl_viewport.x;
1930                                 d3dviewport.Y = gl_viewport.y;
1931                                 d3dviewport.Width = gl_viewport.width;
1932                                 d3dviewport.Height = gl_viewport.height;
1933                                 d3dviewport.MinZ = gl_state.depthrange[0];
1934                                 d3dviewport.MaxZ = gl_state.depthrange[1];
1935                                 IDirect3DDevice9_SetViewport(vid_d3d9dev, &d3dviewport);
1936                         }
1937 #endif
1938                         break;
1939                 case RENDERPATH_D3D10:
1940                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1941                         break;
1942                 case RENDERPATH_D3D11:
1943                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1944                         break;
1945                 case RENDERPATH_SOFT:
1946                         DPSOFTRAST_DepthRange(gl_state.depthrange[0], gl_state.depthrange[1]);
1947                         break;
1948                 }
1949         }
1950 }
1951
1952 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)
1953 {
1954         switch (vid.renderpath)
1955         {
1956         case RENDERPATH_GL11:
1957         case RENDERPATH_GL13:
1958         case RENDERPATH_GL20:
1959         case RENDERPATH_GLES1:
1960         case RENDERPATH_GLES2:
1961                 CHECKGLERROR
1962                 if (enable)
1963                 {
1964                         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
1965                 }
1966                 else
1967                 {
1968                         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
1969                 }
1970                 if (vid.support.ati_separate_stencil)
1971                 {
1972                         qglStencilMask(writemask);CHECKGLERROR
1973                         qglStencilOpSeparate(GL_FRONT, frontfail, frontzfail, frontzpass);CHECKGLERROR
1974                         qglStencilOpSeparate(GL_BACK, backfail, backzfail, backzpass);CHECKGLERROR
1975                         qglStencilFuncSeparate(frontcompare, backcompare, comparereference, comparereference);CHECKGLERROR
1976                 }
1977                 else if (vid.support.ext_stencil_two_side)
1978                 {
1979 #ifdef GL_STENCIL_TEST_TWO_SIDE_EXT
1980                         qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
1981                         qglActiveStencilFaceEXT(GL_FRONT);CHECKGLERROR
1982                         qglStencilMask(writemask);CHECKGLERROR
1983                         qglStencilOp(frontfail, frontzfail, frontzpass);CHECKGLERROR
1984                         qglStencilFunc(frontcompare, comparereference, comparemask);CHECKGLERROR
1985                         qglActiveStencilFaceEXT(GL_BACK);CHECKGLERROR
1986                         qglStencilMask(writemask);CHECKGLERROR
1987                         qglStencilOp(backfail, backzfail, backzpass);CHECKGLERROR
1988                         qglStencilFunc(backcompare, comparereference, comparemask);CHECKGLERROR
1989 #endif
1990                 }
1991                 break;
1992         case RENDERPATH_D3D9:
1993 #ifdef SUPPORTD3D
1994                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_TWOSIDEDSTENCILMODE, true);
1995                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILENABLE, enable);
1996                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILWRITEMASK, writemask);
1997                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFAIL, d3dstencilopforglfunc(frontfail));
1998                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILZFAIL, d3dstencilopforglfunc(frontzfail));
1999                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILPASS, d3dstencilopforglfunc(frontzpass));
2000                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFUNC, d3dcmpforglfunc(frontcompare));
2001                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILFAIL, d3dstencilopforglfunc(backfail));
2002                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILZFAIL, d3dstencilopforglfunc(backzfail));
2003                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILPASS, d3dstencilopforglfunc(backzpass));
2004                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILFUNC, d3dcmpforglfunc(backcompare));
2005                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILREF, comparereference);
2006                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILMASK, comparemask);
2007 #endif
2008                 break;
2009         case RENDERPATH_D3D10:
2010                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2011                 break;
2012         case RENDERPATH_D3D11:
2013                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2014                 break;
2015         case RENDERPATH_SOFT:
2016                 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2017                 break;
2018         }
2019 }
2020
2021 void R_SetStencil(qboolean enable, int writemask, int fail, int zfail, int zpass, int compare, int comparereference, int comparemask)
2022 {
2023         switch (vid.renderpath)
2024         {
2025         case RENDERPATH_GL11:
2026         case RENDERPATH_GL13:
2027         case RENDERPATH_GL20:
2028         case RENDERPATH_GLES1:
2029         case RENDERPATH_GLES2:
2030                 CHECKGLERROR
2031                 if (enable)
2032                 {
2033                         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2034                 }
2035                 else
2036                 {
2037                         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2038                 }
2039                 if (vid.support.ext_stencil_two_side)
2040                 {
2041 #ifdef GL_STENCIL_TEST_TWO_SIDE_EXT
2042                         qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2043 #endif
2044                 }
2045                 qglStencilMask(writemask);CHECKGLERROR
2046                 qglStencilOp(fail, zfail, zpass);CHECKGLERROR
2047                 qglStencilFunc(compare, comparereference, comparemask);CHECKGLERROR
2048                 CHECKGLERROR
2049                 break;
2050         case RENDERPATH_D3D9:
2051 #ifdef SUPPORTD3D
2052                 if (vid.support.ati_separate_stencil)
2053                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_TWOSIDEDSTENCILMODE, true);
2054                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILENABLE, enable);
2055                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILWRITEMASK, writemask);
2056                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFAIL, d3dstencilopforglfunc(fail));
2057                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILZFAIL, d3dstencilopforglfunc(zfail));
2058                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILPASS, d3dstencilopforglfunc(zpass));
2059                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFUNC, d3dcmpforglfunc(compare));
2060                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILREF, comparereference);
2061                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILMASK, comparemask);
2062 #endif
2063                 break;
2064         case RENDERPATH_D3D10:
2065                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2066                 break;
2067         case RENDERPATH_D3D11:
2068                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2069                 break;
2070         case RENDERPATH_SOFT:
2071                 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2072                 break;
2073         }
2074 }
2075
2076 void GL_PolygonOffset(float planeoffset, float depthoffset)
2077 {
2078         if (gl_state.polygonoffset[0] != planeoffset || gl_state.polygonoffset[1] != depthoffset)
2079         {
2080                 gl_state.polygonoffset[0] = planeoffset;
2081                 gl_state.polygonoffset[1] = depthoffset;
2082                 switch(vid.renderpath)
2083                 {
2084                 case RENDERPATH_GL11:
2085                 case RENDERPATH_GL13:
2086                 case RENDERPATH_GL20:
2087                 case RENDERPATH_GLES1:
2088                 case RENDERPATH_GLES2:
2089                         qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
2090                         break;
2091                 case RENDERPATH_D3D9:
2092 #ifdef SUPPORTD3D
2093                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SLOPESCALEDEPTHBIAS, gl_state.polygonoffset[0]);
2094                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_DEPTHBIAS, gl_state.polygonoffset[1] * (1.0f / 16777216.0f));
2095 #endif
2096                         break;
2097                 case RENDERPATH_D3D10:
2098                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2099                         break;
2100                 case RENDERPATH_D3D11:
2101                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2102                         break;
2103                 case RENDERPATH_SOFT:
2104                         DPSOFTRAST_PolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
2105                         break;
2106                 }
2107         }
2108 }
2109
2110 void GL_SetMirrorState(qboolean state)
2111 {
2112         if (v_flipped_state != state)
2113         {
2114                 v_flipped_state = state;
2115                 if (gl_state.cullface == GL_BACK)
2116                         gl_state.cullface = GL_FRONT;
2117                 else if (gl_state.cullface == GL_FRONT)
2118                         gl_state.cullface = GL_BACK;
2119                 else
2120                         return;
2121                 switch(vid.renderpath)
2122                 {
2123                 case RENDERPATH_GL11:
2124                 case RENDERPATH_GL13:
2125                 case RENDERPATH_GL20:
2126                 case RENDERPATH_GLES1:
2127                 case RENDERPATH_GLES2:
2128                         qglCullFace(gl_state.cullface);CHECKGLERROR
2129                         break;
2130                 case RENDERPATH_D3D9:
2131 #ifdef SUPPORTD3D
2132                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, gl_state.cullface == GL_FRONT ? D3DCULL_CCW : D3DCULL_CW);
2133 #endif
2134                         break;
2135                 case RENDERPATH_D3D10:
2136                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2137                         break;
2138                 case RENDERPATH_D3D11:
2139                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2140                         break;
2141                 case RENDERPATH_SOFT:
2142                         DPSOFTRAST_CullFace(gl_state.cullface);
2143                         break;
2144                 }
2145         }
2146 }
2147
2148 void GL_CullFace(int state)
2149 {
2150         if(v_flipped_state)
2151         {
2152                 if(state == GL_FRONT)
2153                         state = GL_BACK;
2154                 else if(state == GL_BACK)
2155                         state = GL_FRONT;
2156         }
2157
2158         switch(vid.renderpath)
2159         {
2160         case RENDERPATH_GL11:
2161         case RENDERPATH_GL13:
2162         case RENDERPATH_GL20:
2163         case RENDERPATH_GLES1:
2164         case RENDERPATH_GLES2:
2165                 CHECKGLERROR
2166
2167                 if (state != GL_NONE)
2168                 {
2169                         if (!gl_state.cullfaceenable)
2170                         {
2171                                 gl_state.cullfaceenable = true;
2172                                 qglEnable(GL_CULL_FACE);CHECKGLERROR
2173                         }
2174                         if (gl_state.cullface != state)
2175                         {
2176                                 gl_state.cullface = state;
2177                                 qglCullFace(gl_state.cullface);CHECKGLERROR
2178                         }
2179                 }
2180                 else
2181                 {
2182                         if (gl_state.cullfaceenable)
2183                         {
2184                                 gl_state.cullfaceenable = false;
2185                                 qglDisable(GL_CULL_FACE);CHECKGLERROR
2186                         }
2187                 }
2188                 break;
2189         case RENDERPATH_D3D9:
2190 #ifdef SUPPORTD3D
2191                 if (gl_state.cullface != state)
2192                 {
2193                         gl_state.cullface = state;
2194                         switch(gl_state.cullface)
2195                         {
2196                         case GL_NONE:
2197                                 gl_state.cullfaceenable = false;
2198                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_NONE);
2199                                 break;
2200                         case GL_FRONT:
2201                                 gl_state.cullfaceenable = true;
2202                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_CCW);
2203                                 break;
2204                         case GL_BACK:
2205                                 gl_state.cullfaceenable = true;
2206                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_CW);
2207                                 break;
2208                         }
2209                 }
2210 #endif
2211                 break;
2212         case RENDERPATH_D3D10:
2213                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2214                 break;
2215         case RENDERPATH_D3D11:
2216                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2217                 break;
2218         case RENDERPATH_SOFT:
2219                 if (gl_state.cullface != state)
2220                 {
2221                         gl_state.cullface = state;
2222                         gl_state.cullfaceenable = state != GL_NONE ? true : false;
2223                         DPSOFTRAST_CullFace(gl_state.cullface);
2224                 }
2225                 break;
2226         }
2227 }
2228
2229 void GL_AlphaTest(int state)
2230 {
2231         if (gl_state.alphatest != state)
2232         {
2233                 gl_state.alphatest = state;
2234                 switch(vid.renderpath)
2235                 {
2236                 case RENDERPATH_GL11:
2237                 case RENDERPATH_GL13:
2238                 case RENDERPATH_GLES1:
2239 #ifdef GL_ALPHA_TEST
2240                         // only fixed function uses alpha test, other paths use pixel kill capability in shaders
2241                         CHECKGLERROR
2242                         if (gl_state.alphatest)
2243                         {
2244                                 qglEnable(GL_ALPHA_TEST);CHECKGLERROR
2245                         }
2246                         else
2247                         {
2248                                 qglDisable(GL_ALPHA_TEST);CHECKGLERROR
2249                         }
2250 #endif
2251                         break;
2252                 case RENDERPATH_D3D9:
2253                 case RENDERPATH_D3D10:
2254                 case RENDERPATH_D3D11:
2255                 case RENDERPATH_SOFT:
2256                 case RENDERPATH_GL20:
2257                 case RENDERPATH_GLES2:
2258                         break;
2259                 }
2260         }
2261 }
2262
2263 void GL_AlphaToCoverage(qboolean state)
2264 {
2265         if (gl_state.alphatocoverage != state)
2266         {
2267                 gl_state.alphatocoverage = state;
2268                 switch(vid.renderpath)
2269                 {
2270                 case RENDERPATH_GL11:
2271                 case RENDERPATH_GL13:
2272                 case RENDERPATH_GLES1:
2273                 case RENDERPATH_GLES2:
2274                 case RENDERPATH_D3D9:
2275                 case RENDERPATH_D3D10:
2276                 case RENDERPATH_D3D11:
2277                 case RENDERPATH_SOFT:
2278                         break;
2279                 case RENDERPATH_GL20:
2280 #ifdef GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
2281                         // alpha to coverage turns the alpha value of the pixel into 0%, 25%, 50%, 75% or 100% by masking the multisample fragments accordingly
2282                         CHECKGLERROR
2283                         if (gl_state.alphatocoverage)
2284                         {
2285                                 qglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
2286 //                              qglEnable(GL_MULTISAMPLE_ARB);CHECKGLERROR
2287                         }
2288                         else
2289                         {
2290                                 qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
2291 //                              qglDisable(GL_MULTISAMPLE_ARB);CHECKGLERROR
2292                         }
2293 #endif
2294                         break;
2295                 }
2296         }
2297 }
2298
2299 void GL_ColorMask(int r, int g, int b, int a)
2300 {
2301         // NOTE: this matches D3DCOLORWRITEENABLE_RED, GREEN, BLUE, ALPHA
2302         int state = (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0) | (a ? 8 : 0);
2303         if (gl_state.colormask != state)
2304         {
2305                 gl_state.colormask = state;
2306                 switch(vid.renderpath)
2307                 {
2308                 case RENDERPATH_GL11:
2309                 case RENDERPATH_GL13:
2310                 case RENDERPATH_GL20:
2311                 case RENDERPATH_GLES1:
2312                 case RENDERPATH_GLES2:
2313                         CHECKGLERROR
2314                         qglColorMask((GLboolean)r, (GLboolean)g, (GLboolean)b, (GLboolean)a);CHECKGLERROR
2315                         break;
2316                 case RENDERPATH_D3D9:
2317 #ifdef SUPPORTD3D
2318                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_COLORWRITEENABLE, state);
2319 #endif
2320                         break;
2321                 case RENDERPATH_D3D10:
2322                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2323                         break;
2324                 case RENDERPATH_D3D11:
2325                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2326                         break;
2327                 case RENDERPATH_SOFT:
2328                         DPSOFTRAST_ColorMask(r, g, b, a);
2329                         break;
2330                 }
2331         }
2332 }
2333
2334 void GL_Color(float cr, float cg, float cb, float ca)
2335 {
2336         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)
2337         {
2338                 gl_state.color4f[0] = cr;
2339                 gl_state.color4f[1] = cg;
2340                 gl_state.color4f[2] = cb;
2341                 gl_state.color4f[3] = ca;
2342                 switch(vid.renderpath)
2343                 {
2344                 case RENDERPATH_GL11:
2345                 case RENDERPATH_GL13:
2346                 case RENDERPATH_GLES1:
2347                         CHECKGLERROR
2348                         qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);
2349                         CHECKGLERROR
2350                         break;
2351                 case RENDERPATH_D3D9:
2352                 case RENDERPATH_D3D10:
2353                 case RENDERPATH_D3D11:
2354                         // no equivalent in D3D
2355                         break;
2356                 case RENDERPATH_SOFT:
2357                         DPSOFTRAST_Color4f(cr, cg, cb, ca);
2358                         break;
2359                 case RENDERPATH_GL20:
2360                 case RENDERPATH_GLES2:
2361                         qglVertexAttrib4f(GLSLATTRIB_COLOR, cr, cg, cb, ca);
2362                         break;
2363                 }
2364         }
2365 }
2366
2367 void GL_Scissor (int x, int y, int width, int height)
2368 {
2369         switch(vid.renderpath)
2370         {
2371         case RENDERPATH_GL11:
2372         case RENDERPATH_GL13:
2373         case RENDERPATH_GL20:
2374         case RENDERPATH_GLES1:
2375         case RENDERPATH_GLES2:
2376                 CHECKGLERROR
2377                 qglScissor(x, y,width,height);
2378                 CHECKGLERROR
2379                 break;
2380         case RENDERPATH_D3D9:
2381 #ifdef SUPPORTD3D
2382                 {
2383                         RECT d3drect;
2384                         d3drect.left = x;
2385                         d3drect.top = y;
2386                         d3drect.right = x + width;
2387                         d3drect.bottom = y + height;
2388                         IDirect3DDevice9_SetScissorRect(vid_d3d9dev, &d3drect);
2389                 }
2390 #endif
2391                 break;
2392         case RENDERPATH_D3D10:
2393                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2394                 break;
2395         case RENDERPATH_D3D11:
2396                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2397                 break;
2398         case RENDERPATH_SOFT:
2399                 DPSOFTRAST_Scissor(x, y, width, height);
2400                 break;
2401         }
2402 }
2403
2404 void GL_ScissorTest(int state)
2405 {
2406         if (gl_state.scissortest != state)
2407         {
2408                 gl_state.scissortest = state;
2409                 switch(vid.renderpath)
2410                 {
2411                 case RENDERPATH_GL11:
2412                 case RENDERPATH_GL13:
2413                 case RENDERPATH_GL20:
2414                 case RENDERPATH_GLES1:
2415                 case RENDERPATH_GLES2:
2416                         CHECKGLERROR
2417                         if(gl_state.scissortest)
2418                                 qglEnable(GL_SCISSOR_TEST);
2419                         else
2420                                 qglDisable(GL_SCISSOR_TEST);
2421                         CHECKGLERROR
2422                         break;
2423                 case RENDERPATH_D3D9:
2424 #ifdef SUPPORTD3D
2425                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SCISSORTESTENABLE, gl_state.scissortest);
2426 #endif
2427                         break;
2428                 case RENDERPATH_D3D10:
2429                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2430                         break;
2431                 case RENDERPATH_D3D11:
2432                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2433                         break;
2434                 case RENDERPATH_SOFT:
2435                         DPSOFTRAST_ScissorTest(gl_state.scissortest);
2436                         break;
2437                 }
2438         }
2439 }
2440
2441 void GL_Clear(int mask, const float *colorvalue, float depthvalue, int stencilvalue)
2442 {
2443         static const float blackcolor[4] = {0, 0, 0, 0};
2444         // prevent warnings when trying to clear a buffer that does not exist
2445         if (!colorvalue)
2446                 colorvalue = blackcolor;
2447         if (!vid.stencil)
2448         {
2449                 mask &= ~GL_STENCIL_BUFFER_BIT;
2450                 stencilvalue = 0;
2451         }
2452         switch(vid.renderpath)
2453         {
2454         case RENDERPATH_GL11:
2455         case RENDERPATH_GL13:
2456         case RENDERPATH_GL20:
2457         case RENDERPATH_GLES1:
2458         case RENDERPATH_GLES2:
2459                 CHECKGLERROR
2460                 if (mask & GL_COLOR_BUFFER_BIT)
2461                 {
2462                         qglClearColor(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]);CHECKGLERROR
2463                 }
2464                 if (mask & GL_DEPTH_BUFFER_BIT)
2465                 {
2466 #ifdef USE_GLES2
2467                         qglClearDepthf(depthvalue);CHECKGLERROR
2468 #else
2469                         qglClearDepth(depthvalue);CHECKGLERROR
2470 #endif
2471                 }
2472                 if (mask & GL_STENCIL_BUFFER_BIT)
2473                 {
2474                         qglClearStencil(stencilvalue);CHECKGLERROR
2475                 }
2476                 qglClear(mask);CHECKGLERROR
2477                 break;
2478         case RENDERPATH_D3D9:
2479 #ifdef SUPPORTD3D
2480                 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);
2481 #endif
2482                 break;
2483         case RENDERPATH_D3D10:
2484                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2485                 break;
2486         case RENDERPATH_D3D11:
2487                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2488                 break;
2489         case RENDERPATH_SOFT:
2490                 if (mask & GL_COLOR_BUFFER_BIT)
2491                         DPSOFTRAST_ClearColor(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]);
2492                 if (mask & GL_DEPTH_BUFFER_BIT)
2493                         DPSOFTRAST_ClearDepth(depthvalue);
2494                 break;
2495         }
2496 }
2497
2498 void GL_ReadPixelsBGRA(int x, int y, int width, int height, unsigned char *outpixels)
2499 {
2500         switch(vid.renderpath)
2501         {
2502         case RENDERPATH_GL11:
2503         case RENDERPATH_GL13:
2504         case RENDERPATH_GL20:
2505         case RENDERPATH_GLES1:
2506         case RENDERPATH_GLES2:
2507                 CHECKGLERROR
2508                 qglReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_BYTE, outpixels);CHECKGLERROR
2509                 break;
2510         case RENDERPATH_D3D9:
2511 #ifdef SUPPORTD3D
2512                 {
2513                         // LordHavoc: we can't directly download the backbuffer because it may be
2514                         // multisampled, and it may not be lockable, so we blit it to a lockable
2515                         // surface of the same dimensions (but without multisample) to resolve the
2516                         // multisample buffer to a normal image, and then lock that...
2517                         IDirect3DSurface9 *stretchsurface = NULL;
2518                         if (!FAILED(IDirect3DDevice9_CreateRenderTarget(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &stretchsurface, NULL)))
2519                         {
2520                                 D3DLOCKED_RECT lockedrect;
2521                                 if (!FAILED(IDirect3DDevice9_StretchRect(vid_d3d9dev, gl_state.d3drt_backbuffercolorsurface, NULL, stretchsurface, NULL, D3DTEXF_POINT)))
2522                                 {
2523                                         if (!FAILED(IDirect3DSurface9_LockRect(stretchsurface, &lockedrect, NULL, D3DLOCK_READONLY)))
2524                                         {
2525                                                 int line;
2526                                                 unsigned char *row = (unsigned char *)lockedrect.pBits + x * 4 + lockedrect.Pitch * (vid.height - 1 - y);
2527                                                 for (line = 0;line < height;line++, row -= lockedrect.Pitch)
2528                                                         memcpy(outpixels + line * width * 4, row, width * 4);
2529                                                 IDirect3DSurface9_UnlockRect(stretchsurface);
2530                                         }
2531                                 }
2532                                 IDirect3DSurface9_Release(stretchsurface);
2533                         }
2534                         // code scraps
2535                         //IDirect3DSurface9 *syssurface = NULL;
2536                         //if (!FAILED(IDirect3DDevice9_CreateRenderTarget(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, FALSE, &stretchsurface, NULL)))
2537                         //if (!FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &syssurface, NULL)))
2538                         //IDirect3DDevice9_GetRenderTargetData(vid_d3d9dev, gl_state.d3drt_backbuffercolorsurface, syssurface);
2539                         //if (!FAILED(IDirect3DDevice9_GetFrontBufferData(vid_d3d9dev, 0, syssurface)))
2540                         //if (!FAILED(IDirect3DSurface9_LockRect(syssurface, &lockedrect, NULL, D3DLOCK_READONLY)))
2541                         //IDirect3DSurface9_UnlockRect(syssurface);
2542                         //IDirect3DSurface9_Release(syssurface);
2543                 }
2544 #endif
2545                 break;
2546         case RENDERPATH_D3D10:
2547                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2548                 break;
2549         case RENDERPATH_D3D11:
2550                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2551                 break;
2552         case RENDERPATH_SOFT:
2553                 DPSOFTRAST_GetPixelsBGRA(x, y, width, height, outpixels);
2554                 break;
2555         }
2556 }
2557
2558 // called at beginning of frame
2559 void R_Mesh_Start(void)
2560 {
2561         BACKENDACTIVECHECK
2562         R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL);
2563         R_Mesh_SetUseVBO();
2564         if (gl_printcheckerror.integer && !gl_paranoid.integer)
2565         {
2566                 Con_Printf("WARNING: gl_printcheckerror is on but gl_paranoid is off, turning it on...\n");
2567                 Cvar_SetValueQuick(&gl_paranoid, 1);
2568         }
2569 }
2570
2571 static qboolean GL_Backend_CompileShader(int programobject, GLenum shadertypeenum, const char *shadertype, int numstrings, const char **strings)
2572 {
2573         int shaderobject;
2574         int shadercompiled;
2575         char compilelog[MAX_INPUTLINE];
2576         shaderobject = qglCreateShader(shadertypeenum);CHECKGLERROR
2577         if (!shaderobject)
2578                 return false;
2579         qglShaderSource(shaderobject, numstrings, strings, NULL);CHECKGLERROR
2580         qglCompileShader(shaderobject);CHECKGLERROR
2581         qglGetShaderiv(shaderobject, GL_COMPILE_STATUS, &shadercompiled);CHECKGLERROR
2582         qglGetShaderInfoLog(shaderobject, sizeof(compilelog), NULL, compilelog);CHECKGLERROR
2583         if (compilelog[0] && (strstr(compilelog, "error") || strstr(compilelog, "ERROR") || strstr(compilelog, "Error") || strstr(compilelog, "WARNING") || strstr(compilelog, "warning") || strstr(compilelog, "Warning") || developer_extra.integer))
2584         {
2585                 int i, j, pretextlines = 0;
2586                 for (i = 0;i < numstrings - 1;i++)
2587                         for (j = 0;strings[i][j];j++)
2588                                 if (strings[i][j] == '\n')
2589                                         pretextlines++;
2590                 Con_Printf("%s shader compile log:\n%s\n(line offset for any above warnings/errors: %i)\n", shadertype, compilelog, pretextlines);
2591         }
2592         if (!shadercompiled)
2593         {
2594                 qglDeleteShader(shaderobject);CHECKGLERROR
2595                 return false;
2596         }
2597         qglAttachShader(programobject, shaderobject);CHECKGLERROR
2598         qglDeleteShader(shaderobject);CHECKGLERROR
2599         return true;
2600 }
2601
2602 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)
2603 {
2604         GLint programlinked;
2605         GLuint programobject = 0;
2606         char linklog[MAX_INPUTLINE];
2607         CHECKGLERROR
2608
2609         programobject = qglCreateProgram();CHECKGLERROR
2610         if (!programobject)
2611                 return 0;
2612
2613         qglBindAttribLocation(programobject, GLSLATTRIB_POSITION , "Attrib_Position" );
2614         qglBindAttribLocation(programobject, GLSLATTRIB_COLOR    , "Attrib_Color"    );
2615         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD0, "Attrib_TexCoord0");
2616         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD1, "Attrib_TexCoord1");
2617         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD2, "Attrib_TexCoord2");
2618         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD3, "Attrib_TexCoord3");
2619         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD4, "Attrib_TexCoord4");
2620         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD5, "Attrib_TexCoord5");
2621         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD6, "Attrib_TexCoord6");
2622         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD7, "Attrib_TexCoord7");
2623 #ifndef USE_GLES2
2624         if(vid.support.gl20shaders130)
2625                 qglBindFragDataLocation(programobject, 0, "dp_FragColor");
2626 #endif
2627
2628         if (vertexstrings_count && !GL_Backend_CompileShader(programobject, GL_VERTEX_SHADER, "vertex", vertexstrings_count, vertexstrings_list))
2629                 goto cleanup;
2630
2631 #ifdef GL_GEOMETRY_SHADER
2632         if (geometrystrings_count && !GL_Backend_CompileShader(programobject, GL_GEOMETRY_SHADER, "geometry", geometrystrings_count, geometrystrings_list))
2633                 goto cleanup;
2634 #endif
2635
2636         if (fragmentstrings_count && !GL_Backend_CompileShader(programobject, GL_FRAGMENT_SHADER, "fragment", fragmentstrings_count, fragmentstrings_list))
2637                 goto cleanup;
2638
2639         qglLinkProgram(programobject);CHECKGLERROR
2640         qglGetProgramiv(programobject, GL_LINK_STATUS, &programlinked);CHECKGLERROR
2641         qglGetProgramInfoLog(programobject, sizeof(linklog), NULL, linklog);CHECKGLERROR
2642         if (linklog[0])
2643         {
2644                 if (strstr(linklog, "error") || strstr(linklog, "ERROR") || strstr(linklog, "Error") || strstr(linklog, "WARNING") || strstr(linklog, "warning") || strstr(linklog, "Warning") || developer_extra.integer)
2645                         Con_DPrintf("program link log:\n%s\n", linklog);
2646                 // software vertex shader is ok but software fragment shader is WAY
2647                 // too slow, fail program if so.
2648                 // NOTE: this string might be ATI specific, but that's ok because the
2649                 // ATI R300 chip (Radeon 9500-9800/X300) is the most likely to use a
2650                 // software fragment shader due to low instruction and dependent
2651                 // texture limits.
2652                 if (strstr(linklog, "fragment shader will run in software"))
2653                         programlinked = false;
2654         }
2655         if (!programlinked)
2656                 goto cleanup;
2657         return programobject;
2658 cleanup:
2659         qglDeleteProgram(programobject);CHECKGLERROR
2660         return 0;
2661 }
2662
2663 void GL_Backend_FreeProgram(unsigned int prog)
2664 {
2665         CHECKGLERROR
2666         qglDeleteProgram(prog);
2667         CHECKGLERROR
2668 }
2669
2670 // renders triangles using vertices from the active arrays
2671 int paranoidblah = 0;
2672 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)
2673 {
2674         unsigned int numelements = numtriangles * 3;
2675         int bufferobject3i;
2676         size_t bufferoffset3i;
2677         int bufferobject3s;
2678         size_t bufferoffset3s;
2679         if (numvertices < 3 || numtriangles < 1)
2680         {
2681                 if (numvertices < 0 || numtriangles < 0 || developer_extra.integer)
2682                         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);
2683                 return;
2684         }
2685         if (!gl_mesh_prefer_short_elements.integer)
2686         {
2687                 if (element3i)
2688                         element3s = NULL;
2689                 if (element3i_indexbuffer)
2690                         element3i_indexbuffer = NULL;
2691         }
2692         // adjust the pointers for firsttriangle
2693         if (element3i)
2694                 element3i += firsttriangle * 3;
2695         if (element3i_indexbuffer)
2696                 element3i_bufferoffset += firsttriangle * 3 * sizeof(*element3i);
2697         if (element3s)
2698                 element3s += firsttriangle * 3;
2699         if (element3s_indexbuffer)
2700                 element3s_bufferoffset += firsttriangle * 3 * sizeof(*element3s);
2701         switch(vid.renderpath)
2702         {
2703         case RENDERPATH_GL11:
2704         case RENDERPATH_GL13:
2705         case RENDERPATH_GL20:
2706         case RENDERPATH_GLES1:
2707         case RENDERPATH_GLES2:
2708                 // check if the user specified to ignore static index buffers
2709                 if (!gl_state.usevbo_staticindex || (gl_vbo.integer == 3 && !vid.forcevbo && (element3i_bufferoffset || element3s_bufferoffset)))
2710                 {
2711                         element3i_indexbuffer = NULL;
2712                         element3s_indexbuffer = NULL;
2713                 }
2714                 break;
2715         case RENDERPATH_D3D9:
2716         case RENDERPATH_D3D10:
2717         case RENDERPATH_D3D11:
2718                 break;
2719         case RENDERPATH_SOFT:
2720                 break;
2721         }
2722         // upload a dynamic index buffer if needed
2723         if (element3s)
2724         {
2725                 if (!element3s_indexbuffer && gl_state.usevbo_dynamicindex)
2726                 {
2727                         if (gl_state.draw_dynamicindexbuffer)
2728                                 R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3s, numelements * sizeof(*element3s));
2729                         else
2730                                 gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3s, numelements * sizeof(*element3s), "temporary", true, true, true);
2731                         element3s_indexbuffer = gl_state.draw_dynamicindexbuffer;
2732                         element3s_bufferoffset = 0;
2733                 }
2734         }
2735         else if (element3i)
2736         {
2737                 if (!element3i_indexbuffer && gl_state.usevbo_dynamicindex)
2738                 {
2739                         if (gl_state.draw_dynamicindexbuffer)
2740                                 R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3i, numelements * sizeof(*element3i));
2741                         else
2742                                 gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3i, numelements * sizeof(*element3i), "temporary", true, true, false);
2743                         element3i_indexbuffer = gl_state.draw_dynamicindexbuffer;
2744                         element3i_bufferoffset = 0;
2745                 }
2746         }
2747         bufferobject3i = element3i_indexbuffer ? element3i_indexbuffer->bufferobject : 0;
2748         bufferoffset3i = element3i_bufferoffset;
2749         bufferobject3s = element3s_indexbuffer ? element3s_indexbuffer->bufferobject : 0;
2750         bufferoffset3s = element3s_bufferoffset;
2751         r_refdef.stats.draws++;
2752         r_refdef.stats.draws_vertices += numvertices;
2753         r_refdef.stats.draws_elements += numelements;
2754         if (gl_paranoid.integer)
2755         {
2756                 unsigned int i;
2757                 // LordHavoc: disabled this - it needs to be updated to handle components and gltype and stride in each array
2758 #if 0
2759                 unsigned int j, size;
2760                 const int *p;
2761                 // note: there's no validation done here on buffer objects because it
2762                 // is somewhat difficult to get at the data, and gl_paranoid can be
2763                 // used without buffer objects if the need arises
2764                 // (the data could be gotten using glMapBuffer but it would be very
2765                 //  slow due to uncachable video memory reads)
2766                 if (!qglIsEnabled(GL_VERTEX_ARRAY))
2767                         Con_Print("R_Mesh_Draw: vertex array not enabled\n");
2768                 CHECKGLERROR
2769                 if (gl_state.pointer_vertex_pointer)
2770                         for (j = 0, size = numvertices * 3, p = (int *)((float *)gl_state.pointer_vertex + firstvertex * 3);j < size;j++, p++)
2771                                 paranoidblah += *p;
2772                 if (gl_state.pointer_color_enabled)
2773                 {
2774                         if (!qglIsEnabled(GL_COLOR_ARRAY))
2775                                 Con_Print("R_Mesh_Draw: color array set but not enabled\n");
2776                         CHECKGLERROR
2777                         if (gl_state.pointer_color && gl_state.pointer_color_enabled)
2778                                 for (j = 0, size = numvertices * 4, p = (int *)((float *)gl_state.pointer_color + firstvertex * 4);j < size;j++, p++)
2779                                         paranoidblah += *p;
2780                 }
2781                 for (i = 0;i < vid.texarrayunits;i++)
2782                 {
2783                         if (gl_state.units[i].arrayenabled)
2784                         {
2785                                 GL_ClientActiveTexture(i);
2786                                 if (!qglIsEnabled(GL_TEXTURE_COORD_ARRAY))
2787                                         Con_Print("R_Mesh_Draw: texcoord array set but not enabled\n");
2788                                 CHECKGLERROR
2789                                 if (gl_state.units[i].pointer_texcoord && gl_state.units[i].arrayenabled)
2790                                         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++)
2791                                                 paranoidblah += *p;
2792                         }
2793                 }
2794 #endif
2795                 if (element3i)
2796                 {
2797                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2798                         {
2799                                 if (element3i[i] < firstvertex || element3i[i] >= firstvertex + numvertices)
2800                                 {
2801                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3i array\n", element3i[i], firstvertex, firstvertex + numvertices);
2802                                         return;
2803                                 }
2804                         }
2805                 }
2806                 if (element3s)
2807                 {
2808                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2809                         {
2810                                 if (element3s[i] < firstvertex || element3s[i] >= firstvertex + numvertices)
2811                                 {
2812                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3s array\n", element3s[i], firstvertex, firstvertex + numvertices);
2813                                         return;
2814                                 }
2815                         }
2816                 }
2817         }
2818         if (r_render.integer || r_refdef.draw2dstage)
2819         {
2820                 switch(vid.renderpath)
2821                 {
2822                 case RENDERPATH_GL11:
2823                 case RENDERPATH_GL13:
2824                 case RENDERPATH_GL20:
2825                         CHECKGLERROR
2826                         if (gl_mesh_testmanualfeeding.integer)
2827                         {
2828 #ifndef USE_GLES2
2829                                 unsigned int i, j, element;
2830                                 const GLfloat *p;
2831                                 qglBegin(GL_TRIANGLES);
2832                                 if(vid.renderpath == RENDERPATH_GL20)
2833                                 {
2834                                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2835                                         {
2836                                                 if (element3i)
2837                                                         element = element3i[i];
2838                                                 else if (element3s)
2839                                                         element = element3s[i];
2840                                                 else
2841                                                         element = firstvertex + i;
2842                                                 for (j = 0;j < vid.texarrayunits;j++)
2843                                                 {
2844                                                         if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
2845                                                         {
2846                                                                 if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
2847                                                                 {
2848                                                                         p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2849                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
2850                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2], p[3]);
2851                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
2852                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2]);
2853                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
2854                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1]);
2855                                                                         else
2856                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, p[0]);
2857                                                                 }
2858                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
2859                                                                 {
2860                                                                         const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2861                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
2862                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2], s[3]);
2863                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
2864                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2]);
2865                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
2866                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1]);
2867                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
2868                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, s[0]);
2869                                                                 }
2870                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
2871                                                                 {
2872                                                                         const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2873                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
2874                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2], sb[3]);
2875                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
2876                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2]);
2877                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
2878                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1]);
2879                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
2880                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, sb[0]);
2881                                                                 }
2882                                                         }
2883                                                 }
2884                                                 if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
2885                                                 {
2886                                                         if (gl_state.pointer_color_gltype == GL_FLOAT)
2887                                                         {
2888                                                                 p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
2889                                                                 qglVertexAttrib4f(GLSLATTRIB_COLOR, p[0], p[1], p[2], p[3]);
2890                                                         }
2891                                                         else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
2892                                                         {
2893                                                                 const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
2894                                                                 qglVertexAttrib4Nub(GLSLATTRIB_COLOR, ub[0], ub[1], ub[2], ub[3]);
2895                                                         }
2896                                                 }
2897                                                 if (gl_state.pointer_vertex_gltype == GL_FLOAT)
2898                                                 {
2899                                                         p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
2900                                                         if (gl_state.pointer_vertex_components == 4)
2901                                                                 qglVertexAttrib4f(GLSLATTRIB_POSITION, p[0], p[1], p[2], p[3]);
2902                                                         else if (gl_state.pointer_vertex_components == 3)
2903                                                                 qglVertexAttrib3f(GLSLATTRIB_POSITION, p[0], p[1], p[2]);
2904                                                         else
2905                                                                 qglVertexAttrib2f(GLSLATTRIB_POSITION, p[0], p[1]);
2906                                                 }
2907                                         }
2908                                 }
2909                                 else
2910                                 {
2911                                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2912                                         {
2913                                                 if (element3i)
2914                                                         element = element3i[i];
2915                                                 else if (element3s)
2916                                                         element = element3s[i];
2917                                                 else
2918                                                         element = firstvertex + i;
2919                                                 for (j = 0;j < vid.texarrayunits;j++)
2920                                                 {
2921                                                         if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
2922                                                         {
2923                                                                 if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
2924                                                                 {
2925                                                                         p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2926                                                                         if (vid.texarrayunits > 1)
2927                                                                         {
2928                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2929                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, p[0], p[1], p[2], p[3]);
2930                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2931                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, p[0], p[1], p[2]);
2932                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2933                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, p[0], p[1]);
2934                                                                                 else
2935                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, p[0]);
2936                                                                         }
2937                                                                         else
2938                                                                         {
2939                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2940                                                                                         qglTexCoord4f(p[0], p[1], p[2], p[3]);
2941                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2942                                                                                         qglTexCoord3f(p[0], p[1], p[2]);
2943                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2944                                                                                         qglTexCoord2f(p[0], p[1]);
2945                                                                                 else
2946                                                                                         qglTexCoord1f(p[0]);
2947                                                                         }
2948                                                                 }
2949                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
2950                                                                 {
2951                                                                         const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2952                                                                         if (vid.texarrayunits > 1)
2953                                                                         {
2954                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2955                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, s[0], s[1], s[2], s[3]);
2956                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2957                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, s[0], s[1], s[2]);
2958                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2959                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, s[0], s[1]);
2960                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2961                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, s[0]);
2962                                                                         }
2963                                                                         else
2964                                                                         {
2965                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2966                                                                                         qglTexCoord4f(s[0], s[1], s[2], s[3]);
2967                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2968                                                                                         qglTexCoord3f(s[0], s[1], s[2]);
2969                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2970                                                                                         qglTexCoord2f(s[0], s[1]);
2971                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2972                                                                                         qglTexCoord1f(s[0]);
2973                                                                         }
2974                                                                 }
2975                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
2976                                                                 {
2977                                                                         const GLbyte *sb = (const GLbyte *)((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, sb[0], sb[1], sb[2], sb[3]);
2982                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2983                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, sb[0], sb[1], sb[2]);
2984                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2985                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, sb[0], sb[1]);
2986                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2987                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, sb[0]);
2988                                                                         }
2989                                                                         else
2990                                                                         {
2991                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2992                                                                                         qglTexCoord4f(sb[0], sb[1], sb[2], sb[3]);
2993                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2994                                                                                         qglTexCoord3f(sb[0], sb[1], sb[2]);
2995                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2996                                                                                         qglTexCoord2f(sb[0], sb[1]);
2997                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2998                                                                                         qglTexCoord1f(sb[0]);
2999                                                                         }
3000                                                                 }
3001                                                         }
3002                                                 }
3003                                                 if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
3004                                                 {
3005                                                         if (gl_state.pointer_color_gltype == GL_FLOAT)
3006                                                         {
3007                                                                 p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3008                                                                 qglColor4f(p[0], p[1], p[2], p[3]);
3009                                                         }
3010                                                         else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
3011                                                         {
3012                                                                 const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3013                                                                 qglColor4ub(ub[0], ub[1], ub[2], ub[3]);
3014                                                         }
3015                                                 }
3016                                                 if (gl_state.pointer_vertex_gltype == GL_FLOAT)
3017                                                 {
3018                                                         p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
3019                                                         if (gl_state.pointer_vertex_components == 4)
3020                                                                 qglVertex4f(p[0], p[1], p[2], p[3]);
3021                                                         else if (gl_state.pointer_vertex_components == 3)
3022                                                                 qglVertex3f(p[0], p[1], p[2]);
3023                                                         else
3024                                                                 qglVertex2f(p[0], p[1]);
3025                                                 }
3026                                         }
3027                                 }
3028                                 qglEnd();
3029                                 CHECKGLERROR
3030 #endif
3031                         }
3032                         else if (bufferobject3s)
3033                         {
3034                                 GL_BindEBO(bufferobject3s);
3035 #ifndef USE_GLES2
3036                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3037                                 {
3038                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s);
3039                                         CHECKGLERROR
3040                                 }
3041                                 else
3042 #endif
3043                                 {
3044                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, (void *)(firsttriangle * sizeof(unsigned short[3])));
3045                                         CHECKGLERROR
3046                                 }
3047                         }
3048                         else if (bufferobject3i)
3049                         {
3050                                 GL_BindEBO(bufferobject3i);
3051 #ifndef USE_GLES2
3052                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3053                                 {
3054                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i);
3055                                         CHECKGLERROR
3056                                 }
3057                                 else
3058 #endif
3059                                 {
3060                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, (void *)(firsttriangle * sizeof(unsigned int[3])));
3061                                         CHECKGLERROR
3062                                 }
3063                         }
3064                         else if (element3s)
3065                         {
3066                                 GL_BindEBO(0);
3067 #ifndef USE_GLES2
3068                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3069                                 {
3070                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, element3s);
3071                                         CHECKGLERROR
3072                                 }
3073                                 else
3074 #endif
3075                                 {
3076                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s);
3077                                         CHECKGLERROR
3078                                 }
3079                         }
3080                         else if (element3i)
3081                         {
3082                                 GL_BindEBO(0);
3083 #ifndef USE_GLES2
3084                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3085                                 {
3086                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, element3i);
3087                                         CHECKGLERROR
3088                                 }
3089                                 else
3090 #endif
3091                                 {
3092                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i);
3093                                         CHECKGLERROR
3094                                 }
3095                         }
3096                         else
3097                         {
3098                                 qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);
3099                                 CHECKGLERROR
3100                         }
3101                         break;
3102                 case RENDERPATH_D3D9:
3103 #ifdef SUPPORTD3D
3104                         if (gl_state.d3dvertexbuffer && ((element3s && element3s_indexbuffer) || (element3i && element3i_indexbuffer)))
3105                         {
3106                                 if (element3s_indexbuffer)
3107                                 {
3108                                         IDirect3DDevice9_SetIndices(vid_d3d9dev, (IDirect3DIndexBuffer9 *)element3s_indexbuffer->devicebuffer);
3109                                         IDirect3DDevice9_DrawIndexedPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, 0, firstvertex, numvertices, element3s_bufferoffset>>1, numtriangles);
3110                                 }
3111                                 else if (element3i_indexbuffer)
3112                                 {
3113                                         IDirect3DDevice9_SetIndices(vid_d3d9dev, (IDirect3DIndexBuffer9 *)element3i_indexbuffer->devicebuffer);
3114                                         IDirect3DDevice9_DrawIndexedPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, 0, firstvertex, numvertices, element3i_bufferoffset>>2, numtriangles);
3115                                 }
3116                                 else
3117                                         IDirect3DDevice9_DrawPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices);
3118                         }
3119                         else
3120                         {
3121                                 if (element3s)
3122                                         IDirect3DDevice9_DrawIndexedPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices, numtriangles, element3s, D3DFMT_INDEX16, gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3123                                 else if (element3i)
3124                                         IDirect3DDevice9_DrawIndexedPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices, numtriangles, element3i, D3DFMT_INDEX32, gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3125                                 else
3126                                         IDirect3DDevice9_DrawPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, numvertices, (void *)gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3127                         }
3128 #endif
3129                         break;
3130                 case RENDERPATH_D3D10:
3131                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3132                         break;
3133                 case RENDERPATH_D3D11:
3134                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3135                         break;
3136                 case RENDERPATH_SOFT:
3137                         DPSOFTRAST_DrawTriangles(firstvertex, numvertices, numtriangles, element3i, element3s);
3138                         break;
3139                 case RENDERPATH_GLES1:
3140                 case RENDERPATH_GLES2:
3141                         // GLES does not have glDrawRangeElements, and generally
3142                         // underperforms with index buffers, so this code path is
3143                         // relatively straightforward...
3144 #if 0
3145                         if (gl_paranoid.integer)
3146                         {
3147                                 int r, prog, enabled, i;
3148                                 GLsizei         attriblength;
3149                                 GLint           attribsize;
3150                                 GLenum          attribtype;
3151                                 GLchar          attribname[1024];
3152                                 r = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER);CHECKGLERROR
3153                                 if (r != GL_FRAMEBUFFER_COMPLETE)
3154                                         Con_DPrintf("fbo %i not complete (default %i)\n", gl_state.framebufferobject, gl_state.defaultframebufferobject);
3155 #ifndef GL_CURRENT_PROGRAM
3156 #define GL_CURRENT_PROGRAM 0x8B8D
3157 #endif
3158                                 qglGetIntegerv(GL_CURRENT_PROGRAM, &r);CHECKGLERROR
3159                                 if (r < 0 || r > 10000)
3160                                         Con_DPrintf("GL_CURRENT_PROGRAM = %i\n", r);
3161                                 prog = r;
3162                                 for (i = 0;i < 8;i++)
3163                                 {
3164                                         qglGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &r);CHECKGLERROR
3165                                         if (!r)
3166                                                 continue;
3167                                         qglGetActiveAttrib(prog, i, sizeof(attribname), &attriblength, &attribsize, &attribtype, attribname);CHECKGLERROR
3168                                         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);
3169                                 }
3170                         }
3171 #endif
3172                         if (element3s)
3173                         {
3174                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s);
3175                                 CHECKGLERROR
3176                         }
3177                         else if (element3i)
3178                         {
3179                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i);
3180                                 CHECKGLERROR
3181                         }
3182                         else
3183                         {
3184                                 qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);
3185                                 CHECKGLERROR
3186                         }
3187                         break;
3188                 }
3189         }
3190 }
3191
3192 // restores backend state, used when done with 3D rendering
3193 void R_Mesh_Finish(void)
3194 {
3195         R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL);
3196 }
3197
3198 r_meshbuffer_t *R_Mesh_CreateMeshBuffer(const void *data, size_t size, const char *name, qboolean isindexbuffer, qboolean isdynamic, qboolean isindex16)
3199 {
3200         r_meshbuffer_t *buffer;
3201         if (!(isdynamic ? (isindexbuffer ? gl_state.usevbo_dynamicindex : gl_state.usevbo_dynamicvertex) : (isindexbuffer ? gl_state.usevbo_staticindex : gl_state.usevbo_staticvertex)))
3202                 return NULL;
3203         buffer = (r_meshbuffer_t *)Mem_ExpandableArray_AllocRecord(&gl_state.meshbufferarray);
3204         memset(buffer, 0, sizeof(*buffer));
3205         buffer->bufferobject = 0;
3206         buffer->devicebuffer = NULL;
3207         buffer->size = 0;
3208         buffer->isindexbuffer = isindexbuffer;
3209         buffer->isdynamic = isdynamic;
3210         buffer->isindex16 = isindex16;
3211         strlcpy(buffer->name, name, sizeof(buffer->name));
3212         R_Mesh_UpdateMeshBuffer(buffer, data, size);
3213         return buffer;
3214 }
3215
3216 void R_Mesh_UpdateMeshBuffer(r_meshbuffer_t *buffer, const void *data, size_t size)
3217 {
3218         if (!buffer)
3219                 return;
3220         if (buffer->isindexbuffer)
3221         {
3222                 r_refdef.stats.indexbufferuploadcount++;
3223                 r_refdef.stats.indexbufferuploadsize += size;
3224         }
3225         else
3226         {
3227                 r_refdef.stats.vertexbufferuploadcount++;
3228                 r_refdef.stats.vertexbufferuploadsize += size;
3229         }
3230         switch(vid.renderpath)
3231         {
3232         case RENDERPATH_GL11:
3233         case RENDERPATH_GL13:
3234         case RENDERPATH_GL20:
3235         case RENDERPATH_GLES1:
3236         case RENDERPATH_GLES2:
3237                 if (!buffer->bufferobject)
3238                         qglGenBuffersARB(1, (GLuint *)&buffer->bufferobject);
3239                 if (buffer->isindexbuffer)
3240                         GL_BindEBO(buffer->bufferobject);
3241                 else
3242                         GL_BindVBO(buffer->bufferobject);
3243                 qglBufferDataARB(buffer->isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER, size, data, buffer->isdynamic ? GL_STREAM_DRAW : GL_STATIC_DRAW);
3244                 break;
3245         case RENDERPATH_D3D9:
3246 #ifdef SUPPORTD3D
3247                 {
3248                         int result;
3249                         void *datapointer = NULL;
3250                         if (buffer->isindexbuffer)
3251                         {
3252                                 IDirect3DIndexBuffer9 *d3d9indexbuffer = (IDirect3DIndexBuffer9 *)buffer->devicebuffer;
3253                                 if (size > buffer->size || !buffer->devicebuffer)
3254                                 {
3255                                         if (buffer->devicebuffer)
3256                                                 IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9*)buffer->devicebuffer);
3257                                         buffer->devicebuffer = NULL;
3258                                         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)))
3259                                                 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);
3260                                         buffer->devicebuffer = (void *)d3d9indexbuffer;
3261                                         buffer->size = size;
3262                                 }
3263                                 if (!FAILED(IDirect3DIndexBuffer9_Lock(d3d9indexbuffer, 0, 0, &datapointer, buffer->isdynamic ? D3DLOCK_DISCARD : 0)))
3264                                 {
3265                                         if (data)
3266                                                 memcpy(datapointer, data, size);
3267                                         else
3268                                                 memset(datapointer, 0, size);
3269                                         IDirect3DIndexBuffer9_Unlock(d3d9indexbuffer);
3270                                 }
3271                         }
3272                         else
3273                         {
3274                                 IDirect3DVertexBuffer9 *d3d9vertexbuffer = (IDirect3DVertexBuffer9 *)buffer->devicebuffer;
3275                                 if (size > buffer->size || !buffer->devicebuffer)
3276                                 {
3277                                         if (buffer->devicebuffer)
3278                                                 IDirect3DVertexBuffer9_Release((IDirect3DVertexBuffer9*)buffer->devicebuffer);
3279                                         buffer->devicebuffer = NULL;
3280                                         if (FAILED(result = IDirect3DDevice9_CreateVertexBuffer(vid_d3d9dev, size, buffer->isdynamic ? D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC : 0, 0, buffer->isdynamic ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED, &d3d9vertexbuffer, NULL)))
3281                                                 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);
3282                                         buffer->devicebuffer = (void *)d3d9vertexbuffer;
3283                                         buffer->size = size;
3284                                 }
3285                                 if (!FAILED(IDirect3DVertexBuffer9_Lock(d3d9vertexbuffer, 0, 0, &datapointer, buffer->isdynamic ? D3DLOCK_DISCARD : 0)))
3286                                 {
3287                                         if (data)
3288                                                 memcpy(datapointer, data, size);
3289                                         else
3290                                                 memset(datapointer, 0, size);
3291                                         IDirect3DVertexBuffer9_Unlock(d3d9vertexbuffer);
3292                                 }
3293                         }
3294                 }
3295 #endif
3296                 break;
3297         case RENDERPATH_D3D10:
3298                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3299                 break;
3300         case RENDERPATH_D3D11:
3301                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3302                 break;
3303         case RENDERPATH_SOFT:
3304                 break;
3305         }
3306 }
3307
3308 void R_Mesh_DestroyMeshBuffer(r_meshbuffer_t *buffer)
3309 {
3310         if (!buffer)
3311                 return;
3312         switch(vid.renderpath)
3313         {
3314         case RENDERPATH_GL11:
3315         case RENDERPATH_GL13:
3316         case RENDERPATH_GL20:
3317         case RENDERPATH_GLES1:
3318         case RENDERPATH_GLES2:
3319                 qglDeleteBuffersARB(1, (GLuint *)&buffer->bufferobject);
3320                 break;
3321         case RENDERPATH_D3D9:
3322 #ifdef SUPPORTD3D
3323                 if (gl_state.d3dvertexbuffer == (void *)buffer)
3324                         gl_state.d3dvertexbuffer = NULL;
3325                 if (buffer->devicebuffer)
3326                 {
3327                         if (buffer->isindexbuffer)
3328                                 IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9 *)buffer->devicebuffer);
3329                         else
3330                                 IDirect3DVertexBuffer9_Release((IDirect3DVertexBuffer9 *)buffer->devicebuffer);
3331                         buffer->devicebuffer = NULL;
3332                 }
3333 #endif
3334                 break;
3335         case RENDERPATH_D3D10:
3336                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3337                 break;
3338         case RENDERPATH_D3D11:
3339                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3340                 break;
3341         case RENDERPATH_SOFT:
3342                 break;
3343         }
3344         Mem_ExpandableArray_FreeRecord(&gl_state.meshbufferarray, (void *)buffer);
3345 }
3346
3347 void GL_Mesh_ListVBOs(qboolean printeach)
3348 {
3349         int i, endindex;
3350         size_t ebocount = 0, ebomemory = 0;
3351         size_t vbocount = 0, vbomemory = 0;
3352         r_meshbuffer_t *buffer;
3353         endindex = Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray);
3354         for (i = 0;i < endindex;i++)
3355         {
3356                 buffer = (r_meshbuffer_t *) Mem_ExpandableArray_RecordAtIndex(&gl_state.meshbufferarray, i);
3357                 if (!buffer)
3358                         continue;
3359                 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)");}
3360                 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)");}
3361         }
3362         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);
3363 }
3364
3365
3366
3367 void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
3368 {
3369         switch(vid.renderpath)
3370         {
3371         case RENDERPATH_GL11:
3372         case RENDERPATH_GL13:
3373         case RENDERPATH_GLES1:
3374                 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)
3375                 {
3376                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3377                         gl_state.pointer_vertex_components = components;
3378                         gl_state.pointer_vertex_gltype = gltype;
3379                         gl_state.pointer_vertex_stride = stride;
3380                         gl_state.pointer_vertex_pointer = pointer;
3381                         gl_state.pointer_vertex_vertexbuffer = vertexbuffer;
3382                         gl_state.pointer_vertex_offset = bufferoffset;
3383                         CHECKGLERROR
3384                         GL_BindVBO(bufferobject);
3385                         qglVertexPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3386                 }
3387                 break;
3388         case RENDERPATH_GL20:
3389         case RENDERPATH_GLES2:
3390                 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)
3391                 {
3392                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3393                         gl_state.pointer_vertex_components = components;
3394                         gl_state.pointer_vertex_gltype = gltype;
3395                         gl_state.pointer_vertex_stride = stride;
3396                         gl_state.pointer_vertex_pointer = pointer;
3397                         gl_state.pointer_vertex_vertexbuffer = vertexbuffer;
3398                         gl_state.pointer_vertex_offset = bufferoffset;
3399                         CHECKGLERROR
3400                         GL_BindVBO(bufferobject);
3401                         qglVertexAttribPointer(GLSLATTRIB_POSITION, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3402                 }
3403                 break;
3404         case RENDERPATH_D3D9:
3405         case RENDERPATH_D3D10:
3406         case RENDERPATH_D3D11:
3407         case RENDERPATH_SOFT:
3408                 break;
3409         }
3410 }
3411
3412 void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
3413 {
3414         // note: vertexbuffer may be non-NULL even if pointer is NULL, so check
3415         // the pointer only.
3416         switch(vid.renderpath)
3417         {
3418         case RENDERPATH_GL11:
3419         case RENDERPATH_GL13:
3420         case RENDERPATH_GLES1:
3421 #ifdef GL_MODELVIEW
3422                 CHECKGLERROR
3423                 if (pointer)
3424                 {
3425                         // caller wants color array enabled
3426                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3427                         if (!gl_state.pointer_color_enabled)
3428                         {
3429                                 gl_state.pointer_color_enabled = true;
3430                                 CHECKGLERROR
3431                                 qglEnableClientState(GL_COLOR_ARRAY);CHECKGLERROR
3432                         }
3433                         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)
3434                         {
3435                                 gl_state.pointer_color_components = components;
3436                                 gl_state.pointer_color_gltype = gltype;
3437                                 gl_state.pointer_color_stride = stride;
3438                                 gl_state.pointer_color_pointer = pointer;
3439                                 gl_state.pointer_color_vertexbuffer = vertexbuffer;
3440                                 gl_state.pointer_color_offset = bufferoffset;
3441                                 CHECKGLERROR
3442                                 GL_BindVBO(bufferobject);
3443                                 qglColorPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3444                         }
3445                 }
3446                 else
3447                 {
3448                         // caller wants color array disabled
3449                         if (gl_state.pointer_color_enabled)
3450                         {
3451                                 gl_state.pointer_color_enabled = false;
3452                                 CHECKGLERROR
3453                                 qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
3454                                 // when color array is on the glColor gets trashed, set it again
3455                                 qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
3456                         }
3457                 }
3458 #endif
3459                 break;
3460         case RENDERPATH_GL20:
3461         case RENDERPATH_GLES2:
3462                 CHECKGLERROR
3463                 if (pointer)
3464                 {
3465                         // caller wants color array enabled
3466                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3467                         if (!gl_state.pointer_color_enabled)
3468                         {
3469                                 gl_state.pointer_color_enabled = true;
3470                                 CHECKGLERROR
3471                                 qglEnableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
3472                         }
3473                         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)
3474                         {
3475                                 gl_state.pointer_color_components = components;
3476                                 gl_state.pointer_color_gltype = gltype;
3477                                 gl_state.pointer_color_stride = stride;
3478                                 gl_state.pointer_color_pointer = pointer;
3479                                 gl_state.pointer_color_vertexbuffer = vertexbuffer;
3480                                 gl_state.pointer_color_offset = bufferoffset;
3481                                 CHECKGLERROR
3482                                 GL_BindVBO(bufferobject);
3483                                 qglVertexAttribPointer(GLSLATTRIB_COLOR, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3484                         }
3485                 }
3486                 else
3487                 {
3488                         // caller wants color array disabled
3489                         if (gl_state.pointer_color_enabled)
3490                         {
3491                                 gl_state.pointer_color_enabled = false;
3492                                 CHECKGLERROR
3493                                 qglDisableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
3494                                 // when color array is on the glColor gets trashed, set it again
3495                                 qglVertexAttrib4f(GLSLATTRIB_COLOR, gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
3496                         }
3497                 }
3498                 break;
3499         case RENDERPATH_D3D9:
3500         case RENDERPATH_D3D10:
3501         case RENDERPATH_D3D11:
3502         case RENDERPATH_SOFT:
3503                 break;
3504         }
3505 }
3506
3507 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)
3508 {
3509         gltextureunit_t *unit = gl_state.units + unitnum;
3510         // update array settings
3511         // note: there is no need to check bufferobject here because all cases
3512         // that involve a valid bufferobject also supply a texcoord array
3513         switch(vid.renderpath)
3514         {
3515         case RENDERPATH_GL11:
3516         case RENDERPATH_GL13:
3517         case RENDERPATH_GLES1:
3518 #ifdef GL_MODELVIEW
3519                 CHECKGLERROR
3520                 if (pointer)
3521                 {
3522                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3523                         // texture array unit is enabled, enable the array
3524                         if (!unit->arrayenabled)
3525                         {
3526                                 unit->arrayenabled = true;
3527                                 GL_ClientActiveTexture(unitnum);
3528                                 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
3529                         }
3530                         // texcoord array
3531                         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)
3532                         {
3533                                 unit->pointer_texcoord_components = components;
3534                                 unit->pointer_texcoord_gltype = gltype;
3535                                 unit->pointer_texcoord_stride = stride;
3536                                 unit->pointer_texcoord_pointer = pointer;
3537                                 unit->pointer_texcoord_vertexbuffer = vertexbuffer;
3538                                 unit->pointer_texcoord_offset = bufferoffset;
3539                                 GL_ClientActiveTexture(unitnum);
3540                                 GL_BindVBO(bufferobject);
3541                                 qglTexCoordPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3542                         }
3543                 }
3544                 else
3545                 {
3546                         // texture array unit is disabled, disable the array
3547                         if (unit->arrayenabled)
3548                         {
3549                                 unit->arrayenabled = false;
3550                                 GL_ClientActiveTexture(unitnum);
3551                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
3552                         }
3553                 }
3554 #endif
3555                 break;
3556         case RENDERPATH_GL20:
3557         case RENDERPATH_GLES2:
3558                 CHECKGLERROR
3559                 if (pointer)
3560                 {
3561                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3562                         // texture array unit is enabled, enable the array
3563                         if (!unit->arrayenabled)
3564                         {
3565                                 unit->arrayenabled = true;
3566                                 qglEnableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
3567                         }
3568                         // texcoord array
3569                         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)
3570                         {
3571                                 unit->pointer_texcoord_components = components;
3572                                 unit->pointer_texcoord_gltype = gltype;
3573                                 unit->pointer_texcoord_stride = stride;
3574                                 unit->pointer_texcoord_pointer = pointer;
3575                                 unit->pointer_texcoord_vertexbuffer = vertexbuffer;
3576                                 unit->pointer_texcoord_offset = bufferoffset;
3577                                 GL_BindVBO(bufferobject);
3578                                 qglVertexAttribPointer(unitnum+GLSLATTRIB_TEXCOORD0, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3579                         }
3580                 }
3581                 else
3582                 {
3583                         // texture array unit is disabled, disable the array
3584                         if (unit->arrayenabled)
3585                         {
3586                                 unit->arrayenabled = false;
3587                                 qglDisableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
3588                         }
3589                 }
3590                 break;
3591         case RENDERPATH_D3D9:
3592         case RENDERPATH_D3D10:
3593         case RENDERPATH_D3D11:
3594         case RENDERPATH_SOFT:
3595                 break;
3596         }
3597 }
3598
3599 int R_Mesh_TexBound(unsigned int unitnum, int id)
3600 {
3601         gltextureunit_t *unit = gl_state.units + unitnum;
3602         if (unitnum >= vid.teximageunits)
3603                 return 0;
3604         if (id == GL_TEXTURE_2D)
3605                 return unit->t2d;
3606         if (id == GL_TEXTURE_3D)
3607                 return unit->t3d;
3608         if (id == GL_TEXTURE_CUBE_MAP)
3609                 return unit->tcubemap;
3610         return 0;
3611 }
3612
3613 void R_Mesh_CopyToTexture(rtexture_t *tex, int tx, int ty, int sx, int sy, int width, int height)
3614 {
3615         switch(vid.renderpath)
3616         {
3617         case RENDERPATH_GL11:
3618         case RENDERPATH_GL13:
3619         case RENDERPATH_GL20:
3620         case RENDERPATH_GLES1:
3621         case RENDERPATH_GLES2:
3622                 R_Mesh_TexBind(0, tex);
3623                 GL_ActiveTexture(0);CHECKGLERROR
3624                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, sx, sy, width, height);CHECKGLERROR
3625                 break;
3626         case RENDERPATH_D3D9:
3627 #ifdef SUPPORTD3D
3628                 {
3629                         IDirect3DSurface9 *currentsurface = NULL;
3630                         IDirect3DSurface9 *texturesurface = NULL;
3631                         RECT sourcerect;
3632                         RECT destrect;
3633                         sourcerect.left = sx;
3634                         sourcerect.top = sy;
3635                         sourcerect.right = sx + width;
3636                         sourcerect.bottom = sy + height;
3637                         destrect.left = tx;
3638                         destrect.top = ty;
3639                         destrect.right = tx + width;
3640                         destrect.bottom = ty + height;
3641                         if (!FAILED(IDirect3DTexture9_GetSurfaceLevel(((IDirect3DTexture9 *)tex->d3dtexture), 0, &texturesurface)))
3642                         {
3643                                 if (!FAILED(IDirect3DDevice9_GetRenderTarget(vid_d3d9dev, 0, &currentsurface)))
3644                                 {
3645                                         IDirect3DDevice9_StretchRect(vid_d3d9dev, currentsurface, &sourcerect, texturesurface, &destrect, D3DTEXF_NONE);
3646                                         IDirect3DSurface9_Release(currentsurface);
3647                                 }
3648                                 IDirect3DSurface9_Release(texturesurface);
3649                         }
3650                 }
3651 #endif
3652                 break;
3653         case RENDERPATH_D3D10:
3654                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3655                 break;
3656         case RENDERPATH_D3D11:
3657                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3658                 break;
3659         case RENDERPATH_SOFT:
3660                 DPSOFTRAST_CopyRectangleToTexture(tex->texnum, 0, tx, ty, sx, sy, width, height);
3661                 break;
3662         }
3663 }
3664
3665 #ifdef SUPPORTD3D
3666 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};
3667 #endif
3668
3669 void R_Mesh_ClearBindingsForTexture(int texnum)
3670 {
3671         gltextureunit_t *unit;
3672         unsigned int unitnum;
3673         // 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)
3674         for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
3675         {
3676                 unit = gl_state.units + unitnum;
3677                 if (unit->t2d == texnum)
3678                         unit->t2d = -1;
3679                 if (unit->t3d == texnum)
3680                         unit->t3d = -1;
3681                 if (unit->tcubemap == texnum)
3682                         unit->tcubemap = -1;
3683         }
3684 }
3685
3686 void R_Mesh_TexBind(unsigned int unitnum, rtexture_t *tex)
3687 {
3688         gltextureunit_t *unit = gl_state.units + unitnum;
3689         int tex2d, tex3d, texcubemap, texnum;
3690         if (unitnum >= vid.teximageunits)
3691                 return;
3692 //      if (unit->texture == tex)
3693 //              return;
3694         switch(vid.renderpath)
3695         {
3696         case RENDERPATH_GL20:
3697         case RENDERPATH_GLES2:
3698                 if (!tex)
3699                 {
3700                         tex = r_texture_white;
3701                         // not initialized enough yet...
3702                         if (!tex)
3703                                 return;
3704                 }
3705                 unit->texture = tex;
3706                 texnum = R_GetTexture(tex);
3707                 switch(tex->gltexturetypeenum)
3708                 {
3709                 case GL_TEXTURE_2D: if (unit->t2d != texnum) {GL_ActiveTexture(unitnum);unit->t2d = texnum;qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR}break;
3710                 case GL_TEXTURE_3D: if (unit->t3d != texnum) {GL_ActiveTexture(unitnum);unit->t3d = texnum;qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR}break;
3711                 case GL_TEXTURE_CUBE_MAP: if (unit->tcubemap != texnum) {GL_ActiveTexture(unitnum);unit->tcubemap = texnum;qglBindTexture(GL_TEXTURE_CUBE_MAP, unit->tcubemap);CHECKGLERROR}break;
3712                 }
3713                 break;
3714         case RENDERPATH_GL11:
3715         case RENDERPATH_GL13:
3716         case RENDERPATH_GLES1:
3717                 unit->texture = tex;
3718                 tex2d = 0;
3719                 tex3d = 0;
3720                 texcubemap = 0;
3721                 if (tex)
3722                 {
3723                         texnum = R_GetTexture(tex);
3724                         switch(tex->gltexturetypeenum)
3725                         {
3726                         case GL_TEXTURE_2D:
3727                                 tex2d = texnum;
3728                                 break;
3729                         case GL_TEXTURE_3D:
3730                                 tex3d = texnum;
3731                                 break;
3732                         case GL_TEXTURE_CUBE_MAP:
3733                                 texcubemap = texnum;
3734                                 break;
3735                         }
3736                 }
3737                 // update 2d texture binding
3738                 if (unit->t2d != tex2d)
3739                 {
3740                         GL_ActiveTexture(unitnum);
3741                         if (tex2d)
3742                         {
3743                                 if (unit->t2d == 0)
3744                                 {
3745                                         qglEnable(GL_TEXTURE_2D);CHECKGLERROR
3746                                 }
3747                         }
3748                         else
3749                         {
3750                                 if (unit->t2d)
3751                                 {
3752                                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
3753                                 }
3754                         }
3755                         unit->t2d = tex2d;
3756                         qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
3757                 }
3758                 // update 3d texture binding
3759                 if (unit->t3d != tex3d)
3760                 {
3761                         GL_ActiveTexture(unitnum);
3762                         if (tex3d)
3763                         {
3764                                 if (unit->t3d == 0)
3765                                 {
3766                                         qglEnable(GL_TEXTURE_3D);CHECKGLERROR
3767                                 }
3768                         }
3769                         else
3770                         {
3771                                 if (unit->t3d)
3772                                 {
3773                                         qglDisable(GL_TEXTURE_3D);CHECKGLERROR
3774                                 }
3775                         }
3776                         unit->t3d = tex3d;
3777                         qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
3778                 }
3779                 // update cubemap texture binding
3780                 if (unit->tcubemap != texcubemap)
3781                 {
3782                         GL_ActiveTexture(unitnum);
3783                         if (texcubemap)
3784                         {
3785                                 if (unit->tcubemap == 0)
3786                                 {
3787                                         qglEnable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
3788                                 }
3789                         }
3790                         else
3791                         {
3792                                 if (unit->tcubemap)
3793                                 {
3794                                         qglDisable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
3795                                 }
3796                         }
3797                         unit->tcubemap = texcubemap;
3798                         qglBindTexture(GL_TEXTURE_CUBE_MAP, unit->tcubemap);CHECKGLERROR
3799                 }
3800                 break;
3801         case RENDERPATH_D3D9:
3802 #ifdef SUPPORTD3D
3803                 {
3804                         extern cvar_t gl_texture_anisotropy;
3805                         if (!tex)
3806                         {
3807                                 tex = r_texture_white;
3808                                 // not initialized enough yet...
3809                                 if (!tex)
3810                                         return;
3811                         }
3812                         // upload texture if needed
3813                         R_GetTexture(tex);
3814                         if (unit->texture == tex)
3815                                 return;
3816                         unit->texture = tex;
3817                         IDirect3DDevice9_SetTexture(vid_d3d9dev, unitnum, (IDirect3DBaseTexture9*)tex->d3dtexture);
3818                         //IDirect3DDevice9_SetRenderState(vid_d3d9dev, d3drswrap[unitnum], (tex->flags & TEXF_CLAMP) ? (D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2) : 0);
3819                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSU, tex->d3daddressu);
3820                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSV, tex->d3daddressv);
3821                         if (tex->d3daddressw)
3822                                 IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSW,  tex->d3daddressw);
3823                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAGFILTER, tex->d3dmagfilter);
3824                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MINFILTER, tex->d3dminfilter);
3825                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MIPFILTER, tex->d3dmipfilter);
3826                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MIPMAPLODBIAS, tex->d3dmipmaplodbias);
3827                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAXMIPLEVEL, tex->d3dmaxmiplevelfilter);
3828                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAXANISOTROPY, gl_texture_anisotropy.integer);
3829                 }
3830 #endif
3831                 break;
3832         case RENDERPATH_D3D10:
3833                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3834                 break;
3835         case RENDERPATH_D3D11:
3836                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3837                 break;
3838         case RENDERPATH_SOFT:
3839                 if (!tex)
3840                 {
3841                         tex = r_texture_white;
3842                         // not initialized enough yet...
3843                         if (!tex)
3844                                 return;
3845                 }
3846                 texnum = R_GetTexture(tex);
3847                 if (unit->texture == tex)
3848                         return;
3849                 unit->texture = tex;
3850                 DPSOFTRAST_SetTexture(unitnum, texnum);
3851                 break;
3852         }
3853 }
3854
3855 void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix)
3856 {
3857         gltextureunit_t *unit = gl_state.units + unitnum;
3858         switch(vid.renderpath)
3859         {
3860         case RENDERPATH_GL11:
3861         case RENDERPATH_GL13:
3862         case RENDERPATH_GL20:
3863         case RENDERPATH_GLES1:
3864         case RENDERPATH_GLES2:
3865 #ifdef GL_MODELVIEW
3866                 if (matrix && matrix->m[3][3])
3867                 {
3868                         // texmatrix specified, check if it is different
3869                         if (!unit->texmatrixenabled || memcmp(&unit->matrix, matrix, sizeof(matrix4x4_t)))
3870                         {
3871                                 float glmatrix[16];
3872                                 unit->texmatrixenabled = true;
3873                                 unit->matrix = *matrix;
3874                                 CHECKGLERROR
3875                                 Matrix4x4_ToArrayFloatGL(&unit->matrix, glmatrix);
3876                                 GL_ActiveTexture(unitnum);
3877                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
3878                                 qglLoadMatrixf(glmatrix);CHECKGLERROR
3879                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
3880                         }
3881                 }
3882                 else
3883                 {
3884                         // no texmatrix specified, revert to identity
3885                         if (unit->texmatrixenabled)
3886                         {
3887                                 unit->texmatrixenabled = false;
3888                                 unit->matrix = identitymatrix;
3889                                 CHECKGLERROR
3890                                 GL_ActiveTexture(unitnum);
3891                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
3892                                 qglLoadIdentity();CHECKGLERROR
3893                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
3894                         }
3895                 }
3896 #endif
3897                 break;
3898         case RENDERPATH_D3D9:
3899         case RENDERPATH_D3D10:
3900         case RENDERPATH_D3D11:
3901                 break;
3902         case RENDERPATH_SOFT:
3903                 break;
3904         }
3905 }
3906
3907 void R_Mesh_TexCombine(unsigned int unitnum, int combinergb, int combinealpha, int rgbscale, int alphascale)
3908 {
3909         gltextureunit_t *unit = gl_state.units + unitnum;
3910         CHECKGLERROR
3911         switch(vid.renderpath)
3912         {
3913         case RENDERPATH_GL20:
3914         case RENDERPATH_GLES2:
3915                 // do nothing
3916                 break;
3917         case RENDERPATH_GL13:
3918         case RENDERPATH_GLES1:
3919 #ifdef GL_TEXTURE_ENV
3920                 // GL_ARB_texture_env_combine
3921                 if (!combinergb)
3922                         combinergb = GL_MODULATE;
3923                 if (!combinealpha)
3924                         combinealpha = GL_MODULATE;
3925                 if (!rgbscale)
3926                         rgbscale = 1;
3927                 if (!alphascale)
3928                         alphascale = 1;
3929                 if (combinergb != combinealpha || rgbscale != 1 || alphascale != 1)
3930                 {
3931                         if (combinergb == GL_DECAL)
3932                                 combinergb = GL_INTERPOLATE;
3933                         if (unit->combine != GL_COMBINE)
3934                         {
3935                                 unit->combine = GL_COMBINE;
3936                                 GL_ActiveTexture(unitnum);
3937                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);CHECKGLERROR
3938                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);CHECKGLERROR // for GL_INTERPOLATE mode
3939                         }
3940                         if (unit->combinergb != combinergb)
3941                         {
3942                                 unit->combinergb = combinergb;
3943                                 GL_ActiveTexture(unitnum);
3944                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, unit->combinergb);CHECKGLERROR
3945                         }
3946                         if (unit->combinealpha != combinealpha)
3947                         {
3948                                 unit->combinealpha = combinealpha;
3949                                 GL_ActiveTexture(unitnum);
3950                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, unit->combinealpha);CHECKGLERROR
3951                         }
3952                         if (unit->rgbscale != rgbscale)
3953                         {
3954                                 unit->rgbscale = rgbscale;
3955                                 GL_ActiveTexture(unitnum);
3956                                 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, unit->rgbscale);CHECKGLERROR
3957                         }
3958                         if (unit->alphascale != alphascale)
3959                         {
3960                                 unit->alphascale = alphascale;
3961                                 GL_ActiveTexture(unitnum);
3962                                 qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, unit->alphascale);CHECKGLERROR
3963                         }
3964                 }
3965                 else
3966                 {
3967                         if (unit->combine != combinergb)
3968                         {
3969                                 unit->combine = combinergb;
3970                                 GL_ActiveTexture(unitnum);
3971                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
3972                         }
3973                 }
3974 #endif
3975                 break;
3976         case RENDERPATH_GL11:
3977                 // normal GL texenv
3978 #ifdef GL_TEXTURE_ENV
3979                 if (!combinergb)
3980                         combinergb = GL_MODULATE;
3981                 if (unit->combine != combinergb)
3982                 {
3983                         unit->combine = combinergb;
3984                         GL_ActiveTexture(unitnum);
3985                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
3986                 }
3987 #endif
3988                 break;
3989         case RENDERPATH_D3D9:
3990         case RENDERPATH_D3D10:
3991         case RENDERPATH_D3D11:
3992                 break;
3993         case RENDERPATH_SOFT:
3994                 break;
3995         }
3996 }
3997
3998 void R_Mesh_ResetTextureState(void)
3999 {
4000         unsigned int unitnum;
4001
4002         BACKENDACTIVECHECK
4003
4004         for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
4005                 R_Mesh_TexBind(unitnum, NULL);
4006         for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++)
4007                 R_Mesh_TexCoordPointer(unitnum, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4008         switch(vid.renderpath)
4009         {
4010         case RENDERPATH_GL20:
4011         case RENDERPATH_GLES2:
4012         case RENDERPATH_D3D9:
4013         case RENDERPATH_D3D10:
4014         case RENDERPATH_D3D11:
4015         case RENDERPATH_SOFT:
4016                 break;
4017         case RENDERPATH_GL11:
4018         case RENDERPATH_GL13:
4019         case RENDERPATH_GLES1:
4020                 for (unitnum = 0;unitnum < vid.texunits;unitnum++)
4021                 {
4022                         R_Mesh_TexCombine(unitnum, GL_MODULATE, GL_MODULATE, 1, 1);
4023                         R_Mesh_TexMatrix(unitnum, NULL);
4024                 }
4025                 break;
4026         }
4027 }
4028
4029
4030
4031 #ifdef SUPPORTD3D
4032 //#define r_vertex3f_d3d9fvf (D3DFVF_XYZ)
4033 //#define r_vertexgeneric_d3d9fvf (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)
4034 //#define r_vertexmesh_d3d9fvf (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX5 | D3DFVF_TEXCOORDSIZE1(3) | D3DFVF_TEXCOORDSIZE2(3) | D3DFVF_TEXCOORDSIZE3(3))
4035
4036 D3DVERTEXELEMENT9 r_vertex3f_d3d9elements[] =
4037 {
4038         {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4039         D3DDECL_END()
4040 };
4041
4042 D3DVERTEXELEMENT9 r_vertexgeneric_d3d9elements[] =
4043 {
4044         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->vertex3f  ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4045         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->color4f   ), D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
4046         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->texcoord2f), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
4047         D3DDECL_END()
4048 };
4049
4050 D3DVERTEXELEMENT9 r_vertexmesh_d3d9elements[] =
4051 {
4052         {0, (int)((size_t)&((r_vertexmesh_t *)0)->vertex3f          ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4053         {0, (int)((size_t)&((r_vertexmesh_t *)0)->color4f           ), D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
4054         {0, (int)((size_t)&((r_vertexmesh_t *)0)->texcoordtexture2f ), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
4055         {0, (int)((size_t)&((r_vertexmesh_t *)0)->svector3f         ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
4056         {0, (int)((size_t)&((r_vertexmesh_t *)0)->tvector3f         ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 2},
4057         {0, (int)((size_t)&((r_vertexmesh_t *)0)->normal3f          ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 3},
4058         {0, (int)((size_t)&((r_vertexmesh_t *)0)->texcoordlightmap2f), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 4},
4059         D3DDECL_END()
4060 };
4061
4062 IDirect3DVertexDeclaration9 *r_vertex3f_d3d9decl;
4063 IDirect3DVertexDeclaration9 *r_vertexgeneric_d3d9decl;
4064 IDirect3DVertexDeclaration9 *r_vertexmesh_d3d9decl;
4065 #endif
4066
4067 static void R_Mesh_InitVertexDeclarations(void)
4068 {
4069 #ifdef SUPPORTD3D
4070         r_vertex3f_d3d9decl = NULL;
4071         r_vertexgeneric_d3d9decl = NULL;
4072         r_vertexmesh_d3d9decl = NULL;
4073         switch(vid.renderpath)
4074         {
4075         case RENDERPATH_GL20:
4076         case RENDERPATH_GL13:
4077         case RENDERPATH_GL11:
4078         case RENDERPATH_GLES1:
4079         case RENDERPATH_GLES2:
4080                 break;
4081         case RENDERPATH_D3D9:
4082                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertex3f_d3d9elements, &r_vertex3f_d3d9decl);
4083                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertexgeneric_d3d9elements, &r_vertexgeneric_d3d9decl);
4084                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertexmesh_d3d9elements, &r_vertexmesh_d3d9decl);
4085                 break;
4086         case RENDERPATH_D3D10:
4087                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4088                 break;
4089         case RENDERPATH_D3D11:
4090                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4091                 break;
4092         case RENDERPATH_SOFT:
4093                 break;
4094         }
4095 #endif
4096 }
4097
4098 static void R_Mesh_DestroyVertexDeclarations(void)
4099 {
4100 #ifdef SUPPORTD3D
4101         if (r_vertex3f_d3d9decl)
4102                 IDirect3DVertexDeclaration9_Release(r_vertex3f_d3d9decl);
4103         r_vertex3f_d3d9decl = NULL;
4104         if (r_vertexgeneric_d3d9decl)
4105                 IDirect3DVertexDeclaration9_Release(r_vertexgeneric_d3d9decl);
4106         r_vertexgeneric_d3d9decl = NULL;
4107         if (r_vertexmesh_d3d9decl)
4108                 IDirect3DVertexDeclaration9_Release(r_vertexmesh_d3d9decl);
4109         r_vertexmesh_d3d9decl = NULL;
4110 #endif
4111 }
4112
4113 void R_Mesh_PrepareVertices_Vertex3f(int numvertices, const float *vertex3f, const r_meshbuffer_t *vertexbuffer)
4114 {
4115         // upload temporary vertexbuffer for this rendering
4116         if (!gl_state.usevbo_staticvertex)
4117                 vertexbuffer = NULL;
4118         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4119         {
4120                 if (gl_state.preparevertices_dynamicvertexbuffer)
4121                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex3f, numvertices * sizeof(float[3]));
4122                 else
4123                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex3f, numvertices * sizeof(float[3]), "temporary", false, true, false);
4124                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
4125         }
4126         switch(vid.renderpath)
4127         {
4128         case RENDERPATH_GL20:
4129         case RENDERPATH_GLES2:
4130                 if (vertexbuffer)
4131                 {
4132                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4133                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4134                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4135                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4136                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4137                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4138                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4139                 }
4140                 else
4141                 {
4142                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4143                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4144                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4145                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4146                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4147                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4148                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4149                 }
4150                 break;
4151         case RENDERPATH_GL13:
4152         case RENDERPATH_GLES1:
4153                 if (vertexbuffer)
4154                 {
4155                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4156                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4157                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4158                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4159                 }
4160                 else
4161                 {
4162                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4163                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4164                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4165                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4166                 }
4167                 break;
4168         case RENDERPATH_GL11:
4169                 if (vertexbuffer)
4170                 {
4171                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4172                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4173                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4174                 }
4175                 else
4176                 {
4177                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4178                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4179                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4180                 }
4181                 break;
4182         case RENDERPATH_D3D9:
4183 #ifdef SUPPORTD3D
4184                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertex3f_d3d9decl);
4185                 if (vertexbuffer)
4186                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, 0, sizeof(float[3]));
4187                 else
4188                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4189                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4190                 gl_state.d3dvertexdata = (void *)vertex3f;
4191                 gl_state.d3dvertexsize = sizeof(float[3]);
4192 #endif
4193                 break;
4194         case RENDERPATH_D3D10:
4195                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4196                 break;
4197         case RENDERPATH_D3D11:
4198                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4199                 break;
4200         case RENDERPATH_SOFT:
4201                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4202                 DPSOFTRAST_SetColorPointer(NULL, 0);
4203                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), NULL);
4204                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(float[2]), NULL);
4205                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(float[2]), NULL);
4206                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(float[2]), NULL);
4207                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), NULL);
4208                 break;
4209         }
4210 }
4211
4212
4213
4214 r_vertexgeneric_t *R_Mesh_PrepareVertices_Generic_Lock(int numvertices)
4215 {
4216         size_t size;
4217         size = sizeof(r_vertexgeneric_t) * numvertices;
4218         if (gl_state.preparevertices_tempdatamaxsize < size)
4219         {
4220                 gl_state.preparevertices_tempdatamaxsize = size;
4221                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
4222         }
4223         gl_state.preparevertices_vertexgeneric = (r_vertexgeneric_t *)gl_state.preparevertices_tempdata;
4224         gl_state.preparevertices_numvertices = numvertices;
4225         return gl_state.preparevertices_vertexgeneric;
4226 }
4227
4228 qboolean R_Mesh_PrepareVertices_Generic_Unlock(void)
4229 {
4230         R_Mesh_PrepareVertices_Generic(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexgeneric, NULL);
4231         gl_state.preparevertices_vertexgeneric = NULL;
4232         gl_state.preparevertices_numvertices = 0;
4233         return true;
4234 }
4235
4236 void R_Mesh_PrepareVertices_Generic_Arrays(int numvertices, const float *vertex3f, const float *color4f, const float *texcoord2f)
4237 {
4238         int i;
4239         r_vertexgeneric_t *vertex;
4240         switch(vid.renderpath)
4241         {
4242         case RENDERPATH_GL20:
4243         case RENDERPATH_GLES2:
4244                 if (!vid.useinterleavedarrays)
4245                 {
4246                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4247                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4248                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
4249                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4250                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4251                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4252                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4253                         return;
4254                 }
4255                 break;
4256         case RENDERPATH_GL11:
4257         case RENDERPATH_GL13:
4258         case RENDERPATH_GLES1:
4259                 if (!vid.useinterleavedarrays)
4260                 {
4261                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4262                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4263                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
4264                         if (vid.texunits >= 2)
4265                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4266                         if (vid.texunits >= 3)
4267                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4268                         return;
4269                 }
4270                 break;
4271         case RENDERPATH_D3D9:
4272         case RENDERPATH_D3D10:
4273         case RENDERPATH_D3D11:
4274                 break;
4275         case RENDERPATH_SOFT:
4276                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4277                 DPSOFTRAST_SetColorPointer(color4f, sizeof(float[4]));
4278                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), texcoord2f);
4279                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(float[2]), NULL);
4280                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(float[2]), NULL);
4281                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(float[2]), NULL);
4282                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), NULL);
4283                 return;
4284         }
4285
4286         // no quick path for this case, convert to vertex structs
4287         vertex = R_Mesh_PrepareVertices_Generic_Lock(numvertices);
4288         for (i = 0;i < numvertices;i++)
4289                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
4290         if (color4f)
4291         {
4292                 for (i = 0;i < numvertices;i++)
4293                         Vector4Copy(color4f + 4*i, vertex[i].color4f);
4294         }
4295         else
4296         {
4297                 for (i = 0;i < numvertices;i++)
4298                         Vector4Copy(gl_state.color4f, vertex[i].color4f);
4299         }
4300         if (texcoord2f)
4301                 for (i = 0;i < numvertices;i++)
4302                         Vector2Copy(texcoord2f + 2*i, vertex[i].texcoord2f);
4303         R_Mesh_PrepareVertices_Generic_Unlock();
4304         R_Mesh_PrepareVertices_Generic(numvertices, vertex, NULL);
4305 }
4306
4307 void R_Mesh_PrepareVertices_Generic(int numvertices, const r_vertexgeneric_t *vertex, const r_meshbuffer_t *vertexbuffer)
4308 {
4309         // upload temporary vertexbuffer for this rendering
4310         if (!gl_state.usevbo_staticvertex)
4311                 vertexbuffer = NULL;
4312         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4313         {
4314                 if (gl_state.preparevertices_dynamicvertexbuffer)
4315                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex));
4316                 else
4317                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true, false);
4318                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
4319         }
4320         switch(vid.renderpath)
4321         {
4322         case RENDERPATH_GL20:
4323         case RENDERPATH_GLES2:
4324                 if (vertexbuffer)
4325                 {
4326                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4327                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4328                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4329                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4330                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4331                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4332                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4333                 }
4334                 else
4335                 {
4336                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4337                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4338                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4339                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4340                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4341                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4342                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4343                 }
4344                 break;
4345         case RENDERPATH_GL13:
4346         case RENDERPATH_GLES1:
4347                 if (vertexbuffer)
4348                 {
4349                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4350                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4351                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4352                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4353                 }
4354                 else
4355                 {
4356                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4357                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4358                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4359                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4360                 }
4361                 break;
4362         case RENDERPATH_GL11:
4363                 if (vertexbuffer)
4364                 {
4365                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4366                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4367                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4368                 }
4369                 else
4370                 {
4371                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4372                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4373                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4374                 }
4375                 break;
4376         case RENDERPATH_D3D9:
4377 #ifdef SUPPORTD3D
4378                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertexgeneric_d3d9decl);
4379                 if (vertexbuffer)
4380                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, 0, sizeof(*vertex));
4381                 else
4382                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4383                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4384                 gl_state.d3dvertexdata = (void *)vertex;
4385                 gl_state.d3dvertexsize = sizeof(*vertex);
4386 #endif
4387                 break;
4388         case RENDERPATH_D3D10:
4389                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4390                 break;
4391         case RENDERPATH_D3D11:
4392                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4393                 break;
4394         case RENDERPATH_SOFT:
4395                 DPSOFTRAST_SetVertexPointer(vertex->vertex3f, sizeof(*vertex));
4396                 DPSOFTRAST_SetColorPointer(vertex->color4f, sizeof(*vertex));
4397                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(*vertex), vertex->texcoord2f);
4398                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(*vertex), NULL);
4399                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(*vertex), NULL);
4400                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(*vertex), NULL);
4401                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(*vertex), NULL);
4402                 break;
4403         }
4404 }
4405
4406
4407
4408 r_vertexmesh_t *R_Mesh_PrepareVertices_Mesh_Lock(int numvertices)
4409 {
4410         size_t size;
4411         size = sizeof(r_vertexmesh_t) * numvertices;
4412         if (gl_state.preparevertices_tempdatamaxsize < size)
4413         {
4414                 gl_state.preparevertices_tempdatamaxsize = size;
4415                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
4416         }
4417         gl_state.preparevertices_vertexmesh = (r_vertexmesh_t *)gl_state.preparevertices_tempdata;
4418         gl_state.preparevertices_numvertices = numvertices;
4419         return gl_state.preparevertices_vertexmesh;
4420 }
4421
4422 qboolean R_Mesh_PrepareVertices_Mesh_Unlock(void)
4423 {
4424         R_Mesh_PrepareVertices_Mesh(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexmesh, NULL);
4425         gl_state.preparevertices_vertexmesh = NULL;
4426         gl_state.preparevertices_numvertices = 0;
4427         return true;
4428 }
4429
4430 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)
4431 {
4432         int i;
4433         r_vertexmesh_t *vertex;
4434         switch(vid.renderpath)
4435         {
4436         case RENDERPATH_GL20:
4437         case RENDERPATH_GLES2:
4438                 if (!vid.useinterleavedarrays)
4439                 {
4440                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4441                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4442                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
4443                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), svector3f, NULL, 0);
4444                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), tvector3f, NULL, 0);
4445                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), normal3f, NULL, 0);
4446                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
4447                         return;
4448                 }
4449                 break;
4450         case RENDERPATH_GL11:
4451         case RENDERPATH_GL13:
4452         case RENDERPATH_GLES1:
4453                 if (!vid.useinterleavedarrays)
4454                 {
4455                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4456                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4457                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
4458                         if (vid.texunits >= 2)
4459                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
4460                         if (vid.texunits >= 3)
4461                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4462                         return;
4463                 }
4464                 break;
4465         case RENDERPATH_D3D9:
4466         case RENDERPATH_D3D10:
4467         case RENDERPATH_D3D11:
4468                 break;
4469         case RENDERPATH_SOFT:
4470                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4471                 DPSOFTRAST_SetColorPointer(color4f, sizeof(float[4]));
4472                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), texcoordtexture2f);
4473                 DPSOFTRAST_SetTexCoordPointer(1, 3, sizeof(float[3]), svector3f);
4474                 DPSOFTRAST_SetTexCoordPointer(2, 3, sizeof(float[3]), tvector3f);
4475                 DPSOFTRAST_SetTexCoordPointer(3, 3, sizeof(float[3]), normal3f);
4476                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), texcoordlightmap2f);
4477                 return;
4478         }
4479
4480         vertex = R_Mesh_PrepareVertices_Mesh_Lock(numvertices);
4481         for (i = 0;i < numvertices;i++)
4482                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
4483         if (svector3f)
4484                 for (i = 0;i < numvertices;i++)
4485                         VectorCopy(svector3f + 3*i, vertex[i].svector3f);
4486         if (tvector3f)
4487                 for (i = 0;i < numvertices;i++)
4488                         VectorCopy(tvector3f + 3*i, vertex[i].tvector3f);
4489         if (normal3f)
4490                 for (i = 0;i < numvertices;i++)
4491                         VectorCopy(normal3f + 3*i, vertex[i].normal3f);
4492         if (color4f)
4493         {
4494                 for (i = 0;i < numvertices;i++)
4495                         Vector4Copy(color4f + 4*i, vertex[i].color4f);
4496         }
4497         else
4498         {
4499                 for (i = 0;i < numvertices;i++)
4500                         Vector4Copy(gl_state.color4f, vertex[i].color4f);
4501         }
4502         if (texcoordtexture2f)
4503                 for (i = 0;i < numvertices;i++)
4504                         Vector2Copy(texcoordtexture2f + 2*i, vertex[i].texcoordtexture2f);
4505         if (texcoordlightmap2f)
4506                 for (i = 0;i < numvertices;i++)
4507                         Vector2Copy(texcoordlightmap2f + 2*i, vertex[i].texcoordlightmap2f);
4508         R_Mesh_PrepareVertices_Mesh_Unlock();
4509         R_Mesh_PrepareVertices_Mesh(numvertices, vertex, NULL);
4510 }
4511
4512 void R_Mesh_PrepareVertices_Mesh(int numvertices, const r_vertexmesh_t *vertex, const r_meshbuffer_t *vertexbuffer)
4513 {
4514         // upload temporary vertexbuffer for this rendering
4515         if (!gl_state.usevbo_staticvertex)
4516                 vertexbuffer = NULL;
4517         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4518         {
4519                 if (gl_state.preparevertices_dynamicvertexbuffer)
4520                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex));
4521                 else
4522                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true, false);
4523                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
4524         }
4525         switch(vid.renderpath)
4526         {
4527         case RENDERPATH_GL20:
4528         case RENDERPATH_GLES2:
4529                 if (vertexbuffer)
4530                 {
4531                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4532                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4533                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4534                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , vertexbuffer, (int)((unsigned char *)vertex->svector3f          - (unsigned char *)vertex));
4535                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , vertexbuffer, (int)((unsigned char *)vertex->tvector3f          - (unsigned char *)vertex));
4536                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , vertexbuffer, (int)((unsigned char *)vertex->normal3f           - (unsigned char *)vertex));
4537                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
4538                 }
4539                 else
4540                 {
4541                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4542                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4543                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4544                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , NULL, 0);
4545                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , NULL, 0);
4546                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , NULL, 0);
4547                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
4548                 }
4549                 break;
4550         case RENDERPATH_GL13:
4551         case RENDERPATH_GLES1:
4552                 if (vertexbuffer)
4553                 {
4554                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4555                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4556                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4557                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
4558                 }
4559                 else
4560                 {
4561                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4562                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4563                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4564                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
4565                 }
4566                 break;
4567         case RENDERPATH_GL11:
4568                 if (vertexbuffer)
4569                 {
4570                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4571                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4572                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4573                 }
4574                 else
4575                 {
4576                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4577                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4578                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4579                 }
4580                 break;
4581         case RENDERPATH_D3D9:
4582 #ifdef SUPPORTD3D
4583                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertexmesh_d3d9decl);
4584                 if (vertexbuffer)
4585                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, 0, sizeof(*vertex));
4586                 else
4587                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4588                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4589                 gl_state.d3dvertexdata = (void *)vertex;
4590                 gl_state.d3dvertexsize = sizeof(*vertex);
4591 #endif
4592                 break;
4593         case RENDERPATH_D3D10:
4594                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4595                 break;
4596         case RENDERPATH_D3D11:
4597                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4598                 break;
4599         case RENDERPATH_SOFT:
4600                 DPSOFTRAST_SetVertexPointer(vertex->vertex3f, sizeof(*vertex));
4601                 DPSOFTRAST_SetColorPointer(vertex->color4f, sizeof(*vertex));
4602                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(*vertex), vertex->texcoordtexture2f);
4603                 DPSOFTRAST_SetTexCoordPointer(1, 3, sizeof(*vertex), vertex->svector3f);
4604                 DPSOFTRAST_SetTexCoordPointer(2, 3, sizeof(*vertex), vertex->tvector3f);
4605                 DPSOFTRAST_SetTexCoordPointer(3, 3, sizeof(*vertex), vertex->normal3f);
4606                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(*vertex), vertex->texcoordlightmap2f);
4607                 break;
4608         }
4609 }
4610
4611 void GL_BlendEquationSubtract(qboolean negated)
4612 {
4613         if(negated)
4614         {
4615                 switch(vid.renderpath)
4616                 {
4617                 case RENDERPATH_GL11:
4618                 case RENDERPATH_GL13:
4619                 case RENDERPATH_GL20:
4620                 case RENDERPATH_GLES1:
4621                 case RENDERPATH_GLES2:
4622                         qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT);
4623                         break;
4624                 case RENDERPATH_D3D9:
4625 #ifdef SUPPORTD3D
4626                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
4627 #endif
4628                         break;
4629                 case RENDERPATH_D3D10:
4630                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4631                         break;
4632                 case RENDERPATH_D3D11:
4633                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4634                         break;
4635                 case RENDERPATH_SOFT:
4636                         DPSOFTRAST_BlendSubtract(true);
4637                         break;
4638                 }
4639         }
4640         else
4641         {
4642                 switch(vid.renderpath)
4643                 {
4644                 case RENDERPATH_GL11:
4645                 case RENDERPATH_GL13:
4646                 case RENDERPATH_GL20:
4647                 case RENDERPATH_GLES1:
4648                 case RENDERPATH_GLES2:
4649                         qglBlendEquationEXT(GL_FUNC_ADD);
4650                         break;
4651                 case RENDERPATH_D3D9:
4652 #ifdef SUPPORTD3D
4653                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
4654 #endif
4655                         break;
4656                 case RENDERPATH_D3D10:
4657                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4658                         break;
4659                 case RENDERPATH_D3D11:
4660                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4661                         break;
4662                 case RENDERPATH_SOFT:
4663                         DPSOFTRAST_BlendSubtract(false);
4664                         break;
4665                 }
4666         }
4667 }