gl_backend.c

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