renamed varray_ arrays to rsurface_array_, and they are no longer used outside the...
[xonotic/darkplaces.git] / 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_paranoid = {0, "gl_paranoid", "0", "enables OpenGL error checking and other tests"};
9 cvar_t gl_printcheckerror = {0, "gl_printcheckerror", "0", "prints all OpenGL error checks, useful to identify location of driver crashes"};
10
11 cvar_t r_render = {0, "r_render", "1", "enables rendering calls (you want this on!)"};
12 cvar_t r_waterwarp = {CVAR_SAVE, "r_waterwarp", "1", "warp view while underwater"};
13 cvar_t gl_polyblend = {CVAR_SAVE, "gl_polyblend", "1", "tints view while underwater, hurt, etc"};
14 cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1", "enables OpenGL dithering (16bit looks bad with this off)"};
15 cvar_t gl_lockarrays = {0, "gl_lockarrays", "1", "enables use of glLockArraysEXT, may cause glitches with some broken drivers"};
16
17 int gl_maxdrawrangeelementsvertices;
18 int gl_maxdrawrangeelementsindices;
19
20 #ifdef DEBUGGL
21 int errornumber = 0;
22
23 void GL_PrintError(int errornumber, char *filename, int linenumber)
24 {
25         switch(errornumber)
26         {
27 #ifdef GL_INVALID_ENUM
28         case GL_INVALID_ENUM:
29                 Con_Printf("GL_INVALID_ENUM at %s:%i\n", filename, linenumber);
30                 break;
31 #endif
32 #ifdef GL_INVALID_VALUE
33         case GL_INVALID_VALUE:
34                 Con_Printf("GL_INVALID_VALUE at %s:%i\n", filename, linenumber);
35                 break;
36 #endif
37 #ifdef GL_INVALID_OPERATION
38         case GL_INVALID_OPERATION:
39                 Con_Printf("GL_INVALID_OPERATION at %s:%i\n", filename, linenumber);
40                 break;
41 #endif
42 #ifdef GL_STACK_OVERFLOW
43         case GL_STACK_OVERFLOW:
44                 Con_Printf("GL_STACK_OVERFLOW at %s:%i\n", filename, linenumber);
45                 break;
46 #endif
47 #ifdef GL_STACK_UNDERFLOW
48         case GL_STACK_UNDERFLOW:
49                 Con_Printf("GL_STACK_UNDERFLOW at %s:%i\n", filename, linenumber);
50                 break;
51 #endif
52 #ifdef GL_OUT_OF_MEMORY
53         case GL_OUT_OF_MEMORY:
54                 Con_Printf("GL_OUT_OF_MEMORY at %s:%i\n", filename, linenumber);
55                 break;
56 #endif
57 #ifdef GL_TABLE_TOO_LARGE
58         case GL_TABLE_TOO_LARGE:
59                 Con_Printf("GL_TABLE_TOO_LARGE at %s:%i\n", filename, linenumber);
60                 break;
61 #endif
62         default:
63                 Con_Printf("GL UNKNOWN (%i) at %s:%i\n", errornumber, filename, linenumber);
64                 break;
65         }
66 }
67 #endif
68
69 #define BACKENDACTIVECHECK if (!backendactive) Sys_Error("GL backend function called when backend is not active");
70
71 void SCR_ScreenShot_f (void);
72
73 static matrix4x4_t backend_viewmatrix;
74 static matrix4x4_t backend_modelmatrix;
75 static matrix4x4_t backend_modelviewmatrix;
76 static matrix4x4_t backend_glmodelviewmatrix;
77 static matrix4x4_t backend_projectmatrix;
78
79 static unsigned int backendunits, backendimageunits, backendarrayunits, backendactive;
80
81 /*
82 note: here's strip order for a terrain row:
83 0--1--2--3--4
84 |\ |\ |\ |\ |
85 | \| \| \| \|
86 A--B--C--D--E
87 clockwise
88
89 A0B, 01B, B1C, 12C, C2D, 23D, D3E, 34E
90
91 *elements++ = i + row;
92 *elements++ = i;
93 *elements++ = i + row + 1;
94 *elements++ = i;
95 *elements++ = i + 1;
96 *elements++ = i + row + 1;
97
98
99 for (y = 0;y < rows - 1;y++)
100 {
101         for (x = 0;x < columns - 1;x++)
102         {
103                 i = y * rows + x;
104                 *elements++ = i + columns;
105                 *elements++ = i;
106                 *elements++ = i + columns + 1;
107                 *elements++ = i;
108                 *elements++ = i + 1;
109                 *elements++ = i + columns + 1;
110         }
111 }
112
113 alternative:
114 0--1--2--3--4
115 | /| /|\ | /|
116 |/ |/ | \|/ |
117 A--B--C--D--E
118 counterclockwise
119
120 for (y = 0;y < rows - 1;y++)
121 {
122         for (x = 0;x < columns - 1;x++)
123         {
124                 i = y * rows + x;
125                 *elements++ = i;
126                 *elements++ = i + columns;
127                 *elements++ = i + columns + 1;
128                 *elements++ = i + columns;
129                 *elements++ = i + columns + 1;
130                 *elements++ = i + 1;
131         }
132 }
133 */
134
135 int polygonelements[(POLYGONELEMENTS_MAXPOINTS-2)*3];
136 int quadelements[QUADELEMENTS_MAXQUADS*6];
137
138 void GL_Backend_AllocArrays(void)
139 {
140 }
141
142 void GL_Backend_FreeArrays(void)
143 {
144 }
145
146 static void gl_backend_start(void)
147 {
148         Con_Print("OpenGL Backend starting...\n");
149         CHECKGLERROR
150
151         if (qglDrawRangeElements != NULL)
152         {
153                 CHECKGLERROR
154                 qglGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &gl_maxdrawrangeelementsvertices);
155                 CHECKGLERROR
156                 qglGetIntegerv(GL_MAX_ELEMENTS_INDICES, &gl_maxdrawrangeelementsindices);
157                 CHECKGLERROR
158                 Con_Printf("glDrawRangeElements detected (max vertices %i, max indices %i)\n", gl_maxdrawrangeelementsvertices, gl_maxdrawrangeelementsindices);
159         }
160
161         backendunits = min(MAX_TEXTUREUNITS, gl_textureunits);
162         backendimageunits = backendunits;
163         backendarrayunits = backendunits;
164         if (gl_support_fragment_shader)
165         {
166                 CHECKGLERROR
167                 qglGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, (int *)&backendimageunits);
168                 CHECKGLERROR
169                 qglGetIntegerv(GL_MAX_TEXTURE_COORDS_ARB, (int *)&backendarrayunits);
170                 CHECKGLERROR
171                 Con_Printf("GLSL shader support detected: texture units = %i texenv, %i image, %i array\n", backendunits, backendimageunits, backendarrayunits);
172         }
173         else if (backendunits > 1)
174                 Con_Printf("multitexture detected: texture units = %i\n", backendunits);
175         else
176                 Con_Printf("singletexture\n");
177
178         GL_Backend_AllocArrays();
179
180         Con_Printf("OpenGL backend started.\n");
181
182         CHECKGLERROR
183
184         backendactive = true;
185 }
186
187 static void gl_backend_shutdown(void)
188 {
189         backendunits = 0;
190         backendimageunits = 0;
191         backendarrayunits = 0;
192         backendactive = false;
193
194         Con_Print("OpenGL Backend shutting down\n");
195
196         GL_Backend_FreeArrays();
197 }
198
199 static void gl_backend_newmap(void)
200 {
201 }
202
203 void gl_backend_init(void)
204 {
205         int i;
206
207         for (i = 0;i < POLYGONELEMENTS_MAXPOINTS - 2;i++)
208         {
209                 polygonelements[i * 3 + 0] = 0;
210                 polygonelements[i * 3 + 1] = i + 1;
211                 polygonelements[i * 3 + 2] = i + 2;
212         }
213         // elements for rendering a series of quads as triangles
214         for (i = 0;i < QUADELEMENTS_MAXQUADS;i++)
215         {
216                 quadelements[i * 6 + 0] = i * 4;
217                 quadelements[i * 6 + 1] = i * 4 + 1;
218                 quadelements[i * 6 + 2] = i * 4 + 2;
219                 quadelements[i * 6 + 3] = i * 4;
220                 quadelements[i * 6 + 4] = i * 4 + 2;
221                 quadelements[i * 6 + 5] = i * 4 + 3;
222         }
223
224         Cvar_RegisterVariable(&r_render);
225         Cvar_RegisterVariable(&r_waterwarp);
226         Cvar_RegisterVariable(&gl_polyblend);
227         Cvar_RegisterVariable(&gl_dither);
228         Cvar_RegisterVariable(&gl_lockarrays);
229         Cvar_RegisterVariable(&gl_paranoid);
230         Cvar_RegisterVariable(&gl_printcheckerror);
231 #ifdef NORENDER
232         Cvar_SetValue("r_render", 0);
233 #endif
234
235         Cvar_RegisterVariable(&gl_mesh_drawrangeelements);
236         Cvar_RegisterVariable(&gl_mesh_testarrayelement);
237         Cvar_RegisterVariable(&gl_mesh_testmanualfeeding);
238
239         R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap);
240 }
241
242 void GL_SetupView_Orientation_Identity (void)
243 {
244         backend_viewmatrix = identitymatrix;
245         memset(&backend_modelmatrix, 0, sizeof(backend_modelmatrix));
246 }
247
248 void GL_SetupView_Orientation_FromEntity(matrix4x4_t *matrix)
249 {
250         matrix4x4_t tempmatrix, basematrix;
251         Matrix4x4_Invert_Simple(&tempmatrix, matrix);
252         Matrix4x4_CreateRotate(&basematrix, -90, 1, 0, 0);
253         Matrix4x4_ConcatRotate(&basematrix, 90, 0, 0, 1);
254         Matrix4x4_Concat(&backend_viewmatrix, &basematrix, &tempmatrix);
255         //Matrix4x4_ConcatRotate(&backend_viewmatrix, -angles[2], 1, 0, 0);
256         //Matrix4x4_ConcatRotate(&backend_viewmatrix, -angles[0], 0, 1, 0);
257         //Matrix4x4_ConcatRotate(&backend_viewmatrix, -angles[1], 0, 0, 1);
258         //Matrix4x4_ConcatTranslate(&backend_viewmatrix, -origin[0], -origin[1], -origin[2]);
259         memset(&backend_modelmatrix, 0, sizeof(backend_modelmatrix));
260 }
261
262 void GL_SetupView_Mode_Perspective (double frustumx, double frustumy, double zNear, double zFar)
263 {
264         double m[16];
265
266         if (!r_render.integer)
267                 return;
268
269         // set up viewpoint
270         qglMatrixMode(GL_PROJECTION);CHECKGLERROR
271         qglLoadIdentity();CHECKGLERROR
272         // set view pyramid
273         qglFrustum(-frustumx * zNear, frustumx * zNear, -frustumy * zNear, frustumy * zNear, zNear, zFar);CHECKGLERROR
274         qglGetDoublev(GL_PROJECTION_MATRIX, m);
275         backend_projectmatrix.m[0][0] = m[0];
276         backend_projectmatrix.m[1][0] = m[1];
277         backend_projectmatrix.m[2][0] = m[2];
278         backend_projectmatrix.m[3][0] = m[3];
279         backend_projectmatrix.m[0][1] = m[4];
280         backend_projectmatrix.m[1][1] = m[5];
281         backend_projectmatrix.m[2][1] = m[6];
282         backend_projectmatrix.m[3][1] = m[7];
283         backend_projectmatrix.m[0][2] = m[8];
284         backend_projectmatrix.m[1][2] = m[9];
285         backend_projectmatrix.m[2][2] = m[10];
286         backend_projectmatrix.m[3][2] = m[11];
287         backend_projectmatrix.m[0][3] = m[12];
288         backend_projectmatrix.m[1][3] = m[13];
289         backend_projectmatrix.m[2][3] = m[14];
290         backend_projectmatrix.m[3][3] = m[15];
291         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
292         GL_SetupView_Orientation_Identity();
293 }
294
295 void GL_SetupView_Mode_PerspectiveInfiniteFarClip (double frustumx, double frustumy, double zNear)
296 {
297         double nudge, m[16];
298
299         if (!r_render.integer)
300                 return;
301
302         // set up viewpoint
303         qglMatrixMode(GL_PROJECTION);CHECKGLERROR
304         qglLoadIdentity();CHECKGLERROR
305         // set view pyramid
306         nudge = 1.0 - 1.0 / (1<<23);
307         m[ 0] = 1.0 / frustumx;
308         m[ 1] = 0;
309         m[ 2] = 0;
310         m[ 3] = 0;
311         m[ 4] = 0;
312         m[ 5] = 1.0 / frustumy;
313         m[ 6] = 0;
314         m[ 7] = 0;
315         m[ 8] = 0;
316         m[ 9] = 0;
317         m[10] = -nudge;
318         m[11] = -1;
319         m[12] = 0;
320         m[13] = 0;
321         m[14] = -2 * zNear * nudge;
322         m[15] = 0;
323         qglLoadMatrixd(m);
324         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
325         GL_SetupView_Orientation_Identity();
326         backend_projectmatrix.m[0][0] = m[0];
327         backend_projectmatrix.m[1][0] = m[1];
328         backend_projectmatrix.m[2][0] = m[2];
329         backend_projectmatrix.m[3][0] = m[3];
330         backend_projectmatrix.m[0][1] = m[4];
331         backend_projectmatrix.m[1][1] = m[5];
332         backend_projectmatrix.m[2][1] = m[6];
333         backend_projectmatrix.m[3][1] = m[7];
334         backend_projectmatrix.m[0][2] = m[8];
335         backend_projectmatrix.m[1][2] = m[9];
336         backend_projectmatrix.m[2][2] = m[10];
337         backend_projectmatrix.m[3][2] = m[11];
338         backend_projectmatrix.m[0][3] = m[12];
339         backend_projectmatrix.m[1][3] = m[13];
340         backend_projectmatrix.m[2][3] = m[14];
341         backend_projectmatrix.m[3][3] = m[15];
342 }
343
344 void GL_SetupView_Mode_Ortho (double x1, double y1, double x2, double y2, double zNear, double zFar)
345 {
346         double m[16];
347
348         if (!r_render.integer)
349                 return;
350
351         // set up viewpoint
352         qglMatrixMode(GL_PROJECTION);CHECKGLERROR
353         qglLoadIdentity();CHECKGLERROR
354         qglOrtho(x1, x2, y2, y1, zNear, zFar);
355         qglGetDoublev(GL_PROJECTION_MATRIX, m);
356         backend_projectmatrix.m[0][0] = m[0];
357         backend_projectmatrix.m[1][0] = m[1];
358         backend_projectmatrix.m[2][0] = m[2];
359         backend_projectmatrix.m[3][0] = m[3];
360         backend_projectmatrix.m[0][1] = m[4];
361         backend_projectmatrix.m[1][1] = m[5];
362         backend_projectmatrix.m[2][1] = m[6];
363         backend_projectmatrix.m[3][1] = m[7];
364         backend_projectmatrix.m[0][2] = m[8];
365         backend_projectmatrix.m[1][2] = m[9];
366         backend_projectmatrix.m[2][2] = m[10];
367         backend_projectmatrix.m[3][2] = m[11];
368         backend_projectmatrix.m[0][3] = m[12];
369         backend_projectmatrix.m[1][3] = m[13];
370         backend_projectmatrix.m[2][3] = m[14];
371         backend_projectmatrix.m[3][3] = m[15];
372         qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
373         GL_SetupView_Orientation_Identity();
374 }
375
376 typedef struct gltextureunit_s
377 {
378         int t1d, t2d, t3d, tcubemap;
379         int arrayenabled;
380         unsigned int arraycomponents;
381         const void *pointer_texcoord;
382         float rgbscale, alphascale;
383         int combinergb, combinealpha;
384         // FIXME: add more combine stuff
385         // texmatrixenabled exists only to avoid unnecessary texmatrix compares
386         int texmatrixenabled;
387         matrix4x4_t matrix;
388 }
389 gltextureunit_t;
390
391 static struct gl_state_s
392 {
393         int blendfunc1;
394         int blendfunc2;
395         int blend;
396         GLboolean depthmask;
397         int colormask; // stored as bottom 4 bits: r g b a (3 2 1 0 order)
398         int depthtest;
399         int scissortest;
400         unsigned int unit;
401         unsigned int clientunit;
402         gltextureunit_t units[MAX_TEXTUREUNITS];
403         float color4f[4];
404         int lockrange_first;
405         int lockrange_count;
406         const void *pointer_vertex;
407         const void *pointer_color;
408 }
409 gl_state;
410
411 void GL_SetupTextureState(void)
412 {
413         unsigned int i;
414         gltextureunit_t *unit;
415         CHECKGLERROR
416         gl_state.unit = MAX_TEXTUREUNITS;
417         gl_state.clientunit = MAX_TEXTUREUNITS;
418         for (i = 0;i < MAX_TEXTUREUNITS;i++)
419         {
420                 unit = gl_state.units + i;
421                 unit->t1d = 0;
422                 unit->t2d = 0;
423                 unit->t3d = 0;
424                 unit->tcubemap = 0;
425                 unit->arrayenabled = false;
426                 unit->arraycomponents = 0;
427                 unit->pointer_texcoord = NULL;
428                 unit->rgbscale = 1;
429                 unit->alphascale = 1;
430                 unit->combinergb = GL_MODULATE;
431                 unit->combinealpha = GL_MODULATE;
432                 unit->texmatrixenabled = false;
433                 unit->matrix = identitymatrix;
434         }
435
436         for (i = 0;i < backendimageunits;i++)
437         {
438                 GL_ActiveTexture(i);
439                 qglBindTexture(GL_TEXTURE_1D, 0);CHECKGLERROR
440                 qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
441                 if (gl_texture3d)
442                 {
443                         qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
444                 }
445                 if (gl_texturecubemap)
446                 {
447                         qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, 0);CHECKGLERROR
448                 }
449         }
450
451         for (i = 0;i < backendarrayunits;i++)
452         {
453                 GL_ClientActiveTexture(i);
454                 qglTexCoordPointer(2, GL_FLOAT, sizeof(float[2]), NULL);CHECKGLERROR
455                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
456         }
457
458         for (i = 0;i < backendunits;i++)
459         {
460                 GL_ActiveTexture(i);
461                 qglDisable(GL_TEXTURE_1D);CHECKGLERROR
462                 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
463                 if (gl_texture3d)
464                 {
465                         qglDisable(GL_TEXTURE_3D);CHECKGLERROR
466                 }
467                 if (gl_texturecubemap)
468                 {
469                         qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR
470                 }
471                 qglMatrixMode(GL_TEXTURE);
472                 qglLoadIdentity();
473                 qglMatrixMode(GL_MODELVIEW);
474                 if (gl_combine.integer)
475                 {
476                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);CHECKGLERROR
477                         qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);CHECKGLERROR
478                         qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);CHECKGLERROR
479                         qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);CHECKGLERROR
480                         qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE);CHECKGLERROR // for GL_INTERPOLATE_ARB mode
481                         qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);CHECKGLERROR
482                         qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);CHECKGLERROR
483                         qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);CHECKGLERROR
484                         qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);CHECKGLERROR
485                         qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);CHECKGLERROR
486                         qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);CHECKGLERROR
487                         qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_CONSTANT_ARB);CHECKGLERROR
488                         qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
489                         qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
490                         qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
491                         qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1);CHECKGLERROR
492                         qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1);CHECKGLERROR
493                 }
494                 else
495                 {
496                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
497                 }
498         }
499         CHECKGLERROR
500 }
501
502 void GL_Backend_ResetState(void)
503 {
504         memset(&gl_state, 0, sizeof(gl_state));
505         gl_state.depthtest = true;
506         gl_state.blendfunc1 = GL_ONE;
507         gl_state.blendfunc2 = GL_ZERO;
508         gl_state.blend = false;
509         gl_state.depthmask = GL_TRUE;
510         gl_state.colormask = 15;
511         gl_state.color4f[0] = gl_state.color4f[1] = gl_state.color4f[2] = gl_state.color4f[3] = 1;
512         gl_state.lockrange_first = 0;
513         gl_state.lockrange_count = 0;
514         gl_state.pointer_vertex = NULL;
515         gl_state.pointer_color = NULL;
516
517         CHECKGLERROR
518
519         qglColorMask(1, 1, 1, 1);
520         qglEnable(GL_CULL_FACE);CHECKGLERROR
521         qglCullFace(GL_FRONT);CHECKGLERROR
522         qglEnable(GL_DEPTH_TEST);CHECKGLERROR
523         qglBlendFunc(gl_state.blendfunc1, gl_state.blendfunc2);CHECKGLERROR
524         qglDisable(GL_BLEND);CHECKGLERROR
525         qglDepthMask(gl_state.depthmask);CHECKGLERROR
526
527         qglVertexPointer(3, GL_FLOAT, sizeof(float[3]), NULL);CHECKGLERROR
528         qglEnableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
529
530         qglColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL);CHECKGLERROR
531         qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
532
533         GL_Color(0, 0, 0, 0);
534         GL_Color(1, 1, 1, 1);
535
536         GL_SetupTextureState();
537 }
538
539 void GL_ActiveTexture(unsigned int num)
540 {
541         if (gl_state.unit != num)
542         {
543                 gl_state.unit = num;
544                 if (qglActiveTexture)
545                 {
546                         qglActiveTexture(GL_TEXTURE0_ARB + gl_state.unit);
547                         CHECKGLERROR
548                 }
549         }
550 }
551
552 void GL_ClientActiveTexture(unsigned int num)
553 {
554         if (gl_state.clientunit != num)
555         {
556                 gl_state.clientunit = num;
557                 if (qglActiveTexture)
558                 {
559                         qglClientActiveTexture(GL_TEXTURE0_ARB + gl_state.clientunit);
560                         CHECKGLERROR
561                 }
562         }
563 }
564
565 void GL_BlendFunc(int blendfunc1, int blendfunc2)
566 {
567         if (gl_state.blendfunc1 != blendfunc1 || gl_state.blendfunc2 != blendfunc2)
568         {
569                 if (r_showtrispass)
570                         return;
571                 qglBlendFunc(gl_state.blendfunc1 = blendfunc1, gl_state.blendfunc2 = blendfunc2);CHECKGLERROR
572                 if (gl_state.blendfunc2 == GL_ZERO)
573                 {
574                         if (gl_state.blendfunc1 == GL_ONE)
575                         {
576                                 if (gl_state.blend)
577                                 {
578                                         gl_state.blend = 0;
579                                         qglDisable(GL_BLEND);CHECKGLERROR
580                                 }
581                         }
582                         else
583                         {
584                                 if (!gl_state.blend)
585                                 {
586                                         gl_state.blend = 1;
587                                         qglEnable(GL_BLEND);CHECKGLERROR
588                                 }
589                         }
590                 }
591                 else
592                 {
593                         if (!gl_state.blend)
594                         {
595                                 gl_state.blend = 1;
596                                 qglEnable(GL_BLEND);CHECKGLERROR
597                         }
598                 }
599         }
600 }
601
602 void GL_DepthMask(int state)
603 {
604         if (gl_state.depthmask != state)
605         {
606                 if (r_showtrispass)
607                         return;
608                 qglDepthMask(gl_state.depthmask = state);CHECKGLERROR
609         }
610 }
611
612 void GL_DepthTest(int state)
613 {
614         if (gl_state.depthtest != state)
615         {
616                 if (r_showtrispass && r_showdisabledepthtest.integer)
617                         return;
618                 gl_state.depthtest = state;
619                 if (gl_state.depthtest)
620                 {
621                         qglEnable(GL_DEPTH_TEST);CHECKGLERROR
622                 }
623                 else
624                 {
625                         qglDisable(GL_DEPTH_TEST);CHECKGLERROR
626                 }
627         }
628 }
629
630 void GL_ColorMask(int r, int g, int b, int a)
631 {
632         int state = r*8 + g*4 + b*2 + a*1;
633         if (gl_state.colormask != state)
634         {
635                 gl_state.colormask = state;
636                 qglColorMask((GLboolean)r, (GLboolean)g, (GLboolean)b, (GLboolean)a);CHECKGLERROR
637         }
638 }
639
640 void GL_Color(float cr, float cg, float cb, float ca)
641 {
642         if (gl_state.pointer_color || gl_state.color4f[0] != cr || gl_state.color4f[1] != cg || gl_state.color4f[2] != cb || gl_state.color4f[3] != ca)
643         {
644                 if (r_showtrispass)
645                         return;
646                 gl_state.color4f[0] = cr;
647                 gl_state.color4f[1] = cg;
648                 gl_state.color4f[2] = cb;
649                 gl_state.color4f[3] = ca;
650                 CHECKGLERROR
651                 qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);
652                 CHECKGLERROR
653         }
654 }
655
656 void GL_ShowTrisColor(float cr, float cg, float cb, float ca)
657 {
658         if (!r_showtrispass)
659                 return;
660         r_showtrispass = 0;
661         GL_Color(cr * r_showtris.value, cg * r_showtris.value, cb * r_showtris.value, ca);
662         r_showtrispass = 1;
663 }
664
665
666 void GL_LockArrays(int first, int count)
667 {
668         if (gl_state.lockrange_count != count || gl_state.lockrange_first != first)
669         {
670                 if (gl_state.lockrange_count)
671                 {
672                         gl_state.lockrange_count = 0;
673                         CHECKGLERROR
674                         qglUnlockArraysEXT();
675                         CHECKGLERROR
676                 }
677                 if (count && gl_supportslockarrays && gl_lockarrays.integer && r_render.integer)
678                 {
679                         gl_state.lockrange_first = first;
680                         gl_state.lockrange_count = count;
681                         CHECKGLERROR
682                         qglLockArraysEXT(first, count);
683                         CHECKGLERROR
684                 }
685         }
686 }
687
688 void GL_Scissor (int x, int y, int width, int height)
689 {
690         CHECKGLERROR
691         qglScissor(x, vid.height - (y + height),width,height);
692         CHECKGLERROR
693 }
694
695 void GL_ScissorTest(int state)
696 {
697         if(gl_state.scissortest == state)
698                 return;
699
700         CHECKGLERROR
701         if((gl_state.scissortest = state))
702                 qglEnable(GL_SCISSOR_TEST);
703         else
704                 qglDisable(GL_SCISSOR_TEST);
705         CHECKGLERROR
706 }
707
708 void GL_Clear(int mask)
709 {
710         // in showtris rendering, don't clear the color buffer as that would hide
711         // the accumulated lines
712         if (r_showtrispass)
713                 mask &= ~GL_COLOR_BUFFER_BIT;
714         qglClear(mask);CHECKGLERROR
715 }
716
717 void GL_TransformToScreen(const vec4_t in, vec4_t out)
718 {
719         vec4_t temp;
720         float iw;
721         Matrix4x4_Transform4 (&backend_viewmatrix, in, temp);
722         Matrix4x4_Transform4 (&backend_projectmatrix, temp, out);
723         iw = 1.0f / out[3];
724         out[0] = r_view_x + (out[0] * iw + 1.0f) * r_view_width * 0.5f;
725         out[1] = r_view_y + (out[1] * iw + 1.0f) * r_view_height * 0.5f;
726         out[2] = r_view_z + (out[2] * iw + 1.0f) * r_view_depth * 0.5f;
727 }
728
729 // called at beginning of frame
730 void R_Mesh_Start(void)
731 {
732         BACKENDACTIVECHECK
733         CHECKGLERROR
734         GL_Backend_ResetState();
735 }
736
737 unsigned int GL_Backend_CompileProgram(int vertexstrings_count, const char **vertexstrings_list, int fragmentstrings_count, const char **fragmentstrings_list)
738 {
739         GLint vertexshadercompiled, fragmentshadercompiled, programlinked;
740         GLuint vertexshaderobject, fragmentshaderobject, programobject = 0;
741         char compilelog[MAX_INPUTLINE];
742         CHECKGLERROR
743
744         programobject = qglCreateProgramObjectARB();
745         CHECKGLERROR
746         if (!programobject)
747                 return 0;
748
749         if (vertexstrings_count)
750         {
751                 CHECKGLERROR
752                 vertexshaderobject = qglCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
753                 if (!vertexshaderobject)
754                 {
755                         qglDeleteObjectARB(programobject);
756                         CHECKGLERROR
757                         return 0;
758                 }
759                 qglShaderSourceARB(vertexshaderobject, vertexstrings_count, vertexstrings_list, NULL);
760                 qglCompileShaderARB(vertexshaderobject);
761                 CHECKGLERROR
762                 qglGetObjectParameterivARB(vertexshaderobject, GL_OBJECT_COMPILE_STATUS_ARB, &vertexshadercompiled);
763                 qglGetInfoLogARB(vertexshaderobject, sizeof(compilelog), NULL, compilelog);
764                 if (compilelog[0])
765                         Con_DPrintf("vertex shader compile log:\n%s\n", compilelog);
766                 if (!vertexshadercompiled)
767                 {
768                         qglDeleteObjectARB(programobject);
769                         qglDeleteObjectARB(vertexshaderobject);
770                         CHECKGLERROR
771                         return 0;
772                 }
773                 qglAttachObjectARB(programobject, vertexshaderobject);
774                 qglDeleteObjectARB(vertexshaderobject);
775                 CHECKGLERROR
776         }
777
778         if (fragmentstrings_count)
779         {
780                 CHECKGLERROR
781                 fragmentshaderobject = qglCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
782                 if (!fragmentshaderobject)
783                 {
784                         qglDeleteObjectARB(programobject);
785                         CHECKGLERROR
786                         return 0;
787                 }
788                 qglShaderSourceARB(fragmentshaderobject, fragmentstrings_count, fragmentstrings_list, NULL);
789                 qglCompileShaderARB(fragmentshaderobject);
790                 CHECKGLERROR
791                 qglGetObjectParameterivARB(fragmentshaderobject, GL_OBJECT_COMPILE_STATUS_ARB, &fragmentshadercompiled);
792                 qglGetInfoLogARB(fragmentshaderobject, sizeof(compilelog), NULL, compilelog);
793                 if (compilelog[0])
794                         Con_DPrintf("fragment shader compile log:\n%s\n", compilelog);
795                 if (!fragmentshadercompiled)
796                 {
797                         qglDeleteObjectARB(programobject);
798                         qglDeleteObjectARB(fragmentshaderobject);
799                         CHECKGLERROR
800                         return 0;
801                 }
802                 qglAttachObjectARB(programobject, fragmentshaderobject);
803                 qglDeleteObjectARB(fragmentshaderobject);
804                 CHECKGLERROR
805         }
806
807         qglLinkProgramARB(programobject);
808         CHECKGLERROR
809         qglGetObjectParameterivARB(programobject, GL_OBJECT_LINK_STATUS_ARB, &programlinked);
810         qglGetInfoLogARB(programobject, sizeof(compilelog), NULL, compilelog);
811         if (compilelog[0])
812         {
813                 Con_DPrintf("program link log:\n%s\n", compilelog);
814                 // software vertex shader is ok but software fragment shader is WAY
815                 // too slow, fail program if so.
816                 // NOTE: this string might be ATI specific, but that's ok because the
817                 // ATI R300 chip (Radeon 9500-9800/X300) is the most likely to use a
818                 // software fragment shader due to low instruction and dependent
819                 // texture limits.
820                 if (strstr(compilelog, "fragment shader will run in software"))
821                         programlinked = false;
822         }
823         CHECKGLERROR
824         if (!programlinked)
825         {
826                 qglDeleteObjectARB(programobject);
827                 return 0;
828         }
829         CHECKGLERROR
830         return programobject;
831 }
832
833 void GL_Backend_FreeProgram(unsigned int prog)
834 {
835         CHECKGLERROR
836         qglDeleteObjectARB(prog);
837         CHECKGLERROR
838 }
839
840 int gl_backend_rebindtextures;
841
842 void GL_Backend_RenumberElements(int *out, int count, const int *in, int offset)
843 {
844         int i;
845         if (offset)
846         {
847                 for (i = 0;i < count;i++)
848                         *out++ = *in++ + offset;
849         }
850         else
851                 memcpy(out, in, sizeof(*out) * count);
852 }
853
854 // renders triangles using vertices from the active arrays
855 int paranoidblah = 0;
856 void R_Mesh_Draw(int firstvertex, int numvertices, int numtriangles, const int *elements)
857 {
858         unsigned int numelements = numtriangles * 3;
859         if (numvertices < 3 || numtriangles < 1)
860         {
861                 Con_Printf("R_Mesh_Draw(%d, %d, %d, %08p);\n", firstvertex, numvertices, numtriangles, elements);
862                 return;
863         }
864         //CHECKGLERROR
865         if (r_showtrispass)
866         {
867                 R_Mesh_Draw_ShowTris(firstvertex, numvertices, numtriangles, elements);
868                 return;
869         }
870         renderstats.meshes++;
871         renderstats.meshes_elements += numelements;
872         if (gl_paranoid.integer)
873         {
874                 unsigned int i, j, size;
875                 const int *p;
876                 if (!qglIsEnabled(GL_VERTEX_ARRAY))
877                         Con_Print("R_Mesh_Draw: vertex array not enabled\n");
878                 for (j = 0, size = numvertices * 3, p = (int *)((float *)gl_state.pointer_vertex + firstvertex * 3);j < size;j++, p++)
879                         paranoidblah += *p;
880                 if (gl_state.pointer_color)
881                 {
882                         if (!qglIsEnabled(GL_COLOR_ARRAY))
883                                 Con_Print("R_Mesh_Draw: color array set but not enabled\n");
884                         for (j = 0, size = numvertices * 4, p = (int *)((float *)gl_state.pointer_color + firstvertex * 4);j < size;j++, p++)
885                                 paranoidblah += *p;
886                 }
887                 for (i = 0;i < backendarrayunits;i++)
888                 {
889                         if (gl_state.units[i].arrayenabled)
890                         {
891                                 GL_ClientActiveTexture(i);
892                                 if (!qglIsEnabled(GL_TEXTURE_COORD_ARRAY))
893                                         Con_Print("R_Mesh_Draw: texcoord array set but not enabled\n");
894                                 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++)
895                                         paranoidblah += *p;
896                         }
897                 }
898                 for (i = 0;i < (unsigned int) numtriangles * 3;i++)
899                 {
900                         if (elements[i] < firstvertex || elements[i] >= firstvertex + numvertices)
901                         {
902                                 Con_Printf("R_Mesh_Draw: invalid vertex index %i (outside range %i - %i) in elements list\n", elements[i], firstvertex, firstvertex + numvertices);
903                                 return;
904                         }
905                 }
906                 CHECKGLERROR
907         }
908         if (r_render.integer)
909         {
910                 CHECKGLERROR
911                 if (gl_mesh_testmanualfeeding.integer)
912                 {
913                         unsigned int i, j;
914                         const GLfloat *p;
915                         qglBegin(GL_TRIANGLES);
916                         for (i = 0;i < (unsigned int) numtriangles * 3;i++)
917                         {
918                                 for (j = 0;j < backendarrayunits;j++)
919                                 {
920                                         if (gl_state.units[j].pointer_texcoord)
921                                         {
922                                                 if (backendarrayunits > 1)
923                                                 {
924                                                         if (gl_state.units[j].arraycomponents == 4)
925                                                         {
926                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 4;
927                                                                 qglMultiTexCoord4f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2], p[3]);
928                                                         }
929                                                         else if (gl_state.units[j].arraycomponents == 3)
930                                                         {
931                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 3;
932                                                                 qglMultiTexCoord3f(GL_TEXTURE0_ARB + j, p[0], p[1], p[2]);
933                                                         }
934                                                         else if (gl_state.units[j].arraycomponents == 2)
935                                                         {
936                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 2;
937                                                                 qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, p[0], p[1]);
938                                                         }
939                                                         else
940                                                         {
941                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 1;
942                                                                 qglMultiTexCoord1f(GL_TEXTURE0_ARB + j, p[0]);
943                                                         }
944                                                 }
945                                                 else
946                                                 {
947                                                         if (gl_state.units[j].arraycomponents == 4)
948                                                         {
949                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 4;
950                                                                 qglTexCoord4f(p[0], p[1], p[2], p[3]);
951                                                         }
952                                                         else if (gl_state.units[j].arraycomponents == 3)
953                                                         {
954                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 3;
955                                                                 qglTexCoord3f(p[0], p[1], p[2]);
956                                                         }
957                                                         else if (gl_state.units[j].arraycomponents == 2)
958                                                         {
959                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 2;
960                                                                 qglTexCoord2f(p[0], p[1]);
961                                                         }
962                                                         else
963                                                         {
964                                                                 p = ((const GLfloat *)(gl_state.units[j].pointer_texcoord)) + elements[i] * 1;
965                                                                 qglTexCoord1f(p[0]);
966                                                         }
967                                                 }
968                                         }
969                                 }
970                                 if (gl_state.pointer_color)
971                                 {
972                                         p = ((const GLfloat *)(gl_state.pointer_color)) + elements[i] * 4;
973                                         qglColor4f(p[0], p[1], p[2], p[3]);
974                                 }
975                                 p = ((const GLfloat *)(gl_state.pointer_vertex)) + elements[i] * 3;
976                                 qglVertex3f(p[0], p[1], p[2]);
977                         }
978                         qglEnd();
979                         CHECKGLERROR
980                 }
981                 else if (gl_mesh_testarrayelement.integer)
982                 {
983                         int i;
984                         qglBegin(GL_TRIANGLES);
985                         for (i = 0;i < numtriangles * 3;i++)
986                         {
987                                 qglArrayElement(elements[i]);
988                         }
989                         qglEnd();
990                         CHECKGLERROR
991                 }
992                 else if (gl_mesh_drawrangeelements.integer && qglDrawRangeElements != NULL)
993                 {
994                         qglDrawRangeElements(GL_TRIANGLES, firstvertex, firstvertex + numvertices, numelements, GL_UNSIGNED_INT, elements);
995                         CHECKGLERROR
996                 }
997                 else
998                 {
999                         qglDrawElements(GL_TRIANGLES, numelements, GL_UNSIGNED_INT, elements);
1000                         CHECKGLERROR
1001                 }
1002         }
1003 }
1004
1005 // restores backend state, used when done with 3D rendering
1006 void R_Mesh_Finish(void)
1007 {
1008         unsigned int i;
1009         BACKENDACTIVECHECK
1010         CHECKGLERROR
1011         GL_LockArrays(0, 0);
1012         CHECKGLERROR
1013
1014         for (i = 0;i < backendimageunits;i++)
1015         {
1016                 GL_ActiveTexture(i);
1017                 qglBindTexture(GL_TEXTURE_1D, 0);CHECKGLERROR
1018                 qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
1019                 if (gl_texture3d)
1020                 {
1021                         qglBindTexture(GL_TEXTURE_3D, 0);CHECKGLERROR
1022                 }
1023                 if (gl_texturecubemap)
1024                 {
1025                         qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, 0);CHECKGLERROR
1026                 }
1027         }
1028         for (i = 0;i < backendarrayunits;i++)
1029         {
1030                 GL_ActiveTexture(backendarrayunits - 1 - i);
1031                 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
1032         }
1033         for (i = 0;i < backendunits;i++)
1034         {
1035                 GL_ActiveTexture(backendunits - 1 - i);
1036                 qglDisable(GL_TEXTURE_1D);CHECKGLERROR
1037                 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
1038                 if (gl_texture3d)
1039                 {
1040                         qglDisable(GL_TEXTURE_3D);CHECKGLERROR
1041                 }
1042                 if (gl_texturecubemap)
1043                 {
1044                         qglDisable(GL_TEXTURE_CUBE_MAP_ARB);CHECKGLERROR
1045                 }
1046                 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
1047                 if (gl_combine.integer)
1048                 {
1049                         qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1);CHECKGLERROR
1050                         qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1);CHECKGLERROR
1051                 }
1052         }
1053         qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
1054         qglDisableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
1055
1056         qglDisable(GL_BLEND);CHECKGLERROR
1057         qglEnable(GL_DEPTH_TEST);CHECKGLERROR
1058         qglDepthMask(GL_TRUE);CHECKGLERROR
1059         qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);CHECKGLERROR
1060 }
1061
1062 void R_Mesh_Matrix(const matrix4x4_t *matrix)
1063 {
1064         if (memcmp(matrix, &backend_modelmatrix, sizeof(matrix4x4_t)))
1065         {
1066                 backend_modelmatrix = *matrix;
1067                 Matrix4x4_Concat(&backend_modelviewmatrix, &backend_viewmatrix, matrix);
1068                 Matrix4x4_Transpose(&backend_glmodelviewmatrix, &backend_modelviewmatrix);
1069                 qglLoadMatrixf(&backend_glmodelviewmatrix.m[0][0]);
1070         }
1071 }
1072
1073 void R_Mesh_VertexPointer(const float *vertex3f)
1074 {
1075         if (gl_state.pointer_vertex != vertex3f)
1076         {
1077                 gl_state.pointer_vertex = vertex3f;
1078                 CHECKGLERROR
1079                 qglVertexPointer(3, GL_FLOAT, sizeof(float[3]), gl_state.pointer_vertex);
1080                 CHECKGLERROR
1081         }
1082 }
1083
1084 void R_Mesh_ColorPointer(const float *color4f)
1085 {
1086         if (r_showtrispass)
1087                 return;
1088         if (gl_state.pointer_color != color4f)
1089         {
1090                 CHECKGLERROR
1091                 if (!gl_state.pointer_color)
1092                 {
1093                         qglEnableClientState(GL_COLOR_ARRAY);
1094                         CHECKGLERROR
1095                 }
1096                 else if (!color4f)
1097                 {
1098                         qglDisableClientState(GL_COLOR_ARRAY);
1099                         CHECKGLERROR
1100                         // when color array is on the glColor gets trashed, set it again
1101                         qglColor4f(gl_state.color4f[0], gl_state.color4f[1], gl_state.color4f[2], gl_state.color4f[3]);
1102                         CHECKGLERROR
1103                 }
1104                 gl_state.pointer_color = color4f;
1105                 qglColorPointer(4, GL_FLOAT, sizeof(float[4]), gl_state.pointer_color);
1106                 CHECKGLERROR
1107         }
1108 }
1109
1110 void R_Mesh_TexCoordPointer(unsigned int unitnum, unsigned int numcomponents, const float *texcoord)
1111 {
1112         gltextureunit_t *unit = gl_state.units + unitnum;
1113         if (r_showtrispass)
1114                 return;
1115         // update array settings
1116         if (texcoord)
1117         {
1118                 // texcoord array
1119                 if (unit->pointer_texcoord != texcoord || unit->arraycomponents != numcomponents)
1120                 {
1121                         unit->pointer_texcoord = texcoord;
1122                         unit->arraycomponents = numcomponents;
1123                         GL_ClientActiveTexture(unitnum);
1124                         qglTexCoordPointer(unit->arraycomponents, GL_FLOAT, sizeof(float) * unit->arraycomponents, unit->pointer_texcoord);
1125                         CHECKGLERROR
1126                 }
1127                 // texture array unit is enabled, enable the array
1128                 if (!unit->arrayenabled)
1129                 {
1130                         unit->arrayenabled = true;
1131                         GL_ClientActiveTexture(unitnum);
1132                         qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
1133                 }
1134         }
1135         else
1136         {
1137                 // texture array unit is disabled, disable the array
1138                 if (unit->arrayenabled)
1139                 {
1140                         unit->arrayenabled = false;
1141                         GL_ClientActiveTexture(unitnum);
1142                         qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
1143                 }
1144         }
1145 }
1146
1147 void R_Mesh_TexBindAll(unsigned int unitnum, int tex1d, int tex2d, int tex3d, int texcubemap)
1148 {
1149         gltextureunit_t *unit = gl_state.units + unitnum;
1150         if (unitnum >= backendimageunits)
1151                 return;
1152         if (r_showtrispass)
1153                 return;
1154         // update 1d texture binding
1155         if (unit->t1d != tex1d)
1156         {
1157                 GL_ActiveTexture(unitnum);
1158                 if (unitnum < backendunits)
1159                 {
1160                         if (tex1d)
1161                         {
1162                                 if (unit->t1d == 0)
1163                                         qglEnable(GL_TEXTURE_1D);
1164                         }
1165                         else
1166                         {
1167                                 if (unit->t1d)
1168                                         qglDisable(GL_TEXTURE_1D);
1169                         }
1170                 }
1171                 unit->t1d = tex1d;
1172                 qglBindTexture(GL_TEXTURE_1D, unit->t1d);
1173                 CHECKGLERROR
1174         }
1175         // update 2d texture binding
1176         if (unit->t2d != tex2d)
1177         {
1178                 GL_ActiveTexture(unitnum);
1179                 if (unitnum < backendunits)
1180                 {
1181                         if (tex2d)
1182                         {
1183                                 if (unit->t2d == 0)
1184                                         qglEnable(GL_TEXTURE_2D);
1185                         }
1186                         else
1187                         {
1188                                 if (unit->t2d)
1189                                         qglDisable(GL_TEXTURE_2D);
1190                         }
1191                 }
1192                 unit->t2d = tex2d;
1193                 qglBindTexture(GL_TEXTURE_2D, unit->t2d);
1194                 CHECKGLERROR
1195         }
1196         // update 3d texture binding
1197         if (unit->t3d != tex3d)
1198         {
1199                 GL_ActiveTexture(unitnum);
1200                 if (unitnum < backendunits)
1201                 {
1202                         if (tex3d)
1203                         {
1204                                 if (unit->t3d == 0)
1205                                         qglEnable(GL_TEXTURE_3D);
1206                         }
1207                         else
1208                         {
1209                                 if (unit->t3d)
1210                                         qglDisable(GL_TEXTURE_3D);
1211                         }
1212                 }
1213                 unit->t3d = tex3d;
1214                 qglBindTexture(GL_TEXTURE_3D, unit->t3d);
1215                 CHECKGLERROR
1216         }
1217         // update cubemap texture binding
1218         if (unit->tcubemap != texcubemap)
1219         {
1220                 GL_ActiveTexture(unitnum);
1221                 if (unitnum < backendunits)
1222                 {
1223                         if (texcubemap)
1224                         {
1225                                 if (unit->tcubemap == 0)
1226                                         qglEnable(GL_TEXTURE_CUBE_MAP_ARB);
1227                         }
1228                         else
1229                         {
1230                                 if (unit->tcubemap)
1231                                         qglDisable(GL_TEXTURE_CUBE_MAP_ARB);
1232                         }
1233                 }
1234                 unit->tcubemap = texcubemap;
1235                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);
1236                 CHECKGLERROR
1237         }
1238 }
1239
1240 void R_Mesh_TexBind1D(unsigned int unitnum, int texnum)
1241 {
1242         gltextureunit_t *unit = gl_state.units + unitnum;
1243         if (unitnum >= backendimageunits)
1244                 return;
1245         if (r_showtrispass)
1246                 return;
1247         // update 1d texture binding
1248         if (unit->t1d != texnum)
1249         {
1250                 GL_ActiveTexture(unitnum);
1251                 if (unitnum < backendunits)
1252                 {
1253                         if (texnum)
1254                         {
1255                                 if (unit->t1d == 0)
1256                                         qglEnable(GL_TEXTURE_1D);
1257                         }
1258                         else
1259                         {
1260                                 if (unit->t1d)
1261                                         qglDisable(GL_TEXTURE_1D);
1262                         }
1263                 }
1264                 unit->t1d = texnum;
1265                 qglBindTexture(GL_TEXTURE_1D, unit->t1d);
1266                 CHECKGLERROR
1267         }
1268         // update 2d texture binding
1269         if (unit->t2d)
1270         {
1271                 GL_ActiveTexture(unitnum);
1272                 if (unitnum < backendunits)
1273                 {
1274                         if (unit->t2d)
1275                                 qglDisable(GL_TEXTURE_2D);
1276                 }
1277                 unit->t2d = 0;
1278                 qglBindTexture(GL_TEXTURE_2D, unit->t2d);
1279                 CHECKGLERROR
1280         }
1281         // update 3d texture binding
1282         if (unit->t3d)
1283         {
1284                 GL_ActiveTexture(unitnum);
1285                 if (unitnum < backendunits)
1286                 {
1287                         if (unit->t3d)
1288                                 qglDisable(GL_TEXTURE_3D);
1289                 }
1290                 unit->t3d = 0;
1291                 qglBindTexture(GL_TEXTURE_3D, unit->t3d);
1292                 CHECKGLERROR
1293         }
1294         // update cubemap texture binding
1295         if (unit->tcubemap)
1296         {
1297                 GL_ActiveTexture(unitnum);
1298                 if (unitnum < backendunits)
1299                 {
1300                         if (unit->tcubemap)
1301                                 qglDisable(GL_TEXTURE_CUBE_MAP_ARB);
1302                 }
1303                 unit->tcubemap = 0;
1304                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);
1305                 CHECKGLERROR
1306         }
1307 }
1308
1309 void R_Mesh_TexBind(unsigned int unitnum, int texnum)
1310 {
1311         gltextureunit_t *unit = gl_state.units + unitnum;
1312         if (unitnum >= backendimageunits)
1313                 return;
1314         if (r_showtrispass)
1315                 return;
1316         // update 1d texture binding
1317         if (unit->t1d)
1318         {
1319                 GL_ActiveTexture(unitnum);
1320                 if (unitnum < backendunits)
1321                 {
1322                         if (unit->t1d)
1323                                 qglDisable(GL_TEXTURE_1D);
1324                 }
1325                 unit->t1d = 0;
1326                 qglBindTexture(GL_TEXTURE_1D, unit->t1d);
1327                 CHECKGLERROR
1328         }
1329         // update 2d texture binding
1330         if (unit->t2d != texnum)
1331         {
1332                 GL_ActiveTexture(unitnum);
1333                 if (unitnum < backendunits)
1334                 {
1335                         if (texnum)
1336                         {
1337                                 if (unit->t2d == 0)
1338                                         qglEnable(GL_TEXTURE_2D);
1339                         }
1340                         else
1341                         {
1342                                 if (unit->t2d)
1343                                         qglDisable(GL_TEXTURE_2D);
1344                         }
1345                 }
1346                 unit->t2d = texnum;
1347                 qglBindTexture(GL_TEXTURE_2D, unit->t2d);
1348                 CHECKGLERROR
1349         }
1350         // update 3d texture binding
1351         if (unit->t3d)
1352         {
1353                 GL_ActiveTexture(unitnum);
1354                 if (unitnum < backendunits)
1355                 {
1356                         if (unit->t3d)
1357                                 qglDisable(GL_TEXTURE_3D);
1358                 }
1359                 unit->t3d = 0;
1360                 qglBindTexture(GL_TEXTURE_3D, unit->t3d);
1361                 CHECKGLERROR
1362         }
1363         // update cubemap texture binding
1364         if (unit->tcubemap != 0)
1365         {
1366                 GL_ActiveTexture(unitnum);
1367                 if (unitnum < backendunits)
1368                 {
1369                         if (unit->tcubemap)
1370                                 qglDisable(GL_TEXTURE_CUBE_MAP_ARB);
1371                 }
1372                 unit->tcubemap = 0;
1373                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);
1374                 CHECKGLERROR
1375         }
1376 }
1377
1378 void R_Mesh_TexBind3D(unsigned int unitnum, int texnum)
1379 {
1380         gltextureunit_t *unit = gl_state.units + unitnum;
1381         if (unitnum >= backendimageunits)
1382                 return;
1383         if (r_showtrispass)
1384                 return;
1385         // update 1d texture binding
1386         if (unit->t1d)
1387         {
1388                 GL_ActiveTexture(unitnum);
1389                 if (unitnum < backendunits)
1390                 {
1391                         if (unit->t1d)
1392                                 qglDisable(GL_TEXTURE_1D);
1393                 }
1394                 unit->t1d = 0;
1395                 qglBindTexture(GL_TEXTURE_1D, unit->t1d);
1396                 CHECKGLERROR
1397         }
1398         // update 2d texture binding
1399         if (unit->t2d)
1400         {
1401                 GL_ActiveTexture(unitnum);
1402                 if (unitnum < backendunits)
1403                 {
1404                         if (unit->t2d)
1405                                 qglDisable(GL_TEXTURE_2D);
1406                 }
1407                 unit->t2d = 0;
1408                 qglBindTexture(GL_TEXTURE_2D, unit->t2d);
1409                 CHECKGLERROR
1410         }
1411         // update 3d texture binding
1412         if (unit->t3d != texnum)
1413         {
1414                 GL_ActiveTexture(unitnum);
1415                 if (unitnum < backendunits)
1416                 {
1417                         if (texnum)
1418                         {
1419                                 if (unit->t3d == 0)
1420                                         qglEnable(GL_TEXTURE_3D);
1421                         }
1422                         else
1423                         {
1424                                 if (unit->t3d)
1425                                         qglDisable(GL_TEXTURE_3D);
1426                         }
1427                 }
1428                 unit->t3d = texnum;
1429                 qglBindTexture(GL_TEXTURE_3D, unit->t3d);
1430                 CHECKGLERROR
1431         }
1432         // update cubemap texture binding
1433         if (unit->tcubemap != 0)
1434         {
1435                 GL_ActiveTexture(unitnum);
1436                 if (unitnum < backendunits)
1437                 {
1438                         if (unit->tcubemap)
1439                                 qglDisable(GL_TEXTURE_CUBE_MAP_ARB);
1440                 }
1441                 unit->tcubemap = 0;
1442                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);
1443                 CHECKGLERROR
1444         }
1445 }
1446
1447 void R_Mesh_TexBindCubeMap(unsigned int unitnum, int texnum)
1448 {
1449         gltextureunit_t *unit = gl_state.units + unitnum;
1450         if (unitnum >= backendimageunits)
1451                 return;
1452         if (r_showtrispass)
1453                 return;
1454         // update 1d texture binding
1455         if (unit->t1d)
1456         {
1457                 GL_ActiveTexture(unitnum);
1458                 if (unitnum < backendunits)
1459                 {
1460                         if (unit->t1d)
1461                                 qglDisable(GL_TEXTURE_1D);
1462                 }
1463                 unit->t1d = 0;
1464                 qglBindTexture(GL_TEXTURE_1D, unit->t1d);
1465                 CHECKGLERROR
1466         }
1467         // update 2d texture binding
1468         if (unit->t2d)
1469         {
1470                 GL_ActiveTexture(unitnum);
1471                 if (unitnum < backendunits)
1472                 {
1473                         if (unit->t2d)
1474                                 qglDisable(GL_TEXTURE_2D);
1475                 }
1476                 unit->t2d = 0;
1477                 qglBindTexture(GL_TEXTURE_2D, unit->t2d);
1478                 CHECKGLERROR
1479         }
1480         // update 3d texture binding
1481         if (unit->t3d)
1482         {
1483                 GL_ActiveTexture(unitnum);
1484                 if (unitnum < backendunits)
1485                 {
1486                         if (unit->t3d)
1487                                 qglDisable(GL_TEXTURE_3D);
1488                 }
1489                 unit->t3d = 0;
1490                 qglBindTexture(GL_TEXTURE_3D, unit->t3d);
1491                 CHECKGLERROR
1492         }
1493         // update cubemap texture binding
1494         if (unit->tcubemap != texnum)
1495         {
1496                 GL_ActiveTexture(unitnum);
1497                 if (unitnum < backendunits)
1498                 {
1499                         if (texnum)
1500                         {
1501                                 if (unit->tcubemap == 0)
1502                                         qglEnable(GL_TEXTURE_CUBE_MAP_ARB);
1503                         }
1504                         else
1505                         {
1506                                 if (unit->tcubemap)
1507                                         qglDisable(GL_TEXTURE_CUBE_MAP_ARB);
1508                         }
1509                 }
1510                 unit->tcubemap = texnum;
1511                 qglBindTexture(GL_TEXTURE_CUBE_MAP_ARB, unit->tcubemap);
1512                 CHECKGLERROR
1513         }
1514 }
1515
1516 void R_Mesh_TexMatrix(unsigned int unitnum, const matrix4x4_t *matrix)
1517 {
1518         gltextureunit_t *unit = gl_state.units + unitnum;
1519         if (r_showtrispass)
1520                 return;
1521         if (matrix->m[3][3])
1522         {
1523                 // texmatrix specified, check if it is different
1524                 if (!unit->texmatrixenabled || memcmp(&unit->matrix, matrix, sizeof(matrix4x4_t)))
1525                 {
1526                         matrix4x4_t tempmatrix;
1527                         unit->texmatrixenabled = true;
1528                         unit->matrix = *matrix;
1529                         Matrix4x4_Transpose(&tempmatrix, &unit->matrix);
1530                         qglMatrixMode(GL_TEXTURE);
1531                         GL_ActiveTexture(unitnum);
1532                         qglLoadMatrixf(&tempmatrix.m[0][0]);
1533                         qglMatrixMode(GL_MODELVIEW);
1534                 }
1535         }
1536         else
1537         {
1538                 // no texmatrix specified, revert to identity
1539                 if (unit->texmatrixenabled)
1540                 {
1541                         unit->texmatrixenabled = false;
1542                         qglMatrixMode(GL_TEXTURE);
1543                         GL_ActiveTexture(unitnum);
1544                         qglLoadIdentity();
1545                         qglMatrixMode(GL_MODELVIEW);
1546                 }
1547         }
1548 }
1549
1550 void R_Mesh_TexCombine(unsigned int unitnum, int combinergb, int combinealpha, int rgbscale, int alphascale)
1551 {
1552         gltextureunit_t *unit = gl_state.units + unitnum;
1553         if (r_showtrispass)
1554                 return;
1555         if (gl_combine.integer)
1556         {
1557                 // GL_ARB_texture_env_combine
1558                 if (!combinergb)
1559                         combinergb = GL_MODULATE;
1560                 if (!combinealpha)
1561                         combinealpha = GL_MODULATE;
1562                 if (!rgbscale)
1563                         rgbscale = 1;
1564                 if (!alphascale)
1565                         alphascale = 1;
1566                 if (unit->combinergb != combinergb)
1567                 {
1568                         unit->combinergb = combinergb;
1569                         GL_ActiveTexture(unitnum);
1570                         qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, unit->combinergb);CHECKGLERROR
1571                 }
1572                 if (unit->combinealpha != combinealpha)
1573                 {
1574                         unit->combinealpha = combinealpha;
1575                         GL_ActiveTexture(unitnum);
1576                         qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, unit->combinealpha);CHECKGLERROR
1577                 }
1578                 if (unit->rgbscale != rgbscale)
1579                 {
1580                         GL_ActiveTexture(unitnum);
1581                         qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, (unit->rgbscale = rgbscale));CHECKGLERROR
1582                 }
1583                 if (unit->alphascale != alphascale)
1584                 {
1585                         GL_ActiveTexture(unitnum);
1586                         qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, (unit->alphascale = alphascale));CHECKGLERROR
1587                 }
1588         }
1589         else
1590         {
1591                 // normal GL texenv
1592                 if (!combinergb)
1593                         combinergb = GL_MODULATE;
1594                 if (unit->combinergb != combinergb)
1595                 {
1596                         unit->combinergb = combinergb;
1597                         GL_ActiveTexture(unitnum);
1598                         qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->combinergb);CHECKGLERROR
1599                 }
1600         }
1601 }
1602
1603 void R_Mesh_State(const rmeshstate_t *m)
1604 {
1605         unsigned int i;
1606
1607         BACKENDACTIVECHECK
1608
1609         R_Mesh_VertexPointer(m->pointer_vertex);
1610         R_Mesh_ColorPointer(m->pointer_color);
1611
1612         if (gl_backend_rebindtextures)
1613         {
1614                 gl_backend_rebindtextures = false;
1615                 GL_SetupTextureState();
1616         }
1617
1618         for (i = 0;i < backendimageunits;i++)
1619                 R_Mesh_TexBindAll(i, m->tex1d[i], m->tex[i], m->tex3d[i], m->texcubemap[i]);
1620         for (i = 0;i < backendarrayunits;i++)
1621         {
1622                 if (m->pointer_texcoord3f[i])
1623                         R_Mesh_TexCoordPointer(i, 3, m->pointer_texcoord3f[i]);
1624                 else
1625                         R_Mesh_TexCoordPointer(i, 2, m->pointer_texcoord[i]);
1626         }
1627         for (i = 0;i < backendunits;i++)
1628         {
1629                 R_Mesh_TexMatrix(i, &m->texmatrix[i]);
1630                 R_Mesh_TexCombine(i, m->texcombinergb[i], m->texcombinealpha[i], m->texrgbscale[i], m->texalphascale[i]);
1631         }
1632 }
1633
1634 void R_Mesh_Draw_ShowTris(int firstvertex, int numvertices, int numtriangles, const int *elements)
1635 {
1636         qglBegin(GL_LINES);
1637         for (;numtriangles;numtriangles--, elements += 3)
1638         {
1639                 qglArrayElement(elements[0]);qglArrayElement(elements[1]);
1640                 qglArrayElement(elements[1]);qglArrayElement(elements[2]);
1641                 qglArrayElement(elements[2]);qglArrayElement(elements[0]);
1642         }
1643         qglEnd();
1644         CHECKGLERROR
1645 }