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, int texrgbscale)
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;
1371 layer->texrgbscale = texrgbscale;
1374 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
1376 // FIXME: identify models using a better check than ent->model->brush.shadowmesh
1377 //int lightmode = ((ent->effects & EF_FULLBRIGHT) || ent->model->brush.shadowmesh) ? 0 : 2;
1378 vec4_t currentcolorbase;
1381 texture_t *texture = t;
1382 model_t *model = ent->model;
1383 int s = ent->skinnum;
1384 if ((unsigned int)s >= (unsigned int)model->numskins)
1388 if (model->skinscenes)
1390 if (model->skinscenes[s].framecount > 1)
1391 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
1393 s = model->skinscenes[s].firstframe;
1396 t = t + s * model->num_surfaces;
1398 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];
1399 texture->currentframe = t;
1402 t->currentmaterialflags = t->basematerialflags;
1403 currentcolorbase[0] = ent->colormod[0];
1404 currentcolorbase[1] = ent->colormod[1];
1405 currentcolorbase[2] = ent->colormod[2];
1406 currentcolorbase[3] = ent->alpha;
1407 if (t->basematerialflags & MATERIALFLAG_WATERALPHA)
1408 currentcolorbase[3] *= r_wateralpha.value;
1409 if (!(ent->flags & RENDER_LIGHT))
1410 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
1411 if (ent->effects & EF_ADDITIVE)
1412 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_TRANSPARENT;
1413 else if (currentcolorbase[3] < 1)
1414 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_TRANSPARENT;
1415 if (ent->effects & EF_NODEPTHTEST)
1416 t->currentmaterialflags |= MATERIALFLAG_NODEPTHTEST;
1417 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
1418 t->currenttexmatrix = r_waterscrollmatrix;
1420 t->currenttexmatrix = r_identitymatrix;
1421 t->currentnumlayers = 0;
1422 if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
1424 int blendfunc1, blendfunc2, depthmask;
1425 if (t->currentmaterialflags & MATERIALFLAG_ADD)
1427 blendfunc1 = GL_SRC_ALPHA;
1428 blendfunc2 = GL_ONE;
1431 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
1433 blendfunc1 = GL_SRC_ALPHA;
1434 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
1439 blendfunc1 = GL_ONE;
1440 blendfunc2 = GL_ZERO;
1443 if (gl_lightmaps.integer)
1444 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LIGHTMAP, r_texture_white, &r_identitymatrix, 1, 1, 1, 1, 1);
1445 else if (t->currentmaterialflags & MATERIALFLAG_SKY)
1447 // transparent sky would be ridiculous
1448 if (!(t->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
1449 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_SKY, r_texture_white, &r_identitymatrix, fogcolor[0], fogcolor[1], fogcolor[2], 1, 1);
1451 else if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
1454 float colorscale, r, g, b;
1455 rtexture_t *currentbasetexture;
1457 if (fogenabled && (t->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
1458 layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
1460 // q3bsp has no lightmap updates, so the lightstylevalue that
1461 // would normally be baked into the lightmaptexture must be
1462 // applied to the color
1463 if (!(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) && ent->model->type == mod_brushq3)
1464 colorscale *= d_lightstylevalue[0] * (1.0f / 256.0f);
1465 r = currentcolorbase[0] * colorscale;
1466 g = currentcolorbase[1] * colorscale;
1467 b = currentcolorbase[2] * colorscale;
1468 // transparent and fullbright are not affected by r_lightmapintensity
1469 if (!(t->currentmaterialflags & (MATERIALFLAG_TRANSPARENT | MATERIALFLAG_FULLBRIGHT)))
1471 r *= r_lightmapintensity;
1472 g *= r_lightmapintensity;
1473 b *= r_lightmapintensity;
1475 currentbasetexture = (ent->colormap >= 0 && t->skin.merged) ? t->skin.merged : t->skin.base;
1476 if (!(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) && r_textureunits.integer >= 2 && gl_combine.integer)
1478 if ((r > 2 || g > 2 || b > 2) && gl_combine.integer)
1479 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LIGHTMAP_DOUBLEMODULATE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r * 0.25f, g * 0.25f, b * 0.25f, currentcolorbase[3], 4);
1480 else if ((r > 1 || g > 1 || b > 1) && gl_combine.integer)
1481 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LIGHTMAP_DOUBLEMODULATE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r * 0.5f, g * 0.5f, b * 0.5f, currentcolorbase[3], 2);
1483 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LIGHTMAP_DOUBLEMODULATE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r, g, b, currentcolorbase[3], 1);
1485 else if ((t->currentmaterialflags & (MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_TRANSPARENT)) == 0)
1487 R_Texture_AddLayer(t, true, GL_ONE, GL_ZERO, TEXTURELAYERTYPE_LIGHTMAP, r_texture_white, &r_identitymatrix, 1, 1, 1, 1, 1);
1488 if (r > 1 || g > 1 || b > 1)
1489 R_Texture_AddLayer(t, false, GL_DST_COLOR, GL_SRC_COLOR, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r * 0.5f, g * 0.5f, b * 0.5f, currentcolorbase[3], 1);
1491 R_Texture_AddLayer(t, false, GL_ZERO, GL_SRC_COLOR, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r, g, b, currentcolorbase[3], 1);
1495 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1497 type = TEXTURELAYERTYPE_TEXTURE;
1503 type = TEXTURELAYERTYPE_VERTEXTEXTURE;
1504 if ((r > 2 || g > 2 || b > 2) && gl_combine.integer)
1505 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, type, currentbasetexture, &t->currenttexmatrix, r * 0.25f, g * 0.25f, b * 0.25f, currentcolorbase[3], 4);
1506 else if ((r > 1 || g > 1 || b > 1) && gl_combine.integer)
1507 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, type, currentbasetexture, &t->currenttexmatrix, r * 0.5f, g * 0.5f, b * 0.5f, currentcolorbase[3], 2);
1509 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, type, currentbasetexture, &t->currenttexmatrix, r, g, b, currentcolorbase[3], 1);
1511 if (ent->colormap >= 0 && t->skin.pants)
1515 // 128-224 are backwards ranges
1516 cb = (ent->colormap & 0xF) << 4;cb += (cb >= 128 && cb < 224) ? 4 : 12;
1517 cbcolor = (qbyte *) (&palette_complete[cb]);
1518 r = cbcolor[0] * (1.0f / 255.0f) * currentcolorbase[0] * colorscale;
1519 g = cbcolor[1] * (1.0f / 255.0f) * currentcolorbase[1] * colorscale;
1520 b = cbcolor[2] * (1.0f / 255.0f) * currentcolorbase[2] * colorscale;
1521 // transparent and fullbright are not affected by r_lightmapintensity
1522 if ((cb >= 224) || (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
1524 type = TEXTURELAYERTYPE_TEXTURE;
1531 type = TEXTURELAYERTYPE_VERTEXTEXTURE;
1532 if (!(t->currentmaterialflags & (MATERIALFLAG_TRANSPARENT | MATERIALFLAG_FULLBRIGHT)))
1534 r *= r_lightmapintensity;
1535 g *= r_lightmapintensity;
1536 b *= r_lightmapintensity;
1539 if ((r > 2 || g > 2 || b > 2) && gl_combine.integer)
1540 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, type, t->skin.pants, &t->currenttexmatrix, r * 0.25f, g * 0.25f, b * 0.25f, currentcolorbase[3], 4);
1541 else if ((r > 1 || g > 1 || b > 1) && gl_combine.integer)
1542 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, type, t->skin.pants, &t->currenttexmatrix, r * 0.5f, g * 0.5f, b * 0.5f, currentcolorbase[3], 2);
1544 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, type, t->skin.pants, &t->currenttexmatrix, r, g, b, currentcolorbase[3], 1);
1546 if (ent->colormap >= 0 && t->skin.shirt)
1550 // 128-224 are backwards ranges
1551 cb = (ent->colormap & 0xF0);cb += (cb >= 128 && cb < 224) ? 4 : 12;
1552 cbcolor = (qbyte *) (&palette_complete[cb]);
1553 r = cbcolor[0] * (1.0f / 255.0f) * currentcolorbase[0] * colorscale;
1554 g = cbcolor[1] * (1.0f / 255.0f) * currentcolorbase[1] * colorscale;
1555 b = cbcolor[2] * (1.0f / 255.0f) * currentcolorbase[2] * colorscale;
1556 // transparent and fullbright are not affected by r_lightmapintensity
1557 if ((cb >= 224) || (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
1559 type = TEXTURELAYERTYPE_TEXTURE;
1566 type = TEXTURELAYERTYPE_VERTEXTEXTURE;
1567 if (!(t->currentmaterialflags & (MATERIALFLAG_TRANSPARENT | MATERIALFLAG_FULLBRIGHT)))
1569 r *= r_lightmapintensity;
1570 g *= r_lightmapintensity;
1571 b *= r_lightmapintensity;
1574 if ((r > 2 || g > 2 || b > 2) && gl_combine.integer)
1575 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, type, t->skin.shirt, &t->currenttexmatrix, r * 0.25f, g * 0.25f, b * 0.25f, currentcolorbase[3], 4);
1576 else if ((r > 1 || g > 1 || b > 1) && gl_combine.integer)
1577 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, type, t->skin.shirt, &t->currenttexmatrix, r * 0.5f, g * 0.5f, b * 0.5f, currentcolorbase[3], 2);
1579 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, type, t->skin.shirt, &t->currenttexmatrix, r, g, b, currentcolorbase[3], 1);
1581 if (r_ambient.value >= (1.0f/64.0f))
1583 r = currentcolorbase[0] * colorscale * r_ambient.value * (1.0f / 64.0f);
1584 g = currentcolorbase[1] * colorscale * r_ambient.value * (1.0f / 64.0f);
1585 b = currentcolorbase[2] * colorscale * r_ambient.value * (1.0f / 64.0f);
1586 if ((r > 2 || g > 2 || b > 2) && gl_combine.integer)
1587 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r * 0.25f, g * 0.25f, b * 0.25f, currentcolorbase[3], 4);
1588 else if ((r > 1 || g > 1 || b > 1) && gl_combine.integer)
1589 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r * 0.5f, g * 0.5f, b * 0.5f, currentcolorbase[3], 2);
1591 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, r, g, b, currentcolorbase[3], 1);
1593 if (t->skin.glow != NULL)
1594 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->skin.glow, &t->currenttexmatrix, 1, 1, 1, currentcolorbase[3], 1);
1595 if (fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
1597 // if this is opaque use alpha blend which will darken the earlier
1600 // if this is an alpha blended material, all the earlier passes
1601 // were darkened by fog already, so we only need to add the fog
1602 // color ontop through the fog mask texture
1604 // if this is an additive blended material, all the earlier passes
1605 // were darkened by fog already, and we should not add fog color
1606 // (because the background was not darkened, there is no fog color
1607 // that was lost behind it).
1608 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], currentcolorbase[3], 1);
1614 void R_UpdateAllTextureInfo(entity_render_t *ent)
1618 for (i = 0;i < ent->model->num_textures;i++)
1619 R_UpdateTextureInfo(ent, ent->model->data_textures + i);
1622 float *rsurface_vertex3f;
1623 float *rsurface_svector3f;
1624 float *rsurface_tvector3f;
1625 float *rsurface_normal3f;
1626 float *rsurface_lightmapcolor4f;
1628 void RSurf_SetVertexPointer(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t modelorg)
1631 float center[3], forward[3], right[3], up[3], v[4][3];
1632 matrix4x4_t matrix1, imatrix1;
1633 if ((ent->frameblend[0].lerp != 1 || ent->frameblend[0].frame != 0) && (surface->groupmesh->data_morphvertex3f || surface->groupmesh->data_vertexboneweights))
1635 rsurface_vertex3f = varray_vertex3f;
1636 rsurface_svector3f = NULL;
1637 rsurface_tvector3f = NULL;
1638 rsurface_normal3f = NULL;
1639 Mod_Alias_GetMesh_Vertex3f(ent->model, ent->frameblend, surface->groupmesh, rsurface_vertex3f);
1643 rsurface_vertex3f = surface->groupmesh->data_vertex3f;
1644 rsurface_svector3f = surface->groupmesh->data_svector3f;
1645 rsurface_tvector3f = surface->groupmesh->data_tvector3f;
1646 rsurface_normal3f = surface->groupmesh->data_normal3f;
1648 if (texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2)
1650 if (!rsurface_svector3f)
1652 rsurface_svector3f = varray_svector3f;
1653 rsurface_tvector3f = varray_tvector3f;
1654 rsurface_normal3f = varray_normal3f;
1655 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);
1657 // a single autosprite surface can contain multiple sprites...
1658 VectorClear(forward);
1660 VectorSet(up, 0, 0, 1);
1661 for (j = 0;j < surface->num_vertices - 3;j += 4)
1663 VectorClear(center);
1664 for (i = 0;i < 4;i++)
1665 VectorAdd(center, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
1666 VectorScale(center, 0.25f, center);
1667 // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
1668 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);
1669 Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
1670 for (i = 0;i < 4;i++)
1671 Matrix4x4_Transform(&imatrix1, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
1672 forward[0] = modelorg[0] - center[0];
1673 forward[1] = modelorg[1] - center[1];
1674 VectorNormalize(forward);
1675 right[0] = forward[1];
1676 right[1] = -forward[0];
1677 for (i = 0;i < 4;i++)
1678 VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, varray_vertex3f + (surface->num_firstvertex+i+j) * 3);
1680 rsurface_vertex3f = varray_vertex3f;
1681 rsurface_svector3f = NULL;
1682 rsurface_tvector3f = NULL;
1683 rsurface_normal3f = NULL;
1685 else if (texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE)
1687 if (!rsurface_svector3f)
1689 rsurface_svector3f = varray_svector3f;
1690 rsurface_tvector3f = varray_tvector3f;
1691 rsurface_normal3f = varray_normal3f;
1692 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);
1694 Matrix4x4_Transform(&ent->inversematrix, r_viewforward, forward);
1695 Matrix4x4_Transform(&ent->inversematrix, r_viewright, right);
1696 Matrix4x4_Transform(&ent->inversematrix, r_viewup, up);
1697 // a single autosprite surface can contain multiple sprites...
1698 for (j = 0;j < surface->num_vertices - 3;j += 4)
1700 VectorClear(center);
1701 for (i = 0;i < 4;i++)
1702 VectorAdd(center, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
1703 VectorScale(center, 0.25f, center);
1704 // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
1705 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);
1706 Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
1707 for (i = 0;i < 4;i++)
1708 Matrix4x4_Transform(&imatrix1, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
1709 for (i = 0;i < 4;i++)
1710 VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, varray_vertex3f + (surface->num_firstvertex+i+j) * 3);
1712 rsurface_vertex3f = varray_vertex3f;
1713 rsurface_svector3f = NULL;
1714 rsurface_tvector3f = NULL;
1715 rsurface_normal3f = NULL;
1717 R_Mesh_VertexPointer(rsurface_vertex3f);
1720 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)
1729 vec4_t ambientcolor4f;
1730 vec3_t diffusecolor;
1731 vec3_t diffusenormal;
1732 if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, r*0.5f, g*0.5f, b*0.5f, a, false))
1734 rsurface_lightmapcolor4f = varray_color4f;
1735 if (rsurface_normal3f == NULL)
1737 rsurface_normal3f = varray_normal3f;
1738 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);
1740 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);
1749 r = ambientcolor4f[0];
1750 g = ambientcolor4f[1];
1751 b = ambientcolor4f[2];
1752 a = ambientcolor4f[3];
1753 rsurface_lightmapcolor4f = NULL;
1756 else if (lightmode >= 1)
1758 if (surface->lightmapinfo)
1760 for (i = 0, c = varray_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
1762 const qbyte *lm = surface->lightmapinfo->samples + (surface->groupmesh->data_lightmapoffsets + surface->num_firstvertex)[i];
1763 float scale = d_lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
1764 VectorScale(lm, scale, c);
1765 if (surface->lightmapinfo->styles[1] != 255)
1767 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
1769 scale = d_lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
1770 VectorMA(c, scale, lm, c);
1771 if (surface->lightmapinfo->styles[2] != 255)
1774 scale = d_lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
1775 VectorMA(c, scale, lm, c);
1776 if (surface->lightmapinfo->styles[3] != 255)
1779 scale = d_lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
1780 VectorMA(c, scale, lm, c);
1785 rsurface_lightmapcolor4f = varray_color4f;
1788 rsurface_lightmapcolor4f = surface->groupmesh->data_lightmapcolor4f;
1791 rsurface_lightmapcolor4f = NULL;
1794 if (rsurface_lightmapcolor4f)
1796 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)
1798 VectorSubtract(v, modelorg, diff);
1799 f = 1 - exp(fogdensity/DotProduct(diff, diff));
1808 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)
1810 VectorSubtract(v, modelorg, diff);
1811 f = 1 - exp(fogdensity/DotProduct(diff, diff));
1818 rsurface_lightmapcolor4f = varray_color4f;
1820 if (applycolor && rsurface_lightmapcolor4f)
1822 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)
1829 rsurface_lightmapcolor4f = varray_color4f;
1831 R_Mesh_ColorPointer(rsurface_lightmapcolor4f);
1832 GL_Color(r, g, b, a);
1836 static void R_DrawTextureSurfaceList(const entity_render_t *ent, texture_t *texture, int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t modelorg)
1838 int texturesurfaceindex;
1840 const msurface_t *surface;
1841 qboolean applycolor;
1843 if (texture->currentmaterialflags & MATERIALFLAG_NODRAW)
1845 c_faces += texturenumsurfaces;
1846 // FIXME: identify models using a better check than ent->model->brush.shadowmesh
1847 lightmode = ((ent->effects & EF_FULLBRIGHT) || ent->model->brush.shadowmesh) ? 0 : 2;
1848 // gl_lightmaps debugging mode skips normal texturing
1849 if (gl_lightmaps.integer)
1851 GL_BlendFunc(GL_ONE, GL_ZERO);
1854 qglDisable(GL_CULL_FACE);
1855 GL_Color(1, 1, 1, 1);
1856 memset(&m, 0, sizeof(m));
1858 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1860 surface = texturesurfacelist[texturesurfaceindex];
1861 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1862 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1863 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1864 RSurf_SetColorPointer(ent, surface, modelorg, 1, 1, 1, 1, lightmode ? lightmode : !surface->lightmaptexture, false, false);
1865 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1866 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1867 GL_LockArrays(0, 0);
1869 qglEnable(GL_CULL_FACE);
1872 GL_DepthTest(!(texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
1873 if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED)
1874 qglDisable(GL_CULL_FACE);
1875 if (texture->currentnumlayers)
1878 texturelayer_t *layer;
1879 for (layerindex = 0, layer = texture->currentlayers;layerindex < texture->currentnumlayers;layerindex++, layer++)
1881 GL_DepthMask(layer->depthmask);
1882 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
1883 GL_Color(layer->color[0], layer->color[1], layer->color[2], layer->color[3]);
1884 applycolor = layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1;
1885 switch (layer->type)
1887 case TEXTURELAYERTYPE_SKY:
1890 skyrendernow = false;
1891 if (skyrendermasked)
1894 // restore entity matrix and GL_Color
1895 R_Mesh_Matrix(&ent->matrix);
1896 GL_Color(layer->color[0], layer->color[1], layer->color[2], layer->color[3]);
1899 // LordHavoc: HalfLife maps have freaky skypolys...
1900 //if (!ent->model->brush.ishlbsp)
1902 if (skyrendermasked)
1904 // depth-only (masking)
1905 GL_ColorMask(0,0,0,0);
1906 // just to make sure that braindead drivers don't draw anything
1907 // despite that colormask...
1908 GL_BlendFunc(GL_ZERO, GL_ONE);
1913 GL_BlendFunc(GL_ONE, GL_ZERO);
1915 memset(&m, 0, sizeof(m));
1917 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1919 surface = texturesurfacelist[texturesurfaceindex];
1920 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1921 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1922 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1923 GL_LockArrays(0, 0);
1925 if (skyrendermasked)
1926 GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
1929 case TEXTURELAYERTYPE_LIGHTMAP_DOUBLEMODULATE_TEXTURE:
1930 memset(&m, 0, sizeof(m));
1931 m.tex[1] = R_GetTexture(layer->texture);
1932 m.texmatrix[1] = layer->texmatrix;
1933 m.texrgbscale[1] = layer->texrgbscale;
1934 m.pointer_color = varray_color4f;
1936 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1938 surface = texturesurfacelist[texturesurfaceindex];
1939 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1940 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1941 R_Mesh_TexCoordPointer(1, 2, surface->groupmesh->data_texcoordtexture2f);
1944 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1945 RSurf_SetColorPointer(ent, surface, modelorg, layer->color[0], layer->color[1], layer->color[2], layer->color[3], 2, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1947 else if (surface->lightmaptexture)
1949 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1950 RSurf_SetColorPointer(ent, surface, modelorg, layer->color[0], layer->color[1], layer->color[2], layer->color[3], 0, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1954 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1955 RSurf_SetColorPointer(ent, surface, modelorg, layer->color[0], layer->color[1], layer->color[2], layer->color[3], 1, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
1957 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1958 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1959 GL_LockArrays(0, 0);
1962 case TEXTURELAYERTYPE_LIGHTMAP:
1963 memset(&m, 0, sizeof(m));
1965 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1967 surface = texturesurfacelist[texturesurfaceindex];
1968 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1969 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1972 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1973 RSurf_SetColorPointer(ent, surface, modelorg, layer->color[0], layer->color[1], layer->color[2], layer->color[3], 2, applycolor, false);
1975 else if (surface->lightmaptexture)
1977 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1978 R_Mesh_ColorPointer(NULL);
1982 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1983 // TODO: use a specialized RSurf_SetColorPointer
1984 RSurf_SetColorPointer(ent, surface, modelorg, layer->color[0], layer->color[1], layer->color[2], layer->color[3], 1, applycolor, false);
1986 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1987 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1988 GL_LockArrays(0, 0);
1991 case TEXTURELAYERTYPE_VERTEXTEXTURE:
1992 memset(&m, 0, sizeof(m));
1993 m.tex[0] = R_GetTexture(layer->texture);
1994 m.texmatrix[0] = layer->texmatrix;
1995 m.pointer_color = varray_color4f;
1996 m.texrgbscale[0] = layer->texrgbscale;
1998 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2000 surface = texturesurfacelist[texturesurfaceindex];
2001 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2002 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2003 RSurf_SetColorPointer(ent, surface, modelorg, layer->color[0], layer->color[1], layer->color[2], layer->color[3], lightmode ? lightmode : 1, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
2004 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2005 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2006 GL_LockArrays(0, 0);
2009 case TEXTURELAYERTYPE_TEXTURE:
2010 memset(&m, 0, sizeof(m));
2011 m.tex[0] = R_GetTexture(layer->texture);
2012 m.texmatrix[0] = layer->texmatrix;
2013 m.pointer_color = varray_color4f;
2014 m.texrgbscale[0] = layer->texrgbscale;
2016 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2018 surface = texturesurfacelist[texturesurfaceindex];
2019 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2020 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2021 RSurf_SetColorPointer(ent, surface, modelorg, layer->color[0], layer->color[1], layer->color[2], layer->color[3], 0, applycolor, layer->flags & TEXTURELAYERFLAG_FOGDARKEN);
2022 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2023 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2024 GL_LockArrays(0, 0);
2027 case TEXTURELAYERTYPE_FOG:
2028 memset(&m, 0, sizeof(m));
2031 m.tex[0] = R_GetTexture(layer->texture);
2032 m.texmatrix[0] = layer->texmatrix;
2035 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2040 surface = texturesurfacelist[texturesurfaceindex];
2041 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2043 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2044 R_Mesh_ColorPointer(varray_color4f);
2045 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)
2047 VectorSubtract(v, modelorg, diff);
2048 f = exp(fogdensity/DotProduct(diff, diff));
2049 c[0] = layer->color[0];
2050 c[1] = layer->color[1];
2051 c[2] = layer->color[2];
2052 c[3] = f * layer->color[3];
2054 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2055 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2056 GL_LockArrays(0, 0);
2060 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
2064 if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED)
2065 qglEnable(GL_CULL_FACE);
2068 static void RSurfShader_Transparent_Callback(const void *calldata1, int calldata2)
2070 const entity_render_t *ent = calldata1;
2071 const msurface_t *surface = ent->model->data_surfaces + calldata2;
2075 texture = surface->texture;
2076 if (texture->basematerialflags & MATERIALFLAG_SKY)
2077 return; // transparent sky is too difficult
2078 R_UpdateTextureInfo(ent, texture);
2080 R_Mesh_Matrix(&ent->matrix);
2081 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2082 R_DrawTextureSurfaceList(ent, texture->currentframe, 1, &surface, modelorg);
2085 void R_QueueTextureSurfaceList(entity_render_t *ent, texture_t *texture, int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t modelorg)
2087 int texturesurfaceindex;
2088 const msurface_t *surface;
2089 vec3_t tempcenter, center;
2090 if (texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT)
2092 // drawing sky transparently would be too difficult
2093 if (!(texture->currentmaterialflags & MATERIALFLAG_SKY))
2095 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2097 surface = texturesurfacelist[texturesurfaceindex];
2098 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
2099 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
2100 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
2101 Matrix4x4_Transform(&ent->matrix, tempcenter, center);
2102 R_MeshQueue_AddTransparent(texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_vieworigin : center, RSurfShader_Transparent_Callback, ent, surface - ent->model->data_surfaces);
2107 R_DrawTextureSurfaceList(ent, texture, texturenumsurfaces, texturesurfacelist, modelorg);
2110 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
2111 void R_DrawSurfaces(entity_render_t *ent, qboolean skysurfaces)
2113 int i, j, f, flagsmask;
2114 msurface_t *surface, **surfacechain;
2115 texture_t *t, *texture;
2116 model_t *model = ent->model;
2118 const int maxsurfacelist = 1024;
2119 int numsurfacelist = 0;
2120 const msurface_t *surfacelist[1024];
2123 R_Mesh_Matrix(&ent->matrix);
2124 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2126 // update light styles
2127 if (!skysurfaces && model->brushq1.light_styleupdatechains)
2129 for (i = 0;i < model->brushq1.light_styles;i++)
2131 if (model->brushq1.light_stylevalue[i] != d_lightstylevalue[model->brushq1.light_style[i]])
2133 model->brushq1.light_stylevalue[i] = d_lightstylevalue[model->brushq1.light_style[i]];
2134 if ((surfacechain = model->brushq1.light_styleupdatechains[i]))
2135 for (;(surface = *surfacechain);surfacechain++)
2136 surface->cached_dlight = true;
2141 R_UpdateAllTextureInfo(ent);
2142 flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL);
2147 if (ent == r_refdef.worldentity)
2149 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
2151 if (!r_worldsurfacevisible[j])
2153 if (t != surface->texture)
2157 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2160 t = surface->texture;
2161 texture = t->currentframe;
2162 f = texture->currentmaterialflags & flagsmask;
2164 if (f && surface->num_triangles)
2166 // if lightmap parameters changed, rebuild lightmap texture
2167 if (surface->cached_dlight && surface->lightmapinfo->samples)
2168 R_BuildLightMap(ent, surface);
2169 // add face to draw list
2170 surfacelist[numsurfacelist++] = surface;
2171 if (numsurfacelist >= maxsurfacelist)
2173 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2181 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
2183 if (t != surface->texture)
2187 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2190 t = surface->texture;
2191 texture = t->currentframe;
2192 f = texture->currentmaterialflags & flagsmask;
2194 if (f && surface->num_triangles)
2196 // if lightmap parameters changed, rebuild lightmap texture
2197 if (surface->cached_dlight && surface->lightmapinfo->samples)
2198 R_BuildLightMap(ent, surface);
2199 // add face to draw list
2200 surfacelist[numsurfacelist++] = surface;
2201 if (numsurfacelist >= maxsurfacelist)
2203 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2210 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);