gl_backend.c

   1
   2 #include "quakedef.h"
   3
   4 cvar_t gl_mesh_maxverts = {0, "gl_mesh_maxverts", "1024"};
   5 cvar_t gl_mesh_floatcolors = {0, "gl_mesh_floatcolors", "1"};
   6 cvar_t gl_mesh_drawmode = {CVAR_SAVE, "gl_mesh_drawmode", "3"};
   7
   8 cvar_t r_render = {0, "r_render", "1"};
   9 cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1"}; // whether or not to use dithering
  10 cvar_t gl_lockarrays = {0, "gl_lockarrays", "1"};
  11
  12 int gl_maxdrawrangeelementsvertices;
  13 int gl_maxdrawrangeelementsindices;
  14
  15 #ifdef DEBUGGL
  16 int errornumber = 0;
  17
  18 void GL_PrintError(int errornumber, char *filename, int linenumber)
  19 {
  20         switch(errornumber)
  21         {
  22 #ifdef GL_INVALID_ENUM
  23         case GL_INVALID_ENUM:
  24                 Con_Printf("GL_INVALID_ENUM at %s:%i\n", filename, linenumber);
  25                 break;
  26 #endif
  27 #ifdef GL_INVALID_VALUE
  28         case GL_INVALID_VALUE:
  29                 Con_Printf("GL_INVALID_VALUE at %s:%i\n", filename, linenumber);
  30                 break;
  31 #endif
  32 #ifdef GL_INVALID_OPERATION
  33         case GL_INVALID_OPERATION:
  34                 Con_Printf("GL_INVALID_OPERATION at %s:%i\n", filename, linenumber);
  35                 break;
  36 #endif
  37 #ifdef GL_STACK_OVERFLOW
  38         case GL_STACK_OVERFLOW:
  39                 Con_Printf("GL_STACK_OVERFLOW at %s:%i\n", filename, linenumber);
  40                 break;
  41 #endif
  42 #ifdef GL_STACK_UNDERFLOW
  43         case GL_STACK_UNDERFLOW:
  44                 Con_Printf("GL_STACK_UNDERFLOW at %s:%i\n", filename, linenumber);
  45                 break;
  46 #endif
  47 #ifdef GL_OUT_OF_MEMORY
  48         case GL_OUT_OF_MEMORY:
  49                 Con_Printf("GL_OUT_OF_MEMORY at %s:%i\n", filename, linenumber);
  50                 break;
  51 #endif
  52 #ifdef GL_TABLE_TOO_LARGE
  53     case GL_TABLE_TOO_LARGE:
  54                 Con_Printf("GL_TABLE_TOO_LARGE at %s:%i\n", filename, linenumber);
  55                 break;
  56 #endif
  57         default:
  58                 Con_Printf("GL UNKNOWN (%i) at %s:%i\n", errornumber, filename, linenumber);
  59                 break;
  60         }
  61 }
  62 #endif
  63
  64 #define BACKENDACTIVECHECK if (!backendactive) Sys_Error("GL backend function called when backend is not active\n");
  65
  66 float r_mesh_farclip;
  67
  68 static float viewdist;
  69 // sign bits (true if negative) for vpn[] entries, so quick integer compares can be used instead of float compares
  70 static int vpnbit0, vpnbit1, vpnbit2;
  71
  72 int c_meshs, c_meshtris;
  73
  74 int lightscalebit;
  75 float lightscale;
  76 float overbrightscale;
  77
  78 void SCR_ScreenShot_f (void);
  79
  80 // these are externally accessible
  81 float mesh_colorscale;
  82 float *varray_vertex;
  83 float *varray_color;
  84 float *varray_texcoord[MAX_TEXTUREUNITS];
  85 int mesh_maxverts;
  86
  87 static matrix4x4_t backend_viewmatrix;
  88 static matrix4x4_t backend_modelmatrix;
  89 static matrix4x4_t backend_modelviewmatrix;
  90 static matrix4x4_t backend_glmodelviewmatrix;
  91
  92 static int backendunits, backendactive;
  93 static qbyte *varray_bcolor;
  94 static mempool_t *gl_backend_mempool;
  95
  96 int polygonelements[768];
  97
  98 void GL_Backend_AllocArrays(void)
  99 {
 100         int i;
 101
 102         for (i = 0;i < POLYGONELEMENTS_MAXPOINTS - 2;i++)
 103         {
 104                 polygonelements[i * 3 + 0] = 0;
 105                 polygonelements[i * 3 + 1] = i + 1;
 106                 polygonelements[i * 3 + 2] = i + 2;
 107         }
 108
 109         if (!gl_backend_mempool)
 110                 gl_backend_mempool = Mem_AllocPool("GL_Backend");
 111
 112         varray_vertex = Mem_Alloc(gl_backend_mempool, mesh_maxverts * sizeof(float[4]));
 113         varray_color = Mem_Alloc(gl_backend_mempool, mesh_maxverts * sizeof(float[4]));
 114         varray_bcolor = Mem_Alloc(gl_backend_mempool, mesh_maxverts * sizeof(qbyte[4]));
 115         for (i = 0;i < backendunits;i++)
 116                 varray_texcoord[i] = Mem_Alloc(gl_backend_mempool, mesh_maxverts * sizeof(float[2]));
 117         for (;i < MAX_TEXTUREUNITS;i++)
 118                 varray_texcoord[i] = NULL;
 119 }
 120
 121 void GL_Backend_FreeArrays(int resizingbuffers)
 122 {
 123         int i;
 124         if (resizingbuffers)
 125                 Mem_EmptyPool(gl_backend_mempool);
 126         else
 127                 Mem_FreePool(&gl_backend_mempool);
 128         varray_vertex = NULL;
 129         varray_color = NULL;
 130         varray_bcolor = NULL;
 131         for (i = 0;i < MAX_TEXTUREUNITS;i++)
 132                 varray_texcoord[i] = NULL;
 133 }
 134
 135 static void gl_backend_start(void)
 136 {
 137         Con_Printf("OpenGL Backend started with gl_mesh_maxverts %i\n", gl_mesh_maxverts.integer);
 138         if (qglDrawRangeElements != NULL)
 139         {
 140                 qglGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &gl_maxdrawrangeelementsvertices);
 141                 qglGetIntegerv(GL_MAX_ELEMENTS_INDICES, &gl_maxdrawrangeelementsindices);
 142                 CHECKGLERROR
 143                 Con_Printf("glDrawRangeElements detected (max vertices %i, max indices %i)\n", gl_maxdrawrangeelementsvertices, gl_maxdrawrangeelementsindices);
 144         }
 145         if (strstr(gl_renderer, "3Dfx"))
 146         {
 147                 Con_Printf("3Dfx driver detected, forcing gl_mesh_floatcolors to 0 to prevent crashs\n");
 148                 Cvar_SetValueQuick(&gl_mesh_floatcolors, 0);
 149         }
 150
 151         backendunits = min(MAX_TEXTUREUNITS, gl_textureunits);
 152
 153         GL_Backend_AllocArrays();
 154
 155         backendactive = true;
 156 }
 157
 158 static void gl_backend_shutdown(void)
 159 {
 160         backendunits = 0;
 161         backendactive = false;
 162
 163         Con_Printf("OpenGL Backend shutting down\n");
 164
 165         GL_Backend_FreeArrays(false);
 166 }
 167
 168 void GL_Backend_CheckCvars(void)
 169 {
 170         if (gl_mesh_drawmode.integer < 0)
 171                 Cvar_SetValueQuick(&gl_mesh_drawmode, 0);
 172         if (gl_mesh_drawmode.integer > 3)
 173                 Cvar_SetValueQuick(&gl_mesh_drawmode, 3);
 174
 175         // change drawmode 3 to 2 if 3 won't work
 176         if (gl_mesh_drawmode.integer >= 3 && qglDrawRangeElements == NULL)
 177                 Cvar_SetValueQuick(&gl_mesh_drawmode, 2);
 178
 179         // 21760 is (65536 / 3) rounded off to a multiple of 128
 180         if (gl_mesh_maxverts.integer < 1024)
 181                 Cvar_SetValueQuick(&gl_mesh_maxverts, 1024);
 182         if (gl_mesh_maxverts.integer > 21760)
 183                 Cvar_SetValueQuick(&gl_mesh_maxverts, 21760);
 184 }
 185
 186 void GL_Backend_ResizeArrays(int numtriangles)
 187 {
 188         Cvar_SetValueQuick(&gl_mesh_maxverts, numtriangles);
 189         GL_Backend_CheckCvars();
 190         mesh_maxverts = gl_mesh_maxverts.integer;
 191         GL_Backend_FreeArrays(true);
 192         GL_Backend_AllocArrays();
 193 }
 194
 195 static void gl_backend_newmap(void)
 196 {
 197 }
 198
 199 void gl_backend_init(void)
 200 {
 201         Cvar_RegisterVariable(&r_render);
 202         Cvar_RegisterVariable(&gl_dither);
 203         Cvar_RegisterVariable(&gl_lockarrays);
 204 #ifdef NORENDER
 205         Cvar_SetValue("r_render", 0);
 206 #endif
 207
 208         Cvar_RegisterVariable(&gl_mesh_maxverts);
 209         Cvar_RegisterVariable(&gl_mesh_floatcolors);
 210         Cvar_RegisterVariable(&gl_mesh_drawmode);
 211         GL_Backend_CheckCvars();
 212         R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap);
 213 }
 214
 215 /*
 216 =============
 217 GL_SetupFrame
 218 =============
 219 */
 220 static void GL_SetupFrame (void)
 221 {
 222         double xmax, ymax;
 223         double fovx, fovy, zNear, zFar, aspect;
 224
 225         if (!r_render.integer)
 226                 return;
 227
 228         qglDepthFunc (GL_LEQUAL);CHECKGLERROR
 229
 230         // set up viewpoint
 231         qglMatrixMode(GL_PROJECTION);CHECKGLERROR
 232         qglLoadIdentity ();CHECKGLERROR
 233
 234         // y is weird beause OpenGL is bottom to top, we use top to bottom
 235         qglViewport(r_refdef.x, vid.realheight - (r_refdef.y + r_refdef.height), r_refdef.width, r_refdef.height);CHECKGLERROR
 236
 237         // depth range
 238         zNear = 1.0;
 239         zFar = r_mesh_farclip;
 240         if (zFar < 64)
 241                 zFar = 64;
 242
 243         // fov angles
 244         fovx = r_refdef.fov_x;
 245         fovy = r_refdef.fov_y;
 246         aspect = r_refdef.width / r_refdef.height;
 247
 248         // pyramid slopes
 249         xmax = zNear * tan(fovx * M_PI / 360.0) * aspect;
 250         ymax = zNear * tan(fovy * M_PI / 360.0);
 251
 252         // set view pyramid
 253         qglFrustum(-xmax, xmax, -ymax, ymax, zNear, zFar);CHECKGLERROR
 254
 255         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
 256
 257         Matrix4x4_CreateRotate(&backend_viewmatrix, -90, 1, 0, 0);
 258         Matrix4x4_ConcatRotate(&backend_viewmatrix, 90, 0, 0, 1);
 259         Matrix4x4_ConcatRotate(&backend_viewmatrix, -r_refdef.viewangles[2], 1, 0, 0);
 260         Matrix4x4_ConcatRotate(&backend_viewmatrix, -r_refdef.viewangles[0], 0, 1, 0);
 261         Matrix4x4_ConcatRotate(&backend_viewmatrix, -r_refdef.viewangles[1], 0, 0, 1);
 262         Matrix4x4_ConcatTranslate(&backend_viewmatrix, -r_refdef.vieworg[0],  -r_refdef.vieworg[1],  -r_refdef.vieworg[2]);
 263         //Con_Printf("Our Matrix:\n");
 264         //Matrix4x4_Print(&backend_viewmatrix);
 265
 266         //Matrix4x4_Transpose(&backend_glmodelviewmatrix, &backend_viewmatrix);
 267         //qglLoadMatrixf(&backend_glmodelviewmatrix.m[0][0]);CHECKGLERROR
 268         memset(&backend_modelmatrix, 0, sizeof(backend_modelmatrix));
 269
 270         /*
 271         // put Z going up
 272         qglLoadIdentity ();CHECKGLERROR
 273         qglRotatef (-90,  1, 0, 0);CHECKGLERROR
 274         qglRotatef (90,  0, 0, 1);CHECKGLERROR
 275         // camera rotation
 276         qglRotatef (-r_refdef.viewangles[2],  1, 0, 0);CHECKGLERROR
 277         qglRotatef (-r_refdef.viewangles[0],  0, 1, 0);CHECKGLERROR
 278         qglRotatef (-r_refdef.viewangles[1],  0, 0, 1);CHECKGLERROR
 279         // camera location
 280         qglTranslatef (-r_refdef.vieworg[0],  -r_refdef.vieworg[1],  -r_refdef.vieworg[2]);CHECKGLERROR
 281         qglGetFloatv (GL_MODELVIEW_MATRIX, &gl_viewmatrix.m[0][0]);
 282         Matrix4x4_Transpose(&backend_viewmatrix, &gl_viewmatrix);
 283         Con_Printf("GL Matrix:\n");
 284         Matrix4x4_Print(&backend_viewmatrix);
 285         */
 286 }
 287
 288 static struct
 289 {
 290         int blendfunc1;
 291         int blendfunc2;
 292         int blend;
 293         GLboolean depthmask;
 294         int depthdisable;
 295         int unit;
 296         int clientunit;
 297         int texture[MAX_TEXTUREUNITS];
 298         float texturergbscale[MAX_TEXTUREUNITS];
 299 }
 300 gl_state;
 301
 302 void GL_SetupTextureState(void)
 303 {
 304         int i;
 305         if (backendunits > 1)
 306         {
 307                 for (i = 0;i < backendunits;i++)
 308                 {
 309                         qglActiveTexture(GL_TEXTURE0_ARB + (gl_state.unit = i));CHECKGLERROR
 310                         qglBindTexture(GL_TEXTURE_2D, gl_state.texture[i]);CHECKGLERROR
 311                         if (gl_combine.integer)
 312                         {
 313                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);CHECKGLERROR
 314                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);CHECKGLERROR
 315                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);CHECKGLERROR
 316                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);CHECKGLERROR
 317                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_CONSTANT_ARB);CHECKGLERROR
 318                                 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);CHECKGLERROR
 319                                 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);CHECKGLERROR
 320                                 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);CHECKGLERROR
 321                                 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);CHECKGLERROR
 322                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);CHECKGLERROR
 323                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);CHECKGLERROR
 324                                 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_CONSTANT_ARB);CHECKGLERROR
 325                                 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
 326                                 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
 327                                 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
 328                                 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, gl_state.texturergbscale[i]);CHECKGLERROR
 329                                 qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1);CHECKGLERROR
 330                         }
 331                         else
 332                         {
 333                                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
 334                         }
 335                         if (gl_state.texture[i])
 336                         {
 337                                 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
 338                         }
 339                         else
 340                         {
 341                                 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
 342                         }
 343                         if (gl_mesh_drawmode.integer > 0)
 344                         {
 345                                 qglClientActiveTexture(GL_TEXTURE0_ARB + (gl_state.clientunit = i));CHECKGLERROR
 346                                 qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), varray_texcoord[i]);CHECKGLERROR
 347                                 if (gl_state.texture[i])
 348                                 {
 349                                         qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 350                                 }
 351                                 else
 352                                 {
 353                                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 354                                 }
 355                         }
 356                 }
 357         }
 358         else
 359         {
 360                 qglBindTexture(GL_TEXTURE_2D, gl_state.texture[0]);CHECKGLERROR
 361                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
 362                 if (gl_state.texture[0])
 363                 {
 364                         qglEnable(GL_TEXTURE_2D);CHECKGLERROR
 365                 }
 366                 else
 367                 {
 368                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
 369                 }
 370                 if (gl_mesh_drawmode.integer > 0)
 371                 {
 372                         qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), varray_texcoord[0]);CHECKGLERROR
 373                         if (gl_state.texture[0])
 374                         {
 375                                 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 376                         }
 377                         else
 378                         {
 379                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 380                         }
 381                 }
 382         }
 383 }
 384
 385 int usedarrays;
 386 void GL_Backend_ResetState(void)
 387 {
 388         int i;
 389         gl_state.unit = 0;
 390         gl_state.clientunit = 0;
 391
 392         for (i = 0;i < backendunits;i++)
 393         {
 394                 gl_state.texture[i] = 0;
 395                 gl_state.texturergbscale[i] = 1;
 396         }
 397
 398         qglEnable(GL_CULL_FACE);CHECKGLERROR
 399         qglCullFace(GL_FRONT);CHECKGLERROR
 400
 401         gl_state.depthdisable = false;
 402         qglEnable(GL_DEPTH_TEST);CHECKGLERROR
 403
 404         gl_state.blendfunc1 = GL_ONE;
 405         gl_state.blendfunc2 = GL_ZERO;
 406         qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
 407
 408         gl_state.blend = 0;
 409         qglDisable(GL_BLEND);CHECKGLERROR
 410
 411         gl_state.depthmask = GL_TRUE;
 412         qglDepthMask(gl_state.depthmask);CHECKGLERROR
 413
 414         usedarrays = false;
 415         if (gl_mesh_drawmode.integer > 0)
 416         {
 417                 usedarrays = true;
 418                 qglVertexPointer(3, GL_FLOAT, sizeof(float[4]), varray_vertex);CHECKGLERROR
 419                 qglEnableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
 420                 if (gl_mesh_floatcolors.integer)
 421                 {
 422                         qglColorPointer(4, GL_FLOAT, sizeof(float[4]), varray_color);CHECKGLERROR
 423                 }
 424                 else
 425                 {
 426                         qglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(qbyte[4]), varray_bcolor);CHECKGLERROR
 427                 }
 428                 qglEnableClientState(GL_COLOR_ARRAY);CHECKGLERROR
 429         }
 430
 431         GL_SetupTextureState();
 432 }
 433
 434 // called at beginning of frame
 435 void R_Mesh_Start(float farclip)
 436 {
 437         BACKENDACTIVECHECK
 438
 439         CHECKGLERROR
 440
 441         r_mesh_farclip = farclip;
 442         viewdist = DotProduct(r_origin, vpn);
 443         vpnbit0 = vpn[0] < 0;
 444         vpnbit1 = vpn[1] < 0;
 445         vpnbit2 = vpn[2] < 0;
 446
 447         c_meshs = 0;
 448         c_meshtris = 0;
 449
 450         GL_Backend_CheckCvars();
 451         if (mesh_maxverts != gl_mesh_maxverts.integer)
 452                 GL_Backend_ResizeArrays(gl_mesh_maxverts.integer);
 453
 454         GL_SetupFrame();
 455
 456         GL_Backend_ResetState();
 457 }
 458
 459 int gl_backend_rebindtextures;
 460
 461 void GL_ConvertColorsFloatToByte(int numverts)
 462 {
 463         int i, k, total;
 464         // LordHavoc: to avoid problems with aliasing (treating memory as two
 465         // different types - exactly what this is doing), these must be volatile
 466         // (or a union)
 467         volatile int *icolor;
 468         volatile float *fcolor;
 469         qbyte *bcolor;
 470
 471         total = numverts * 4;
 472
 473         // shift float to have 8bit fraction at base of number
 474         fcolor = varray_color;
 475         for (i = 0;i < total;)
 476         {
 477                 fcolor[i    ] += 32768.0f;
 478                 fcolor[i + 1] += 32768.0f;
 479                 fcolor[i + 2] += 32768.0f;
 480                 fcolor[i + 3] += 32768.0f;
 481                 i += 4;
 482         }
 483
 484         // then read as integer and kill float bits...
 485         icolor = (int *)varray_color;
 486         bcolor = varray_bcolor;
 487         for (i = 0;i < total;)
 488         {
 489                 k = icolor[i    ] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i    ] = (qbyte) k;
 490                 k = icolor[i + 1] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i + 1] = (qbyte) k;
 491                 k = icolor[i + 2] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i + 2] = (qbyte) k;
 492                 k = icolor[i + 3] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i + 3] = (qbyte) k;
 493                 i += 4;
 494         }
 495 }
 496
 497 /*
 498 void GL_TransformVertices(int numverts)
 499 {
 500         int i;
 501         float m[12], tempv[4], *v;
 502         m[0] = backendmatrix.m[0][0];
 503         m[1] = backendmatrix.m[0][1];
 504         m[2] = backendmatrix.m[0][2];
 505         m[3] = backendmatrix.m[0][3];
 506         m[4] = backendmatrix.m[1][0];
 507         m[5] = backendmatrix.m[1][1];
 508         m[6] = backendmatrix.m[1][2];
 509         m[7] = backendmatrix.m[1][3];
 510         m[8] = backendmatrix.m[2][0];
 511         m[9] = backendmatrix.m[2][1];
 512         m[10] = backendmatrix.m[2][2];
 513         m[11] = backendmatrix.m[2][3];
 514         for (i = 0, v = varray_vertex;i < numverts;i++, v += 4)
 515         {
 516                 VectorCopy(v, tempv);
 517                 v[0] = tempv[0] * m[0] + tempv[1] * m[1] + tempv[2] * m[2] + m[3];
 518                 v[1] = tempv[0] * m[4] + tempv[1] * m[5] + tempv[2] * m[6] + m[7];
 519                 v[2] = tempv[0] * m[8] + tempv[1] * m[9] + tempv[2] * m[10] + m[11];
 520         }
 521 }
 522 */
 523
 524 void GL_DrawRangeElements(int firstvert, int endvert, int indexcount, GLuint *index)
 525 {
 526         unsigned int i, j, in;
 527         qbyte *c;
 528         float *v;
 529         int arraylocked = false;
 530         if (gl_supportslockarrays && gl_lockarrays.integer && gl_mesh_drawmode.integer > 0)
 531         {
 532                 qglLockArraysEXT(firstvert, endvert - firstvert);
 533                 CHECKGLERROR
 534                 arraylocked = true;
 535         }
 536         if (gl_mesh_drawmode.integer >= 3/* && (endvert - firstvert) <= gl_maxdrawrangeelementsvertices && (indexcount) <= gl_maxdrawrangeelementsindices*/)
 537         {
 538                 // GL 1.2 or GL 1.1 with extension
 539                 qglDrawRangeElements(GL_TRIANGLES, firstvert, endvert, indexcount, GL_UNSIGNED_INT, index);
 540                 CHECKGLERROR
 541         }
 542         else if (gl_mesh_drawmode.integer >= 2)
 543         {
 544                 // GL 1.1
 545                 qglDrawElements(GL_TRIANGLES, indexcount, GL_UNSIGNED_INT, index);
 546                 CHECKGLERROR
 547         }
 548         else if (gl_mesh_drawmode.integer >= 1)
 549         {
 550                 // GL 1.1
 551                 // feed it manually using glArrayElement
 552                 qglBegin(GL_TRIANGLES);
 553                 for (i = 0;i < indexcount;i++)
 554                         qglArrayElement(index[i]);
 555                 qglEnd();
 556                 CHECKGLERROR
 557         }
 558         else
 559         {
 560                 // GL 1.1 but not using vertex arrays - 3dfx glquake minigl driver
 561                 // feed it manually
 562                 qglBegin(GL_TRIANGLES);
 563                 if (gl_state.texture[1]) // if the mesh uses multiple textures
 564                 {
 565                         // the minigl doesn't have this (because it does not have ARB_multitexture)
 566                         for (i = 0;i < indexcount;i++)
 567                         {
 568                                 in = index[i];
 569                                 c = varray_bcolor + in * 4;
 570                                 qglColor4ub(c[0], c[1], c[2], c[3]);
 571                                 for (j = 0;j < backendunits;j++)
 572                                 {
 573                                         if (gl_state.texture[j])
 574                                         {
 575                                                 v = varray_texcoord[j] + in * 2;
 576                                                 qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, v[0], v[1]);
 577                                         }
 578                                 }
 579                                 v = varray_vertex + in * 4;
 580                                 qglVertex3f(v[0], v[1], v[2]);
 581                         }
 582                 }
 583                 else
 584                 {
 585                         for (i = 0;i < indexcount;i++)
 586                         {
 587                                 in = index[i];
 588                                 c = varray_bcolor + in * 4;
 589                                 qglColor4ub(c[0], c[1], c[2], c[3]);
 590                                 if (gl_state.texture[0])
 591                                 {
 592                                         v = varray_texcoord[0] + in * 2;
 593                                         qglTexCoord2f(v[0], v[1]);
 594                                 }
 595                                 v = varray_vertex + in * 4;
 596                                 qglVertex3f(v[0], v[1], v[2]);
 597                         }
 598                 }
 599                 qglEnd();
 600                 CHECKGLERROR
 601         }
 602         if (arraylocked)
 603         {
 604                 qglUnlockArraysEXT();
 605                 CHECKGLERROR
 606                 arraylocked = false;
 607         }
 608 }
 609
 610 // enlarges geometry buffers if they are too small
 611 void _R_Mesh_ResizeCheck(int numverts)
 612 {
 613         if (numverts > mesh_maxverts)
 614         {
 615                 BACKENDACTIVECHECK
 616                 GL_Backend_ResizeArrays(numverts + 100);
 617                 GL_Backend_ResetState();
 618         }
 619 }
 620
 621 // renders the mesh
 622 void R_Mesh_Draw(int numverts, int numtriangles, int *elements)
 623 {
 624         BACKENDACTIVECHECK
 625
 626         c_meshs++;
 627         c_meshtris += numtriangles;
 628
 629         CHECKGLERROR
 630
 631         // drawmode 0 always uses byte colors
 632         if (!gl_mesh_floatcolors.integer || gl_mesh_drawmode.integer <= 0)
 633                 GL_ConvertColorsFloatToByte(numverts);
 634         //GL_TransformVertices(numverts);
 635         if (!r_render.integer)
 636                 return;
 637         GL_DrawRangeElements(0, numverts, numtriangles * 3, elements);
 638 }
 639
 640 // restores backend state, used when done with 3D rendering
 641 void R_Mesh_Finish(void)
 642 {
 643         int i;
 644         BACKENDACTIVECHECK
 645
 646         if (backendunits > 1)
 647         {
 648                 for (i = backendunits - 1;i >= 0;i--)
 649                 {
 650                         qglActiveTexture(GL_TEXTURE0_ARB + i);CHECKGLERROR
 651                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
 652                         if (gl_combine.integer)
 653                         {
 654                                 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1);CHECKGLERROR
 655                         }
 656                         if (i > 0)
 657                         {
 658                                 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
 659                         }
 660                         else
 661                         {
 662                                 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
 663                         }
 664                         qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
 665
 666                         if (usedarrays)
 667                         {
 668                                 qglClientActiveTexture(GL_TEXTURE0_ARB + i);CHECKGLERROR
 669                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 670                         }
 671                 }
 672         }
 673         else
 674         {
 675                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
 676                 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
 677                 if (usedarrays)
 678                 {
 679                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 680                 }
 681         }
 682         if (usedarrays)
 683         {
 684                 qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
 685                 qglDisableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
 686         }
 687
 688         qglDisable(GL_BLEND);CHECKGLERROR
 689         qglEnable(GL_DEPTH_TEST);CHECKGLERROR
 690         qglDepthMask(GL_TRUE);CHECKGLERROR
 691         qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);CHECKGLERROR
 692 }
 693
 694 void R_Mesh_ClearDepth(void)
 695 {
 696         BACKENDACTIVECHECK
 697
 698         R_Mesh_Finish();
 699         qglClear(GL_DEPTH_BUFFER_BIT);
 700         R_Mesh_Start(r_mesh_farclip);
 701 }
 702
 703 void R_Mesh_Matrix(const matrix4x4_t *matrix)
 704 {
 705         if (memcmp(matrix, &backend_modelmatrix, sizeof(matrix4x4_t)))
 706         {
 707                 backend_modelmatrix = *matrix;
 708                 Matrix4x4_Concat(&backend_modelviewmatrix, &backend_viewmatrix, matrix);
 709                 Matrix4x4_Transpose(&backend_glmodelviewmatrix, &backend_modelviewmatrix);
 710                 qglLoadMatrixf(&backend_glmodelviewmatrix.m[0][0]);
 711         }
 712 }
 713
 714 // sets up the requested state
 715 void R_Mesh_State(const rmeshstate_t *m)
 716 {
 717         int i, overbright;
 718         int texturergbscale[MAX_TEXTUREUNITS];
 719         float scaler;
 720
 721         BACKENDACTIVECHECK
 722
 723         if (gl_backend_rebindtextures)
 724         {
 725                 gl_backend_rebindtextures = false;
 726                 GL_SetupTextureState();
 727         }
 728
 729         overbright = false;
 730         scaler = 1;
 731         if (m->blendfunc1 == GL_DST_COLOR)
 732         {
 733                 // check if it is a 2x modulate with framebuffer
 734                 if (m->blendfunc2 == GL_SRC_COLOR)
 735                         scaler *= 0.5f;
 736         }
 737         else if (m->blendfunc2 != GL_SRC_COLOR)
 738         {
 739                 if (m->tex[0])
 740                 {
 741                         overbright = m->wantoverbright && gl_combine.integer;
 742                         if (overbright)
 743                                 scaler *= 0.25f;
 744                 }
 745                 scaler *= overbrightscale;
 746         }
 747         mesh_colorscale = scaler;
 748
 749         if (gl_state.blendfunc1 != m->blendfunc1 || gl_state.blendfunc2 != m->blendfunc2)
 750         {
 751                 qglBlendFunc(gl_state.blendfunc1 = m->blendfunc1, gl_state.blendfunc2 = m->blendfunc2);CHECKGLERROR
 752                 if (gl_state.blendfunc2 == GL_ZERO)
 753                 {
 754                         if (gl_state.blendfunc1 == GL_ONE)
 755                         {
 756                                 if (gl_state.blend)
 757                                 {
 758                                         gl_state.blend = 0;
 759                                         qglDisable(GL_BLEND);CHECKGLERROR
 760                                 }
 761                         }
 762                         else
 763                         {
 764                                 if (!gl_state.blend)
 765                                 {
 766                                         gl_state.blend = 1;
 767                                         qglEnable(GL_BLEND);CHECKGLERROR
 768                                 }
 769                         }
 770                 }
 771                 else
 772                 {
 773                         if (!gl_state.blend)
 774                         {
 775                                 gl_state.blend = 1;
 776                                 qglEnable(GL_BLEND);CHECKGLERROR
 777                         }
 778                 }
 779         }
 780         if (gl_state.depthdisable != m->depthdisable)
 781         {
 782                 gl_state.depthdisable = m->depthdisable;
 783                 if (gl_state.depthdisable)
 784                         qglDisable(GL_DEPTH_TEST);
 785                 else
 786                         qglEnable(GL_DEPTH_TEST);
 787         }
 788         if (gl_state.depthmask != (m->blendfunc2 == GL_ZERO || m->depthwrite))
 789         {
 790                 qglDepthMask(gl_state.depthmask = (m->blendfunc2 == GL_ZERO || m->depthwrite));CHECKGLERROR
 791         }
 792
 793         for (i = 0;i < backendunits;i++)
 794         {
 795                 if (m->texrgbscale[i])
 796                         texturergbscale[i] = m->texrgbscale[i];
 797                 else
 798                         texturergbscale[i] = 1;
 799         }
 800         if (overbright)
 801         {
 802                 for (i = backendunits - 1;i >= 0;i--)
 803                 {
 804                         if (m->tex[i])
 805                         {
 806                                 texturergbscale[i] = 4;
 807                                 break;
 808                         }
 809                 }
 810         }
 811
 812         if (backendunits > 1)
 813         {
 814                 for (i = 0;i < backendunits;i++)
 815                 {
 816                         if (gl_state.texture[i] != m->tex[i])
 817                         {
 818                                 if (gl_state.unit != i)
 819                                 {
 820                                         qglActiveTexture(GL_TEXTURE0_ARB + (gl_state.unit = i));CHECKGLERROR
 821                                 }
 822                                 if (gl_state.texture[i] == 0)
 823                                 {
 824                                         qglEnable(GL_TEXTURE_2D);CHECKGLERROR
 825                                         if (gl_state.clientunit != i)
 826                                         {
 827                                                 qglClientActiveTexture(GL_TEXTURE0_ARB + (gl_state.clientunit = i));CHECKGLERROR
 828                                         }
 829                                         qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 830                                 }
 831                                 qglBindTexture(GL_TEXTURE_2D, (gl_state.texture[i] = m->tex[i]));CHECKGLERROR
 832                                 if (gl_state.texture[i] == 0)
 833                                 {
 834                                         qglDisable(GL_TEXTURE_2D);CHECKGLERROR
 835                                         if (gl_state.clientunit != i)
 836                                         {
 837                                                 qglClientActiveTexture(GL_TEXTURE0_ARB + (gl_state.clientunit = i));CHECKGLERROR
 838                                         }
 839                                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 840                                 }
 841                         }
 842                         if (gl_state.texturergbscale[i] != texturergbscale[i])
 843                         {
 844                                 if (gl_state.unit != i)
 845                                 {
 846                                         qglActiveTexture(GL_TEXTURE0_ARB + (gl_state.unit = i));CHECKGLERROR
 847                                 }
 848                                 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, (gl_state.texturergbscale[i] = texturergbscale[i]));CHECKGLERROR
 849                         }
 850                 }
 851         }
 852         else
 853         {
 854                 if (gl_state.texture[0] != m->tex[0])
 855                 {
 856                         if (gl_state.texture[0] == 0)
 857                         {
 858                                 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
 859                                 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 860                         }
 861                         qglBindTexture(GL_TEXTURE_2D, (gl_state.texture[0] = m->tex[0]));CHECKGLERROR
 862                         if (gl_state.texture[0] == 0)
 863                         {
 864                                 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
 865                                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
 866                         }
 867                 }
 868         }
 869 }
 870
 871 /*
 872 ==============================================================================
 873
 874                                                 SCREEN SHOTS
 875
 876 ==============================================================================
 877 */
 878
 879 qboolean SCR_ScreenShot(char *filename, int x, int y, int width, int height)
 880 {
 881         qboolean ret;
 882         int i;
 883         qbyte *buffer;
 884
 885         if (!r_render.integer)
 886                 return false;
 887
 888         buffer = Mem_Alloc(tempmempool, width*height*3);
 889         qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);
 890         CHECKGLERROR
 891
 892         // LordHavoc: compensate for v_overbrightbits when using hardware gamma
 893         if (v_hwgamma.integer)
 894                 for (i = 0;i < width * height * 3;i++)
 895                         buffer[i] <<= v_overbrightbits.integer;
 896
 897         ret = Image_WriteTGARGB_preflipped(filename, width, height, buffer);
 898
 899         Mem_Free(buffer);
 900         return ret;
 901 }
 902
 903 //=============================================================================
 904
 905 void R_ClearScreen(void)
 906 {
 907         if (r_render.integer)
 908         {
 909                 // clear to black
 910                 qglClearColor(0,0,0,0);CHECKGLERROR
 911                 // clear the screen
 912                 qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);CHECKGLERROR
 913                 // set dithering mode
 914                 if (gl_dither.integer)
 915                 {
 916                         qglEnable(GL_DITHER);CHECKGLERROR
 917                 }
 918                 else
 919                 {
 920                         qglDisable(GL_DITHER);CHECKGLERROR
 921                 }
 922         }
 923 }
 924
 925 /*
 926 ==================
 927 SCR_UpdateScreen
 928
 929 This is called every frame, and can also be called explicitly to flush
 930 text to the screen.
 931 ==================
 932 */
 933 void SCR_UpdateScreen (void)
 934 {
 935         VID_Finish ();
 936
 937         R_TimeReport("finish");
 938
 939         if (r_textureunits.integer > gl_textureunits)
 940                 Cvar_SetValueQuick(&r_textureunits, gl_textureunits);
 941         if (r_textureunits.integer < 1)
 942                 Cvar_SetValueQuick(&r_textureunits, 1);
 943
 944         if (gl_combine.integer && (!gl_combine_extension || r_textureunits.integer < 2))
 945                 Cvar_SetValueQuick(&gl_combine, 0);
 946
 947         // lighting scale
 948         overbrightscale = 1.0f / (float) (1 << v_overbrightbits.integer);
 949
 950         // lightmaps only
 951         lightscalebit = v_overbrightbits.integer;
 952         if (gl_combine.integer && r_textureunits.integer > 1)
 953                 lightscalebit += 2;
 954         lightscale = 1.0f / (float) (1 << lightscalebit);
 955
 956         R_TimeReport("setup");
 957
 958         R_ClearScreen();
 959
 960         R_TimeReport("clear");
 961
 962         if (scr_conlines < vid.conheight && cls.signon == SIGNONS)
 963                 R_RenderView();
 964
 965         // draw 2D stuff
 966         R_DrawQueue();
 967
 968         // tell driver to commit it's partially full geometry queue to the rendering queue
 969         // (this doesn't wait for the commands themselves to complete)
 970         qglFlush();
 971 }
 972