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