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