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(GL_FRONT, frontcompare, comparereference, comparereference);CHECKGLERROR
1976                         qglStencilFuncSeparate(GL_BACK, backcompare, comparereference, comparereference);CHECKGLERROR
1977                 }
1978                 else if (vid.support.ext_stencil_two_side)
1979                 {
1980 #ifdef GL_STENCIL_TEST_TWO_SIDE_EXT
1981                         qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
1982                         qglActiveStencilFaceEXT(GL_FRONT);CHECKGLERROR
1983                         qglStencilMask(writemask);CHECKGLERROR
1984                         qglStencilOp(frontfail, frontzfail, frontzpass);CHECKGLERROR
1985                         qglStencilFunc(frontcompare, comparereference, comparemask);CHECKGLERROR
1986                         qglActiveStencilFaceEXT(GL_BACK);CHECKGLERROR
1987                         qglStencilMask(writemask);CHECKGLERROR
1988                         qglStencilOp(backfail, backzfail, backzpass);CHECKGLERROR
1989                         qglStencilFunc(backcompare, comparereference, comparemask);CHECKGLERROR
1990 #endif
1991                 }
1992                 break;
1993         case RENDERPATH_D3D9:
1994 #ifdef SUPPORTD3D
1995                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_TWOSIDEDSTENCILMODE, true);
1996                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILENABLE, enable);
1997                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILWRITEMASK, writemask);
1998                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFAIL, d3dstencilopforglfunc(frontfail));
1999                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILZFAIL, d3dstencilopforglfunc(frontzfail));
2000                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILPASS, d3dstencilopforglfunc(frontzpass));
2001                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFUNC, d3dcmpforglfunc(frontcompare));
2002                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILFAIL, d3dstencilopforglfunc(backfail));
2003                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILZFAIL, d3dstencilopforglfunc(backzfail));
2004                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILPASS, d3dstencilopforglfunc(backzpass));
2005                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CCW_STENCILFUNC, d3dcmpforglfunc(backcompare));
2006                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILREF, comparereference);
2007                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILMASK, comparemask);
2008 #endif
2009                 break;
2010         case RENDERPATH_D3D10:
2011                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2012                 break;
2013         case RENDERPATH_D3D11:
2014                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2015                 break;
2016         case RENDERPATH_SOFT:
2017                 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2018                 break;
2019         }
2020 }
2021
2022 void R_SetStencil(qboolean enable, int writemask, int fail, int zfail, int zpass, int compare, int comparereference, int comparemask)
2023 {
2024         switch (vid.renderpath)
2025         {
2026         case RENDERPATH_GL11:
2027         case RENDERPATH_GL13:
2028         case RENDERPATH_GL20:
2029         case RENDERPATH_GLES1:
2030         case RENDERPATH_GLES2:
2031                 CHECKGLERROR
2032                 if (enable)
2033                 {
2034                         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2035                 }
2036                 else
2037                 {
2038                         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2039                 }
2040                 if (vid.support.ext_stencil_two_side)
2041                 {
2042 #ifdef GL_STENCIL_TEST_TWO_SIDE_EXT
2043                         qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2044 #endif
2045                 }
2046                 qglStencilMask(writemask);CHECKGLERROR
2047                 qglStencilOp(fail, zfail, zpass);CHECKGLERROR
2048                 qglStencilFunc(compare, comparereference, comparemask);CHECKGLERROR
2049                 CHECKGLERROR
2050                 break;
2051         case RENDERPATH_D3D9:
2052 #ifdef SUPPORTD3D
2053                 if (vid.support.ati_separate_stencil)
2054                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_TWOSIDEDSTENCILMODE, true);
2055                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILENABLE, enable);
2056                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILWRITEMASK, writemask);
2057                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFAIL, d3dstencilopforglfunc(fail));
2058                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILZFAIL, d3dstencilopforglfunc(zfail));
2059                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILPASS, d3dstencilopforglfunc(zpass));
2060                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILFUNC, d3dcmpforglfunc(compare));
2061                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILREF, comparereference);
2062                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_STENCILMASK, comparemask);
2063 #endif
2064                 break;
2065         case RENDERPATH_D3D10:
2066                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2067                 break;
2068         case RENDERPATH_D3D11:
2069                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2070                 break;
2071         case RENDERPATH_SOFT:
2072                 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2073                 break;
2074         }
2075 }
2076
2077 void GL_PolygonOffset(float planeoffset, float depthoffset)
2078 {
2079         if (gl_state.polygonoffset[0] != planeoffset || gl_state.polygonoffset[1] != depthoffset)
2080         {
2081                 gl_state.polygonoffset[0] = planeoffset;
2082                 gl_state.polygonoffset[1] = depthoffset;
2083                 switch(vid.renderpath)
2084                 {
2085                 case RENDERPATH_GL11:
2086                 case RENDERPATH_GL13:
2087                 case RENDERPATH_GL20:
2088                 case RENDERPATH_GLES1:
2089                 case RENDERPATH_GLES2:
2090                         qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
2091                         break;
2092                 case RENDERPATH_D3D9:
2093 #ifdef SUPPORTD3D
2094                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SLOPESCALEDEPTHBIAS, gl_state.polygonoffset[0]);
2095                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_DEPTHBIAS, gl_state.polygonoffset[1] * (1.0f / 16777216.0f));
2096 #endif
2097                         break;
2098                 case RENDERPATH_D3D10:
2099                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2100                         break;
2101                 case RENDERPATH_D3D11:
2102                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2103                         break;
2104                 case RENDERPATH_SOFT:
2105                         DPSOFTRAST_PolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
2106                         break;
2107                 }
2108         }
2109 }
2110
2111 void GL_SetMirrorState(qboolean state)
2112 {
2113         if (v_flipped_state != state)
2114         {
2115                 v_flipped_state = state;
2116                 if (gl_state.cullface == GL_BACK)
2117                         gl_state.cullface = GL_FRONT;
2118                 else if (gl_state.cullface == GL_FRONT)
2119                         gl_state.cullface = GL_BACK;
2120                 else
2121                         return;
2122                 switch(vid.renderpath)
2123                 {
2124                 case RENDERPATH_GL11:
2125                 case RENDERPATH_GL13:
2126                 case RENDERPATH_GL20:
2127                 case RENDERPATH_GLES1:
2128                 case RENDERPATH_GLES2:
2129                         qglCullFace(gl_state.cullface);CHECKGLERROR
2130                         break;
2131                 case RENDERPATH_D3D9:
2132 #ifdef SUPPORTD3D
2133                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, gl_state.cullface == GL_FRONT ? D3DCULL_CCW : D3DCULL_CW);
2134 #endif
2135                         break;
2136                 case RENDERPATH_D3D10:
2137                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2138                         break;
2139                 case RENDERPATH_D3D11:
2140                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2141                         break;
2142                 case RENDERPATH_SOFT:
2143                         DPSOFTRAST_CullFace(gl_state.cullface);
2144                         break;
2145                 }
2146         }
2147 }
2148
2149 void GL_CullFace(int state)
2150 {
2151         if(v_flipped_state)
2152         {
2153                 if(state == GL_FRONT)
2154                         state = GL_BACK;
2155                 else if(state == GL_BACK)
2156                         state = GL_FRONT;
2157         }
2158
2159         switch(vid.renderpath)
2160         {
2161         case RENDERPATH_GL11:
2162         case RENDERPATH_GL13:
2163         case RENDERPATH_GL20:
2164         case RENDERPATH_GLES1:
2165         case RENDERPATH_GLES2:
2166                 CHECKGLERROR
2167
2168                 if (state != GL_NONE)
2169                 {
2170                         if (!gl_state.cullfaceenable)
2171                         {
2172                                 gl_state.cullfaceenable = true;
2173                                 qglEnable(GL_CULL_FACE);CHECKGLERROR
2174                         }
2175                         if (gl_state.cullface != state)
2176                         {
2177                                 gl_state.cullface = state;
2178                                 qglCullFace(gl_state.cullface);CHECKGLERROR
2179                         }
2180                 }
2181                 else
2182                 {
2183                         if (gl_state.cullfaceenable)
2184                         {
2185                                 gl_state.cullfaceenable = false;
2186                                 qglDisable(GL_CULL_FACE);CHECKGLERROR
2187                         }
2188                 }
2189                 break;
2190         case RENDERPATH_D3D9:
2191 #ifdef SUPPORTD3D
2192                 if (gl_state.cullface != state)
2193                 {
2194                         gl_state.cullface = state;
2195                         switch(gl_state.cullface)
2196                         {
2197                         case GL_NONE:
2198                                 gl_state.cullfaceenable = false;
2199                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_NONE);
2200                                 break;
2201                         case GL_FRONT:
2202                                 gl_state.cullfaceenable = true;
2203                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_CCW);
2204                                 break;
2205                         case GL_BACK:
2206                                 gl_state.cullfaceenable = true;
2207                                 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_CULLMODE, D3DCULL_CW);
2208                                 break;
2209                         }
2210                 }
2211 #endif
2212                 break;
2213         case RENDERPATH_D3D10:
2214                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2215                 break;
2216         case RENDERPATH_D3D11:
2217                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2218                 break;
2219         case RENDERPATH_SOFT:
2220                 if (gl_state.cullface != state)
2221                 {
2222                         gl_state.cullface = state;
2223                         gl_state.cullfaceenable = state != GL_NONE ? true : false;
2224                         DPSOFTRAST_CullFace(gl_state.cullface);
2225                 }
2226                 break;
2227         }
2228 }
2229
2230 void GL_AlphaTest(int state)
2231 {
2232         if (gl_state.alphatest != state)
2233         {
2234                 gl_state.alphatest = state;
2235                 switch(vid.renderpath)
2236                 {
2237                 case RENDERPATH_GL11:
2238                 case RENDERPATH_GL13:
2239                 case RENDERPATH_GLES1:
2240 #ifdef GL_ALPHA_TEST
2241                         // only fixed function uses alpha test, other paths use pixel kill capability in shaders
2242                         CHECKGLERROR
2243                         if (gl_state.alphatest)
2244                         {
2245                                 qglEnable(GL_ALPHA_TEST);CHECKGLERROR
2246                         }
2247                         else
2248                         {
2249                                 qglDisable(GL_ALPHA_TEST);CHECKGLERROR
2250                         }
2251 #endif
2252                         break;
2253                 case RENDERPATH_D3D9:
2254                 case RENDERPATH_D3D10:
2255                 case RENDERPATH_D3D11:
2256                 case RENDERPATH_SOFT:
2257                 case RENDERPATH_GL20:
2258                 case RENDERPATH_GLES2:
2259                         break;
2260                 }
2261         }
2262 }
2263
2264 void GL_AlphaToCoverage(qboolean state)
2265 {
2266         if (gl_state.alphatocoverage != state)
2267         {
2268                 gl_state.alphatocoverage = state;
2269                 switch(vid.renderpath)
2270                 {
2271                 case RENDERPATH_GL11:
2272                 case RENDERPATH_GL13:
2273                 case RENDERPATH_GLES1:
2274                 case RENDERPATH_GLES2:
2275                 case RENDERPATH_D3D9:
2276                 case RENDERPATH_D3D10:
2277                 case RENDERPATH_D3D11:
2278                 case RENDERPATH_SOFT:
2279                         break;
2280                 case RENDERPATH_GL20:
2281 #ifdef GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
2282                         // alpha to coverage turns the alpha value of the pixel into 0%, 25%, 50%, 75% or 100% by masking the multisample fragments accordingly
2283                         CHECKGLERROR
2284                         if (gl_state.alphatocoverage)
2285                         {
2286                                 qglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
2287 //                              qglEnable(GL_MULTISAMPLE_ARB);CHECKGLERROR
2288                         }
2289                         else
2290                         {
2291                                 qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);CHECKGLERROR
2292 //                              qglDisable(GL_MULTISAMPLE_ARB);CHECKGLERROR
2293                         }
2294 #endif
2295                         break;
2296                 }
2297         }
2298 }
2299
2300 void GL_ColorMask(int r, int g, int b, int a)
2301 {
2302         // NOTE: this matches D3DCOLORWRITEENABLE_RED, GREEN, BLUE, ALPHA
2303         int state = (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0) | (a ? 8 : 0);
2304         if (gl_state.colormask != state)
2305         {
2306                 gl_state.colormask = state;
2307                 switch(vid.renderpath)
2308                 {
2309                 case RENDERPATH_GL11:
2310                 case RENDERPATH_GL13:
2311                 case RENDERPATH_GL20:
2312                 case RENDERPATH_GLES1:
2313                 case RENDERPATH_GLES2:
2314                         CHECKGLERROR
2315                         qglColorMask((GLboolean)r, (GLboolean)g, (GLboolean)b, (GLboolean)a);CHECKGLERROR
2316                         break;
2317                 case RENDERPATH_D3D9:
2318 #ifdef SUPPORTD3D
2319                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_COLORWRITEENABLE, state);
2320 #endif
2321                         break;
2322                 case RENDERPATH_D3D10:
2323                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2324                         break;
2325                 case RENDERPATH_D3D11:
2326                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2327                         break;
2328                 case RENDERPATH_SOFT:
2329                         DPSOFTRAST_ColorMask(r, g, b, a);
2330                         break;
2331                 }
2332         }
2333 }
2334
2335 void GL_Color(float cr, float cg, float cb, float ca)
2336 {
2337         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)
2338         {
2339                 gl_state.color4f[0] = cr;
2340                 gl_state.color4f[1] = cg;
2341                 gl_state.color4f[2] = cb;
2342                 gl_state.color4f[3] = ca;
2343                 switch(vid.renderpath)
2344                 {
2345                 case RENDERPATH_GL11:
2346                 case RENDERPATH_GL13:
2347                 case RENDERPATH_GLES1:
2348                         CHECKGLERROR
2349                         qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);
2350                         CHECKGLERROR
2351                         break;
2352                 case RENDERPATH_D3D9:
2353                 case RENDERPATH_D3D10:
2354                 case RENDERPATH_D3D11:
2355                         // no equivalent in D3D
2356                         break;
2357                 case RENDERPATH_SOFT:
2358                         DPSOFTRAST_Color4f(cr, cg, cb, ca);
2359                         break;
2360                 case RENDERPATH_GL20:
2361                 case RENDERPATH_GLES2:
2362                         qglVertexAttrib4f(GLSLATTRIB_COLOR, cr, cg, cb, ca);
2363                         break;
2364                 }
2365         }
2366 }
2367
2368 void GL_Scissor (int x, int y, int width, int height)
2369 {
2370         switch(vid.renderpath)
2371         {
2372         case RENDERPATH_GL11:
2373         case RENDERPATH_GL13:
2374         case RENDERPATH_GL20:
2375         case RENDERPATH_GLES1:
2376         case RENDERPATH_GLES2:
2377                 CHECKGLERROR
2378                 qglScissor(x, y,width,height);
2379                 CHECKGLERROR
2380                 break;
2381         case RENDERPATH_D3D9:
2382 #ifdef SUPPORTD3D
2383                 {
2384                         RECT d3drect;
2385                         d3drect.left = x;
2386                         d3drect.top = y;
2387                         d3drect.right = x + width;
2388                         d3drect.bottom = y + height;
2389                         IDirect3DDevice9_SetScissorRect(vid_d3d9dev, &d3drect);
2390                 }
2391 #endif
2392                 break;
2393         case RENDERPATH_D3D10:
2394                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2395                 break;
2396         case RENDERPATH_D3D11:
2397                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2398                 break;
2399         case RENDERPATH_SOFT:
2400                 DPSOFTRAST_Scissor(x, y, width, height);
2401                 break;
2402         }
2403 }
2404
2405 void GL_ScissorTest(int state)
2406 {
2407         if (gl_state.scissortest != state)
2408         {
2409                 gl_state.scissortest = state;
2410                 switch(vid.renderpath)
2411                 {
2412                 case RENDERPATH_GL11:
2413                 case RENDERPATH_GL13:
2414                 case RENDERPATH_GL20:
2415                 case RENDERPATH_GLES1:
2416                 case RENDERPATH_GLES2:
2417                         CHECKGLERROR
2418                         if(gl_state.scissortest)
2419                                 qglEnable(GL_SCISSOR_TEST);
2420                         else
2421                                 qglDisable(GL_SCISSOR_TEST);
2422                         CHECKGLERROR
2423                         break;
2424                 case RENDERPATH_D3D9:
2425 #ifdef SUPPORTD3D
2426                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_SCISSORTESTENABLE, gl_state.scissortest);
2427 #endif
2428                         break;
2429                 case RENDERPATH_D3D10:
2430                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2431                         break;
2432                 case RENDERPATH_D3D11:
2433                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2434                         break;
2435                 case RENDERPATH_SOFT:
2436                         DPSOFTRAST_ScissorTest(gl_state.scissortest);
2437                         break;
2438                 }
2439         }
2440 }
2441
2442 void GL_Clear(int mask, const float *colorvalue, float depthvalue, int stencilvalue)
2443 {
2444         static const float blackcolor[4] = {0, 0, 0, 0};
2445         // prevent warnings when trying to clear a buffer that does not exist
2446         if (!colorvalue)
2447                 colorvalue = blackcolor;
2448         if (!vid.stencil)
2449         {
2450                 mask &= ~GL_STENCIL_BUFFER_BIT;
2451                 stencilvalue = 0;
2452         }
2453         switch(vid.renderpath)
2454         {
2455         case RENDERPATH_GL11:
2456         case RENDERPATH_GL13:
2457         case RENDERPATH_GL20:
2458         case RENDERPATH_GLES1:
2459         case RENDERPATH_GLES2:
2460                 CHECKGLERROR
2461                 if (mask & GL_COLOR_BUFFER_BIT)
2462                 {
2463                         qglClearColor(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]);CHECKGLERROR
2464                 }
2465                 if (mask & GL_DEPTH_BUFFER_BIT)
2466                 {
2467 #ifdef USE_GLES2
2468                         qglClearDepthf(depthvalue);CHECKGLERROR
2469 #else
2470                         qglClearDepth(depthvalue);CHECKGLERROR
2471 #endif
2472                 }
2473                 if (mask & GL_STENCIL_BUFFER_BIT)
2474                 {
2475                         qglClearStencil(stencilvalue);CHECKGLERROR
2476                 }
2477                 qglClear(mask);CHECKGLERROR
2478                 break;
2479         case RENDERPATH_D3D9:
2480 #ifdef SUPPORTD3D
2481                 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);
2482 #endif
2483                 break;
2484         case RENDERPATH_D3D10:
2485                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2486                 break;
2487         case RENDERPATH_D3D11:
2488                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2489                 break;
2490         case RENDERPATH_SOFT:
2491                 if (mask & GL_COLOR_BUFFER_BIT)
2492                         DPSOFTRAST_ClearColor(colorvalue[0], colorvalue[1], colorvalue[2], colorvalue[3]);
2493                 if (mask & GL_DEPTH_BUFFER_BIT)
2494                         DPSOFTRAST_ClearDepth(depthvalue);
2495                 break;
2496         }
2497 }
2498
2499 void GL_ReadPixelsBGRA(int x, int y, int width, int height, unsigned char *outpixels)
2500 {
2501         switch(vid.renderpath)
2502         {
2503         case RENDERPATH_GL11:
2504         case RENDERPATH_GL13:
2505         case RENDERPATH_GL20:
2506         case RENDERPATH_GLES1:
2507         case RENDERPATH_GLES2:
2508                 CHECKGLERROR
2509                 qglReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_BYTE, outpixels);CHECKGLERROR
2510                 break;
2511         case RENDERPATH_D3D9:
2512 #ifdef SUPPORTD3D
2513                 {
2514                         // LordHavoc: we can't directly download the backbuffer because it may be
2515                         // multisampled, and it may not be lockable, so we blit it to a lockable
2516                         // surface of the same dimensions (but without multisample) to resolve the
2517                         // multisample buffer to a normal image, and then lock that...
2518                         IDirect3DSurface9 *stretchsurface = NULL;
2519                         if (!FAILED(IDirect3DDevice9_CreateRenderTarget(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &stretchsurface, NULL)))
2520                         {
2521                                 D3DLOCKED_RECT lockedrect;
2522                                 if (!FAILED(IDirect3DDevice9_StretchRect(vid_d3d9dev, gl_state.d3drt_backbuffercolorsurface, NULL, stretchsurface, NULL, D3DTEXF_POINT)))
2523                                 {
2524                                         if (!FAILED(IDirect3DSurface9_LockRect(stretchsurface, &lockedrect, NULL, D3DLOCK_READONLY)))
2525                                         {
2526                                                 int line;
2527                                                 unsigned char *row = (unsigned char *)lockedrect.pBits + x * 4 + lockedrect.Pitch * (vid.height - 1 - y);
2528                                                 for (line = 0;line < height;line++, row -= lockedrect.Pitch)
2529                                                         memcpy(outpixels + line * width * 4, row, width * 4);
2530                                                 IDirect3DSurface9_UnlockRect(stretchsurface);
2531                                         }
2532                                 }
2533                                 IDirect3DSurface9_Release(stretchsurface);
2534                         }
2535                         // code scraps
2536                         //IDirect3DSurface9 *syssurface = NULL;
2537                         //if (!FAILED(IDirect3DDevice9_CreateRenderTarget(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, FALSE, &stretchsurface, NULL)))
2538                         //if (!FAILED(IDirect3DDevice9_CreateOffscreenPlainSurface(vid_d3d9dev, vid.width, vid.height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &syssurface, NULL)))
2539                         //IDirect3DDevice9_GetRenderTargetData(vid_d3d9dev, gl_state.d3drt_backbuffercolorsurface, syssurface);
2540                         //if (!FAILED(IDirect3DDevice9_GetFrontBufferData(vid_d3d9dev, 0, syssurface)))
2541                         //if (!FAILED(IDirect3DSurface9_LockRect(syssurface, &lockedrect, NULL, D3DLOCK_READONLY)))
2542                         //IDirect3DSurface9_UnlockRect(syssurface);
2543                         //IDirect3DSurface9_Release(syssurface);
2544                 }
2545 #endif
2546                 break;
2547         case RENDERPATH_D3D10:
2548                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2549                 break;
2550         case RENDERPATH_D3D11:
2551                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2552                 break;
2553         case RENDERPATH_SOFT:
2554                 DPSOFTRAST_GetPixelsBGRA(x, y, width, height, outpixels);
2555                 break;
2556         }
2557 }
2558
2559 // called at beginning of frame
2560 void R_Mesh_Start(void)
2561 {
2562         BACKENDACTIVECHECK
2563         R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL);
2564         R_Mesh_SetUseVBO();
2565         if (gl_printcheckerror.integer && !gl_paranoid.integer)
2566         {
2567                 Con_Printf("WARNING: gl_printcheckerror is on but gl_paranoid is off, turning it on...\n");
2568                 Cvar_SetValueQuick(&gl_paranoid, 1);
2569         }
2570 }
2571
2572 static qboolean GL_Backend_CompileShader(int programobject, GLenum shadertypeenum, const char *shadertype, int numstrings, const char **strings)
2573 {
2574         int shaderobject;
2575         int shadercompiled;
2576         char compilelog[MAX_INPUTLINE];
2577         shaderobject = qglCreateShader(shadertypeenum);CHECKGLERROR
2578         if (!shaderobject)
2579                 return false;
2580         qglShaderSource(shaderobject, numstrings, strings, NULL);CHECKGLERROR
2581         qglCompileShader(shaderobject);CHECKGLERROR
2582         qglGetShaderiv(shaderobject, GL_COMPILE_STATUS, &shadercompiled);CHECKGLERROR
2583         qglGetShaderInfoLog(shaderobject, sizeof(compilelog), NULL, compilelog);CHECKGLERROR
2584         if (compilelog[0] && (strstr(compilelog, "error") || strstr(compilelog, "ERROR") || strstr(compilelog, "Error") || strstr(compilelog, "WARNING") || strstr(compilelog, "warning") || strstr(compilelog, "Warning") || developer_extra.integer))
2585         {
2586                 int i, j, pretextlines = 0;
2587                 for (i = 0;i < numstrings - 1;i++)
2588                         for (j = 0;strings[i][j];j++)
2589                                 if (strings[i][j] == '\n')
2590                                         pretextlines++;
2591                 Con_Printf("%s shader compile log:\n%s\n(line offset for any above warnings/errors: %i)\n", shadertype, compilelog, pretextlines);
2592         }
2593         if (!shadercompiled)
2594         {
2595                 qglDeleteShader(shaderobject);CHECKGLERROR
2596                 return false;
2597         }
2598         qglAttachShader(programobject, shaderobject);CHECKGLERROR
2599         qglDeleteShader(shaderobject);CHECKGLERROR
2600         return true;
2601 }
2602
2603 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)
2604 {
2605         GLint programlinked;
2606         GLuint programobject = 0;
2607         char linklog[MAX_INPUTLINE];
2608         CHECKGLERROR
2609
2610         programobject = qglCreateProgram();CHECKGLERROR
2611         if (!programobject)
2612                 return 0;
2613
2614         qglBindAttribLocation(programobject, GLSLATTRIB_POSITION , "Attrib_Position" );
2615         qglBindAttribLocation(programobject, GLSLATTRIB_COLOR    , "Attrib_Color"    );
2616         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD0, "Attrib_TexCoord0");
2617         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD1, "Attrib_TexCoord1");
2618         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD2, "Attrib_TexCoord2");
2619         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD3, "Attrib_TexCoord3");
2620         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD4, "Attrib_TexCoord4");
2621         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD5, "Attrib_TexCoord5");
2622         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD6, "Attrib_TexCoord6");
2623         qglBindAttribLocation(programobject, GLSLATTRIB_TEXCOORD7, "Attrib_TexCoord7");
2624 #ifndef USE_GLES2
2625         if(vid.support.gl20shaders130)
2626                 qglBindFragDataLocation(programobject, 0, "dp_FragColor");
2627 #endif
2628
2629         if (vertexstrings_count && !GL_Backend_CompileShader(programobject, GL_VERTEX_SHADER, "vertex", vertexstrings_count, vertexstrings_list))
2630                 goto cleanup;
2631
2632 #ifdef GL_GEOMETRY_SHADER
2633         if (geometrystrings_count && !GL_Backend_CompileShader(programobject, GL_GEOMETRY_SHADER, "geometry", geometrystrings_count, geometrystrings_list))
2634                 goto cleanup;
2635 #endif
2636
2637         if (fragmentstrings_count && !GL_Backend_CompileShader(programobject, GL_FRAGMENT_SHADER, "fragment", fragmentstrings_count, fragmentstrings_list))
2638                 goto cleanup;
2639
2640         qglLinkProgram(programobject);CHECKGLERROR
2641         qglGetProgramiv(programobject, GL_LINK_STATUS, &programlinked);CHECKGLERROR
2642         qglGetProgramInfoLog(programobject, sizeof(linklog), NULL, linklog);CHECKGLERROR
2643         if (linklog[0])
2644         {
2645                 if (strstr(linklog, "error") || strstr(linklog, "ERROR") || strstr(linklog, "Error") || strstr(linklog, "WARNING") || strstr(linklog, "warning") || strstr(linklog, "Warning") || developer_extra.integer)
2646                         Con_DPrintf("program link log:\n%s\n", linklog);
2647                 // software vertex shader is ok but software fragment shader is WAY
2648                 // too slow, fail program if so.
2649                 // NOTE: this string might be ATI specific, but that's ok because the
2650                 // ATI R300 chip (Radeon 9500-9800/X300) is the most likely to use a
2651                 // software fragment shader due to low instruction and dependent
2652                 // texture limits.
2653                 if (strstr(linklog, "fragment shader will run in software"))
2654                         programlinked = false;
2655         }
2656         if (!programlinked)
2657                 goto cleanup;
2658         return programobject;
2659 cleanup:
2660         qglDeleteProgram(programobject);CHECKGLERROR
2661         return 0;
2662 }
2663
2664 void GL_Backend_FreeProgram(unsigned int prog)
2665 {
2666         CHECKGLERROR
2667         qglDeleteProgram(prog);
2668         CHECKGLERROR
2669 }
2670
2671 // renders triangles using vertices from the active arrays
2672 int paranoidblah = 0;
2673 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)
2674 {
2675         unsigned int numelements = numtriangles * 3;
2676         int bufferobject3i;
2677         size_t bufferoffset3i;
2678         int bufferobject3s;
2679         size_t bufferoffset3s;
2680         if (numvertices < 3 || numtriangles < 1)
2681         {
2682                 if (numvertices < 0 || numtriangles < 0 || developer_extra.integer)
2683                         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);
2684                 return;
2685         }
2686         if (!gl_mesh_prefer_short_elements.integer)
2687         {
2688                 if (element3i)
2689                         element3s = NULL;
2690                 if (element3i_indexbuffer)
2691                         element3i_indexbuffer = NULL;
2692         }
2693         // adjust the pointers for firsttriangle
2694         if (element3i)
2695                 element3i += firsttriangle * 3;
2696         if (element3i_indexbuffer)
2697                 element3i_bufferoffset += firsttriangle * 3 * sizeof(*element3i);
2698         if (element3s)
2699                 element3s += firsttriangle * 3;
2700         if (element3s_indexbuffer)
2701                 element3s_bufferoffset += firsttriangle * 3 * sizeof(*element3s);
2702         switch(vid.renderpath)
2703         {
2704         case RENDERPATH_GL11:
2705         case RENDERPATH_GL13:
2706         case RENDERPATH_GL20:
2707         case RENDERPATH_GLES1:
2708         case RENDERPATH_GLES2:
2709                 // check if the user specified to ignore static index buffers
2710                 if (!gl_state.usevbo_staticindex || (gl_vbo.integer == 3 && !vid.forcevbo && (element3i_bufferoffset || element3s_bufferoffset)))
2711                 {
2712                         element3i_indexbuffer = NULL;
2713                         element3s_indexbuffer = NULL;
2714                 }
2715                 break;
2716         case RENDERPATH_D3D9:
2717         case RENDERPATH_D3D10:
2718         case RENDERPATH_D3D11:
2719                 break;
2720         case RENDERPATH_SOFT:
2721                 break;
2722         }
2723         // upload a dynamic index buffer if needed
2724         if (element3s)
2725         {
2726                 if (!element3s_indexbuffer && gl_state.usevbo_dynamicindex)
2727                 {
2728                         if (gl_state.draw_dynamicindexbuffer)
2729                                 R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3s, numelements * sizeof(*element3s));
2730                         else
2731                                 gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3s, numelements * sizeof(*element3s), "temporary", true, true, true);
2732                         element3s_indexbuffer = gl_state.draw_dynamicindexbuffer;
2733                         element3s_bufferoffset = 0;
2734                 }
2735         }
2736         else if (element3i)
2737         {
2738                 if (!element3i_indexbuffer && gl_state.usevbo_dynamicindex)
2739                 {
2740                         if (gl_state.draw_dynamicindexbuffer)
2741                                 R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3i, numelements * sizeof(*element3i));
2742                         else
2743                                 gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3i, numelements * sizeof(*element3i), "temporary", true, true, false);
2744                         element3i_indexbuffer = gl_state.draw_dynamicindexbuffer;
2745                         element3i_bufferoffset = 0;
2746                 }
2747         }
2748         bufferobject3i = element3i_indexbuffer ? element3i_indexbuffer->bufferobject : 0;
2749         bufferoffset3i = element3i_bufferoffset;
2750         bufferobject3s = element3s_indexbuffer ? element3s_indexbuffer->bufferobject : 0;
2751         bufferoffset3s = element3s_bufferoffset;
2752         r_refdef.stats.draws++;
2753         r_refdef.stats.draws_vertices += numvertices;
2754         r_refdef.stats.draws_elements += numelements;
2755         if (gl_paranoid.integer)
2756         {
2757                 unsigned int i;
2758                 // LordHavoc: disabled this - it needs to be updated to handle components and gltype and stride in each array
2759 #if 0
2760                 unsigned int j, size;
2761                 const int *p;
2762                 // note: there's no validation done here on buffer objects because it
2763                 // is somewhat difficult to get at the data, and gl_paranoid can be
2764                 // used without buffer objects if the need arises
2765                 // (the data could be gotten using glMapBuffer but it would be very
2766                 //  slow due to uncachable video memory reads)
2767                 if (!qglIsEnabled(GL_VERTEX_ARRAY))
2768                         Con_Print("R_Mesh_Draw: vertex array not enabled\n");
2769                 CHECKGLERROR
2770                 if (gl_state.pointer_vertex_pointer)
2771                         for (j = 0, size = numvertices * 3, p = (int *)((float *)gl_state.pointer_vertex + firstvertex * 3);j < size;j++, p++)
2772                                 paranoidblah += *p;
2773                 if (gl_state.pointer_color_enabled)
2774                 {
2775                         if (!qglIsEnabled(GL_COLOR_ARRAY))
2776                                 Con_Print("R_Mesh_Draw: color array set but not enabled\n");
2777                         CHECKGLERROR
2778                         if (gl_state.pointer_color && gl_state.pointer_color_enabled)
2779                                 for (j = 0, size = numvertices * 4, p = (int *)((float *)gl_state.pointer_color + firstvertex * 4);j < size;j++, p++)
2780                                         paranoidblah += *p;
2781                 }
2782                 for (i = 0;i < vid.texarrayunits;i++)
2783                 {
2784                         if (gl_state.units[i].arrayenabled)
2785                         {
2786                                 GL_ClientActiveTexture(i);
2787                                 if (!qglIsEnabled(GL_TEXTURE_COORD_ARRAY))
2788                                         Con_Print("R_Mesh_Draw: texcoord array set but not enabled\n");
2789                                 CHECKGLERROR
2790                                 if (gl_state.units[i].pointer_texcoord && gl_state.units[i].arrayenabled)
2791                                         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++)
2792                                                 paranoidblah += *p;
2793                         }
2794                 }
2795 #endif
2796                 if (element3i)
2797                 {
2798                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2799                         {
2800                                 if (element3i[i] < firstvertex || element3i[i] >= firstvertex + numvertices)
2801                                 {
2802                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3i array\n", element3i[i], firstvertex, firstvertex + numvertices);
2803                                         return;
2804                                 }
2805                         }
2806                 }
2807                 if (element3s)
2808                 {
2809                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2810                         {
2811                                 if (element3s[i] < firstvertex || element3s[i] >= firstvertex + numvertices)
2812                                 {
2813                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3s array\n", element3s[i], firstvertex, firstvertex + numvertices);
2814                                         return;
2815                                 }
2816                         }
2817                 }
2818         }
2819         if (r_render.integer || r_refdef.draw2dstage)
2820         {
2821                 switch(vid.renderpath)
2822                 {
2823                 case RENDERPATH_GL11:
2824                 case RENDERPATH_GL13:
2825                 case RENDERPATH_GL20:
2826                         CHECKGLERROR
2827                         if (gl_mesh_testmanualfeeding.integer)
2828                         {
2829 #ifndef USE_GLES2
2830                                 unsigned int i, j, element;
2831                                 const GLfloat *p;
2832                                 qglBegin(GL_TRIANGLES);
2833                                 if(vid.renderpath == RENDERPATH_GL20)
2834                                 {
2835                                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2836                                         {
2837                                                 if (element3i)
2838                                                         element = element3i[i];
2839                                                 else if (element3s)
2840                                                         element = element3s[i];
2841                                                 else
2842                                                         element = firstvertex + i;
2843                                                 for (j = 0;j < vid.texarrayunits;j++)
2844                                                 {
2845                                                         if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
2846                                                         {
2847                                                                 if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
2848                                                                 {
2849                                                                         p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2850                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
2851                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2], p[3]);
2852                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
2853                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1], p[2]);
2854                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
2855                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, p[0], p[1]);
2856                                                                         else
2857                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, p[0]);
2858                                                                 }
2859                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
2860                                                                 {
2861                                                                         const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2862                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
2863                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2], s[3]);
2864                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
2865                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1], s[2]);
2866                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
2867                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, s[0], s[1]);
2868                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
2869                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, s[0]);
2870                                                                 }
2871                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
2872                                                                 {
2873                                                                         const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2874                                                                         if (gl_state.units[j].pointer_texcoord_components == 4)
2875                                                                                 qglVertexAttrib4f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2], sb[3]);
2876                                                                         else if (gl_state.units[j].pointer_texcoord_components == 3)
2877                                                                                 qglVertexAttrib3f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1], sb[2]);
2878                                                                         else if (gl_state.units[j].pointer_texcoord_components == 2)
2879                                                                                 qglVertexAttrib2f(GLSLATTRIB_TEXCOORD0 + j, sb[0], sb[1]);
2880                                                                         else if (gl_state.units[j].pointer_texcoord_components == 1)
2881                                                                                 qglVertexAttrib1f(GLSLATTRIB_TEXCOORD0 + j, sb[0]);
2882                                                                 }
2883                                                         }
2884                                                 }
2885                                                 if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
2886                                                 {
2887                                                         if (gl_state.pointer_color_gltype == GL_FLOAT)
2888                                                         {
2889                                                                 p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
2890                                                                 qglVertexAttrib4f(GLSLATTRIB_COLOR, p[0], p[1], p[2], p[3]);
2891                                                         }
2892                                                         else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
2893                                                         {
2894                                                                 const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
2895                                                                 qglVertexAttrib4Nub(GLSLATTRIB_COLOR, ub[0], ub[1], ub[2], ub[3]);
2896                                                         }
2897                                                 }
2898                                                 if (gl_state.pointer_vertex_gltype == GL_FLOAT)
2899                                                 {
2900                                                         p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
2901                                                         if (gl_state.pointer_vertex_components == 4)
2902                                                                 qglVertexAttrib4f(GLSLATTRIB_POSITION, p[0], p[1], p[2], p[3]);
2903                                                         else if (gl_state.pointer_vertex_components == 3)
2904                                                                 qglVertexAttrib3f(GLSLATTRIB_POSITION, p[0], p[1], p[2]);
2905                                                         else
2906                                                                 qglVertexAttrib2f(GLSLATTRIB_POSITION, p[0], p[1]);
2907                                                 }
2908                                         }
2909                                 }
2910                                 else
2911                                 {
2912                                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
2913                                         {
2914                                                 if (element3i)
2915                                                         element = element3i[i];
2916                                                 else if (element3s)
2917                                                         element = element3s[i];
2918                                                 else
2919                                                         element = firstvertex + i;
2920                                                 for (j = 0;j < vid.texarrayunits;j++)
2921                                                 {
2922                                                         if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
2923                                                         {
2924                                                                 if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
2925                                                                 {
2926                                                                         p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2927                                                                         if (vid.texarrayunits > 1)
2928                                                                         {
2929                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2930                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, p[0], p[1], p[2], p[3]);
2931                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2932                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, p[0], p[1], p[2]);
2933                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2934                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, p[0], p[1]);
2935                                                                                 else
2936                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, p[0]);
2937                                                                         }
2938                                                                         else
2939                                                                         {
2940                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2941                                                                                         qglTexCoord4f(p[0], p[1], p[2], p[3]);
2942                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2943                                                                                         qglTexCoord3f(p[0], p[1], p[2]);
2944                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2945                                                                                         qglTexCoord2f(p[0], p[1]);
2946                                                                                 else
2947                                                                                         qglTexCoord1f(p[0]);
2948                                                                         }
2949                                                                 }
2950                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
2951                                                                 {
2952                                                                         const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2953                                                                         if (vid.texarrayunits > 1)
2954                                                                         {
2955                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2956                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, s[0], s[1], s[2], s[3]);
2957                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2958                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, s[0], s[1], s[2]);
2959                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2960                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, s[0], s[1]);
2961                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2962                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, s[0]);
2963                                                                         }
2964                                                                         else
2965                                                                         {
2966                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2967                                                                                         qglTexCoord4f(s[0], s[1], s[2], s[3]);
2968                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2969                                                                                         qglTexCoord3f(s[0], s[1], s[2]);
2970                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2971                                                                                         qglTexCoord2f(s[0], s[1]);
2972                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2973                                                                                         qglTexCoord1f(s[0]);
2974                                                                         }
2975                                                                 }
2976                                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
2977                                                                 {
2978                                                                         const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
2979                                                                         if (vid.texarrayunits > 1)
2980                                                                         {
2981                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2982                                                                                         qglMultiTexCoord4f(GL_TEXTURE0 + j, sb[0], sb[1], sb[2], sb[3]);
2983                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2984                                                                                         qglMultiTexCoord3f(GL_TEXTURE0 + j, sb[0], sb[1], sb[2]);
2985                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2986                                                                                         qglMultiTexCoord2f(GL_TEXTURE0 + j, sb[0], sb[1]);
2987                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2988                                                                                         qglMultiTexCoord1f(GL_TEXTURE0 + j, sb[0]);
2989                                                                         }
2990                                                                         else
2991                                                                         {
2992                                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
2993                                                                                         qglTexCoord4f(sb[0], sb[1], sb[2], sb[3]);
2994                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
2995                                                                                         qglTexCoord3f(sb[0], sb[1], sb[2]);
2996                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
2997                                                                                         qglTexCoord2f(sb[0], sb[1]);
2998                                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
2999                                                                                         qglTexCoord1f(sb[0]);
3000                                                                         }
3001                                                                 }
3002                                                         }
3003                                                 }
3004                                                 if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
3005                                                 {
3006                                                         if (gl_state.pointer_color_gltype == GL_FLOAT)
3007                                                         {
3008                                                                 p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3009                                                                 qglColor4f(p[0], p[1], p[2], p[3]);
3010                                                         }
3011                                                         else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
3012                                                         {
3013                                                                 const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
3014                                                                 qglColor4ub(ub[0], ub[1], ub[2], ub[3]);
3015                                                         }
3016                                                 }
3017                                                 if (gl_state.pointer_vertex_gltype == GL_FLOAT)
3018                                                 {
3019                                                         p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
3020                                                         if (gl_state.pointer_vertex_components == 4)
3021                                                                 qglVertex4f(p[0], p[1], p[2], p[3]);
3022                                                         else if (gl_state.pointer_vertex_components == 3)
3023                                                                 qglVertex3f(p[0], p[1], p[2]);
3024                                                         else
3025                                                                 qglVertex2f(p[0], p[1]);
3026                                                 }
3027                                         }
3028                                 }
3029                                 qglEnd();
3030                                 CHECKGLERROR
3031 #endif
3032                         }
3033                         else if (bufferobject3s)
3034                         {
3035                                 GL_BindEBO(bufferobject3s);
3036 #ifndef USE_GLES2
3037                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3038                                 {
3039                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s);
3040                                         CHECKGLERROR
3041                                 }
3042                                 else
3043 #endif
3044                                 {
3045                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, (void *)(firsttriangle * sizeof(unsigned short[3])));
3046                                         CHECKGLERROR
3047                                 }
3048                         }
3049                         else if (bufferobject3i)
3050                         {
3051                                 GL_BindEBO(bufferobject3i);
3052 #ifndef USE_GLES2
3053                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3054                                 {
3055                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i);
3056                                         CHECKGLERROR
3057                                 }
3058                                 else
3059 #endif
3060                                 {
3061                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, (void *)(firsttriangle * sizeof(unsigned int[3])));
3062                                         CHECKGLERROR
3063                                 }
3064                         }
3065                         else if (element3s)
3066                         {
3067                                 GL_BindEBO(0);
3068 #ifndef USE_GLES2
3069                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3070                                 {
3071                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, element3s);
3072                                         CHECKGLERROR
3073                                 }
3074                                 else
3075 #endif
3076                                 {
3077                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s);
3078                                         CHECKGLERROR
3079                                 }
3080                         }
3081                         else if (element3i)
3082                         {
3083                                 GL_BindEBO(0);
3084 #ifndef USE_GLES2
3085                                 if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
3086                                 {
3087                                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, element3i);
3088                                         CHECKGLERROR
3089                                 }
3090                                 else
3091 #endif
3092                                 {
3093                                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i);
3094                                         CHECKGLERROR
3095                                 }
3096                         }
3097                         else
3098                         {
3099                                 qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);
3100                                 CHECKGLERROR
3101                         }
3102                         break;
3103                 case RENDERPATH_D3D9:
3104 #ifdef SUPPORTD3D
3105                         if (gl_state.d3dvertexbuffer && ((element3s && element3s_indexbuffer) || (element3i && element3i_indexbuffer)))
3106                         {
3107                                 if (element3s_indexbuffer)
3108                                 {
3109                                         IDirect3DDevice9_SetIndices(vid_d3d9dev, (IDirect3DIndexBuffer9 *)element3s_indexbuffer->devicebuffer);
3110                                         IDirect3DDevice9_DrawIndexedPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, 0, firstvertex, numvertices, element3s_bufferoffset>>1, numtriangles);
3111                                 }
3112                                 else if (element3i_indexbuffer)
3113                                 {
3114                                         IDirect3DDevice9_SetIndices(vid_d3d9dev, (IDirect3DIndexBuffer9 *)element3i_indexbuffer->devicebuffer);
3115                                         IDirect3DDevice9_DrawIndexedPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, 0, firstvertex, numvertices, element3i_bufferoffset>>2, numtriangles);
3116                                 }
3117                                 else
3118                                         IDirect3DDevice9_DrawPrimitive(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices);
3119                         }
3120                         else
3121                         {
3122                                 if (element3s)
3123                                         IDirect3DDevice9_DrawIndexedPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices, numtriangles, element3s, D3DFMT_INDEX16, gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3124                                 else if (element3i)
3125                                         IDirect3DDevice9_DrawIndexedPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, firstvertex, numvertices, numtriangles, element3i, D3DFMT_INDEX32, gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3126                                 else
3127                                         IDirect3DDevice9_DrawPrimitiveUP(vid_d3d9dev, D3DPT_TRIANGLELIST, numvertices, (void *)gl_state.d3dvertexdata, gl_state.d3dvertexsize);
3128                         }
3129 #endif
3130                         break;
3131                 case RENDERPATH_D3D10:
3132                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3133                         break;
3134                 case RENDERPATH_D3D11:
3135                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3136                         break;
3137                 case RENDERPATH_SOFT:
3138                         DPSOFTRAST_DrawTriangles(firstvertex, numvertices, numtriangles, element3i, element3s);
3139                         break;
3140                 case RENDERPATH_GLES1:
3141                 case RENDERPATH_GLES2:
3142                         // GLES does not have glDrawRangeElements, and generally
3143                         // underperforms with index buffers, so this code path is
3144                         // relatively straightforward...
3145 #if 0
3146                         if (gl_paranoid.integer)
3147                         {
3148                                 int r, prog, enabled, i;
3149                                 GLsizei         attriblength;
3150                                 GLint           attribsize;
3151                                 GLenum          attribtype;
3152                                 GLchar          attribname[1024];
3153                                 r = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER);CHECKGLERROR
3154                                 if (r != GL_FRAMEBUFFER_COMPLETE)
3155                                         Con_DPrintf("fbo %i not complete (default %i)\n", gl_state.framebufferobject, gl_state.defaultframebufferobject);
3156 #ifndef GL_CURRENT_PROGRAM
3157 #define GL_CURRENT_PROGRAM 0x8B8D
3158 #endif
3159                                 qglGetIntegerv(GL_CURRENT_PROGRAM, &r);CHECKGLERROR
3160                                 if (r < 0 || r > 10000)
3161                                         Con_DPrintf("GL_CURRENT_PROGRAM = %i\n", r);
3162                                 prog = r;
3163                                 for (i = 0;i < 8;i++)
3164                                 {
3165                                         qglGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &r);CHECKGLERROR
3166                                         if (!r)
3167                                                 continue;
3168                                         qglGetActiveAttrib(prog, i, sizeof(attribname), &attriblength, &attribsize, &attribtype, attribname);CHECKGLERROR
3169                                         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);
3170                                 }
3171                         }
3172 #endif
3173                         if (element3s)
3174                         {
3175                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s);
3176                                 CHECKGLERROR
3177                         }
3178                         else if (element3i)
3179                         {
3180                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i);
3181                                 CHECKGLERROR
3182                         }
3183                         else
3184                         {
3185                                 qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);
3186                                 CHECKGLERROR
3187                         }
3188                         break;
3189                 }
3190         }
3191 }
3192
3193 // restores backend state, used when done with 3D rendering
3194 void R_Mesh_Finish(void)
3195 {
3196         R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL);
3197 }
3198
3199 r_meshbuffer_t *R_Mesh_CreateMeshBuffer(const void *data, size_t size, const char *name, qboolean isindexbuffer, qboolean isdynamic, qboolean isindex16)
3200 {
3201         r_meshbuffer_t *buffer;
3202         if (!(isdynamic ? (isindexbuffer ? gl_state.usevbo_dynamicindex : gl_state.usevbo_dynamicvertex) : (isindexbuffer ? gl_state.usevbo_staticindex : gl_state.usevbo_staticvertex)))
3203                 return NULL;
3204         buffer = (r_meshbuffer_t *)Mem_ExpandableArray_AllocRecord(&gl_state.meshbufferarray);
3205         memset(buffer, 0, sizeof(*buffer));
3206         buffer->bufferobject = 0;
3207         buffer->devicebuffer = NULL;
3208         buffer->size = 0;
3209         buffer->isindexbuffer = isindexbuffer;
3210         buffer->isdynamic = isdynamic;
3211         buffer->isindex16 = isindex16;
3212         strlcpy(buffer->name, name, sizeof(buffer->name));
3213         R_Mesh_UpdateMeshBuffer(buffer, data, size);
3214         return buffer;
3215 }
3216
3217 void R_Mesh_UpdateMeshBuffer(r_meshbuffer_t *buffer, const void *data, size_t size)
3218 {
3219         if (!buffer)
3220                 return;
3221         if (buffer->isindexbuffer)
3222         {
3223                 r_refdef.stats.indexbufferuploadcount++;
3224                 r_refdef.stats.indexbufferuploadsize += size;
3225         }
3226         else
3227         {
3228                 r_refdef.stats.vertexbufferuploadcount++;
3229                 r_refdef.stats.vertexbufferuploadsize += size;
3230         }
3231         switch(vid.renderpath)
3232         {
3233         case RENDERPATH_GL11:
3234         case RENDERPATH_GL13:
3235         case RENDERPATH_GL20:
3236         case RENDERPATH_GLES1:
3237         case RENDERPATH_GLES2:
3238                 if (!buffer->bufferobject)
3239                         qglGenBuffersARB(1, (GLuint *)&buffer->bufferobject);
3240                 if (buffer->isindexbuffer)
3241                         GL_BindEBO(buffer->bufferobject);
3242                 else
3243                         GL_BindVBO(buffer->bufferobject);
3244                 qglBufferDataARB(buffer->isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER, size, data, buffer->isdynamic ? GL_STREAM_DRAW : GL_STATIC_DRAW);
3245                 break;
3246         case RENDERPATH_D3D9:
3247 #ifdef SUPPORTD3D
3248                 {
3249                         int result;
3250                         void *datapointer = NULL;
3251                         if (buffer->isindexbuffer)
3252                         {
3253                                 IDirect3DIndexBuffer9 *d3d9indexbuffer = (IDirect3DIndexBuffer9 *)buffer->devicebuffer;
3254                                 if (size > buffer->size || !buffer->devicebuffer)
3255                                 {
3256                                         if (buffer->devicebuffer)
3257                                                 IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9*)buffer->devicebuffer);
3258                                         buffer->devicebuffer = NULL;
3259                                         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)))
3260                                                 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);
3261                                         buffer->devicebuffer = (void *)d3d9indexbuffer;
3262                                         buffer->size = size;
3263                                 }
3264                                 if (!FAILED(IDirect3DIndexBuffer9_Lock(d3d9indexbuffer, 0, 0, &datapointer, buffer->isdynamic ? D3DLOCK_DISCARD : 0)))
3265                                 {
3266                                         if (data)
3267                                                 memcpy(datapointer, data, size);
3268                                         else
3269                                                 memset(datapointer, 0, size);
3270                                         IDirect3DIndexBuffer9_Unlock(d3d9indexbuffer);
3271                                 }
3272                         }
3273                         else
3274                         {
3275                                 IDirect3DVertexBuffer9 *d3d9vertexbuffer = (IDirect3DVertexBuffer9 *)buffer->devicebuffer;
3276                                 if (size > buffer->size || !buffer->devicebuffer)
3277                                 {
3278                                         if (buffer->devicebuffer)
3279                                                 IDirect3DVertexBuffer9_Release((IDirect3DVertexBuffer9*)buffer->devicebuffer);
3280                                         buffer->devicebuffer = NULL;
3281                                         if (FAILED(result = IDirect3DDevice9_CreateVertexBuffer(vid_d3d9dev, size, buffer->isdynamic ? D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC : 0, 0, buffer->isdynamic ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED, &d3d9vertexbuffer, NULL)))
3282                                                 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);
3283                                         buffer->devicebuffer = (void *)d3d9vertexbuffer;
3284                                         buffer->size = size;
3285                                 }
3286                                 if (!FAILED(IDirect3DVertexBuffer9_Lock(d3d9vertexbuffer, 0, 0, &datapointer, buffer->isdynamic ? D3DLOCK_DISCARD : 0)))
3287                                 {
3288                                         if (data)
3289                                                 memcpy(datapointer, data, size);
3290                                         else
3291                                                 memset(datapointer, 0, size);
3292                                         IDirect3DVertexBuffer9_Unlock(d3d9vertexbuffer);
3293                                 }
3294                         }
3295                 }
3296 #endif
3297                 break;
3298         case RENDERPATH_D3D10:
3299                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3300                 break;
3301         case RENDERPATH_D3D11:
3302                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3303                 break;
3304         case RENDERPATH_SOFT:
3305                 break;
3306         }
3307 }
3308
3309 void R_Mesh_DestroyMeshBuffer(r_meshbuffer_t *buffer)
3310 {
3311         if (!buffer)
3312                 return;
3313         switch(vid.renderpath)
3314         {
3315         case RENDERPATH_GL11:
3316         case RENDERPATH_GL13:
3317         case RENDERPATH_GL20:
3318         case RENDERPATH_GLES1:
3319         case RENDERPATH_GLES2:
3320                 qglDeleteBuffersARB(1, (GLuint *)&buffer->bufferobject);
3321                 break;
3322         case RENDERPATH_D3D9:
3323 #ifdef SUPPORTD3D
3324                 if (gl_state.d3dvertexbuffer == (void *)buffer)
3325                         gl_state.d3dvertexbuffer = NULL;
3326                 if (buffer->devicebuffer)
3327                 {
3328                         if (buffer->isindexbuffer)
3329                                 IDirect3DIndexBuffer9_Release((IDirect3DIndexBuffer9 *)buffer->devicebuffer);
3330                         else
3331                                 IDirect3DVertexBuffer9_Release((IDirect3DVertexBuffer9 *)buffer->devicebuffer);
3332                         buffer->devicebuffer = NULL;
3333                 }
3334 #endif
3335                 break;
3336         case RENDERPATH_D3D10:
3337                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3338                 break;
3339         case RENDERPATH_D3D11:
3340                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3341                 break;
3342         case RENDERPATH_SOFT:
3343                 break;
3344         }
3345         Mem_ExpandableArray_FreeRecord(&gl_state.meshbufferarray, (void *)buffer);
3346 }
3347
3348 void GL_Mesh_ListVBOs(qboolean printeach)
3349 {
3350         int i, endindex;
3351         size_t ebocount = 0, ebomemory = 0;
3352         size_t vbocount = 0, vbomemory = 0;
3353         r_meshbuffer_t *buffer;
3354         endindex = Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray);
3355         for (i = 0;i < endindex;i++)
3356         {
3357                 buffer = (r_meshbuffer_t *) Mem_ExpandableArray_RecordAtIndex(&gl_state.meshbufferarray, i);
3358                 if (!buffer)
3359                         continue;
3360                 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)");}
3361                 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)");}
3362         }
3363         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);
3364 }
3365
3366
3367
3368 void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
3369 {
3370         switch(vid.renderpath)
3371         {
3372         case RENDERPATH_GL11:
3373         case RENDERPATH_GL13:
3374         case RENDERPATH_GLES1:
3375                 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)
3376                 {
3377                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3378                         gl_state.pointer_vertex_components = components;
3379                         gl_state.pointer_vertex_gltype = gltype;
3380                         gl_state.pointer_vertex_stride = stride;
3381                         gl_state.pointer_vertex_pointer = pointer;
3382                         gl_state.pointer_vertex_vertexbuffer = vertexbuffer;
3383                         gl_state.pointer_vertex_offset = bufferoffset;
3384                         CHECKGLERROR
3385                         GL_BindVBO(bufferobject);
3386                         qglVertexPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3387                 }
3388                 break;
3389         case RENDERPATH_GL20:
3390         case RENDERPATH_GLES2:
3391                 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)
3392                 {
3393                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3394                         gl_state.pointer_vertex_components = components;
3395                         gl_state.pointer_vertex_gltype = gltype;
3396                         gl_state.pointer_vertex_stride = stride;
3397                         gl_state.pointer_vertex_pointer = pointer;
3398                         gl_state.pointer_vertex_vertexbuffer = vertexbuffer;
3399                         gl_state.pointer_vertex_offset = bufferoffset;
3400                         CHECKGLERROR
3401                         GL_BindVBO(bufferobject);
3402                         qglVertexAttribPointer(GLSLATTRIB_POSITION, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3403                 }
3404                 break;
3405         case RENDERPATH_D3D9:
3406         case RENDERPATH_D3D10:
3407         case RENDERPATH_D3D11:
3408         case RENDERPATH_SOFT:
3409                 break;
3410         }
3411 }
3412
3413 void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
3414 {
3415         // note: vertexbuffer may be non-NULL even if pointer is NULL, so check
3416         // the pointer only.
3417         switch(vid.renderpath)
3418         {
3419         case RENDERPATH_GL11:
3420         case RENDERPATH_GL13:
3421         case RENDERPATH_GLES1:
3422 #ifdef GL_MODELVIEW
3423                 CHECKGLERROR
3424                 if (pointer)
3425                 {
3426                         // caller wants color array enabled
3427                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3428                         if (!gl_state.pointer_color_enabled)
3429                         {
3430                                 gl_state.pointer_color_enabled = true;
3431                                 CHECKGLERROR
3432                                 qglEnableClientState(GL_COLOR_ARRAY);CHECKGLERROR
3433                         }
3434                         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)
3435                         {
3436                                 gl_state.pointer_color_components = components;
3437                                 gl_state.pointer_color_gltype = gltype;
3438                                 gl_state.pointer_color_stride = stride;
3439                                 gl_state.pointer_color_pointer = pointer;
3440                                 gl_state.pointer_color_vertexbuffer = vertexbuffer;
3441                                 gl_state.pointer_color_offset = bufferoffset;
3442                                 CHECKGLERROR
3443                                 GL_BindVBO(bufferobject);
3444                                 qglColorPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3445                         }
3446                 }
3447                 else
3448                 {
3449                         // caller wants color array disabled
3450                         if (gl_state.pointer_color_enabled)
3451                         {
3452                                 gl_state.pointer_color_enabled = false;
3453                                 CHECKGLERROR
3454                                 qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
3455                                 // when color array is on the glColor gets trashed, set it again
3456                                 qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
3457                         }
3458                 }
3459 #endif
3460                 break;
3461         case RENDERPATH_GL20:
3462         case RENDERPATH_GLES2:
3463                 CHECKGLERROR
3464                 if (pointer)
3465                 {
3466                         // caller wants color array enabled
3467                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3468                         if (!gl_state.pointer_color_enabled)
3469                         {
3470                                 gl_state.pointer_color_enabled = true;
3471                                 CHECKGLERROR
3472                                 qglEnableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
3473                         }
3474                         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)
3475                         {
3476                                 gl_state.pointer_color_components = components;
3477                                 gl_state.pointer_color_gltype = gltype;
3478                                 gl_state.pointer_color_stride = stride;
3479                                 gl_state.pointer_color_pointer = pointer;
3480                                 gl_state.pointer_color_vertexbuffer = vertexbuffer;
3481                                 gl_state.pointer_color_offset = bufferoffset;
3482                                 CHECKGLERROR
3483                                 GL_BindVBO(bufferobject);
3484                                 qglVertexAttribPointer(GLSLATTRIB_COLOR, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3485                         }
3486                 }
3487                 else
3488                 {
3489                         // caller wants color array disabled
3490                         if (gl_state.pointer_color_enabled)
3491                         {
3492                                 gl_state.pointer_color_enabled = false;
3493                                 CHECKGLERROR
3494                                 qglDisableVertexAttribArray(GLSLATTRIB_COLOR);CHECKGLERROR
3495                                 // when color array is on the glColor gets trashed, set it again
3496                                 qglVertexAttrib4f(GLSLATTRIB_COLOR, gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
3497                         }
3498                 }
3499                 break;
3500         case RENDERPATH_D3D9:
3501         case RENDERPATH_D3D10:
3502         case RENDERPATH_D3D11:
3503         case RENDERPATH_SOFT:
3504                 break;
3505         }
3506 }
3507
3508 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)
3509 {
3510         gltextureunit_t *unit = gl_state.units + unitnum;
3511         // update array settings
3512         // note: there is no need to check bufferobject here because all cases
3513         // that involve a valid bufferobject also supply a texcoord array
3514         switch(vid.renderpath)
3515         {
3516         case RENDERPATH_GL11:
3517         case RENDERPATH_GL13:
3518         case RENDERPATH_GLES1:
3519 #ifdef GL_MODELVIEW
3520                 CHECKGLERROR
3521                 if (pointer)
3522                 {
3523                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3524                         // texture array unit is enabled, enable the array
3525                         if (!unit->arrayenabled)
3526                         {
3527                                 unit->arrayenabled = true;
3528                                 GL_ClientActiveTexture(unitnum);
3529                                 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
3530                         }
3531                         // texcoord array
3532                         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)
3533                         {
3534                                 unit->pointer_texcoord_components = components;
3535                                 unit->pointer_texcoord_gltype = gltype;
3536                                 unit->pointer_texcoord_stride = stride;
3537                                 unit->pointer_texcoord_pointer = pointer;
3538                                 unit->pointer_texcoord_vertexbuffer = vertexbuffer;
3539                                 unit->pointer_texcoord_offset = bufferoffset;
3540                                 GL_ClientActiveTexture(unitnum);
3541                                 GL_BindVBO(bufferobject);
3542                                 qglTexCoordPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3543                         }
3544                 }
3545                 else
3546                 {
3547                         // texture array unit is disabled, disable the array
3548                         if (unit->arrayenabled)
3549                         {
3550                                 unit->arrayenabled = false;
3551                                 GL_ClientActiveTexture(unitnum);
3552                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
3553                         }
3554                 }
3555 #endif
3556                 break;
3557         case RENDERPATH_GL20:
3558         case RENDERPATH_GLES2:
3559                 CHECKGLERROR
3560                 if (pointer)
3561                 {
3562                         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
3563                         // texture array unit is enabled, enable the array
3564                         if (!unit->arrayenabled)
3565                         {
3566                                 unit->arrayenabled = true;
3567                                 qglEnableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
3568                         }
3569                         // texcoord array
3570                         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)
3571                         {
3572                                 unit->pointer_texcoord_components = components;
3573                                 unit->pointer_texcoord_gltype = gltype;
3574                                 unit->pointer_texcoord_stride = stride;
3575                                 unit->pointer_texcoord_pointer = pointer;
3576                                 unit->pointer_texcoord_vertexbuffer = vertexbuffer;
3577                                 unit->pointer_texcoord_offset = bufferoffset;
3578                                 GL_BindVBO(bufferobject);
3579                                 qglVertexAttribPointer(unitnum+GLSLATTRIB_TEXCOORD0, components, gltype, false, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
3580                         }
3581                 }
3582                 else
3583                 {
3584                         // texture array unit is disabled, disable the array
3585                         if (unit->arrayenabled)
3586                         {
3587                                 unit->arrayenabled = false;
3588                                 qglDisableVertexAttribArray(unitnum+GLSLATTRIB_TEXCOORD0);CHECKGLERROR
3589                         }
3590                 }
3591                 break;
3592         case RENDERPATH_D3D9:
3593         case RENDERPATH_D3D10:
3594         case RENDERPATH_D3D11:
3595         case RENDERPATH_SOFT:
3596                 break;
3597         }
3598 }
3599
3600 int R_Mesh_TexBound(unsigned int unitnum, int id)
3601 {
3602         gltextureunit_t *unit = gl_state.units + unitnum;
3603         if (unitnum >= vid.teximageunits)
3604                 return 0;
3605         if (id == GL_TEXTURE_2D)
3606                 return unit->t2d;
3607         if (id == GL_TEXTURE_3D)
3608                 return unit->t3d;
3609         if (id == GL_TEXTURE_CUBE_MAP)
3610                 return unit->tcubemap;
3611         return 0;
3612 }
3613
3614 void R_Mesh_CopyToTexture(rtexture_t *tex, int tx, int ty, int sx, int sy, int width, int height)
3615 {
3616         switch(vid.renderpath)
3617         {
3618         case RENDERPATH_GL11:
3619         case RENDERPATH_GL13:
3620         case RENDERPATH_GL20:
3621         case RENDERPATH_GLES1:
3622         case RENDERPATH_GLES2:
3623                 R_Mesh_TexBind(0, tex);
3624                 GL_ActiveTexture(0);CHECKGLERROR
3625                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, sx, sy, width, height);CHECKGLERROR
3626                 break;
3627         case RENDERPATH_D3D9:
3628 #ifdef SUPPORTD3D
3629                 {
3630                         IDirect3DSurface9 *currentsurface = NULL;
3631                         IDirect3DSurface9 *texturesurface = NULL;
3632                         RECT sourcerect;
3633                         RECT destrect;
3634                         sourcerect.left = sx;
3635                         sourcerect.top = sy;
3636                         sourcerect.right = sx + width;
3637                         sourcerect.bottom = sy + height;
3638                         destrect.left = tx;
3639                         destrect.top = ty;
3640                         destrect.right = tx + width;
3641                         destrect.bottom = ty + height;
3642                         if (!FAILED(IDirect3DTexture9_GetSurfaceLevel(((IDirect3DTexture9 *)tex->d3dtexture), 0, &texturesurface)))
3643                         {
3644                                 if (!FAILED(IDirect3DDevice9_GetRenderTarget(vid_d3d9dev, 0, &currentsurface)))
3645                                 {
3646                                         IDirect3DDevice9_StretchRect(vid_d3d9dev, currentsurface, &sourcerect, texturesurface, &destrect, D3DTEXF_NONE);
3647                                         IDirect3DSurface9_Release(currentsurface);
3648                                 }
3649                                 IDirect3DSurface9_Release(texturesurface);
3650                         }
3651                 }
3652 #endif
3653                 break;
3654         case RENDERPATH_D3D10:
3655                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3656                 break;
3657         case RENDERPATH_D3D11:
3658                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3659                 break;
3660         case RENDERPATH_SOFT:
3661                 DPSOFTRAST_CopyRectangleToTexture(tex->texnum, 0, tx, ty, sx, sy, width, height);
3662                 break;
3663         }
3664 }
3665
3666 #ifdef SUPPORTD3D
3667 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};
3668 #endif
3669
3670 void R_Mesh_ClearBindingsForTexture(int texnum)
3671 {
3672         gltextureunit_t *unit;
3673         unsigned int unitnum;
3674         // 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)
3675         for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
3676         {
3677                 unit = gl_state.units + unitnum;
3678                 if (unit->t2d == texnum)
3679                         unit->t2d = -1;
3680                 if (unit->t3d == texnum)
3681                         unit->t3d = -1;
3682                 if (unit->tcubemap == texnum)
3683                         unit->tcubemap = -1;
3684         }
3685 }
3686
3687 void R_Mesh_TexBind(unsigned int unitnum, rtexture_t *tex)
3688 {
3689         gltextureunit_t *unit = gl_state.units + unitnum;
3690         int tex2d, tex3d, texcubemap, texnum;
3691         if (unitnum >= vid.teximageunits)
3692                 return;
3693 //      if (unit->texture == tex)
3694 //              return;
3695         switch(vid.renderpath)
3696         {
3697         case RENDERPATH_GL20:
3698         case RENDERPATH_GLES2:
3699                 if (!tex)
3700                 {
3701                         tex = r_texture_white;
3702                         // not initialized enough yet...
3703                         if (!tex)
3704                                 return;
3705                 }
3706                 unit->texture = tex;
3707                 texnum = R_GetTexture(tex);
3708                 switch(tex->gltexturetypeenum)
3709                 {
3710                 case GL_TEXTURE_2D: if (unit->t2d != texnum) {GL_ActiveTexture(unitnum);unit->t2d = texnum;qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR}break;
3711                 case GL_TEXTURE_3D: if (unit->t3d != texnum) {GL_ActiveTexture(unitnum);unit->t3d = texnum;qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR}break;
3712                 case GL_TEXTURE_CUBE_MAP: if (unit->tcubemap != texnum) {GL_ActiveTexture(unitnum);unit->tcubemap = texnum;qglBindTexture(GL_TEXTURE_CUBE_MAP, unit->tcubemap);CHECKGLERROR}break;
3713                 }
3714                 break;
3715         case RENDERPATH_GL11:
3716         case RENDERPATH_GL13:
3717         case RENDERPATH_GLES1:
3718                 unit->texture = tex;
3719                 tex2d = 0;
3720                 tex3d = 0;
3721                 texcubemap = 0;
3722                 if (tex)
3723                 {
3724                         texnum = R_GetTexture(tex);
3725                         switch(tex->gltexturetypeenum)
3726                         {
3727                         case GL_TEXTURE_2D:
3728                                 tex2d = texnum;
3729                                 break;
3730                         case GL_TEXTURE_3D:
3731                                 tex3d = texnum;
3732                                 break;
3733                         case GL_TEXTURE_CUBE_MAP:
3734                                 texcubemap = texnum;
3735                                 break;
3736                         }
3737                 }
3738                 // update 2d texture binding
3739                 if (unit->t2d != tex2d)
3740                 {
3741                         GL_ActiveTexture(unitnum);
3742                         if (tex2d)
3743                         {
3744                                 if (unit->t2d == 0)
3745                                 {
3746                                         qglEnable(GL_TEXTURE_2D);CHECKGLERROR
3747                                 }
3748                         }
3749                         else
3750                         {
3751                                 if (unit->t2d)
3752                                 {
3753                                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
3754                                 }
3755                         }
3756                         unit->t2d = tex2d;
3757                         qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
3758                 }
3759                 // update 3d texture binding
3760                 if (unit->t3d != tex3d)
3761                 {
3762                         GL_ActiveTexture(unitnum);
3763                         if (tex3d)
3764                         {
3765                                 if (unit->t3d == 0)
3766                                 {
3767                                         qglEnable(GL_TEXTURE_3D);CHECKGLERROR
3768                                 }
3769                         }
3770                         else
3771                         {
3772                                 if (unit->t3d)
3773                                 {
3774                                         qglDisable(GL_TEXTURE_3D);CHECKGLERROR
3775                                 }
3776                         }
3777                         unit->t3d = tex3d;
3778                         qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
3779                 }
3780                 // update cubemap texture binding
3781                 if (unit->tcubemap != texcubemap)
3782                 {
3783                         GL_ActiveTexture(unitnum);
3784                         if (texcubemap)
3785                         {
3786                                 if (unit->tcubemap == 0)
3787                                 {
3788                                         qglEnable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
3789                                 }
3790                         }
3791                         else
3792                         {
3793                                 if (unit->tcubemap)
3794                                 {
3795                                         qglDisable(GL_TEXTURE_CUBE_MAP);CHECKGLERROR
3796                                 }
3797                         }
3798                         unit->tcubemap = texcubemap;
3799                         qglBindTexture(GL_TEXTURE_CUBE_MAP, unit->tcubemap);CHECKGLERROR
3800                 }
3801                 break;
3802         case RENDERPATH_D3D9:
3803 #ifdef SUPPORTD3D
3804                 {
3805                         extern cvar_t gl_texture_anisotropy;
3806                         if (!tex)
3807                         {
3808                                 tex = r_texture_white;
3809                                 // not initialized enough yet...
3810                                 if (!tex)
3811                                         return;
3812                         }
3813                         // upload texture if needed
3814                         R_GetTexture(tex);
3815                         if (unit->texture == tex)
3816                                 return;
3817                         unit->texture = tex;
3818                         IDirect3DDevice9_SetTexture(vid_d3d9dev, unitnum, (IDirect3DBaseTexture9*)tex->d3dtexture);
3819                         //IDirect3DDevice9_SetRenderState(vid_d3d9dev, d3drswrap[unitnum], (tex->flags & TEXF_CLAMP) ? (D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2) : 0);
3820                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSU, tex->d3daddressu);
3821                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSV, tex->d3daddressv);
3822                         if (tex->d3daddressw)
3823                                 IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_ADDRESSW,  tex->d3daddressw);
3824                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAGFILTER, tex->d3dmagfilter);
3825                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MINFILTER, tex->d3dminfilter);
3826                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MIPFILTER, tex->d3dmipfilter);
3827                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MIPMAPLODBIAS, tex->d3dmipmaplodbias);
3828                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAXMIPLEVEL, tex->d3dmaxmiplevelfilter);
3829                         IDirect3DDevice9_SetSamplerState(vid_d3d9dev, unitnum, D3DSAMP_MAXANISOTROPY, gl_texture_anisotropy.integer);
3830                 }
3831 #endif
3832                 break;
3833         case RENDERPATH_D3D10:
3834                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3835                 break;
3836         case RENDERPATH_D3D11:
3837                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3838                 break;
3839         case RENDERPATH_SOFT:
3840                 if (!tex)
3841                 {
3842                         tex = r_texture_white;
3843                         // not initialized enough yet...
3844                         if (!tex)
3845                                 return;
3846                 }
3847                 texnum = R_GetTexture(tex);
3848                 if (unit->texture == tex)
3849                         return;
3850                 unit->texture = tex;
3851                 DPSOFTRAST_SetTexture(unitnum, texnum);
3852                 break;
3853         }
3854 }
3855
3856 void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix)
3857 {
3858         gltextureunit_t *unit = gl_state.units + unitnum;
3859         switch(vid.renderpath)
3860         {
3861         case RENDERPATH_GL11:
3862         case RENDERPATH_GL13:
3863         case RENDERPATH_GL20:
3864         case RENDERPATH_GLES1:
3865         case RENDERPATH_GLES2:
3866 #ifdef GL_MODELVIEW
3867                 if (matrix && matrix->m[3][3])
3868                 {
3869                         // texmatrix specified, check if it is different
3870                         if (!unit->texmatrixenabled || memcmp(&unit->matrix, matrix, sizeof(matrix4x4_t)))
3871                         {
3872                                 float glmatrix[16];
3873                                 unit->texmatrixenabled = true;
3874                                 unit->matrix = *matrix;
3875                                 CHECKGLERROR
3876                                 Matrix4x4_ToArrayFloatGL(&unit->matrix, glmatrix);
3877                                 GL_ActiveTexture(unitnum);
3878                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
3879                                 qglLoadMatrixf(glmatrix);CHECKGLERROR
3880                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
3881                         }
3882                 }
3883                 else
3884                 {
3885                         // no texmatrix specified, revert to identity
3886                         if (unit->texmatrixenabled)
3887                         {
3888                                 unit->texmatrixenabled = false;
3889                                 unit->matrix = identitymatrix;
3890                                 CHECKGLERROR
3891                                 GL_ActiveTexture(unitnum);
3892                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
3893                                 qglLoadIdentity();CHECKGLERROR
3894                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
3895                         }
3896                 }
3897 #endif
3898                 break;
3899         case RENDERPATH_D3D9:
3900         case RENDERPATH_D3D10:
3901         case RENDERPATH_D3D11:
3902                 break;
3903         case RENDERPATH_SOFT:
3904                 break;
3905         }
3906 }
3907
3908 void R_Mesh_TexCombine(unsigned int unitnum, int combinergb, int combinealpha, int rgbscale, int alphascale)
3909 {
3910         gltextureunit_t *unit = gl_state.units + unitnum;
3911         CHECKGLERROR
3912         switch(vid.renderpath)
3913         {
3914         case RENDERPATH_GL20:
3915         case RENDERPATH_GLES2:
3916                 // do nothing
3917                 break;
3918         case RENDERPATH_GL13:
3919         case RENDERPATH_GLES1:
3920 #ifdef GL_TEXTURE_ENV
3921                 // GL_ARB_texture_env_combine
3922                 if (!combinergb)
3923                         combinergb = GL_MODULATE;
3924                 if (!combinealpha)
3925                         combinealpha = GL_MODULATE;
3926                 if (!rgbscale)
3927                         rgbscale = 1;
3928                 if (!alphascale)
3929                         alphascale = 1;
3930                 if (combinergb != combinealpha || rgbscale != 1 || alphascale != 1)
3931                 {
3932                         if (combinergb == GL_DECAL)
3933                                 combinergb = GL_INTERPOLATE;
3934                         if (unit->combine != GL_COMBINE)
3935                         {
3936                                 unit->combine = GL_COMBINE;
3937                                 GL_ActiveTexture(unitnum);
3938                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);CHECKGLERROR
3939                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);CHECKGLERROR // for GL_INTERPOLATE mode
3940                         }
3941                         if (unit->combinergb != combinergb)
3942                         {
3943                                 unit->combinergb = combinergb;
3944                                 GL_ActiveTexture(unitnum);
3945                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, unit->combinergb);CHECKGLERROR
3946                         }
3947                         if (unit->combinealpha != combinealpha)
3948                         {
3949                                 unit->combinealpha = combinealpha;
3950                                 GL_ActiveTexture(unitnum);
3951                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, unit->combinealpha);CHECKGLERROR
3952                         }
3953                         if (unit->rgbscale != rgbscale)
3954                         {
3955                                 unit->rgbscale = rgbscale;
3956                                 GL_ActiveTexture(unitnum);
3957                                 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, unit->rgbscale);CHECKGLERROR
3958                         }
3959                         if (unit->alphascale != alphascale)
3960                         {
3961                                 unit->alphascale = alphascale;
3962                                 GL_ActiveTexture(unitnum);
3963                                 qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, unit->alphascale);CHECKGLERROR
3964                         }
3965                 }
3966                 else
3967                 {
3968                         if (unit->combine != combinergb)
3969                         {
3970                                 unit->combine = combinergb;
3971                                 GL_ActiveTexture(unitnum);
3972                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
3973                         }
3974                 }
3975 #endif
3976                 break;
3977         case RENDERPATH_GL11:
3978                 // normal GL texenv
3979 #ifdef GL_TEXTURE_ENV
3980                 if (!combinergb)
3981                         combinergb = GL_MODULATE;
3982                 if (unit->combine != combinergb)
3983                 {
3984                         unit->combine = combinergb;
3985                         GL_ActiveTexture(unitnum);
3986                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
3987                 }
3988 #endif
3989                 break;
3990         case RENDERPATH_D3D9:
3991         case RENDERPATH_D3D10:
3992         case RENDERPATH_D3D11:
3993                 break;
3994         case RENDERPATH_SOFT:
3995                 break;
3996         }
3997 }
3998
3999 void R_Mesh_ResetTextureState(void)
4000 {
4001         unsigned int unitnum;
4002
4003         BACKENDACTIVECHECK
4004
4005         for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
4006                 R_Mesh_TexBind(unitnum, NULL);
4007         for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++)
4008                 R_Mesh_TexCoordPointer(unitnum, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4009         switch(vid.renderpath)
4010         {
4011         case RENDERPATH_GL20:
4012         case RENDERPATH_GLES2:
4013         case RENDERPATH_D3D9:
4014         case RENDERPATH_D3D10:
4015         case RENDERPATH_D3D11:
4016         case RENDERPATH_SOFT:
4017                 break;
4018         case RENDERPATH_GL11:
4019         case RENDERPATH_GL13:
4020         case RENDERPATH_GLES1:
4021                 for (unitnum = 0;unitnum < vid.texunits;unitnum++)
4022                 {
4023                         R_Mesh_TexCombine(unitnum, GL_MODULATE, GL_MODULATE, 1, 1);
4024                         R_Mesh_TexMatrix(unitnum, NULL);
4025                 }
4026                 break;
4027         }
4028 }
4029
4030
4031
4032 #ifdef SUPPORTD3D
4033 //#define r_vertex3f_d3d9fvf (D3DFVF_XYZ)
4034 //#define r_vertexgeneric_d3d9fvf (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)
4035 //#define r_vertexmesh_d3d9fvf (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX5 | D3DFVF_TEXCOORDSIZE1(3) | D3DFVF_TEXCOORDSIZE2(3) | D3DFVF_TEXCOORDSIZE3(3))
4036
4037 D3DVERTEXELEMENT9 r_vertex3f_d3d9elements[] =
4038 {
4039         {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4040         D3DDECL_END()
4041 };
4042
4043 D3DVERTEXELEMENT9 r_vertexgeneric_d3d9elements[] =
4044 {
4045         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->vertex3f  ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4046         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->color4f   ), D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
4047         {0, (int)((size_t)&((r_vertexgeneric_t *)0)->texcoord2f), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
4048         D3DDECL_END()
4049 };
4050
4051 D3DVERTEXELEMENT9 r_vertexmesh_d3d9elements[] =
4052 {
4053         {0, (int)((size_t)&((r_vertexmesh_t *)0)->vertex3f          ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4054         {0, (int)((size_t)&((r_vertexmesh_t *)0)->color4f           ), D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
4055         {0, (int)((size_t)&((r_vertexmesh_t *)0)->texcoordtexture2f ), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
4056         {0, (int)((size_t)&((r_vertexmesh_t *)0)->svector3f         ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
4057         {0, (int)((size_t)&((r_vertexmesh_t *)0)->tvector3f         ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 2},
4058         {0, (int)((size_t)&((r_vertexmesh_t *)0)->normal3f          ), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 3},
4059         {0, (int)((size_t)&((r_vertexmesh_t *)0)->texcoordlightmap2f), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 4},
4060         D3DDECL_END()
4061 };
4062
4063 IDirect3DVertexDeclaration9 *r_vertex3f_d3d9decl;
4064 IDirect3DVertexDeclaration9 *r_vertexgeneric_d3d9decl;
4065 IDirect3DVertexDeclaration9 *r_vertexmesh_d3d9decl;
4066 #endif
4067
4068 static void R_Mesh_InitVertexDeclarations(void)
4069 {
4070 #ifdef SUPPORTD3D
4071         r_vertex3f_d3d9decl = NULL;
4072         r_vertexgeneric_d3d9decl = NULL;
4073         r_vertexmesh_d3d9decl = NULL;
4074         switch(vid.renderpath)
4075         {
4076         case RENDERPATH_GL20:
4077         case RENDERPATH_GL13:
4078         case RENDERPATH_GL11:
4079         case RENDERPATH_GLES1:
4080         case RENDERPATH_GLES2:
4081                 break;
4082         case RENDERPATH_D3D9:
4083                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertex3f_d3d9elements, &r_vertex3f_d3d9decl);
4084                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertexgeneric_d3d9elements, &r_vertexgeneric_d3d9decl);
4085                 IDirect3DDevice9_CreateVertexDeclaration(vid_d3d9dev, r_vertexmesh_d3d9elements, &r_vertexmesh_d3d9decl);
4086                 break;
4087         case RENDERPATH_D3D10:
4088                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4089                 break;
4090         case RENDERPATH_D3D11:
4091                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4092                 break;
4093         case RENDERPATH_SOFT:
4094                 break;
4095         }
4096 #endif
4097 }
4098
4099 static void R_Mesh_DestroyVertexDeclarations(void)
4100 {
4101 #ifdef SUPPORTD3D
4102         if (r_vertex3f_d3d9decl)
4103                 IDirect3DVertexDeclaration9_Release(r_vertex3f_d3d9decl);
4104         r_vertex3f_d3d9decl = NULL;
4105         if (r_vertexgeneric_d3d9decl)
4106                 IDirect3DVertexDeclaration9_Release(r_vertexgeneric_d3d9decl);
4107         r_vertexgeneric_d3d9decl = NULL;
4108         if (r_vertexmesh_d3d9decl)
4109                 IDirect3DVertexDeclaration9_Release(r_vertexmesh_d3d9decl);
4110         r_vertexmesh_d3d9decl = NULL;
4111 #endif
4112 }
4113
4114 void R_Mesh_PrepareVertices_Vertex3f(int numvertices, const float *vertex3f, const r_meshbuffer_t *vertexbuffer)
4115 {
4116         // upload temporary vertexbuffer for this rendering
4117         if (!gl_state.usevbo_staticvertex)
4118                 vertexbuffer = NULL;
4119         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4120         {
4121                 if (gl_state.preparevertices_dynamicvertexbuffer)
4122                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex3f, numvertices * sizeof(float[3]));
4123                 else
4124                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex3f, numvertices * sizeof(float[3]), "temporary", false, true, false);
4125                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
4126         }
4127         switch(vid.renderpath)
4128         {
4129         case RENDERPATH_GL20:
4130         case RENDERPATH_GLES2:
4131                 if (vertexbuffer)
4132                 {
4133                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4134                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4135                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4136                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4137                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4138                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4139                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4140                 }
4141                 else
4142                 {
4143                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4144                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4145                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4146                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4147                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4148                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4149                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4150                 }
4151                 break;
4152         case RENDERPATH_GL13:
4153         case RENDERPATH_GLES1:
4154                 if (vertexbuffer)
4155                 {
4156                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4157                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4158                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4159                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4160                 }
4161                 else
4162                 {
4163                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4164                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4165                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4166                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4167                 }
4168                 break;
4169         case RENDERPATH_GL11:
4170                 if (vertexbuffer)
4171                 {
4172                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4173                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4174                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4175                 }
4176                 else
4177                 {
4178                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, vertexbuffer, 0);
4179                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
4180                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4181                 }
4182                 break;
4183         case RENDERPATH_D3D9:
4184 #ifdef SUPPORTD3D
4185                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertex3f_d3d9decl);
4186                 if (vertexbuffer)
4187                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, 0, sizeof(float[3]));
4188                 else
4189                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4190                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4191                 gl_state.d3dvertexdata = (void *)vertex3f;
4192                 gl_state.d3dvertexsize = sizeof(float[3]);
4193 #endif
4194                 break;
4195         case RENDERPATH_D3D10:
4196                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4197                 break;
4198         case RENDERPATH_D3D11:
4199                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4200                 break;
4201         case RENDERPATH_SOFT:
4202                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4203                 DPSOFTRAST_SetColorPointer(NULL, 0);
4204                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), NULL);
4205                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(float[2]), NULL);
4206                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(float[2]), NULL);
4207                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(float[2]), NULL);
4208                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), NULL);
4209                 break;
4210         }
4211 }
4212
4213
4214
4215 r_vertexgeneric_t *R_Mesh_PrepareVertices_Generic_Lock(int numvertices)
4216 {
4217         size_t size;
4218         size = sizeof(r_vertexgeneric_t) * numvertices;
4219         if (gl_state.preparevertices_tempdatamaxsize < size)
4220         {
4221                 gl_state.preparevertices_tempdatamaxsize = size;
4222                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
4223         }
4224         gl_state.preparevertices_vertexgeneric = (r_vertexgeneric_t *)gl_state.preparevertices_tempdata;
4225         gl_state.preparevertices_numvertices = numvertices;
4226         return gl_state.preparevertices_vertexgeneric;
4227 }
4228
4229 qboolean R_Mesh_PrepareVertices_Generic_Unlock(void)
4230 {
4231         R_Mesh_PrepareVertices_Generic(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexgeneric, NULL);
4232         gl_state.preparevertices_vertexgeneric = NULL;
4233         gl_state.preparevertices_numvertices = 0;
4234         return true;
4235 }
4236
4237 void R_Mesh_PrepareVertices_Generic_Arrays(int numvertices, const float *vertex3f, const float *color4f, const float *texcoord2f)
4238 {
4239         int i;
4240         r_vertexgeneric_t *vertex;
4241         switch(vid.renderpath)
4242         {
4243         case RENDERPATH_GL20:
4244         case RENDERPATH_GLES2:
4245                 if (!vid.useinterleavedarrays)
4246                 {
4247                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4248                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4249                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
4250                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4251                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4252                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4253                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4254                         return;
4255                 }
4256                 break;
4257         case RENDERPATH_GL11:
4258         case RENDERPATH_GL13:
4259         case RENDERPATH_GLES1:
4260                 if (!vid.useinterleavedarrays)
4261                 {
4262                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4263                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4264                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
4265                         if (vid.texunits >= 2)
4266                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4267                         if (vid.texunits >= 3)
4268                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4269                         return;
4270                 }
4271                 break;
4272         case RENDERPATH_D3D9:
4273         case RENDERPATH_D3D10:
4274         case RENDERPATH_D3D11:
4275                 break;
4276         case RENDERPATH_SOFT:
4277                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4278                 DPSOFTRAST_SetColorPointer(color4f, sizeof(float[4]));
4279                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), texcoord2f);
4280                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(float[2]), NULL);
4281                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(float[2]), NULL);
4282                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(float[2]), NULL);
4283                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), NULL);
4284                 return;
4285         }
4286
4287         // no quick path for this case, convert to vertex structs
4288         vertex = R_Mesh_PrepareVertices_Generic_Lock(numvertices);
4289         for (i = 0;i < numvertices;i++)
4290                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
4291         if (color4f)
4292         {
4293                 for (i = 0;i < numvertices;i++)
4294                         Vector4Copy(color4f + 4*i, vertex[i].color4f);
4295         }
4296         else
4297         {
4298                 for (i = 0;i < numvertices;i++)
4299                         Vector4Copy(gl_state.color4f, vertex[i].color4f);
4300         }
4301         if (texcoord2f)
4302                 for (i = 0;i < numvertices;i++)
4303                         Vector2Copy(texcoord2f + 2*i, vertex[i].texcoord2f);
4304         R_Mesh_PrepareVertices_Generic_Unlock();
4305         R_Mesh_PrepareVertices_Generic(numvertices, vertex, NULL);
4306 }
4307
4308 void R_Mesh_PrepareVertices_Generic(int numvertices, const r_vertexgeneric_t *vertex, const r_meshbuffer_t *vertexbuffer)
4309 {
4310         // upload temporary vertexbuffer for this rendering
4311         if (!gl_state.usevbo_staticvertex)
4312                 vertexbuffer = NULL;
4313         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4314         {
4315                 if (gl_state.preparevertices_dynamicvertexbuffer)
4316                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex));
4317                 else
4318                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true, false);
4319                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
4320         }
4321         switch(vid.renderpath)
4322         {
4323         case RENDERPATH_GL20:
4324         case RENDERPATH_GLES2:
4325                 if (vertexbuffer)
4326                 {
4327                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4328                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4329                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4330                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4331                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4332                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4333                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4334                 }
4335                 else
4336                 {
4337                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4338                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4339                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4340                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4341                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4342                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4343                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4344                 }
4345                 break;
4346         case RENDERPATH_GL13:
4347         case RENDERPATH_GLES1:
4348                 if (vertexbuffer)
4349                 {
4350                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4351                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4352                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4353                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4354                 }
4355                 else
4356                 {
4357                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4358                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4359                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4360                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4361                 }
4362                 break;
4363         case RENDERPATH_GL11:
4364                 if (vertexbuffer)
4365                 {
4366                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4367                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4368                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
4369                 }
4370                 else
4371                 {
4372                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4373                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4374                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
4375                 }
4376                 break;
4377         case RENDERPATH_D3D9:
4378 #ifdef SUPPORTD3D
4379                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertexgeneric_d3d9decl);
4380                 if (vertexbuffer)
4381                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, 0, sizeof(*vertex));
4382                 else
4383                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4384                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4385                 gl_state.d3dvertexdata = (void *)vertex;
4386                 gl_state.d3dvertexsize = sizeof(*vertex);
4387 #endif
4388                 break;
4389         case RENDERPATH_D3D10:
4390                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4391                 break;
4392         case RENDERPATH_D3D11:
4393                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4394                 break;
4395         case RENDERPATH_SOFT:
4396                 DPSOFTRAST_SetVertexPointer(vertex->vertex3f, sizeof(*vertex));
4397                 DPSOFTRAST_SetColorPointer(vertex->color4f, sizeof(*vertex));
4398                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(*vertex), vertex->texcoord2f);
4399                 DPSOFTRAST_SetTexCoordPointer(1, 2, sizeof(*vertex), NULL);
4400                 DPSOFTRAST_SetTexCoordPointer(2, 2, sizeof(*vertex), NULL);
4401                 DPSOFTRAST_SetTexCoordPointer(3, 2, sizeof(*vertex), NULL);
4402                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(*vertex), NULL);
4403                 break;
4404         }
4405 }
4406
4407
4408
4409 r_vertexmesh_t *R_Mesh_PrepareVertices_Mesh_Lock(int numvertices)
4410 {
4411         size_t size;
4412         size = sizeof(r_vertexmesh_t) * numvertices;
4413         if (gl_state.preparevertices_tempdatamaxsize < size)
4414         {
4415                 gl_state.preparevertices_tempdatamaxsize = size;
4416                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
4417         }
4418         gl_state.preparevertices_vertexmesh = (r_vertexmesh_t *)gl_state.preparevertices_tempdata;
4419         gl_state.preparevertices_numvertices = numvertices;
4420         return gl_state.preparevertices_vertexmesh;
4421 }
4422
4423 qboolean R_Mesh_PrepareVertices_Mesh_Unlock(void)
4424 {
4425         R_Mesh_PrepareVertices_Mesh(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexmesh, NULL);
4426         gl_state.preparevertices_vertexmesh = NULL;
4427         gl_state.preparevertices_numvertices = 0;
4428         return true;
4429 }
4430
4431 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)
4432 {
4433         int i;
4434         r_vertexmesh_t *vertex;
4435         switch(vid.renderpath)
4436         {
4437         case RENDERPATH_GL20:
4438         case RENDERPATH_GLES2:
4439                 if (!vid.useinterleavedarrays)
4440                 {
4441                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4442                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4443                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
4444                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), svector3f, NULL, 0);
4445                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), tvector3f, NULL, 0);
4446                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), normal3f, NULL, 0);
4447                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
4448                         return;
4449                 }
4450                 break;
4451         case RENDERPATH_GL11:
4452         case RENDERPATH_GL13:
4453         case RENDERPATH_GLES1:
4454                 if (!vid.useinterleavedarrays)
4455                 {
4456                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
4457                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
4458                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
4459                         if (vid.texunits >= 2)
4460                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
4461                         if (vid.texunits >= 3)
4462                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
4463                         return;
4464                 }
4465                 break;
4466         case RENDERPATH_D3D9:
4467         case RENDERPATH_D3D10:
4468         case RENDERPATH_D3D11:
4469                 break;
4470         case RENDERPATH_SOFT:
4471                 DPSOFTRAST_SetVertexPointer(vertex3f, sizeof(float[3]));
4472                 DPSOFTRAST_SetColorPointer(color4f, sizeof(float[4]));
4473                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(float[2]), texcoordtexture2f);
4474                 DPSOFTRAST_SetTexCoordPointer(1, 3, sizeof(float[3]), svector3f);
4475                 DPSOFTRAST_SetTexCoordPointer(2, 3, sizeof(float[3]), tvector3f);
4476                 DPSOFTRAST_SetTexCoordPointer(3, 3, sizeof(float[3]), normal3f);
4477                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(float[2]), texcoordlightmap2f);
4478                 return;
4479         }
4480
4481         vertex = R_Mesh_PrepareVertices_Mesh_Lock(numvertices);
4482         for (i = 0;i < numvertices;i++)
4483                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
4484         if (svector3f)
4485                 for (i = 0;i < numvertices;i++)
4486                         VectorCopy(svector3f + 3*i, vertex[i].svector3f);
4487         if (tvector3f)
4488                 for (i = 0;i < numvertices;i++)
4489                         VectorCopy(tvector3f + 3*i, vertex[i].tvector3f);
4490         if (normal3f)
4491                 for (i = 0;i < numvertices;i++)
4492                         VectorCopy(normal3f + 3*i, vertex[i].normal3f);
4493         if (color4f)
4494         {
4495                 for (i = 0;i < numvertices;i++)
4496                         Vector4Copy(color4f + 4*i, vertex[i].color4f);
4497         }
4498         else
4499         {
4500                 for (i = 0;i < numvertices;i++)
4501                         Vector4Copy(gl_state.color4f, vertex[i].color4f);
4502         }
4503         if (texcoordtexture2f)
4504                 for (i = 0;i < numvertices;i++)
4505                         Vector2Copy(texcoordtexture2f + 2*i, vertex[i].texcoordtexture2f);
4506         if (texcoordlightmap2f)
4507                 for (i = 0;i < numvertices;i++)
4508                         Vector2Copy(texcoordlightmap2f + 2*i, vertex[i].texcoordlightmap2f);
4509         R_Mesh_PrepareVertices_Mesh_Unlock();
4510         R_Mesh_PrepareVertices_Mesh(numvertices, vertex, NULL);
4511 }
4512
4513 void R_Mesh_PrepareVertices_Mesh(int numvertices, const r_vertexmesh_t *vertex, const r_meshbuffer_t *vertexbuffer)
4514 {
4515         // upload temporary vertexbuffer for this rendering
4516         if (!gl_state.usevbo_staticvertex)
4517                 vertexbuffer = NULL;
4518         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
4519         {
4520                 if (gl_state.preparevertices_dynamicvertexbuffer)
4521                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex));
4522                 else
4523                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true, false);
4524                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
4525         }
4526         switch(vid.renderpath)
4527         {
4528         case RENDERPATH_GL20:
4529         case RENDERPATH_GLES2:
4530                 if (vertexbuffer)
4531                 {
4532                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4533                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4534                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4535                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , vertexbuffer, (int)((unsigned char *)vertex->svector3f          - (unsigned char *)vertex));
4536                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , vertexbuffer, (int)((unsigned char *)vertex->tvector3f          - (unsigned char *)vertex));
4537                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , vertexbuffer, (int)((unsigned char *)vertex->normal3f           - (unsigned char *)vertex));
4538                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
4539                 }
4540                 else
4541                 {
4542                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4543                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4544                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4545                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , NULL, 0);
4546                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , NULL, 0);
4547                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , NULL, 0);
4548                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
4549                 }
4550                 break;
4551         case RENDERPATH_GL13:
4552         case RENDERPATH_GLES1:
4553                 if (vertexbuffer)
4554                 {
4555                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4556                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4557                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4558                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
4559                 }
4560                 else
4561                 {
4562                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4563                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4564                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4565                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
4566                 }
4567                 break;
4568         case RENDERPATH_GL11:
4569                 if (vertexbuffer)
4570                 {
4571                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
4572                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , vertexbuffer, (int)((unsigned char *)vertex->color4f            - (unsigned char *)vertex));
4573                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
4574                 }
4575                 else
4576                 {
4577                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
4578                         R_Mesh_ColorPointer(      4, GL_FLOAT        , sizeof(*vertex), vertex->color4f           , NULL, 0);
4579                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
4580                 }
4581                 break;
4582         case RENDERPATH_D3D9:
4583 #ifdef SUPPORTD3D
4584                 IDirect3DDevice9_SetVertexDeclaration(vid_d3d9dev, r_vertexmesh_d3d9decl);
4585                 if (vertexbuffer)
4586                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, (IDirect3DVertexBuffer9*)vertexbuffer->devicebuffer, 0, sizeof(*vertex));
4587                 else
4588                         IDirect3DDevice9_SetStreamSource(vid_d3d9dev, 0, NULL, 0, 0);
4589                 gl_state.d3dvertexbuffer = (void *)vertexbuffer;
4590                 gl_state.d3dvertexdata = (void *)vertex;
4591                 gl_state.d3dvertexsize = sizeof(*vertex);
4592 #endif
4593                 break;
4594         case RENDERPATH_D3D10:
4595                 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4596                 break;
4597         case RENDERPATH_D3D11:
4598                 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4599                 break;
4600         case RENDERPATH_SOFT:
4601                 DPSOFTRAST_SetVertexPointer(vertex->vertex3f, sizeof(*vertex));
4602                 DPSOFTRAST_SetColorPointer(vertex->color4f, sizeof(*vertex));
4603                 DPSOFTRAST_SetTexCoordPointer(0, 2, sizeof(*vertex), vertex->texcoordtexture2f);
4604                 DPSOFTRAST_SetTexCoordPointer(1, 3, sizeof(*vertex), vertex->svector3f);
4605                 DPSOFTRAST_SetTexCoordPointer(2, 3, sizeof(*vertex), vertex->tvector3f);
4606                 DPSOFTRAST_SetTexCoordPointer(3, 3, sizeof(*vertex), vertex->normal3f);
4607                 DPSOFTRAST_SetTexCoordPointer(4, 2, sizeof(*vertex), vertex->texcoordlightmap2f);
4608                 break;
4609         }
4610 }
4611
4612 void GL_BlendEquationSubtract(qboolean negated)
4613 {
4614         if(negated)
4615         {
4616                 switch(vid.renderpath)
4617                 {
4618                 case RENDERPATH_GL11:
4619                 case RENDERPATH_GL13:
4620                 case RENDERPATH_GL20:
4621                 case RENDERPATH_GLES1:
4622                 case RENDERPATH_GLES2:
4623                         qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT);
4624                         break;
4625                 case RENDERPATH_D3D9:
4626 #ifdef SUPPORTD3D
4627                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
4628 #endif
4629                         break;
4630                 case RENDERPATH_D3D10:
4631                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4632                         break;
4633                 case RENDERPATH_D3D11:
4634                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4635                         break;
4636                 case RENDERPATH_SOFT:
4637                         DPSOFTRAST_BlendSubtract(true);
4638                         break;
4639                 }
4640         }
4641         else
4642         {
4643                 switch(vid.renderpath)
4644                 {
4645                 case RENDERPATH_GL11:
4646                 case RENDERPATH_GL13:
4647                 case RENDERPATH_GL20:
4648                 case RENDERPATH_GLES1:
4649                 case RENDERPATH_GLES2:
4650                         qglBlendEquationEXT(GL_FUNC_ADD);
4651                         break;
4652                 case RENDERPATH_D3D9:
4653 #ifdef SUPPORTD3D
4654                         IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
4655 #endif
4656                         break;
4657                 case RENDERPATH_D3D10:
4658                         Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4659                         break;
4660                 case RENDERPATH_D3D11:
4661                         Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4662                         break;
4663                 case RENDERPATH_SOFT:
4664                         DPSOFTRAST_BlendSubtract(false);
4665                         break;
4666                 }
4667         }
4668 }