cleanup of float/byte colors, now colors are always floats until R_Mesh_Render conver...
[divverent/darkplaces.git] / gl_backend.c
1
2 #include "quakedef.h"
3
4 cvar_t          r_render = {0, "r_render", "1"};
5 cvar_t          gl_dither = {CVAR_SAVE, "gl_dither", "1"}; // whether or not to use dithering
6
7 int                     lightscalebit;
8 float           lightscale;
9 float           overbrightscale;
10
11 void SCR_ScreenShot_f (void);
12 static void R_Envmap_f (void);
13
14 static int max_meshs;
15 static int max_batch;
16 static int max_verts; // always max_meshs * 3
17 #define TRANSDEPTHRES 4096
18
19 //static cvar_t gl_mesh_maxtriangles = {0, "gl_mesh_maxtriangles", "21760"};
20 static cvar_t gl_mesh_maxtriangles = {0, "gl_mesh_maxtriangles", "8192"};
21 static cvar_t gl_mesh_batchtriangles = {0, "gl_mesh_batchtriangles", "1024"};
22 static cvar_t gl_mesh_merge = {0, "gl_mesh_merge", "1"};
23 static cvar_t gl_mesh_floatcolors = {0, "gl_mesh_floatcolors", "0"};
24 static cvar_t gl_mesh_dupetransverts = {0, "gl_mesh_dupetransverts", "0"};
25 static cvar_t gl_mesh_sorttransbymesh = {0, "gl_mesh_sorttransbymesh", "1"};
26
27 typedef struct buf_mesh_s
28 {
29         //struct buf_mesh_s *next;
30         int depthmask;
31         int depthtest;
32         int blendfunc1, blendfunc2;
33         int textures[MAX_TEXTUREUNITS];
34         float texturergbscale[MAX_TEXTUREUNITS];
35         int firsttriangle;
36         int triangles;
37         int firstvert;
38         int lastvert;
39         struct buf_mesh_s *chain;
40         struct buf_transtri_s *transchain;
41         //struct buf_transtri_s **transchainpointer;
42 }
43 buf_mesh_t;
44
45 typedef struct buf_transtri_s
46 {
47         struct buf_transtri_s *next;
48         struct buf_transtri_s *meshsortchain;
49         buf_mesh_t *mesh;
50         int index[3];
51 }
52 buf_transtri_t;
53
54 typedef struct buf_tri_s
55 {
56         int index[3];
57 }
58 buf_tri_t;
59
60 typedef struct
61 {
62         float v[4];
63 }
64 buf_vertex_t;
65
66 typedef struct
67 {
68         float c[4];
69 }
70 buf_fcolor_t;
71
72 typedef struct
73 {
74         byte c[4];
75 }
76 buf_bcolor_t;
77
78 typedef struct
79 {
80         float t[2];
81 }
82 buf_texcoord_t;
83
84 static float meshfarclip;
85 static int currentmesh, currenttriangle, currentvertex, backendunits, backendactive, meshmerge, transranout;
86 static buf_mesh_t *buf_mesh;
87 static buf_tri_t *buf_tri;
88 static buf_vertex_t *buf_vertex;
89 static buf_fcolor_t *buf_fcolor;
90 static buf_bcolor_t *buf_bcolor;
91 static buf_texcoord_t *buf_texcoord[MAX_TEXTUREUNITS];
92
93 static int currenttransmesh, currenttransvertex, currenttranstriangle;
94 static buf_mesh_t *buf_transmesh;
95 static buf_transtri_t *buf_transtri;
96 static buf_transtri_t **buf_transtri_list;
97 static buf_vertex_t *buf_transvertex;
98 static buf_fcolor_t *buf_transfcolor;
99 static buf_texcoord_t *buf_transtexcoord[MAX_TEXTUREUNITS];
100
101 static mempool_t *gl_backend_mempool;
102 static int resizingbuffers = false;
103
104 static void gl_backend_start(void)
105 {
106         int i;
107
108         max_verts = max_meshs * 3;
109
110         if (!gl_backend_mempool)
111                 gl_backend_mempool = Mem_AllocPool("GL_Backend");
112
113 #define BACKENDALLOC(var, count, sizeofstruct)\
114         {\
115                 var = Mem_Alloc(gl_backend_mempool, count * sizeof(sizeofstruct));\
116                 if (var == NULL)\
117                         Sys_Error("gl_backend_start: unable to allocate memory\n");\
118                 memset(var, 0, count * sizeof(sizeofstruct));\
119         }
120
121         BACKENDALLOC(buf_mesh, max_meshs, buf_mesh_t)
122         BACKENDALLOC(buf_tri, max_meshs, buf_tri_t)
123         BACKENDALLOC(buf_vertex, max_verts, buf_vertex_t)
124         BACKENDALLOC(buf_fcolor, max_verts, buf_fcolor_t)
125         BACKENDALLOC(buf_bcolor, max_verts, buf_bcolor_t)
126
127         BACKENDALLOC(buf_transmesh, max_meshs, buf_mesh_t)
128         BACKENDALLOC(buf_transtri, max_meshs, buf_transtri_t)
129         BACKENDALLOC(buf_transtri_list, TRANSDEPTHRES, buf_transtri_t *)
130         BACKENDALLOC(buf_transvertex, max_verts, buf_vertex_t)
131         BACKENDALLOC(buf_transfcolor, max_verts, buf_fcolor_t)
132
133         for (i = 0;i < MAX_TEXTUREUNITS;i++)
134         {
135                 // only allocate as many texcoord arrays as we need
136                 if (i < gl_textureunits)
137                 {
138                         BACKENDALLOC(buf_texcoord[i], max_verts, buf_texcoord_t)
139                         BACKENDALLOC(buf_transtexcoord[i], max_verts, buf_texcoord_t)
140                 }
141                 else
142                 {
143                         buf_texcoord[i] = NULL;
144                         buf_transtexcoord[i] = NULL;
145                 }
146         }
147         backendunits = min(MAX_TEXTUREUNITS, gl_textureunits);
148         backendactive = true;
149 }
150
151 static void gl_backend_shutdown(void)
152 {
153         //int i;
154         /*
155 #define BACKENDFREE(var)\
156         if (var)\
157         {\
158                 Mem_Free(var);\
159                 var = NULL;\
160         }
161         */
162         /*
163 #define BACKENDFREE(var) var = NULL;
164
165         BACKENDFREE(buf_mesh)
166         BACKENDFREE(buf_tri)
167         BACKENDFREE(buf_vertex)
168         BACKENDFREE(buf_fcolor)
169         BACKENDFREE(buf_bcolor)
170
171         BACKENDFREE(buf_transmesh)
172         BACKENDFREE(buf_transtri)
173         BACKENDFREE(buf_transtri_list)
174         BACKENDFREE(buf_transvertex)
175         BACKENDFREE(buf_transfcolor)
176
177         for (i = 0;i < MAX_TEXTUREUNITS;i++)
178         {
179                 BACKENDFREE(buf_texcoord[i])
180                 BACKENDFREE(buf_transtexcoord[i])
181         }
182         */
183
184         if (resizingbuffers)
185                 Mem_EmptyPool(gl_backend_mempool);
186         else
187                 Mem_FreePool(&gl_backend_mempool);
188
189         backendunits = 0;
190         backendactive = false;
191 }
192
193 static void gl_backend_bufferchanges(int init)
194 {
195         // 21760 is (65536 / 3) rounded off to a multiple of 128
196         if (gl_mesh_maxtriangles.integer < 256)
197                 Cvar_SetValue("gl_mesh_maxtriangles", 256);
198         if (gl_mesh_maxtriangles.integer > 21760)
199                 Cvar_SetValue("gl_mesh_maxtriangles", 21760);
200
201         if (gl_mesh_batchtriangles.integer < 0)
202                 Cvar_SetValue("gl_mesh_batchtriangles", 0);
203         if (gl_mesh_batchtriangles.integer > gl_mesh_maxtriangles.integer)
204                 Cvar_SetValue("gl_mesh_batchtriangles", gl_mesh_maxtriangles.integer);
205
206         max_batch = gl_mesh_batchtriangles.integer;
207
208         if (max_meshs != gl_mesh_maxtriangles.integer)
209         {
210                 max_meshs = gl_mesh_maxtriangles.integer;
211
212                 if (!init)
213                 {
214                         resizingbuffers = true;
215                         gl_backend_shutdown();
216                         gl_backend_start();
217                         resizingbuffers = false;
218                 }
219         }
220 }
221
222 float r_farclip, r_newfarclip;
223
224 static void gl_backend_newmap(void)
225 {
226         r_farclip = r_newfarclip = 2048.0f;
227 }
228
229 int polyindexarray[768];
230
231 void gl_backend_init(void)
232 {
233         int i;
234
235         Cvar_RegisterVariable (&r_render);
236         Cvar_RegisterVariable (&gl_dither);
237 #ifdef NORENDER
238         Cvar_SetValue("r_render", 0);
239 #endif
240
241         Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
242         Cmd_AddCommand ("envmap", R_Envmap_f);
243
244         Cvar_RegisterVariable(&gl_mesh_maxtriangles);
245         Cvar_RegisterVariable(&gl_mesh_batchtriangles);
246         Cvar_RegisterVariable(&gl_mesh_merge);
247         Cvar_RegisterVariable(&gl_mesh_floatcolors);
248         Cvar_RegisterVariable(&gl_mesh_dupetransverts);
249         Cvar_RegisterVariable(&gl_mesh_sorttransbymesh);
250         R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap);
251         gl_backend_bufferchanges(true);
252         for (i = 0;i < 256;i++)
253         {
254                 polyindexarray[i*3+0] = 0;
255                 polyindexarray[i*3+1] = i + 1;
256                 polyindexarray[i*3+2] = i + 2;
257         }
258 }
259
260 static void MYgluPerspective(GLdouble fovx, GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar )
261 {
262         GLdouble xmax, ymax;
263
264         xmax = zNear * tan( fovx * M_PI / 360.0 ) * aspect;
265         ymax = zNear * tan( fovy * M_PI / 360.0 );
266
267         glFrustum(-xmax, xmax, -ymax, ymax, zNear, zFar );
268 }
269
270
271 /*
272 =============
273 GL_SetupFrame
274 =============
275 */
276 static void GL_SetupFrame (void)
277 {
278         if (!r_render.integer)
279                 return;
280
281 //      glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // LordHavoc: moved to SCR_UpdateScreen
282         gldepthmin = 0;
283         gldepthmax = 1;
284         glDepthFunc (GL_LEQUAL);
285
286         glDepthRange (gldepthmin, gldepthmax);
287
288         // update farclip based on previous frame
289         r_farclip = r_newfarclip;
290
291         // set up viewpoint
292         glMatrixMode(GL_PROJECTION);
293         glLoadIdentity ();
294
295         // y is weird beause OpenGL is bottom to top, we use top to bottom
296         glViewport(r_refdef.x, vid.realheight - (r_refdef.y + r_refdef.height), r_refdef.width, r_refdef.height);
297 //      yfov = 2*atan((float)r_refdef.height/r_refdef.width)*180/M_PI;
298         MYgluPerspective (r_refdef.fov_x, r_refdef.fov_y, r_refdef.width/r_refdef.height, 4, r_farclip);
299
300         glCullFace(GL_FRONT);
301
302         glMatrixMode(GL_MODELVIEW);
303         glLoadIdentity ();
304
305         glRotatef (-90,  1, 0, 0);          // put Z going up
306         glRotatef (90,  0, 0, 1);           // put Z going up
307         glRotatef (-r_refdef.viewangles[2],  1, 0, 0);
308         glRotatef (-r_refdef.viewangles[0],  0, 1, 0);
309         glRotatef (-r_refdef.viewangles[1],  0, 0, 1);
310         glTranslatef (-r_refdef.vieworg[0],  -r_refdef.vieworg[1],  -r_refdef.vieworg[2]);
311
312 //      glGetFloatv (GL_MODELVIEW_MATRIX, r_world_matrix);
313
314         //
315         // set drawing parms
316         //
317 //      if (gl_cull.integer)
318                 glEnable(GL_CULL_FACE);
319 //      else
320 //              glDisable(GL_CULL_FACE);
321
322         glEnable(GL_BLEND); // was Disable
323         glEnable(GL_DEPTH_TEST);
324         glDepthMask(1);
325 }
326
327 static float viewdist;
328
329 int c_meshs, c_meshtris, c_transmeshs, c_transtris;
330
331 // called at beginning of frame
332 void R_Mesh_Clear(void)
333 {
334         if (!backendactive)
335                 Sys_Error("R_Mesh_Clear: called when backend is not active\n");
336
337         gl_backend_bufferchanges(false);
338
339         currentmesh = 0;
340         currenttriangle = 0;
341         currentvertex = 0;
342         currenttransmesh = 0;
343         currenttranstriangle = 0;
344         currenttransvertex = 0;
345         meshfarclip = 0;
346         meshmerge = gl_mesh_merge.integer;
347         transranout = false;
348         viewdist = DotProduct(r_origin, vpn);
349
350         c_meshs = 0;
351         c_meshtris = 0;
352         c_transmeshs = 0;
353         c_transtris = 0;
354
355         GL_SetupFrame();
356 }
357
358 #ifdef DEBUGGL
359 void GL_PrintError(int errornumber, char *filename, int linenumber)
360 {
361         switch(errornumber)
362         {
363         case GL_INVALID_ENUM:
364                 Con_Printf("GL_INVALID_ENUM at %s:%i\n", filename, linenumber);
365                 break;
366         case GL_INVALID_VALUE:
367                 Con_Printf("GL_INVALID_VALUE at %s:%i\n", filename, linenumber);
368                 break;
369         case GL_INVALID_OPERATION:
370                 Con_Printf("GL_INVALID_OPERATION at %s:%i\n", filename, linenumber);
371                 break;
372         case GL_STACK_OVERFLOW:
373                 Con_Printf("GL_STACK_OVERFLOW at %s:%i\n", filename, linenumber);
374                 break;
375         case GL_STACK_UNDERFLOW:
376                 Con_Printf("GL_STACK_UNDERFLOW at %s:%i\n", filename, linenumber);
377                 break;
378         case GL_OUT_OF_MEMORY:
379                 Con_Printf("GL_OUT_OF_MEMORY at %s:%i\n", filename, linenumber);
380                 break;
381 #ifdef GL_TABLE_TOO_LARGE
382     case GL_TABLE_TOO_LARGE:
383                 Con_Printf("GL_TABLE_TOO_LARGE at %s:%i\n", filename, linenumber);
384                 break;
385 #endif
386         default:
387                 Con_Printf("GL UNKNOWN (%i) at %s:%i\n", errornumber, filename, linenumber);
388                 break;
389         }
390 }
391
392 int errornumber = 0;
393 #endif
394
395 // renders mesh buffers, called to flush buffers when full
396 void R_Mesh_Render(void)
397 {
398         int i, k, blendfunc1, blendfunc2, blend, depthmask, depthtest, unit = 0, clientunit = 0, firsttriangle, triangles, firstvert, lastvert, texture[MAX_TEXTUREUNITS];
399         float farclip, texturergbscale[MAX_TEXTUREUNITS];
400         buf_mesh_t *mesh;
401         // float to byte color conversion
402         int *icolor;
403         float *fcolor;
404         byte *bcolor;
405         if (!backendactive)
406                 Sys_Error("R_Mesh_Render: called when backend is not active\n");
407         if (!currentmesh)
408                 return;
409
410 CHECKGLERROR
411
412         // push out farclip based on vertices
413         for (i = 0;i < currentvertex;i++)
414         {
415                 farclip = DotProduct(buf_vertex[i].v, vpn);
416                 if (meshfarclip < farclip)
417                         meshfarclip = farclip;
418         }
419
420         farclip = meshfarclip + 256.0f - viewdist; // + 256 just to be safe
421
422         // push out farclip for next frame
423         if (farclip > r_newfarclip)
424                 r_newfarclip = ceil((farclip + 255) / 256) * 256 + 256;
425
426         for (i = 0;i < backendunits;i++)
427                 texturergbscale[i] = 1;
428
429         glEnable(GL_CULL_FACE);
430 CHECKGLERROR
431         glCullFace(GL_FRONT);
432 CHECKGLERROR
433         depthtest = true;
434         glEnable(GL_DEPTH_TEST);
435 CHECKGLERROR
436         blendfunc1 = GL_ONE;
437         blendfunc2 = GL_ZERO;
438         glBlendFunc(blendfunc1, blendfunc2);
439 CHECKGLERROR
440         blend = 0;
441         glDisable(GL_BLEND);
442 CHECKGLERROR
443         depthmask = true;
444         glDepthMask((GLboolean) depthmask);
445 CHECKGLERROR
446
447         glVertexPointer(3, GL_FLOAT, sizeof(buf_vertex_t), buf_vertex);
448 CHECKGLERROR
449         glEnableClientState(GL_VERTEX_ARRAY);
450 CHECKGLERROR
451         if (gl_mesh_floatcolors.integer)
452         {
453                 glColorPointer(4, GL_FLOAT, sizeof(buf_fcolor_t), buf_fcolor);
454 CHECKGLERROR
455         }
456         else
457         {
458                 // shift float to have 8bit fraction at base of number
459                 for (i = 0, fcolor = &buf_fcolor->c[0];i < currentvertex;i++)
460                 {
461                         *fcolor++ += 32768.0f;
462                         *fcolor++ += 32768.0f;
463                         *fcolor++ += 32768.0f;
464                         *fcolor++ += 32768.0f;
465                 }
466                 // then read as integer and kill float bits...
467                 for (i = 0, icolor = (int *)&buf_fcolor->c[0], bcolor = &buf_bcolor->c[0];i < currentvertex;i++)
468                 {
469                         k = (*icolor++) & 0x7FFFFF;*bcolor++ = k > 255 ? 255 : k;
470                         k = (*icolor++) & 0x7FFFFF;*bcolor++ = k > 255 ? 255 : k;
471                         k = (*icolor++) & 0x7FFFFF;*bcolor++ = k > 255 ? 255 : k;
472                         k = (*icolor++) & 0x7FFFFF;*bcolor++ = k > 255 ? 255 : k;
473                 }
474                 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(buf_bcolor_t), buf_bcolor);
475 CHECKGLERROR
476         }
477         glEnableClientState(GL_COLOR_ARRAY);
478 CHECKGLERROR
479
480         if (backendunits > 1)
481         {
482                 for (i = 0;i < backendunits;i++)
483                 {
484                         qglActiveTexture(GL_TEXTURE0_ARB + (unit = i));
485 CHECKGLERROR
486                         glBindTexture(GL_TEXTURE_2D, (texture[i] = 0));
487 CHECKGLERROR
488                         glDisable(GL_TEXTURE_2D);
489 CHECKGLERROR
490                         if (gl_combine.integer)
491                         {
492                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
493 CHECKGLERROR
494                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
495 CHECKGLERROR
496                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
497 CHECKGLERROR
498                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
499 CHECKGLERROR
500                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_CONSTANT_ARB);
501 CHECKGLERROR
502                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
503 CHECKGLERROR
504                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
505 CHECKGLERROR
506                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);
507 CHECKGLERROR
508                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
509 CHECKGLERROR
510                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
511 CHECKGLERROR
512                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);
513 CHECKGLERROR
514                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_CONSTANT_ARB);
515 CHECKGLERROR
516                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
517 CHECKGLERROR
518                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);
519 CHECKGLERROR
520                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA);
521 CHECKGLERROR
522                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0f);
523 CHECKGLERROR
524                                 glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0f);
525 CHECKGLERROR
526                         }
527                         else
528                         {
529                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
530 CHECKGLERROR
531                         }
532
533                         qglClientActiveTexture(GL_TEXTURE0_ARB + (clientunit = i));
534 CHECKGLERROR
535                         glTexCoordPointer(2, GL_FLOAT, sizeof(buf_texcoord_t), buf_texcoord[i]);
536 CHECKGLERROR
537                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
538 CHECKGLERROR
539                 }
540         }
541         else
542         {
543                 glBindTexture(GL_TEXTURE_2D, (texture[0] = 0));
544 CHECKGLERROR
545                 glDisable(GL_TEXTURE_2D);
546 CHECKGLERROR
547                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
548 CHECKGLERROR
549
550                 glTexCoordPointer(2, GL_FLOAT, sizeof(buf_texcoord_t), buf_texcoord[0]);
551 CHECKGLERROR
552                 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
553 CHECKGLERROR
554         }
555
556         // lock as early as possible
557         GL_LockArray(0, currentvertex);
558 CHECKGLERROR
559
560         for (k = 0;k < currentmesh;)
561         {
562                 mesh = &buf_mesh[k];
563
564                 if (backendunits > 1)
565                 {
566 //                      int topunit = 0;
567                         for (i = 0;i < backendunits;i++)
568                         {
569                                 if (texture[i] != mesh->textures[i])
570                                 {
571                                         if (unit != i)
572                                         {
573                                                 qglActiveTexture(GL_TEXTURE0_ARB + (unit = i));
574 CHECKGLERROR
575                                         }
576                                         if (texture[i] == 0)
577                                         {
578                                                 glEnable(GL_TEXTURE_2D);
579 CHECKGLERROR
580                                                 // have to disable texcoord array on disabled texture
581                                                 // units due to NVIDIA driver bug with
582                                                 // compiled_vertex_array
583                                                 if (clientunit != i)
584                                                 {
585                                                         qglClientActiveTexture(GL_TEXTURE0_ARB + (clientunit = i));
586 CHECKGLERROR
587                                                 }
588                                                 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
589 CHECKGLERROR
590                                         }
591                                         glBindTexture(GL_TEXTURE_2D, (texture[i] = mesh->textures[i]));
592 CHECKGLERROR
593                                         if (texture[i] == 0)
594                                         {
595                                                 glDisable(GL_TEXTURE_2D);
596 CHECKGLERROR
597                                                 // have to disable texcoord array on disabled texture
598                                                 // units due to NVIDIA driver bug with
599                                                 // compiled_vertex_array
600                                                 if (clientunit != i)
601                                                 {
602                                                         qglClientActiveTexture(GL_TEXTURE0_ARB + (clientunit = i));
603 CHECKGLERROR
604                                                 }
605                                                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
606 CHECKGLERROR
607                                         }
608                                 }
609                                 if (texturergbscale[i] != mesh->texturergbscale[i])
610                                 {
611                                         if (unit != i)
612                                         {
613                                                 qglActiveTexture(GL_TEXTURE0_ARB + (unit = i));
614 CHECKGLERROR
615                                         }
616                                         glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, (texturergbscale[i] = mesh->texturergbscale[i]));
617 CHECKGLERROR
618                                 }
619 //                              if (texture[i])
620 //                                      topunit = i;
621                         }
622 //                      if (unit != topunit)
623 //                      {
624 //                              qglActiveTexture(GL_TEXTURE0_ARB + (unit = topunit));
625 //CHECKGLERROR
626 //                      }
627                 }
628                 else
629                 {
630                         if (texture[0] != mesh->textures[0])
631                         {
632                                 if (texture[0] == 0)
633                                 {
634                                         glEnable(GL_TEXTURE_2D);
635 CHECKGLERROR
636                                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
637 CHECKGLERROR
638                                 }
639                                 glBindTexture(GL_TEXTURE_2D, (texture[0] = mesh->textures[0]));
640 CHECKGLERROR
641                                 if (texture[0] == 0)
642                                 {
643                                         glDisable(GL_TEXTURE_2D);
644 CHECKGLERROR
645                                         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
646 CHECKGLERROR
647                                 }
648                         }
649                 }
650                 if (blendfunc1 != mesh->blendfunc1 || blendfunc2 != mesh->blendfunc2)
651                 {
652                         blendfunc1 = mesh->blendfunc1;
653                         blendfunc2 = mesh->blendfunc2;
654                         glBlendFunc(blendfunc1, blendfunc2);
655 CHECKGLERROR
656                         if (blendfunc2 == GL_ZERO)
657                         {
658                                 if (blendfunc1 == GL_ONE)
659                                 {
660                                         if (blend)
661                                         {
662                                                 blend = 0;
663                                                 glDisable(GL_BLEND);
664 CHECKGLERROR
665                                         }
666                                 }
667                                 else
668                                 {
669                                         if (!blend)
670                                         {
671                                                 blend = 1;
672                                                 glEnable(GL_BLEND);
673 CHECKGLERROR
674                                         }
675                                 }
676                         }
677                         else
678                         {
679                                 if (!blend)
680                                 {
681                                         blend = 1;
682                                         glEnable(GL_BLEND);
683 CHECKGLERROR
684                                 }
685                         }
686                 }
687                 if (depthtest != mesh->depthtest)
688                 {
689                         depthtest = mesh->depthtest;
690                         if (depthtest)
691                                 glEnable(GL_DEPTH_TEST);
692                         else
693                                 glDisable(GL_DEPTH_TEST);
694                 }
695                 if (depthmask != mesh->depthmask)
696                 {
697                         depthmask = mesh->depthmask;
698                         glDepthMask((GLboolean) depthmask);
699 CHECKGLERROR
700                 }
701
702                 firsttriangle = mesh->firsttriangle;
703                 triangles = mesh->triangles;
704                 firstvert = mesh->firstvert;
705                 lastvert = mesh->lastvert;
706                 mesh = &buf_mesh[++k];
707
708                 if (meshmerge)
709                 {
710                         #if MAX_TEXTUREUNITS != 4
711                         #error update this code
712                         #endif
713                         while (k < currentmesh
714                                 && mesh->blendfunc1 == blendfunc1
715                                 && mesh->blendfunc2 == blendfunc2
716                                 && mesh->depthtest == depthtest
717                                 && mesh->depthmask == depthmask
718                                 && mesh->textures[0] == texture[0]
719                                 && mesh->textures[1] == texture[1]
720                                 && mesh->textures[2] == texture[2]
721                                 && mesh->textures[3] == texture[3]
722                                 && mesh->texturergbscale[0] == texturergbscale[0]
723                                 && mesh->texturergbscale[1] == texturergbscale[1]
724                                 && mesh->texturergbscale[2] == texturergbscale[2]
725                                 && mesh->texturergbscale[3] == texturergbscale[3])
726                         {
727                                 triangles += mesh->triangles;
728                                 if (firstvert > mesh->firstvert)
729                                         firstvert = mesh->firstvert;
730                                 if (lastvert < mesh->lastvert)
731                                         lastvert = mesh->lastvert;
732                                 mesh = &buf_mesh[++k];
733                         }
734                 }
735
736 #ifdef WIN32
737                 // FIXME: dynamic link to GL so we can get DrawRangeElements on WIN32
738                 glDrawElements(GL_TRIANGLES, triangles * 3, GL_UNSIGNED_INT, (unsigned int *)&buf_tri[firsttriangle]);
739 #else
740                 glDrawRangeElements(GL_TRIANGLES, firstvert, lastvert + 1, triangles * 3, GL_UNSIGNED_INT, (unsigned int *)&buf_tri[firsttriangle]);
741 #endif
742 CHECKGLERROR
743         }
744
745         currentmesh = 0;
746         currenttriangle = 0;
747         currentvertex = 0;
748
749         GL_UnlockArray();
750 CHECKGLERROR
751
752         if (backendunits > 1)
753         {
754                 for (i = backendunits - 1;i >= 0;i--)
755                 {
756                         qglActiveTexture(GL_TEXTURE0_ARB + (unit = i));
757 CHECKGLERROR
758                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
759 CHECKGLERROR
760                         if (gl_combine.integer)
761                         {
762                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0f);
763 CHECKGLERROR
764                         }
765                         if (i > 0)
766                         {
767                                 glDisable(GL_TEXTURE_2D);
768 CHECKGLERROR
769                         }
770                         else
771                         {
772                                 glEnable(GL_TEXTURE_2D);
773 CHECKGLERROR
774                         }
775                         glBindTexture(GL_TEXTURE_2D, 0);
776 CHECKGLERROR
777
778                         qglClientActiveTexture(GL_TEXTURE0_ARB + (clientunit = i));
779 CHECKGLERROR
780                         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
781 CHECKGLERROR
782                 }
783         }
784         else
785         {
786                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
787 CHECKGLERROR
788                 glEnable(GL_TEXTURE_2D);
789 CHECKGLERROR
790                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
791 CHECKGLERROR
792         }
793         glDisableClientState(GL_COLOR_ARRAY);
794 CHECKGLERROR
795         glDisableClientState(GL_VERTEX_ARRAY);
796 CHECKGLERROR
797
798         glDisable(GL_BLEND);
799 CHECKGLERROR
800         glEnable(GL_DEPTH_TEST);
801 CHECKGLERROR
802         glDepthMask(true);
803 CHECKGLERROR
804         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
805 CHECKGLERROR
806 }
807
808 void R_Mesh_AddTransparent(void)
809 {
810         if (gl_mesh_sorttransbymesh.integer)
811         {
812                 int i, j, k;
813                 float viewdistcompare, centerscaler, dist1, dist2, dist3, center, maxdist;
814                 buf_vertex_t *vert1, *vert2, *vert3;
815                 buf_transtri_t *tri;
816                 buf_mesh_t *mesh, *transmesh;
817
818                 // process and add transparent mesh triangles
819                 if (!currenttranstriangle)
820                         return;
821
822                 // map farclip to 0-4095 list range
823                 centerscaler = (TRANSDEPTHRES / r_farclip) * (1.0f / 3.0f);
824                 viewdistcompare = viewdist + 4.0f;
825
826                 memset(buf_transtri_list, 0, TRANSDEPTHRES * sizeof(buf_transtri_t *));
827
828                 k = 0;
829                 for (j = 0;j < currenttranstriangle;j++)
830                 {
831                         tri = &buf_transtri[j];
832
833                         vert1 = &buf_transvertex[tri->index[0]];
834                         vert2 = &buf_transvertex[tri->index[1]];
835                         vert3 = &buf_transvertex[tri->index[2]];
836
837                         dist1 = DotProduct(vert1->v, vpn);
838                         dist2 = DotProduct(vert2->v, vpn);
839                         dist3 = DotProduct(vert3->v, vpn);
840
841                         maxdist = max(dist1, max(dist2, dist3));
842                         if (maxdist < viewdistcompare)
843                                 continue;
844
845                         center = (dist1 + dist2 + dist3) * centerscaler - viewdist;
846         #if SLOWMATH
847                         i = (int) center;
848                         i = bound(0, i, (TRANSDEPTHRES - 1));
849         #else
850                         if (center < 0.0f)
851                                 center = 0.0f;
852                         center += 8388608.0f;
853                         i = *((long *)&center) & 0x7FFFFF;
854                         i = min(i, (TRANSDEPTHRES - 1));
855         #endif
856                         tri->next = buf_transtri_list[i];
857                         buf_transtri_list[i] = tri;
858                         k++;
859                 }
860
861                 #ifndef TRANSBATCH
862                 if (currentmesh + k > max_meshs || currenttriangle + k > max_batch || currentvertex + currenttransvertex > max_verts)
863                         R_Mesh_Render();
864
865                 // note: can't batch these because they can be rendered in any order
866                 // there can never be more transparent triangles than fit in main buffers
867                 memcpy(&buf_vertex[currentvertex], &buf_transvertex[0], currenttransvertex * sizeof(buf_vertex_t));
868                 memcpy(&buf_fcolor[currentvertex], &buf_transfcolor[0], currenttransvertex * sizeof(buf_fcolor_t));
869                 for (i = 0;i < backendunits;i++)
870                         memcpy(&buf_texcoord[i][currentvertex], &buf_transtexcoord[i][0], currenttransvertex * sizeof(buf_texcoord_t));
871                 #endif
872
873                 for (i = 0;i < currenttransmesh;i++)
874                 {
875                         buf_transmesh[i].transchain = NULL;
876                         //buf_transmesh[i].transchainpointer = &buf_transmesh[i].transchain;
877                         buf_transmesh[i].triangles = 0;
878                 }
879                 transmesh = NULL;
880                 for (j = 0;j < TRANSDEPTHRES;j++)
881                 {
882                         if ((tri = buf_transtri_list[j]))
883                         {
884                                 for (;tri;tri = tri->next)
885                                 {
886                                         if (!tri->mesh->transchain)
887                                         {
888                                                 tri->mesh->chain = transmesh;
889                                                 transmesh = tri->mesh;
890                                         }
891                                         tri->meshsortchain = tri->mesh->transchain;
892                                         tri->mesh->transchain = tri;
893                                         /*
894                                         *tri->mesh->transchainpointer = tri;
895                                         tri->meshsortchain = NULL;
896                                         tri->mesh->transchainpointer = &tri->meshsortchain;
897                                         */
898                                         tri->mesh->triangles++;
899                                 }
900                         }
901                 }
902
903                 #if TRANSBATCH
904                 for (;transmesh;transmesh = transmesh->chain)
905                 {
906                         int meshvertexadjust;
907                         int numverts = transmesh->lastvert - transmesh->firstvert + 1;
908                         if (currentmesh >= max_meshs || currenttriangle + transmesh->triangles > max_batch || currentvertex + numverts > max_verts)
909                                 R_Mesh_Render();
910
911                         memcpy(&buf_vertex[currentvertex], &buf_transvertex[transmesh->firstvert], numverts * sizeof(buf_vertex_t));
912                         memcpy(&buf_fcolor[currentvertex], &buf_transfcolor[transmesh->firstvert], numverts * sizeof(buf_fcolor_t));
913                         for (i = 0;i < backendunits && transmesh->textures[i];i++)
914                                 memcpy(&buf_texcoord[i][currentvertex], &buf_transtexcoord[i][transmesh->firstvert], numverts * sizeof(buf_texcoord_t));
915
916                         mesh = &buf_mesh[currentmesh++];
917                         *mesh = *transmesh; // copy mesh properties
918                         mesh->firstvert = currentvertex;
919                         mesh->lastvert = currentvertex + numverts - 1;
920                         currentvertex += numverts;
921                         meshvertexadjust = mesh->firstvert - transmesh->firstvert;
922                         mesh->firsttriangle = currenttriangle;
923                         for (tri = transmesh->transchain;tri;tri = tri->meshsortchain)
924                         {
925                                 buf_tri[currenttriangle].index[0] = tri->index[0] + meshvertexadjust;
926                                 buf_tri[currenttriangle].index[1] = tri->index[1] + meshvertexadjust;
927                                 buf_tri[currenttriangle].index[2] = tri->index[2] + meshvertexadjust;
928                                 /*
929                                 if (tri->mesh != transmesh)
930                                         Sys_Error("!?!");
931                                 if ((unsigned int) buf_tri[currenttriangle].index[0] < (unsigned int) mesh->firstvert
932                                  || (unsigned int) buf_tri[currenttriangle].index[0] > (unsigned int) mesh->lastvert
933                                  || (unsigned int) buf_tri[currenttriangle].index[1] < (unsigned int) mesh->firstvert
934                                  || (unsigned int) buf_tri[currenttriangle].index[1] > (unsigned int) mesh->lastvert
935                                  || (unsigned int) buf_tri[currenttriangle].index[2] < (unsigned int) mesh->firstvert
936                                  || (unsigned int) buf_tri[currenttriangle].index[2] > (unsigned int) mesh->lastvert)
937                                         Sys_Error("!?");
938                                 */
939                                 currenttriangle++;
940                         }
941                         /*
942                         if (mesh->triangles != currenttriangle - mesh->firsttriangle)
943                                 Sys_Error("!");
944                         */
945                 }
946                 #else
947                 for (;transmesh;transmesh = transmesh->chain)
948                 {
949                         mesh = &buf_mesh[currentmesh++];
950                         *mesh = *transmesh; // copy mesh properties
951                         mesh->firstvert += currentvertex;
952                         mesh->lastvert += currentvertex;
953                         mesh->firsttriangle = currenttriangle;
954                         for (tri = transmesh->transchain;tri;tri = tri->meshsortchain)
955                         {
956                                 buf_tri[currenttriangle].index[0] = tri->index[0] + currentvertex;
957                                 buf_tri[currenttriangle].index[1] = tri->index[1] + currentvertex;
958                                 buf_tri[currenttriangle].index[2] = tri->index[2] + currentvertex;
959                                 /*
960                                 if (tri->mesh != transmesh)
961                                         Sys_Error("!?!");
962                                 if ((unsigned int) buf_tri[currenttriangle].index[0] < (unsigned int) mesh->firstvert
963                                  || (unsigned int) buf_tri[currenttriangle].index[0] > (unsigned int) mesh->lastvert
964                                  || (unsigned int) buf_tri[currenttriangle].index[1] < (unsigned int) mesh->firstvert
965                                  || (unsigned int) buf_tri[currenttriangle].index[1] > (unsigned int) mesh->lastvert
966                                  || (unsigned int) buf_tri[currenttriangle].index[2] < (unsigned int) mesh->firstvert
967                                  || (unsigned int) buf_tri[currenttriangle].index[2] > (unsigned int) mesh->lastvert)
968                                         Sys_Error("!?");
969                                 */
970                                 currenttriangle++;
971                         }
972                         /*
973                         if (mesh->triangles != currenttriangle - mesh->firsttriangle)
974                                 Sys_Error("!");
975                         */
976                 }
977                 currentvertex += currenttransvertex;
978                 #endif
979
980                 currenttransmesh = 0;
981                 currenttranstriangle = 0;
982                 currenttransvertex = 0;
983         }
984         else if (gl_mesh_dupetransverts.integer)
985         {
986                 int i, j, k, index;
987                 float viewdistcompare, centerscaler, dist1, dist2, dist3, center, maxdist;
988                 buf_vertex_t *vert1, *vert2, *vert3;
989                 buf_transtri_t *tri;
990                 buf_mesh_t *mesh;
991
992                 // process and add transparent mesh triangles
993                 if (!currenttranstriangle)
994                         return;
995
996                 // map farclip to 0-4095 list range
997                 centerscaler = (TRANSDEPTHRES / r_farclip) * (1.0f / 3.0f);
998                 viewdistcompare = viewdist + 4.0f;
999
1000                 memset(buf_transtri_list, 0, TRANSDEPTHRES * sizeof(buf_transtri_t *));
1001
1002                 // process in reverse because transtri_list adding code is in reverse as well
1003                 k = 0;
1004                 for (j = currenttranstriangle - 1;j >= 0;j--)
1005                 {
1006                         tri = &buf_transtri[j];
1007
1008                         vert1 = &buf_transvertex[tri->index[0]];
1009                         vert2 = &buf_transvertex[tri->index[1]];
1010                         vert3 = &buf_transvertex[tri->index[2]];
1011
1012                         dist1 = DotProduct(vert1->v, vpn);
1013                         dist2 = DotProduct(vert2->v, vpn);
1014                         dist3 = DotProduct(vert3->v, vpn);
1015
1016                         maxdist = max(dist1, max(dist2, dist3));
1017                         if (maxdist < viewdistcompare)
1018                                 continue;
1019
1020                         center = (dist1 + dist2 + dist3) * centerscaler - viewdist;
1021         #if SLOWMATH
1022                         i = (int) center;
1023                         i = bound(0, i, (TRANSDEPTHRES - 1));
1024         #else
1025                         if (center < 0.0f)
1026                                 center = 0.0f;
1027                         center += 8388608.0f;
1028                         i = *((long *)&center) & 0x7FFFFF;
1029                         i = min(i, (TRANSDEPTHRES - 1));
1030         #endif
1031                         tri->next = buf_transtri_list[i];
1032                         buf_transtri_list[i] = tri;
1033                         k++;
1034                 }
1035
1036                 if (currentmesh + k > max_meshs || currenttriangle + k > max_batch || currentvertex + k * 3 > max_verts)
1037                         R_Mesh_Render();
1038
1039                 currenttransmesh = 0;
1040                 currenttranstriangle = 0;
1041                 currenttransvertex = 0;
1042
1043                 // note: can't batch these because they can be rendered in any order
1044                 // there can never be more transparent triangles than fit in main buffers
1045                 for (j = TRANSDEPTHRES - 1;j >= 0;j--)
1046                 {
1047                         if ((tri = buf_transtri_list[j]))
1048                         {
1049                                 while(tri)
1050                                 {
1051                                         mesh = &buf_mesh[currentmesh++];
1052                                         *mesh = *tri->mesh; // copy mesh properties
1053                                         mesh->firstvert = currentvertex;
1054                                         mesh->lastvert = currentvertex + 2;
1055                                         mesh->firsttriangle = currenttriangle;
1056                                         mesh->triangles = 1;
1057                                         for (k = 0;k < 3;k++)
1058                                         {
1059                                                 index = tri->index[k];
1060                                                 buf_tri[currenttriangle].index[k] = currentvertex;
1061                                                 memcpy(buf_vertex[currentvertex].v, buf_transvertex[index].v, sizeof(buf_vertex_t));
1062                                                 memcpy(buf_fcolor[currentvertex].c, buf_transfcolor[index].c, sizeof(buf_fcolor_t));
1063                                                 for (i = 0;i < backendunits && tri->mesh->textures[i];i++)
1064                                                         memcpy(buf_texcoord[i][currentvertex].t, buf_transtexcoord[i][index].t, sizeof(buf_texcoord_t));
1065                                                 currentvertex++;
1066                                         }
1067                                         currenttriangle++;
1068                                         tri = tri->next;
1069                                 }
1070                         }
1071                 }
1072         }
1073         else
1074         {
1075                 int i, j, k;
1076                 float viewdistcompare, centerscaler, dist1, dist2, dist3, center, maxdist;
1077                 buf_vertex_t *vert1, *vert2, *vert3;
1078                 buf_transtri_t *tri;
1079                 buf_mesh_t *mesh;
1080
1081                 // process and add transparent mesh triangles
1082                 if (!currenttranstriangle)
1083                         return;
1084
1085                 // map farclip to 0-4095 list range
1086                 centerscaler = (TRANSDEPTHRES / r_farclip) * (1.0f / 3.0f);
1087                 viewdistcompare = viewdist + 4.0f;
1088
1089                 memset(buf_transtri_list, 0, TRANSDEPTHRES * sizeof(buf_transtri_t *));
1090
1091                 // process in reverse because transtri_list adding code is in reverse as well
1092                 k = 0;
1093                 for (j = currenttranstriangle - 1;j >= 0;j--)
1094                 {
1095                         tri = &buf_transtri[j];
1096
1097                         vert1 = &buf_transvertex[tri->index[0]];
1098                         vert2 = &buf_transvertex[tri->index[1]];
1099                         vert3 = &buf_transvertex[tri->index[2]];
1100
1101                         dist1 = DotProduct(vert1->v, vpn);
1102                         dist2 = DotProduct(vert2->v, vpn);
1103                         dist3 = DotProduct(vert3->v, vpn);
1104
1105                         maxdist = max(dist1, max(dist2, dist3));
1106                         if (maxdist < viewdistcompare)
1107                                 continue;
1108
1109                         center = (dist1 + dist2 + dist3) * centerscaler - viewdist;
1110         #if SLOWMATH
1111                         i = (int) center;
1112                         i = bound(0, i, (TRANSDEPTHRES - 1));
1113         #else
1114                         if (center < 0.0f)
1115                                 center = 0.0f;
1116                         center += 8388608.0f;
1117                         i = *((long *)&center) & 0x7FFFFF;
1118                         i = min(i, (TRANSDEPTHRES - 1));
1119         #endif
1120                         tri->next = buf_transtri_list[i];
1121                         buf_transtri_list[i] = tri;
1122                         k++;
1123                 }
1124
1125                 if (currentmesh + k > max_meshs || currenttriangle + k > max_batch || currentvertex + currenttransvertex > max_verts)
1126                         R_Mesh_Render();
1127
1128                 // note: can't batch these because they can be rendered in any order
1129                 // there can never be more transparent triangles than fit in main buffers
1130                 memcpy(&buf_vertex[currentvertex], &buf_transvertex[0], currenttransvertex * sizeof(buf_vertex_t));
1131                 memcpy(&buf_fcolor[currentvertex], &buf_transfcolor[0], currenttransvertex * sizeof(buf_fcolor_t));
1132                 for (i = 0;i < backendunits;i++)
1133                         memcpy(&buf_texcoord[i][currentvertex], &buf_transtexcoord[i][0], currenttransvertex * sizeof(buf_texcoord_t));
1134
1135                 for (j = TRANSDEPTHRES - 1;j >= 0;j--)
1136                 {
1137                         if ((tri = buf_transtri_list[j]))
1138                         {
1139                                 while(tri)
1140                                 {
1141                                         mesh = &buf_mesh[currentmesh++];
1142                                         *mesh = *tri->mesh; // copy mesh properties
1143                                         buf_tri[currenttriangle].index[0] = tri->index[0] + currentvertex;
1144                                         buf_tri[currenttriangle].index[1] = tri->index[1] + currentvertex;
1145                                         buf_tri[currenttriangle].index[2] = tri->index[2] + currentvertex;
1146                                         mesh->firstvert = min(buf_tri[currenttriangle].index[0], min(buf_tri[currenttriangle].index[1], buf_tri[currenttriangle].index[2]));
1147                                         mesh->lastvert = max(buf_tri[currenttriangle].index[0], max(buf_tri[currenttriangle].index[1], buf_tri[currenttriangle].index[2]));
1148                                         mesh->firsttriangle = currenttriangle++;
1149                                         mesh->triangles = 1;
1150                                         tri = tri->next;
1151                                 }
1152                         }
1153                 }
1154                 currentvertex += currenttransvertex;
1155                 currenttransmesh = 0;
1156                 currenttranstriangle = 0;
1157                 currenttransvertex = 0;
1158         }
1159 }
1160
1161 void R_Mesh_Draw(const rmeshinfo_t *m)
1162 {
1163         // these are static because gcc runs out of virtual registers otherwise
1164         static int i, j, *index, overbright;
1165         static float *in, scaler;
1166         static float cr, cg, cb, ca;
1167         static buf_mesh_t *mesh;
1168         static buf_vertex_t *vert;
1169         static buf_fcolor_t *fcolor;
1170         static buf_texcoord_t *texcoord[MAX_TEXTUREUNITS];
1171         static buf_transtri_t *tri;
1172
1173         if (m->index == NULL
1174          || !m->numtriangles
1175          || m->vertex == NULL
1176          || !m->numverts)
1177                 return;
1178         // ignore meaningless alpha meshs
1179         if (!m->depthwrite && m->blendfunc1 == GL_SRC_ALPHA && (m->blendfunc2 == GL_ONE || m->blendfunc2 == GL_ONE_MINUS_SRC_ALPHA))
1180         {
1181                 if (m->color)
1182                 {
1183                         for (i = 0, in = m->color + 3;i < m->numverts;i++, (int)in += m->colorstep)
1184                                 if (*in >= 0.01f)
1185                                         break;
1186                         if (i == m->numverts)
1187                                 return;
1188                 }
1189                 else if (m->ca < 0.01f)
1190                         return;
1191         }
1192
1193         if (!backendactive)
1194                 Sys_Error("R_Mesh_Draw: called when backend is not active\n");
1195
1196         scaler = 1;
1197         if (m->blendfunc2 == GL_SRC_COLOR)
1198         {
1199                 if (m->blendfunc1 == GL_DST_COLOR) // 2x modulate with framebuffer
1200                         scaler *= 0.5f;
1201         }
1202         else
1203         {
1204                 if (m->tex[0])
1205                 {
1206                         overbright = gl_combine.integer;
1207                         if (overbright)
1208                                 scaler *= 0.25f;
1209                 }
1210                 scaler *= overbrightscale;
1211         }
1212
1213         if (m->transparent)
1214         {
1215                 if (currenttransmesh >= max_meshs || (currenttranstriangle + m->numtriangles) > max_meshs || (currenttransvertex + m->numverts) > max_verts)
1216                 {
1217                         if (!transranout)
1218                         {
1219                                 Con_Printf("R_Mesh_Draw: ran out of room for transparent meshs\n");
1220                                 transranout = true;
1221                         }
1222                         return;
1223                 }
1224
1225                 c_transmeshs++;
1226                 c_transtris += m->numtriangles;
1227                 vert = &buf_transvertex[currenttransvertex];
1228                 fcolor = &buf_transfcolor[currenttransvertex];
1229                 for (i = 0;i < backendunits;i++)
1230                         texcoord[i] = &buf_transtexcoord[i][currenttransvertex];
1231
1232                 // transmesh is only for storage of transparent meshs until they
1233                 // are inserted into the main mesh array
1234                 mesh = &buf_transmesh[currenttransmesh++];
1235
1236                 // transparent meshs are broken up into individual triangles which can
1237                 // be sorted by depth
1238                 index = m->index;
1239                 for (i = 0;i < m->numtriangles;i++)
1240                 {
1241                         tri = &buf_transtri[currenttranstriangle++];
1242                         tri->mesh = mesh;
1243                         tri->index[0] = *index++ + currenttransvertex;
1244                         tri->index[1] = *index++ + currenttransvertex;
1245                         tri->index[2] = *index++ + currenttransvertex;
1246                 }
1247
1248                 mesh->firstvert = currenttransvertex;
1249                 mesh->lastvert = currenttransvertex + m->numverts - 1;
1250                 currenttransvertex += m->numverts;
1251         }
1252         else
1253         {
1254                 if (m->numtriangles > max_meshs || m->numverts > max_verts)
1255                 {
1256                         Con_Printf("R_Mesh_Draw: mesh too big for buffers\n");
1257                         return;
1258                 }
1259
1260                 if (currentmesh >= max_meshs || (currenttriangle + m->numtriangles) > max_batch || (currentvertex + m->numverts) > max_verts)
1261                         R_Mesh_Render();
1262
1263                 c_meshs++;
1264                 c_meshtris += m->numtriangles;
1265                 vert = &buf_vertex[currentvertex];
1266                 fcolor = &buf_fcolor[currentvertex];
1267                 for (i = 0;i < backendunits;i++)
1268                         texcoord[i] = &buf_texcoord[i][currentvertex];
1269
1270                 mesh = &buf_mesh[currentmesh++];
1271                 // opaque meshs are rendered directly
1272                 index = (int *)&buf_tri[currenttriangle];
1273                 mesh->firsttriangle = currenttriangle;
1274                 currenttriangle += m->numtriangles;
1275                 for (i = 0;i < m->numtriangles * 3;i++)
1276                         index[i] = m->index[i] + currentvertex;
1277
1278                 mesh->firstvert = currentvertex;
1279                 mesh->lastvert = currentvertex + m->numverts - 1;
1280                 currentvertex += m->numverts;
1281         }
1282
1283         // code shared for transparent and opaque meshs
1284         mesh->blendfunc1 = m->blendfunc1;
1285         mesh->blendfunc2 = m->blendfunc2;
1286         mesh->depthmask = (m->blendfunc2 == GL_ZERO || m->depthwrite);
1287         mesh->depthtest = !m->depthdisable;
1288         mesh->triangles = m->numtriangles;
1289         j = -1;
1290         for (i = 0;i < backendunits;i++)
1291         {
1292                 if ((mesh->textures[i] = m->tex[i]))
1293                         j = i;
1294                 mesh->texturergbscale[i] = m->texrgbscale[i];
1295                 if (mesh->texturergbscale[i] != 1 && mesh->texturergbscale[i] != 2 && mesh->texturergbscale[i] != 4)
1296                         mesh->texturergbscale[i] = 1;
1297         }
1298         if (overbright && j >= 0)
1299                 mesh->texturergbscale[j] = 4;
1300
1301         if (m->vertexstep != sizeof(buf_vertex_t))
1302         {
1303                 for (i = 0, in = m->vertex;i < m->numverts;i++, (int)in += m->vertexstep)
1304                 {
1305                         vert[i].v[0] = in[0];
1306                         vert[i].v[1] = in[1];
1307                         vert[i].v[2] = in[2];
1308                 }
1309         }
1310         else
1311                 memcpy(vert, m->vertex, m->numverts * sizeof(buf_vertex_t));
1312
1313         if (m->color)
1314         {
1315                 for (i = 0, in = m->color;i < m->numverts;i++, (int)in += m->colorstep)
1316                 {
1317                         fcolor[i].c[0] = in[0] * scaler;
1318                         fcolor[i].c[1] = in[1] * scaler;
1319                         fcolor[i].c[2] = in[2] * scaler;
1320                         fcolor[i].c[3] = in[3];
1321                 }
1322         }
1323         else
1324         {
1325                 cr = m->cr * scaler;
1326                 cg = m->cg * scaler;
1327                 cb = m->cb * scaler;
1328                 ca = m->ca;
1329                 for (i = 0;i < m->numverts;i++)
1330                 {
1331                         fcolor[i].c[0] = cr;
1332                         fcolor[i].c[1] = cg;
1333                         fcolor[i].c[2] = cb;
1334                         fcolor[i].c[3] = ca;
1335                 }
1336         }
1337
1338         for (j = 0;j < MAX_TEXTUREUNITS && m->tex[j];j++)
1339         {
1340                 if (j >= backendunits)
1341                         Sys_Error("R_Mesh_Draw: texture %i supplied when there are only %i texture units\n", j + 1, backendunits);
1342                 if (m->texcoordstep[j] != sizeof(buf_texcoord_t))
1343                 {
1344                         for (i = 0, in = m->texcoords[j];i < m->numverts;i++, (int)in += m->texcoordstep[j])
1345                         {
1346                                 texcoord[j][i].t[0] = in[0];
1347                                 texcoord[j][i].t[1] = in[1];
1348                         }
1349                 }
1350                 else
1351                         memcpy(&texcoord[j][0].t[0], m->texcoords[j], m->numverts * sizeof(buf_texcoord_t));
1352         }
1353         #if 0
1354         for (;j < backendunits;j++)
1355                 memset(&texcoord[j][0].t[0], 0, m->numverts * sizeof(buf_texcoord_t));
1356         #endif
1357 }
1358
1359 void R_Mesh_DrawPolygon(rmeshinfo_t *m, int numverts)
1360 {
1361         m->index = polyindexarray;
1362         m->numverts = numverts;
1363         m->numtriangles = numverts - 2;
1364         if (m->numtriangles < 1)
1365         {
1366                 Con_Printf("R_Mesh_DrawPolygon: invalid vertex count\n");
1367                 return;
1368         }
1369         if (m->numtriangles >= 256)
1370         {
1371                 Con_Printf("R_Mesh_DrawPolygon: only up to 256 triangles (258 verts) supported\n");
1372                 return;
1373         }
1374         R_Mesh_Draw(m);
1375 }
1376
1377 // LordHavoc: this thing is evil, but necessary because decals account for so much overhead
1378 void R_Mesh_DrawDecal(const rmeshinfo_t *m)
1379 {
1380         // these are static because gcc runs out of virtual registers otherwise
1381         static int i, *index, overbright;
1382         static float scaler;
1383         static float cr, cg, cb, ca;
1384         static buf_mesh_t *mesh;
1385         static buf_vertex_t *vert;
1386         static buf_fcolor_t *fcolor;
1387         static buf_texcoord_t *texcoord;
1388         static buf_transtri_t *tri;
1389
1390         if (!backendactive)
1391                 Sys_Error("R_Mesh_Draw: called when backend is not active\n");
1392
1393         scaler = 1;
1394         if (m->tex[0])
1395         {
1396                 overbright = gl_combine.integer;
1397                 if (overbright)
1398                         scaler *= 0.25f;
1399         }
1400         scaler *= overbrightscale;
1401
1402         if (m->transparent)
1403         {
1404                 if (currenttransmesh >= max_meshs || (currenttranstriangle + 2) > max_meshs || (currenttransvertex + 4) > max_verts)
1405                 {
1406                         if (!transranout)
1407                         {
1408                                 Con_Printf("R_Mesh_Draw: ran out of room for transparent meshs\n");
1409                                 transranout = true;
1410                         }
1411                         return;
1412                 }
1413
1414                 c_transmeshs++;
1415                 c_transtris += 2;
1416                 vert = &buf_transvertex[currenttransvertex];
1417                 fcolor = &buf_transfcolor[currenttransvertex];
1418                 texcoord = &buf_transtexcoord[0][currenttransvertex];
1419
1420                 // transmesh is only for storage of transparent meshs until they
1421                 // are inserted into the main mesh array
1422                 mesh = &buf_transmesh[currenttransmesh++];
1423                 mesh->blendfunc1 = m->blendfunc1;
1424                 mesh->blendfunc2 = m->blendfunc2;
1425                 mesh->depthmask = false;
1426                 mesh->depthtest = true;
1427                 mesh->triangles = 2;
1428                 mesh->textures[0] = m->tex[0];
1429                 mesh->texturergbscale[0] = overbright ? 4 : 1;
1430                 for (i = 1;i < backendunits;i++)
1431                 {
1432                         mesh->textures[i] = 0;
1433                         mesh->texturergbscale[i] = 1;
1434                 }
1435                 mesh->chain = NULL;
1436
1437                 // transparent meshs are broken up into individual triangles which can
1438                 // be sorted by depth
1439                 index = m->index;
1440                 tri = &buf_transtri[currenttranstriangle++];
1441                 tri->mesh = mesh;
1442                 tri->index[0] = 0 + currenttransvertex;
1443                 tri->index[1] = 1 + currenttransvertex;
1444                 tri->index[2] = 2 + currenttransvertex;
1445                 tri = &buf_transtri[currenttranstriangle++];
1446                 tri->mesh = mesh;
1447                 tri->index[0] = 0 + currenttransvertex;
1448                 tri->index[1] = 2 + currenttransvertex;
1449                 tri->index[2] = 3 + currenttransvertex;
1450
1451                 mesh->firstvert = currenttransvertex;
1452                 mesh->lastvert = currenttransvertex + 3;
1453                 currenttransvertex += 4;
1454         }
1455         else
1456         {
1457                 if (2 > max_meshs || 4 > max_verts)
1458                 {
1459                         Con_Printf("R_Mesh_Draw: mesh too big for buffers\n");
1460                         return;
1461                 }
1462
1463                 if (currentmesh >= max_meshs || (currenttriangle + 2) > max_batch || (currentvertex + 4) > max_verts)
1464                         R_Mesh_Render();
1465
1466                 c_meshs++;
1467                 c_meshtris += 2;
1468                 vert = &buf_vertex[currentvertex];
1469                 fcolor = &buf_fcolor[currentvertex];
1470                 texcoord = &buf_texcoord[0][currentvertex];
1471
1472                 mesh = &buf_mesh[currentmesh++];
1473                 mesh->blendfunc1 = m->blendfunc1;
1474                 mesh->blendfunc2 = m->blendfunc2;
1475                 mesh->depthmask = false;
1476                 mesh->depthtest = !m->depthdisable;
1477                 mesh->firsttriangle = currenttriangle;
1478                 mesh->triangles = 2;
1479                 mesh->textures[0] = m->tex[0];
1480                 mesh->texturergbscale[0] = overbright ? 4 : 1;
1481                 for (i = 1;i < backendunits;i++)
1482                 {
1483                         mesh->textures[i] = 0;
1484                         mesh->texturergbscale[i] = 1;
1485                 }
1486
1487                 // opaque meshs are rendered directly
1488                 index = (int *)&buf_tri[currenttriangle];
1489                 index[0] = 0 + currentvertex;
1490                 index[1] = 1 + currentvertex;
1491                 index[2] = 2 + currentvertex;
1492                 index[3] = 0 + currentvertex;
1493                 index[4] = 2 + currentvertex;
1494                 index[5] = 3 + currentvertex;
1495                 mesh->firstvert = currentvertex;
1496                 mesh->lastvert = currentvertex + 3;
1497                 currenttriangle += 2;
1498                 currentvertex += 4;
1499         }
1500
1501         // buf_vertex_t must match the size of the decal vertex array (or vice versa)
1502         memcpy(vert, m->vertex, 4 * sizeof(buf_vertex_t));
1503
1504         cr = m->cr * scaler;
1505         cg = m->cg * scaler;
1506         cb = m->cb * scaler;
1507         ca = m->ca;
1508         fcolor[0].c[0] = cr;
1509         fcolor[0].c[1] = cg;
1510         fcolor[0].c[2] = cb;
1511         fcolor[0].c[3] = ca;
1512         fcolor[1].c[0] = cr;
1513         fcolor[1].c[1] = cg;
1514         fcolor[1].c[2] = cb;
1515         fcolor[1].c[3] = ca;
1516         fcolor[2].c[0] = cr;
1517         fcolor[2].c[1] = cg;
1518         fcolor[2].c[2] = cb;
1519         fcolor[2].c[3] = ca;
1520         fcolor[3].c[0] = cr;
1521         fcolor[3].c[1] = cg;
1522         fcolor[3].c[2] = cb;
1523         fcolor[3].c[3] = ca;
1524
1525         // buf_texcoord_t must be the same size as the decal texcoord array (or vice versa)
1526         memcpy(&texcoord[0].t[0], m->texcoords[0], 4 * sizeof(buf_texcoord_t));
1527 }
1528
1529 /*
1530 ==============================================================================
1531
1532                                                 SCREEN SHOTS
1533
1534 ==============================================================================
1535 */
1536
1537 float CalcFov (float fov_x, float width, float height);
1538 void R_ClearScreen(void);
1539
1540 void SCR_ScreenShot(char *filename, int x, int y, int width, int height)
1541 {
1542         int i;
1543         byte *buffer;
1544
1545         buffer = Mem_Alloc(tempmempool, width*height*3);
1546         glReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);
1547         CHECKGLERROR
1548
1549         // LordHavoc: compensate for v_overbrightbits when using hardware gamma
1550         if (v_hwgamma.integer)
1551                 for (i = 0;i < width * height * 3;i++)
1552                         buffer[i] <<= v_overbrightbits.integer;
1553
1554         Image_WriteTGARGB_preflipped(filename, width, height, buffer);
1555
1556         Mem_Free(buffer);
1557 }
1558
1559 /*
1560 ==================
1561 SCR_ScreenShot_f
1562 ==================
1563 */
1564 void SCR_ScreenShot_f (void)
1565 {
1566         int i;
1567         char filename[16];
1568         char checkname[MAX_OSPATH];
1569 //
1570 // find a file name to save it to
1571 //
1572         strcpy(filename, "dp0000.tga");
1573
1574         for (i=0 ; i<=9999 ; i++)
1575         {
1576                 filename[2] = (i/1000)%10 + '0';
1577                 filename[3] = (i/ 100)%10 + '0';
1578                 filename[4] = (i/  10)%10 + '0';
1579                 filename[5] = (i/   1)%10 + '0';
1580                 sprintf (checkname, "%s/%s", com_gamedir, filename);
1581                 if (Sys_FileTime(checkname) == -1)
1582                         break;  // file doesn't exist
1583         }
1584         if (i==10000)
1585         {
1586                 Con_Printf ("SCR_ScreenShot_f: Couldn't create a TGA file\n");
1587                 return;
1588         }
1589
1590         SCR_ScreenShot(filename, vid.realx, vid.realy, vid.realwidth, vid.realheight);
1591         Con_Printf ("Wrote %s\n", filename);
1592 }
1593
1594 /*
1595 ===============
1596 R_Envmap_f
1597
1598 Grab six views for environment mapping tests
1599 ===============
1600 */
1601 struct
1602 {
1603         float angles[3];
1604         char *name;
1605 }
1606 envmapinfo[6] =
1607 {
1608         {{  0,   0, 0}, "ft"},
1609         {{  0,  90, 0}, "rt"},
1610         {{  0, 180, 0}, "bk"},
1611         {{  0, 270, 0}, "lf"},
1612         {{-90,  90, 0}, "up"},
1613         {{ 90,  90, 0}, "dn"}
1614 };
1615 static void R_Envmap_f (void)
1616 {
1617         int j, size;
1618         char filename[256], basename[256];
1619
1620         if (Cmd_Argc() != 3)
1621         {
1622                 Con_Printf ("envmap <basename> <size>: save out 6 cubic environment map images, usable with loadsky, note that size must one of 128, 256, 512, or 1024 and can't be bigger than your current resolution\n");
1623                 return;
1624         }
1625
1626         if (!r_render.integer)
1627                 return;
1628
1629         strcpy(basename, Cmd_Argv(1));
1630         size = atoi(Cmd_Argv(2));
1631         if (size != 128 && size != 256 && size != 512 && size != 1024)
1632         {
1633                 Con_Printf("envmap: size must be one of 128, 256, 512, or 1024\n");
1634                 return;
1635         }
1636         if (size > vid.realwidth || size > vid.realheight)
1637         {
1638                 Con_Printf("envmap: your resolution is not big enough to render that size\n");
1639                 return;
1640         }
1641
1642         envmap = true;
1643
1644         r_refdef.x = 0;
1645         r_refdef.y = 0;
1646         r_refdef.width = size;
1647         r_refdef.height = size;
1648
1649         r_refdef.fov_x = 90;
1650         r_refdef.fov_y = 90;
1651
1652         for (j = 0;j < 6;j++)
1653         {
1654                 sprintf(filename, "env/%s%s.tga", basename, envmapinfo[j].name);
1655                 VectorCopy(envmapinfo[j].angles, r_refdef.viewangles);
1656                 R_ClearScreen();
1657                 R_RenderView ();
1658                 SCR_ScreenShot(filename, vid.realx, vid.realy, size, size);
1659         }
1660
1661         envmap = false;
1662 }
1663
1664 //=============================================================================
1665
1666 void R_ClearScreen(void)
1667 {
1668         if (r_render.integer)
1669         {
1670                 glClearColor(0,0,0,0);
1671                 CHECKGLERROR
1672                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // LordHavoc: clear the screen (around the view as well)
1673                 CHECKGLERROR
1674                 if (gl_dither.integer)
1675                         glEnable(GL_DITHER);
1676                 else
1677                         glDisable(GL_DITHER);
1678                 CHECKGLERROR
1679         }
1680 }
1681
1682 /*
1683 ==================
1684 SCR_UpdateScreen
1685
1686 This is called every frame, and can also be called explicitly to flush
1687 text to the screen.
1688 ==================
1689 */
1690 void SCR_UpdateScreen (void)
1691 {
1692         //Mem_CheckSentinelsGlobal();
1693         //R_TimeReport("memtest");
1694
1695         glFinish ();
1696         CHECKGLERROR
1697
1698         VID_Finish ();
1699
1700         R_TimeReport("finish");
1701
1702         if (gl_combine.integer && !gl_combine_extension)
1703                 Cvar_SetValue("gl_combine", 0);
1704
1705         lightscalebit = v_overbrightbits.integer;
1706         if (gl_combine.integer && r_multitexture.integer)
1707                 lightscalebit += 2;
1708
1709         lightscale = 1.0f / (float) (1 << lightscalebit);
1710         overbrightscale = 1.0f / (float) (1 << v_overbrightbits.integer);
1711
1712         R_TimeReport("setup");
1713
1714         R_ClearScreen();
1715
1716         R_TimeReport("clear");
1717
1718         if (scr_conlines < vid.conheight)
1719                 R_RenderView();
1720
1721         // draw 2D stuff
1722         R_DrawQueue();
1723 }