4 cvar_t gl_mesh_maxtriangles = {0, "gl_mesh_maxtriangles", "1024"};
5 cvar_t gl_mesh_transtriangles = {0, "gl_mesh_transtriangles", "16384"};
6 cvar_t gl_mesh_floatcolors = {0, "gl_mesh_floatcolors", "1"};
7 cvar_t gl_mesh_drawmode = {CVAR_SAVE, "gl_mesh_drawmode", "3"};
9 cvar_t r_render = {0, "r_render", "1"};
10 cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1"}; // whether or not to use dithering
11 cvar_t gl_lockarrays = {0, "gl_lockarrays", "1"};
13 // this is used to increase gl_mesh_maxtriangles automatically if a mesh was
14 // too large for the buffers in the previous frame
15 int overflowedverts = 0;
16 // increase transtriangles automatically too
17 int overflowedtransverts = 0;
19 int gl_maxdrawrangeelementsvertices;
20 int gl_maxdrawrangeelementsindices;
25 void GL_PrintError(int errornumber, char *filename, int linenumber)
29 #ifdef GL_INVALID_ENUM
31 Con_Printf("GL_INVALID_ENUM at %s:%i\n", filename, linenumber);
34 #ifdef GL_INVALID_VALUE
35 case GL_INVALID_VALUE:
36 Con_Printf("GL_INVALID_VALUE at %s:%i\n", filename, linenumber);
39 #ifdef GL_INVALID_OPERATION
40 case GL_INVALID_OPERATION:
41 Con_Printf("GL_INVALID_OPERATION at %s:%i\n", filename, linenumber);
44 #ifdef GL_STACK_OVERFLOW
45 case GL_STACK_OVERFLOW:
46 Con_Printf("GL_STACK_OVERFLOW at %s:%i\n", filename, linenumber);
49 #ifdef GL_STACK_UNDERFLOW
50 case GL_STACK_UNDERFLOW:
51 Con_Printf("GL_STACK_UNDERFLOW at %s:%i\n", filename, linenumber);
54 #ifdef GL_OUT_OF_MEMORY
55 case GL_OUT_OF_MEMORY:
56 Con_Printf("GL_OUT_OF_MEMORY at %s:%i\n", filename, linenumber);
59 #ifdef GL_TABLE_TOO_LARGE
60 case GL_TABLE_TOO_LARGE:
61 Con_Printf("GL_TABLE_TOO_LARGE at %s:%i\n", filename, linenumber);
65 Con_Printf("GL UNKNOWN (%i) at %s:%i\n", errornumber, filename, linenumber);
73 int polyindexarray[768];
75 static float viewdist;
76 // sign bits (true if negative) for vpn[] entries, so quick integer compares can be used instead of float compares
77 static int vpnbit0, vpnbit1, vpnbit2;
79 int c_meshs, c_meshtris, c_transmeshs, c_transtris;
83 float overbrightscale;
85 void SCR_ScreenShot_f (void);
88 static int max_transmeshs;
89 static int max_verts; // always max_meshs * 3
90 static int max_transverts; // always max_transmeshs * 3
91 #define TRANSDEPTHRES 4096
93 typedef struct buf_mesh_s
97 int blendfunc1, blendfunc2;
98 int textures[MAX_TEXTUREUNITS];
99 int texturergbscale[MAX_TEXTUREUNITS];
104 struct buf_mesh_s *chain;
105 struct buf_transtri_s *transchain;
109 typedef struct buf_transtri_s
111 struct buf_transtri_s *next;
112 struct buf_transtri_s *meshsortchain;
118 typedef struct buf_tri_s
148 static int currentmesh, currenttriangle, currentvertex, backendunits, backendactive, transranout;
149 static buf_mesh_t *buf_mesh;
150 static buf_tri_t *buf_tri;
151 static buf_vertex_t *buf_vertex;
152 static buf_fcolor_t *buf_fcolor;
153 static buf_bcolor_t *buf_bcolor;
154 static buf_texcoord_t *buf_texcoord[MAX_TEXTUREUNITS];
156 static int currenttransmesh, currenttransvertex, currenttranstriangle;
157 static buf_mesh_t *buf_transmesh;
158 static buf_transtri_t *buf_sorttranstri;
159 static buf_transtri_t **buf_sorttranstri_list;
160 static buf_tri_t *buf_transtri;
161 static buf_vertex_t *buf_transvertex;
162 static buf_fcolor_t *buf_transfcolor;
163 static buf_texcoord_t *buf_transtexcoord[MAX_TEXTUREUNITS];
165 static mempool_t *gl_backend_mempool;
166 static int resizingbuffers = false;
168 static void gl_backend_start(void)
172 qglGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &gl_maxdrawrangeelementsvertices);
173 qglGetIntegerv(GL_MAX_ELEMENTS_INDICES, &gl_maxdrawrangeelementsindices);
175 Con_Printf("OpenGL Backend started with gl_mesh_maxtriangles %i, gl_mesh_transtriangles %i\n", gl_mesh_maxtriangles.integer, gl_mesh_transtriangles.integer);
176 if (qglDrawRangeElements != NULL)
177 Con_Printf("glDrawRangeElements detected (max vertices %i, max indices %i)\n", gl_maxdrawrangeelementsvertices, gl_maxdrawrangeelementsindices);
178 if (strstr(gl_renderer, "3Dfx"))
180 Con_Printf("3Dfx driver detected, forcing gl_mesh_floatcolors to 0 to prevent crashs\n");
181 Cvar_SetValueQuick(&gl_mesh_floatcolors, 0);
185 max_verts = max_meshs * 3;
186 max_transverts = max_transmeshs * 3;
188 if (!gl_backend_mempool)
189 gl_backend_mempool = Mem_AllocPool("GL_Backend");
191 #define BACKENDALLOC(var, count, sizeofstruct, varname)\
193 var = Mem_Alloc(gl_backend_mempool, count * sizeof(sizeofstruct));\
195 Sys_Error("gl_backend_start: unable to allocate memory for %s (%d bytes)\n", (varname), count * sizeof(sizeofstruct));\
196 memset(var, 0, count * sizeof(sizeofstruct));\
199 BACKENDALLOC(buf_mesh, max_meshs, buf_mesh_t, "buf_mesh")
200 BACKENDALLOC(buf_tri, max_meshs, buf_tri_t, "buf_tri")
201 BACKENDALLOC(buf_vertex, max_verts, buf_vertex_t, "buf_vertex")
202 BACKENDALLOC(buf_fcolor, max_verts, buf_fcolor_t, "buf_fcolor")
203 BACKENDALLOC(buf_bcolor, max_verts, buf_bcolor_t, "buf_bcolor")
205 BACKENDALLOC(buf_transmesh, max_transmeshs, buf_mesh_t, "buf_transmesh")
206 BACKENDALLOC(buf_sorttranstri, max_transmeshs, buf_transtri_t, "buf_sorttranstri")
207 BACKENDALLOC(buf_sorttranstri_list, TRANSDEPTHRES, buf_transtri_t *, "buf_sorttranstri_list")
208 BACKENDALLOC(buf_transtri, max_transmeshs, buf_tri_t, "buf_transtri")
209 BACKENDALLOC(buf_transvertex, max_transverts, buf_vertex_t, "buf_vertex")
210 BACKENDALLOC(buf_transfcolor, max_transverts, buf_fcolor_t, "buf_fcolor")
212 for (i = 0;i < MAX_TEXTUREUNITS;i++)
214 // only allocate as many texcoord arrays as we need
215 if (i < gl_textureunits)
217 BACKENDALLOC(buf_texcoord[i], max_verts, buf_texcoord_t, va("buf_texcoord[%d]", i))
218 BACKENDALLOC(buf_transtexcoord[i], max_transverts, buf_texcoord_t, va("buf_transtexcoord[%d]", i))
222 buf_texcoord[i] = NULL;
223 buf_transtexcoord[i] = NULL;
226 backendunits = min(MAX_TEXTUREUNITS, gl_textureunits);
227 backendactive = true;
230 static void gl_backend_shutdown(void)
232 Con_Printf("OpenGL Backend shutting down\n");
235 Mem_EmptyPool(gl_backend_mempool);
237 Mem_FreePool(&gl_backend_mempool);
240 backendactive = false;
243 static void gl_backend_bufferchanges(int init)
245 if (overflowedverts > gl_mesh_maxtriangles.integer * 3)
246 Cvar_SetValueQuick(&gl_mesh_maxtriangles, (int) ((overflowedverts + 2) / 3));
249 if (overflowedtransverts > gl_mesh_transtriangles.integer * 3)
250 Cvar_SetValueQuick(&gl_mesh_transtriangles, (int) ((overflowedtransverts + 2) / 3));
251 overflowedtransverts = 0;
253 if (gl_mesh_drawmode.integer < 0)
254 Cvar_SetValueQuick(&gl_mesh_drawmode, 0);
255 if (gl_mesh_drawmode.integer > 3)
256 Cvar_SetValueQuick(&gl_mesh_drawmode, 3);
258 if (gl_mesh_drawmode.integer >= 3 && qglDrawRangeElements == NULL)
260 // change drawmode 3 to 2 if 3 won't work at all
261 Cvar_SetValueQuick(&gl_mesh_drawmode, 2);
264 // 21760 is (65536 / 3) rounded off to a multiple of 128
265 if (gl_mesh_maxtriangles.integer < 1024)
266 Cvar_SetValueQuick(&gl_mesh_maxtriangles, 1024);
267 if (gl_mesh_maxtriangles.integer > 21760)
268 Cvar_SetValueQuick(&gl_mesh_maxtriangles, 21760);
270 if (gl_mesh_transtriangles.integer < 1024)
271 Cvar_SetValueQuick(&gl_mesh_transtriangles, 1024);
272 if (gl_mesh_transtriangles.integer > 65536)
273 Cvar_SetValueQuick(&gl_mesh_transtriangles, 65536);
275 if (max_meshs != gl_mesh_maxtriangles.integer || max_transmeshs != gl_mesh_transtriangles.integer)
277 max_meshs = gl_mesh_maxtriangles.integer;
278 max_transmeshs = gl_mesh_transtriangles.integer;
282 resizingbuffers = true;
283 gl_backend_shutdown();
285 resizingbuffers = false;
290 static void gl_backend_newmap(void)
294 void gl_backend_init(void)
298 Cvar_RegisterVariable(&r_render);
299 Cvar_RegisterVariable(&gl_dither);
300 Cvar_RegisterVariable(&gl_lockarrays);
302 Cvar_SetValue("r_render", 0);
305 Cvar_RegisterVariable(&gl_mesh_maxtriangles);
306 Cvar_RegisterVariable(&gl_mesh_transtriangles);
307 Cvar_RegisterVariable(&gl_mesh_floatcolors);
308 Cvar_RegisterVariable(&gl_mesh_drawmode);
309 R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap);
310 gl_backend_bufferchanges(true);
311 for (i = 0;i < 256;i++)
313 polyindexarray[i*3+0] = 0;
314 polyindexarray[i*3+1] = i + 1;
315 polyindexarray[i*3+2] = i + 2;
319 int arraylocked = false;
321 void GL_LockArray(int first, int count)
323 if (!arraylocked && gl_supportslockarrays && gl_lockarrays.integer && gl_mesh_drawmode.integer > 0)
325 qglLockArraysEXT(first, count);
331 void GL_UnlockArray(void)
335 qglUnlockArraysEXT();
346 static void GL_SetupFrame (void)
349 double fovx, fovy, zNear, zFar, aspect;
351 if (!r_render.integer)
354 qglDepthFunc (GL_LEQUAL);CHECKGLERROR
357 qglMatrixMode(GL_PROJECTION);CHECKGLERROR
358 qglLoadIdentity ();CHECKGLERROR
360 // y is weird beause OpenGL is bottom to top, we use top to bottom
361 qglViewport(r_refdef.x, vid.realheight - (r_refdef.y + r_refdef.height), r_refdef.width, r_refdef.height);CHECKGLERROR
365 zFar = r_mesh_farclip;
368 fovx = r_refdef.fov_x;
369 fovy = r_refdef.fov_y;
370 aspect = r_refdef.width / r_refdef.height;
373 xmax = zNear * tan(fovx * M_PI / 360.0) * aspect;
374 ymax = zNear * tan(fovy * M_PI / 360.0);
377 qglFrustum(-xmax, xmax, -ymax, ymax, zNear, zFar);CHECKGLERROR
379 qglMatrixMode(GL_MODELVIEW);CHECKGLERROR
380 qglLoadIdentity ();CHECKGLERROR
383 qglRotatef (-90, 1, 0, 0);CHECKGLERROR
384 qglRotatef (90, 0, 0, 1);CHECKGLERROR
386 qglRotatef (-r_refdef.viewangles[2], 1, 0, 0);CHECKGLERROR
387 qglRotatef (-r_refdef.viewangles[0], 0, 1, 0);CHECKGLERROR
388 qglRotatef (-r_refdef.viewangles[1], 0, 0, 1);CHECKGLERROR
390 qglTranslatef (-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);CHECKGLERROR
393 static int mesh_blendfunc1;
394 static int mesh_blendfunc2;
395 static int mesh_blend;
396 static GLboolean mesh_depthmask;
397 static int mesh_depthtest;
398 static int mesh_unit;
399 static int mesh_clientunit;
400 static int mesh_texture[MAX_TEXTUREUNITS];
401 static float mesh_texturergbscale[MAX_TEXTUREUNITS];
403 void GL_SetupTextureState(void)
406 if (backendunits > 1)
408 for (i = 0;i < backendunits;i++)
410 qglActiveTexture(GL_TEXTURE0_ARB + (mesh_unit = i));CHECKGLERROR
411 qglBindTexture(GL_TEXTURE_2D, mesh_texture[i]);CHECKGLERROR
412 if (gl_combine.integer)
414 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);CHECKGLERROR
415 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);CHECKGLERROR
416 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);CHECKGLERROR
417 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);CHECKGLERROR
418 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_CONSTANT_ARB);CHECKGLERROR
419 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);CHECKGLERROR
420 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);CHECKGLERROR
421 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);CHECKGLERROR
422 qglTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);CHECKGLERROR
423 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);CHECKGLERROR
424 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);CHECKGLERROR
425 qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_CONSTANT_ARB);CHECKGLERROR
426 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
427 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
428 qglTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA);CHECKGLERROR
429 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, mesh_texturergbscale[i]);CHECKGLERROR
430 qglTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1);CHECKGLERROR
434 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
438 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
442 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
444 if (gl_mesh_drawmode.integer > 0)
446 qglClientActiveTexture(GL_TEXTURE0_ARB + (mesh_clientunit = i));CHECKGLERROR
447 qglTexCoordPointer(2, GL_FLOAT, sizeof(buf_texcoord_t), buf_texcoord[i]);CHECKGLERROR
450 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
454 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
461 qglBindTexture(GL_TEXTURE_2D, mesh_texture[0]);CHECKGLERROR
462 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
465 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
469 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
471 if (gl_mesh_drawmode.integer > 0)
473 qglTexCoordPointer(2, GL_FLOAT, sizeof(buf_texcoord_t), buf_texcoord[0]);CHECKGLERROR
476 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
480 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
486 // called at beginning of frame
488 void R_Mesh_Start(float farclip)
492 Sys_Error("R_Mesh_Clear: called when backend is not active\n");
496 gl_backend_bufferchanges(false);
501 currenttransmesh = 0;
502 currenttranstriangle = 0;
503 currenttransvertex = 0;
505 r_mesh_farclip = farclip;
506 viewdist = DotProduct(r_origin, vpn);
507 vpnbit0 = vpn[0] < 0;
508 vpnbit1 = vpn[1] < 0;
509 vpnbit2 = vpn[2] < 0;
521 for (i = 0;i < backendunits;i++)
524 mesh_texturergbscale[i] = 1;
527 qglEnable(GL_CULL_FACE);CHECKGLERROR
528 qglCullFace(GL_FRONT);CHECKGLERROR
530 mesh_depthtest = true;
531 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
533 mesh_blendfunc1 = GL_ONE;
534 mesh_blendfunc2 = GL_ZERO;
535 qglBlendFunc(mesh_blendfunc1, mesh_blendfunc2);CHECKGLERROR
538 qglDisable(GL_BLEND);CHECKGLERROR
540 mesh_depthmask = GL_TRUE;
541 qglDepthMask(mesh_depthmask);CHECKGLERROR
544 if (gl_mesh_drawmode.integer > 0)
547 qglVertexPointer(3, GL_FLOAT, sizeof(buf_vertex_t), &buf_vertex[0].v[0]);CHECKGLERROR
548 qglEnableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
549 if (gl_mesh_floatcolors.integer)
551 qglColorPointer(4, GL_FLOAT, sizeof(buf_fcolor_t), &buf_fcolor[0].c[0]);CHECKGLERROR
555 qglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(buf_bcolor_t), &buf_bcolor[0].c[0]);CHECKGLERROR
557 qglEnableClientState(GL_COLOR_ARRAY);CHECKGLERROR
560 GL_SetupTextureState();
563 int gl_backend_rebindtextures;
565 void GL_ConvertColorsFloatToByte(void)
568 // LordHavoc: to avoid problems with aliasing (treating memory as two
569 // different types - exactly what this is doing), these must be volatile
571 volatile int *icolor;
572 volatile float *fcolor;
575 total = currentvertex * 4;
577 // shift float to have 8bit fraction at base of number
578 fcolor = &buf_fcolor->c[0];
579 for (i = 0;i < total;)
581 fcolor[i ] += 32768.0f;
582 fcolor[i + 1] += 32768.0f;
583 fcolor[i + 2] += 32768.0f;
584 fcolor[i + 3] += 32768.0f;
588 // then read as integer and kill float bits...
589 icolor = (int *)&buf_fcolor->c[0];
590 bcolor = &buf_bcolor->c[0];
591 for (i = 0;i < total;)
593 k = icolor[i ] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i ] = (qbyte) k;
594 k = icolor[i + 1] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i + 1] = (qbyte) k;
595 k = icolor[i + 2] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i + 2] = (qbyte) k;
596 k = icolor[i + 3] & 0x7FFFFF;if (k > 255) k = 255;bcolor[i + 3] = (qbyte) k;
601 void GL_MeshState(buf_mesh_t *mesh)
604 if (backendunits > 1)
606 for (i = 0;i < backendunits;i++)
608 if (mesh_texture[i] != mesh->textures[i])
612 qglActiveTexture(GL_TEXTURE0_ARB + (mesh_unit = i));CHECKGLERROR
614 if (mesh_texture[i] == 0)
616 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
617 // have to disable texcoord array on disabled texture
618 // units due to NVIDIA driver bug with
619 // compiled_vertex_array
620 if (mesh_clientunit != i)
622 qglClientActiveTexture(GL_TEXTURE0_ARB + (mesh_clientunit = i));CHECKGLERROR
624 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
626 qglBindTexture(GL_TEXTURE_2D, (mesh_texture[i] = mesh->textures[i]));CHECKGLERROR
627 if (mesh_texture[i] == 0)
629 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
630 // have to disable texcoord array on disabled texture
631 // units due to NVIDIA driver bug with
632 // compiled_vertex_array
633 if (mesh_clientunit != i)
635 qglClientActiveTexture(GL_TEXTURE0_ARB + (mesh_clientunit = i));CHECKGLERROR
637 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
640 if (mesh_texturergbscale[i] != mesh->texturergbscale[i])
644 qglActiveTexture(GL_TEXTURE0_ARB + (mesh_unit = i));CHECKGLERROR
646 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, (mesh_texturergbscale[i] = mesh->texturergbscale[i]));CHECKGLERROR
652 if (mesh_texture[0] != mesh->textures[0])
654 if (mesh_texture[0] == 0)
656 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
657 qglEnableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
659 qglBindTexture(GL_TEXTURE_2D, (mesh_texture[0] = mesh->textures[0]));CHECKGLERROR
660 if (mesh_texture[0] == 0)
662 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
663 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
667 if (mesh_blendfunc1 != mesh->blendfunc1 || mesh_blendfunc2 != mesh->blendfunc2)
669 qglBlendFunc(mesh_blendfunc1 = mesh->blendfunc1, mesh_blendfunc2 = mesh->blendfunc2);CHECKGLERROR
670 if (mesh_blendfunc2 == GL_ZERO)
672 if (mesh_blendfunc1 == GL_ONE)
677 qglDisable(GL_BLEND);CHECKGLERROR
685 qglEnable(GL_BLEND);CHECKGLERROR
694 qglEnable(GL_BLEND);CHECKGLERROR
698 if (mesh_depthtest != mesh->depthtest)
700 mesh_depthtest = mesh->depthtest;
702 qglEnable(GL_DEPTH_TEST);
704 qglDisable(GL_DEPTH_TEST);
706 if (mesh_depthmask != mesh->depthmask)
708 qglDepthMask(mesh_depthmask = mesh->depthmask);CHECKGLERROR
712 void GL_DrawRangeElements(int firstvert, int endvert, int indexcount, GLuint *index)
714 unsigned int i, j, in;
715 if (gl_mesh_drawmode.integer >= 3/* && (endvert - firstvert) <= gl_maxdrawrangeelementsvertices && (indexcount) <= gl_maxdrawrangeelementsindices*/)
717 // GL 1.2 or GL 1.1 with extension
718 qglDrawRangeElements(GL_TRIANGLES, firstvert, endvert, indexcount, GL_UNSIGNED_INT, index);
720 else if (gl_mesh_drawmode.integer >= 2)
723 qglDrawElements(GL_TRIANGLES, indexcount, GL_UNSIGNED_INT, index);
725 else if (gl_mesh_drawmode.integer >= 1)
728 // feed it manually using glArrayElement
729 qglBegin(GL_TRIANGLES);
730 for (i = 0;i < indexcount;i++)
731 qglArrayElement(index[i]);
736 // GL 1.1 but not using vertex arrays - 3dfx glquake minigl driver
738 qglBegin(GL_TRIANGLES);
739 if (mesh_texture[1]) // if the mesh uses multiple textures
741 // the minigl doesn't have this (because it does not have ARB_multitexture)
742 for (i = 0;i < indexcount;i++)
745 qglColor4ub(buf_bcolor[in].c[0], buf_bcolor[in].c[1], buf_bcolor[in].c[2], buf_bcolor[in].c[3]);
746 for (j = 0;j < backendunits;j++)
748 qglMultiTexCoord2f(GL_TEXTURE0_ARB + j, buf_texcoord[j][in].t[0], buf_texcoord[j][in].t[1]);
749 qglVertex3f(buf_vertex[in].v[0], buf_vertex[in].v[1], buf_vertex[in].v[2]);
754 for (i = 0;i < indexcount;i++)
757 qglColor4ub(buf_bcolor[in].c[0], buf_bcolor[in].c[1], buf_bcolor[in].c[2], buf_bcolor[in].c[3]);
759 qglTexCoord2f(buf_texcoord[0][in].t[0], buf_texcoord[0][in].t[1]);
760 qglVertex3f(buf_vertex[in].v[0], buf_vertex[in].v[1], buf_vertex[in].v[2]);
767 // renders mesh buffers, called to flush buffers when full
768 void R_Mesh_Render(void)
774 Sys_Error("R_Mesh_Render: called when backend is not active\n");
779 if (!r_render.integer)
789 // drawmode 0 always uses byte colors
790 if (!gl_mesh_floatcolors.integer || gl_mesh_drawmode.integer <= 0)
791 GL_ConvertColorsFloatToByte();
793 if (gl_backend_rebindtextures)
795 gl_backend_rebindtextures = false;
796 GL_SetupTextureState();
799 GL_MeshState(buf_mesh);
800 GL_LockArray(0, currentvertex);
801 GL_DrawRangeElements(buf_mesh->firstvert, buf_mesh->firstvert + buf_mesh->verts, buf_mesh->triangles * 3, (unsigned int *)&buf_tri[buf_mesh->firsttriangle].index[0]);CHECKGLERROR
803 if (currentmesh >= 2)
805 for (k = 1, mesh = buf_mesh + k;k < currentmesh;k++, mesh++)
808 GL_DrawRangeElements(mesh->firstvert, mesh->firstvert + mesh->verts, mesh->triangles * 3, buf_tri[mesh->firsttriangle].index);CHECKGLERROR
816 GL_UnlockArray();CHECKGLERROR
819 // restores backend state, used when done with 3D rendering
820 void R_Mesh_Finish(void)
823 // flush any queued meshs
827 if (backendunits > 1)
829 for (i = backendunits - 1;i >= 0;i--)
831 qglActiveTexture(GL_TEXTURE0_ARB + i);CHECKGLERROR
832 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
833 if (gl_combine.integer)
835 qglTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1);CHECKGLERROR
839 qglDisable(GL_TEXTURE_2D);CHECKGLERROR
843 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
845 qglBindTexture(GL_TEXTURE_2D, 0);CHECKGLERROR
849 qglClientActiveTexture(GL_TEXTURE0_ARB + i);CHECKGLERROR
850 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
856 qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);CHECKGLERROR
857 qglEnable(GL_TEXTURE_2D);CHECKGLERROR
860 qglDisableClientState(GL_TEXTURE_COORD_ARRAY);CHECKGLERROR
865 qglDisableClientState(GL_COLOR_ARRAY);CHECKGLERROR
866 qglDisableClientState(GL_VERTEX_ARRAY);CHECKGLERROR
869 qglDisable(GL_BLEND);CHECKGLERROR
870 qglEnable(GL_DEPTH_TEST);CHECKGLERROR
871 qglDepthMask(GL_TRUE);CHECKGLERROR
872 qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);CHECKGLERROR
875 void R_Mesh_ClearDepth(void)
877 if (currenttransmesh)
878 R_Mesh_AddTransparent();
882 qglClear(GL_DEPTH_BUFFER_BIT);
883 R_Mesh_Start(r_mesh_farclip);
886 void R_Mesh_AddTransparent(void)
889 float viewdistcompare, centerscaler, dist1, dist2, dist3, center, maxdist;
890 buf_vertex_t *vert1, *vert2, *vert3;
892 buf_mesh_t *mesh, *transmesh;
894 if (!currenttransmesh)
897 // convert index data to transtris for sorting
898 for (j = 0;j < currenttransmesh;j++)
900 mesh = buf_transmesh + j;
901 k = mesh->firsttriangle;
902 index = &buf_transtri[k].index[0];
903 for (i = 0;i < mesh->triangles;i++)
905 tri = &buf_sorttranstri[k++];
907 tri->index[0] = *index++;
908 tri->index[1] = *index++;
909 tri->index[2] = *index++;
913 // map farclip to 0-4095 list range
914 centerscaler = (TRANSDEPTHRES / r_mesh_farclip) * (1.0f / 3.0f);
915 viewdistcompare = viewdist + 4.0f;
917 memset(buf_sorttranstri_list, 0, TRANSDEPTHRES * sizeof(buf_transtri_t *));
920 for (j = 0;j < currenttranstriangle;j++)
922 tri = &buf_sorttranstri[j];
923 i = tri->mesh->firstvert;
925 vert1 = &buf_transvertex[tri->index[0] + i];
926 vert2 = &buf_transvertex[tri->index[1] + i];
927 vert3 = &buf_transvertex[tri->index[2] + i];
929 dist1 = DotProduct(vert1->v, vpn);
930 dist2 = DotProduct(vert2->v, vpn);
931 dist3 = DotProduct(vert3->v, vpn);
933 maxdist = max(dist1, max(dist2, dist3));
934 if (maxdist < viewdistcompare)
937 center = (dist1 + dist2 + dist3) * centerscaler - viewdist;
940 i = bound(0, i, (TRANSDEPTHRES - 1));
944 center += 8388608.0f;
945 i = *((int *)¢er) & 0x7FFFFF;
946 i = min(i, (TRANSDEPTHRES - 1));
948 tri->next = buf_sorttranstri_list[i];
949 buf_sorttranstri_list[i] = tri;
953 for (i = 0;i < currenttransmesh;i++)
954 buf_transmesh[i].transchain = NULL;
956 for (j = 0;j < TRANSDEPTHRES;j++)
958 if ((tri = buf_sorttranstri_list[j]))
960 for (;tri;tri = tri->next)
962 if (!tri->mesh->transchain)
964 tri->mesh->chain = transmesh;
965 transmesh = tri->mesh;
967 tri->meshsortchain = tri->mesh->transchain;
968 tri->mesh->transchain = tri;
974 for (;transmesh;transmesh = transmesh->chain)
976 mesh = &buf_mesh[currentmesh++];
977 *mesh = *transmesh; // copy mesh properties
979 mesh->firstvert = currentvertex;
980 memcpy(&buf_vertex[currentvertex], &buf_transvertex[transmesh->firstvert], transmesh->verts * sizeof(buf_vertex_t));
981 memcpy(&buf_fcolor[currentvertex], &buf_transfcolor[transmesh->firstvert], transmesh->verts * sizeof(buf_fcolor_t));
982 for (i = 0;i < backendunits && transmesh->textures[i];i++)
983 memcpy(&buf_texcoord[i][currentvertex], &buf_transtexcoord[i][transmesh->firstvert], transmesh->verts * sizeof(buf_texcoord_t));
984 currentvertex += mesh->verts;
986 mesh->firsttriangle = currenttriangle;
987 for (tri = transmesh->transchain;tri;tri = tri->meshsortchain)
989 buf_tri[currenttriangle].index[0] = tri->index[0];
990 buf_tri[currenttriangle].index[1] = tri->index[1];
991 buf_tri[currenttriangle].index[2] = tri->index[2];
994 mesh->triangles = currenttriangle - mesh->firsttriangle;
998 currenttransmesh = 0;
999 currenttranstriangle = 0;
1000 currenttransvertex = 0;
1003 void R_Mesh_Draw(const rmeshinfo_t *m)
1005 // these are static because gcc runs out of virtual registers otherwise
1006 static int i, j, overbright, *index;
1007 static float *in, scaler;
1008 static float cr, cg, cb, ca;
1009 static buf_mesh_t *mesh;
1010 static buf_vertex_t *vert;
1011 static buf_fcolor_t *fcolor;
1012 static buf_texcoord_t *texcoord[MAX_TEXTUREUNITS];
1015 Sys_Error("R_Mesh_Draw: called when backend is not active\n");
1017 if (m->index == NULL
1019 || m->vertex == NULL
1021 Host_Error("R_Mesh_Draw: no triangles or verts\n");
1023 // ignore meaningless alpha meshs
1024 if (!m->depthwrite && m->blendfunc1 == GL_SRC_ALPHA && (m->blendfunc2 == GL_ONE || m->blendfunc2 == GL_ONE_MINUS_SRC_ALPHA))
1028 for (i = 0, in = m->color + 3;i < m->numverts;i++, (int)in += m->colorstep)
1031 if (i == m->numverts)
1034 else if (m->ca < 0.01f)
1039 Sys_Error("R_Mesh_Draw: called when backend is not active\n");
1042 for (i = 0;i < m->numtriangles * 3;i++)
1043 if ((unsigned int) m->index[i] >= (unsigned int) m->numverts)
1044 Host_Error("R_Mesh_Draw: invalid index (%i of %i verts)\n", m->index, m->numverts);
1047 // LordHavoc: removed this error condition because with floatcolors 0,
1048 // the 3DFX driver works with very large meshs
1049 // FIXME: we can work around this by falling back on non-array renderer if buffers are too big
1050 //if (m->numtriangles > 1024 || m->numverts > 3072)
1052 // Con_Printf("R_Mesh_Draw: mesh too big for 3DFX drivers, rejected\n");
1056 i = max(m->numtriangles * 3, m->numverts);
1057 if (overflowedverts < i)
1058 overflowedverts = i;
1060 if (m->numtriangles > max_meshs || m->numverts > max_verts)
1062 Con_Printf("R_Mesh_Draw: mesh too big for current gl_mesh_maxtriangles setting, increasing limits\n");
1068 overflowedtransverts += max(m->numtriangles * 3, m->numverts);
1069 if (currenttransmesh >= max_transmeshs || (currenttranstriangle + m->numtriangles) > max_transmeshs || (currenttransvertex + m->numverts) > max_transverts)
1073 Con_Printf("R_Mesh_Draw: ran out of room for transparent meshs\n");
1080 c_transtris += m->numtriangles;
1081 vert = &buf_transvertex[currenttransvertex];
1082 fcolor = &buf_transfcolor[currenttransvertex];
1083 for (i = 0;i < backendunits;i++)
1084 texcoord[i] = &buf_transtexcoord[i][currenttransvertex];
1086 // transmesh is only for storage of transparent meshs until they
1087 // are inserted into the main mesh array
1088 mesh = &buf_transmesh[currenttransmesh++];
1089 mesh->firsttriangle = currenttranstriangle;
1090 mesh->firstvert = currenttransvertex;
1091 index = &buf_transtri[currenttranstriangle].index[0];
1093 currenttranstriangle += m->numtriangles;
1094 currenttransvertex += m->numverts;
1101 Con_Printf("mesh queue not empty, flushing.\n");
1105 c_meshtris += m->numtriangles;
1106 vert = &buf_vertex[currentvertex];
1107 fcolor = &buf_fcolor[currentvertex];
1108 for (i = 0;i < backendunits;i++)
1109 texcoord[i] = &buf_texcoord[i][currentvertex];
1111 // opaque meshs are rendered directly
1112 mesh = &buf_mesh[currentmesh++];
1113 mesh->firsttriangle = currenttriangle;
1114 mesh->firstvert = currentvertex;
1115 index = &buf_tri[currenttriangle].index[0];
1117 currenttriangle += m->numtriangles;
1118 currentvertex += m->numverts;
1121 // code shared for transparent and opaque meshs
1122 memcpy(index, m->index, sizeof(int[3]) * m->numtriangles);
1123 mesh->blendfunc1 = m->blendfunc1;
1124 mesh->blendfunc2 = m->blendfunc2;
1125 mesh->depthmask = (m->blendfunc2 == GL_ZERO || m->depthwrite);
1126 mesh->depthtest = !m->depthdisable;
1127 mesh->triangles = m->numtriangles;
1128 mesh->verts = m->numverts;
1132 if (m->blendfunc1 == GL_DST_COLOR)
1134 // check if it is a 2x modulate with framebuffer
1135 if (m->blendfunc2 == GL_SRC_COLOR)
1138 else if (m->blendfunc2 != GL_SRC_COLOR)
1142 overbright = gl_combine.integer;
1146 scaler *= overbrightscale;
1151 for (i = 0;i < backendunits;i++)
1153 if ((mesh->textures[i] = m->tex[i]))
1155 mesh->texturergbscale[i] = m->texrgbscale[i];
1156 if (mesh->texturergbscale[i] != 1 && mesh->texturergbscale[i] != 2 && mesh->texturergbscale[i] != 4)
1157 mesh->texturergbscale[i] = 1;
1159 if (overbright && j >= 0)
1160 mesh->texturergbscale[j] = 4;
1162 if (m->vertexstep != sizeof(buf_vertex_t))
1164 for (i = 0, in = m->vertex;i < m->numverts;i++, (int)in += m->vertexstep)
1166 vert[i].v[0] = in[0];
1167 vert[i].v[1] = in[1];
1168 vert[i].v[2] = in[2];
1172 memcpy(vert, m->vertex, m->numverts * sizeof(buf_vertex_t));
1176 for (i = 0, in = m->color;i < m->numverts;i++, (int)in += m->colorstep)
1178 fcolor[i].c[0] = in[0] * scaler;
1179 fcolor[i].c[1] = in[1] * scaler;
1180 fcolor[i].c[2] = in[2] * scaler;
1181 fcolor[i].c[3] = in[3];
1186 cr = m->cr * scaler;
1187 cg = m->cg * scaler;
1188 cb = m->cb * scaler;
1190 for (i = 0;i < m->numverts;i++)
1192 fcolor[i].c[0] = cr;
1193 fcolor[i].c[1] = cg;
1194 fcolor[i].c[2] = cb;
1195 fcolor[i].c[3] = ca;
1199 for (j = 0;j < MAX_TEXTUREUNITS && m->tex[j];j++)
1201 if (j >= backendunits)
1202 Sys_Error("R_Mesh_Draw: texture %i supplied when there are only %i texture units\n", j + 1, backendunits);
1203 if (m->texcoordstep[j] != sizeof(buf_texcoord_t))
1205 for (i = 0, in = m->texcoords[j];i < m->numverts;i++, (int)in += m->texcoordstep[j])
1207 texcoord[j][i].t[0] = in[0];
1208 texcoord[j][i].t[1] = in[1];
1212 memcpy(&texcoord[j][0].t[0], m->texcoords[j], m->numverts * sizeof(buf_texcoord_t));
1216 // allocates space in geometry buffers, and fills in pointers to the buffers in passsed struct
1217 // (this is used for very high speed rendering, no copying)
1218 int R_Mesh_Draw_GetBuffer(rmeshbufferinfo_t *m, int wantoverbright)
1220 // these are static because gcc runs out of virtual registers otherwise
1221 int i, j, overbright;
1226 Sys_Error("R_Mesh_Draw: called when backend is not active\n");
1228 if (!m->numtriangles
1230 Host_Error("R_Mesh_Draw: no triangles or verts\n");
1232 // LordHavoc: removed this error condition because with floatcolors 0,
1233 // the 3DFX driver works with very large meshs
1234 // FIXME: we can work around this by falling back on non-array renderer if buffers are too big
1235 //if (m->numtriangles > 1024 || m->numverts > 3072)
1237 // Con_Printf("R_Mesh_Draw_GetBuffer: mesh too big for 3DFX drivers, rejected\n");
1241 i = max(m->numtriangles * 3, m->numverts);
1242 if (overflowedverts < i)
1243 overflowedverts = i;
1245 if (m->numtriangles > max_meshs || m->numverts > max_verts)
1247 Con_Printf("R_Mesh_Draw_GetBuffer: mesh too big for current gl_mesh_maxtriangles setting, increasing limits\n");
1253 overflowedtransverts += max(m->numtriangles * 3, m->numverts);
1254 if (currenttransmesh >= max_transmeshs || (currenttranstriangle + m->numtriangles) > max_transmeshs || (currenttransvertex + m->numverts) > max_transverts)
1258 Con_Printf("R_Mesh_Draw: ran out of room for transparent meshs\n");
1265 c_transtris += m->numtriangles;
1266 m->index = &buf_transtri[currenttranstriangle].index[0];
1267 m->vertex = &buf_transvertex[currenttransvertex].v[0];
1268 m->color = &buf_transfcolor[currenttransvertex].c[0];
1269 for (i = 0;i < backendunits;i++)
1270 m->texcoords[i] = &buf_transtexcoord[i][currenttransvertex].t[0];
1272 // transmesh is only for storage of transparent meshs until they
1273 // are inserted into the main mesh array
1274 mesh = &buf_transmesh[currenttransmesh++];
1275 mesh->firsttriangle = currenttranstriangle;
1276 mesh->firstvert = currenttransvertex;
1277 currenttranstriangle += m->numtriangles;
1278 currenttransvertex += m->numverts;
1285 Con_Printf("mesh queue not empty, flushing.\n");
1289 c_meshtris += m->numtriangles;
1290 m->index = &buf_tri[currenttriangle].index[0];
1291 m->vertex = &buf_vertex[currentvertex].v[0];
1292 m->color = &buf_fcolor[currentvertex].c[0];
1293 for (i = 0;i < backendunits;i++)
1294 m->texcoords[i] = &buf_texcoord[i][currentvertex].t[0];
1296 // opaque meshs are rendered directly
1297 mesh = &buf_mesh[currentmesh++];
1298 mesh->firsttriangle = currenttriangle;
1299 mesh->firstvert = currentvertex;
1300 currenttriangle += m->numtriangles;
1301 currentvertex += m->numverts;
1304 // code shared for transparent and opaque meshs
1305 mesh->blendfunc1 = m->blendfunc1;
1306 mesh->blendfunc2 = m->blendfunc2;
1307 mesh->depthmask = (m->blendfunc2 == GL_ZERO || m->depthwrite);
1308 mesh->depthtest = !m->depthdisable;
1309 mesh->triangles = m->numtriangles;
1310 mesh->verts = m->numverts;
1314 if (m->blendfunc1 == GL_DST_COLOR)
1316 // check if it is a 2x modulate with framebuffer
1317 if (m->blendfunc2 == GL_SRC_COLOR)
1320 else if (m->blendfunc2 != GL_SRC_COLOR)
1324 overbright = wantoverbright && gl_combine.integer;
1328 scaler *= overbrightscale;
1330 m->colorscale = scaler;
1333 for (i = 0;i < MAX_TEXTUREUNITS;i++)
1335 if ((mesh->textures[i] = m->tex[i]))
1338 if (i >= backendunits)
1339 Sys_Error("R_Mesh_Draw_GetBuffer: texture %i supplied when there are only %i texture units\n", j + 1, backendunits);
1341 mesh->texturergbscale[i] = m->texrgbscale[i];
1342 if (mesh->texturergbscale[i] != 1 && mesh->texturergbscale[i] != 2 && mesh->texturergbscale[i] != 4)
1343 mesh->texturergbscale[i] = 1;
1345 if (overbright && j >= 0)
1346 mesh->texturergbscale[j] = 4;
1351 void R_Mesh_DrawPolygon(rmeshinfo_t *m, int numverts)
1353 m->index = polyindexarray;
1354 m->numverts = numverts;
1355 m->numtriangles = numverts - 2;
1356 if (m->numtriangles < 1)
1358 Con_Printf("R_Mesh_DrawPolygon: invalid vertex count\n");
1361 if (m->numtriangles >= 256)
1363 Con_Printf("R_Mesh_DrawPolygon: only up to 256 triangles (258 verts) supported\n");
1370 ==============================================================================
1374 ==============================================================================
1377 qboolean SCR_ScreenShot(char *filename, int x, int y, int width, int height)
1383 if (!r_render.integer)
1386 buffer = Mem_Alloc(tempmempool, width*height*3);
1387 qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);
1390 // LordHavoc: compensate for v_overbrightbits when using hardware gamma
1391 if (v_hwgamma.integer)
1392 for (i = 0;i < width * height * 3;i++)
1393 buffer[i] <<= v_overbrightbits.integer;
1395 ret = Image_WriteTGARGB_preflipped(filename, width, height, buffer);
1401 //=============================================================================
1403 void R_ClearScreen(void)
1405 if (r_render.integer)
1408 qglClearColor(0,0,0,0);CHECKGLERROR
1410 qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);CHECKGLERROR
1411 // set dithering mode
1412 if (gl_dither.integer)
1414 qglEnable(GL_DITHER);CHECKGLERROR
1418 qglDisable(GL_DITHER);CHECKGLERROR
1427 This is called every frame, and can also be called explicitly to flush
1431 void SCR_UpdateScreen (void)
1435 R_TimeReport("finish");
1437 if (r_textureunits.integer > gl_textureunits)
1438 Cvar_SetValueQuick(&r_textureunits, gl_textureunits);
1439 if (r_textureunits.integer < 1)
1440 Cvar_SetValueQuick(&r_textureunits, 1);
1442 if (gl_combine.integer && (!gl_combine_extension || r_textureunits.integer < 2))
1443 Cvar_SetValueQuick(&gl_combine, 0);
1446 overbrightscale = 1.0f / (float) (1 << v_overbrightbits.integer);
1449 lightscalebit = v_overbrightbits.integer;
1450 if (gl_combine.integer && r_textureunits.integer > 1)
1452 lightscale = 1.0f / (float) (1 << lightscalebit);
1454 R_TimeReport("setup");
1458 R_TimeReport("clear");
1460 if (scr_conlines < vid.conheight)
1466 // tell driver to commit it's partially full geometry queue to the rendering queue
1467 // (this doesn't wait for the commands themselves to complete)