gl_backend.c

   1
   2 #include "quakedef.h"
   3 #include "cl_collision.h"
   4
   5 cvar_t gl_mesh_drawrangeelements = {0, "gl_mesh_drawrangeelements", "1", "use glDrawRangeElements function if available instead of glDrawElements (for performance comparisons or bug testing)"};
   6 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)"};
   7 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"};
   8 cvar_t gl_mesh_separatearrays = {0, "gl_mesh_separatearrays", "1", "use several separate vertex arrays rather than one combined stream"};
   9 cvar_t gl_paranoid = {0, "gl_paranoid", "0", "enables OpenGL error checking and other tests"};
  10 cvar_t gl_printcheckerror = {0, "gl_printcheckerror", "0", "prints all OpenGL error checks, useful to identify location of driver crashes"};
  11
  12 cvar_t r_render = {0, "r_render", "1", "enables rendering 3D views (you want this on!)"};
  13 cvar_t r_renderview = {0, "r_renderview", "1", "enables rendering 3D views (you want this on!)"};
  14 cvar_t r_waterwarp = {CVAR_SAVE, "r_waterwarp", "1", "warp view while underwater"};
  15 cvar_t gl_polyblend = {CVAR_SAVE, "gl_polyblend", "1", "tints view while underwater, hurt, etc"};
  16 cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1", "enables OpenGL dithering (16bit looks bad with this off)"};
  17 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)"};
  18 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"};
  19 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"};
  20 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"};
  21
  22 cvar_t v_flipped = {0, "v_flipped", "0", "mirror the screen (poor man's left handed mode)"};
  23 qboolean v_flipped_state = false;
  24
  25 r_viewport_t gl_viewport;
  26 matrix4x4_t gl_modelmatrix;
  27 matrix4x4_t gl_viewmatrix;
  28 matrix4x4_t gl_modelviewmatrix;
  29 matrix4x4_t gl_projectionmatrix;
  30 matrix4x4_t gl_modelviewprojectionmatrix;
  31 float gl_modelview16f[16];
  32 float gl_modelviewprojection16f[16];
  33 qboolean gl_modelmatrixchanged;
  34
  35 int gl_maxdrawrangeelementsvertices;
  36 int gl_maxdrawrangeelementsindices;
  37
  38 #ifdef DEBUGGL
  39 int errornumber = 0;
  40
  41 void GL_PrintError(int errornumber, char *filename, int linenumber)
  42 {
  43         switch(errornumber)
  44         {
  45 #ifdef GL_INVALID_ENUM
  46         case GL_INVALID_ENUM:
  47                 Con_Printf("GL_INVALID_ENUM at %s:%i\n", filename, linenumber);
  48                 break;
  49 #endif
  50 #ifdef GL_INVALID_VALUE
  51         case GL_INVALID_VALUE:
  52                 Con_Printf("GL_INVALID_VALUE at %s:%i\n", filename, linenumber);
  53                 break;
  54 #endif
  55 #ifdef GL_INVALID_OPERATION
  56         case GL_INVALID_OPERATION:
  57                 Con_Printf("GL_INVALID_OPERATION at %s:%i\n", filename, linenumber);
  58                 break;
  59 #endif
  60 #ifdef GL_STACK_OVERFLOW
  61         case GL_STACK_OVERFLOW:
  62                 Con_Printf("GL_STACK_OVERFLOW at %s:%i\n", filename, linenumber);
  63                 break;
  64 #endif
  65 #ifdef GL_STACK_UNDERFLOW
  66         case GL_STACK_UNDERFLOW:
  67                 Con_Printf("GL_STACK_UNDERFLOW at %s:%i\n", filename, linenumber);
  68                 break;
  69 #endif
  70 #ifdef GL_OUT_OF_MEMORY
  71         case GL_OUT_OF_MEMORY:
  72                 Con_Printf("GL_OUT_OF_MEMORY at %s:%i\n", filename, linenumber);
  73                 break;
  74 #endif
  75 #ifdef GL_TABLE_TOO_LARGE
  76         case GL_TABLE_TOO_LARGE:
  77                 Con_Printf("GL_TABLE_TOO_LARGE at %s:%i\n", filename, linenumber);
  78                 break;
  79 #endif
  80 #ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT
  81         case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
  82                 Con_Printf("GL_INVALID_FRAMEBUFFER_OPERATION at %s:%i\n", filename, linenumber);
  83                 break;
  84 #endif
  85         default:
  86                 Con_Printf("GL UNKNOWN (%i) at %s:%i\n", errornumber, filename, linenumber);
  87                 break;
  88         }
  89 }
  90 #endif
  91
  92 #define BACKENDACTIVECHECK if (!gl_state.active) Sys_Error("GL backend function called when backend is not active");
  93
  94 void SCR_ScreenShot_f (void);
  95
  96 typedef struct gltextureunit_s
  97 {
  98         int pointer_texcoord_components;
  99         int pointer_texcoord_gltype;
 100         size_t pointer_texcoord_stride;
 101         const void *pointer_texcoord_pointer;
 102         const r_meshbuffer_t *pointer_texcoord_vertexbuffer;
 103         size_t pointer_texcoord_offset;
 104
 105         int t2d, t3d, tcubemap, trectangle;
 106         int arrayenabled;
 107         int rgbscale, alphascale;
 108         int combine;
 109         int combinergb, combinealpha;
 110         // texmatrixenabled exists only to avoid unnecessary texmatrix compares
 111         int texmatrixenabled;
 112         matrix4x4_t matrix;
 113 }
 114 gltextureunit_t;
 115
 116 typedef struct gl_state_s
 117 {
 118         int cullface;
 119         int cullfaceenable;
 120         int blendfunc1;
 121         int blendfunc2;
 122         int blend;
 123         GLboolean depthmask;
 124         int colormask; // stored as bottom 4 bits: r g b a (3 2 1 0 order)
 125         int depthtest;
 126         float depthrange[2];
 127         float polygonoffset[2];
 128         int alphatest;
 129         int scissortest;
 130         unsigned int unit;
 131         unsigned int clientunit;
 132         gltextureunit_t units[MAX_TEXTUREUNITS];
 133         float color4f[4];
 134         int lockrange_first;
 135         int lockrange_count;
 136         int vertexbufferobject;
 137         int elementbufferobject;
 138         qboolean pointer_color_enabled;
 139
 140         int pointer_vertex_components;
 141         int pointer_vertex_gltype;
 142         size_t pointer_vertex_stride;
 143         const void *pointer_vertex_pointer;
 144         const r_meshbuffer_t *pointer_vertex_vertexbuffer;
 145         size_t pointer_vertex_offset;
 146
 147         int pointer_color_components;
 148         int pointer_color_gltype;
 149         size_t pointer_color_stride;
 150         const void *pointer_color_pointer;
 151         const r_meshbuffer_t *pointer_color_vertexbuffer;
 152         size_t pointer_color_offset;
 153
 154         void *preparevertices_tempdata;
 155         size_t preparevertices_tempdatamaxsize;
 156         r_meshbuffer_t *preparevertices_dynamicvertexbuffer;
 157         r_vertexposition_t *preparevertices_vertexposition;
 158         r_vertexgeneric_t *preparevertices_vertexgeneric;
 159         r_vertexmesh_t *preparevertices_vertexmesh;
 160         int preparevertices_numvertices;
 161
 162         r_meshbuffer_t *draw_dynamicindexbuffer;
 163
 164         qboolean usevbo_staticvertex;
 165         qboolean usevbo_staticindex;
 166         qboolean usevbo_dynamicvertex;
 167         qboolean usevbo_dynamicindex;
 168
 169         memexpandablearray_t meshbufferarray;
 170
 171         qboolean active;
 172 }
 173 gl_state_t;
 174
 175 static gl_state_t gl_state;
 176
 177
 178 /*
 179 note: here's strip order for a terrain row:
 180 0--1--2--3--4
 181 |\ |\ |\ |\ |
 182 | \| \| \| \|
 183 A--B--C--D--E
 184 clockwise
 185
 186 A0B, 01B, B1C, 12C, C2D, 23D, D3E, 34E
 187
 188 *elements++ = i + row;
 189 *elements++ = i;
 190 *elements++ = i + row + 1;
 191 *elements++ = i;
 192 *elements++ = i + 1;
 193 *elements++ = i + row + 1;
 194
 195
 196 for (y = 0;y < rows - 1;y++)
 197 {
 198         for (x = 0;x < columns - 1;x++)
 199         {
 200                 i = y * rows + x;
 201                 *elements++ = i + columns;
 202                 *elements++ = i;
 203                 *elements++ = i + columns + 1;
 204                 *elements++ = i;
 205                 *elements++ = i + 1;
 206                 *elements++ = i + columns + 1;
 207         }
 208 }
 209
 210 alternative:
 211 0--1--2--3--4
 212 | /| /|\ | /|
 213 |/ |/ | \|/ |
 214 A--B--C--D--E
 215 counterclockwise
 216
 217 for (y = 0;y < rows - 1;y++)
 218 {
 219         for (x = 0;x < columns - 1;x++)
 220         {
 221                 i = y * rows + x;
 222                 *elements++ = i;
 223                 *elements++ = i + columns;
 224                 *elements++ = i + columns + 1;
 225                 *elements++ = i + columns;
 226                 *elements++ = i + columns + 1;
 227                 *elements++ = i + 1;
 228         }
 229 }
 230 */
 231
 232 int polygonelement3i[(POLYGONELEMENTS_MAXPOINTS-2)*3];
 233 unsigned short polygonelement3s[(POLYGONELEMENTS_MAXPOINTS-2)*3];
 234 int quadelement3i[QUADELEMENTS_MAXQUADS*6];
 235 unsigned short quadelement3s[QUADELEMENTS_MAXQUADS*6];
 236
 237 void GL_VBOStats_f(void)
 238 {
 239         GL_Mesh_ListVBOs(true);
 240 }
 241
 242 static void GL_Backend_ResetState(void);
 243
 244 static void gl_backend_start(void)
 245 {
 246         memset(&gl_state, 0, sizeof(gl_state));
 247
 248         gl_state.usevbo_staticvertex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo;
 249         gl_state.usevbo_staticindex = (vid.support.arb_vertex_buffer_object && (gl_vbo.integer == 1 || gl_vbo.integer == 3)) || vid.forcevbo;
 250         gl_state.usevbo_dynamicvertex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicvertex.integer) || vid.forcevbo;
 251         gl_state.usevbo_dynamicindex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicindex.integer) || vid.forcevbo;
 252         Mem_ExpandableArray_NewArray(&gl_state.meshbufferarray, r_main_mempool, sizeof(r_meshbuffer_t), 128);
 253
 254         Con_DPrintf("OpenGL backend started.\n");
 255
 256         CHECKGLERROR
 257
 258         GL_Backend_ResetState();
 259 }
 260
 261 static void gl_backend_shutdown(void)
 262 {
 263         Con_DPrint("OpenGL Backend shutting down\n");
 264
 265         if (gl_state.preparevertices_tempdata)
 266                 Mem_Free(gl_state.preparevertices_tempdata);
 267         if (gl_state.preparevertices_dynamicvertexbuffer)
 268                 R_Mesh_DestroyMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer);
 269
 270         Mem_ExpandableArray_FreeArray(&gl_state.meshbufferarray);
 271
 272         memset(&gl_state, 0, sizeof(gl_state));
 273 }
 274
 275 static void gl_backend_newmap(void)
 276 {
 277 }
 278
 279 void gl_backend_init(void)
 280 {
 281         int i;
 282
 283         for (i = 0;i < POLYGONELEMENTS_MAXPOINTS - 2;i++)
 284         {
 285                 polygonelement3s[i * 3 + 0] = 0;
 286                 polygonelement3s[i * 3 + 1] = i + 1;
 287                 polygonelement3s[i * 3 + 2] = i + 2;
 288         }
 289         // elements for rendering a series of quads as triangles
 290         for (i = 0;i < QUADELEMENTS_MAXQUADS;i++)
 291         {
 292                 quadelement3s[i * 6 + 0] = i * 4;
 293                 quadelement3s[i * 6 + 1] = i * 4 + 1;
 294                 quadelement3s[i * 6 + 2] = i * 4 + 2;
 295                 quadelement3s[i * 6 + 3] = i * 4;
 296                 quadelement3s[i * 6 + 4] = i * 4 + 2;
 297                 quadelement3s[i * 6 + 5] = i * 4 + 3;
 298         }
 299
 300         for (i = 0;i < (POLYGONELEMENTS_MAXPOINTS - 2)*3;i++)
 301                 polygonelement3i[i] = polygonelement3s[i];
 302         for (i = 0;i < QUADELEMENTS_MAXQUADS*3;i++)
 303                 quadelement3i[i] = quadelement3s[i];
 304
 305         Cvar_RegisterVariable(&r_render);
 306         Cvar_RegisterVariable(&r_renderview);
 307         Cvar_RegisterVariable(&r_waterwarp);
 308         Cvar_RegisterVariable(&gl_polyblend);
 309         Cvar_RegisterVariable(&v_flipped);
 310         Cvar_RegisterVariable(&gl_dither);
 311         Cvar_RegisterVariable(&gl_vbo);
 312         Cvar_RegisterVariable(&gl_vbo_dynamicvertex);
 313         Cvar_RegisterVariable(&gl_vbo_dynamicindex);
 314         Cvar_RegisterVariable(&gl_paranoid);
 315         Cvar_RegisterVariable(&gl_printcheckerror);
 316
 317         Cvar_RegisterVariable(&gl_mesh_drawrangeelements);
 318         Cvar_RegisterVariable(&gl_mesh_testmanualfeeding);
 319         Cvar_RegisterVariable(&gl_mesh_prefer_short_elements);
 320         Cvar_RegisterVariable(&gl_mesh_separatearrays);
 321
 322         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");
 323
 324         R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap, NULL, NULL);
 325 }
 326
 327 void GL_SetMirrorState(qboolean state);
 328
 329 void R_Viewport_TransformToScreen(const r_viewport_t *v, const vec4_t in, vec4_t out)
 330 {
 331         vec4_t temp;
 332         float iw;
 333         Matrix4x4_Transform4 (&v->viewmatrix, in, temp);
 334         Matrix4x4_Transform4 (&v->projectmatrix, temp, out);
 335         iw = 1.0f / out[3];
 336         out[0] = v->x + (out[0] * iw + 1.0f) * v->width * 0.5f;
 337         out[1] = v->y + v->height - (out[1] * iw + 1.0f) * v->height * 0.5f;
 338         out[2] = v->z + (out[2] * iw + 1.0f) * v->depth * 0.5f;
 339 }
 340
 341 static void R_Viewport_ApplyNearClipPlaneFloatGL(const r_viewport_t *v, float *m, float normalx, float normaly, float normalz, float dist)
 342 {
 343         float q[4];
 344         float d;
 345         float clipPlane[4], v3[3], v4[3];
 346         float normal[3];
 347
 348         // This is inspired by Oblique Depth Projection from http://www.terathon.com/code/oblique.php
 349
 350         VectorSet(normal, normalx, normaly, normalz);
 351         Matrix4x4_Transform3x3(&v->viewmatrix, normal, clipPlane);
 352         VectorScale(normal, dist, v3);
 353         Matrix4x4_Transform(&v->viewmatrix, v3, v4);
 354         // FIXME: LordHavoc: I think this can be done more efficiently somehow but I can't remember the technique
 355         clipPlane[3] = -DotProduct(v4, clipPlane);
 356
 357 #if 0
 358 {
 359         // testing code for comparing results
 360         float clipPlane2[4];
 361         VectorCopy4(clipPlane, clipPlane2);
 362         R_EntityMatrix(&identitymatrix);
 363         VectorSet(q, normal[0], normal[1], normal[2], -dist);
 364         qglClipPlane(GL_CLIP_PLANE0, q);
 365         qglGetClipPlane(GL_CLIP_PLANE0, q);
 366         VectorCopy4(q, clipPlane);
 367 }
 368 #endif
 369
 370         // Calculate the clip-space corner point opposite the clipping plane
 371         // as (sgn(clipPlane.x), sgn(clipPlane.y), 1, 1) and
 372         // transform it into camera space by multiplying it
 373         // by the inverse of the projection matrix
 374         q[0] = ((clipPlane[0] < 0.0f ? -1.0f : clipPlane[0] > 0.0f ? 1.0f : 0.0f) + m[8]) / m[0];
 375         q[1] = ((clipPlane[1] < 0.0f ? -1.0f : clipPlane[1] > 0.0f ? 1.0f : 0.0f) + m[9]) / m[5];
 376         q[2] = -1.0f;
 377         q[3] = (1.0f + m[10]) / m[14];
 378
 379         // Calculate the scaled plane vector
 380         d = 2.0f / DotProduct4(clipPlane, q);
 381
 382         // Replace the third row of the projection matrix
 383         m[2] = clipPlane[0] * d;
 384         m[6] = clipPlane[1] * d;
 385         m[10] = clipPlane[2] * d + 1.0f;
 386         m[14] = clipPlane[3] * d;
 387 }
 388
 389 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)
 390 {
 391         float left = x1, right = x2, bottom = y2, top = y1, zNear = nearclip, zFar = farclip;
 392         float m[16];
 393         memset(v, 0, sizeof(*v));
 394         v->type = R_VIEWPORTTYPE_ORTHO;
 395         v->cameramatrix = *cameramatrix;
 396         v->x = x;
 397         v->y = y;
 398         v->z = 0;
 399         v->width = width;
 400         v->height = height;
 401         v->depth = 1;
 402         memset(m, 0, sizeof(m));
 403         m[0]  = 2/(right - left);
 404         m[5]  = 2/(top - bottom);
 405         m[10] = -2/(zFar - zNear);
 406         m[12] = - (right + left)/(right - left);
 407         m[13] = - (top + bottom)/(top - bottom);
 408         m[14] = - (zFar + zNear)/(zFar - zNear);
 409         m[15] = 1;
 410         v->screentodepth[0] = -farclip / (farclip - nearclip);
 411         v->screentodepth[1] = farclip * nearclip / (farclip - nearclip);
 412
 413         Matrix4x4_Invert_Full(&v->viewmatrix, &v->cameramatrix);
 414
 415         if (nearplane)
 416                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 417
 418         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 419
 420 #if 0
 421         {
 422                 vec4_t test1;
 423                 vec4_t test2;
 424                 Vector4Set(test1, (x1+x2)*0.5f, (y1+y2)*0.5f, 0.0f, 1.0f);
 425                 R_Viewport_TransformToScreen(v, test1, test2);
 426                 Con_Printf("%f %f %f -> %f %f %f\n", test1[0], test1[1], test1[2], test2[0], test2[1], test2[2]);
 427         }
 428 #endif
 429 }
 430
 431 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)
 432 {
 433         matrix4x4_t tempmatrix, basematrix;
 434         float m[16];
 435         memset(v, 0, sizeof(*v));
 436
 437         v->type = R_VIEWPORTTYPE_PERSPECTIVE;
 438         v->cameramatrix = *cameramatrix;
 439         v->x = x;
 440         v->y = y;
 441         v->z = 0;
 442         v->width = width;
 443         v->height = height;
 444         v->depth = 1;
 445         memset(m, 0, sizeof(m));
 446         m[0]  = 1.0 / frustumx;
 447         m[5]  = 1.0 / frustumy;
 448         m[10] = -(farclip + nearclip) / (farclip - nearclip);
 449         m[11] = -1;
 450         m[14] = -2 * nearclip * farclip / (farclip - nearclip);
 451         v->screentodepth[0] = -farclip / (farclip - nearclip);
 452         v->screentodepth[1] = farclip * nearclip / (farclip - nearclip);
 453
 454         Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix);
 455         Matrix4x4_CreateRotate(&basematrix, -90, 1, 0, 0);
 456         Matrix4x4_ConcatRotate(&basematrix, 90, 0, 0, 1);
 457         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
 458
 459         if (nearplane)
 460                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 461
 462         if(v_flipped.integer)
 463         {
 464                 m[0] = -m[0];
 465                 m[4] = -m[4];
 466                 m[8] = -m[8];
 467                 m[12] = -m[12];
 468         }
 469
 470         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 471 }
 472
 473 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)
 474 {
 475         matrix4x4_t tempmatrix, basematrix;
 476         const float nudge = 1.0 - 1.0 / (1<<23);
 477         float m[16];
 478         memset(v, 0, sizeof(*v));
 479
 480         v->type = R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP;
 481         v->cameramatrix = *cameramatrix;
 482         v->x = x;
 483         v->y = y;
 484         v->z = 0;
 485         v->width = width;
 486         v->height = height;
 487         v->depth = 1;
 488         memset(m, 0, sizeof(m));
 489         m[ 0] = 1.0 / frustumx;
 490         m[ 5] = 1.0 / frustumy;
 491         m[10] = -nudge;
 492         m[11] = -1;
 493         m[14] = -2 * nearclip * nudge;
 494         v->screentodepth[0] = (m[10] + 1) * 0.5 - 1;
 495         v->screentodepth[1] = m[14] * -0.5;
 496
 497         Matrix4x4_Invert_Full(&tempmatrix, &v->cameramatrix);
 498         Matrix4x4_CreateRotate(&basematrix, -90, 1, 0, 0);
 499         Matrix4x4_ConcatRotate(&basematrix, 90, 0, 0, 1);
 500         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
 501
 502         if (nearplane)
 503                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 504
 505         if(v_flipped.integer)
 506         {
 507                 m[0] = -m[0];
 508                 m[4] = -m[4];
 509                 m[8] = -m[8];
 510                 m[12] = -m[12];
 511         }
 512
 513         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 514 }
 515
 516 float cubeviewmatrix[6][16] =
 517 {
 518     // standard cubemap projections
 519     { // +X
 520          0, 0,-1, 0,
 521          0,-1, 0, 0,
 522         -1, 0, 0, 0,
 523          0, 0, 0, 1,
 524     },
 525     { // -X
 526          0, 0, 1, 0,
 527          0,-1, 0, 0,
 528          1, 0, 0, 0,
 529          0, 0, 0, 1,
 530     },
 531     { // +Y
 532          1, 0, 0, 0,
 533          0, 0,-1, 0,
 534          0, 1, 0, 0,
 535          0, 0, 0, 1,
 536     },
 537     { // -Y
 538          1, 0, 0, 0,
 539          0, 0, 1, 0,
 540          0,-1, 0, 0,
 541          0, 0, 0, 1,
 542     },
 543     { // +Z
 544          1, 0, 0, 0,
 545          0,-1, 0, 0,
 546          0, 0,-1, 0,
 547          0, 0, 0, 1,
 548     },
 549     { // -Z
 550         -1, 0, 0, 0,
 551          0,-1, 0, 0,
 552          0, 0, 1, 0,
 553          0, 0, 0, 1,
 554     },
 555 };
 556 float rectviewmatrix[6][16] =
 557 {
 558     // sign-preserving cubemap projections
 559     { // +X
 560          0, 0,-1, 0,
 561          0, 1, 0, 0,
 562          1, 0, 0, 0,
 563          0, 0, 0, 1,
 564     },
 565     { // -X
 566          0, 0, 1, 0,
 567          0, 1, 0, 0,
 568          1, 0, 0, 0,
 569          0, 0, 0, 1,
 570     },
 571     { // +Y
 572          1, 0, 0, 0,
 573          0, 0,-1, 0,
 574          0, 1, 0, 0,
 575          0, 0, 0, 1,
 576     },
 577     { // -Y
 578          1, 0, 0, 0,
 579          0, 0, 1, 0,
 580          0, 1, 0, 0,
 581          0, 0, 0, 1,
 582     },
 583     { // +Z
 584          1, 0, 0, 0,
 585          0, 1, 0, 0,
 586          0, 0,-1, 0,
 587          0, 0, 0, 1,
 588     },
 589     { // -Z
 590          1, 0, 0, 0,
 591          0, 1, 0, 0,
 592          0, 0, 1, 0,
 593          0, 0, 0, 1,
 594     },
 595 };
 596
 597 void R_Viewport_InitCubeSideView(r_viewport_t *v, const matrix4x4_t *cameramatrix, int side, int size, float nearclip, float farclip, const float *nearplane)
 598 {
 599         matrix4x4_t tempmatrix, basematrix;
 600         float m[16];
 601         memset(v, 0, sizeof(*v));
 602         v->type = R_VIEWPORTTYPE_PERSPECTIVECUBESIDE;
 603         v->cameramatrix = *cameramatrix;
 604         v->width = size;
 605         v->height = size;
 606         v->depth = 1;
 607         memset(m, 0, sizeof(m));
 608         m[0] = m[5] = 1.0f;
 609         m[10] = -(farclip + nearclip) / (farclip - nearclip);
 610         m[11] = -1;
 611         m[14] = -2 * nearclip * farclip / (farclip - nearclip);
 612
 613         Matrix4x4_FromArrayFloatGL(&basematrix, cubeviewmatrix[side]);
 614         Matrix4x4_Invert_Simple(&tempmatrix, &v->cameramatrix);
 615         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
 616
 617         if (nearplane)
 618                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 619
 620         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 621 }
 622
 623 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)
 624 {
 625         matrix4x4_t tempmatrix, basematrix;
 626         float m[16];
 627         memset(v, 0, sizeof(*v));
 628         v->type = R_VIEWPORTTYPE_PERSPECTIVECUBESIDE;
 629         v->cameramatrix = *cameramatrix;
 630         v->x = (side & 1) * size;
 631         v->y = (side >> 1) * size;
 632         v->width = size;
 633         v->height = size;
 634         v->depth = 1;
 635         memset(m, 0, sizeof(m));
 636         m[0] = m[5] = 1.0f * ((float)size - border) / size;
 637         m[10] = -(farclip + nearclip) / (farclip - nearclip);
 638         m[11] = -1;
 639         m[14] = -2 * nearclip * farclip / (farclip - nearclip);
 640
 641         Matrix4x4_FromArrayFloatGL(&basematrix, rectviewmatrix[side]);
 642         Matrix4x4_Invert_Simple(&tempmatrix, &v->cameramatrix);
 643         Matrix4x4_Concat(&v->viewmatrix, &basematrix, &tempmatrix);
 644
 645         if (nearplane)
 646                 R_Viewport_ApplyNearClipPlaneFloatGL(v, m, nearplane[0], nearplane[1], nearplane[2], nearplane[3]);
 647
 648         Matrix4x4_FromArrayFloatGL(&v->projectmatrix, m);
 649 }
 650
 651 void R_SetViewport(const r_viewport_t *v)
 652 {
 653         float m[16];
 654         gl_viewport = *v;
 655
 656         CHECKGLERROR
 657         qglViewport(v->x, v->y, v->width, v->height);CHECKGLERROR
 658
 659         // FIXME: v_flipped_state is evil, this probably breaks somewhere
 660         GL_SetMirrorState(v_flipped.integer && (v->type == R_VIEWPORTTYPE_PERSPECTIVE || v->type == R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP));
 661
 662         // copy over the matrices to our state
 663         gl_viewmatrix = v->viewmatrix;
 664         gl_projectionmatrix = v->projectmatrix;
 665
 666         switch(vid.renderpath)
 667         {
 668         case RENDERPATH_GL20:
 669         case RENDERPATH_CGGL:
 670 //              break;
 671         case RENDERPATH_GL13:
 672         case RENDERPATH_GL11:
 673                 // Load the projection matrix into OpenGL
 674                 qglMatrixMode(GL_PROJECTION);CHECKGLERROR
 675                 Matrix4x4_ToArrayFloatGL(&gl_projectionmatrix, m);
 676                 qglLoadMatrixf(m);CHECKGLERROR
 677                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
 678                 break;
 679         }
 680
 681         // force an update of the derived matrices
 682         gl_modelmatrixchanged = true;
 683         R_EntityMatrix(&gl_modelmatrix);
 684 }
 685
 686 void R_GetViewport(r_viewport_t *v)
 687 {
 688         *v = gl_viewport;
 689 }
 690
 691 static void GL_BindVBO(int bufferobject)
 692 {
 693         if (gl_state.vertexbufferobject != bufferobject)
 694         {
 695                 gl_state.vertexbufferobject = bufferobject;
 696                 CHECKGLERROR
 697                 qglBindBufferARB(GL_ARRAY_BUFFER_ARB, bufferobject);
 698                 CHECKGLERROR
 699         }
 700 }
 701
 702 static void GL_BindEBO(int bufferobject)
 703 {
 704         if (gl_state.elementbufferobject != bufferobject)
 705         {
 706                 gl_state.elementbufferobject = bufferobject;
 707                 CHECKGLERROR
 708                 qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, bufferobject);
 709                 CHECKGLERROR
 710         }
 711 }
 712
 713 static void GL_Backend_ResetState(void)
 714 {
 715         unsigned int i;
 716         gl_state.active = true;
 717         gl_state.depthtest = true;
 718         gl_state.alphatest = false;
 719         gl_state.blendfunc1 = GL_ONE;
 720         gl_state.blendfunc2 = GL_ZERO;
 721         gl_state.blend = false;
 722         gl_state.depthmask = GL_TRUE;
 723         gl_state.colormask = 15;
 724         gl_state.color4f[0] = gl_state.color4f[1] = gl_state.color4f[2] = gl_state.color4f[3] = 1;
 725         gl_state.lockrange_first = 0;
 726         gl_state.lockrange_count = 0;
 727         gl_state.cullface = v_flipped_state ? GL_BACK : GL_FRONT; // quake is backwards, this culls back faces
 728         gl_state.cullfaceenable = true;
 729         gl_state.polygonoffset[0] = 0;
 730         gl_state.polygonoffset[1] = 0;
 731
 732         CHECKGLERROR
 733
 734         qglColorMask(1, 1, 1, 1);
 735         qglAlphaFunc(GL_GEQUAL, 0.5);CHECKGLERROR
 736         qglDisable(GL_ALPHA_TEST);CHECKGLERROR
 737         qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
 738         qglDisable(GL_BLEND);CHECKGLERROR
 739         qglCullFace(gl_state.cullface);CHECKGLERROR
 740         qglEnable(GL_CULL_FACE);CHECKGLERROR
 741         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
 742         qglEnable(GL_DEPTH_TEST);CHECKGLERROR
 743         qglDepthMask(gl_state.depthmask);CHECKGLERROR
 744         qglPolygonOffset(gl_state.polygonoffset[0], gl_state.polygonoffset[1]);
 745
 746         if (vid.support.arb_vertex_buffer_object)
 747         {
 748                 qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
 749                 qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
 750         }
 751
 752         if (vid.support.ext_framebuffer_object)
 753         {
 754                 qglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
 755                 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 756         }
 757
 758         qglVertexPointer(3, GL_FLOAT, sizeof(float[3]), NULL);CHECKGLERROR
 759         qglEnableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
 760
 761         qglColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL);CHECKGLERROR
 762         qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
 763
 764         GL_Color(0, 0, 0, 0);
 765         GL_Color(1, 1, 1, 1);
 766
 767         gl_state.unit = MAX_TEXTUREUNITS;
 768         gl_state.clientunit = MAX_TEXTUREUNITS;
 769         switch(vid.renderpath)
 770         {
 771         case RENDERPATH_GL20:
 772         case RENDERPATH_CGGL:
 773                 for (i = 0;i < vid.teximageunits;i++)
 774                 {
 775                         GL_ActiveTexture(i);
 776                         qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
 777                         if (vid.support.ext_texture_3d)
 778                         {
 779                                 qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
 780                         }
 781                         if (vid.support.arb_texture_cube_map)
 782                         {
 783                                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, 0);CHECKGLERROR
 784                         }
 785                         if (vid.support.arb_texture_rectangle)
 786                         {
 787                                 qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);CHECKGLERROR
 788                         }
 789                 }
 790
 791                 for (i = 0;i < vid.texarrayunits;i++)
 792                 {
 793                         GL_ClientActiveTexture(i);
 794                         GL_BindVBO(0);
 795                         qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), NULL);CHECKGLERROR
 796                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 797                 }
 798                 CHECKGLERROR
 799                 break;
 800         case RENDERPATH_GL13:
 801         case RENDERPATH_GL11:
 802                 for (i = 0;i < vid.texunits;i++)
 803                 {
 804                         GL_ActiveTexture(i);
 805                         GL_ClientActiveTexture(i);
 806                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
 807                         qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
 808                         if (vid.support.ext_texture_3d)
 809                         {
 810                                 qglDisable(GL_TEXTURE_3D);CHECKGLERROR
 811                                 qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
 812                         }
 813                         if (vid.support.arb_texture_cube_map)
 814                         {
 815                                 qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR
 816                                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, 0);CHECKGLERROR
 817                         }
 818                         if (vid.support.arb_texture_rectangle)
 819                         {
 820                                 qglDisable(GL_TEXTURE_RECTANGLE_ARB);CHECKGLERROR
 821                                 qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);CHECKGLERROR
 822                         }
 823                         GL_BindVBO(0);
 824                         qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), NULL);CHECKGLERROR
 825                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 826                         qglMatrixMode(GL_TEXTURE);CHECKGLERROR
 827                         qglLoadIdentity();CHECKGLERROR
 828                         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
 829                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
 830                 }
 831                 CHECKGLERROR
 832                 break;
 833         }
 834 }
 835
 836 void GL_ActiveTexture(unsigned int num)
 837 {
 838         if (gl_state.unit != num)
 839         {
 840                 gl_state.unit = num;
 841                 if (qglActiveTexture)
 842                 {
 843                         CHECKGLERROR
 844                         qglActiveTexture(GL_TEXTURE0_ARB + gl_state.unit);
 845                         CHECKGLERROR
 846                 }
 847         }
 848 }
 849
 850 void GL_ClientActiveTexture(unsigned int num)
 851 {
 852         if (gl_state.clientunit != num)
 853         {
 854                 gl_state.clientunit = num;
 855                 if (qglActiveTexture)
 856                 {
 857                         CHECKGLERROR
 858                         qglClientActiveTexture(GL_TEXTURE0_ARB + gl_state.clientunit);
 859                         CHECKGLERROR
 860                 }
 861         }
 862 }
 863
 864 void GL_BlendFunc(int blendfunc1, int blendfunc2)
 865 {
 866         if (gl_state.blendfunc1 != blendfunc1 || gl_state.blendfunc2 != blendfunc2)
 867         {
 868                 CHECKGLERROR
 869                 qglBlendFunc(gl_state.blendfunc1 = blendfunc1, gl_state.blendfunc2 = blendfunc2);CHECKGLERROR
 870                 if (gl_state.blendfunc2 == GL_ZERO)
 871                 {
 872                         if (gl_state.blendfunc1 == GL_ONE)
 873                         {
 874                                 if (gl_state.blend)
 875                                 {
 876                                         gl_state.blend = 0;
 877                                         qglDisable(GL_BLEND);CHECKGLERROR
 878                                 }
 879                         }
 880                         else
 881                         {
 882                                 if (!gl_state.blend)
 883                                 {
 884                                         gl_state.blend = 1;
 885                                         qglEnable(GL_BLEND);CHECKGLERROR
 886                                 }
 887                         }
 888                 }
 889                 else
 890                 {
 891                         if (!gl_state.blend)
 892                         {
 893                                 gl_state.blend = 1;
 894                                 qglEnable(GL_BLEND);CHECKGLERROR
 895                         }
 896                 }
 897         }
 898 }
 899
 900 void GL_DepthMask(int state)
 901 {
 902         if (gl_state.depthmask != state)
 903         {
 904                 CHECKGLERROR
 905                 qglDepthMask(gl_state.depthmask = state);CHECKGLERROR
 906         }
 907 }
 908
 909 void GL_DepthTest(int state)
 910 {
 911         if (gl_state.depthtest != state)
 912         {
 913                 gl_state.depthtest = state;
 914                 CHECKGLERROR
 915                 if (gl_state.depthtest)
 916                 {
 917                         qglEnable(GL_DEPTH_TEST);CHECKGLERROR
 918                 }
 919                 else
 920                 {
 921                         qglDisable(GL_DEPTH_TEST);CHECKGLERROR
 922                 }
 923         }
 924 }
 925
 926 void GL_DepthRange(float nearfrac, float farfrac)
 927 {
 928         if (gl_state.depthrange[0] != nearfrac || gl_state.depthrange[1] != farfrac)
 929         {
 930                 gl_state.depthrange[0] = nearfrac;
 931                 gl_state.depthrange[1] = farfrac;
 932                 qglDepthRange(nearfrac, farfrac);
 933         }
 934 }
 935
 936 void GL_PolygonOffset(float planeoffset, float depthoffset)
 937 {
 938         if (gl_state.polygonoffset[0] != planeoffset || gl_state.polygonoffset[1] != depthoffset)
 939         {
 940                 gl_state.polygonoffset[0] = planeoffset;
 941                 gl_state.polygonoffset[1] = depthoffset;
 942                 qglPolygonOffset(planeoffset, depthoffset);
 943         }
 944 }
 945
 946 void GL_SetMirrorState(qboolean state)
 947 {
 948         if(!state != !v_flipped_state)
 949         {
 950                 // change cull face mode!
 951                 if(gl_state.cullface == GL_BACK)
 952                         qglCullFace((gl_state.cullface = GL_FRONT));
 953                 else if(gl_state.cullface == GL_FRONT)
 954                         qglCullFace((gl_state.cullface = GL_BACK));
 955         }
 956         v_flipped_state = state;
 957 }
 958
 959 void GL_CullFace(int state)
 960 {
 961         CHECKGLERROR
 962
 963         if(v_flipped_state)
 964         {
 965                 if(state == GL_FRONT)
 966                         state = GL_BACK;
 967                 else if(state == GL_BACK)
 968                         state = GL_FRONT;
 969         }
 970
 971         if (state != GL_NONE)
 972         {
 973                 if (!gl_state.cullfaceenable)
 974                 {
 975                         gl_state.cullfaceenable = true;
 976                         qglEnable(GL_CULL_FACE);CHECKGLERROR
 977                 }
 978                 if (gl_state.cullface != state)
 979                 {
 980                         gl_state.cullface = state;
 981                         qglCullFace(gl_state.cullface);CHECKGLERROR
 982                 }
 983         }
 984         else
 985         {
 986                 if (gl_state.cullfaceenable)
 987                 {
 988                         gl_state.cullfaceenable = false;
 989                         qglDisable(GL_CULL_FACE);CHECKGLERROR
 990                 }
 991         }
 992 }
 993
 994 void GL_AlphaTest(int state)
 995 {
 996         if (gl_state.alphatest != state)
 997         {
 998                 gl_state.alphatest = state;
 999                 CHECKGLERROR
1000                 if (gl_state.alphatest)
1001                 {
1002                         qglEnable(GL_ALPHA_TEST);CHECKGLERROR
1003                 }
1004                 else
1005                 {
1006                         qglDisable(GL_ALPHA_TEST);CHECKGLERROR
1007                 }
1008         }
1009 }
1010
1011 void GL_ColorMask(int r, int g, int b, int a)
1012 {
1013         int state = r*8 + g*4 + b*2 + a*1;
1014         if (gl_state.colormask != state)
1015         {
1016                 gl_state.colormask = state;
1017                 CHECKGLERROR
1018                 qglColorMask((GLboolean)r, (GLboolean)g, (GLboolean)b, (GLboolean)a);CHECKGLERROR
1019         }
1020 }
1021
1022 void GL_Color(float cr, float cg, float cb, float ca)
1023 {
1024         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)
1025         {
1026                 gl_state.color4f[0] = cr;
1027                 gl_state.color4f[1] = cg;
1028                 gl_state.color4f[2] = cb;
1029                 gl_state.color4f[3] = ca;
1030                 CHECKGLERROR
1031                 qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);
1032                 CHECKGLERROR
1033         }
1034 }
1035
1036 void GL_Scissor (int x, int y, int width, int height)
1037 {
1038         CHECKGLERROR
1039         qglScissor(x, y,width,height);
1040         CHECKGLERROR
1041 }
1042
1043 void GL_ScissorTest(int state)
1044 {
1045         if(gl_state.scissortest == state)
1046                 return;
1047
1048         CHECKGLERROR
1049         if((gl_state.scissortest = state))
1050                 qglEnable(GL_SCISSOR_TEST);
1051         else
1052                 qglDisable(GL_SCISSOR_TEST);
1053         CHECKGLERROR
1054 }
1055
1056 void GL_Clear(int mask)
1057 {
1058         CHECKGLERROR
1059         qglClear(mask);CHECKGLERROR
1060 }
1061
1062 // called at beginning of frame
1063 void R_Mesh_Start(void)
1064 {
1065         BACKENDACTIVECHECK
1066         CHECKGLERROR
1067         gl_state.usevbo_staticvertex = (vid.support.arb_vertex_buffer_object && gl_vbo.integer) || vid.forcevbo;
1068         gl_state.usevbo_staticindex = (vid.support.arb_vertex_buffer_object && (gl_vbo.integer == 1 || gl_vbo.integer == 3)) || vid.forcevbo;
1069         gl_state.usevbo_dynamicvertex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicvertex.integer) || vid.forcevbo;
1070         gl_state.usevbo_dynamicindex = (vid.support.arb_vertex_buffer_object && gl_vbo_dynamicindex.integer) || vid.forcevbo;
1071         if (gl_printcheckerror.integer && !gl_paranoid.integer)
1072         {
1073                 Con_Printf("WARNING: gl_printcheckerror is on but gl_paranoid is off, turning it on...\n");
1074                 Cvar_SetValueQuick(&gl_paranoid, 1);
1075         }
1076 }
1077
1078 qboolean GL_Backend_CompileShader(int programobject, GLenum shadertypeenum, const char *shadertype, int numstrings, const char **strings)
1079 {
1080         int shaderobject;
1081         int shadercompiled;
1082         char compilelog[MAX_INPUTLINE];
1083         shaderobject = qglCreateShaderObjectARB(shadertypeenum);CHECKGLERROR
1084         if (!shaderobject)
1085                 return false;
1086         qglShaderSourceARB(shaderobject, numstrings, strings, NULL);CHECKGLERROR
1087         qglCompileShaderARB(shaderobject);CHECKGLERROR
1088         qglGetObjectParameterivARB(shaderobject, GL_OBJECT_COMPILE_STATUS_ARB, &shadercompiled);CHECKGLERROR
1089         qglGetInfoLogARB(shaderobject, sizeof(compilelog), NULL, compilelog);CHECKGLERROR
1090         if (compilelog[0] && (strstr(compilelog, "error") || strstr(compilelog, "ERROR") || strstr(compilelog, "Error") || strstr(compilelog, "WARNING") || strstr(compilelog, "warning") || strstr(compilelog, "Warning")))
1091         {
1092                 int i, j, pretextlines = 0;
1093                 for (i = 0;i < numstrings - 1;i++)
1094                         for (j = 0;strings[i][j];j++)
1095                                 if (strings[i][j] == '\n')
1096                                         pretextlines++;
1097                 Con_Printf("%s shader compile log:\n%s\n(line offset for any above warnings/errors: %i)\n", shadertype, compilelog, pretextlines);
1098         }
1099         if (!shadercompiled)
1100         {
1101                 qglDeleteObjectARB(shaderobject);CHECKGLERROR
1102                 return false;
1103         }
1104         qglAttachObjectARB(programobject, shaderobject);CHECKGLERROR
1105         qglDeleteObjectARB(shaderobject);CHECKGLERROR
1106         return true;
1107 }
1108
1109 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)
1110 {
1111         GLint programlinked;
1112         GLuint programobject = 0;
1113         char linklog[MAX_INPUTLINE];
1114         CHECKGLERROR
1115
1116         programobject = qglCreateProgramObjectARB();CHECKGLERROR
1117         if (!programobject)
1118                 return 0;
1119
1120         if (vertexstrings_count && !GL_Backend_CompileShader(programobject, GL_VERTEX_SHADER_ARB, "vertex", vertexstrings_count, vertexstrings_list))
1121                 goto cleanup;
1122
1123 #ifdef GL_GEOMETRY_SHADER_ARB
1124         if (geometrystrings_count && !GL_Backend_CompileShader(programobject, GL_GEOMETRY_SHADER_ARB, "geometry", geometrystrings_count, geometrystrings_list))
1125                 goto cleanup;
1126 #endif
1127
1128         if (fragmentstrings_count && !GL_Backend_CompileShader(programobject, GL_FRAGMENT_SHADER_ARB, "fragment", fragmentstrings_count, fragmentstrings_list))
1129                 goto cleanup;
1130
1131         qglLinkProgramARB(programobject);CHECKGLERROR
1132         qglGetObjectParameterivARB(programobject, GL_OBJECT_LINK_STATUS_ARB, &programlinked);CHECKGLERROR
1133         qglGetInfoLogARB(programobject, sizeof(linklog), NULL, linklog);CHECKGLERROR
1134         if (linklog[0])
1135         {
1136                 if (strstr(linklog, "error") || strstr(linklog, "ERROR") || strstr(linklog, "Error") || strstr(linklog, "WARNING") || strstr(linklog, "warning") || strstr(linklog, "Warning"))
1137                         Con_DPrintf("program link log:\n%s\n", linklog);
1138                 // software vertex shader is ok but software fragment shader is WAY
1139                 // too slow, fail program if so.
1140                 // NOTE: this string might be ATI specific, but that's ok because the
1141                 // ATI R300 chip (Radeon 9500-9800/X300) is the most likely to use a
1142                 // software fragment shader due to low instruction and dependent
1143                 // texture limits.
1144                 if (strstr(linklog, "fragment shader will run in software"))
1145                         programlinked = false;
1146         }
1147         if (!programlinked)
1148                 goto cleanup;
1149         return programobject;
1150 cleanup:
1151         qglDeleteObjectARB(programobject);CHECKGLERROR
1152         return 0;
1153 }
1154
1155 void GL_Backend_FreeProgram(unsigned int prog)
1156 {
1157         CHECKGLERROR
1158         qglDeleteObjectARB(prog);
1159         CHECKGLERROR
1160 }
1161
1162 void GL_Backend_RenumberElements(int *out, int count, const int *in, int offset)
1163 {
1164         int i;
1165         if (offset)
1166         {
1167                 for (i = 0;i < count;i++)
1168                         *out++ = *in++ + offset;
1169         }
1170         else
1171                 memcpy(out, in, sizeof(*out) * count);
1172 }
1173
1174 // renders triangles using vertices from the active arrays
1175 int paranoidblah = 0;
1176 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)
1177 {
1178         unsigned int numelements = numtriangles * 3;
1179         int bufferobject3i;
1180         size_t bufferoffset3i;
1181         int bufferobject3s;
1182         size_t bufferoffset3s;
1183         if (numvertices < 3 || numtriangles < 1)
1184         {
1185                 if (numvertices < 0 || numtriangles < 0 || developer_extra.integer)
1186                         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);
1187                 return;
1188         }
1189         if (gl_state.pointer_vertex_pointer == NULL)
1190         {
1191                 Con_DPrintf("R_Mesh_Draw with no vertex pointer!\n");
1192                 return;
1193         }
1194         if (!gl_mesh_prefer_short_elements.integer)
1195         {
1196                 if (element3i)
1197                         element3s = NULL;
1198                 if (element3i_indexbuffer)
1199                         element3i_indexbuffer = NULL;
1200         }
1201         // adjust the pointers for firsttriangle
1202         if (element3i)
1203                 element3i += firsttriangle * 3;
1204         if (element3i_indexbuffer)
1205                 element3i_bufferoffset += firsttriangle * 3 * sizeof(*element3i);
1206         if (element3s)
1207                 element3s += firsttriangle * 3;
1208         if (element3s_indexbuffer)
1209                 element3s_bufferoffset += firsttriangle * 3 * sizeof(*element3s);
1210         // check if the user specified to ignore static index buffers
1211         if (!gl_state.usevbo_staticindex || (gl_vbo.integer == 3 && !vid.forcevbo && (element3i_bufferoffset || element3s_bufferoffset)))
1212         {
1213                 element3i_indexbuffer = NULL;
1214                 element3s_indexbuffer = NULL;
1215         }
1216         // upload a dynamic index buffer if needed
1217         if (element3s)
1218         {
1219                 if (!element3s_indexbuffer && gl_state.usevbo_dynamicindex)
1220                 {
1221                         if (gl_state.draw_dynamicindexbuffer)
1222                                 R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3s, numelements * sizeof(*element3s));
1223                         else
1224                                 gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3s, numelements * sizeof(*element3s), "temporary", true, true);
1225                         element3s_indexbuffer = gl_state.draw_dynamicindexbuffer;
1226                         element3s_bufferoffset = 0;
1227                 }
1228         }
1229         else if (element3i)
1230         {
1231                 if (!element3i_indexbuffer && gl_state.usevbo_dynamicindex)
1232                 {
1233                         if (gl_state.draw_dynamicindexbuffer)
1234                                 R_Mesh_UpdateMeshBuffer(gl_state.draw_dynamicindexbuffer, (void *)element3i, numelements * sizeof(*element3i));
1235                         else
1236                                 gl_state.draw_dynamicindexbuffer = R_Mesh_CreateMeshBuffer((void *)element3i, numelements * sizeof(*element3i), "temporary", true, true);
1237                         element3i_indexbuffer = gl_state.draw_dynamicindexbuffer;
1238                         element3i_bufferoffset = 0;
1239                 }
1240         }
1241         bufferobject3i = element3i_indexbuffer ? element3i_indexbuffer->bufferobject : 0;
1242         bufferoffset3i = element3i_bufferoffset;
1243         bufferobject3s = element3s_indexbuffer ? element3s_indexbuffer->bufferobject : 0;
1244         bufferoffset3s = element3s_bufferoffset;
1245         CHECKGLERROR
1246         r_refdef.stats.meshes++;
1247         r_refdef.stats.meshes_elements += numelements;
1248         if (gl_paranoid.integer)
1249         {
1250                 unsigned int i;
1251                 // LordHavoc: disabled this - it needs to be updated to handle components and gltype and stride in each array
1252 #if 0
1253                 unsigned int j, size;
1254                 const int *p;
1255                 // note: there's no validation done here on buffer objects because it
1256                 // is somewhat difficult to get at the data, and gl_paranoid can be
1257                 // used without buffer objects if the need arises
1258                 // (the data could be gotten using glMapBuffer but it would be very
1259                 //  slow due to uncachable video memory reads)
1260                 if (!qglIsEnabled(GL_VERTEX_ARRAY))
1261                         Con_Print("R_Mesh_Draw: vertex array not enabled\n");
1262                 CHECKGLERROR
1263                 if (gl_state.pointer_vertex_pointer)
1264                         for (j = 0, size = numvertices * 3, p = (int *)((float *)gl_state.pointer_vertex + firstvertex * 3);j < size;j++, p++)
1265                                 paranoidblah += *p;
1266                 if (gl_state.pointer_color_enabled)
1267                 {
1268                         if (!qglIsEnabled(GL_COLOR_ARRAY))
1269                                 Con_Print("R_Mesh_Draw: color array set but not enabled\n");
1270                         CHECKGLERROR
1271                         if (gl_state.pointer_color && gl_state.pointer_color_enabled)
1272                                 for (j = 0, size = numvertices * 4, p = (int *)((float *)gl_state.pointer_color + firstvertex * 4);j < size;j++, p++)
1273                                         paranoidblah += *p;
1274                 }
1275                 for (i = 0;i < vid.texarrayunits;i++)
1276                 {
1277                         if (gl_state.units[i].arrayenabled)
1278                         {
1279                                 GL_ClientActiveTexture(i);
1280                                 if (!qglIsEnabled(GL_TEXTURE_COORD_ARRAY))
1281                                         Con_Print("R_Mesh_Draw: texcoord array set but not enabled\n");
1282                                 CHECKGLERROR
1283                                 if (gl_state.units[i].pointer_texcoord && gl_state.units[i].arrayenabled)
1284                                         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++)
1285                                                 paranoidblah += *p;
1286                         }
1287                 }
1288 #endif
1289                 if (element3i)
1290                 {
1291                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
1292                         {
1293                                 if (element3i[i] < firstvertex || element3i[i] >= firstvertex + numvertices)
1294                                 {
1295                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3i array\n", element3i[i], firstvertex, firstvertex + numvertices);
1296                                         return;
1297                                 }
1298                         }
1299                 }
1300                 if (element3s)
1301                 {
1302                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
1303                         {
1304                                 if (element3s[i] < firstvertex || element3s[i] >= firstvertex + numvertices)
1305                                 {
1306                                         Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in element3s array\n", element3s[i], firstvertex, firstvertex + numvertices);
1307                                         return;
1308                                 }
1309                         }
1310                 }
1311                 CHECKGLERROR
1312         }
1313         if (r_render.integer || r_refdef.draw2dstage)
1314         {
1315                 CHECKGLERROR
1316                 if (gl_mesh_testmanualfeeding.integer)
1317                 {
1318                         unsigned int i, j, element;
1319                         const GLfloat *p;
1320                         qglBegin(GL_TRIANGLES);
1321                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
1322                         {
1323                                 if (element3i)
1324                                         element = element3i[i];
1325                                 else if (element3s)
1326                                         element = element3s[i];
1327                                 else
1328                                         element = firstvertex + i;
1329                                 for (j = 0;j < vid.texarrayunits;j++)
1330                                 {
1331                                         if (gl_state.units[j].pointer_texcoord_pointer && gl_state.units[j].arrayenabled)
1332                                         {
1333                                                 if (gl_state.units[j].pointer_texcoord_gltype == GL_FLOAT)
1334                                                 {
1335                                                         p = (const GLfloat *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
1336                                                         if (vid.texarrayunits > 1)
1337                                                         {
1338                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
1339                                                                         qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2], p[3]);
1340                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
1341                                                                         qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2]);
1342                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
1343                                                                         qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, p[0], p[1]);
1344                                                                 else
1345                                                                         qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, p[0]);
1346                                                         }
1347                                                         else
1348                                                         {
1349                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
1350                                                                         qglTexCoord4f(p[0], p[1], p[2], p[3]);
1351                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
1352                                                                         qglTexCoord3f(p[0], p[1], p[2]);
1353                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
1354                                                                         qglTexCoord2f(p[0], p[1]);
1355                                                                 else
1356                                                                         qglTexCoord1f(p[0]);
1357                                                         }
1358                                                 }
1359                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_SHORT)
1360                                                 {
1361                                                         const GLshort *s = (const GLshort *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
1362                                                         if (vid.texarrayunits > 1)
1363                                                         {
1364                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
1365                                                                         qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2], s[3]);
1366                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
1367                                                                         qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, s[0], s[1], s[2]);
1368                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
1369                                                                         qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, s[0], s[1]);
1370                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
1371                                                                         qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, s[0]);
1372                                                         }
1373                                                         else
1374                                                         {
1375                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
1376                                                                         qglTexCoord4f(s[0], s[1], s[2], s[3]);
1377                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
1378                                                                         qglTexCoord3f(s[0], s[1], s[2]);
1379                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
1380                                                                         qglTexCoord2f(s[0], s[1]);
1381                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
1382                                                                         qglTexCoord1f(s[0]);
1383                                                         }
1384                                                 }
1385                                                 else if (gl_state.units[j].pointer_texcoord_gltype == GL_BYTE)
1386                                                 {
1387                                                         const GLbyte *sb = (const GLbyte *)((const unsigned char *)gl_state.units[j].pointer_texcoord_pointer + element * gl_state.units[j].pointer_texcoord_stride);
1388                                                         if (vid.texarrayunits > 1)
1389                                                         {
1390                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
1391                                                                         qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2], sb[3]);
1392                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
1393                                                                         qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, sb[0], sb[1], sb[2]);
1394                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
1395                                                                         qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, sb[0], sb[1]);
1396                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
1397                                                                         qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, sb[0]);
1398                                                         }
1399                                                         else
1400                                                         {
1401                                                                 if (gl_state.units[j].pointer_texcoord_components == 4)
1402                                                                         qglTexCoord4f(sb[0], sb[1], sb[2], sb[3]);
1403                                                                 else if (gl_state.units[j].pointer_texcoord_components == 3)
1404                                                                         qglTexCoord3f(sb[0], sb[1], sb[2]);
1405                                                                 else if (gl_state.units[j].pointer_texcoord_components == 2)
1406                                                                         qglTexCoord2f(sb[0], sb[1]);
1407                                                                 else if (gl_state.units[j].pointer_texcoord_components == 1)
1408                                                                         qglTexCoord1f(sb[0]);
1409                                                         }
1410                                                 }
1411                                         }
1412                                 }
1413                                 if (gl_state.pointer_color_pointer && gl_state.pointer_color_enabled && gl_state.pointer_color_components == 4)
1414                                 {
1415                                         if (gl_state.pointer_color_gltype == GL_FLOAT)
1416                                         {
1417                                                 p = (const GLfloat *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
1418                                                 qglColor4f(p[0], p[1], p[2], p[3]);
1419                                         }
1420                                         else if (gl_state.pointer_color_gltype == GL_UNSIGNED_BYTE)
1421                                         {
1422                                                 const GLubyte *ub = (const GLubyte *)((const unsigned char *)gl_state.pointer_color_pointer + element * gl_state.pointer_color_stride);
1423                                                 qglColor4ub(ub[0], ub[1], ub[2], ub[3]);
1424                                         }
1425                                 }
1426                                 if (gl_state.pointer_vertex_gltype == GL_FLOAT)
1427                                 {
1428                                         p = (const GLfloat *)((const unsigned char *)gl_state.pointer_vertex_pointer + element * gl_state.pointer_vertex_stride);
1429                                         if (gl_state.pointer_vertex_components == 4)
1430                                                 qglVertex4f(p[0], p[1], p[2], p[3]);
1431                                         else if (gl_state.pointer_vertex_components == 3)
1432                                                 qglVertex3f(p[0], p[1], p[2]);
1433                                         else
1434                                                 qglVertex2f(p[0], p[1]);
1435                                 }
1436                         }
1437                         qglEnd();
1438                         CHECKGLERROR
1439                 }
1440                 else if (bufferobject3s)
1441                 {
1442                         GL_BindEBO(bufferobject3s);
1443                         if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
1444                         {
1445                                 qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, (void *)bufferoffset3s);
1446                                 CHECKGLERROR
1447                         }
1448                         else
1449                         {
1450                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, (void *)(firsttriangle * sizeof(unsigned short[3])));
1451                                 CHECKGLERROR
1452                         }
1453                 }
1454                 else if (bufferobject3i)
1455                 {
1456                         GL_BindEBO(bufferobject3i);
1457                         if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
1458                         {
1459                                 qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, (void *)bufferoffset3i);
1460                                 CHECKGLERROR
1461                         }
1462                         else
1463                         {
1464                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, (void *)(firsttriangle * sizeof(unsigned int[3])));
1465                                 CHECKGLERROR
1466                         }
1467                 }
1468                 else if (element3s)
1469                 {
1470                         GL_BindEBO(0);
1471                         if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
1472                         {
1473                                 qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_SHORT, element3s);
1474                                 CHECKGLERROR
1475                         }
1476                         else
1477                         {
1478                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_SHORT, element3s);
1479                                 CHECKGLERROR
1480                         }
1481                 }
1482                 else if (element3i)
1483                 {
1484                         GL_BindEBO(0);
1485                         if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
1486                         {
1487                                 qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices - 1, numelements, GL_UNSIGNED_INT, element3i);
1488                                 CHECKGLERROR
1489                         }
1490                         else
1491                         {
1492                                 qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, element3i);
1493                                 CHECKGLERROR
1494                         }
1495                 }
1496                 else
1497                 {
1498                         qglDrawArrays(GL_TRIANGLES, firstvertex, numvertices);
1499                         CHECKGLERROR
1500                 }
1501         }
1502 }
1503
1504 // restores backend state, used when done with 3D rendering
1505 void R_Mesh_Finish(void)
1506 {
1507 }
1508
1509 r_meshbuffer_t *R_Mesh_CreateMeshBuffer(const void *data, size_t size, const char *name, qboolean isindexbuffer, qboolean isdynamic)
1510 {
1511         int bufferobject = 0;
1512         void *devicebuffer = NULL;
1513         r_meshbuffer_t *buffer;
1514         if (!(isdynamic ? (isindexbuffer ? gl_state.usevbo_dynamicindex : gl_state.usevbo_dynamicvertex) : (isindexbuffer ? gl_state.usevbo_staticindex : gl_state.usevbo_staticvertex)))
1515                 return NULL;
1516         if (isindexbuffer)
1517         {
1518                 r_refdef.stats.indexbufferuploadcount++;
1519                 r_refdef.stats.indexbufferuploadsize += size;
1520         }
1521         else
1522         {
1523                 r_refdef.stats.vertexbufferuploadcount++;
1524                 r_refdef.stats.vertexbufferuploadsize += size;
1525         }
1526         switch(vid.renderpath)
1527         {
1528         case RENDERPATH_GL11:
1529         case RENDERPATH_GL13:
1530         case RENDERPATH_GL20:
1531         case RENDERPATH_CGGL:
1532                 qglGenBuffersARB(1, (GLuint *)&bufferobject);
1533                 if (isindexbuffer)
1534                         GL_BindEBO(bufferobject);
1535                 else
1536                         GL_BindVBO(bufferobject);
1537                 qglBufferDataARB(isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER_ARB : GL_ARRAY_BUFFER_ARB, size, data, isdynamic ? GL_STREAM_DRAW_ARB : GL_STATIC_DRAW_ARB);
1538                 break;
1539         }
1540         buffer = (r_meshbuffer_t *)Mem_ExpandableArray_AllocRecord(&gl_state.meshbufferarray);
1541         memset(buffer, 0, sizeof(*buffer));
1542         buffer->bufferobject = bufferobject;
1543         buffer->devicebuffer = devicebuffer;
1544         buffer->size = size;
1545         buffer->isindexbuffer = isindexbuffer;
1546         buffer->isdynamic = isdynamic;
1547         strlcpy(buffer->name, name, sizeof(buffer->name));
1548         return buffer;
1549 }
1550
1551 void R_Mesh_UpdateMeshBuffer(r_meshbuffer_t *buffer, const void *data, size_t size)
1552 {
1553         if (!buffer || (!buffer->bufferobject && !buffer->devicebuffer))
1554                 return;
1555         if (buffer->isindexbuffer)
1556         {
1557                 r_refdef.stats.indexbufferuploadcount++;
1558                 r_refdef.stats.indexbufferuploadsize += size;
1559         }
1560         else
1561         {
1562                 r_refdef.stats.vertexbufferuploadcount++;
1563                 r_refdef.stats.vertexbufferuploadsize += size;
1564         }
1565         switch(vid.renderpath)
1566         {
1567         case RENDERPATH_GL11:
1568         case RENDERPATH_GL13:
1569         case RENDERPATH_GL20:
1570         case RENDERPATH_CGGL:
1571                 if (buffer->isindexbuffer)
1572                         GL_BindEBO(buffer->bufferobject);
1573                 else
1574                         GL_BindVBO(buffer->bufferobject);
1575                 qglBufferDataARB(buffer->isindexbuffer ? GL_ELEMENT_ARRAY_BUFFER_ARB : GL_ARRAY_BUFFER_ARB, size, data, buffer->isdynamic ? GL_STREAM_DRAW_ARB : GL_STATIC_DRAW_ARB);
1576                 break;
1577         }
1578 }
1579
1580 void R_Mesh_DestroyMeshBuffer(r_meshbuffer_t *buffer)
1581 {
1582         if (!buffer)
1583                 return;
1584         switch(vid.renderpath)
1585         {
1586         case RENDERPATH_GL11:
1587         case RENDERPATH_GL13:
1588         case RENDERPATH_GL20:
1589         case RENDERPATH_CGGL:
1590                 qglDeleteBuffersARB(1, (GLuint *)&buffer->bufferobject);
1591                 break;
1592         }
1593         Mem_ExpandableArray_FreeRecord(&gl_state.meshbufferarray, (void *)buffer);
1594 }
1595
1596 void GL_Mesh_ListVBOs(qboolean printeach)
1597 {
1598         int i, endindex;
1599         size_t ebocount = 0, ebomemory = 0;
1600         size_t vbocount = 0, vbomemory = 0;
1601         r_meshbuffer_t *buffer;
1602         endindex = Mem_ExpandableArray_IndexRange(&gl_state.meshbufferarray);
1603         for (i = 0;i < endindex;i++)
1604         {
1605                 buffer = (r_meshbuffer_t *) Mem_ExpandableArray_RecordAtIndex(&gl_state.meshbufferarray, i);
1606                 if (!buffer)
1607                         continue;
1608                 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)");}
1609                 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)");}
1610         }
1611         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);
1612 }
1613
1614
1615
1616 void R_Mesh_VertexPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
1617 {
1618         int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
1619         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)
1620         {
1621                 gl_state.pointer_vertex_components = components;
1622                 gl_state.pointer_vertex_gltype = gltype;
1623                 gl_state.pointer_vertex_stride = stride;
1624                 gl_state.pointer_vertex_pointer = pointer;
1625                 gl_state.pointer_vertex_vertexbuffer = vertexbuffer;
1626                 gl_state.pointer_vertex_offset = bufferoffset;
1627                 CHECKGLERROR
1628                 GL_BindVBO(bufferobject);
1629                 qglVertexPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
1630         }
1631 }
1632
1633 void R_Mesh_ColorPointer(int components, int gltype, size_t stride, const void *pointer, const r_meshbuffer_t *vertexbuffer, size_t bufferoffset)
1634 {
1635         // note: vertexbuffer may be non-NULL even if pointer is NULL, so check
1636         // the pointer only.
1637         if (pointer)
1638         {
1639                 int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
1640                 // caller wants color array enabled
1641                 if (!gl_state.pointer_color_enabled)
1642                 {
1643                         gl_state.pointer_color_enabled = true;
1644                         CHECKGLERROR
1645                         qglEnableClientState(GL_COLOR_ARRAY);CHECKGLERROR
1646                 }
1647                 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)
1648                 {
1649                         gl_state.pointer_color_components = components;
1650                         gl_state.pointer_color_gltype = gltype;
1651                         gl_state.pointer_color_stride = stride;
1652                         gl_state.pointer_color_pointer = pointer;
1653                         gl_state.pointer_color_vertexbuffer = vertexbuffer;
1654                         gl_state.pointer_color_offset = bufferoffset;
1655                         CHECKGLERROR
1656                         GL_BindVBO(bufferobject);
1657                         qglColorPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
1658                 }
1659         }
1660         else
1661         {
1662                 // caller wants color array disabled
1663                 if (gl_state.pointer_color_enabled)
1664                 {
1665                         gl_state.pointer_color_enabled = false;
1666                         CHECKGLERROR
1667                         qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
1668                         // when color array is on the glColor gets trashed, set it again
1669                         qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);CHECKGLERROR
1670                 }
1671         }
1672 }
1673
1674 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)
1675 {
1676         gltextureunit_t *unit = gl_state.units + unitnum;
1677         // update array settings
1678         CHECKGLERROR
1679         // note: there is no need to check bufferobject here because all cases
1680         // that involve a valid bufferobject also supply a texcoord array
1681         if (pointer)
1682         {
1683                 int bufferobject = vertexbuffer ? vertexbuffer->bufferobject : 0;
1684                 // texture array unit is enabled, enable the array
1685                 if (!unit->arrayenabled)
1686                 {
1687                         unit->arrayenabled = true;
1688                         GL_ClientActiveTexture(unitnum);
1689                         qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
1690                 }
1691                 // texcoord array
1692                 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)
1693                 {
1694                         unit->pointer_texcoord_components = components;
1695                         unit->pointer_texcoord_gltype = gltype;
1696                         unit->pointer_texcoord_stride = stride;
1697                         unit->pointer_texcoord_pointer = pointer;
1698                         unit->pointer_texcoord_vertexbuffer = vertexbuffer;
1699                         unit->pointer_texcoord_offset = bufferoffset;
1700                         GL_ClientActiveTexture(unitnum);
1701                         GL_BindVBO(bufferobject);
1702                         qglTexCoordPointer(components, gltype, stride, bufferobject ? (void *)bufferoffset : pointer);CHECKGLERROR
1703                 }
1704         }
1705         else
1706         {
1707                 // texture array unit is disabled, disable the array
1708                 if (unit->arrayenabled)
1709                 {
1710                         unit->arrayenabled = false;
1711                         GL_ClientActiveTexture(unitnum);
1712                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
1713                 }
1714         }
1715 }
1716
1717 int R_Mesh_TexBound(unsigned int unitnum, int id)
1718 {
1719         gltextureunit_t *unit = gl_state.units + unitnum;
1720         if (unitnum >= vid.teximageunits)
1721                 return 0;
1722         if (id == GL_TEXTURE_2D)
1723                 return unit->t2d;
1724         if (id == GL_TEXTURE_3D)
1725                 return unit->t3d;
1726         if (id == GL_TEXTURE_CUBE_MAP_ARB)
1727                 return unit->tcubemap;
1728         if (id == GL_TEXTURE_RECTANGLE_ARB)
1729                 return unit->trectangle;
1730         return 0;
1731 }
1732
1733 void R_Mesh_CopyToTexture(rtexture_t *tex, int tx, int ty, int sx, int sy, int width, int height)
1734 {
1735         R_Mesh_TexBind(0, tex);
1736         GL_ActiveTexture(0);CHECKGLERROR
1737         qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, tx, ty, sx, sy, width, height);CHECKGLERROR
1738 }
1739
1740 void R_Mesh_TexBind(unsigned int unitnum, rtexture_t *tex)
1741 {
1742         gltextureunit_t *unit = gl_state.units + unitnum;
1743         int tex2d, tex3d, texcubemap, texnum;
1744         if (unitnum >= vid.teximageunits)
1745                 return;
1746         switch(vid.renderpath)
1747         {
1748         case RENDERPATH_GL20:
1749         case RENDERPATH_CGGL:
1750                 if (!tex)
1751                         tex = r_texture_white;
1752                 texnum = R_GetTexture(tex);
1753                 switch(tex->gltexturetypeenum)
1754                 {
1755                 case GL_TEXTURE_2D: if (unit->t2d != texnum) {GL_ActiveTexture(unitnum);unit->t2d = texnum;qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR}break;
1756                 case GL_TEXTURE_3D: if (unit->t3d != texnum) {GL_ActiveTexture(unitnum);unit->t3d = texnum;qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR}break;
1757                 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;
1758                 case GL_TEXTURE_RECTANGLE_ARB: if (unit->trectangle != texnum) {GL_ActiveTexture(unitnum);unit->trectangle = texnum;qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, unit->trectangle);CHECKGLERROR}break;
1759                 }
1760                 break;
1761         case RENDERPATH_GL13:
1762         case RENDERPATH_GL11:
1763                 tex2d = 0;
1764                 tex3d = 0;
1765                 texcubemap = 0;
1766                 if (tex)
1767                 {
1768                         texnum = R_GetTexture(tex);
1769                         switch(tex->gltexturetypeenum)
1770                         {
1771                         case GL_TEXTURE_2D:
1772                                 tex2d = texnum;
1773                                 break;
1774                         case GL_TEXTURE_3D:
1775                                 tex3d = texnum;
1776                                 break;
1777                         case GL_TEXTURE_CUBE_MAP_ARB:
1778                                 texcubemap = texnum;
1779                                 break;
1780                         }
1781                 }
1782                 // update 2d texture binding
1783                 if (unit->t2d != tex2d)
1784                 {
1785                         GL_ActiveTexture(unitnum);
1786                         if (tex2d)
1787                         {
1788                                 if (unit->t2d == 0)
1789                                 {
1790                                         qglEnable(GL_TEXTURE_2D);CHECKGLERROR
1791                                 }
1792                         }
1793                         else
1794                         {
1795                                 if (unit->t2d)
1796                                 {
1797                                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
1798                                 }
1799                         }
1800                         unit->t2d = tex2d;
1801                         qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
1802                 }
1803                 // update 3d texture binding
1804                 if (unit->t3d != tex3d)
1805                 {
1806                         GL_ActiveTexture(unitnum);
1807                         if (tex3d)
1808                         {
1809                                 if (unit->t3d == 0)
1810                                 {
1811                                         qglEnable(GL_TEXTURE_3D);CHECKGLERROR
1812                                 }
1813                         }
1814                         else
1815                         {
1816                                 if (unit->t3d)
1817                                 {
1818                                         qglDisable(GL_TEXTURE_3D);CHECKGLERROR
1819                                 }
1820                         }
1821                         unit->t3d = tex3d;
1822                         qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
1823                 }
1824                 // update cubemap texture binding
1825                 if (unit->tcubemap != texcubemap)
1826                 {
1827                         GL_ActiveTexture(unitnum);
1828                         if (texcubemap)
1829                         {
1830                                 if (unit->tcubemap == 0)
1831                                 {
1832                                         qglEnable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR
1833                                 }
1834                         }
1835                         else
1836                         {
1837                                 if (unit->tcubemap)
1838                                 {
1839                                         qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR
1840                                 }
1841                         }
1842                         unit->tcubemap = texcubemap;
1843                         qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR
1844                 }
1845                 break;
1846         }
1847 }
1848
1849 void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix)
1850 {
1851         gltextureunit_t *unit = gl_state.units + unitnum;
1852         if (matrix && matrix->m[3][3])
1853         {
1854                 // texmatrix specified, check if it is different
1855                 if (!unit->texmatrixenabled || memcmp(&unit->matrix, matrix, sizeof(matrix4x4_t)))
1856                 {
1857                         float glmatrix[16];
1858                         unit->texmatrixenabled = true;
1859                         unit->matrix = *matrix;
1860                         CHECKGLERROR
1861                         Matrix4x4_ToArrayFloatGL(&unit->matrix, glmatrix);
1862                         GL_ActiveTexture(unitnum);
1863                         qglMatrixMode(GL_TEXTURE);CHECKGLERROR
1864                         qglLoadMatrixf(glmatrix);CHECKGLERROR
1865                         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
1866                 }
1867         }
1868         else
1869         {
1870                 // no texmatrix specified, revert to identity
1871                 if (unit->texmatrixenabled)
1872                 {
1873                         unit->texmatrixenabled = false;
1874                         unit->matrix = identitymatrix;
1875                         CHECKGLERROR
1876                         GL_ActiveTexture(unitnum);
1877                         qglMatrixMode(GL_TEXTURE);CHECKGLERROR
1878                         qglLoadIdentity();CHECKGLERROR
1879                         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
1880                 }
1881         }
1882 }
1883
1884 void R_Mesh_TexCombine(unsigned int unitnum, int combinergb, int combinealpha, int rgbscale, int alphascale)
1885 {
1886         gltextureunit_t *unit = gl_state.units + unitnum;
1887         CHECKGLERROR
1888         switch(vid.renderpath)
1889         {
1890         case RENDERPATH_GL20:
1891         case RENDERPATH_CGGL:
1892                 // do nothing
1893                 break;
1894         case RENDERPATH_GL13:
1895                 // GL_ARB_texture_env_combine
1896                 if (!combinergb)
1897                         combinergb = GL_MODULATE;
1898                 if (!combinealpha)
1899                         combinealpha = GL_MODULATE;
1900                 if (!rgbscale)
1901                         rgbscale = 1;
1902                 if (!alphascale)
1903                         alphascale = 1;
1904                 if (combinergb != combinealpha || rgbscale != 1 || alphascale != 1)
1905                 {
1906                         if (combinergb == GL_DECAL)
1907                                 combinergb = GL_INTERPOLATE_ARB;
1908                         if (unit->combine != GL_COMBINE_ARB)
1909                         {
1910                                 unit->combine = GL_COMBINE_ARB;
1911                                 GL_ActiveTexture(unitnum);
1912                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);CHECKGLERROR
1913                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE);CHECKGLERROR // for GL_INTERPOLATE_ARB mode
1914                         }
1915                         if (unit->combinergb != combinergb)
1916                         {
1917                                 unit->combinergb = combinergb;
1918                                 GL_ActiveTexture(unitnum);
1919                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, unit->combinergb);CHECKGLERROR
1920                         }
1921                         if (unit->combinealpha != combinealpha)
1922                         {
1923                                 unit->combinealpha = combinealpha;
1924                                 GL_ActiveTexture(unitnum);
1925                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, unit->combinealpha);CHECKGLERROR
1926                         }
1927                         if (unit->rgbscale != rgbscale)
1928                         {
1929                                 unit->rgbscale = rgbscale;
1930                                 GL_ActiveTexture(unitnum);
1931                                 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, unit->rgbscale);CHECKGLERROR
1932                         }
1933                         if (unit->alphascale != alphascale)
1934                         {
1935                                 unit->alphascale = alphascale;
1936                                 GL_ActiveTexture(unitnum);
1937                                 qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, unit->alphascale);CHECKGLERROR
1938                         }
1939                 }
1940                 else
1941                 {
1942                         if (unit->combine != combinergb)
1943                         {
1944                                 unit->combine = combinergb;
1945                                 GL_ActiveTexture(unitnum);
1946                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
1947                         }
1948                 }
1949                 break;
1950         case RENDERPATH_GL11:
1951                 // normal GL texenv
1952                 if (!combinergb)
1953                         combinergb = GL_MODULATE;
1954                 if (unit->combine != combinergb)
1955                 {
1956                         unit->combine = combinergb;
1957                         GL_ActiveTexture(unitnum);
1958                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
1959                 }
1960                 break;
1961         }
1962 }
1963
1964 void R_Mesh_ResetTextureState(void)
1965 {
1966         unsigned int unitnum;
1967
1968         BACKENDACTIVECHECK
1969
1970         CHECKGLERROR
1971         switch(vid.renderpath)
1972         {
1973         case RENDERPATH_GL20:
1974         case RENDERPATH_CGGL:
1975                 for (unitnum = 0;unitnum < vid.teximageunits;unitnum++)
1976                 {
1977                         gltextureunit_t *unit = gl_state.units + unitnum;
1978                         if (unit->t2d)
1979                         {
1980                                 unit->t2d = 0;
1981                                 GL_ActiveTexture(unitnum);
1982                                 qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
1983                         }
1984                         if (unit->t3d)
1985                         {
1986                                 unit->t3d = 0;
1987                                 GL_ActiveTexture(unitnum);
1988                                 qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
1989                         }
1990                         if (unit->tcubemap)
1991                         {
1992                                 unit->tcubemap = 0;
1993                                 GL_ActiveTexture(unitnum);
1994                                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR
1995                         }
1996                         if (unit->trectangle)
1997                         {
1998                                 unit->trectangle = 0;
1999                                 GL_ActiveTexture(unitnum);
2000                                 qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, unit->trectangle);CHECKGLERROR
2001                         }
2002                 }
2003                 for (unitnum = 0;unitnum < vid.texarrayunits;unitnum++)
2004                 {
2005                         gltextureunit_t *unit = gl_state.units + unitnum;
2006                         if (unit->arrayenabled)
2007                         {
2008                                 unit->arrayenabled = false;
2009                                 GL_ClientActiveTexture(unitnum);
2010                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
2011                         }
2012                 }
2013                 for (unitnum = 0;unitnum < vid.texunits;unitnum++)
2014                 {
2015                         gltextureunit_t *unit = gl_state.units + unitnum;
2016                         if (unit->texmatrixenabled)
2017                         {
2018                                 unit->texmatrixenabled = false;
2019                                 unit->matrix = identitymatrix;
2020                                 CHECKGLERROR
2021                                 GL_ActiveTexture(unitnum);
2022                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
2023                                 qglLoadIdentity();CHECKGLERROR
2024                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
2025                         }
2026                 }
2027                 break;
2028         case RENDERPATH_GL13:
2029         case RENDERPATH_GL11:
2030                 for (unitnum = 0;unitnum < vid.texunits;unitnum++)
2031                 {
2032                         gltextureunit_t *unit = gl_state.units + unitnum;
2033                         if (unit->t2d)
2034                         {
2035                                 unit->t2d = 0;
2036                                 GL_ActiveTexture(unitnum);
2037                                 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
2038                                 qglBindTexture(GL_TEXTURE_2D, unit->t2d);CHECKGLERROR
2039                         }
2040                         if (unit->t3d)
2041                         {
2042                                 unit->t3d = 0;
2043                                 GL_ActiveTexture(unitnum);
2044                                 qglDisable(GL_TEXTURE_3D);CHECKGLERROR
2045                                 qglBindTexture(GL_TEXTURE_3D, unit->t3d);CHECKGLERROR
2046                         }
2047                         if (unit->tcubemap)
2048                         {
2049                                 unit->tcubemap = 0;
2050                                 GL_ActiveTexture(unitnum);
2051                                 qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR
2052                                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);CHECKGLERROR
2053                         }
2054                         if (unit->trectangle)
2055                         {
2056                                 unit->trectangle = 0;
2057                                 GL_ActiveTexture(unitnum);
2058                                 qglDisable(GL_TEXTURE_RECTANGLE_ARB);CHECKGLERROR
2059                                 qglBindTexture(GL_TEXTURE_RECTANGLE_ARB, unit->trectangle);CHECKGLERROR
2060                         }
2061                         if (unit->arrayenabled)
2062                         {
2063                                 unit->arrayenabled = false;
2064                                 GL_ClientActiveTexture(unitnum);
2065                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
2066                         }
2067                         if (unit->texmatrixenabled)
2068                         {
2069                                 unit->texmatrixenabled = false;
2070                                 unit->matrix = identitymatrix;
2071                                 CHECKGLERROR
2072                                 GL_ActiveTexture(unitnum);
2073                                 qglMatrixMode(GL_TEXTURE);CHECKGLERROR
2074                                 qglLoadIdentity();CHECKGLERROR
2075                                 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
2076                         }
2077                         if (unit->combine != GL_MODULATE)
2078                         {
2079                                 unit->combine = GL_MODULATE;
2080                                 GL_ActiveTexture(unitnum);
2081                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combine);CHECKGLERROR
2082                         }
2083                 }
2084                 break;
2085         }
2086 }
2087
2088
2089
2090 r_vertexposition_t *R_Mesh_PrepareVertices_Position_Lock(int numvertices)
2091 {
2092         size_t size;
2093         size = sizeof(r_vertexposition_t) * numvertices;
2094         if (gl_state.preparevertices_tempdatamaxsize < size)
2095         {
2096                 gl_state.preparevertices_tempdatamaxsize = size;
2097                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
2098         }
2099         gl_state.preparevertices_vertexposition = (r_vertexposition_t *)gl_state.preparevertices_tempdata;
2100         gl_state.preparevertices_numvertices = numvertices;
2101         return gl_state.preparevertices_vertexposition;
2102 }
2103
2104 qboolean R_Mesh_PrepareVertices_Position_Unlock(void)
2105 {
2106         R_Mesh_PrepareVertices_Position(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexposition, NULL);
2107         gl_state.preparevertices_vertexposition = NULL;
2108         gl_state.preparevertices_numvertices = 0;
2109         return true;
2110 }
2111
2112 void R_Mesh_PrepareVertices_Position_Arrays(int numvertices, const float *vertex3f)
2113 {
2114         int i;
2115         r_vertexposition_t *vertex;
2116         switch(vid.renderpath)
2117         {
2118         case RENDERPATH_GL20:
2119         case RENDERPATH_CGGL:
2120                 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
2121                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
2122                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2123                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2124                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2125                 R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2126                 R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2127                 break;
2128         case RENDERPATH_GL13:
2129         case RENDERPATH_GL11:
2130                 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
2131                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
2132                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2133                 if (vid.texunits >= 2)
2134                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2135                 if (vid.texunits >= 3)
2136                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2137                 break;
2138         }
2139
2140         // no quick path for this case, convert to vertex structs
2141         vertex = R_Mesh_PrepareVertices_Position_Lock(numvertices);
2142         for (i = 0;i < numvertices;i++)
2143                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
2144         R_Mesh_PrepareVertices_Position_Unlock();
2145         R_Mesh_PrepareVertices_Position(numvertices, vertex, NULL);
2146 }
2147
2148 void R_Mesh_PrepareVertices_Position(int numvertices, const r_vertexposition_t *vertex, const r_meshbuffer_t *vertexbuffer)
2149 {
2150         // upload temporary vertexbuffer for this rendering
2151         if (!gl_state.usevbo_staticvertex)
2152                 vertexbuffer = NULL;
2153         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
2154         {
2155                 if (gl_state.preparevertices_dynamicvertexbuffer)
2156                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex));
2157                 else
2158                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true);
2159                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
2160         }
2161         if (vertexbuffer)
2162         {
2163                 switch(vid.renderpath)
2164                 {
2165                 case RENDERPATH_GL20:
2166                 case RENDERPATH_CGGL:
2167                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2168                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2169                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2170                 case RENDERPATH_GL13:
2171                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2172                 case RENDERPATH_GL11:
2173                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
2174                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
2175                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2176                         break;
2177                 }
2178                 return;
2179         }
2180         switch(vid.renderpath)
2181         {
2182         case RENDERPATH_GL20:
2183         case RENDERPATH_CGGL:
2184                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2185                 R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2186                 R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2187         case RENDERPATH_GL13:
2188                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2189         case RENDERPATH_GL11:
2190                 R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
2191                 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, NULL, 0);
2192                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2193                 break;
2194         }
2195 }
2196
2197
2198
2199 r_vertexgeneric_t *R_Mesh_PrepareVertices_Generic_Lock(int numvertices)
2200 {
2201         size_t size;
2202         size = sizeof(r_vertexgeneric_t) * numvertices;
2203         if (gl_state.preparevertices_tempdatamaxsize < size)
2204         {
2205                 gl_state.preparevertices_tempdatamaxsize = size;
2206                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
2207         }
2208         gl_state.preparevertices_vertexgeneric = (r_vertexgeneric_t *)gl_state.preparevertices_tempdata;
2209         gl_state.preparevertices_numvertices = numvertices;
2210         return gl_state.preparevertices_vertexgeneric;
2211 }
2212
2213 qboolean R_Mesh_PrepareVertices_Generic_Unlock(void)
2214 {
2215         R_Mesh_PrepareVertices_Generic(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexgeneric, NULL);
2216         gl_state.preparevertices_vertexgeneric = NULL;
2217         gl_state.preparevertices_numvertices = 0;
2218         return true;
2219 }
2220
2221 void R_Mesh_PrepareVertices_Generic_Arrays(int numvertices, const float *vertex3f, const float *color4f, const float *texcoord2f)
2222 {
2223         int i;
2224         r_vertexgeneric_t *vertex;
2225         switch(vid.renderpath)
2226         {
2227         case RENDERPATH_GL20:
2228         case RENDERPATH_CGGL:
2229                 if (gl_mesh_separatearrays.integer)
2230                 {
2231                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
2232                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
2233                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
2234                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2235                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2236                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2237                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2238                         return;
2239                 }
2240                 break;
2241         case RENDERPATH_GL13:
2242         case RENDERPATH_GL11:
2243                 if (gl_mesh_separatearrays.integer)
2244                 {
2245                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
2246                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
2247                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoord2f, NULL, 0);
2248                         if (vid.texunits >= 2)
2249                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2250                         if (vid.texunits >= 3)
2251                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2252                         return;
2253                 }
2254                 break;
2255         }
2256
2257         // no quick path for this case, convert to vertex structs
2258         vertex = R_Mesh_PrepareVertices_Generic_Lock(numvertices);
2259         for (i = 0;i < numvertices;i++)
2260                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
2261         if (color4f)
2262         {
2263                 for (i = 0;i < numvertices;i++)
2264                         Vector4Scale(color4f + 4*i, 255.0f, vertex[i].color4ub);
2265         }
2266         else
2267         {
2268                 float tempcolor4f[4];
2269                 unsigned char tempcolor4ub[4];
2270                 Vector4Scale(gl_state.color4f, 255.0f, tempcolor4f);
2271                 tempcolor4ub[0] = (unsigned char)bound(0.0f, tempcolor4f[0], 255.0f);
2272                 tempcolor4ub[1] = (unsigned char)bound(0.0f, tempcolor4f[1], 255.0f);
2273                 tempcolor4ub[2] = (unsigned char)bound(0.0f, tempcolor4f[2], 255.0f);
2274                 tempcolor4ub[3] = (unsigned char)bound(0.0f, tempcolor4f[3], 255.0f);
2275                 for (i = 0;i < numvertices;i++)
2276                         Vector4Copy(tempcolor4ub, vertex[i].color4ub);
2277         }
2278         if (texcoord2f)
2279                 for (i = 0;i < numvertices;i++)
2280                         Vector2Copy(texcoord2f + 2*i, vertex[i].texcoord2f);
2281         R_Mesh_PrepareVertices_Generic_Unlock();
2282         R_Mesh_PrepareVertices_Generic(numvertices, vertex, NULL);
2283 }
2284
2285 void R_Mesh_PrepareVertices_Generic(int numvertices, const r_vertexgeneric_t *vertex, const r_meshbuffer_t *vertexbuffer)
2286 {
2287         // upload temporary vertexbuffer for this rendering
2288         if (!gl_state.usevbo_staticvertex)
2289                 vertexbuffer = NULL;
2290         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
2291         {
2292                 if (gl_state.preparevertices_dynamicvertexbuffer)
2293                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex));
2294                 else
2295                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true);
2296                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
2297         }
2298         if (vertexbuffer)
2299         {
2300                 switch(vid.renderpath)
2301                 {
2302                 case RENDERPATH_GL20:
2303                 case RENDERPATH_CGGL:
2304                         R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2305                         R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2306                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2307                 case RENDERPATH_GL13:
2308                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2309                 case RENDERPATH_GL11:
2310                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
2311                         R_Mesh_ColorPointer(      4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub          , vertexbuffer, (int)((unsigned char *)vertex->color4ub           - (unsigned char *)vertex));
2312                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , vertexbuffer, (int)((unsigned char *)vertex->texcoord2f         - (unsigned char *)vertex));
2313                         break;
2314                 }
2315                 return;
2316         }
2317         switch(vid.renderpath)
2318         {
2319         case RENDERPATH_GL20:
2320         case RENDERPATH_CGGL:
2321                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2322                 R_Mesh_TexCoordPointer(3, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2323                 R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2324         case RENDERPATH_GL13:
2325                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2326         case RENDERPATH_GL11:
2327                 R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
2328                 R_Mesh_ColorPointer(      4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub          , NULL, 0);
2329                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoord2f        , NULL, 0);
2330                 break;
2331         }
2332 }
2333
2334
2335
2336 r_vertexmesh_t *R_Mesh_PrepareVertices_Mesh_Lock(int numvertices)
2337 {
2338         size_t size;
2339         size = sizeof(r_vertexmesh_t) * numvertices;
2340         if (gl_state.preparevertices_tempdatamaxsize < size)
2341         {
2342                 gl_state.preparevertices_tempdatamaxsize = size;
2343                 gl_state.preparevertices_tempdata = Mem_Realloc(r_main_mempool, gl_state.preparevertices_tempdata, gl_state.preparevertices_tempdatamaxsize);
2344         }
2345         gl_state.preparevertices_vertexmesh = (r_vertexmesh_t *)gl_state.preparevertices_tempdata;
2346         gl_state.preparevertices_numvertices = numvertices;
2347         return gl_state.preparevertices_vertexmesh;
2348 }
2349
2350 qboolean R_Mesh_PrepareVertices_Mesh_Unlock(void)
2351 {
2352         R_Mesh_PrepareVertices_Mesh(gl_state.preparevertices_numvertices, gl_state.preparevertices_vertexmesh, NULL);
2353         gl_state.preparevertices_vertexmesh = NULL;
2354         gl_state.preparevertices_numvertices = 0;
2355         return true;
2356 }
2357
2358 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)
2359 {
2360         int i;
2361         r_vertexmesh_t *vertex;
2362         switch(vid.renderpath)
2363         {
2364         case RENDERPATH_GL20:
2365         case RENDERPATH_CGGL:
2366                 if (gl_mesh_separatearrays.integer)
2367                 {
2368                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
2369                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
2370                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
2371                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), svector3f, NULL, 0);
2372                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), tvector3f, NULL, 0);
2373                         R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), normal3f, NULL, 0);
2374                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
2375                         return;
2376                 }
2377                 break;
2378         case RENDERPATH_GL13:
2379         case RENDERPATH_GL11:
2380                 if (gl_mesh_separatearrays.integer)
2381                 {
2382                         R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex3f, NULL, 0);
2383                         R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), color4f, NULL, 0);
2384                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), texcoordtexture2f, NULL, 0);
2385                         if (vid.texunits >= 2)
2386                                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), texcoordlightmap2f, NULL, 0);
2387                         if (vid.texunits >= 3)
2388                                 R_Mesh_TexCoordPointer(2, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
2389                         return;
2390                 }
2391                 break;
2392         }
2393
2394         vertex = R_Mesh_PrepareVertices_Mesh_Lock(numvertices);
2395         for (i = 0;i < numvertices;i++)
2396                 VectorCopy(vertex3f + 3*i, vertex[i].vertex3f);
2397         if (svector3f)
2398                 for (i = 0;i < numvertices;i++)
2399                         VectorCopy(svector3f + 3*i, vertex[i].svector3f);
2400         if (tvector3f)
2401                 for (i = 0;i < numvertices;i++)
2402                         VectorCopy(tvector3f + 3*i, vertex[i].tvector3f);
2403         if (normal3f)
2404                 for (i = 0;i < numvertices;i++)
2405                         VectorCopy(normal3f + 3*i, vertex[i].normal3f);
2406         if (color4f)
2407         {
2408                 for (i = 0;i < numvertices;i++)
2409                         Vector4Scale(color4f + 4*i, 255.0f, vertex[i].color4ub);
2410         }
2411         else
2412         {
2413                 float tempcolor4f[4];
2414                 unsigned char tempcolor4ub[4];
2415                 Vector4Scale(gl_state.color4f, 255.0f, tempcolor4f);
2416                 tempcolor4ub[0] = (unsigned char)bound(0.0f, tempcolor4f[0], 255.0f);
2417                 tempcolor4ub[1] = (unsigned char)bound(0.0f, tempcolor4f[1], 255.0f);
2418                 tempcolor4ub[2] = (unsigned char)bound(0.0f, tempcolor4f[2], 255.0f);
2419                 tempcolor4ub[3] = (unsigned char)bound(0.0f, tempcolor4f[3], 255.0f);
2420                 for (i = 0;i < numvertices;i++)
2421                         Vector4Copy(tempcolor4ub, vertex[i].color4ub);
2422         }
2423         if (texcoordtexture2f)
2424                 for (i = 0;i < numvertices;i++)
2425                         Vector2Copy(texcoordtexture2f + 2*i, vertex[i].texcoordtexture2f);
2426         if (texcoordlightmap2f)
2427                 for (i = 0;i < numvertices;i++)
2428                         Vector2Copy(texcoordlightmap2f + 2*i, vertex[i].texcoordlightmap2f);
2429         R_Mesh_PrepareVertices_Mesh_Unlock();
2430         R_Mesh_PrepareVertices_Mesh(numvertices, vertex, NULL);
2431 }
2432
2433 void R_Mesh_PrepareVertices_Mesh(int numvertices, const r_vertexmesh_t *vertex, const r_meshbuffer_t *vertexbuffer)
2434 {
2435         // upload temporary vertexbuffer for this rendering
2436         if (!gl_state.usevbo_staticvertex)
2437                 vertexbuffer = NULL;
2438         if (!vertexbuffer && gl_state.usevbo_dynamicvertex)
2439         {
2440                 if (gl_state.preparevertices_dynamicvertexbuffer)
2441                         R_Mesh_UpdateMeshBuffer(gl_state.preparevertices_dynamicvertexbuffer, vertex, numvertices * sizeof(*vertex));
2442                 else
2443                         gl_state.preparevertices_dynamicvertexbuffer = R_Mesh_CreateMeshBuffer(vertex, numvertices * sizeof(*vertex), "temporary", false, true);
2444                 vertexbuffer = gl_state.preparevertices_dynamicvertexbuffer;
2445         }
2446         if (vertexbuffer)
2447         {
2448                 switch(vid.renderpath)
2449                 {
2450                 case RENDERPATH_GL20:
2451                 case RENDERPATH_CGGL:
2452                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
2453                         R_Mesh_ColorPointer(      4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub          , vertexbuffer, (int)((unsigned char *)vertex->color4ub           - (unsigned char *)vertex));
2454                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
2455                         R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , vertexbuffer, (int)((unsigned char *)vertex->svector3f          - (unsigned char *)vertex));
2456                         R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , vertexbuffer, (int)((unsigned char *)vertex->tvector3f          - (unsigned char *)vertex));
2457                         R_Mesh_TexCoordPointer(3, 4, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , vertexbuffer, (int)((unsigned char *)vertex->normal3f           - (unsigned char *)vertex));
2458                         R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
2459                         break;
2460                 case RENDERPATH_GL13:
2461                         R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, vertexbuffer, (int)((unsigned char *)vertex->texcoordlightmap2f - (unsigned char *)vertex));
2462                 case RENDERPATH_GL11:
2463                         R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , vertexbuffer, (int)((unsigned char *)vertex->vertex3f           - (unsigned char *)vertex));
2464                         R_Mesh_ColorPointer(      4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub          , vertexbuffer, (int)((unsigned char *)vertex->color4ub           - (unsigned char *)vertex));
2465                         R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , vertexbuffer, (int)((unsigned char *)vertex->texcoordtexture2f  - (unsigned char *)vertex));
2466                         break;
2467                 }
2468                 return;
2469         }
2470         switch(vid.renderpath)
2471         {
2472         case RENDERPATH_GL20:
2473         case RENDERPATH_CGGL:
2474                 R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
2475                 R_Mesh_ColorPointer(      4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub          , NULL, 0);
2476                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
2477                 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT        , sizeof(*vertex), vertex->svector3f         , NULL, 0);
2478                 R_Mesh_TexCoordPointer(2, 3, GL_FLOAT        , sizeof(*vertex), vertex->tvector3f         , NULL, 0);
2479                 R_Mesh_TexCoordPointer(3, 4, GL_FLOAT        , sizeof(*vertex), vertex->normal3f          , NULL, 0);
2480                 R_Mesh_TexCoordPointer(4, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
2481                 break;
2482         case RENDERPATH_GL13:
2483                 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordlightmap2f, NULL, 0);
2484         case RENDERPATH_GL11:
2485                 R_Mesh_VertexPointer(     3, GL_FLOAT        , sizeof(*vertex), vertex->vertex3f          , NULL, 0);
2486                 R_Mesh_ColorPointer(      4, GL_UNSIGNED_BYTE, sizeof(*vertex), vertex->color4ub          , NULL, 0);
2487                 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT        , sizeof(*vertex), vertex->texcoordtexture2f , NULL, 0);
2488                 break;
2489         }
2490 }