2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 // used for dlight push checking and other things
31 matrix4x4_t r_identitymatrix;
33 int c_alias_polys, c_light_polys, c_faces, c_nodes, c_leafs, c_models, c_bmodels, c_sprites, c_particles, c_dlights, c_meshs, c_meshelements, c_rt_lights, c_rt_clears, c_rt_scissored, c_rt_shadowmeshes, c_rt_shadowtris, c_rt_lightmeshes, c_rt_lighttris, c_rtcached_shadowmeshes, c_rtcached_shadowtris, c_bloom, c_bloomcopies, c_bloomcopypixels, c_bloomdraws, c_bloomdrawpixels;
35 // true during envmap command capture
38 // maximum visible distance (recalculated from world box each frame)
40 // brightness of world lightmaps and related lighting
41 // (often reduced when world rtlights are enabled)
42 float r_lightmapintensity;
43 // whether to draw world lights realtime, dlights realtime, and their shadows
45 qboolean r_rtworldshadows;
47 qboolean r_rtdlightshadows;
50 // forces all rendering to draw triangle outlines
67 matrix4x4_t r_view_matrix;
74 // 8.8 fraction of base light value
75 unsigned short d_lightstylevalue[256];
77 cvar_t r_showtris = {0, "r_showtris", "0"};
78 cvar_t r_drawentities = {0, "r_drawentities","1"};
79 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1"};
80 cvar_t r_speeds = {0, "r_speeds","0"};
81 cvar_t r_fullbright = {0, "r_fullbright","0"};
82 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1"};
83 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1"};
84 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1"};
85 cvar_t r_drawcollisionbrushes = {0, "r_drawcollisionbrushes", "0"};
87 cvar_t gl_fogenable = {0, "gl_fogenable", "0"};
88 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25"};
89 cvar_t gl_fogred = {0, "gl_fogred","0.3"};
90 cvar_t gl_foggreen = {0, "gl_foggreen","0.3"};
91 cvar_t gl_fogblue = {0, "gl_fogblue","0.3"};
92 cvar_t gl_fogstart = {0, "gl_fogstart", "0"};
93 cvar_t gl_fogend = {0, "gl_fogend","0"};
95 cvar_t r_textureunits = {0, "r_textureunits", "32"};
97 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1"};
98 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1"};
99 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1"};
101 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0"};
102 cvar_t r_bloom_intensity = {CVAR_SAVE, "r_bloom_intensity", "2"};
103 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "8"};
104 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320"};
105 cvar_t r_bloom_power = {CVAR_SAVE, "r_bloom_power", "4"};
107 cvar_t r_smoothnormals_areaweighting = {0, "r_smoothnormals_areaweighting", "1"};
109 cvar_t developer_texturelogging = {0, "developer_texturelogging", "0"};
111 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0"};
113 cvar_t r_test = {0, "r_test", "0"}; // used for testing renderer code changes, otherwise does nothing
115 rtexturepool_t *r_main_texturepool;
116 rtexture_t *r_bloom_texture_screen;
117 rtexture_t *r_bloom_texture_bloom;
118 rtexture_t *r_texture_blanknormalmap;
119 rtexture_t *r_texture_white;
120 rtexture_t *r_texture_black;
121 rtexture_t *r_texture_notexture;
122 rtexture_t *r_texture_whitecube;
123 rtexture_t *r_texture_normalizationcube;
125 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
128 for (i = 0;i < verts;i++)
139 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
142 for (i = 0;i < verts;i++)
154 float fog_density, fog_red, fog_green, fog_blue;
156 qboolean oldgl_fogenable;
157 void R_UpdateFog(void)
159 if (gamemode == GAME_NEHAHRA)
161 if (gl_fogenable.integer)
163 oldgl_fogenable = true;
164 fog_density = gl_fogdensity.value;
165 fog_red = gl_fogred.value;
166 fog_green = gl_foggreen.value;
167 fog_blue = gl_fogblue.value;
169 else if (oldgl_fogenable)
171 oldgl_fogenable = false;
180 fogcolor[0] = fog_red = bound(0.0f, fog_red , 1.0f);
181 fogcolor[1] = fog_green = bound(0.0f, fog_green, 1.0f);
182 fogcolor[2] = fog_blue = bound(0.0f, fog_blue , 1.0f);
187 fogdensity = -4000.0f / (fog_density * fog_density);
188 // fog color was already set
194 // FIXME: move this to client?
197 if (gamemode == GAME_NEHAHRA)
199 Cvar_Set("gl_fogenable", "0");
200 Cvar_Set("gl_fogdensity", "0.2");
201 Cvar_Set("gl_fogred", "0.3");
202 Cvar_Set("gl_foggreen", "0.3");
203 Cvar_Set("gl_fogblue", "0.3");
205 fog_density = fog_red = fog_green = fog_blue = 0.0f;
208 // FIXME: move this to client?
209 void FOG_registercvars(void)
211 if (gamemode == GAME_NEHAHRA)
213 Cvar_RegisterVariable (&gl_fogenable);
214 Cvar_RegisterVariable (&gl_fogdensity);
215 Cvar_RegisterVariable (&gl_fogred);
216 Cvar_RegisterVariable (&gl_foggreen);
217 Cvar_RegisterVariable (&gl_fogblue);
218 Cvar_RegisterVariable (&gl_fogstart);
219 Cvar_RegisterVariable (&gl_fogend);
223 static void R_BuildBlankTextures(void)
226 data[0] = 128; // normal X
227 data[1] = 128; // normal Y
228 data[2] = 255; // normal Z
229 data[3] = 128; // height
230 r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
235 r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
240 r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
243 static void R_BuildNoTexture(void)
246 qbyte pix[16][16][4];
247 // this makes a light grey/dark grey checkerboard texture
248 for (y = 0;y < 16;y++)
250 for (x = 0;x < 16;x++)
252 if ((y < 8) ^ (x < 8))
268 r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_RGBA, TEXF_MIPMAP, NULL);
271 static void R_BuildWhiteCube(void)
274 data[ 0] = 255;data[ 1] = 255;data[ 2] = 255;data[ 3] = 255;
275 data[ 4] = 255;data[ 5] = 255;data[ 6] = 255;data[ 7] = 255;
276 data[ 8] = 255;data[ 9] = 255;data[10] = 255;data[11] = 255;
277 data[12] = 255;data[13] = 255;data[14] = 255;data[15] = 255;
278 data[16] = 255;data[17] = 255;data[18] = 255;data[19] = 255;
279 data[20] = 255;data[21] = 255;data[22] = 255;data[23] = 255;
280 r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
283 static void R_BuildNormalizationCube(void)
287 vec_t s, t, intensity;
289 qbyte data[6][NORMSIZE][NORMSIZE][4];
290 for (side = 0;side < 6;side++)
292 for (y = 0;y < NORMSIZE;y++)
294 for (x = 0;x < NORMSIZE;x++)
296 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
297 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
331 intensity = 127.0f / sqrt(DotProduct(v, v));
332 data[side][y][x][0] = 128.0f + intensity * v[0];
333 data[side][y][x][1] = 128.0f + intensity * v[1];
334 data[side][y][x][2] = 128.0f + intensity * v[2];
335 data[side][y][x][3] = 255;
339 r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
342 void gl_main_start(void)
344 r_main_texturepool = R_AllocTexturePool();
345 r_bloom_texture_screen = NULL;
346 r_bloom_texture_bloom = NULL;
347 R_BuildBlankTextures();
349 if (gl_texturecubemap)
352 R_BuildNormalizationCube();
356 void gl_main_shutdown(void)
358 R_FreeTexturePool(&r_main_texturepool);
359 r_bloom_texture_screen = NULL;
360 r_bloom_texture_bloom = NULL;
361 r_texture_blanknormalmap = NULL;
362 r_texture_white = NULL;
363 r_texture_black = NULL;
364 r_texture_whitecube = NULL;
365 r_texture_normalizationcube = NULL;
368 extern void CL_ParseEntityLump(char *entitystring);
369 void gl_main_newmap(void)
371 // FIXME: move this code to client
373 char *entities, entname[MAX_QPATH];
377 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
378 l = (int)strlen(entname) - 4;
379 if (l >= 0 && !strcmp(entname + l, ".bsp"))
381 strcpy(entname + l, ".ent");
382 if ((entities = FS_LoadFile(entname, tempmempool, true)))
384 CL_ParseEntityLump(entities);
389 if (cl.worldmodel->brush.entities)
390 CL_ParseEntityLump(cl.worldmodel->brush.entities);
394 void GL_Main_Init(void)
396 Matrix4x4_CreateIdentity(&r_identitymatrix);
397 // FIXME: move this to client?
399 Cvar_RegisterVariable(&r_showtris);
400 Cvar_RegisterVariable(&r_drawentities);
401 Cvar_RegisterVariable(&r_drawviewmodel);
402 Cvar_RegisterVariable(&r_speeds);
403 Cvar_RegisterVariable(&r_fullbrights);
404 Cvar_RegisterVariable(&r_wateralpha);
405 Cvar_RegisterVariable(&r_dynamic);
406 Cvar_RegisterVariable(&r_fullbright);
407 Cvar_RegisterVariable(&r_textureunits);
408 Cvar_RegisterVariable(&r_lerpsprites);
409 Cvar_RegisterVariable(&r_lerpmodels);
410 Cvar_RegisterVariable(&r_waterscroll);
411 Cvar_RegisterVariable(&r_drawcollisionbrushes);
412 Cvar_RegisterVariable(&r_bloom);
413 Cvar_RegisterVariable(&r_bloom_intensity);
414 Cvar_RegisterVariable(&r_bloom_blur);
415 Cvar_RegisterVariable(&r_bloom_resolution);
416 Cvar_RegisterVariable(&r_bloom_power);
417 Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
418 Cvar_RegisterVariable(&developer_texturelogging);
419 Cvar_RegisterVariable(&gl_lightmaps);
420 Cvar_RegisterVariable(&r_test);
421 if (gamemode == GAME_NEHAHRA || gamemode == GAME_NEXUIZ || gamemode == GAME_TENEBRAE)
422 Cvar_SetValue("r_fullbrights", 0);
423 R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
426 static vec3_t r_farclip_origin;
427 static vec3_t r_farclip_direction;
428 static vec_t r_farclip_directiondist;
429 static vec_t r_farclip_meshfarclip;
430 static int r_farclip_directionbit0;
431 static int r_farclip_directionbit1;
432 static int r_farclip_directionbit2;
434 // enlarge farclip to accomodate box
435 static void R_FarClip_Box(vec3_t mins, vec3_t maxs)
438 d = (r_farclip_directionbit0 ? mins[0] : maxs[0]) * r_farclip_direction[0]
439 + (r_farclip_directionbit1 ? mins[1] : maxs[1]) * r_farclip_direction[1]
440 + (r_farclip_directionbit2 ? mins[2] : maxs[2]) * r_farclip_direction[2];
441 if (r_farclip_meshfarclip < d)
442 r_farclip_meshfarclip = d;
445 // return farclip value
446 static float R_FarClip(vec3_t origin, vec3_t direction, vec_t startfarclip)
450 VectorCopy(origin, r_farclip_origin);
451 VectorCopy(direction, r_farclip_direction);
452 r_farclip_directiondist = DotProduct(r_farclip_origin, r_farclip_direction);
453 r_farclip_directionbit0 = r_farclip_direction[0] < 0;
454 r_farclip_directionbit1 = r_farclip_direction[1] < 0;
455 r_farclip_directionbit2 = r_farclip_direction[2] < 0;
456 r_farclip_meshfarclip = r_farclip_directiondist + startfarclip;
458 if (r_refdef.worldmodel)
459 R_FarClip_Box(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
460 for (i = 0;i < r_refdef.numentities;i++)
461 R_FarClip_Box(r_refdef.entities[i]->mins, r_refdef.entities[i]->maxs);
463 return r_farclip_meshfarclip - r_farclip_directiondist;
466 extern void R_Textures_Init(void);
467 extern void GL_Draw_Init(void);
468 extern void GL_Main_Init(void);
469 extern void R_Shadow_Init(void);
470 extern void R_Sky_Init(void);
471 extern void GL_Surf_Init(void);
472 extern void R_Crosshairs_Init(void);
473 extern void R_Light_Init(void);
474 extern void R_Particles_Init(void);
475 extern void R_Explosion_Init(void);
476 extern void gl_backend_init(void);
477 extern void Sbar_Init(void);
478 extern void R_LightningBeams_Init(void);
479 extern void Mod_RenderInit(void);
481 void Render_Init(void)
497 R_LightningBeams_Init();
506 extern char *ENGINE_EXTENSIONS;
509 VID_CheckExtensions();
511 // LordHavoc: report supported extensions
512 Con_DPrintf("\nengine extensions: %s\n", vm_sv_extensions );
514 // clear to black (loading plaque will be seen over this)
515 qglClearColor(0,0,0,1);
516 qglClear(GL_COLOR_BUFFER_BIT);
519 int R_CullBox(const vec3_t mins, const vec3_t maxs)
523 for (i = 0;i < 4;i++)
530 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
534 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
538 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
542 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
546 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
550 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
554 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
558 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
566 //==================================================================================
568 static void R_MarkEntities (void)
571 entity_render_t *ent;
573 if (!r_drawentities.integer)
576 r_refdef.worldentity->visframe = r_framecount;
577 renderimask = envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : (chase_active.integer ? 0 : RENDER_EXTERIORMODEL);
578 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
580 // worldmodel can check visibility
581 for (i = 0;i < r_refdef.numentities;i++)
583 ent = r_refdef.entities[i];
584 Mod_CheckLoaded(ent->model);
585 // some of the renderer still relies on origin...
586 Matrix4x4_OriginFromMatrix(&ent->matrix, ent->origin);
587 // some of the renderer still relies on scale...
588 ent->scale = Matrix4x4_ScaleFromMatrix(&ent->matrix);
589 if (!(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && ((ent->effects & EF_NODEPTHTEST) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_worldleafvisible, ent->mins, ent->maxs)))
591 R_UpdateEntLights(ent);
592 ent->visframe = r_framecount;
598 // no worldmodel or it can't check visibility
599 for (i = 0;i < r_refdef.numentities;i++)
601 ent = r_refdef.entities[i];
602 Mod_CheckLoaded(ent->model);
603 // some of the renderer still relies on origin...
604 Matrix4x4_OriginFromMatrix(&ent->matrix, ent->origin);
605 // some of the renderer still relies on scale...
606 ent->scale = Matrix4x4_ScaleFromMatrix(&ent->matrix);
607 if (!(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && (ent->effects & EF_NODEPTHTEST))
609 R_UpdateEntLights(ent);
610 ent->visframe = r_framecount;
616 // only used if skyrendermasked, and normally returns false
617 int R_DrawBrushModelsSky (void)
620 entity_render_t *ent;
622 if (!r_drawentities.integer)
626 for (i = 0;i < r_refdef.numentities;i++)
628 ent = r_refdef.entities[i];
629 if (ent->visframe == r_framecount && ent->model && ent->model->DrawSky)
631 ent->model->DrawSky(ent);
638 void R_DrawNoModel(entity_render_t *ent);
639 void R_DrawModels(void)
642 entity_render_t *ent;
644 if (!r_drawentities.integer)
647 for (i = 0;i < r_refdef.numentities;i++)
649 ent = r_refdef.entities[i];
650 if (ent->visframe == r_framecount)
652 if (ent->model && ent->model->Draw != NULL)
653 ent->model->Draw(ent);
660 static void R_SetFrustum(void)
662 // break apart the view matrix into vectors for various purposes
663 Matrix4x4_ToVectors(&r_view_matrix, r_viewforward, r_viewleft, r_viewup, r_vieworigin);
664 VectorNegate(r_viewleft, r_viewright);
666 // LordHavoc: note to all quake engine coders, the special case for 90
667 // degrees assumed a square view (wrong), so I removed it, Quake2 has it
670 // rotate R_VIEWFORWARD right by FOV_X/2 degrees
671 RotatePointAroundVector( frustum[0].normal, r_viewup, r_viewforward, -(90 - r_view_fov_x / 2));
672 frustum[0].dist = DotProduct (r_vieworigin, frustum[0].normal);
673 PlaneClassify(&frustum[0]);
675 // rotate R_VIEWFORWARD left by FOV_X/2 degrees
676 RotatePointAroundVector( frustum[1].normal, r_viewup, r_viewforward, (90 - r_view_fov_x / 2));
677 frustum[1].dist = DotProduct (r_vieworigin, frustum[1].normal);
678 PlaneClassify(&frustum[1]);
680 // rotate R_VIEWFORWARD up by FOV_X/2 degrees
681 RotatePointAroundVector( frustum[2].normal, r_viewleft, r_viewforward, -(90 - r_view_fov_y / 2));
682 frustum[2].dist = DotProduct (r_vieworigin, frustum[2].normal);
683 PlaneClassify(&frustum[2]);
685 // rotate R_VIEWFORWARD down by FOV_X/2 degrees
686 RotatePointAroundVector( frustum[3].normal, r_viewleft, r_viewforward, (90 - r_view_fov_y / 2));
687 frustum[3].dist = DotProduct (r_vieworigin, frustum[3].normal);
688 PlaneClassify(&frustum[3]);
691 VectorCopy(r_viewforward, frustum[4].normal);
692 frustum[4].dist = DotProduct (r_vieworigin, frustum[4].normal) + 1.0f;
693 PlaneClassify(&frustum[4]);
696 static void R_BlendView(void)
700 if (r_refdef.viewblend[3] < 0.01f && !r_bloom.integer)
703 GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
706 R_Mesh_Matrix(&r_identitymatrix);
707 // vertex coordinates for a quad that covers the screen exactly
708 varray_vertex3f[0] = 0;varray_vertex3f[1] = 0;varray_vertex3f[2] = 0;
709 varray_vertex3f[3] = 1;varray_vertex3f[4] = 0;varray_vertex3f[5] = 0;
710 varray_vertex3f[6] = 1;varray_vertex3f[7] = 1;varray_vertex3f[8] = 0;
711 varray_vertex3f[9] = 0;varray_vertex3f[10] = 1;varray_vertex3f[11] = 0;
712 if (r_bloom.integer && r_bloom_resolution.value >= 32 && r_bloom_power.integer >= 1 && r_bloom_power.integer < 100 && r_bloom_blur.value >= 0 && r_bloom_blur.value < 512)
714 int screenwidth, screenheight, bloomwidth, bloomheight, x, dobloomblend, range;
715 float xoffset, yoffset, r;
717 // set the (poorly named) screenwidth and screenheight variables to
718 // a power of 2 at least as large as the screen, these will define the
719 // size of the texture to allocate
720 for (screenwidth = 1;screenwidth < vid.width;screenwidth *= 2);
721 for (screenheight = 1;screenheight < vid.height;screenheight *= 2);
722 // allocate textures as needed
723 if (!r_bloom_texture_screen)
724 r_bloom_texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
725 if (!r_bloom_texture_bloom)
726 r_bloom_texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
727 // set bloomwidth and bloomheight to the bloom resolution that will be
728 // used (often less than the screen resolution for faster rendering)
729 bloomwidth = min(r_view_width, r_bloom_resolution.integer);
730 bloomheight = min(r_view_height, bloomwidth * r_view_height / r_view_width);
731 // set up a texcoord array for the full resolution screen image
732 // (we have to keep this around to copy back during final render)
733 varray_texcoord2f[0][0] = 0;
734 varray_texcoord2f[0][1] = (float)r_view_height / (float)screenheight;
735 varray_texcoord2f[0][2] = (float)r_view_width / (float)screenwidth;
736 varray_texcoord2f[0][3] = (float)r_view_height / (float)screenheight;
737 varray_texcoord2f[0][4] = (float)r_view_width / (float)screenwidth;
738 varray_texcoord2f[0][5] = 0;
739 varray_texcoord2f[0][6] = 0;
740 varray_texcoord2f[0][7] = 0;
741 // set up a texcoord array for the reduced resolution bloom image
742 // (which will be additive blended over the screen image)
743 varray_texcoord2f[1][0] = 0;
744 varray_texcoord2f[1][1] = (float)bloomheight / (float)screenheight;
745 varray_texcoord2f[1][2] = (float)bloomwidth / (float)screenwidth;
746 varray_texcoord2f[1][3] = (float)bloomheight / (float)screenheight;
747 varray_texcoord2f[1][4] = (float)bloomwidth / (float)screenwidth;
748 varray_texcoord2f[1][5] = 0;
749 varray_texcoord2f[1][6] = 0;
750 varray_texcoord2f[1][7] = 0;
751 memset(&m, 0, sizeof(m));
752 m.pointer_vertex = varray_vertex3f;
753 m.pointer_texcoord[0] = varray_texcoord2f[0];
754 m.tex[0] = R_GetTexture(r_bloom_texture_screen);
756 // copy view into the full resolution screen image texture
758 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + r_view_height), r_view_width, r_view_height);
760 c_bloomcopypixels += r_view_width * r_view_height;
761 // now scale it down to the bloom size and raise to a power of itself
762 // to darken it (this leaves the really bright stuff bright, and
763 // everything else becomes very dark)
764 // TODO: optimize with multitexture or GLSL
765 qglViewport(r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
766 GL_BlendFunc(GL_ONE, GL_ZERO);
767 GL_Color(1, 1, 1, 1);
768 R_Mesh_Draw(0, 4, 2, polygonelements);
770 c_bloomdrawpixels += bloomwidth * bloomheight;
771 // render multiple times with a multiply blendfunc to raise to a power
772 GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
773 for (x = 1;x < r_bloom_power.integer;x++)
775 R_Mesh_Draw(0, 4, 2, polygonelements);
777 c_bloomdrawpixels += bloomwidth * bloomheight;
779 // we now have a darkened bloom image in the framebuffer, copy it into
780 // the bloom image texture for more processing
781 memset(&m, 0, sizeof(m));
782 m.pointer_vertex = varray_vertex3f;
783 m.tex[0] = R_GetTexture(r_bloom_texture_bloom);
784 m.pointer_texcoord[0] = varray_texcoord2f[2];
787 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
789 c_bloomcopypixels += bloomwidth * bloomheight;
790 // blend on at multiple vertical offsets to achieve a vertical blur
791 // TODO: do offset blends using GLSL
792 range = r_bloom_blur.integer * bloomwidth / 320;
793 GL_BlendFunc(GL_ONE, GL_ZERO);
794 for (x = -range;x <= range;x++)
796 xoffset = 0 / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
797 yoffset = x / (float)bloomheight * (float)bloomheight / (float)screenheight;
798 // compute a texcoord array with the specified x and y offset
799 varray_texcoord2f[2][0] = xoffset+0;
800 varray_texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
801 varray_texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
802 varray_texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
803 varray_texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
804 varray_texcoord2f[2][5] = yoffset+0;
805 varray_texcoord2f[2][6] = xoffset+0;
806 varray_texcoord2f[2][7] = yoffset+0;
807 // this r value looks like a 'dot' particle, fading sharply to
808 // black at the edges
809 // (probably not realistic but looks good enough)
810 r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
813 GL_Color(r, r, r, 1);
814 R_Mesh_Draw(0, 4, 2, polygonelements);
816 c_bloomdrawpixels += bloomwidth * bloomheight;
817 GL_BlendFunc(GL_ONE, GL_ONE);
819 // copy the vertically blurred bloom view to a texture
821 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
823 c_bloomcopypixels += bloomwidth * bloomheight;
824 // blend the vertically blurred image at multiple offsets horizontally
825 // to finish the blur effect
826 // TODO: do offset blends using GLSL
827 range = r_bloom_blur.integer * bloomwidth / 320;
828 GL_BlendFunc(GL_ONE, GL_ZERO);
829 for (x = -range;x <= range;x++)
831 xoffset = x / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
832 yoffset = 0 / (float)bloomheight * (float)bloomheight / (float)screenheight;
833 // compute a texcoord array with the specified x and y offset
834 varray_texcoord2f[2][0] = xoffset+0;
835 varray_texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
836 varray_texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
837 varray_texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
838 varray_texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
839 varray_texcoord2f[2][5] = yoffset+0;
840 varray_texcoord2f[2][6] = xoffset+0;
841 varray_texcoord2f[2][7] = yoffset+0;
842 // this r value looks like a 'dot' particle, fading sharply to
843 // black at the edges
844 // (probably not realistic but looks good enough)
845 r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
848 GL_Color(r, r, r, 1);
849 R_Mesh_Draw(0, 4, 2, polygonelements);
851 c_bloomdrawpixels += bloomwidth * bloomheight;
852 GL_BlendFunc(GL_ONE, GL_ONE);
854 // copy the blurred bloom view to a texture
856 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
858 c_bloomcopypixels += bloomwidth * bloomheight;
859 // go back to full view area
860 qglViewport(r_view_x, vid.height - (r_view_y + r_view_height), r_view_width, r_view_height);
861 // put the original screen image back in place and blend the bloom
863 memset(&m, 0, sizeof(m));
864 m.pointer_vertex = varray_vertex3f;
865 m.tex[0] = R_GetTexture(r_bloom_texture_screen);
866 m.pointer_texcoord[0] = varray_texcoord2f[0];
868 dobloomblend = false;
870 // do both in one pass if possible
871 if (r_textureunits.integer >= 2 && gl_combine.integer)
873 dobloomblend = false;
874 m.texcombinergb[1] = GL_ADD;
875 m.tex[1] = R_GetTexture(r_bloom_texture_bloom);
876 m.pointer_texcoord[1] = varray_texcoord2f[1];
882 GL_BlendFunc(GL_ONE, GL_ZERO);
884 R_Mesh_Draw(0, 4, 2, polygonelements);
886 c_bloomdrawpixels += r_view_width * r_view_height;
887 // now blend on the bloom texture if multipass
890 memset(&m, 0, sizeof(m));
891 m.pointer_vertex = varray_vertex3f;
892 m.tex[0] = R_GetTexture(r_bloom_texture_bloom);
893 m.pointer_texcoord[0] = varray_texcoord2f[1];
895 GL_BlendFunc(GL_ONE, GL_ONE);
897 R_Mesh_Draw(0, 4, 2, polygonelements);
899 c_bloomdrawpixels += r_view_width * r_view_height;
902 if (r_refdef.viewblend[3] >= 0.01f)
904 // apply a color tint to the whole view
905 memset(&m, 0, sizeof(m));
906 m.pointer_vertex = varray_vertex3f;
908 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
909 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
910 R_Mesh_Draw(0, 4, 2, polygonelements);
914 void R_RenderScene(void);
916 matrix4x4_t r_waterscrollmatrix;
923 void R_RenderView(void)
925 if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
926 return; //Host_Error ("R_RenderView: NULL worldmodel");
928 r_view_width = bound(0, r_refdef.width, vid.width);
929 r_view_height = bound(0, r_refdef.height, vid.height);
931 r_view_x = bound(0, r_refdef.x, vid.width - r_refdef.width);
932 r_view_y = bound(0, r_refdef.y, vid.height - r_refdef.height);
934 r_view_fov_x = bound(1, r_refdef.fov_x, 170);
935 r_view_fov_y = bound(1, r_refdef.fov_y, 170);
936 r_view_matrix = r_refdef.viewentitymatrix;
937 GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
938 r_rtworld = r_shadow_realtime_world.integer;
939 r_rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
940 r_rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer;
941 r_rtdlightshadows = r_rtdlight && (r_rtworld ? r_shadow_realtime_world_dlightshadows.integer : r_shadow_realtime_dlight_shadows.integer) && gl_stencil;
942 r_lightmapintensity = r_rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
944 // GL is weird because it's bottom to top, r_view_y is top to bottom
945 qglViewport(r_view_x, vid.height - (r_view_y + r_view_height), r_view_width, r_view_height);
946 GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
947 GL_ScissorTest(true);
953 R_TimeReport("setup");
955 qglDepthFunc(GL_LEQUAL);
956 qglPolygonOffset(0, 0);
957 qglEnable(GL_POLYGON_OFFSET_FILL);
961 qglPolygonOffset(0, 0);
962 qglDisable(GL_POLYGON_OFFSET_FILL);
965 R_TimeReport("blendview");
967 GL_Scissor(0, 0, vid.width, vid.height);
968 GL_ScissorTest(false);
971 extern void R_DrawLightningBeams (void);
972 void R_RenderScene(void)
974 // don't let sound skip if going slow
975 if (r_refdef.extraupdate)
980 R_MeshQueue_BeginScene();
982 GL_ShowTrisColor(0.05, 0.05, 0.05, 1);
986 r_farclip = R_FarClip(r_vieworigin, r_viewforward, 768.0f) + 256.0f;
987 if (r_rtworldshadows || r_rtdlightshadows)
988 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view_fov_x, r_view_fov_y, 1.0f);
990 GL_SetupView_Mode_Perspective(r_view_fov_x, r_view_fov_y, 1.0f, r_farclip);
992 GL_SetupView_Orientation_FromEntity(&r_view_matrix);
994 Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.time) * 0.025 * r_waterscroll.value, sin(r_refdef.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
999 R_TimeReport("worldvis");
1002 R_TimeReport("markentity");
1004 R_Shadow_UpdateWorldLightSelection();
1006 // don't let sound skip if going slow
1007 if (r_refdef.extraupdate)
1010 GL_ShowTrisColor(0.025, 0.025, 0, 1);
1011 if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
1013 r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
1014 R_TimeReport("worldsky");
1017 if (R_DrawBrushModelsSky())
1018 R_TimeReport("bmodelsky");
1020 GL_ShowTrisColor(0.05, 0.05, 0.05, 1);
1021 if (r_refdef.worldmodel && r_refdef.worldmodel->Draw)
1023 r_refdef.worldmodel->Draw(r_refdef.worldentity);
1024 R_TimeReport("world");
1027 // don't let sound skip if going slow
1028 if (r_refdef.extraupdate)
1031 GL_ShowTrisColor(0, 0.015, 0, 1);
1034 R_TimeReport("models");
1036 // don't let sound skip if going slow
1037 if (r_refdef.extraupdate)
1040 GL_ShowTrisColor(0, 0, 0.033, 1);
1041 R_ShadowVolumeLighting(false);
1042 R_TimeReport("rtlights");
1044 // don't let sound skip if going slow
1045 if (r_refdef.extraupdate)
1048 GL_ShowTrisColor(0.1, 0, 0, 1);
1050 R_DrawLightningBeams();
1051 R_TimeReport("lightning");
1054 R_TimeReport("particles");
1057 R_TimeReport("explosions");
1059 R_MeshQueue_RenderTransparent();
1060 R_TimeReport("drawtrans");
1063 R_TimeReport("coronas");
1065 R_DrawWorldCrosshair();
1066 R_TimeReport("crosshair");
1068 R_MeshQueue_Render();
1069 R_MeshQueue_EndScene();
1071 if ((r_shadow_visiblelighting.integer || r_shadow_visiblevolumes.integer) && !r_showtrispass)
1073 R_ShadowVolumeLighting(true);
1074 R_TimeReport("visiblevolume");
1077 GL_ShowTrisColor(0.05, 0.05, 0.05, 1);
1079 // don't let sound skip if going slow
1080 if (r_refdef.extraupdate)
1085 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
1088 float *v, *c, f1, f2, diff[3], vertex3f[8*3], color4f[8*4];
1090 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1091 GL_DepthMask(false);
1093 R_Mesh_Matrix(&r_identitymatrix);
1095 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2];
1096 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
1097 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
1098 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
1099 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
1100 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
1101 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
1102 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
1103 R_FillColors(color, 8, cr, cg, cb, ca);
1106 for (i = 0, v = vertex, c = color;i < 8;i++, v += 4, c += 4)
1108 VectorSubtract(v, r_vieworigin, diff);
1109 f2 = exp(fogdensity/DotProduct(diff, diff));
1111 c[0] = c[0] * f1 + fogcolor[0] * f2;
1112 c[1] = c[1] * f1 + fogcolor[1] * f2;
1113 c[2] = c[2] * f1 + fogcolor[2] * f2;
1116 memset(&m, 0, sizeof(m));
1117 m.pointer_vertex = vertex3f;
1118 m.pointer_color = color;
1124 int nomodelelements[24] =
1136 float nomodelvertex3f[6*3] =
1146 float nomodelcolor4f[6*4] =
1148 0.0f, 0.0f, 0.5f, 1.0f,
1149 0.0f, 0.0f, 0.5f, 1.0f,
1150 0.0f, 0.5f, 0.0f, 1.0f,
1151 0.0f, 0.5f, 0.0f, 1.0f,
1152 0.5f, 0.0f, 0.0f, 1.0f,
1153 0.5f, 0.0f, 0.0f, 1.0f
1156 void R_DrawNoModelCallback(const void *calldata1, int calldata2)
1158 const entity_render_t *ent = calldata1;
1160 float f1, f2, *c, diff[3];
1163 R_Mesh_Matrix(&ent->matrix);
1165 memset(&m, 0, sizeof(m));
1166 m.pointer_vertex = nomodelvertex3f;
1168 if (ent->flags & EF_ADDITIVE)
1170 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1171 GL_DepthMask(false);
1173 else if (ent->alpha < 1)
1175 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1176 GL_DepthMask(false);
1180 GL_BlendFunc(GL_ONE, GL_ZERO);
1183 GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
1186 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
1187 m.pointer_color = color4f;
1188 VectorSubtract(ent->origin, r_vieworigin, diff);
1189 f2 = exp(fogdensity/DotProduct(diff, diff));
1191 for (i = 0, c = color4f;i < 6;i++, c += 4)
1193 c[0] = (c[0] * f1 + fogcolor[0] * f2);
1194 c[1] = (c[1] * f1 + fogcolor[1] * f2);
1195 c[2] = (c[2] * f1 + fogcolor[2] * f2);
1199 else if (ent->alpha != 1)
1201 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
1202 m.pointer_color = color4f;
1203 for (i = 0, c = color4f;i < 6;i++, c += 4)
1207 m.pointer_color = nomodelcolor4f;
1209 R_Mesh_Draw(0, 6, 8, nomodelelements);
1212 void R_DrawNoModel(entity_render_t *ent)
1214 //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
1215 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_vieworigin : ent->origin, R_DrawNoModelCallback, ent, 0);
1217 // R_DrawNoModelCallback(ent, 0);
1220 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
1222 vec3_t right1, right2, diff, normal;
1224 VectorSubtract (org2, org1, normal);
1226 // calculate 'right' vector for start
1227 VectorSubtract (r_vieworigin, org1, diff);
1228 CrossProduct (normal, diff, right1);
1229 VectorNormalize (right1);
1231 // calculate 'right' vector for end
1232 VectorSubtract (r_vieworigin, org2, diff);
1233 CrossProduct (normal, diff, right2);
1234 VectorNormalize (right2);
1236 vert[ 0] = org1[0] + width * right1[0];
1237 vert[ 1] = org1[1] + width * right1[1];
1238 vert[ 2] = org1[2] + width * right1[2];
1239 vert[ 3] = org1[0] - width * right1[0];
1240 vert[ 4] = org1[1] - width * right1[1];
1241 vert[ 5] = org1[2] - width * right1[2];
1242 vert[ 6] = org2[0] - width * right2[0];
1243 vert[ 7] = org2[1] - width * right2[1];
1244 vert[ 8] = org2[2] - width * right2[2];
1245 vert[ 9] = org2[0] + width * right2[0];
1246 vert[10] = org2[1] + width * right2[1];
1247 vert[11] = org2[2] + width * right2[2];
1250 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
1252 void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, int depthdisable, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2, float cr, float cg, float cb, float ca)
1259 VectorSubtract(origin, r_vieworigin, diff);
1260 ca *= 1 - exp(fogdensity/DotProduct(diff,diff));
1263 R_Mesh_Matrix(&r_identitymatrix);
1264 GL_BlendFunc(blendfunc1, blendfunc2);
1265 GL_DepthMask(false);
1266 GL_DepthTest(!depthdisable);
1268 varray_vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
1269 varray_vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
1270 varray_vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
1271 varray_vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
1272 varray_vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
1273 varray_vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
1274 varray_vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
1275 varray_vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
1276 varray_vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
1277 varray_vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
1278 varray_vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
1279 varray_vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
1281 memset(&m, 0, sizeof(m));
1282 m.tex[0] = R_GetTexture(texture);
1283 m.pointer_texcoord[0] = spritetexcoord2f;
1284 m.pointer_vertex = varray_vertex3f;
1286 GL_Color(cr, cg, cb, ca);
1287 R_Mesh_Draw(0, 4, 2, polygonelements);
1290 int R_Mesh_AddVertex3f(rmesh_t *mesh, const float *v)
1294 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
1295 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
1297 if (i == mesh->numvertices)
1299 if (mesh->numvertices < mesh->maxvertices)
1301 VectorCopy(v, vertex3f);
1302 mesh->numvertices++;
1304 return mesh->numvertices;
1310 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
1314 element[0] = R_Mesh_AddVertex3f(mesh, vertex3f);vertex3f += 3;
1315 element[1] = R_Mesh_AddVertex3f(mesh, vertex3f);vertex3f += 3;
1316 e = mesh->element3i + mesh->numtriangles * 3;
1317 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
1319 element[2] = R_Mesh_AddVertex3f(mesh, vertex3f);
1320 if (mesh->numtriangles < mesh->maxtriangles)
1325 mesh->numtriangles++;
1327 element[1] = element[2];
1331 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
1333 int planenum, planenum2;
1336 mplane_t *plane, *plane2;
1337 float temppoints[2][256*3];
1338 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
1342 PolygonF_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->normal[3], 1024.0*1024.0*1024.0);
1343 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
1345 if (planenum2 == planenum)
1347 PolygonF_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, 1.0/32.0, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints);
1350 if (tempnumpoints < 3)
1352 // generate elements forming a triangle fan for this polygon
1353 R_Mesh_AddPolygon3f(mesh, tempnumpoints, temppoints[w]);
1357 void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, int blendfunc2, texturelayertype_t type, rtexture_t *texture, matrix4x4_t *matrix, float r, float g, float b, float a)
1359 texturelayer_t *layer;
1360 layer = t->currentlayers + t->currentnumlayers++;
1362 layer->depthmask = depthmask;
1363 layer->blendfunc1 = blendfunc1;
1364 layer->blendfunc2 = blendfunc2;
1365 layer->texture = texture;
1366 layer->texmatrix = *matrix;
1367 layer->color[0] = r;
1368 layer->color[1] = g;
1369 layer->color[2] = b;
1370 layer->color[3] = a;
1373 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
1375 // FIXME: identify models using a better check than ent->model->brush.shadowmesh
1376 //int lightmode = ((ent->effects & EF_FULLBRIGHT) || ent->model->brush.shadowmesh) ? 0 : 2;
1380 texture_t *texture = t;
1381 model_t *model = ent->model;
1382 int s = ent->skinnum;
1383 if ((unsigned int)s >= (unsigned int)model->numskins)
1387 if (model->skinscenes)
1389 if (model->skinscenes[s].framecount > 1)
1390 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
1392 s = model->skinscenes[s].firstframe;
1395 t = t + s * model->num_surfaces;
1397 t = t->anim_frames[ent->frame != 0][(t->anim_total[ent->frame != 0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[ent->frame != 0]) : 0];
1398 texture->currentframe = t;
1401 t->currentmaterialflags = t->basematerialflags;
1402 currentalpha = ent->alpha;
1403 if (t->basematerialflags & MATERIALFLAG_WATERALPHA)
1404 currentalpha *= r_wateralpha.value;
1405 if (!(ent->flags & RENDER_LIGHT))
1406 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
1407 if (ent->effects & EF_ADDITIVE)
1408 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_TRANSPARENT;
1409 else if (currentalpha < 1)
1410 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_TRANSPARENT;
1411 if (ent->effects & EF_NODEPTHTEST)
1412 t->currentmaterialflags |= MATERIALFLAG_NODEPTHTEST;
1413 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
1414 t->currenttexmatrix = r_waterscrollmatrix;
1416 t->currenttexmatrix = r_identitymatrix;
1417 t->currentnumlayers = 0;
1418 if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
1420 if (gl_lightmaps.integer)
1421 R_Texture_AddLayer(t, true, GL_ONE, GL_ZERO, TEXTURELAYERTYPE_LITTEXTURE_MULTIPASS, r_texture_white, &r_identitymatrix, 1, 1, 1, 1);
1422 else if (t->currentmaterialflags & MATERIALFLAG_SKY)
1424 // transparent sky would be ridiculous
1425 if (!(t->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
1426 R_Texture_AddLayer(t, true, GL_ONE, GL_ZERO, TEXTURELAYERTYPE_SKY, r_texture_white, &r_identitymatrix, fogcolor[0], fogcolor[1], fogcolor[2], 1);
1430 int blendfunc1, blendfunc2, depthmask;
1431 if (t->currentmaterialflags & MATERIALFLAG_ADD)
1433 blendfunc1 = GL_SRC_ALPHA;
1434 blendfunc2 = GL_ONE;
1437 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
1439 blendfunc1 = GL_SRC_ALPHA;
1440 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
1445 blendfunc1 = GL_ONE;
1446 blendfunc2 = GL_ZERO;
1449 if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
1451 rtexture_t *currentbasetexture;
1453 if (fogenabled && (t->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
1454 layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
1455 currentbasetexture = (ent->colormap < 0 && t->skin.merged) ? t->skin.merged : t->skin.base;
1456 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1458 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], currentalpha);
1459 if (ent->colormap >= 0 && t->skin.pants)
1460 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.pants, &t->currenttexmatrix, ent->colormap_pantscolor[0], ent->colormap_pantscolor[1], ent->colormap_pantscolor[2], currentalpha);
1461 if (ent->colormap >= 0 && t->skin.shirt)
1462 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0], ent->colormap_shirtcolor[1], ent->colormap_shirtcolor[2], currentalpha);
1468 // q3bsp has no lightmap updates, so the lightstylevalue that
1469 // would normally be baked into the lightmaptexture must be
1470 // applied to the color
1471 if (ent->model->type == mod_brushq3)
1472 colorscale *= d_lightstylevalue[0] * (1.0f / 256.0f);
1473 // transparent and fullbright are not affected by r_lightmapintensity
1474 if (!(t->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
1475 colorscale *= r_lightmapintensity;
1476 if (r_textureunits.integer >= 2 && gl_combine.integer)
1477 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE_COMBINE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * colorscale, ent->colormod[1] * colorscale, ent->colormod[2] * colorscale, currentalpha);
1478 else if ((t->currentmaterialflags & MATERIALFLAG_TRANSPARENT) == 0)
1479 R_Texture_AddLayer(t, true, GL_ONE, GL_ZERO, TEXTURELAYERTYPE_LITTEXTURE_MULTIPASS, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * colorscale * 0.5f, ent->colormod[1] * colorscale * 0.5f, ent->colormod[2] * colorscale * 0.5f, currentalpha);
1481 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE_VERTEX, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * colorscale, ent->colormod[1] * colorscale, ent->colormod[2] * colorscale, currentalpha);
1482 if (r_ambient.value >= (1.0f/64.0f))
1483 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), currentalpha);
1484 if (ent->colormap >= 0 && t->skin.pants)
1486 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE_VERTEX, t->skin.pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * colorscale, ent->colormap_pantscolor[1] * colorscale, ent->colormap_pantscolor[2] * colorscale, currentalpha);
1487 if (r_ambient.value >= (1.0f/64.0f))
1488 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[2] * r_ambient.value * (1.0f / 64.0f), currentalpha);
1490 if (ent->colormap >= 0 && t->skin.shirt)
1492 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE_VERTEX, t->skin.shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * colorscale, ent->colormap_shirtcolor[1] * colorscale, ent->colormap_shirtcolor[2] * colorscale, currentalpha);
1493 if (r_ambient.value >= (1.0f/64.0f))
1494 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[2] * r_ambient.value * (1.0f / 64.0f), currentalpha);
1497 if (t->skin.glow != NULL)
1498 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.glow, &t->currenttexmatrix, 1, 1, 1, currentalpha);
1499 if (fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
1501 // if this is opaque use alpha blend which will darken the earlier
1504 // if this is an alpha blended material, all the earlier passes
1505 // were darkened by fog already, so we only need to add the fog
1506 // color ontop through the fog mask texture
1508 // if this is an additive blended material, all the earlier passes
1509 // were darkened by fog already, and we should not add fog color
1510 // (because the background was not darkened, there is no fog color
1511 // that was lost behind it).
1512 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_TRANSPARENT) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->skin.fog, &r_identitymatrix, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha);
1519 void R_UpdateAllTextureInfo(entity_render_t *ent)
1523 for (i = 0;i < ent->model->num_textures;i++)
1524 R_UpdateTextureInfo(ent, ent->model->data_textures + i);
1527 float *rsurface_vertex3f;
1528 float *rsurface_svector3f;
1529 float *rsurface_tvector3f;
1530 float *rsurface_normal3f;
1531 float *rsurface_lightmapcolor4f;
1533 void RSurf_SetVertexPointer(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t modelorg)
1536 float center[3], forward[3], right[3], up[3], v[4][3];
1537 matrix4x4_t matrix1, imatrix1;
1538 if ((ent->frameblend[0].lerp != 1 || ent->frameblend[0].frame != 0) && (surface->groupmesh->data_morphvertex3f || surface->groupmesh->data_vertexboneweights))
1540 rsurface_vertex3f = varray_vertex3f;
1541 rsurface_svector3f = NULL;
1542 rsurface_tvector3f = NULL;
1543 rsurface_normal3f = NULL;
1544 Mod_Alias_GetMesh_Vertex3f(ent->model, ent->frameblend, surface->groupmesh, rsurface_vertex3f);
1548 rsurface_vertex3f = surface->groupmesh->data_vertex3f;
1549 rsurface_svector3f = surface->groupmesh->data_svector3f;
1550 rsurface_tvector3f = surface->groupmesh->data_tvector3f;
1551 rsurface_normal3f = surface->groupmesh->data_normal3f;
1553 if (texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2)
1555 if (!rsurface_svector3f)
1557 rsurface_svector3f = varray_svector3f;
1558 rsurface_tvector3f = varray_tvector3f;
1559 rsurface_normal3f = varray_normal3f;
1560 Mod_BuildTextureVectorsAndNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_texcoordtexture2f, surface->groupmesh->data_element3i + surface->num_firsttriangle * 3, rsurface_svector3f, rsurface_tvector3f, rsurface_normal3f, r_smoothnormals_areaweighting.integer);
1562 // a single autosprite surface can contain multiple sprites...
1563 VectorClear(forward);
1565 VectorSet(up, 0, 0, 1);
1566 for (j = 0;j < surface->num_vertices - 3;j += 4)
1568 VectorClear(center);
1569 for (i = 0;i < 4;i++)
1570 VectorAdd(center, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
1571 VectorScale(center, 0.25f, center);
1572 // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
1573 Matrix4x4_FromVectors(&matrix1, (rsurface_normal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_svector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_tvector3f + 3 * surface->num_firstvertex) + j*3, center);
1574 Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
1575 for (i = 0;i < 4;i++)
1576 Matrix4x4_Transform(&imatrix1, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
1577 forward[0] = modelorg[0] - center[0];
1578 forward[1] = modelorg[1] - center[1];
1579 VectorNormalize(forward);
1580 right[0] = forward[1];
1581 right[1] = -forward[0];
1582 for (i = 0;i < 4;i++)
1583 VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, varray_vertex3f + (surface->num_firstvertex+i+j) * 3);
1585 rsurface_vertex3f = varray_vertex3f;
1586 rsurface_svector3f = NULL;
1587 rsurface_tvector3f = NULL;
1588 rsurface_normal3f = NULL;
1590 else if (texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE)
1592 if (!rsurface_svector3f)
1594 rsurface_svector3f = varray_svector3f;
1595 rsurface_tvector3f = varray_tvector3f;
1596 rsurface_normal3f = varray_normal3f;
1597 Mod_BuildTextureVectorsAndNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_texcoordtexture2f, surface->groupmesh->data_element3i + surface->num_firsttriangle * 3, rsurface_svector3f, rsurface_tvector3f, rsurface_normal3f, r_smoothnormals_areaweighting.integer);
1599 Matrix4x4_Transform(&ent->inversematrix, r_viewforward, forward);
1600 Matrix4x4_Transform(&ent->inversematrix, r_viewright, right);
1601 Matrix4x4_Transform(&ent->inversematrix, r_viewup, up);
1602 // a single autosprite surface can contain multiple sprites...
1603 for (j = 0;j < surface->num_vertices - 3;j += 4)
1605 VectorClear(center);
1606 for (i = 0;i < 4;i++)
1607 VectorAdd(center, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
1608 VectorScale(center, 0.25f, center);
1609 // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
1610 Matrix4x4_FromVectors(&matrix1, (rsurface_normal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_svector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_tvector3f + 3 * surface->num_firstvertex) + j*3, center);
1611 Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
1612 for (i = 0;i < 4;i++)
1613 Matrix4x4_Transform(&imatrix1, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
1614 for (i = 0;i < 4;i++)
1615 VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, varray_vertex3f + (surface->num_firstvertex+i+j) * 3);
1617 rsurface_vertex3f = varray_vertex3f;
1618 rsurface_svector3f = NULL;
1619 rsurface_tvector3f = NULL;
1620 rsurface_normal3f = NULL;
1622 R_Mesh_VertexPointer(rsurface_vertex3f);
1625 void RSurf_SetColorPointer(const entity_render_t *ent, const msurface_t *surface, const vec3_t modelorg, float r, float g, float b, float a, int lightmode, qboolean applycolor, qboolean applyfog)
1634 vec4_t ambientcolor4f;
1635 vec3_t diffusecolor;
1636 vec3_t diffusenormal;
1637 if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, r*0.5f, g*0.5f, b*0.5f, a, false))
1639 rsurface_lightmapcolor4f = varray_color4f;
1640 if (rsurface_normal3f == NULL)
1642 rsurface_normal3f = varray_normal3f;
1643 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle, rsurface_normal3f, r_smoothnormals_areaweighting.integer);
1645 R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, surface->groupmesh->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, rsurface_lightmapcolor4f + 4 * surface->num_firstvertex);
1654 r = ambientcolor4f[0];
1655 g = ambientcolor4f[1];
1656 b = ambientcolor4f[2];
1657 a = ambientcolor4f[3];
1658 rsurface_lightmapcolor4f = NULL;
1661 else if (lightmode >= 1)
1663 if (surface->lightmapinfo)
1665 for (i = 0, c = varray_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
1667 const qbyte *lm = surface->lightmapinfo->samples + (surface->groupmesh->data_lightmapoffsets + surface->num_firstvertex)[i];
1670 float scale = d_lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
1671 VectorScale(lm, scale, c);
1672 if (surface->lightmapinfo->styles[1] != 255)
1674 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
1676 scale = d_lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
1677 VectorMA(c, scale, lm, c);
1678 if (surface->lightmapinfo->styles[2] != 255)
1681 scale = d_lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
1682 VectorMA(c, scale, lm, c);
1683 if (surface->lightmapinfo->styles[3] != 255)
1686 scale = d_lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
1687 VectorMA(c, scale, lm, c);
1695 rsurface_lightmapcolor4f = varray_color4f;
1698 rsurface_lightmapcolor4f = surface->groupmesh->data_lightmapcolor4f;
1701 rsurface_lightmapcolor4f = NULL;
1704 if (rsurface_lightmapcolor4f)
1706 for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
1708 VectorSubtract(v, modelorg, diff);
1709 f = 1 - exp(fogdensity/DotProduct(diff, diff));
1718 for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c2 = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
1720 VectorSubtract(v, modelorg, diff);
1721 f = 1 - exp(fogdensity/DotProduct(diff, diff));
1728 rsurface_lightmapcolor4f = varray_color4f;
1730 if (applycolor && rsurface_lightmapcolor4f)
1732 for (i = 0, c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
1739 rsurface_lightmapcolor4f = varray_color4f;
1741 R_Mesh_ColorPointer(rsurface_lightmapcolor4f);
1742 GL_Color(r, g, b, a);
1746 static void R_DrawTextureSurfaceList(const entity_render_t *ent, texture_t *texture, int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t modelorg)
1748 int texturesurfaceindex;
1750 const msurface_t *surface;
1751 qboolean applycolor;
1753 if (texture->currentmaterialflags & MATERIALFLAG_NODRAW)
1755 c_faces += texturenumsurfaces;
1756 // FIXME: identify models using a better check than ent->model->brush.shadowmesh
1757 lightmode = ((ent->effects & EF_FULLBRIGHT) || ent->model->brush.shadowmesh) ? 0 : 2;
1758 GL_DepthTest(!(texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
1759 if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED)
1760 qglDisable(GL_CULL_FACE);
1761 if (texture->currentnumlayers)
1764 texturelayer_t *layer;
1765 for (layerindex = 0, layer = texture->currentlayers;layerindex < texture->currentnumlayers;layerindex++, layer++)
1768 int layertexrgbscale;
1769 GL_DepthMask(layer->depthmask);
1770 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
1771 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
1773 layertexrgbscale = 4;
1774 VectorScale(layer->color, 0.25f, layercolor);
1776 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
1778 layertexrgbscale = 2;
1779 VectorScale(layer->color, 0.5f, layercolor);
1783 layertexrgbscale = 1;
1784 VectorScale(layer->color, 1.0f, layercolor);
1786 layercolor[3] = layer->color[3];
1787 GL_Color(layercolor[0], layercolor[1], layercolor[2], layercolor[3]);
1788 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
1789 switch (layer->type)
1791 case TEXTURELAYERTYPE_SKY:
1794 skyrendernow = false;
1795 if (skyrendermasked)
1798 // restore entity matrix and GL_Color
1799 R_Mesh_Matrix(&ent->matrix);
1800 GL_Color(layercolor[0], layercolor[1], layercolor[2], layercolor[3]);
1803 // LordHavoc: HalfLife maps have freaky skypolys...
1804 //if (!ent->model->brush.ishlbsp)
1806 if (skyrendermasked)
1808 // depth-only (masking)
1809 GL_ColorMask(0,0,0,0);
1810 // just to make sure that braindead drivers don't draw anything
1811 // despite that colormask...
1812 GL_BlendFunc(GL_ZERO, GL_ONE);
1817 GL_BlendFunc(GL_ONE, GL_ZERO);
1819 memset(&m, 0, sizeof(m));
1821 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1823 surface = texturesurfacelist[texturesurfaceindex];
1824 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1825 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1826 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1827 GL_LockArrays(0, 0);
1829 if (skyrendermasked)
1830 GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
1833 case TEXTURELAYERTYPE_LITTEXTURE_COMBINE:
1834 memset(&m, 0, sizeof(m));
1835 m.tex[1] = R_GetTexture(layer->texture);
1836 m.texmatrix[1] = layer->texmatrix;
1837 m.texrgbscale[1] = layertexrgbscale;
1838 m.pointer_color = varray_color4f;
1840 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1842 surface = texturesurfacelist[texturesurfaceindex];
1843 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1844 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1845 R_Mesh_TexCoordPointer(1, 2, surface->groupmesh->data_texcoordtexture2f);
1848 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1849 RSurf_SetColorPointer(ent, surface, modelorg, layercolor[0], layercolor[1], layercolor[2], layercolor[3], 2, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1851 else if (surface->lightmaptexture)
1853 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1854 RSurf_SetColorPointer(ent, surface, modelorg, layercolor[0], layercolor[1], layercolor[2], layercolor[3], 0, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1858 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1859 RSurf_SetColorPointer(ent, surface, modelorg, layercolor[0], layercolor[1], layercolor[2], layercolor[3], 1, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1861 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1862 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1863 GL_LockArrays(0, 0);
1866 case TEXTURELAYERTYPE_LITTEXTURE_MULTIPASS:
1867 memset(&m, 0, sizeof(m));
1868 m.tex[0] = R_GetTexture(layer->texture);
1869 m.texmatrix[0] = layer->texmatrix;
1870 m.pointer_color = varray_color4f;
1871 m.texrgbscale[0] = layertexrgbscale;
1873 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1875 surface = texturesurfacelist[texturesurfaceindex];
1876 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1877 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1880 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1881 RSurf_SetColorPointer(ent, surface, modelorg, 1, 1, 1, 1, 2, false, false);
1883 else if (surface->lightmaptexture)
1885 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1886 R_Mesh_ColorPointer(NULL);
1890 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1891 RSurf_SetColorPointer(ent, surface, modelorg, 1, 1, 1, 1, 1, false, false);
1893 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1894 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1895 GL_LockArrays(0, 0);
1897 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
1898 memset(&m, 0, sizeof(m));
1899 m.tex[0] = R_GetTexture(layer->texture);
1900 m.texmatrix[0] = layer->texmatrix;
1901 m.pointer_color = varray_color4f;
1902 m.texrgbscale[0] = layertexrgbscale;
1904 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1906 surface = texturesurfacelist[texturesurfaceindex];
1907 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1908 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1909 RSurf_SetColorPointer(ent, surface, modelorg, layercolor[0], layercolor[1], layercolor[2], layercolor[3], 0, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1910 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1911 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1912 GL_LockArrays(0, 0);
1915 case TEXTURELAYERTYPE_LITTEXTURE_VERTEX:
1916 memset(&m, 0, sizeof(m));
1917 m.tex[0] = R_GetTexture(layer->texture);
1918 m.texmatrix[0] = layer->texmatrix;
1919 m.texrgbscale[0] = layertexrgbscale;
1920 m.pointer_color = varray_color4f;
1922 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1924 surface = texturesurfacelist[texturesurfaceindex];
1925 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1926 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1927 RSurf_SetColorPointer(ent, surface, modelorg, layercolor[0], layercolor[1], layercolor[2], layercolor[3], lightmode ? lightmode : 1, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1928 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1929 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1930 GL_LockArrays(0, 0);
1933 case TEXTURELAYERTYPE_TEXTURE:
1934 memset(&m, 0, sizeof(m));
1935 m.tex[0] = R_GetTexture(layer->texture);
1936 m.texmatrix[0] = layer->texmatrix;
1937 m.pointer_color = varray_color4f;
1938 m.texrgbscale[0] = layertexrgbscale;
1940 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1942 surface = texturesurfacelist[texturesurfaceindex];
1943 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1944 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1945 RSurf_SetColorPointer(ent, surface, modelorg, layercolor[0], layercolor[1], layercolor[2], layercolor[3], 0, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1946 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1947 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1948 GL_LockArrays(0, 0);
1951 case TEXTURELAYERTYPE_FOG:
1952 memset(&m, 0, sizeof(m));
1955 m.tex[0] = R_GetTexture(layer->texture);
1956 m.texmatrix[0] = layer->texmatrix;
1959 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1964 surface = texturesurfacelist[texturesurfaceindex];
1965 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1967 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1968 R_Mesh_ColorPointer(varray_color4f);
1969 for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
1971 VectorSubtract(v, modelorg, diff);
1972 f = exp(fogdensity/DotProduct(diff, diff));
1973 c[0] = layercolor[0];
1974 c[1] = layercolor[1];
1975 c[2] = layercolor[2];
1976 c[3] = f * layercolor[3];
1978 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1979 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1980 GL_LockArrays(0, 0);
1984 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
1986 // if trying to do overbright on first pass of an opaque surface
1987 // when combine is not supported, brighten as a post process
1988 if (layertexrgbscale > 1 && !gl_combine.integer && layer->depthmask)
1991 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
1992 GL_Color(1, 1, 1, 1);
1993 memset(&m, 0, sizeof(m));
1995 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1997 surface = texturesurfacelist[texturesurfaceindex];
1998 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1999 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2000 for (scale = 1;scale < layertexrgbscale;scale <<= 1)
2001 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2002 GL_LockArrays(0, 0);
2007 if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED)
2008 qglEnable(GL_CULL_FACE);
2011 static void RSurfShader_Transparent_Callback(const void *calldata1, int calldata2)
2013 const entity_render_t *ent = calldata1;
2014 const msurface_t *surface = ent->model->data_surfaces + calldata2;
2018 texture = surface->texture;
2019 if (texture->basematerialflags & MATERIALFLAG_SKY)
2020 return; // transparent sky is too difficult
2021 R_UpdateTextureInfo(ent, texture);
2023 R_Mesh_Matrix(&ent->matrix);
2024 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2025 R_DrawTextureSurfaceList(ent, texture->currentframe, 1, &surface, modelorg);
2028 void R_QueueTextureSurfaceList(entity_render_t *ent, texture_t *texture, int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t modelorg)
2030 int texturesurfaceindex;
2031 const msurface_t *surface;
2032 vec3_t tempcenter, center;
2033 if (texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT)
2035 // drawing sky transparently would be too difficult
2036 if (!(texture->currentmaterialflags & MATERIALFLAG_SKY))
2038 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2040 surface = texturesurfacelist[texturesurfaceindex];
2041 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
2042 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
2043 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
2044 Matrix4x4_Transform(&ent->matrix, tempcenter, center);
2045 R_MeshQueue_AddTransparent(texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_vieworigin : center, RSurfShader_Transparent_Callback, ent, surface - ent->model->data_surfaces);
2050 R_DrawTextureSurfaceList(ent, texture, texturenumsurfaces, texturesurfacelist, modelorg);
2053 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
2054 void R_DrawSurfaces(entity_render_t *ent, qboolean skysurfaces)
2056 int i, j, f, flagsmask;
2057 msurface_t *surface, **surfacechain;
2058 texture_t *t, *texture;
2059 model_t *model = ent->model;
2061 const int maxsurfacelist = 1024;
2062 int numsurfacelist = 0;
2063 const msurface_t *surfacelist[1024];
2066 R_Mesh_Matrix(&ent->matrix);
2067 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2069 // update light styles
2070 if (!skysurfaces && model->brushq1.light_styleupdatechains)
2072 for (i = 0;i < model->brushq1.light_styles;i++)
2074 if (model->brushq1.light_stylevalue[i] != d_lightstylevalue[model->brushq1.light_style[i]])
2076 model->brushq1.light_stylevalue[i] = d_lightstylevalue[model->brushq1.light_style[i]];
2077 if ((surfacechain = model->brushq1.light_styleupdatechains[i]))
2078 for (;(surface = *surfacechain);surfacechain++)
2079 surface->cached_dlight = true;
2084 R_UpdateAllTextureInfo(ent);
2085 flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL);
2090 if (ent == r_refdef.worldentity)
2092 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
2094 if (!r_worldsurfacevisible[j])
2096 if (t != surface->texture)
2100 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2103 t = surface->texture;
2104 texture = t->currentframe;
2105 f = texture->currentmaterialflags & flagsmask;
2107 if (f && surface->num_triangles)
2109 // if lightmap parameters changed, rebuild lightmap texture
2110 if (surface->cached_dlight && surface->lightmapinfo->samples)
2111 R_BuildLightMap(ent, surface);
2112 // add face to draw list
2113 surfacelist[numsurfacelist++] = surface;
2114 if (numsurfacelist >= maxsurfacelist)
2116 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2124 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
2126 if (t != surface->texture)
2130 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2133 t = surface->texture;
2134 texture = t->currentframe;
2135 f = texture->currentmaterialflags & flagsmask;
2137 if (f && surface->num_triangles)
2139 // if lightmap parameters changed, rebuild lightmap texture
2140 if (surface->cached_dlight && surface->lightmapinfo->samples)
2141 R_BuildLightMap(ent, surface);
2142 // add face to draw list
2143 surfacelist[numsurfacelist++] = surface;
2144 if (numsurfacelist >= maxsurfacelist)
2146 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2153 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);