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.
23 #include "cl_dyntexture.h"
28 mempool_t *r_main_mempool;
29 rtexturepool_t *r_main_texturepool;
36 r_viewcache_t r_viewcache;
38 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "1", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"};
39 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
40 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%, 10 = 100%)"};
41 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as different colors, or a value of 2 shows triangle draw order (for analyzing whether meshes are optimized for vertex cache)"};
42 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
43 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
44 cvar_t r_showlighting = {0, "r_showlighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
45 cvar_t r_showshadowvolumes = {0, "r_showshadowvolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
46 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
47 cvar_t r_showcollisionbrushes_polygonfactor = {0, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
48 cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
49 cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};
50 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
51 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
52 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
53 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
54 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling"};
55 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
56 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
57 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
58 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
59 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
60 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
61 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
62 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this)"};
63 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
64 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
65 cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
66 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "2", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
68 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
69 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
70 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
71 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
72 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
73 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
74 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
76 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of hardware texture units reported by driver (note: setting this to 1 turns off gl_combine)"};
78 cvar_t r_glsl = {CVAR_SAVE, "r_glsl", "1", "enables use of OpenGL 2.0 pixel shaders for lighting"};
79 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
80 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
81 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
82 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
83 cvar_t r_glsl_contrastboost = {CVAR_SAVE, "r_glsl_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"};
85 cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
86 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
87 cvar_t r_water_resolutionmultiplier = {CVAR_SAVE, "r_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
88 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
89 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
91 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
92 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
93 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
94 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
96 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
97 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
98 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
99 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
100 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
101 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
102 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
104 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
105 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
106 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
107 cvar_t r_hdr_range = {CVAR_SAVE, "r_hdr_range", "4", "how much dynamic range to render bloom with (equivilant to multiplying r_bloom_brighten by this value and dividing r_bloom_colorscale by this value)"};
109 cvar_t r_smoothnormals_areaweighting = {0, "r_smoothnormals_areaweighting", "1", "uses significantly faster (and supposedly higher quality) area-weighted vertex normals and tangent vectors rather than summing normalized triangle normals and tangents"};
111 cvar_t developer_texturelogging = {0, "developer_texturelogging", "0", "produces a textures.log file containing names of skins and map textures the engine tried to load"};
113 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
115 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
116 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
117 cvar_t r_track_sprites = {CVAR_SAVE, "r_track_sprites", "1", "track SPR_LABEL* sprites by putting them as indicator at the screen border to rotate to"};
118 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
119 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
120 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
122 extern qboolean v_flipped_state;
124 typedef struct r_glsl_bloomshader_s
127 int loc_Texture_Bloom;
129 r_glsl_bloomshader_t;
131 static struct r_bloomstate_s
136 int bloomwidth, bloomheight;
138 int screentexturewidth, screentextureheight;
139 rtexture_t *texture_screen;
141 int bloomtexturewidth, bloomtextureheight;
142 rtexture_t *texture_bloom;
144 r_glsl_bloomshader_t *shader;
146 // arrays for rendering the screen passes
147 float screentexcoord2f[8];
148 float bloomtexcoord2f[8];
149 float offsettexcoord2f[8];
153 typedef struct r_waterstate_waterplane_s
155 rtexture_t *texture_refraction;
156 rtexture_t *texture_reflection;
158 int materialflags; // combined flags of all water surfaces on this plane
159 unsigned char pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps
162 r_waterstate_waterplane_t;
164 #define MAX_WATERPLANES 16
166 static struct r_waterstate_s
170 qboolean renderingscene; // true while rendering a refraction or reflection texture, disables water surfaces
172 int waterwidth, waterheight;
173 int texturewidth, textureheight;
175 int maxwaterplanes; // same as MAX_WATERPLANES
177 r_waterstate_waterplane_t waterplanes[MAX_WATERPLANES];
179 float screenscale[2];
180 float screencenter[2];
184 // shadow volume bsp struct with automatically growing nodes buffer
187 rtexture_t *r_texture_blanknormalmap;
188 rtexture_t *r_texture_white;
189 rtexture_t *r_texture_grey128;
190 rtexture_t *r_texture_black;
191 rtexture_t *r_texture_notexture;
192 rtexture_t *r_texture_whitecube;
193 rtexture_t *r_texture_normalizationcube;
194 rtexture_t *r_texture_fogattenuation;
195 //rtexture_t *r_texture_fogintensity;
197 char r_qwskincache[MAX_SCOREBOARD][MAX_QPATH];
198 skinframe_t *r_qwskincache_skinframe[MAX_SCOREBOARD];
200 // vertex coordinates for a quad that covers the screen exactly
201 const static float r_screenvertex3f[12] =
209 extern void R_DrawModelShadows(void);
211 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
214 for (i = 0;i < verts;i++)
225 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
228 for (i = 0;i < verts;i++)
238 // FIXME: move this to client?
241 if (gamemode == GAME_NEHAHRA)
243 Cvar_Set("gl_fogenable", "0");
244 Cvar_Set("gl_fogdensity", "0.2");
245 Cvar_Set("gl_fogred", "0.3");
246 Cvar_Set("gl_foggreen", "0.3");
247 Cvar_Set("gl_fogblue", "0.3");
249 r_refdef.fog_density = r_refdef.fog_red = r_refdef.fog_green = r_refdef.fog_blue = 0.0f;
250 r_refdef.fog_start = 0;
251 r_refdef.fog_alpha = 1;
254 float FogForDistance(vec_t dist)
256 unsigned int fogmasktableindex = (unsigned int)(dist * r_refdef.fogmasktabledistmultiplier);
257 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
260 float FogPoint_World(const vec3_t p)
262 return FogForDistance(VectorDistance((p), r_view.origin));
265 float FogPoint_Model(const vec3_t p)
267 return FogForDistance(VectorDistance((p), rsurface.modelorg));
270 static void R_BuildBlankTextures(void)
272 unsigned char data[4];
273 data[2] = 128; // normal X
274 data[1] = 128; // normal Y
275 data[0] = 255; // normal Z
276 data[3] = 128; // height
277 r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
282 r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
287 r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
292 r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
295 static void R_BuildNoTexture(void)
298 unsigned char pix[16][16][4];
299 // this makes a light grey/dark grey checkerboard texture
300 for (y = 0;y < 16;y++)
302 for (x = 0;x < 16;x++)
304 if ((y < 8) ^ (x < 8))
320 r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, NULL);
323 static void R_BuildWhiteCube(void)
325 unsigned char data[6*1*1*4];
326 memset(data, 255, sizeof(data));
327 r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
330 static void R_BuildNormalizationCube(void)
334 vec_t s, t, intensity;
336 unsigned char data[6][NORMSIZE][NORMSIZE][4];
337 for (side = 0;side < 6;side++)
339 for (y = 0;y < NORMSIZE;y++)
341 for (x = 0;x < NORMSIZE;x++)
343 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
344 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
379 intensity = 127.0f / sqrt(DotProduct(v, v));
380 data[side][y][x][2] = (unsigned char)(128.0f + intensity * v[0]);
381 data[side][y][x][1] = (unsigned char)(128.0f + intensity * v[1]);
382 data[side][y][x][0] = (unsigned char)(128.0f + intensity * v[2]);
383 data[side][y][x][3] = 255;
387 r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
390 static void R_BuildFogTexture(void)
394 unsigned char data1[FOGWIDTH][4];
395 //unsigned char data2[FOGWIDTH][4];
396 for (x = 0;x < FOGWIDTH;x++)
398 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
403 //data2[x][0] = 255 - b;
404 //data2[x][1] = 255 - b;
405 //data2[x][2] = 255 - b;
408 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
409 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
412 static const char *builtinshaderstring =
413 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
414 "// written by Forest 'LordHavoc' Hale\n"
416 "// common definitions between vertex shader and fragment shader:\n"
418 "#ifdef __GLSL_CG_DATA_TYPES\n"
419 "# define myhalf half\n"
420 "# define myhvec2 hvec2\n"
421 "# define myhvec3 hvec3\n"
422 "# define myhvec4 hvec4\n"
424 "# define myhalf float\n"
425 "# define myhvec2 vec2\n"
426 "# define myhvec3 vec3\n"
427 "# define myhvec4 vec4\n"
430 "varying vec2 TexCoord;\n"
431 "varying vec2 TexCoordLightmap;\n"
433 "//#ifdef MODE_LIGHTSOURCE\n"
434 "varying vec3 CubeVector;\n"
437 "//#ifdef MODE_LIGHTSOURCE\n"
438 "varying vec3 LightVector;\n"
440 "//# ifdef MODE_LIGHTDIRECTION\n"
441 "//varying vec3 LightVector;\n"
445 "varying vec3 EyeVector;\n"
447 "varying vec3 EyeVectorModelSpace;\n"
450 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
451 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
452 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
454 "//#ifdef MODE_WATER\n"
455 "varying vec4 ModelViewProjectionPosition;\n"
457 "//# ifdef MODE_REFRACTION\n"
458 "//varying vec4 ModelViewProjectionPosition;\n"
460 "//# ifdef USEREFLECTION\n"
461 "//varying vec4 ModelViewProjectionPosition;\n"
470 "// vertex shader specific:\n"
471 "#ifdef VERTEX_SHADER\n"
473 "uniform vec3 LightPosition;\n"
474 "uniform vec3 EyePosition;\n"
475 "uniform vec3 LightDir;\n"
477 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)\n"
481 " gl_FrontColor = gl_Color;\n"
482 " // copy the surface texcoord\n"
483 " TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);\n"
484 "#ifndef MODE_LIGHTSOURCE\n"
485 "# ifndef MODE_LIGHTDIRECTION\n"
486 " TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
490 "#ifdef MODE_LIGHTSOURCE\n"
491 " // transform vertex position into light attenuation/cubemap space\n"
492 " // (-1 to +1 across the light box)\n"
493 " CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n"
495 " // transform unnormalized light direction into tangent space\n"
496 " // (we use unnormalized to ensure that it interpolates correctly and then\n"
497 " // normalize it per pixel)\n"
498 " vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
499 " LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
500 " LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
501 " LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
504 "#ifdef MODE_LIGHTDIRECTION\n"
505 " LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
506 " LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
507 " LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
510 " // transform unnormalized eye direction into tangent space\n"
512 " vec3 EyeVectorModelSpace;\n"
514 " EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
515 " EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
516 " EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
517 " EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
519 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
520 " VectorS = gl_MultiTexCoord1.xyz;\n"
521 " VectorT = gl_MultiTexCoord2.xyz;\n"
522 " VectorR = gl_MultiTexCoord3.xyz;\n"
525 "//#if defined(MODE_WATER) || defined(MODE_REFRACTION) || defined(USEREFLECTION)\n"
526 "// ModelViewProjectionPosition = gl_Vertex * gl_ModelViewProjectionMatrix;\n"
527 "// //ModelViewProjectionPosition_svector = (gl_Vertex + vec4(gl_MultiTexCoord1.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
528 "// //ModelViewProjectionPosition_tvector = (gl_Vertex + vec4(gl_MultiTexCoord2.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
531 "// transform vertex to camera space, using ftransform to match non-VS\n"
533 " gl_Position = ftransform();\n"
535 "#ifdef MODE_WATER\n"
536 " ModelViewProjectionPosition = gl_Position;\n"
538 "#ifdef MODE_REFRACTION\n"
539 " ModelViewProjectionPosition = gl_Position;\n"
541 "#ifdef USEREFLECTION\n"
542 " ModelViewProjectionPosition = gl_Position;\n"
546 "#endif // VERTEX_SHADER\n"
551 "// fragment shader specific:\n"
552 "#ifdef FRAGMENT_SHADER\n"
554 "// 13 textures, we can only use up to 16 on DX9-class hardware\n"
555 "uniform sampler2D Texture_Normal;\n"
556 "uniform sampler2D Texture_Color;\n"
557 "uniform sampler2D Texture_Gloss;\n"
558 "uniform samplerCube Texture_Cube;\n"
559 "uniform sampler2D Texture_Attenuation;\n"
560 "uniform sampler2D Texture_FogMask;\n"
561 "uniform sampler2D Texture_Pants;\n"
562 "uniform sampler2D Texture_Shirt;\n"
563 "uniform sampler2D Texture_Lightmap;\n"
564 "uniform sampler2D Texture_Deluxemap;\n"
565 "uniform sampler2D Texture_Glow;\n"
566 "uniform sampler2D Texture_Reflection;\n"
567 "uniform sampler2D Texture_Refraction;\n"
569 "uniform myhvec3 LightColor;\n"
570 "uniform myhvec3 AmbientColor;\n"
571 "uniform myhvec3 DiffuseColor;\n"
572 "uniform myhvec3 SpecularColor;\n"
573 "uniform myhvec3 Color_Pants;\n"
574 "uniform myhvec3 Color_Shirt;\n"
575 "uniform myhvec3 FogColor;\n"
577 "//#ifdef MODE_WATER\n"
578 "uniform vec4 DistortScaleRefractReflect;\n"
579 "uniform vec4 ScreenScaleRefractReflect;\n"
580 "uniform vec4 ScreenCenterRefractReflect;\n"
581 "uniform myhvec4 RefractColor;\n"
582 "uniform myhvec4 ReflectColor;\n"
583 "uniform myhalf ReflectFactor;\n"
584 "uniform myhalf ReflectOffset;\n"
586 "//# ifdef MODE_REFRACTION\n"
587 "//uniform vec4 DistortScaleRefractReflect;\n"
588 "//uniform vec4 ScreenScaleRefractReflect;\n"
589 "//uniform vec4 ScreenCenterRefractReflect;\n"
590 "//uniform myhvec4 RefractColor;\n"
591 "//# ifdef USEREFLECTION\n"
592 "//uniform myhvec4 ReflectColor;\n"
595 "//# ifdef USEREFLECTION\n"
596 "//uniform vec4 DistortScaleRefractReflect;\n"
597 "//uniform vec4 ScreenScaleRefractReflect;\n"
598 "//uniform vec4 ScreenCenterRefractReflect;\n"
599 "//uniform myhvec4 ReflectColor;\n"
604 "uniform myhalf GlowScale;\n"
605 "uniform myhalf SceneBrightness;\n"
606 "#ifdef USECONTRASTBOOST\n"
607 "uniform myhalf ContrastBoostCoeff;\n"
610 "uniform float OffsetMapping_Scale;\n"
611 "uniform float OffsetMapping_Bias;\n"
612 "uniform float FogRangeRecip;\n"
614 "uniform myhalf AmbientScale;\n"
615 "uniform myhalf DiffuseScale;\n"
616 "uniform myhalf SpecularScale;\n"
617 "uniform myhalf SpecularPower;\n"
619 "#ifdef USEOFFSETMAPPING\n"
620 "vec2 OffsetMapping(vec2 TexCoord)\n"
622 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
623 " // 14 sample relief mapping: linear search and then binary search\n"
624 " // this basically steps forward a small amount repeatedly until it finds\n"
625 " // itself inside solid, then jitters forward and back using decreasing\n"
626 " // amounts to find the impact\n"
627 " //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
628 " //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
629 " vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
630 " vec3 RT = vec3(TexCoord, 1);\n"
631 " OffsetVector *= 0.1;\n"
632 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
633 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
634 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
635 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
636 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
637 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
638 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
639 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
640 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
641 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) - 0.5);\n"
642 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5 - 0.25);\n"
643 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25 - 0.125);\n"
644 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125 - 0.0625);\n"
645 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
648 " // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
649 " // this basically moves forward the full distance, and then backs up based\n"
650 " // on height of samples\n"
651 " //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
652 " //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
653 " vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
654 " TexCoord += OffsetVector;\n"
655 " OffsetVector *= 0.333;\n"
656 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
657 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
658 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
659 " return TexCoord;\n"
662 "#endif // USEOFFSETMAPPING\n"
664 "#ifdef MODE_WATER\n"
669 "#ifdef USEOFFSETMAPPING\n"
670 " // apply offsetmapping\n"
671 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
672 "#define TexCoord TexCoordOffset\n"
675 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
676 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
677 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
678 " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 5.0) * ReflectFactor + ReflectOffset;\n"
679 " gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
682 "#else // MODE_WATER\n"
683 "#ifdef MODE_REFRACTION\n"
685 "// refraction pass\n"
688 "#ifdef USEOFFSETMAPPING\n"
689 " // apply offsetmapping\n"
690 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
691 "#define TexCoord TexCoordOffset\n"
694 " vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
695 " //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
696 " vec2 ScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
697 " gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
700 "#else // MODE_REFRACTION\n"
703 "#ifdef USEOFFSETMAPPING\n"
704 " // apply offsetmapping\n"
705 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
706 "#define TexCoord TexCoordOffset\n"
709 " // combine the diffuse textures (base, pants, shirt)\n"
710 " myhvec4 color = myhvec4(texture2D(Texture_Color, TexCoord));\n"
711 "#ifdef USECOLORMAPPING\n"
712 " color.rgb += myhvec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhvec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
718 "#ifdef MODE_LIGHTSOURCE\n"
721 " // calculate surface normal, light normal, and specular normal\n"
722 " // compute color intensity for the two textures (colormap and glossmap)\n"
723 " // scale by light color and attenuation as efficiently as possible\n"
724 " // (do as much scalar math as possible rather than vector math)\n"
725 "# ifdef USESPECULAR\n"
726 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
727 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
728 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
730 " // calculate directional shading\n"
731 " color.rgb = LightColor * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0))) * (color.rgb * (AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0))) + (SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower)) * myhvec3(texture2D(Texture_Gloss, TexCoord)));\n"
733 "# ifdef USEDIFFUSE\n"
734 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
735 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
737 " // calculate directional shading\n"
738 " color.rgb = color.rgb * LightColor * (myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0))) * (AmbientScale + DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0))));\n"
740 " // calculate directionless shading\n"
741 " color.rgb = color.rgb * LightColor * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
745 "# ifdef USECUBEFILTER\n"
746 " // apply light cubemap filter\n"
747 " //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
748 " color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
750 " color *= myhvec4(gl_Color);\n"
751 "#endif // MODE_LIGHTSOURCE\n"
756 "#ifdef MODE_LIGHTDIRECTION\n"
757 " // directional model lighting\n"
758 "# ifdef USESPECULAR\n"
759 " // get the surface normal and light normal\n"
760 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
761 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
763 " // calculate directional shading\n"
764 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
765 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
766 " color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
768 "# ifdef USEDIFFUSE\n"
769 " // get the surface normal and light normal\n"
770 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
771 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
773 " // calculate directional shading\n"
774 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
776 " color.rgb *= AmbientColor;\n"
780 " color *= myhvec4(gl_Color);\n"
781 "#endif // MODE_LIGHTDIRECTION\n"
786 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
787 " // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
789 " // get the surface normal and light normal\n"
790 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
792 " myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5);\n"
793 " myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, myhvec3(VectorS)), dot(diffusenormal_modelspace, myhvec3(VectorT)), dot(diffusenormal_modelspace, myhvec3(VectorR))));\n"
794 " // calculate directional shading\n"
795 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
796 "# ifdef USESPECULAR\n"
797 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
798 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
801 " // apply lightmap color\n"
802 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
803 " color.a *= myhalf(gl_Color.a);\n"
804 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
809 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
810 " // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
812 " // get the surface normal and light normal\n"
813 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
815 " myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5));\n"
816 " // calculate directional shading\n"
817 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
818 "# ifdef USESPECULAR\n"
819 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
820 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
823 " // apply lightmap color\n"
824 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
825 " color.a *= myhalf(gl_Color.a);\n"
826 "#endif // MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
831 "#ifdef MODE_LIGHTMAP\n"
832 " // apply lightmap color\n"
833 " color *= myhvec4(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec4(gl_Color) * myhvec4(myhvec3(DiffuseScale), 1) + myhvec4(myhvec3(AmbientScale), 0);\n"
834 "#endif // MODE_LIGHTMAP\n"
844 " color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
847 "#ifndef MODE_LIGHTSOURCE\n"
848 "# ifdef USEREFLECTION\n"
849 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
850 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
851 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
852 " color.rgb = mix(color.rgb, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor.rgb, ReflectColor.a);\n"
856 "#ifdef USECONTRASTBOOST\n"
857 " color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
860 " color.rgb *= SceneBrightness;\n"
864 " color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
867 " gl_FragColor = vec4(color);\n"
869 "#endif // MODE_REFRACTION\n"
870 "#endif // MODE_WATER\n"
872 "#endif // FRAGMENT_SHADER\n"
875 #define SHADERPERMUTATION_COLORMAPPING (1<<0) // indicates this is a colormapped skin
876 #define SHADERPERMUTATION_CONTRASTBOOST (1<<1) // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma)
877 #define SHADERPERMUTATION_FOG (1<<2) // tint the color by fog color or black if using additive blend mode
878 #define SHADERPERMUTATION_CUBEFILTER (1<<3) // (lightsource) use cubemap light filter
879 #define SHADERPERMUTATION_GLOW (1<<4) // (lightmap) blend in an additive glow texture
880 #define SHADERPERMUTATION_DIFFUSE (1<<5) // (lightsource) whether to use directional shading
881 #define SHADERPERMUTATION_SPECULAR (1<<6) // (lightsource or deluxemapping) render specular effects
882 #define SHADERPERMUTATION_REFLECTION (1<<7) // normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
883 #define SHADERPERMUTATION_OFFSETMAPPING (1<<8) // adjust texcoords to roughly simulate a displacement mapped surface
884 #define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<9) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
885 #define SHADERPERMUTATION_MODEBASE (1<<10) // multiplier for the SHADERMODE_ values to get a valid index
887 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
888 const char *shaderpermutationinfo[][2] =
890 {"#define USECOLORMAPPING\n", " colormapping"},
891 {"#define USECONTRASTBOOST\n", " contrastboost"},
892 {"#define USEFOG\n", " fog"},
893 {"#define USECUBEFILTER\n", " cubefilter"},
894 {"#define USEGLOW\n", " glow"},
895 {"#define USEDIFFUSE\n", " diffuse"},
896 {"#define USESPECULAR\n", " specular"},
897 {"#define USEREFLECTION\n", " reflection"},
898 {"#define USEOFFSETMAPPING\n", " offsetmapping"},
899 {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
903 // this enum is multiplied by SHADERPERMUTATION_MODEBASE
904 typedef enum shadermode_e
906 SHADERMODE_LIGHTMAP, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
907 SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, // (lightmap) use directional pixel shading from texture containing modelspace light directions (deluxemap)
908 SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, // (lightmap) use directional pixel shading from texture containing tangentspace light directions (deluxemap)
909 SHADERMODE_LIGHTDIRECTION, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
910 SHADERMODE_LIGHTSOURCE, // (lightsource) use directional pixel shading from light source (rtlight)
911 SHADERMODE_REFRACTION, // refract background (the material is rendered normally after this pass)
912 SHADERMODE_WATER, // refract background and reflection (the material is rendered normally after this pass)
917 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
918 const char *shadermodeinfo[][2] =
920 {"#define MODE_LIGHTMAP\n", " lightmap"},
921 {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
922 {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
923 {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
924 {"#define MODE_LIGHTSOURCE\n", " lightsource"},
925 {"#define MODE_REFRACTION\n", " refraction"},
926 {"#define MODE_WATER\n", " water"},
930 #define SHADERPERMUTATION_INDICES (SHADERPERMUTATION_MODEBASE * SHADERMODE_COUNT)
932 typedef struct r_glsl_permutation_s
934 // indicates if we have tried compiling this permutation already
936 // 0 if compilation failed
938 // locations of detected uniforms in program object, or -1 if not found
939 int loc_Texture_Normal;
940 int loc_Texture_Color;
941 int loc_Texture_Gloss;
942 int loc_Texture_Cube;
943 int loc_Texture_Attenuation;
944 int loc_Texture_FogMask;
945 int loc_Texture_Pants;
946 int loc_Texture_Shirt;
947 int loc_Texture_Lightmap;
948 int loc_Texture_Deluxemap;
949 int loc_Texture_Glow;
950 int loc_Texture_Refraction;
951 int loc_Texture_Reflection;
953 int loc_LightPosition;
958 int loc_FogRangeRecip;
959 int loc_AmbientScale;
960 int loc_DiffuseScale;
961 int loc_SpecularScale;
962 int loc_SpecularPower;
964 int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost
965 int loc_OffsetMapping_Scale;
966 int loc_AmbientColor;
967 int loc_DiffuseColor;
968 int loc_SpecularColor;
970 int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost
971 int loc_DistortScaleRefractReflect;
972 int loc_ScreenScaleRefractReflect;
973 int loc_ScreenCenterRefractReflect;
974 int loc_RefractColor;
975 int loc_ReflectColor;
976 int loc_ReflectFactor;
977 int loc_ReflectOffset;
979 r_glsl_permutation_t;
981 // information about each possible shader permutation
982 r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_INDICES];
983 // currently selected permutation
984 r_glsl_permutation_t *r_glsl_permutation;
986 // these are additional flags used only by R_GLSL_CompilePermutation
987 #define SHADERTYPE_USES_VERTEXSHADER (1<<0)
988 #define SHADERTYPE_USES_GEOMETRYSHADER (1<<1)
989 #define SHADERTYPE_USES_FRAGMENTSHADER (1<<2)
991 static void R_GLSL_CompilePermutation(const char *filename, int permutation, int shadertype)
994 qboolean shaderfound;
995 r_glsl_permutation_t *p = r_glsl_permutations + permutation;
996 int vertstrings_count;
997 int geomstrings_count;
998 int fragstrings_count;
1000 const char *vertstrings_list[32+1];
1001 const char *geomstrings_list[32+1];
1002 const char *fragstrings_list[32+1];
1003 char permutationname[256];
1008 vertstrings_list[0] = "#define VERTEX_SHADER\n";
1009 geomstrings_list[0] = "#define GEOMETRY_SHADER\n";
1010 fragstrings_list[0] = "#define FRAGMENT_SHADER\n";
1011 vertstrings_count = 1;
1012 geomstrings_count = 1;
1013 fragstrings_count = 1;
1014 permutationname[0] = 0;
1015 i = permutation / SHADERPERMUTATION_MODEBASE;
1016 vertstrings_list[vertstrings_count++] = shadermodeinfo[i][0];
1017 geomstrings_list[geomstrings_count++] = shadermodeinfo[i][0];
1018 fragstrings_list[fragstrings_count++] = shadermodeinfo[i][0];
1019 strlcat(permutationname, shadermodeinfo[i][1], sizeof(permutationname));
1020 for (i = 0;shaderpermutationinfo[i][0];i++)
1022 if (permutation & (1<<i))
1024 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i][0];
1025 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i][0];
1026 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i][0];
1027 strlcat(permutationname, shaderpermutationinfo[i][1], sizeof(permutationname));
1031 // keep line numbers correct
1032 vertstrings_list[vertstrings_count++] = "\n";
1033 geomstrings_list[geomstrings_count++] = "\n";
1034 fragstrings_list[fragstrings_count++] = "\n";
1037 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1038 shaderfound = false;
1041 Con_DPrint("from disk... ");
1042 vertstrings_list[vertstrings_count++] = shaderstring;
1043 geomstrings_list[geomstrings_count++] = shaderstring;
1044 fragstrings_list[fragstrings_count++] = shaderstring;
1047 else if (!strcmp(filename, "glsl/default.glsl"))
1049 vertstrings_list[vertstrings_count++] = builtinshaderstring;
1050 geomstrings_list[geomstrings_count++] = builtinshaderstring;
1051 fragstrings_list[fragstrings_count++] = builtinshaderstring;
1054 // clear any lists that are not needed by this shader
1055 if (!(shadertype & SHADERTYPE_USES_VERTEXSHADER))
1056 vertstrings_count = 0;
1057 if (!(shadertype & SHADERTYPE_USES_GEOMETRYSHADER))
1058 geomstrings_count = 0;
1059 if (!(shadertype & SHADERTYPE_USES_FRAGMENTSHADER))
1060 fragstrings_count = 0;
1061 // compile the shader program
1062 if (shaderfound && vertstrings_count + geomstrings_count + fragstrings_count)
1063 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1067 qglUseProgramObjectARB(p->program);CHECKGLERROR
1068 // look up all the uniform variable names we care about, so we don't
1069 // have to look them up every time we set them
1070 p->loc_Texture_Normal = qglGetUniformLocationARB(p->program, "Texture_Normal");
1071 p->loc_Texture_Color = qglGetUniformLocationARB(p->program, "Texture_Color");
1072 p->loc_Texture_Gloss = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1073 p->loc_Texture_Cube = qglGetUniformLocationARB(p->program, "Texture_Cube");
1074 p->loc_Texture_Attenuation = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
1075 p->loc_Texture_FogMask = qglGetUniformLocationARB(p->program, "Texture_FogMask");
1076 p->loc_Texture_Pants = qglGetUniformLocationARB(p->program, "Texture_Pants");
1077 p->loc_Texture_Shirt = qglGetUniformLocationARB(p->program, "Texture_Shirt");
1078 p->loc_Texture_Lightmap = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
1079 p->loc_Texture_Deluxemap = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
1080 p->loc_Texture_Glow = qglGetUniformLocationARB(p->program, "Texture_Glow");
1081 p->loc_Texture_Refraction = qglGetUniformLocationARB(p->program, "Texture_Refraction");
1082 p->loc_Texture_Reflection = qglGetUniformLocationARB(p->program, "Texture_Reflection");
1083 p->loc_FogColor = qglGetUniformLocationARB(p->program, "FogColor");
1084 p->loc_LightPosition = qglGetUniformLocationARB(p->program, "LightPosition");
1085 p->loc_EyePosition = qglGetUniformLocationARB(p->program, "EyePosition");
1086 p->loc_LightColor = qglGetUniformLocationARB(p->program, "LightColor");
1087 p->loc_Color_Pants = qglGetUniformLocationARB(p->program, "Color_Pants");
1088 p->loc_Color_Shirt = qglGetUniformLocationARB(p->program, "Color_Shirt");
1089 p->loc_FogRangeRecip = qglGetUniformLocationARB(p->program, "FogRangeRecip");
1090 p->loc_AmbientScale = qglGetUniformLocationARB(p->program, "AmbientScale");
1091 p->loc_DiffuseScale = qglGetUniformLocationARB(p->program, "DiffuseScale");
1092 p->loc_SpecularPower = qglGetUniformLocationARB(p->program, "SpecularPower");
1093 p->loc_SpecularScale = qglGetUniformLocationARB(p->program, "SpecularScale");
1094 p->loc_GlowScale = qglGetUniformLocationARB(p->program, "GlowScale");
1095 p->loc_SceneBrightness = qglGetUniformLocationARB(p->program, "SceneBrightness");
1096 p->loc_OffsetMapping_Scale = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
1097 p->loc_AmbientColor = qglGetUniformLocationARB(p->program, "AmbientColor");
1098 p->loc_DiffuseColor = qglGetUniformLocationARB(p->program, "DiffuseColor");
1099 p->loc_SpecularColor = qglGetUniformLocationARB(p->program, "SpecularColor");
1100 p->loc_LightDir = qglGetUniformLocationARB(p->program, "LightDir");
1101 p->loc_ContrastBoostCoeff = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff");
1102 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
1103 p->loc_ScreenScaleRefractReflect = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
1104 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
1105 p->loc_RefractColor = qglGetUniformLocationARB(p->program, "RefractColor");
1106 p->loc_ReflectColor = qglGetUniformLocationARB(p->program, "ReflectColor");
1107 p->loc_ReflectFactor = qglGetUniformLocationARB(p->program, "ReflectFactor");
1108 p->loc_ReflectOffset = qglGetUniformLocationARB(p->program, "ReflectOffset");
1109 // initialize the samplers to refer to the texture units we use
1110 if (p->loc_Texture_Normal >= 0) qglUniform1iARB(p->loc_Texture_Normal, 0);
1111 if (p->loc_Texture_Color >= 0) qglUniform1iARB(p->loc_Texture_Color, 1);
1112 if (p->loc_Texture_Gloss >= 0) qglUniform1iARB(p->loc_Texture_Gloss, 2);
1113 if (p->loc_Texture_Cube >= 0) qglUniform1iARB(p->loc_Texture_Cube, 3);
1114 if (p->loc_Texture_FogMask >= 0) qglUniform1iARB(p->loc_Texture_FogMask, 4);
1115 if (p->loc_Texture_Pants >= 0) qglUniform1iARB(p->loc_Texture_Pants, 5);
1116 if (p->loc_Texture_Shirt >= 0) qglUniform1iARB(p->loc_Texture_Shirt, 6);
1117 if (p->loc_Texture_Lightmap >= 0) qglUniform1iARB(p->loc_Texture_Lightmap, 7);
1118 if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap, 8);
1119 if (p->loc_Texture_Glow >= 0) qglUniform1iARB(p->loc_Texture_Glow, 9);
1120 if (p->loc_Texture_Attenuation >= 0) qglUniform1iARB(p->loc_Texture_Attenuation, 10);
1121 if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction, 11);
1122 if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection, 12);
1124 qglUseProgramObjectARB(0);CHECKGLERROR
1125 if (developer.integer)
1126 Con_Printf("GLSL shader %s :%s compiled.\n", filename, permutationname);
1130 if (developer.integer)
1131 Con_Printf("GLSL shader %s :%s failed! source code line offset for above errors is %i.\n", permutationname, filename, -(vertstrings_count - 1));
1133 Con_Printf("GLSL shader %s :%s failed! some features may not work properly.\n", permutationname, filename);
1136 Mem_Free(shaderstring);
1139 void R_GLSL_Restart_f(void)
1142 for (i = 0;i < SHADERPERMUTATION_INDICES;i++)
1143 if (r_glsl_permutations[i].program)
1144 GL_Backend_FreeProgram(r_glsl_permutations[i].program);
1145 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1148 void R_GLSL_DumpShader_f(void)
1152 qfile_t *file = FS_Open("glsl/default.glsl", "w", false, false);
1155 Con_Printf("failed to write to glsl/default.glsl\n");
1159 FS_Print(file, "// The engine may define the following macros:\n");
1160 FS_Print(file, "// #define VERTEX_SHADER\n// #define GEOMETRY_SHADER\n// #define FRAGMENT_SHADER\n");
1161 for (i = 0;shadermodeinfo[i][0];i++)
1162 FS_Printf(file, "// %s", shadermodeinfo[i][0]);
1163 for (i = 0;shaderpermutationinfo[i][0];i++)
1164 FS_Printf(file, "// %s", shaderpermutationinfo[i][0]);
1165 FS_Print(file, "\n");
1166 FS_Print(file, builtinshaderstring);
1169 Con_Printf("glsl/default.glsl written\n");
1172 extern rtexture_t *r_shadow_attenuationgradienttexture;
1173 extern rtexture_t *r_shadow_attenuation2dtexture;
1174 extern rtexture_t *r_shadow_attenuation3dtexture;
1175 int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
1177 // select a permutation of the lighting shader appropriate to this
1178 // combination of texture, entity, light source, and fogging, only use the
1179 // minimum features necessary to avoid wasting rendering time in the
1180 // fragment shader on features that are not being used
1181 const char *shaderfilename = NULL;
1182 unsigned int permutation = 0;
1183 unsigned int shadertype = 0;
1184 shadermode_t mode = 0;
1185 r_glsl_permutation = NULL;
1186 shaderfilename = "glsl/default.glsl";
1187 shadertype = SHADERTYPE_USES_VERTEXSHADER | SHADERTYPE_USES_FRAGMENTSHADER;
1188 // TODO: implement geometry-shader based shadow volumes someday
1189 if (r_glsl_offsetmapping.integer)
1191 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1192 if (r_glsl_offsetmapping_reliefmapping.integer)
1193 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1195 if (rsurfacepass == RSURFPASS_BACKGROUND)
1197 // distorted background
1198 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
1199 mode = SHADERMODE_WATER;
1201 mode = SHADERMODE_REFRACTION;
1203 else if (rsurfacepass == RSURFPASS_RTLIGHT)
1206 mode = SHADERMODE_LIGHTSOURCE;
1207 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1208 permutation |= SHADERPERMUTATION_CUBEFILTER;
1209 if (diffusescale > 0)
1210 permutation |= SHADERPERMUTATION_DIFFUSE;
1211 if (specularscale > 0)
1212 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1213 if (r_refdef.fogenabled)
1214 permutation |= SHADERPERMUTATION_FOG;
1215 if (rsurface.texture->colormapping)
1216 permutation |= SHADERPERMUTATION_COLORMAPPING;
1217 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1218 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1219 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1220 permutation |= SHADERPERMUTATION_REFLECTION;
1222 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1224 // unshaded geometry (fullbright or ambient model lighting)
1225 mode = SHADERMODE_LIGHTMAP;
1226 if (rsurface.texture->currentskinframe->glow)
1227 permutation |= SHADERPERMUTATION_GLOW;
1228 if (r_refdef.fogenabled)
1229 permutation |= SHADERPERMUTATION_FOG;
1230 if (rsurface.texture->colormapping)
1231 permutation |= SHADERPERMUTATION_COLORMAPPING;
1232 if (r_glsl_offsetmapping.integer)
1234 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1235 if (r_glsl_offsetmapping_reliefmapping.integer)
1236 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1238 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1239 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1240 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1241 permutation |= SHADERPERMUTATION_REFLECTION;
1243 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
1245 // directional model lighting
1246 mode = SHADERMODE_LIGHTDIRECTION;
1247 if (rsurface.texture->currentskinframe->glow)
1248 permutation |= SHADERPERMUTATION_GLOW;
1249 permutation |= SHADERPERMUTATION_DIFFUSE;
1250 if (specularscale > 0)
1251 permutation |= SHADERPERMUTATION_SPECULAR;
1252 if (r_refdef.fogenabled)
1253 permutation |= SHADERPERMUTATION_FOG;
1254 if (rsurface.texture->colormapping)
1255 permutation |= SHADERPERMUTATION_COLORMAPPING;
1256 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1257 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1258 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1259 permutation |= SHADERPERMUTATION_REFLECTION;
1261 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
1263 // ambient model lighting
1264 mode = SHADERMODE_LIGHTDIRECTION;
1265 if (rsurface.texture->currentskinframe->glow)
1266 permutation |= SHADERPERMUTATION_GLOW;
1267 if (r_refdef.fogenabled)
1268 permutation |= SHADERPERMUTATION_FOG;
1269 if (rsurface.texture->colormapping)
1270 permutation |= SHADERPERMUTATION_COLORMAPPING;
1271 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1272 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1273 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1274 permutation |= SHADERPERMUTATION_REFLECTION;
1279 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
1281 // deluxemapping (light direction texture)
1282 if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
1283 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
1285 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1286 if (specularscale > 0)
1287 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1289 else if (r_glsl_deluxemapping.integer >= 2)
1291 // fake deluxemapping (uniform light direction in tangentspace)
1292 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1293 if (specularscale > 0)
1294 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1298 // ordinary lightmapping
1299 mode = SHADERMODE_LIGHTMAP;
1301 if (rsurface.texture->currentskinframe->glow)
1302 permutation |= SHADERPERMUTATION_GLOW;
1303 if (r_refdef.fogenabled)
1304 permutation |= SHADERPERMUTATION_FOG;
1305 if (rsurface.texture->colormapping)
1306 permutation |= SHADERPERMUTATION_COLORMAPPING;
1307 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1308 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1309 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1310 permutation |= SHADERPERMUTATION_REFLECTION;
1312 permutation |= mode * SHADERPERMUTATION_MODEBASE;
1313 if (!r_glsl_permutations[permutation].program)
1315 if (!r_glsl_permutations[permutation].compiled)
1316 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1317 if (!r_glsl_permutations[permutation].program)
1319 // remove features until we find a valid permutation
1321 for (i = (SHADERPERMUTATION_MODEBASE >> 1);;i>>=1)
1325 Con_Printf("OpenGL 2.0 shaders disabled - unable to find a working shader permutation fallback on this driver (set r_glsl 1 if you want to try again)\n");
1326 Cvar_SetValueQuick(&r_glsl, 0);
1327 return 0; // no bit left to clear
1329 // reduce i more quickly whenever it would not remove any bits
1330 if (!(permutation & i))
1333 if (!r_glsl_permutations[permutation].compiled)
1334 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1335 if (r_glsl_permutations[permutation].program)
1340 r_glsl_permutation = r_glsl_permutations + permutation;
1342 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
1343 if (mode == SHADERMODE_LIGHTSOURCE)
1345 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
1346 if (permutation & SHADERPERMUTATION_DIFFUSE)
1348 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
1349 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, ambientscale);
1350 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, diffusescale);
1351 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, specularscale);
1355 // ambient only is simpler
1356 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0] * ambientscale, lightcolorbase[1] * ambientscale, lightcolorbase[2] * ambientscale);
1357 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, 1);
1358 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, 0);
1359 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, 0);
1362 else if (mode == SHADERMODE_LIGHTDIRECTION)
1364 if (r_glsl_permutation->loc_AmbientColor >= 0)
1365 qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale * r_refdef.lightmapintensity, rsurface.modellight_ambient[1] * ambientscale * r_refdef.lightmapintensity, rsurface.modellight_ambient[2] * ambientscale * r_refdef.lightmapintensity);
1366 if (r_glsl_permutation->loc_DiffuseColor >= 0)
1367 qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface.modellight_diffuse[0] * diffusescale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[1] * diffusescale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[2] * diffusescale * r_refdef.lightmapintensity);
1368 if (r_glsl_permutation->loc_SpecularColor >= 0)
1369 qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[1] * specularscale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[2] * specularscale * r_refdef.lightmapintensity);
1370 if (r_glsl_permutation->loc_LightDir >= 0)
1371 qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
1375 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_ambient.value * 2.0f / 128.0f);
1376 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
1377 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
1379 if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
1380 if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
1382 // The formula used is actually:
1383 // color.rgb *= SceneBrightness;
1384 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
1385 // I simplify that to
1386 // color.rgb *= [[SceneBrightness * ContrastBoost]];
1387 // color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1;
1389 // color.rgb = [[SceneBrightness * ContrastBoost]] * color.rgb / ([[(ContrastBoost - 1) * SceneBrightness]] * color.rgb + 1);
1390 // and do [[calculations]] here in the engine
1391 qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale);
1392 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value);
1395 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
1396 if (r_glsl_permutation->loc_FogColor >= 0)
1398 // additive passes are only darkened by fog, not tinted
1399 if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
1400 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
1402 qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
1404 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
1405 if (r_glsl_permutation->loc_Color_Pants >= 0)
1407 if (rsurface.texture->currentskinframe->pants)
1408 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
1410 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
1412 if (r_glsl_permutation->loc_Color_Shirt >= 0)
1414 if (rsurface.texture->currentskinframe->shirt)
1415 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
1417 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
1419 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
1420 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
1421 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
1422 if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
1423 if (r_glsl_permutation->loc_ScreenScaleRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);
1424 if (r_glsl_permutation->loc_ScreenCenterRefractReflect >= 0) qglUniform4fARB(r_glsl_permutation->loc_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);
1425 if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
1426 if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
1427 if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
1428 if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
1433 #define SKINFRAME_HASH 1024
1437 int loadsequence; // incremented each level change
1438 memexpandablearray_t array;
1439 skinframe_t *hash[SKINFRAME_HASH];
1443 void R_SkinFrame_PrepareForPurge(void)
1445 r_skinframe.loadsequence++;
1446 // wrap it without hitting zero
1447 if (r_skinframe.loadsequence >= 200)
1448 r_skinframe.loadsequence = 1;
1451 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
1455 // mark the skinframe as used for the purging code
1456 skinframe->loadsequence = r_skinframe.loadsequence;
1459 void R_SkinFrame_Purge(void)
1463 for (i = 0;i < SKINFRAME_HASH;i++)
1465 for (s = r_skinframe.hash[i];s;s = s->next)
1467 if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
1469 if (s->merged == s->base)
1471 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
1472 R_PurgeTexture(s->stain );s->stain = NULL;
1473 R_PurgeTexture(s->merged);s->merged = NULL;
1474 R_PurgeTexture(s->base );s->base = NULL;
1475 R_PurgeTexture(s->pants );s->pants = NULL;
1476 R_PurgeTexture(s->shirt );s->shirt = NULL;
1477 R_PurgeTexture(s->nmap );s->nmap = NULL;
1478 R_PurgeTexture(s->gloss );s->gloss = NULL;
1479 R_PurgeTexture(s->glow );s->glow = NULL;
1480 R_PurgeTexture(s->fog );s->fog = NULL;
1481 s->loadsequence = 0;
1487 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
1489 char basename[MAX_QPATH];
1491 Image_StripImageExtension(name, basename, sizeof(basename));
1493 if( last == NULL ) {
1495 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1496 item = r_skinframe.hash[hashindex];
1501 // linearly search through the hash bucket
1502 for( ; item ; item = item->next ) {
1503 if( !strcmp( item->basename, basename ) ) {
1510 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
1514 char basename[MAX_QPATH];
1516 Image_StripImageExtension(name, basename, sizeof(basename));
1518 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1519 for (item = r_skinframe.hash[hashindex];item;item = item->next)
1520 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
1524 rtexture_t *dyntexture;
1525 // check whether its a dynamic texture
1526 dyntexture = CL_GetDynTexture( basename );
1527 if (!add && !dyntexture)
1529 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
1530 memset(item, 0, sizeof(*item));
1531 strlcpy(item->basename, basename, sizeof(item->basename));
1532 item->base = dyntexture; // either NULL or dyntexture handle
1533 item->textureflags = textureflags;
1534 item->comparewidth = comparewidth;
1535 item->compareheight = compareheight;
1536 item->comparecrc = comparecrc;
1537 item->next = r_skinframe.hash[hashindex];
1538 r_skinframe.hash[hashindex] = item;
1540 else if( item->base == NULL )
1542 rtexture_t *dyntexture;
1543 // check whether its a dynamic texture
1544 // this only needs to be done because Purge doesnt delete skinframes - only sets the texture pointers to NULL and we need to restore it before returing.. [11/29/2007 Black]
1545 dyntexture = CL_GetDynTexture( basename );
1546 item->base = dyntexture; // either NULL or dyntexture handle
1549 R_SkinFrame_MarkUsed(item);
1553 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
1555 // FIXME: it should be possible to disable loading various layers using
1556 // cvars, to prevent wasted loading time and memory usage if the user does
1558 qboolean loadnormalmap = true;
1559 qboolean loadgloss = true;
1560 qboolean loadpantsandshirt = true;
1561 qboolean loadglow = true;
1563 unsigned char *pixels;
1564 unsigned char *bumppixels;
1565 unsigned char *basepixels = NULL;
1566 int basepixels_width;
1567 int basepixels_height;
1568 skinframe_t *skinframe;
1570 if (cls.state == ca_dedicated)
1573 // return an existing skinframe if already loaded
1574 // if loading of the first image fails, don't make a new skinframe as it
1575 // would cause all future lookups of this to be missing
1576 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
1577 if (skinframe && skinframe->base)
1580 basepixels = loadimagepixelsbgra(name, complain, true);
1581 if (basepixels == NULL)
1584 // we've got some pixels to store, so really allocate this new texture now
1586 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
1587 skinframe->stain = NULL;
1588 skinframe->merged = NULL;
1589 skinframe->base = r_texture_notexture;
1590 skinframe->pants = NULL;
1591 skinframe->shirt = NULL;
1592 skinframe->nmap = r_texture_blanknormalmap;
1593 skinframe->gloss = NULL;
1594 skinframe->glow = NULL;
1595 skinframe->fog = NULL;
1597 basepixels_width = image_width;
1598 basepixels_height = image_height;
1599 skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1601 if (textureflags & TEXF_ALPHA)
1603 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
1604 if (basepixels[j] < 255)
1606 if (j < basepixels_width * basepixels_height * 4)
1608 // has transparent pixels
1609 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1610 for (j = 0;j < image_width * image_height * 4;j += 4)
1615 pixels[j+3] = basepixels[j+3];
1617 skinframe->fog = R_LoadTexture2D (r_main_texturepool, va("%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1622 // _norm is the name used by tenebrae and has been adopted as standard
1625 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL)
1627 skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1631 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL)
1633 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1634 Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
1635 skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1637 Mem_Free(bumppixels);
1639 else if (r_shadow_bumpscale_basetexture.value > 0)
1641 pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
1642 Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
1643 skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1647 // _luma is supported for tenebrae compatibility
1648 // (I think it's a very stupid name, but oh well)
1649 // _glow is the preferred name
1650 if (loadglow && ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false)) != NULL || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false)) != NULL)) {skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1651 if (loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false)) != NULL) {skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1652 if (loadpantsandshirt && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false)) != NULL) {skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1653 if (loadpantsandshirt && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false)) != NULL) {skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL);Mem_Free(pixels);pixels = NULL;}
1656 Mem_Free(basepixels);
1661 static rtexture_t *R_SkinFrame_TextureForSkinLayer(const unsigned char *in, int width, int height, const char *name, const unsigned int *palette, int textureflags, qboolean force)
1666 for (i = 0;i < width*height;i++)
1667 if (((unsigned char *)&palette[in[i]])[3] > 0)
1669 if (i == width*height)
1672 return R_LoadTexture2D (r_main_texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
1675 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
1676 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
1679 unsigned char *temp1, *temp2;
1680 skinframe_t *skinframe;
1682 if (cls.state == ca_dedicated)
1685 // if already loaded just return it, otherwise make a new skinframe
1686 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
1687 if (skinframe && skinframe->base)
1690 skinframe->stain = NULL;
1691 skinframe->merged = NULL;
1692 skinframe->base = r_texture_notexture;
1693 skinframe->pants = NULL;
1694 skinframe->shirt = NULL;
1695 skinframe->nmap = r_texture_blanknormalmap;
1696 skinframe->gloss = NULL;
1697 skinframe->glow = NULL;
1698 skinframe->fog = NULL;
1700 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1704 if (r_shadow_bumpscale_basetexture.value > 0)
1706 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1707 temp2 = temp1 + width * height * 4;
1708 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1709 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1712 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1713 if (textureflags & TEXF_ALPHA)
1715 for (i = 3;i < width * height * 4;i += 4)
1716 if (skindata[i] < 255)
1718 if (i < width * height * 4)
1720 unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
1721 memcpy(fogpixels, skindata, width * height * 4);
1722 for (i = 0;i < width * height * 4;i += 4)
1723 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
1724 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1725 Mem_Free(fogpixels);
1732 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
1735 unsigned char *temp1, *temp2;
1736 skinframe_t *skinframe;
1738 if (cls.state == ca_dedicated)
1741 // if already loaded just return it, otherwise make a new skinframe
1742 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
1743 if (skinframe && skinframe->base)
1746 skinframe->stain = NULL;
1747 skinframe->merged = NULL;
1748 skinframe->base = r_texture_notexture;
1749 skinframe->pants = NULL;
1750 skinframe->shirt = NULL;
1751 skinframe->nmap = r_texture_blanknormalmap;
1752 skinframe->gloss = NULL;
1753 skinframe->glow = NULL;
1754 skinframe->fog = NULL;
1756 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1760 if (r_shadow_bumpscale_basetexture.value > 0)
1762 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1763 temp2 = temp1 + width * height * 4;
1764 // use either a custom palette or the quake palette
1765 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
1766 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1767 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1770 // use either a custom palette, or the quake palette
1771 skinframe->base = skinframe->merged = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_merged", skinframe->basename), (loadglowtexture ? palette_bgra_nofullbrights : ((skinframe->textureflags & TEXF_ALPHA) ? palette_bgra_transparent : palette_bgra_complete)), skinframe->textureflags, true); // all
1772 if (loadglowtexture)
1773 skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_bgra_onlyfullbrights, skinframe->textureflags, false); // glow
1774 if (loadpantsandshirt)
1776 skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_bgra_pantsaswhite, skinframe->textureflags, false); // pants
1777 skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_bgra_shirtaswhite, skinframe->textureflags, false); // shirt
1779 if (skinframe->pants || skinframe->shirt)
1780 skinframe->base = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", skinframe->basename), loadglowtexture ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap, skinframe->textureflags, false); // no special colors
1781 if (textureflags & TEXF_ALPHA)
1783 for (i = 0;i < width * height;i++)
1784 if (((unsigned char *)palette_bgra_alpha)[skindata[i]*4+3] < 255)
1786 if (i < width * height)
1787 skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), palette_bgra_alpha, skinframe->textureflags, true); // fog mask
1793 skinframe_t *R_SkinFrame_LoadMissing(void)
1795 skinframe_t *skinframe;
1797 if (cls.state == ca_dedicated)
1800 skinframe = R_SkinFrame_Find("missing", TEXF_PRECACHE, 0, 0, 0, true);
1801 skinframe->stain = NULL;
1802 skinframe->merged = NULL;
1803 skinframe->base = r_texture_notexture;
1804 skinframe->pants = NULL;
1805 skinframe->shirt = NULL;
1806 skinframe->nmap = r_texture_blanknormalmap;
1807 skinframe->gloss = NULL;
1808 skinframe->glow = NULL;
1809 skinframe->fog = NULL;
1814 void gl_main_start(void)
1819 r = -16.0 / (1.0 * FOGMASKTABLEWIDTH * FOGMASKTABLEWIDTH);
1820 for (x = 0;x < FOGMASKTABLEWIDTH;x++)
1822 alpha = exp(r * ((double)x*(double)x));
1823 if (x == FOGMASKTABLEWIDTH - 1)
1825 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
1828 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1829 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1831 // set up r_skinframe loading system for textures
1832 memset(&r_skinframe, 0, sizeof(r_skinframe));
1833 r_skinframe.loadsequence = 1;
1834 Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
1836 r_main_texturepool = R_AllocTexturePool();
1837 R_BuildBlankTextures();
1839 if (gl_texturecubemap)
1842 R_BuildNormalizationCube();
1844 R_BuildFogTexture();
1845 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1846 memset(&r_waterstate, 0, sizeof(r_waterstate));
1847 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1848 memset(&r_svbsp, 0, sizeof (r_svbsp));
1851 void gl_main_shutdown(void)
1853 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1854 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1856 // clear out the r_skinframe state
1857 Mem_ExpandableArray_FreeArray(&r_skinframe.array);
1858 memset(&r_skinframe, 0, sizeof(r_skinframe));
1861 Mem_Free(r_svbsp.nodes);
1862 memset(&r_svbsp, 0, sizeof (r_svbsp));
1863 R_FreeTexturePool(&r_main_texturepool);
1864 r_texture_blanknormalmap = NULL;
1865 r_texture_white = NULL;
1866 r_texture_grey128 = NULL;
1867 r_texture_black = NULL;
1868 r_texture_whitecube = NULL;
1869 r_texture_normalizationcube = NULL;
1870 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1871 memset(&r_waterstate, 0, sizeof(r_waterstate));
1875 extern void CL_ParseEntityLump(char *entitystring);
1876 void gl_main_newmap(void)
1878 // FIXME: move this code to client
1880 char *entities, entname[MAX_QPATH];
1883 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
1884 l = (int)strlen(entname) - 4;
1885 if (l >= 0 && !strcmp(entname + l, ".bsp"))
1887 memcpy(entname + l, ".ent", 5);
1888 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
1890 CL_ParseEntityLump(entities);
1895 if (cl.worldmodel->brush.entities)
1896 CL_ParseEntityLump(cl.worldmodel->brush.entities);
1900 void GL_Main_Init(void)
1902 r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
1904 Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
1905 Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
1906 // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
1907 if (gamemode == GAME_NEHAHRA)
1909 Cvar_RegisterVariable (&gl_fogenable);
1910 Cvar_RegisterVariable (&gl_fogdensity);
1911 Cvar_RegisterVariable (&gl_fogred);
1912 Cvar_RegisterVariable (&gl_foggreen);
1913 Cvar_RegisterVariable (&gl_fogblue);
1914 Cvar_RegisterVariable (&gl_fogstart);
1915 Cvar_RegisterVariable (&gl_fogend);
1917 Cvar_RegisterVariable(&r_depthfirst);
1918 Cvar_RegisterVariable(&r_nearclip);
1919 Cvar_RegisterVariable(&r_showbboxes);
1920 Cvar_RegisterVariable(&r_showsurfaces);
1921 Cvar_RegisterVariable(&r_showtris);
1922 Cvar_RegisterVariable(&r_shownormals);
1923 Cvar_RegisterVariable(&r_showlighting);
1924 Cvar_RegisterVariable(&r_showshadowvolumes);
1925 Cvar_RegisterVariable(&r_showcollisionbrushes);
1926 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
1927 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
1928 Cvar_RegisterVariable(&r_showdisabledepthtest);
1929 Cvar_RegisterVariable(&r_drawportals);
1930 Cvar_RegisterVariable(&r_drawentities);
1931 Cvar_RegisterVariable(&r_cullentities_trace);
1932 Cvar_RegisterVariable(&r_cullentities_trace_samples);
1933 Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
1934 Cvar_RegisterVariable(&r_cullentities_trace_delay);
1935 Cvar_RegisterVariable(&r_drawviewmodel);
1936 Cvar_RegisterVariable(&r_speeds);
1937 Cvar_RegisterVariable(&r_fullbrights);
1938 Cvar_RegisterVariable(&r_wateralpha);
1939 Cvar_RegisterVariable(&r_dynamic);
1940 Cvar_RegisterVariable(&r_fullbright);
1941 Cvar_RegisterVariable(&r_shadows);
1942 Cvar_RegisterVariable(&r_shadows_throwdistance);
1943 Cvar_RegisterVariable(&r_q1bsp_skymasking);
1944 Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
1945 Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
1946 Cvar_RegisterVariable(&r_textureunits);
1947 Cvar_RegisterVariable(&r_glsl);
1948 Cvar_RegisterVariable(&r_glsl_offsetmapping);
1949 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
1950 Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
1951 Cvar_RegisterVariable(&r_glsl_deluxemapping);
1952 Cvar_RegisterVariable(&r_water);
1953 Cvar_RegisterVariable(&r_water_resolutionmultiplier);
1954 Cvar_RegisterVariable(&r_water_clippingplanebias);
1955 Cvar_RegisterVariable(&r_water_refractdistort);
1956 Cvar_RegisterVariable(&r_water_reflectdistort);
1957 Cvar_RegisterVariable(&r_lerpsprites);
1958 Cvar_RegisterVariable(&r_lerpmodels);
1959 Cvar_RegisterVariable(&r_lerplightstyles);
1960 Cvar_RegisterVariable(&r_waterscroll);
1961 Cvar_RegisterVariable(&r_bloom);
1962 Cvar_RegisterVariable(&r_bloom_colorscale);
1963 Cvar_RegisterVariable(&r_bloom_brighten);
1964 Cvar_RegisterVariable(&r_bloom_blur);
1965 Cvar_RegisterVariable(&r_bloom_resolution);
1966 Cvar_RegisterVariable(&r_bloom_colorexponent);
1967 Cvar_RegisterVariable(&r_bloom_colorsubtract);
1968 Cvar_RegisterVariable(&r_hdr);
1969 Cvar_RegisterVariable(&r_hdr_scenebrightness);
1970 Cvar_RegisterVariable(&r_glsl_contrastboost);
1971 Cvar_RegisterVariable(&r_hdr_glowintensity);
1972 Cvar_RegisterVariable(&r_hdr_range);
1973 Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
1974 Cvar_RegisterVariable(&developer_texturelogging);
1975 Cvar_RegisterVariable(&gl_lightmaps);
1976 Cvar_RegisterVariable(&r_test);
1977 Cvar_RegisterVariable(&r_batchmode);
1978 if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
1979 Cvar_SetValue("r_fullbrights", 0);
1980 R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
1982 Cvar_RegisterVariable(&r_track_sprites);
1983 Cvar_RegisterVariable(&r_track_sprites_flags);
1984 Cvar_RegisterVariable(&r_track_sprites_scalew);
1985 Cvar_RegisterVariable(&r_track_sprites_scaleh);
1988 extern void R_Textures_Init(void);
1989 extern void GL_Draw_Init(void);
1990 extern void GL_Main_Init(void);
1991 extern void R_Shadow_Init(void);
1992 extern void R_Sky_Init(void);
1993 extern void GL_Surf_Init(void);
1994 extern void R_Particles_Init(void);
1995 extern void R_Explosion_Init(void);
1996 extern void gl_backend_init(void);
1997 extern void Sbar_Init(void);
1998 extern void R_LightningBeams_Init(void);
1999 extern void Mod_RenderInit(void);
2001 void Render_Init(void)
2013 R_LightningBeams_Init();
2022 extern char *ENGINE_EXTENSIONS;
2025 VID_CheckExtensions();
2027 // LordHavoc: report supported extensions
2028 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2030 // clear to black (loading plaque will be seen over this)
2032 qglClearColor(0,0,0,1);CHECKGLERROR
2033 qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
2036 int R_CullBox(const vec3_t mins, const vec3_t maxs)
2040 for (i = 0;i < r_view.numfrustumplanes;i++)
2042 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
2045 p = r_view.frustum + i;
2050 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2054 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2058 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2062 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2066 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2070 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2074 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2078 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2086 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
2090 for (i = 0;i < numplanes;i++)
2097 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2101 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2105 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2109 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2113 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2117 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2121 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2125 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2133 //==================================================================================
2135 static void R_View_UpdateEntityVisible (void)
2138 entity_render_t *ent;
2140 if (!r_drawentities.integer)
2143 renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
2144 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
2146 // worldmodel can check visibility
2147 for (i = 0;i < r_refdef.numentities;i++)
2149 ent = r_refdef.entities[i];
2150 r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs)) && ((ent->effects & EF_NODEPTHTEST) || (ent->flags & RENDER_VIEWMODEL) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_viewcache.world_leafvisible, ent->mins, ent->maxs));
2153 if(r_cullentities_trace.integer)
2155 for (i = 0;i < r_refdef.numentities;i++)
2157 ent = r_refdef.entities[i];
2158 if(r_viewcache.entityvisible[i] && !(ent->effects & EF_NODEPTHTEST) && !(ent->flags & RENDER_VIEWMODEL) && !(ent->model && (ent->model->name[0] == '*')))
2160 if(Mod_CanSeeBox_Trace(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.worldmodel, r_view.origin, ent->mins, ent->maxs))
2161 ent->last_trace_visibility = realtime;
2162 if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
2163 r_viewcache.entityvisible[i] = 0;
2170 // no worldmodel or it can't check visibility
2171 for (i = 0;i < r_refdef.numentities;i++)
2173 ent = r_refdef.entities[i];
2174 r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs));
2179 // only used if skyrendermasked, and normally returns false
2180 int R_DrawBrushModelsSky (void)
2183 entity_render_t *ent;
2185 if (!r_drawentities.integer)
2189 for (i = 0;i < r_refdef.numentities;i++)
2191 if (!r_viewcache.entityvisible[i])
2193 ent = r_refdef.entities[i];
2194 if (!ent->model || !ent->model->DrawSky)
2196 ent->model->DrawSky(ent);
2202 static void R_DrawNoModel(entity_render_t *ent);
2203 static void R_DrawModels(void)
2206 entity_render_t *ent;
2208 if (!r_drawentities.integer)
2211 for (i = 0;i < r_refdef.numentities;i++)
2213 if (!r_viewcache.entityvisible[i])
2215 ent = r_refdef.entities[i];
2216 r_refdef.stats.entities++;
2217 if (ent->model && ent->model->Draw != NULL)
2218 ent->model->Draw(ent);
2224 static void R_DrawModelsDepth(void)
2227 entity_render_t *ent;
2229 if (!r_drawentities.integer)
2232 for (i = 0;i < r_refdef.numentities;i++)
2234 if (!r_viewcache.entityvisible[i])
2236 ent = r_refdef.entities[i];
2237 if (ent->model && ent->model->DrawDepth != NULL)
2238 ent->model->DrawDepth(ent);
2242 static void R_DrawModelsDebug(void)
2245 entity_render_t *ent;
2247 if (!r_drawentities.integer)
2250 for (i = 0;i < r_refdef.numentities;i++)
2252 if (!r_viewcache.entityvisible[i])
2254 ent = r_refdef.entities[i];
2255 if (ent->model && ent->model->DrawDebug != NULL)
2256 ent->model->DrawDebug(ent);
2260 static void R_DrawModelsAddWaterPlanes(void)
2263 entity_render_t *ent;
2265 if (!r_drawentities.integer)
2268 for (i = 0;i < r_refdef.numentities;i++)
2270 if (!r_viewcache.entityvisible[i])
2272 ent = r_refdef.entities[i];
2273 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
2274 ent->model->DrawAddWaterPlanes(ent);
2278 static void R_View_SetFrustum(void)
2281 double slopex, slopey;
2283 // break apart the view matrix into vectors for various purposes
2284 Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
2285 VectorNegate(r_view.left, r_view.right);
2288 r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
2289 r_view.frustum[0].normal[1] = 0 - 0;
2290 r_view.frustum[0].normal[2] = -1 - 0;
2291 r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
2292 r_view.frustum[1].normal[1] = 0 + 0;
2293 r_view.frustum[1].normal[2] = -1 + 0;
2294 r_view.frustum[2].normal[0] = 0 - 0;
2295 r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
2296 r_view.frustum[2].normal[2] = -1 - 0;
2297 r_view.frustum[3].normal[0] = 0 + 0;
2298 r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
2299 r_view.frustum[3].normal[2] = -1 + 0;
2303 zNear = r_refdef.nearclip;
2304 nudge = 1.0 - 1.0 / (1<<23);
2305 r_view.frustum[4].normal[0] = 0 - 0;
2306 r_view.frustum[4].normal[1] = 0 - 0;
2307 r_view.frustum[4].normal[2] = -1 - -nudge;
2308 r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
2309 r_view.frustum[5].normal[0] = 0 + 0;
2310 r_view.frustum[5].normal[1] = 0 + 0;
2311 r_view.frustum[5].normal[2] = -1 + -nudge;
2312 r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
2318 r_view.frustum[0].normal[0] = m[3] - m[0];
2319 r_view.frustum[0].normal[1] = m[7] - m[4];
2320 r_view.frustum[0].normal[2] = m[11] - m[8];
2321 r_view.frustum[0].dist = m[15] - m[12];
2323 r_view.frustum[1].normal[0] = m[3] + m[0];
2324 r_view.frustum[1].normal[1] = m[7] + m[4];
2325 r_view.frustum[1].normal[2] = m[11] + m[8];
2326 r_view.frustum[1].dist = m[15] + m[12];
2328 r_view.frustum[2].normal[0] = m[3] - m[1];
2329 r_view.frustum[2].normal[1] = m[7] - m[5];
2330 r_view.frustum[2].normal[2] = m[11] - m[9];
2331 r_view.frustum[2].dist = m[15] - m[13];
2333 r_view.frustum[3].normal[0] = m[3] + m[1];
2334 r_view.frustum[3].normal[1] = m[7] + m[5];
2335 r_view.frustum[3].normal[2] = m[11] + m[9];
2336 r_view.frustum[3].dist = m[15] + m[13];
2338 r_view.frustum[4].normal[0] = m[3] - m[2];
2339 r_view.frustum[4].normal[1] = m[7] - m[6];
2340 r_view.frustum[4].normal[2] = m[11] - m[10];
2341 r_view.frustum[4].dist = m[15] - m[14];
2343 r_view.frustum[5].normal[0] = m[3] + m[2];
2344 r_view.frustum[5].normal[1] = m[7] + m[6];
2345 r_view.frustum[5].normal[2] = m[11] + m[10];
2346 r_view.frustum[5].dist = m[15] + m[14];
2349 if (r_view.useperspective)
2351 slopex = 1.0 / r_view.frustum_x;
2352 slopey = 1.0 / r_view.frustum_y;
2353 VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
2354 VectorMA(r_view.forward, slopex, r_view.left, r_view.frustum[1].normal);
2355 VectorMA(r_view.forward, -slopey, r_view.up , r_view.frustum[2].normal);
2356 VectorMA(r_view.forward, slopey, r_view.up , r_view.frustum[3].normal);
2357 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2359 // Leaving those out was a mistake, those were in the old code, and they
2360 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
2361 // I couldn't reproduce it after adding those normalizations. --blub
2362 VectorNormalize(r_view.frustum[0].normal);
2363 VectorNormalize(r_view.frustum[1].normal);
2364 VectorNormalize(r_view.frustum[2].normal);
2365 VectorNormalize(r_view.frustum[3].normal);
2367 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
2368 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
2369 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
2370 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[2]);
2371 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[3]);
2373 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
2374 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
2375 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
2376 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
2377 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2381 VectorScale(r_view.left, -r_view.ortho_x, r_view.frustum[0].normal);
2382 VectorScale(r_view.left, r_view.ortho_x, r_view.frustum[1].normal);
2383 VectorScale(r_view.up, -r_view.ortho_y, r_view.frustum[2].normal);
2384 VectorScale(r_view.up, r_view.ortho_y, r_view.frustum[3].normal);
2385 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2386 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal) + r_view.ortho_x;
2387 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal) + r_view.ortho_x;
2388 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal) + r_view.ortho_y;
2389 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal) + r_view.ortho_y;
2390 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2392 r_view.numfrustumplanes = 5;
2394 if (r_view.useclipplane)
2396 r_view.numfrustumplanes = 6;
2397 r_view.frustum[5] = r_view.clipplane;
2400 for (i = 0;i < r_view.numfrustumplanes;i++)
2401 PlaneClassify(r_view.frustum + i);
2403 // LordHavoc: note to all quake engine coders, Quake had a special case
2404 // for 90 degrees which assumed a square view (wrong), so I removed it,
2405 // Quake2 has it disabled as well.
2407 // rotate R_VIEWFORWARD right by FOV_X/2 degrees
2408 //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
2409 //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
2410 //PlaneClassify(&frustum[0]);
2412 // rotate R_VIEWFORWARD left by FOV_X/2 degrees
2413 //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
2414 //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
2415 //PlaneClassify(&frustum[1]);
2417 // rotate R_VIEWFORWARD up by FOV_X/2 degrees
2418 //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
2419 //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
2420 //PlaneClassify(&frustum[2]);
2422 // rotate R_VIEWFORWARD down by FOV_X/2 degrees
2423 //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
2424 //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
2425 //PlaneClassify(&frustum[3]);
2428 //VectorCopy(r_view.forward, r_view.frustum[4].normal);
2429 //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
2430 //PlaneClassify(&frustum[4]);
2433 void R_View_Update(void)
2435 R_View_SetFrustum();
2436 R_View_WorldVisibility(r_view.useclipplane);
2437 R_View_UpdateEntityVisible();
2440 void R_SetupView(void)
2442 if (!r_view.useperspective)
2443 GL_SetupView_Mode_Ortho(-r_view.ortho_x, -r_view.ortho_y, r_view.ortho_x, r_view.ortho_y, -r_refdef.farclip, r_refdef.farclip);
2444 else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
2445 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
2447 GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
2449 GL_SetupView_Orientation_FromEntity(&r_view.matrix);
2451 if (r_view.useclipplane)
2453 // LordHavoc: couldn't figure out how to make this approach the
2454 vec_t dist = r_view.clipplane.dist - r_water_clippingplanebias.value;
2455 vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
2456 if (viewdist < r_view.clipplane.dist + r_water_clippingplanebias.value)
2457 dist = r_view.clipplane.dist;
2458 GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
2462 void R_ResetViewRendering2D(void)
2464 if (gl_support_fragment_shader)
2466 qglUseProgramObjectARB(0);CHECKGLERROR
2471 // GL is weird because it's bottom to top, r_view.y is top to bottom
2472 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2473 GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
2474 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2475 GL_Color(1, 1, 1, 1);
2476 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2477 GL_BlendFunc(GL_ONE, GL_ZERO);
2478 GL_AlphaTest(false);
2479 GL_ScissorTest(false);
2480 GL_DepthMask(false);
2481 GL_DepthRange(0, 1);
2482 GL_DepthTest(false);
2483 R_Mesh_Matrix(&identitymatrix);
2484 R_Mesh_ResetTextureState();
2485 GL_PolygonOffset(0, 0);
2486 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2487 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2488 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2489 qglStencilMask(~0);CHECKGLERROR
2490 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2491 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2492 GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
2495 void R_ResetViewRendering3D(void)
2497 if (gl_support_fragment_shader)
2499 qglUseProgramObjectARB(0);CHECKGLERROR
2504 // GL is weird because it's bottom to top, r_view.y is top to bottom
2505 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2507 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2508 GL_Color(1, 1, 1, 1);
2509 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2510 GL_BlendFunc(GL_ONE, GL_ZERO);
2511 GL_AlphaTest(false);
2512 GL_ScissorTest(true);
2514 GL_DepthRange(0, 1);
2516 R_Mesh_Matrix(&identitymatrix);
2517 R_Mesh_ResetTextureState();
2518 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
2519 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2520 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2521 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2522 qglStencilMask(~0);CHECKGLERROR
2523 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2524 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2525 GL_CullFace(r_view.cullface_back);
2529 R_Bloom_SetupShader(
2531 "// written by Forest 'LordHavoc' Hale\n"
2533 "// common definitions between vertex shader and fragment shader:\n"
2535 "#ifdef __GLSL_CG_DATA_TYPES\n"
2536 "#define myhalf half\n"
2537 "#define myhvec2 hvec2\n"
2538 "#define myhvec3 hvec3\n"
2539 "#define myhvec4 hvec4\n"
2541 "#define myhalf float\n"
2542 "#define myhvec2 vec2\n"
2543 "#define myhvec3 vec3\n"
2544 "#define myhvec4 vec4\n"
2547 "varying vec2 ScreenTexCoord;\n"
2548 "varying vec2 BloomTexCoord;\n"
2553 "// vertex shader specific:\n"
2554 "#ifdef VERTEX_SHADER\n"
2558 " ScreenTexCoord = vec2(gl_MultiTexCoord0);\n"
2559 " BloomTexCoord = vec2(gl_MultiTexCoord1);\n"
2560 " // transform vertex to camera space, using ftransform to match non-VS\n"
2562 " gl_Position = ftransform();\n"
2565 "#endif // VERTEX_SHADER\n"
2570 "// fragment shader specific:\n"
2571 "#ifdef FRAGMENT_SHADER\n"
2576 " myhvec3 color = myhvec3(texture2D(Texture_Screen, ScreenTexCoord));\n"
2577 " for (x = -BLUR_X;x <= BLUR_X;x++)
2578 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2579 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2580 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2581 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2583 " gl_FragColor = vec4(color);\n"
2586 "#endif // FRAGMENT_SHADER\n"
2589 void R_RenderScene(qboolean addwaterplanes);
2591 static void R_Water_StartFrame(void)
2594 int waterwidth, waterheight, texturewidth, textureheight;
2595 r_waterstate_waterplane_t *p;
2597 // set waterwidth and waterheight to the water resolution that will be
2598 // used (often less than the screen resolution for faster rendering)
2599 waterwidth = (int)bound(1, r_view.width * r_water_resolutionmultiplier.value, r_view.width);
2600 waterheight = (int)bound(1, r_view.height * r_water_resolutionmultiplier.value, r_view.height);
2602 // calculate desired texture sizes
2603 // can't use water if the card does not support the texture size
2604 if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
2605 texturewidth = textureheight = waterwidth = waterheight = 0;
2606 else if (gl_support_arb_texture_non_power_of_two)
2608 texturewidth = waterwidth;
2609 textureheight = waterheight;
2613 for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
2614 for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
2617 // allocate textures as needed
2618 if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
2620 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2621 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
2623 if (p->texture_refraction)
2624 R_FreeTexture(p->texture_refraction);
2625 p->texture_refraction = NULL;
2626 if (p->texture_reflection)
2627 R_FreeTexture(p->texture_reflection);
2628 p->texture_reflection = NULL;
2630 memset(&r_waterstate, 0, sizeof(r_waterstate));
2631 r_waterstate.waterwidth = waterwidth;
2632 r_waterstate.waterheight = waterheight;
2633 r_waterstate.texturewidth = texturewidth;
2634 r_waterstate.textureheight = textureheight;
2637 if (r_waterstate.waterwidth)
2639 r_waterstate.enabled = true;
2641 // set up variables that will be used in shader setup
2642 r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2643 r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
2644 r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2645 r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
2648 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2649 r_waterstate.numwaterplanes = 0;
2652 static void R_Water_AddWaterPlane(msurface_t *surface)
2654 int triangleindex, planeindex;
2659 r_waterstate_waterplane_t *p;
2660 // just use the first triangle with a valid normal for any decisions
2661 VectorClear(normal);
2662 for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
2664 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
2665 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
2666 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
2667 TriangleNormal(vert[0], vert[1], vert[2], normal);
2668 if (VectorLength2(normal) >= 0.001)
2672 // find a matching plane if there is one
2673 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2674 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
2676 if (planeindex >= r_waterstate.maxwaterplanes)
2677 return; // nothing we can do, out of planes
2679 // if this triangle does not fit any known plane rendered this frame, add one
2680 if (planeindex >= r_waterstate.numwaterplanes)
2682 // store the new plane
2683 r_waterstate.numwaterplanes++;
2684 VectorCopy(normal, p->plane.normal);
2685 VectorNormalize(p->plane.normal);
2686 p->plane.dist = DotProduct(vert[0], p->plane.normal);
2687 PlaneClassify(&p->plane);
2688 // flip the plane if it does not face the viewer
2689 if (PlaneDiff(r_view.origin, &p->plane) < 0)
2691 VectorNegate(p->plane.normal, p->plane.normal);
2692 p->plane.dist *= -1;
2693 PlaneClassify(&p->plane);
2695 // clear materialflags and pvs
2696 p->materialflags = 0;
2697 p->pvsvalid = false;
2699 // merge this surface's materialflags into the waterplane
2700 p->materialflags |= surface->texture->currentframe->currentmaterialflags;
2701 // merge this surface's PVS into the waterplane
2702 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
2703 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS
2704 && r_refdef.worldmodel->brush.PointInLeaf && r_refdef.worldmodel->brush.PointInLeaf(r_refdef.worldmodel, center)->clusterindex >= 0)
2706 r_refdef.worldmodel->brush.FatPVS(r_refdef.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
2711 static void R_Water_ProcessPlanes(void)
2713 r_view_t originalview;
2715 r_waterstate_waterplane_t *p;
2717 originalview = r_view;
2719 // make sure enough textures are allocated
2720 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2722 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2724 if (!p->texture_refraction)
2725 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2726 if (!p->texture_refraction)
2730 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2732 if (!p->texture_reflection)
2733 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2734 if (!p->texture_reflection)
2740 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2742 r_view.showdebug = false;
2743 r_view.width = r_waterstate.waterwidth;
2744 r_view.height = r_waterstate.waterheight;
2745 r_view.useclipplane = true;
2746 r_waterstate.renderingscene = true;
2748 // render the normal view scene and copy into texture
2749 // (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted)
2750 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2752 r_view.clipplane = p->plane;
2753 VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
2754 r_view.clipplane.dist = -r_view.clipplane.dist;
2755 PlaneClassify(&r_view.clipplane);
2757 R_RenderScene(false);
2759 // copy view into the screen texture
2760 R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
2761 GL_ActiveTexture(0);
2763 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2766 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2768 // render reflected scene and copy into texture
2769 Matrix4x4_Reflect(&r_view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
2770 r_view.clipplane = p->plane;
2771 // reverse the cullface settings for this render
2772 r_view.cullface_front = GL_FRONT;
2773 r_view.cullface_back = GL_BACK;
2774 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.num_pvsclusterbytes)
2776 r_view.usecustompvs = true;
2778 memcpy(r_viewcache.world_pvsbits, p->pvsbits, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2780 memset(r_viewcache.world_pvsbits, 0xFF, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2783 R_ResetViewRendering3D();
2785 if (r_timereport_active)
2786 R_TimeReport("viewclear");
2788 R_RenderScene(false);
2790 R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
2791 GL_ActiveTexture(0);
2793 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2795 R_ResetViewRendering3D();
2797 if (r_timereport_active)
2798 R_TimeReport("viewclear");
2801 r_view = originalview;
2802 r_view.clear = true;
2803 r_waterstate.renderingscene = false;
2807 r_view = originalview;
2808 r_waterstate.renderingscene = false;
2809 Cvar_SetValueQuick(&r_water, 0);
2810 Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
2814 void R_Bloom_StartFrame(void)
2816 int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
2818 // set bloomwidth and bloomheight to the bloom resolution that will be
2819 // used (often less than the screen resolution for faster rendering)
2820 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
2821 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_view.height / r_view.width;
2822 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_view.height);
2824 // calculate desired texture sizes
2825 if (gl_support_arb_texture_non_power_of_two)
2827 screentexturewidth = r_view.width;
2828 screentextureheight = r_view.height;
2829 bloomtexturewidth = r_bloomstate.bloomwidth;
2830 bloomtextureheight = r_bloomstate.bloomheight;
2834 for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
2835 for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
2836 for (bloomtexturewidth = 1;bloomtexturewidth < r_bloomstate.bloomwidth ;bloomtexturewidth *= 2);
2837 for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2);
2842 screentexturewidth = screentextureheight = 0;
2844 else if (r_bloom.integer)
2849 screentexturewidth = screentextureheight = 0;
2850 bloomtexturewidth = bloomtextureheight = 0;
2853 if ((!bloomtexturewidth && !bloomtextureheight) || r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512 || screentexturewidth > gl_max_texture_size || screentextureheight > gl_max_texture_size || bloomtexturewidth > gl_max_texture_size || bloomtextureheight > gl_max_texture_size)
2855 // can't use bloom if the parameters are too weird
2856 // can't use bloom if the card does not support the texture size
2857 if (r_bloomstate.texture_screen)
2858 R_FreeTexture(r_bloomstate.texture_screen);
2859 if (r_bloomstate.texture_bloom)
2860 R_FreeTexture(r_bloomstate.texture_bloom);
2861 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
2865 r_bloomstate.enabled = true;
2866 r_bloomstate.hdr = r_hdr.integer != 0;
2868 // allocate textures as needed
2869 if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
2871 if (r_bloomstate.texture_screen)
2872 R_FreeTexture(r_bloomstate.texture_screen);
2873 r_bloomstate.texture_screen = NULL;
2874 r_bloomstate.screentexturewidth = screentexturewidth;
2875 r_bloomstate.screentextureheight = screentextureheight;
2876 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
2877 r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2879 if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
2881 if (r_bloomstate.texture_bloom)
2882 R_FreeTexture(r_bloomstate.texture_bloom);
2883 r_bloomstate.texture_bloom = NULL;
2884 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
2885 r_bloomstate.bloomtextureheight = bloomtextureheight;
2886 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
2887 r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
2890 // set up a texcoord array for the full resolution screen image
2891 // (we have to keep this around to copy back during final render)
2892 r_bloomstate.screentexcoord2f[0] = 0;
2893 r_bloomstate.screentexcoord2f[1] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2894 r_bloomstate.screentexcoord2f[2] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2895 r_bloomstate.screentexcoord2f[3] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2896 r_bloomstate.screentexcoord2f[4] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2897 r_bloomstate.screentexcoord2f[5] = 0;
2898 r_bloomstate.screentexcoord2f[6] = 0;
2899 r_bloomstate.screentexcoord2f[7] = 0;
2901 // set up a texcoord array for the reduced resolution bloom image
2902 // (which will be additive blended over the screen image)
2903 r_bloomstate.bloomtexcoord2f[0] = 0;
2904 r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2905 r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2906 r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2907 r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2908 r_bloomstate.bloomtexcoord2f[5] = 0;
2909 r_bloomstate.bloomtexcoord2f[6] = 0;
2910 r_bloomstate.bloomtexcoord2f[7] = 0;
2913 void R_Bloom_CopyScreenTexture(float colorscale)
2915 r_refdef.stats.bloom++;
2917 R_ResetViewRendering2D();
2918 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2919 R_Mesh_ColorPointer(NULL, 0, 0);
2920 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
2921 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
2923 // copy view into the screen texture
2924 GL_ActiveTexture(0);
2926 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2927 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2929 // now scale it down to the bloom texture size
2931 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2932 GL_BlendFunc(GL_ONE, GL_ZERO);
2933 GL_Color(colorscale, colorscale, colorscale, 1);
2934 // TODO: optimize with multitexture or GLSL
2935 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2936 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2938 // we now have a bloom image in the framebuffer
2939 // copy it into the bloom image texture for later processing
2940 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2941 GL_ActiveTexture(0);
2943 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2944 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2947 void R_Bloom_CopyHDRTexture(void)
2949 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2950 GL_ActiveTexture(0);
2952 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2953 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2956 void R_Bloom_MakeTexture(void)
2959 float xoffset, yoffset, r, brighten;
2961 r_refdef.stats.bloom++;
2963 R_ResetViewRendering2D();
2964 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2965 R_Mesh_ColorPointer(NULL, 0, 0);
2967 // we have a bloom image in the framebuffer
2969 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2971 for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
2974 r = bound(0, r_bloom_colorexponent.value / x, 1);
2975 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
2976 GL_Color(r, r, r, 1);
2977 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2978 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
2979 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2980 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2982 // copy the vertically blurred bloom view to a texture
2983 GL_ActiveTexture(0);
2985 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2986 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2989 range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
2990 brighten = r_bloom_brighten.value;
2992 brighten *= r_hdr_range.value;
2993 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2994 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
2996 for (dir = 0;dir < 2;dir++)
2998 // blend on at multiple vertical offsets to achieve a vertical blur
2999 // TODO: do offset blends using GLSL
3000 GL_BlendFunc(GL_ONE, GL_ZERO);
3001 for (x = -range;x <= range;x++)
3003 if (!dir){xoffset = 0;yoffset = x;}
3004 else {xoffset = x;yoffset = 0;}
3005 xoffset /= (float)r_bloomstate.bloomtexturewidth;
3006 yoffset /= (float)r_bloomstate.bloomtextureheight;
3007 // compute a texcoord array with the specified x and y offset
3008 r_bloomstate.offsettexcoord2f[0] = xoffset+0;
3009 r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3010 r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3011 r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3012 r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3013 r_bloomstate.offsettexcoord2f[5] = yoffset+0;
3014 r_bloomstate.offsettexcoord2f[6] = xoffset+0;
3015 r_bloomstate.offsettexcoord2f[7] = yoffset+0;
3016 // this r value looks like a 'dot' particle, fading sharply to
3017 // black at the edges
3018 // (probably not realistic but looks good enough)
3019 //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
3020 //r = (dir ? 1.0f : brighten)/(range*2+1);
3021 r = (dir ? 1.0f : brighten)/(range*2+1)*(1 - x*x/(float)(range*range));
3022 GL_Color(r, r, r, 1);
3023 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3024 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3025 GL_BlendFunc(GL_ONE, GL_ONE);
3028 // copy the vertically blurred bloom view to a texture
3029 GL_ActiveTexture(0);
3031 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3032 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3035 // apply subtract last
3036 // (just like it would be in a GLSL shader)
3037 if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract)
3039 GL_BlendFunc(GL_ONE, GL_ZERO);
3040 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3041 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3042 GL_Color(1, 1, 1, 1);
3043 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3044 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3046 GL_BlendFunc(GL_ONE, GL_ONE);
3047 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
3048 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
3049 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3050 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
3051 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3052 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3053 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3055 // copy the darkened bloom view to a texture
3056 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3057 GL_ActiveTexture(0);
3059 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3060 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3064 static void R_UpdateFogColor(void); // needs to be called before HDR subrender too, as that changes colorscale!
3066 void R_HDR_RenderBloomTexture(void)
3068 int oldwidth, oldheight;
3070 oldwidth = r_view.width;
3071 oldheight = r_view.height;
3072 r_view.width = r_bloomstate.bloomwidth;
3073 r_view.height = r_bloomstate.bloomheight;
3075 // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer? it might improve SLI performance.
3076 // TODO: add exposure compensation features
3077 // TODO: add fp16 framebuffer support
3079 r_view.showdebug = false;
3080 r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
3082 r_view.colorscale /= r_hdr_range.value;
3086 r_waterstate.numwaterplanes = 0;
3087 R_RenderScene(r_waterstate.enabled);
3088 r_view.showdebug = true;
3090 R_ResetViewRendering2D();
3092 R_Bloom_CopyHDRTexture();
3093 R_Bloom_MakeTexture();
3095 R_ResetViewRendering3D();
3098 if (r_timereport_active)
3099 R_TimeReport("viewclear");
3101 // restore the view settings
3102 r_view.width = oldwidth;
3103 r_view.height = oldheight;
3106 static void R_BlendView(void)
3108 if (r_bloomstate.enabled && r_bloomstate.hdr)
3110 // render high dynamic range bloom effect
3111 // the bloom texture was made earlier this render, so we just need to
3112 // blend it onto the screen...
3113 R_ResetViewRendering2D();
3114 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3115 R_Mesh_ColorPointer(NULL, 0, 0);
3116 GL_Color(1, 1, 1, 1);
3117 GL_BlendFunc(GL_ONE, GL_ONE);
3118 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3119 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3120 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3121 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3123 else if (r_bloomstate.enabled)
3125 // render simple bloom effect
3126 // copy the screen and shrink it and darken it for the bloom process
3127 R_Bloom_CopyScreenTexture(r_bloom_colorscale.value);
3128 // make the bloom texture
3129 R_Bloom_MakeTexture();
3130 // put the original screen image back in place and blend the bloom
3132 R_ResetViewRendering2D();
3133 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3134 R_Mesh_ColorPointer(NULL, 0, 0);
3135 GL_Color(1, 1, 1, 1);
3136 GL_BlendFunc(GL_ONE, GL_ZERO);
3137 // do both in one pass if possible
3138 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3139 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3140 if (r_textureunits.integer >= 2 && gl_combine.integer)
3142 R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
3143 R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen));
3144 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0);
3148 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3149 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3150 // now blend on the bloom texture
3151 GL_BlendFunc(GL_ONE, GL_ONE);
3152 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3153 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3155 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3156 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3158 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
3160 // apply a color tint to the whole view
3161 R_ResetViewRendering2D();
3162 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3163 R_Mesh_ColorPointer(NULL, 0, 0);
3164 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3165 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
3166 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3170 void R_RenderScene(qboolean addwaterplanes);
3172 matrix4x4_t r_waterscrollmatrix;
3174 static void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
3176 if (r_refdef.fog_density)
3178 r_refdef.fogcolor[0] = r_refdef.fog_red;
3179 r_refdef.fogcolor[1] = r_refdef.fog_green;
3180 r_refdef.fogcolor[2] = r_refdef.fog_blue;
3184 // color.rgb *= SceneBrightness;
3185 VectorScale(r_refdef.fogcolor, r_view.colorscale, fogvec);
3186 if(r_glsl.integer && (r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)) // need to support contrast boost
3188 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
3189 fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
3190 fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
3191 fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
3193 r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
3194 r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
3195 r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
3200 void R_UpdateVariables(void)
3204 r_refdef.farclip = 4096;
3205 if (r_refdef.worldmodel)
3206 r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
3207 r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
3209 if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
3210 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
3211 r_refdef.polygonfactor = 0;
3212 r_refdef.polygonoffset = 0;
3213 r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3214 r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3216 r_refdef.rtworld = r_shadow_realtime_world.integer;
3217 r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
3218 r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
3219 r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
3220 r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
3221 if (r_showsurfaces.integer)
3223 r_refdef.rtworld = false;
3224 r_refdef.rtworldshadows = false;
3225 r_refdef.rtdlight = false;
3226 r_refdef.rtdlightshadows = false;
3227 r_refdef.lightmapintensity = 0;
3230 if (gamemode == GAME_NEHAHRA)
3232 if (gl_fogenable.integer)
3234 r_refdef.oldgl_fogenable = true;
3235 r_refdef.fog_density = gl_fogdensity.value;
3236 r_refdef.fog_red = gl_fogred.value;
3237 r_refdef.fog_green = gl_foggreen.value;
3238 r_refdef.fog_blue = gl_fogblue.value;
3240 else if (r_refdef.oldgl_fogenable)
3242 r_refdef.oldgl_fogenable = false;
3243 r_refdef.fog_density = 0;
3244 r_refdef.fog_red = 0;
3245 r_refdef.fog_green = 0;
3246 r_refdef.fog_blue = 0;
3250 r_refdef.fog_alpha = min(1, r_refdef.fog_alpha);
3251 r_refdef.fog_start = max(0, r_refdef.fog_start);
3255 if (r_refdef.fog_density)
3257 r_refdef.fogenabled = true;
3258 // this is the point where the fog reaches 0.9986 alpha, which we
3259 // consider a good enough cutoff point for the texture
3260 // (0.9986 * 256 == 255.6)
3261 r_refdef.fogrange = 16 / (r_refdef.fog_density * r_refdef.fog_density);
3262 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
3263 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
3264 // fog color was already set
3267 r_refdef.fogenabled = false;
3275 void R_RenderView(void)
3277 if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
3278 return; //Host_Error ("R_RenderView: NULL worldmodel");
3280 R_Shadow_UpdateWorldLightSelection();
3282 R_Bloom_StartFrame();
3283 R_Water_StartFrame();
3286 if (r_timereport_active)
3287 R_TimeReport("viewsetup");
3289 R_ResetViewRendering3D();
3294 if (r_timereport_active)
3295 R_TimeReport("viewclear");
3297 r_view.clear = true;
3299 r_view.showdebug = true;
3301 // this produces a bloom texture to be used in R_BlendView() later
3303 R_HDR_RenderBloomTexture();
3305 r_view.colorscale = r_hdr_scenebrightness.value;
3306 r_waterstate.numwaterplanes = 0;
3307 R_RenderScene(r_waterstate.enabled);
3310 if (r_timereport_active)
3311 R_TimeReport("blendview");
3313 GL_Scissor(0, 0, vid.width, vid.height);
3314 GL_ScissorTest(false);
3318 extern void R_DrawLightningBeams (void);
3319 extern void VM_CL_AddPolygonsToMeshQueue (void);
3320 extern void R_DrawPortals (void);
3321 extern cvar_t cl_locs_show;
3322 static void R_DrawLocs(void);
3323 static void R_DrawEntityBBoxes(void);
3324 void R_RenderScene(qboolean addwaterplanes)
3328 R_ResetViewRendering3D();
3331 if (r_timereport_active)
3332 R_TimeReport("watervis");
3334 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawAddWaterPlanes)
3336 r_refdef.worldmodel->DrawAddWaterPlanes(r_refdef.worldentity);
3337 if (r_timereport_active)
3338 R_TimeReport("waterworld");
3341 // don't let sound skip if going slow
3342 if (r_refdef.extraupdate)
3345 R_DrawModelsAddWaterPlanes();
3346 if (r_timereport_active)
3347 R_TimeReport("watermodels");
3349 R_Water_ProcessPlanes();
3350 if (r_timereport_active)
3351 R_TimeReport("waterscenes");
3354 R_ResetViewRendering3D();
3356 // don't let sound skip if going slow
3357 if (r_refdef.extraupdate)
3360 R_MeshQueue_BeginScene();
3365 if (r_timereport_active)
3366 R_TimeReport("visibility");
3368 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);
3370 if (cl.csqc_vidvars.drawworld)
3372 // don't let sound skip if going slow
3373 if (r_refdef.extraupdate)
3376 if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
3378 r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
3379 if (r_timereport_active)
3380 R_TimeReport("worldsky");
3383 if (R_DrawBrushModelsSky() && r_timereport_active)
3384 R_TimeReport("bmodelsky");
3387 if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawDepth)
3389 r_refdef.worldmodel->DrawDepth(r_refdef.worldentity);
3390 if (r_timereport_active)
3391 R_TimeReport("worlddepth");
3393 if (r_depthfirst.integer >= 2)
3395 R_DrawModelsDepth();
3396 if (r_timereport_active)
3397 R_TimeReport("modeldepth");
3400 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->Draw)
3402 r_refdef.worldmodel->Draw(r_refdef.worldentity);
3403 if (r_timereport_active)
3404 R_TimeReport("world");
3407 // don't let sound skip if going slow
3408 if (r_refdef.extraupdate)
3412 if (r_timereport_active)
3413 R_TimeReport("models");
3415 // don't let sound skip if going slow
3416 if (r_refdef.extraupdate)
3419 if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
3421 R_DrawModelShadows();
3423 R_ResetViewRendering3D();
3425 // don't let sound skip if going slow
3426 if (r_refdef.extraupdate)
3430 R_ShadowVolumeLighting(false);
3431 if (r_timereport_active)
3432 R_TimeReport("rtlights");
3434 // don't let sound skip if going slow
3435 if (r_refdef.extraupdate)
3438 if (cl.csqc_vidvars.drawworld)
3440 R_DrawLightningBeams();
3441 if (r_timereport_active)
3442 R_TimeReport("lightning");
3445 if (r_timereport_active)
3446 R_TimeReport("decals");
3449 if (r_timereport_active)
3450 R_TimeReport("particles");
3453 if (r_timereport_active)
3454 R_TimeReport("explosions");
3457 if (gl_support_fragment_shader)
3459 qglUseProgramObjectARB(0);CHECKGLERROR
3461 VM_CL_AddPolygonsToMeshQueue();
3463 if (r_view.showdebug)
3465 if (cl_locs_show.integer)
3468 if (r_timereport_active)
3469 R_TimeReport("showlocs");
3472 if (r_drawportals.integer)
3475 if (r_timereport_active)
3476 R_TimeReport("portals");
3479 if (r_showbboxes.value > 0)
3481 R_DrawEntityBBoxes();
3482 if (r_timereport_active)
3483 R_TimeReport("bboxes");
3487 if (gl_support_fragment_shader)
3489 qglUseProgramObjectARB(0);CHECKGLERROR
3491 R_MeshQueue_RenderTransparent();
3492 if (r_timereport_active)
3493 R_TimeReport("drawtrans");
3495 if (gl_support_fragment_shader)
3497 qglUseProgramObjectARB(0);CHECKGLERROR
3500 if (r_view.showdebug && r_refdef.worldmodel && r_refdef.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value > 0 || r_showcollisionbrushes.value > 0))
3502 r_refdef.worldmodel->DrawDebug(r_refdef.worldentity);
3503 if (r_timereport_active)
3504 R_TimeReport("worlddebug");
3505 R_DrawModelsDebug();
3506 if (r_timereport_active)
3507 R_TimeReport("modeldebug");
3510 if (gl_support_fragment_shader)
3512 qglUseProgramObjectARB(0);CHECKGLERROR
3515 if (cl.csqc_vidvars.drawworld)
3518 if (r_timereport_active)
3519 R_TimeReport("coronas");
3522 // don't let sound skip if going slow
3523 if (r_refdef.extraupdate)
3526 R_ResetViewRendering2D();
3529 static const int bboxelements[36] =
3539 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
3542 float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
3543 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3544 GL_DepthMask(false);
3545 GL_DepthRange(0, 1);
3546 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3547 R_Mesh_Matrix(&identitymatrix);
3548 R_Mesh_ResetTextureState();
3550 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
3551 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
3552 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
3553 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
3554 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
3555 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
3556 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
3557 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
3558 R_FillColors(color4f, 8, cr, cg, cb, ca);
3559 if (r_refdef.fogenabled)
3561 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
3563 f1 = FogPoint_World(v);
3565 c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
3566 c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
3567 c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
3570 R_Mesh_VertexPointer(vertex3f, 0, 0);
3571 R_Mesh_ColorPointer(color4f, 0, 0);
3572 R_Mesh_ResetTextureState();
3573 R_Mesh_Draw(0, 8, 12, bboxelements, 0, 0);
3576 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3580 prvm_edict_t *edict;
3581 // this function draws bounding boxes of server entities
3585 for (i = 0;i < numsurfaces;i++)
3587 edict = PRVM_EDICT_NUM(surfacelist[i]);
3588 switch ((int)edict->fields.server->solid)
3590 case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
3591 case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
3592 case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
3593 case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
3594 case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
3595 default: Vector4Set(color, 0, 0, 0, 0.50);break;
3597 color[3] *= r_showbboxes.value;
3598 color[3] = bound(0, color[3], 1);
3599 GL_DepthTest(!r_showdisabledepthtest.integer);
3600 GL_CullFace(r_view.cullface_front);
3601 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
3606 static void R_DrawEntityBBoxes(void)
3609 prvm_edict_t *edict;
3611 // this function draws bounding boxes of server entities
3615 for (i = 0;i < prog->num_edicts;i++)
3617 edict = PRVM_EDICT_NUM(i);
3618 if (edict->priv.server->free)
3620 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
3621 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
3626 int nomodelelements[24] =
3638 float nomodelvertex3f[6*3] =
3648 float nomodelcolor4f[6*4] =
3650 0.0f, 0.0f, 0.5f, 1.0f,
3651 0.0f, 0.0f, 0.5f, 1.0f,
3652 0.0f, 0.5f, 0.0f, 1.0f,
3653 0.0f, 0.5f, 0.0f, 1.0f,
3654 0.5f, 0.0f, 0.0f, 1.0f,
3655 0.5f, 0.0f, 0.0f, 1.0f
3658 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3663 // this is only called once per entity so numsurfaces is always 1, and
3664 // surfacelist is always {0}, so this code does not handle batches
3665 R_Mesh_Matrix(&ent->matrix);
3667 if (ent->flags & EF_ADDITIVE)
3669 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
3670 GL_DepthMask(false);
3672 else if (ent->alpha < 1)
3674 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3675 GL_DepthMask(false);
3679 GL_BlendFunc(GL_ONE, GL_ZERO);
3682 GL_DepthRange(0, (ent->flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
3683 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3684 GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
3685 GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : r_view.cullface_back);
3686 R_Mesh_VertexPointer(nomodelvertex3f, 0, 0);
3687 if (r_refdef.fogenabled)
3690 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3691 R_Mesh_ColorPointer(color4f, 0, 0);
3692 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3693 f1 = FogPoint_World(org);
3695 for (i = 0, c = color4f;i < 6;i++, c += 4)
3697 c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
3698 c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
3699 c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
3703 else if (ent->alpha != 1)
3705 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3706 R_Mesh_ColorPointer(color4f, 0, 0);
3707 for (i = 0, c = color4f;i < 6;i++, c += 4)
3711 R_Mesh_ColorPointer(nomodelcolor4f, 0, 0);
3712 R_Mesh_ResetTextureState();
3713 R_Mesh_Draw(0, 6, 8, nomodelelements, 0, 0);
3716 void R_DrawNoModel(entity_render_t *ent)
3719 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3720 //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
3721 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
3723 // R_DrawNoModelCallback(ent, 0);
3726 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
3728 vec3_t right1, right2, diff, normal;
3730 VectorSubtract (org2, org1, normal);
3732 // calculate 'right' vector for start
3733 VectorSubtract (r_view.origin, org1, diff);
3734 CrossProduct (normal, diff, right1);
3735 VectorNormalize (right1);
3737 // calculate 'right' vector for end
3738 VectorSubtract (r_view.origin, org2, diff);
3739 CrossProduct (normal, diff, right2);
3740 VectorNormalize (right2);
3742 vert[ 0] = org1[0] + width * right1[0];
3743 vert[ 1] = org1[1] + width * right1[1];
3744 vert[ 2] = org1[2] + width * right1[2];
3745 vert[ 3] = org1[0] - width * right1[0];
3746 vert[ 4] = org1[1] - width * right1[1];
3747 vert[ 5] = org1[2] - width * right1[2];
3748 vert[ 6] = org2[0] - width * right2[0];
3749 vert[ 7] = org2[1] - width * right2[1];
3750 vert[ 8] = org2[2] - width * right2[2];
3751 vert[ 9] = org2[0] + width * right2[0];
3752 vert[10] = org2[1] + width * right2[1];
3753 vert[11] = org2[2] + width * right2[2];
3756 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
3758 void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_t *fogtexture, qboolean depthdisable, qboolean depthshort, 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)
3763 if (r_refdef.fogenabled)
3764 fog = FogPoint_World(origin);
3766 R_Mesh_Matrix(&identitymatrix);
3767 GL_BlendFunc(blendfunc1, blendfunc2);
3773 GL_CullFace(r_view.cullface_front);
3776 GL_CullFace(r_view.cullface_back);
3778 GL_DepthMask(false);
3779 GL_DepthRange(0, depthshort ? 0.0625 : 1);
3780 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3781 GL_DepthTest(!depthdisable);
3783 vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
3784 vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
3785 vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
3786 vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
3787 vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
3788 vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
3789 vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
3790 vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
3791 vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
3792 vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
3793 vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
3794 vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
3796 R_Mesh_VertexPointer(vertex3f, 0, 0);
3797 R_Mesh_ColorPointer(NULL, 0, 0);
3798 R_Mesh_ResetTextureState();
3799 R_Mesh_TexBind(0, R_GetTexture(texture));
3800 R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f, 0, 0);
3801 // FIXME: fixed function path can't properly handle r_view.colorscale > 1
3802 GL_Color(cr * fog * r_view.colorscale, cg * fog * r_view.colorscale, cb * fog * r_view.colorscale, ca);
3803 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3805 if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
3807 R_Mesh_TexBind(0, R_GetTexture(fogtexture));
3808 GL_BlendFunc(blendfunc1, GL_ONE);
3810 GL_Color(r_refdef.fogcolor[0] * fog, r_refdef.fogcolor[1] * fog, r_refdef.fogcolor[2] * fog, ca);
3811 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3815 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
3820 VectorSet(v, x, y, z);
3821 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
3822 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
3824 if (i == mesh->numvertices)
3826 if (mesh->numvertices < mesh->maxvertices)
3828 VectorCopy(v, vertex3f);
3829 mesh->numvertices++;
3831 return mesh->numvertices;
3837 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
3841 element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3842 element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3843 e = mesh->element3i + mesh->numtriangles * 3;
3844 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
3846 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
3847 if (mesh->numtriangles < mesh->maxtriangles)
3852 mesh->numtriangles++;
3854 element[1] = element[2];
3858 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
3862 element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3863 element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3864 e = mesh->element3i + mesh->numtriangles * 3;
3865 for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
3867 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
3868 if (mesh->numtriangles < mesh->maxtriangles)
3873 mesh->numtriangles++;
3875 element[1] = element[2];
3879 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
3880 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
3882 int planenum, planenum2;
3885 mplane_t *plane, *plane2;
3887 double temppoints[2][256*3];
3888 // figure out how large a bounding box we need to properly compute this brush
3890 for (w = 0;w < numplanes;w++)
3891 maxdist = max(maxdist, planes[w].dist);
3892 // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
3893 maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
3894 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
3898 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
3899 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
3901 if (planenum2 == planenum)
3903 PolygonD_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, R_MESH_PLANE_DIST_EPSILON, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints, NULL);
3906 if (tempnumpoints < 3)
3908 // generate elements forming a triangle fan for this polygon
3909 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
3913 static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, int blendfunc2, texturelayertype_t type, rtexture_t *texture, const matrix4x4_t *matrix, float r, float g, float b, float a)
3915 texturelayer_t *layer;
3916 layer = t->currentlayers + t->currentnumlayers++;
3918 layer->depthmask = depthmask;
3919 layer->blendfunc1 = blendfunc1;
3920 layer->blendfunc2 = blendfunc2;
3921 layer->texture = texture;
3922 layer->texmatrix = *matrix;
3923 layer->color[0] = r * r_view.colorscale;
3924 layer->color[1] = g * r_view.colorscale;
3925 layer->color[2] = b * r_view.colorscale;
3926 layer->color[3] = a;
3929 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
3932 index = parms[2] + r_refdef.time * parms[3];
3933 index -= floor(index);
3937 case Q3WAVEFUNC_NONE:
3938 case Q3WAVEFUNC_NOISE:
3939 case Q3WAVEFUNC_COUNT:
3942 case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
3943 case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
3944 case Q3WAVEFUNC_SAWTOOTH: f = index;break;
3945 case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
3946 case Q3WAVEFUNC_TRIANGLE:
3948 f = index - floor(index);
3959 return (float)(parms[0] + parms[1] * f);
3962 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
3965 model_t *model = ent->model;
3968 q3shaderinfo_layer_tcmod_t *tcmod;
3970 // switch to an alternate material if this is a q1bsp animated material
3972 texture_t *texture = t;
3973 int s = ent->skinnum;
3974 if ((unsigned int)s >= (unsigned int)model->numskins)
3976 if (model->skinscenes)
3978 if (model->skinscenes[s].framecount > 1)
3979 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
3981 s = model->skinscenes[s].firstframe;
3984 t = t + s * model->num_surfaces;
3987 // use an alternate animation if the entity's frame is not 0,
3988 // and only if the texture has an alternate animation
3989 if (ent->frame2 != 0 && t->anim_total[1])
3990 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
3992 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
3994 texture->currentframe = t;
3997 // update currentskinframe to be a qw skin or animation frame
3998 if ((i = ent->entitynumber - 1) >= 0 && i < cl.maxclients)
4000 if (strcmp(r_qwskincache[i], cl.scores[i].qw_skin))
4002 strlcpy(r_qwskincache[i], cl.scores[i].qw_skin, sizeof(r_qwskincache[i]));
4003 Con_DPrintf("loading skins/%s\n", r_qwskincache[i]);
4004 r_qwskincache_skinframe[i] = R_SkinFrame_LoadExternal(va("skins/%s", r_qwskincache[i]), TEXF_PRECACHE | (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS, developer.integer > 0);
4006 t->currentskinframe = r_qwskincache_skinframe[i];
4007 if (t->currentskinframe == NULL)
4008 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4010 else if (t->numskinframes >= 2)
4011 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4012 if (t->backgroundnumskinframes >= 2)
4013 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - ent->frame2time)) % t->backgroundnumskinframes];
4015 t->currentmaterialflags = t->basematerialflags;
4016 t->currentalpha = ent->alpha;
4017 if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
4019 t->currentalpha *= r_wateralpha.value;
4021 * FIXME what is this supposed to do?
4022 // if rendering refraction/reflection, disable transparency
4023 if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
4024 t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
4027 if(!r_waterstate.enabled)
4028 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
4029 if (!(ent->flags & RENDER_LIGHT))
4030 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
4031 else if (rsurface.modeltexcoordlightmap2f == NULL)
4033 // pick a model lighting mode
4034 if (VectorLength2(ent->modellight_diffuse) >= (1.0f / 256.0f))
4035 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
4037 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
4039 if (ent->effects & EF_ADDITIVE)
4040 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4041 else if (t->currentalpha < 1)
4042 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4043 if (ent->effects & EF_DOUBLESIDED)
4044 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
4045 if (ent->effects & EF_NODEPTHTEST)
4046 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4047 if (ent->flags & RENDER_VIEWMODEL)
4048 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4049 if (t->backgroundnumskinframes && !(t->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
4050 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
4052 // make sure that the waterscroll matrix is used on water surfaces when
4053 // there is no tcmod
4054 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4055 t->currenttexmatrix = r_waterscrollmatrix;
4057 for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
4060 switch(tcmod->tcmod)
4064 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4065 matrix = r_waterscrollmatrix;
4067 matrix = identitymatrix;
4069 case Q3TCMOD_ENTITYTRANSLATE:
4070 // this is used in Q3 to allow the gamecode to control texcoord
4071 // scrolling on the entity, which is not supported in darkplaces yet.
4072 Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
4074 case Q3TCMOD_ROTATE:
4075 Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
4076 Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.time, 0, 0, 1);
4077 Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
4080 Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
4082 case Q3TCMOD_SCROLL:
4083 Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.time, tcmod->parms[1] * r_refdef.time, 0);
4085 case Q3TCMOD_STRETCH:
4086 f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
4087 Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
4089 case Q3TCMOD_TRANSFORM:
4090 VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
4091 VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
4092 VectorSet(tcmat + 6, 0 , 0 , 1);
4093 VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
4094 Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
4096 case Q3TCMOD_TURBULENT:
4097 // this is handled in the RSurf_PrepareVertices function
4098 matrix = identitymatrix;
4101 // either replace or concatenate the transformation
4103 t->currenttexmatrix = matrix;
4106 matrix4x4_t temp = t->currenttexmatrix;
4107 Matrix4x4_Concat(&t->currenttexmatrix, &matrix, &temp);
4111 t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
4112 t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4113 t->glosstexture = r_texture_black;
4114 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
4115 t->backgroundglosstexture = r_texture_black;
4116 t->specularpower = r_shadow_glossexponent.value;
4117 // TODO: store reference values for these in the texture?
4118 t->specularscale = 0;
4119 if (r_shadow_gloss.integer > 0)
4121 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
4123 if (r_shadow_glossintensity.value > 0)
4125 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
4126 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
4127 t->specularscale = r_shadow_glossintensity.value;
4130 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
4132 t->glosstexture = r_texture_white;
4133 t->backgroundglosstexture = r_texture_white;
4134 t->specularscale = r_shadow_gloss2intensity.value;
4138 // lightmaps mode looks bad with dlights using actual texturing, so turn
4139 // off the colormap and glossmap, but leave the normalmap on as it still
4140 // accurately represents the shading involved
4141 if (gl_lightmaps.integer && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
4143 t->basetexture = r_texture_white;
4144 t->specularscale = 0;
4147 VectorClear(t->dlightcolor);
4148 t->currentnumlayers = 0;
4149 if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
4151 if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
4153 int blendfunc1, blendfunc2, depthmask;
4154 if (t->currentmaterialflags & MATERIALFLAG_ADD)
4156 blendfunc1 = GL_SRC_ALPHA;
4157 blendfunc2 = GL_ONE;
4159 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
4161 blendfunc1 = GL_SRC_ALPHA;
4162 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
4164 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
4166 blendfunc1 = t->customblendfunc[0];
4167 blendfunc2 = t->customblendfunc[1];
4171 blendfunc1 = GL_ONE;
4172 blendfunc2 = GL_ZERO;
4174 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
4175 if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
4177 rtexture_t *currentbasetexture;
4179 if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
4180 layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
4181 currentbasetexture = (VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) < (1.0f / 1048576.0f) && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4182 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
4184 // fullbright is not affected by r_refdef.lightmapintensity
4185 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
4186 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4187 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0], ent->colormap_pantscolor[1] * ent->colormod[1], ent->colormap_pantscolor[2] * ent->colormod[2], t->currentalpha);
4188 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4189 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0], ent->colormap_shirtcolor[1] * ent->colormod[1], ent->colormap_shirtcolor[2] * ent->colormod[2], t->currentalpha);
4194 // set the color tint used for lights affecting this surface
4195 VectorSet(t->dlightcolor, ent->colormod[0] * t->currentalpha, ent->colormod[1] * t->currentalpha, ent->colormod[2] * t->currentalpha);
4197 // q3bsp has no lightmap updates, so the lightstylevalue that
4198 // would normally be baked into the lightmap must be
4199 // applied to the color
4200 // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
4201 if (ent->model->type == mod_brushq3)
4202 colorscale *= r_refdef.rtlightstylevalue[0];
4203 colorscale *= r_refdef.lightmapintensity;
4204 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * colorscale, ent->colormod[1] * colorscale, ent->colormod[2] * colorscale, t->currentalpha);
4205 if (r_ambient.value >= (1.0f/64.0f))
4206 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), t->currentalpha);
4207 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4209 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0] * colorscale, ent->colormap_pantscolor[1] * ent->colormod[1] * colorscale, ent->colormap_pantscolor[2] * ent->colormod[2] * colorscale, t->currentalpha);
4210 if (r_ambient.value >= (1.0f/64.0f))
4211 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[1] * ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[2] * ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
4213 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4215 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0] * colorscale, ent->colormap_shirtcolor[1] * ent->colormod[1] * colorscale, ent->colormap_shirtcolor[2] * ent->colormod[2] * colorscale, t->currentalpha);
4216 if (r_ambient.value >= (1.0f/64.0f))
4217 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[1] * ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[2] * ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
4220 if (t->currentskinframe->glow != NULL)
4221 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->glow, &t->currenttexmatrix, r_hdr_glowintensity.value, r_hdr_glowintensity.value, r_hdr_glowintensity.value, t->currentalpha);
4222 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
4224 // if this is opaque use alpha blend which will darken the earlier
4227 // if this is an alpha blended material, all the earlier passes
4228 // were darkened by fog already, so we only need to add the fog
4229 // color ontop through the fog mask texture
4231 // if this is an additive blended material, all the earlier passes
4232 // were darkened by fog already, and we should not add fog color
4233 // (because the background was not darkened, there is no fog color
4234 // that was lost behind it).
4235 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_BLENDED) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->currentskinframe->fog, &identitymatrix, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], t->currentalpha);
4242 void R_UpdateAllTextureInfo(entity_render_t *ent)
4246 for (i = 0;i < ent->model->num_texturesperskin;i++)
4247 R_UpdateTextureInfo(ent, ent->model->data_textures + i);
4250 rsurfacestate_t rsurface;
4252 void R_Mesh_ResizeArrays(int newvertices)
4255 if (rsurface.array_size >= newvertices)
4257 if (rsurface.array_modelvertex3f)
4258 Mem_Free(rsurface.array_modelvertex3f);
4259 rsurface.array_size = (newvertices + 1023) & ~1023;
4260 base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
4261 rsurface.array_modelvertex3f = base + rsurface.array_size * 0;
4262 rsurface.array_modelsvector3f = base + rsurface.array_size * 3;
4263 rsurface.array_modeltvector3f = base + rsurface.array_size * 6;
4264 rsurface.array_modelnormal3f = base + rsurface.array_size * 9;
4265 rsurface.array_deformedvertex3f = base + rsurface.array_size * 12;
4266 rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
4267 rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
4268 rsurface.array_deformednormal3f = base + rsurface.array_size * 21;
4269 rsurface.array_texcoord3f = base + rsurface.array_size * 24;
4270 rsurface.array_color4f = base + rsurface.array_size * 27;
4271 rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
4274 void RSurf_CleanUp(void)
4277 if (rsurface.mode == RSURFMODE_GLSL)
4279 qglUseProgramObjectARB(0);CHECKGLERROR
4281 GL_AlphaTest(false);
4282 rsurface.mode = RSURFMODE_NONE;
4283 rsurface.uselightmaptexture = false;
4284 rsurface.texture = NULL;
4287 void RSurf_ActiveWorldEntity(void)
4289 model_t *model = r_refdef.worldmodel;
4291 if (rsurface.array_size < model->surfmesh.num_vertices)
4292 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4293 rsurface.matrix = identitymatrix;
4294 rsurface.inversematrix = identitymatrix;
4295 R_Mesh_Matrix(&identitymatrix);
4296 VectorCopy(r_view.origin, rsurface.modelorg);
4297 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
4298 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
4299 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
4300 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
4301 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
4302 rsurface.frameblend[0].frame = 0;
4303 rsurface.frameblend[0].lerp = 1;
4304 rsurface.frameblend[1].frame = 0;
4305 rsurface.frameblend[1].lerp = 0;
4306 rsurface.frameblend[2].frame = 0;
4307 rsurface.frameblend[2].lerp = 0;
4308 rsurface.frameblend[3].frame = 0;
4309 rsurface.frameblend[3].lerp = 0;
4310 rsurface.basepolygonfactor = r_refdef.polygonfactor;
4311 rsurface.basepolygonoffset = r_refdef.polygonoffset;
4312 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4313 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4314 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4315 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4316 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4317 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4318 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4319 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4320 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4321 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4322 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4323 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4324 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4325 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4326 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4327 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4328 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4329 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4330 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4331 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4332 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4333 rsurface.modelelement3i = model->surfmesh.data_element3i;
4334 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4335 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4336 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4337 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4338 rsurface.modelsurfaces = model->data_surfaces;
4339 rsurface.generatedvertex = false;
4340 rsurface.vertex3f = rsurface.modelvertex3f;
4341 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4342 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4343 rsurface.svector3f = rsurface.modelsvector3f;
4344 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4345 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4346 rsurface.tvector3f = rsurface.modeltvector3f;
4347 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4348 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4349 rsurface.normal3f = rsurface.modelnormal3f;
4350 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4351 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4352 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4355 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4357 model_t *model = ent->model;
4359 if (rsurface.array_size < model->surfmesh.num_vertices)
4360 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4361 rsurface.matrix = ent->matrix;
4362 rsurface.inversematrix = ent->inversematrix;
4363 R_Mesh_Matrix(&rsurface.matrix);
4364 Matrix4x4_Transform(&rsurface.inversematrix, r_view.origin, rsurface.modelorg);
4365 VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
4366 VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
4367 VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
4368 VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
4369 VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
4370 rsurface.frameblend[0] = ent->frameblend[0];
4371 rsurface.frameblend[1] = ent->frameblend[1];
4372 rsurface.frameblend[2] = ent->frameblend[2];
4373 rsurface.frameblend[3] = ent->frameblend[3];
4374 rsurface.basepolygonfactor = r_refdef.polygonfactor;
4375 rsurface.basepolygonoffset = r_refdef.polygonoffset;
4376 if (ent->model->brush.submodel)
4378 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
4379 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
4381 if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0))
4385 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4386 rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4387 rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4388 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4389 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
4391 else if (wantnormals)
4393 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4394 rsurface.modelsvector3f = NULL;
4395 rsurface.modeltvector3f = NULL;
4396 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4397 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
4401 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4402 rsurface.modelsvector3f = NULL;
4403 rsurface.modeltvector3f = NULL;
4404 rsurface.modelnormal3f = NULL;
4405 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL);
4407 rsurface.modelvertex3f_bufferobject = 0;
4408 rsurface.modelvertex3f_bufferoffset = 0;
4409 rsurface.modelsvector3f_bufferobject = 0;
4410 rsurface.modelsvector3f_bufferoffset = 0;
4411 rsurface.modeltvector3f_bufferobject = 0;
4412 rsurface.modeltvector3f_bufferoffset = 0;
4413 rsurface.modelnormal3f_bufferobject = 0;
4414 rsurface.modelnormal3f_bufferoffset = 0;
4415 rsurface.generatedvertex = true;
4419 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4420 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4421 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4422 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4423 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4424 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4425 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4426 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4427 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4428 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4429 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4430 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4431 rsurface.generatedvertex = false;
4433 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4434 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4435 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4436 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4437 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4438 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4439 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4440 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4441 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4442 rsurface.modelelement3i = model->surfmesh.data_element3i;
4443 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4444 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4445 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4446 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4447 rsurface.modelsurfaces = model->data_surfaces;
4448 rsurface.vertex3f = rsurface.modelvertex3f;
4449 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4450 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4451 rsurface.svector3f = rsurface.modelsvector3f;
4452 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4453 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4454 rsurface.tvector3f = rsurface.modeltvector3f;
4455 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4456 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4457 rsurface.normal3f = rsurface.modelnormal3f;
4458 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4459 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4460 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4463 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
4464 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
4467 int texturesurfaceindex;
4472 const float *v1, *in_tc;
4474 float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
4476 q3shaderinfo_deform_t *deform;
4477 // if vertices are dynamic (animated models), generate them into the temporary rsurface.array_model* arrays and point rsurface.model* at them instead of the static data from the model itself
4478 if (rsurface.generatedvertex)
4480 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
4481 generatenormals = true;
4482 for (i = 0;i < Q3MAXDEFORMS;i++)
4484 if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
4486 generatetangents = true;
4487 generatenormals = true;
4489 if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
4490 generatenormals = true;
4492 if (generatenormals && !rsurface.modelnormal3f)
4494 rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4495 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
4496 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
4497 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer);
4499 if (generatetangents && !rsurface.modelsvector3f)
4501 rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4502 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
4503 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
4504 rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4505 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
4506 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
4507 Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer);
4510 rsurface.vertex3f = rsurface.modelvertex3f;
4511 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4512 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4513 rsurface.svector3f = rsurface.modelsvector3f;
4514 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4515 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4516 rsurface.tvector3f = rsurface.modeltvector3f;
4517 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4518 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4519 rsurface.normal3f = rsurface.modelnormal3f;
4520 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4521 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4522 // if vertices are deformed (sprite flares and things in maps, possibly
4523 // water waves, bulges and other deformations), generate them into
4524 // rsurface.deform* arrays from whatever the rsurface.* arrays point to
4525 // (may be static model data or generated data for an animated model, or
4526 // the previous deform pass)
4527 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
4529 switch (deform->deform)
4532 case Q3DEFORM_PROJECTIONSHADOW:
4533 case Q3DEFORM_TEXT0:
4534 case Q3DEFORM_TEXT1:
4535 case Q3DEFORM_TEXT2:
4536 case Q3DEFORM_TEXT3:
4537 case Q3DEFORM_TEXT4:
4538 case Q3DEFORM_TEXT5:
4539 case Q3DEFORM_TEXT6:
4540 case Q3DEFORM_TEXT7:
4543 case Q3DEFORM_AUTOSPRITE:
4544 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4545 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4546 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4547 VectorNormalize(newforward);
4548 VectorNormalize(newright);
4549 VectorNormalize(newup);
4550 // make deformed versions of only the model vertices used by the specified surfaces
4551 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4553 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4554 // a single autosprite surface can contain multiple sprites...
4555 for (j = 0;j < surface->num_vertices - 3;j += 4)
4557 VectorClear(center);
4558 for (i = 0;i < 4;i++)
4559 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4560 VectorScale(center, 0.25f, center);
4561 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, forward);
4562 VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
4563 VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
4564 for (i = 0;i < 4;i++)
4566 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
4567 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4570 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
4571 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
4573 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4574 rsurface.vertex3f_bufferobject = 0;
4575 rsurface.vertex3f_bufferoffset = 0;
4576 rsurface.svector3f = rsurface.array_deformedsvector3f;
4577 rsurface.svector3f_bufferobject = 0;
4578 rsurface.svector3f_bufferoffset = 0;
4579 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4580 rsurface.tvector3f_bufferobject = 0;
4581 rsurface.tvector3f_bufferoffset = 0;
4582 rsurface.normal3f = rsurface.array_deformednormal3f;
4583 rsurface.normal3f_bufferobject = 0;
4584 rsurface.normal3f_bufferoffset = 0;
4586 case Q3DEFORM_AUTOSPRITE2:
4587 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4588 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4589 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4590 VectorNormalize(newforward);
4591 VectorNormalize(newright);
4592 VectorNormalize(newup);
4593 // make deformed versions of only the model vertices used by the specified surfaces
4594 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4596 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4597 const float *v1, *v2;
4607 memset(shortest, 0, sizeof(shortest));
4608 // a single autosprite surface can contain multiple sprites...
4609 for (j = 0;j < surface->num_vertices - 3;j += 4)
4611 VectorClear(center);
4612 for (i = 0;i < 4;i++)
4613 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4614 VectorScale(center, 0.25f, center);
4615 // find the two shortest edges, then use them to define the
4616 // axis vectors for rotating around the central axis
4617 for (i = 0;i < 6;i++)
4619 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
4620 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
4622 Debug_PolygonBegin(NULL, 0, false, 0);
4623 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
4624 Debug_PolygonVertex((v1[0] + v2[0]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, (v1[1] + v2[1]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1], (v1[2] + v2[2]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2], 0, 0, 1, 1, 0, 1);
4625 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
4628 l = VectorDistance2(v1, v2);
4629 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
4631 l += (1.0f / 1024.0f);
4632 if (shortest[0].length2 > l || i == 0)
4634 shortest[1] = shortest[0];
4635 shortest[0].length2 = l;
4636 shortest[0].v1 = v1;
4637 shortest[0].v2 = v2;
4639 else if (shortest[1].length2 > l || i == 1)
4641 shortest[1].length2 = l;
4642 shortest[1].v1 = v1;
4643 shortest[1].v2 = v2;
4646 VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
4647 VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
4649 Debug_PolygonBegin(NULL, 0, false, 0);
4650 Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
4651 Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 4, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 4, 0, 0, 0, 1, 0, 1);
4652 Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
4655 // this calculates the right vector from the shortest edge
4656 // and the up vector from the edge midpoints
4657 VectorSubtract(shortest[0].v1, shortest[0].v2, right);
4658 VectorNormalize(right);
4659 VectorSubtract(end, start, up);
4660 VectorNormalize(up);
4661 // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
4662 //VectorSubtract(rsurface.modelorg, center, forward);
4663 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, forward);
4664 VectorNegate(forward, forward);
4665 VectorReflect(forward, 0, up, forward);
4666 VectorNormalize(forward);
4667 CrossProduct(up, forward, newright);
4668 VectorNormalize(newright);
4670 Debug_PolygonBegin(NULL, 0, false, 0);
4671 Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 8, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 8, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 8, 0, 0, 1, 0, 0, 1);
4672 Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
4673 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4677 Debug_PolygonBegin(NULL, 0, false, 0);
4678 Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
4679 Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
4680 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4683 // rotate the quad around the up axis vector, this is made
4684 // especially easy by the fact we know the quad is flat,
4685 // so we only have to subtract the center position and
4686 // measure distance along the right vector, and then
4687 // multiply that by the newright vector and add back the
4689 // we also need to subtract the old position to undo the
4690 // displacement from the center, which we do with a
4691 // DotProduct, the subtraction/addition of center is also
4692 // optimized into DotProducts here
4693 l = DotProduct(right, center);
4694 for (i = 0;i < 4;i++)
4696 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
4697 f = DotProduct(right, v1) - l;
4698 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4701 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
4702 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
4704 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4705 rsurface.vertex3f_bufferobject = 0;
4706 rsurface.vertex3f_bufferoffset = 0;
4707 rsurface.svector3f = rsurface.array_deformedsvector3f;
4708 rsurface.svector3f_bufferobject = 0;
4709 rsurface.svector3f_bufferoffset = 0;
4710 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4711 rsurface.tvector3f_bufferobject = 0;
4712 rsurface.tvector3f_bufferoffset = 0;
4713 rsurface.normal3f = rsurface.array_deformednormal3f;
4714 rsurface.normal3f_bufferobject = 0;
4715 rsurface.normal3f_bufferoffset = 0;
4717 case Q3DEFORM_NORMAL:
4718 // deform the normals to make reflections wavey
4719 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4721 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4722 for (j = 0;j < surface->num_vertices;j++)
4725 float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3;
4726 VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
4727 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal);
4728 normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4729 normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4730 normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4731 VectorNormalize(normal);
4733 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
4735 rsurface.svector3f = rsurface.array_deformedsvector3f;
4736 rsurface.svector3f_bufferobject = 0;
4737 rsurface.svector3f_bufferoffset = 0;
4738 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4739 rsurface.tvector3f_bufferobject = 0;
4740 rsurface.tvector3f_bufferoffset = 0;
4741 rsurface.normal3f = rsurface.array_deformednormal3f;
4742 rsurface.normal3f_bufferobject = 0;
4743 rsurface.normal3f_bufferoffset = 0;
4746 // deform vertex array to make wavey water and flags and such
4747 waveparms[0] = deform->waveparms[0];
4748 waveparms[1] = deform->waveparms[1];
4749 waveparms[2] = deform->waveparms[2];
4750 waveparms[3] = deform->waveparms[3];
4751 // this is how a divisor of vertex influence on deformation
4752 animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
4753 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4754 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4756 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4757 for (j = 0;j < surface->num_vertices;j++)
4759 float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3;
4760 VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex);
4761 // if the wavefunc depends on time, evaluate it per-vertex
4764 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
4765 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4767 VectorMA(vertex, scale, (rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, vertex);
4770 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4771 rsurface.vertex3f_bufferobject = 0;
4772 rsurface.vertex3f_bufferoffset = 0;
4774 case Q3DEFORM_BULGE:
4775 // deform vertex array to make the surface have moving bulges
4776 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4778 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4779 for (j = 0;j < surface->num_vertices;j++)
4781 scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.time * deform->parms[2])) * deform->parms[1];
4782 VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4785 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4786 rsurface.vertex3f_bufferobject = 0;
4787 rsurface.vertex3f_bufferoffset = 0;
4790 // deform vertex array
4791 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
4792 VectorScale(deform->parms, scale, waveparms);
4793 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4795 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4796 for (j = 0;j < surface->num_vertices;j++)
4797 VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4799 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4800 rsurface.vertex3f_bufferobject = 0;
4801 rsurface.vertex3f_bufferoffset = 0;
4805 // generate texcoords based on the chosen texcoord source
4806 switch(rsurface.texture->tcgen.tcgen)
4809 case Q3TCGEN_TEXTURE:
4810 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4811 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordtexture2f_bufferobject;
4812 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
4814 case Q3TCGEN_LIGHTMAP:
4815 rsurface.texcoordtexture2f = rsurface.modeltexcoordlightmap2f;
4816 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4817 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4819 case Q3TCGEN_VECTOR:
4820 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4822 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4823 for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, out_tc += 2)
4825 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
4826 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
4829 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4830 rsurface.texcoordtexture2f_bufferobject = 0;
4831 rsurface.texcoordtexture2f_bufferoffset = 0;
4833 case Q3TCGEN_ENVIRONMENT:
4834 // make environment reflections using a spheremap
4835 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4837 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4838 const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
4839 const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
4840 float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
4841 for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
4843 float l, d, eyedir[3];
4844 VectorSubtract(rsurface.modelorg, vertex, eyedir);
4845 l = 0.5f / VectorLength(eyedir);
4846 d = DotProduct(normal, eyedir)*2;
4847 out_tc[0] = 0.5f + (normal[1]*d - eyedir[1])*l;
4848 out_tc[1] = 0.5f - (normal[2]*d - eyedir[2])*l;
4851 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4852 rsurface.texcoordtexture2f_bufferobject = 0;
4853 rsurface.texcoordtexture2f_bufferoffset = 0;
4856 // the only tcmod that needs software vertex processing is turbulent, so
4857 // check for it here and apply the changes if needed
4858 // and we only support that as the first one
4859 // (handling a mixture of turbulent and other tcmods would be problematic
4860 // without punting it entirely to a software path)
4861 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
4863 amplitude = rsurface.texture->tcmods[0].parms[1];
4864 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.time * rsurface.texture->tcmods[0].parms[3];
4865 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4867 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4868 for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, in_tc = rsurface.texcoordtexture2f + 2 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, in_tc += 2, out_tc += 2)
4870 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4871 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4874 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4875 rsurface.texcoordtexture2f_bufferobject = 0;
4876 rsurface.texcoordtexture2f_bufferoffset = 0;
4878 rsurface.texcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
4879 rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4880 rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4881 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
4884 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
4887 const msurface_t *surface = texturesurfacelist[0];
4888 const msurface_t *surface2;
4893 // TODO: lock all array ranges before render, rather than on each surface
4894 if (texturenumsurfaces == 1)
4896 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4897 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
4899 else if (r_batchmode.integer == 2)
4901 #define MAXBATCHTRIANGLES 4096
4902 int batchtriangles = 0;
4903 int batchelements[MAXBATCHTRIANGLES*3];
4904 for (i = 0;i < texturenumsurfaces;i = j)
4906 surface = texturesurfacelist[i];
4908 if (surface->num_triangles > MAXBATCHTRIANGLES)
4910 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
4913 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
4914 batchtriangles = surface->num_triangles;
4915 firstvertex = surface->num_firstvertex;
4916 endvertex = surface->num_firstvertex + surface->num_vertices;
4917 for (;j < texturenumsurfaces;j++)
4919 surface2 = texturesurfacelist[j];
4920 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
4922 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
4923 batchtriangles += surface2->num_triangles;
4924 firstvertex = min(firstvertex, surface2->num_firstvertex);
4925 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
4927 surface2 = texturesurfacelist[j-1];
4928 numvertices = endvertex - firstvertex;
4929 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
4932 else if (r_batchmode.integer == 1)
4934 for (i = 0;i < texturenumsurfaces;i = j)
4936 surface = texturesurfacelist[i];
4937 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
4938 if (texturesurfacelist[j] != surface2)
4940 surface2 = texturesurfacelist[j-1];
4941 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
4942 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
4943 GL_LockArrays(surface->num_firstvertex, numvertices);
4944 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
4949 for (i = 0;i < texturenumsurfaces;i++)
4951 surface = texturesurfacelist[i];
4952 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4953 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
4958 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit, int refractiontexunit, int reflectiontexunit)
4960 int i, planeindex, vertexindex;
4964 r_waterstate_waterplane_t *p, *bestp;
4965 msurface_t *surface;
4966 if (r_waterstate.renderingscene)
4968 for (i = 0;i < texturenumsurfaces;i++)
4970 surface = texturesurfacelist[i];
4971 if (lightmaptexunit >= 0)
4972 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
4973 if (deluxemaptexunit >= 0)
4974 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
4975 // pick the closest matching water plane
4978 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
4981 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
4983 Matrix4x4_Transform(&rsurface.matrix, v, vert);
4984 d += fabs(PlaneDiff(vert, &p->plane));
4986 if (bestd > d || !bestp)
4994 if (refractiontexunit >= 0)
4995 R_Mesh_TexBind(refractiontexunit, R_GetTexture(bestp->texture_refraction));
4996 if (reflectiontexunit >= 0)
4997 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(bestp->texture_reflection));
5001 if (refractiontexunit >= 0)
5002 R_Mesh_TexBind(refractiontexunit, R_GetTexture(r_texture_black));
5003 if (reflectiontexunit >= 0)
5004 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(r_texture_black));
5006 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5007 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5011 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit)
5015 const msurface_t *surface = texturesurfacelist[0];
5016 const msurface_t *surface2;
5021 // TODO: lock all array ranges before render, rather than on each surface
5022 if (texturenumsurfaces == 1)
5024 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5025 if (deluxemaptexunit >= 0)
5026 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5027 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5028 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5030 else if (r_batchmode.integer == 2)
5032 #define MAXBATCHTRIANGLES 4096
5033 int batchtriangles = 0;
5034 int batchelements[MAXBATCHTRIANGLES*3];
5035 for (i = 0;i < texturenumsurfaces;i = j)
5037 surface = texturesurfacelist[i];
5038 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5039 if (deluxemaptexunit >= 0)
5040 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5042 if (surface->num_triangles > MAXBATCHTRIANGLES)
5044 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5047 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
5048 batchtriangles = surface->num_triangles;
5049 firstvertex = surface->num_firstvertex;
5050 endvertex = surface->num_firstvertex + surface->num_vertices;
5051 for (;j < texturenumsurfaces;j++)
5053 surface2 = texturesurfacelist[j];
5054 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
5056 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
5057 batchtriangles += surface2->num_triangles;
5058 firstvertex = min(firstvertex, surface2->num_firstvertex);
5059 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
5061 surface2 = texturesurfacelist[j-1];
5062 numvertices = endvertex - firstvertex;
5063 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
5066 else if (r_batchmode.integer == 1)
5069 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
5070 for (i = 0;i < texturenumsurfaces;i = j)
5072 surface = texturesurfacelist[i];
5073 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5074 if (texturesurfacelist[j] != surface2)
5076 Con_Printf(" %i", j - i);
5079 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
5081 for (i = 0;i < texturenumsurfaces;i = j)
5083 surface = texturesurfacelist[i];
5084 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5085 if (deluxemaptexunit >= 0)
5086 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5087 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5088 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
5091 Con_Printf(" %i", j - i);
5093 surface2 = texturesurfacelist[j-1];
5094 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
5095 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
5096 GL_LockArrays(surface->num_firstvertex, numvertices);
5097 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5105 for (i = 0;i < texturenumsurfaces;i++)
5107 surface = texturesurfacelist[i];
5108 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5109 if (deluxemaptexunit >= 0)
5110 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5111 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5112 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5117 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5120 int texturesurfaceindex;
5121 if (r_showsurfaces.integer == 2)
5123 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5125 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5126 for (j = 0;j < surface->num_triangles;j++)
5128 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_view.colorscale;
5129 GL_Color(f, f, f, 1);
5130 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, 1, (rsurface.modelelement3i + 3 * (j + surface->num_firsttriangle)), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * (j + surface->num_firsttriangle)));
5136 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5138 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5139 int k = (int)(((size_t)surface) / sizeof(msurface_t));
5140 GL_Color((k & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 4) & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 8) & 15) * (1.0f / 16.0f) * r_view.colorscale, 1);
5141 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5142 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5147 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **texturesurfacelist)
5149 int texturesurfaceindex;
5153 if (rsurface.lightmapcolor4f)
5155 // generate color arrays for the surfaces in this list
5156 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5158 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5159 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
5161 f = FogPoint_Model(v);
5171 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5173 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5174 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
5176 f = FogPoint_Model(v);
5184 rsurface.lightmapcolor4f = rsurface.array_color4f;
5185 rsurface.lightmapcolor4f_bufferobject = 0;
5186 rsurface.lightmapcolor4f_bufferoffset = 0;
5189 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a)
5191 int texturesurfaceindex;
5194 if (!rsurface.lightmapcolor4f)
5196 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5198 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5199 for (i = 0, c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
5207 rsurface.lightmapcolor4f = rsurface.array_color4f;
5208 rsurface.lightmapcolor4f_bufferobject = 0;
5209 rsurface.lightmapcolor4f_bufferoffset = 0;
5212 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5215 rsurface.lightmapcolor4f = NULL;
5216 rsurface.lightmapcolor4f_bufferobject = 0;
5217 rsurface.lightmapcolor4f_bufferoffset = 0;
5218 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5219 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5220 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5221 GL_Color(r, g, b, a);
5222 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1);
5225 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5227 // TODO: optimize applyfog && applycolor case
5228 // just apply fog if necessary, and tint the fog color array if necessary
5229 rsurface.lightmapcolor4f = NULL;
5230 rsurface.lightmapcolor4f_bufferobject = 0;
5231 rsurface.lightmapcolor4f_bufferoffset = 0;
5232 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5233 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5234 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5235 GL_Color(r, g, b, a);
5236 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5239 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5241 int texturesurfaceindex;
5245 if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
5247 // generate color arrays for the surfaces in this list
5248 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5250 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5251 for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
5253 if (surface->lightmapinfo->samples)
5255 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
5256 float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
5257 VectorScale(lm, scale, c);
5258 if (surface->lightmapinfo->styles[1] != 255)
5260 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
5262 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
5263 VectorMA(c, scale, lm, c);
5264 if (surface->lightmapinfo->styles[2] != 255)
5267 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
5268 VectorMA(c, scale, lm, c);
5269 if (surface->lightmapinfo->styles[3] != 255)
5272 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
5273 VectorMA(c, scale, lm, c);
5283 rsurface.lightmapcolor4f = rsurface.array_color4f;
5284 rsurface.lightmapcolor4f_bufferobject = 0;
5285 rsurface.lightmapcolor4f_bufferoffset = 0;
5289 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
5290 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
5291 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
5293 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5294 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5295 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5296 GL_Color(r, g, b, a);
5297 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5300 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5302 int texturesurfaceindex;
5306 vec3_t ambientcolor;
5307 vec3_t diffusecolor;
5311 VectorCopy(rsurface.modellight_lightdir, lightdir);
5312 f = 0.5f * r_refdef.lightmapintensity;
5313 ambientcolor[0] = rsurface.modellight_ambient[0] * r * f;
5314 ambientcolor[1] = rsurface.modellight_ambient[1] * g * f;
5315 ambientcolor[2] = rsurface.modellight_ambient[2] * b * f;
5316 diffusecolor[0] = rsurface.modellight_diffuse[0] * r * f;
5317 diffusecolor[1] = rsurface.modellight_diffuse[1] * g * f;
5318 diffusecolor[2] = rsurface.modellight_diffuse[2] * b * f;
5319 if (VectorLength2(diffusecolor) > 0)
5321 // generate color arrays for the surfaces in this list
5322 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5324 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5325 int numverts = surface->num_vertices;
5326 v = rsurface.vertex3f + 3 * surface->num_firstvertex;
5327 c2 = rsurface.normal3f + 3 * surface->num_firstvertex;
5328 c = rsurface.array_color4f + 4 * surface->num_firstvertex;
5329 // q3-style directional shading
5330 for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
5332 if ((f = DotProduct(c2, lightdir)) > 0)
5333 VectorMA(ambientcolor, f, diffusecolor, c);
5335 VectorCopy(ambientcolor, c);
5344 rsurface.lightmapcolor4f = rsurface.array_color4f;
5345 rsurface.lightmapcolor4f_bufferobject = 0;
5346 rsurface.lightmapcolor4f_bufferoffset = 0;
5350 r = ambientcolor[0];
5351 g = ambientcolor[1];
5352 b = ambientcolor[2];
5353 rsurface.lightmapcolor4f = NULL;
5354 rsurface.lightmapcolor4f_bufferobject = 0;
5355 rsurface.lightmapcolor4f_bufferoffset = 0;
5357 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5358 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5359 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5360 GL_Color(r, g, b, a);
5361 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5364 void RSurf_SetupDepthAndCulling(void)
5366 // submodels are biased to avoid z-fighting with world surfaces that they
5367 // may be exactly overlapping (avoids z-fighting artifacts on certain
5368 // doors and things in Quake maps)
5369 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5370 GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
5371 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5372 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5375 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5377 RSurf_SetupDepthAndCulling();
5378 if (rsurface.mode != RSURFMODE_SHOWSURFACES)
5380 rsurface.mode = RSURFMODE_SHOWSURFACES;
5382 GL_BlendFunc(GL_ONE, GL_ZERO);
5383 R_Mesh_ColorPointer(NULL, 0, 0);
5384 R_Mesh_ResetTextureState();
5386 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5387 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5390 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
5392 // transparent sky would be ridiculous
5393 if ((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5395 if (rsurface.mode != RSURFMODE_SKY)
5397 if (rsurface.mode == RSURFMODE_GLSL)
5399 qglUseProgramObjectARB(0);CHECKGLERROR
5401 rsurface.mode = RSURFMODE_SKY;
5405 skyrendernow = false;
5407 // restore entity matrix
5408 R_Mesh_Matrix(&rsurface.matrix);
5410 RSurf_SetupDepthAndCulling();
5412 // LordHavoc: HalfLife maps have freaky skypolys so don't use
5413 // skymasking on them, and Quake3 never did sky masking (unlike
5414 // software Quake and software Quake2), so disable the sky masking
5415 // in Quake3 maps as it causes problems with q3map2 sky tricks,
5416 // and skymasking also looks very bad when noclipping outside the
5417 // level, so don't use it then either.
5418 if (r_refdef.worldmodel && r_refdef.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
5420 GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
5421 R_Mesh_ColorPointer(NULL, 0, 0);
5422 R_Mesh_ResetTextureState();
5423 if (skyrendermasked)
5425 // depth-only (masking)
5426 GL_ColorMask(0,0,0,0);
5427 // just to make sure that braindead drivers don't draw
5428 // anything despite that colormask...
5429 GL_BlendFunc(GL_ZERO, GL_ONE);
5434 GL_BlendFunc(GL_ONE, GL_ZERO);
5436 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5437 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5438 if (skyrendermasked)
5439 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5443 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
5445 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
5448 if (rsurface.mode != RSURFMODE_GLSL)
5450 rsurface.mode = RSURFMODE_GLSL;
5451 R_Mesh_ResetTextureState();
5454 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
5455 R_Mesh_TexBind(0, R_GetTexture(rsurface.texture->currentskinframe->nmap));
5456 R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
5457 R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
5458 R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
5459 R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
5460 R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
5461 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5463 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5464 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5465 R_Mesh_ColorPointer(NULL, 0, 0);
5467 else if (rsurface.uselightmaptexture)
5469 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5470 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5471 R_Mesh_ColorPointer(NULL, 0, 0);
5475 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5476 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5477 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5479 R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow));
5480 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5481 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5483 if (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5485 // render background
5486 GL_BlendFunc(GL_ONE, GL_ZERO);
5488 GL_AlphaTest(false);
5490 GL_Color(1, 1, 1, 1);
5491 R_Mesh_ColorPointer(NULL, 0, 0);
5493 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
5494 if (r_glsl_permutation)
5496 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
5497 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5498 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5499 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5500 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5501 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5502 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection ? 12 : -1);
5505 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5506 GL_DepthMask(false);
5507 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5508 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5510 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5511 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5512 R_Mesh_ColorPointer(NULL, 0, 0);
5514 else if (rsurface.uselightmaptexture)
5516 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5517 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5518 R_Mesh_ColorPointer(NULL, 0, 0);
5522 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5523 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5524 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5526 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5527 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5530 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
5531 if (!r_glsl_permutation)
5534 RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0 || r_glsl_permutation->loc_LightDir >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
5535 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5536 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5537 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5538 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5539 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5540 // FIXME MOVE THIS TO A UNIFORM
5541 GL_Color(rsurface.texture->currentlayers[0].color[0], rsurface.texture->currentlayers[0].color[1], rsurface.texture->currentlayers[0].color[2], rsurface.texture->currentlayers[0].color[3]);
5543 if (r_glsl_permutation->loc_Texture_Refraction >= 0)
5545 GL_BlendFunc(GL_ONE, GL_ZERO);
5547 GL_AlphaTest(false);
5550 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
5552 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5553 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? 12 : -1);
5555 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
5559 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5560 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction >= 0 ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection >= 0 ? 12 : -1);
5562 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5564 if (rsurface.texture->backgroundnumskinframes && !(rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5569 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
5571 // OpenGL 1.3 path - anything not completely ancient
5572 int texturesurfaceindex;
5573 qboolean applycolor;
5577 const texturelayer_t *layer;
5578 if (rsurface.mode != RSURFMODE_MULTIPASS)
5579 rsurface.mode = RSURFMODE_MULTIPASS;
5580 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5582 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5585 int layertexrgbscale;
5586 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5588 if (layerindex == 0)
5592 GL_AlphaTest(false);
5593 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5596 GL_DepthMask(layer->depthmask);
5597 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5598 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
5600 layertexrgbscale = 4;
5601 VectorScale(layer->color, 0.25f, layercolor);
5603 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
5605 layertexrgbscale = 2;
5606 VectorScale(layer->color, 0.5f, layercolor);
5610 layertexrgbscale = 1;
5611 VectorScale(layer->color, 1.0f, layercolor);
5613 layercolor[3] = layer->color[3];
5614 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
5615 R_Mesh_ColorPointer(NULL, 0, 0);
5616 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5617 switch (layer->type)
5619 case TEXTURELAYERTYPE_LITTEXTURE:
5620 memset(&m, 0, sizeof(m));
5621 m.tex[0] = R_GetTexture(r_texture_white);
5622 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5623 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5624 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5625 m.tex[1] = R_GetTexture(layer->texture);
5626 m.texmatrix[1] = layer->texmatrix;
5627 m.texrgbscale[1] = layertexrgbscale;
5628 m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
5629 m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
5630 m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
5631 R_Mesh_TextureState(&m);
5632 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5633 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5634 else if (rsurface.uselightmaptexture)
5635 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5637 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5639 case TEXTURELAYERTYPE_TEXTURE:
5640 memset(&m, 0, sizeof(m));
5641 m.tex[0] = R_GetTexture(layer->texture);
5642 m.texmatrix[0] = layer->texmatrix;
5643 m.texrgbscale[0] = layertexrgbscale;
5644 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5645 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5646 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5647 R_Mesh_TextureState(&m);
5648 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5650 case TEXTURELAYERTYPE_FOG:
5651 memset(&m, 0, sizeof(m));
5652 m.texrgbscale[0] = layertexrgbscale;
5655 m.tex[0] = R_GetTexture(layer->texture);
5656 m.texmatrix[0] = layer->texmatrix;
5657 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5658 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5659 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5661 R_Mesh_TextureState(&m);
5662 // generate a color array for the fog pass
5663 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5664 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5668 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5669 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
5671 f = 1 - FogPoint_Model(v);
5672 c[0] = layercolor[0];
5673 c[1] = layercolor[1];
5674 c[2] = layercolor[2];
5675 c[3] = f * layercolor[3];
5678 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5681 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5683 GL_LockArrays(0, 0);
5686 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5688 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5689 GL_AlphaTest(false);
5693 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist)
5695 // OpenGL 1.1 - crusty old voodoo path
5696 int texturesurfaceindex;
5700 const texturelayer_t *layer;
5701 if (rsurface.mode != RSURFMODE_MULTIPASS)
5702 rsurface.mode = RSURFMODE_MULTIPASS;
5703 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5705 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5707 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5709 if (layerindex == 0)
5713 GL_AlphaTest(false);
5714 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5717 GL_DepthMask(layer->depthmask);
5718 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5719 R_Mesh_ColorPointer(NULL, 0, 0);
5720 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5721 switch (layer->type)
5723 case TEXTURELAYERTYPE_LITTEXTURE:
5724 if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
5726 // two-pass lit texture with 2x rgbscale
5727 // first the lightmap pass
5728 memset(&m, 0, sizeof(m));
5729 m.tex[0] = R_GetTexture(r_texture_white);
5730 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5731 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5732 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5733 R_Mesh_TextureState(&m);
5734 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5735 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5736 else if (rsurface.uselightmaptexture)
5737 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5739 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5740 GL_LockArrays(0, 0);
5741 // then apply the texture to it
5742 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5743 memset(&m, 0, sizeof(m));
5744 m.tex[0] = R_GetTexture(layer->texture);
5745 m.texmatrix[0] = layer->texmatrix;
5746 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5747 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5748 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5749 R_Mesh_TextureState(&m);
5750 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0] * 0.5f, layer->color[1] * 0.5f, layer->color[2] * 0.5f, layer->color[3], layer->color[0] != 2 || layer->color[1] != 2 || layer->color[2] != 2 || layer->color[3] != 1, false);
5754 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
5755 memset(&m, 0, sizeof(m));
5756 m.tex[0] = R_GetTexture(layer->texture);
5757 m.texmatrix[0] = layer->texmatrix;
5758 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5759 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5760 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5761 R_Mesh_TextureState(&m);
5762 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5763 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
5765 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
5768 case TEXTURELAYERTYPE_TEXTURE:
5769 // singletexture unlit texture with transparency support
5770 memset(&m, 0, sizeof(m));
5771 m.tex[0] = R_GetTexture(layer->texture);
5772 m.texmatrix[0] = layer->texmatrix;
5773 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5774 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5775 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5776 R_Mesh_TextureState(&m);
5777 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
5779 case TEXTURELAYERTYPE_FOG:
5780 // singletexture fogging
5781 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5784 memset(&m, 0, sizeof(m));
5785 m.tex[0] = R_GetTexture(layer->texture);
5786 m.texmatrix[0] = layer->texmatrix;
5787 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5788 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5789 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5790 R_Mesh_TextureState(&m);
5793 R_Mesh_ResetTextureState();
5794 // generate a color array for the fog pass
5795 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5799 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5800 for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
5802 f = 1 - FogPoint_Model(v);
5803 c[0] = layer->color[0];
5804 c[1] = layer->color[1];
5805 c[2] = layer->color[2];
5806 c[3] = f * layer->color[3];
5809 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5812 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5814 GL_LockArrays(0, 0);
5817 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5819 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5820 GL_AlphaTest(false);
5824 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly)
5826 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW)
5828 rsurface.rtlight = NULL;
5832 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
5834 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
5836 if (rsurface.mode != RSURFMODE_MULTIPASS)
5837 rsurface.mode = RSURFMODE_MULTIPASS;
5838 if (r_depthfirst.integer == 3)
5840 int i = (int)(texturesurfacelist[0] - rsurface.modelsurfaces);
5841 if (!r_view.showdebug)
5842 GL_Color(0, 0, 0, 1);
5844 GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1);
5848 GL_ColorMask(0,0,0,0);
5851 RSurf_SetupDepthAndCulling();
5853 GL_BlendFunc(GL_ONE, GL_ZERO);
5855 GL_AlphaTest(false);
5856 R_Mesh_ColorPointer(NULL, 0, 0);
5857 R_Mesh_ResetTextureState();
5858 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5859 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5860 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5862 else if (r_depthfirst.integer == 3)
5864 else if (!r_view.showdebug && (r_showsurfaces.integer || gl_lightmaps.integer))
5866 GL_Color(0, 0, 0, 1);
5867 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5869 else if (r_showsurfaces.integer)
5871 if (rsurface.mode != RSURFMODE_MULTIPASS)
5872 rsurface.mode = RSURFMODE_MULTIPASS;
5873 RSurf_SetupDepthAndCulling();
5875 GL_BlendFunc(GL_ONE, GL_ZERO);
5876 GL_DepthMask(writedepth);
5878 GL_AlphaTest(false);
5879 R_Mesh_ColorPointer(NULL, 0, 0);
5880 R_Mesh_ResetTextureState();
5881 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5882 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5884 else if (gl_lightmaps.integer)
5887 if (rsurface.mode != RSURFMODE_MULTIPASS)
5888 rsurface.mode = RSURFMODE_MULTIPASS;
5889 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5891 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5892 GL_BlendFunc(GL_ONE, GL_ZERO);
5893 GL_DepthMask(writedepth);
5895 GL_AlphaTest(false);
5896 R_Mesh_ColorPointer(NULL, 0, 0);
5897 memset(&m, 0, sizeof(m));
5898 m.tex[0] = R_GetTexture(r_texture_white);
5899 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5900 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5901 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5902 R_Mesh_TextureState(&m);
5903 RSurf_PrepareVerticesForBatch(rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, false, texturenumsurfaces, texturesurfacelist);
5904 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5905 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5906 else if (rsurface.uselightmaptexture)
5907 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5909 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5911 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
5912 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
5913 else if (rsurface.texture->currentnumlayers)
5915 // write depth for anything we skipped on the depth-only pass earlier
5916 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5918 RSurf_SetupDepthAndCulling();
5919 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5920 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
5921 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5922 if (r_glsl.integer && gl_support_fragment_shader)
5923 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
5924 else if (gl_combine.integer && r_textureunits.integer >= 2)
5925 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist);
5927 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist);
5930 GL_LockArrays(0, 0);
5933 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5936 int texturenumsurfaces, endsurface;
5938 msurface_t *surface;
5939 msurface_t *texturesurfacelist[1024];
5941 // if the model is static it doesn't matter what value we give for
5942 // wantnormals and wanttangents, so this logic uses only rules applicable
5943 // to a model, knowing that they are meaningless otherwise
5944 if (ent == r_refdef.worldentity)
5945 RSurf_ActiveWorldEntity();
5946 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
5947 RSurf_ActiveModelEntity(ent, false, false);
5949 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
5951 for (i = 0;i < numsurfaces;i = j)
5954 surface = rsurface.modelsurfaces + surfacelist[i];
5955 texture = surface->texture;
5956 R_UpdateTextureInfo(ent, texture);
5957 rsurface.texture = texture->currentframe;
5958 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
5959 // scan ahead until we find a different texture
5960 endsurface = min(i + 1024, numsurfaces);
5961 texturenumsurfaces = 0;
5962 texturesurfacelist[texturenumsurfaces++] = surface;
5963 for (;j < endsurface;j++)
5965 surface = rsurface.modelsurfaces + surfacelist[j];
5966 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
5968 texturesurfacelist[texturenumsurfaces++] = surface;
5970 // render the range of surfaces
5971 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist, true, false);
5977 void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
5980 vec3_t tempcenter, center;
5982 // if we're rendering water textures (extra scene renders), use a separate loop to avoid burdening the main one
5985 for (i = 0;i < numsurfaces;i++)
5986 if (surfacelist[i]->texture->currentframe->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
5987 R_Water_AddWaterPlane(surfacelist[i]);
5990 // break the surface list down into batches by texture and use of lightmapping
5991 for (i = 0;i < numsurfaces;i = j)
5994 // texture is the base texture pointer, rsurface.texture is the
5995 // current frame/skin the texture is directing us to use (for example
5996 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
5997 // use skin 1 instead)
5998 texture = surfacelist[i]->texture;
5999 rsurface.texture = texture->currentframe;
6000 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
6001 if (!(rsurface.texture->currentmaterialflags & flagsmask))
6003 // if this texture is not the kind we want, skip ahead to the next one
6004 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
6008 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
6010 // transparent surfaces get pushed off into the transparent queue
6011 const msurface_t *surface = surfacelist[i];
6014 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
6015 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
6016 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
6017 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
6018 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.modelsurfaces, rsurface.rtlight);
6022 // simply scan ahead until we find a different texture or lightmap state
6023 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
6025 // render the range of surfaces
6026 R_DrawTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly);
6031 float locboxvertex3f[6*4*3] =
6033 1,0,1, 1,0,0, 1,1,0, 1,1,1,
6034 0,1,1, 0,1,0, 0,0,0, 0,0,1,
6035 1,1,1, 1,1,0, 0,1,0, 0,1,1,
6036 0,0,1, 0,0,0, 1,0,0, 1,0,1,
6037 0,0,1, 1,0,1, 1,1,1, 0,1,1,
6038 1,0,0, 0,0,0, 0,1,0, 1,1,0
6041 int locboxelement3i[6*2*3] =
6051 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6054 cl_locnode_t *loc = (cl_locnode_t *)ent;
6056 float vertex3f[6*4*3];
6058 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6059 GL_DepthMask(false);
6060 GL_DepthRange(0, 1);
6061 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6063 GL_CullFace(GL_NONE);
6064 R_Mesh_Matrix(&identitymatrix);
6066 R_Mesh_VertexPointer(vertex3f, 0, 0);
6067 R_Mesh_ColorPointer(NULL, 0, 0);
6068 R_Mesh_ResetTextureState();
6071 GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_view.colorscale,
6072 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_view.colorscale,
6073 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_view.colorscale,
6074 surfacelist[0] < 0 ? 0.5f : 0.125f);
6076 if (VectorCompare(loc->mins, loc->maxs))
6078 VectorSet(size, 2, 2, 2);
6079 VectorMA(loc->mins, -0.5f, size, mins);
6083 VectorCopy(loc->mins, mins);
6084 VectorSubtract(loc->maxs, loc->mins, size);
6087 for (i = 0;i < 6*4*3;)
6088 for (j = 0;j < 3;j++, i++)
6089 vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
6091 R_Mesh_Draw(0, 6*4, 6*2, locboxelement3i, 0, 0);
6094 void R_DrawLocs(void)
6097 cl_locnode_t *loc, *nearestloc;
6099 nearestloc = CL_Locs_FindNearest(cl.movement_origin);
6100 for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
6102 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
6103 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
6107 void R_DrawDebugModel(entity_render_t *ent)
6109 int i, j, k, l, flagsmask;
6110 const int *elements;
6112 msurface_t *surface;
6113 model_t *model = ent->model;
6116 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WATER | MATERIALFLAG_WALL;
6118 R_Mesh_ColorPointer(NULL, 0, 0);
6119 R_Mesh_ResetTextureState();
6120 GL_DepthRange(0, 1);
6121 GL_DepthTest(!r_showdisabledepthtest.integer);
6122 GL_DepthMask(false);
6123 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6125 if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
6127 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
6128 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
6130 if (brush->colbrushf && brush->colbrushf->numtriangles)
6132 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
6133 GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, r_showcollisionbrushes.value);
6134 R_Mesh_Draw(0, brush->colbrushf->numpoints, brush->colbrushf->numtriangles, brush->colbrushf->elements, 0, 0);
6137 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
6139 if (surface->num_collisiontriangles)
6141 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
6142 GL_Color((i & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_view.colorscale, r_showcollisionbrushes.value);
6143 R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i, 0, 0);
6148 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6150 if (r_showtris.integer || r_shownormals.integer)
6152 if (r_showdisabledepthtest.integer)
6154 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6155 GL_DepthMask(false);
6159 GL_BlendFunc(GL_ONE, GL_ZERO);
6162 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
6164 if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
6166 rsurface.texture = surface->texture->currentframe;
6167 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
6169 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
6170 if (r_showtris.value > 0)
6172 if (!rsurface.texture->currentlayers->depthmask)
6173 GL_Color(r_view.colorscale, 0, 0, r_showtris.value);
6174 else if (ent == r_refdef.worldentity)
6175 GL_Color(r_view.colorscale, r_view.colorscale, r_view.colorscale, r_showtris.value);
6177 GL_Color(0, r_view.colorscale, 0, r_showtris.value);
6178 elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
6181 for (k = 0;k < surface->num_triangles;k++, elements += 3)
6183 #define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
6184 GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
6185 GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
6186 GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
6191 if (r_shownormals.value > 0)
6194 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6196 VectorCopy(rsurface.vertex3f + l * 3, v);
6197 GL_Color(r_view.colorscale, 0, 0, 1);
6198 qglVertex3f(v[0], v[1], v[2]);
6199 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
6200 GL_Color(r_view.colorscale, 1, 1, 1);
6201 qglVertex3f(v[0], v[1], v[2]);
6206 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6208 VectorCopy(rsurface.vertex3f + l * 3, v);
6209 GL_Color(0, r_view.colorscale, 0, 1);
6210 qglVertex3f(v[0], v[1], v[2]);
6211 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
6212 GL_Color(r_view.colorscale, 1, 1, 1);
6213 qglVertex3f(v[0], v[1], v[2]);
6218 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6220 VectorCopy(rsurface.vertex3f + l * 3, v);
6221 GL_Color(0, 0, r_view.colorscale, 1);
6222 qglVertex3f(v[0], v[1], v[2]);
6223 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
6224 GL_Color(r_view.colorscale, 1, 1, 1);
6225 qglVertex3f(v[0], v[1], v[2]);
6232 rsurface.texture = NULL;
6236 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
6237 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6239 int i, j, endj, f, flagsmask;
6240 msurface_t *surface;
6242 model_t *model = r_refdef.worldmodel;
6243 const int maxsurfacelist = 1024;
6244 int numsurfacelist = 0;
6245 msurface_t *surfacelist[1024];
6249 RSurf_ActiveWorldEntity();
6251 // update light styles on this submodel
6252 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6254 model_brush_lightstyleinfo_t *style;
6255 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6257 if (style->value != r_refdef.lightstylevalue[style->style])
6259 msurface_t *surfaces = model->data_surfaces;
6260 int *list = style->surfacelist;
6261 style->value = r_refdef.lightstylevalue[style->style];
6262 for (j = 0;j < style->numsurfaces;j++)
6263 surfaces[list[j]].cached_dlight = true;
6268 R_UpdateAllTextureInfo(r_refdef.worldentity);
6269 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6273 R_DrawDebugModel(r_refdef.worldentity);
6279 rsurface.uselightmaptexture = false;
6280 rsurface.texture = NULL;
6282 j = model->firstmodelsurface;
6283 endj = j + model->nummodelsurfaces;
6286 // quickly skip over non-visible surfaces
6287 for (;j < endj && !r_viewcache.world_surfacevisible[j];j++)
6289 // quickly iterate over visible surfaces
6290 for (;j < endj && r_viewcache.world_surfacevisible[j];j++)
6292 // process this surface
6293 surface = model->data_surfaces + j;
6294 // if this surface fits the criteria, add it to the list
6295 if (surface->num_triangles)
6297 // if lightmap parameters changed, rebuild lightmap texture
6298 if (surface->cached_dlight)
6299 R_BuildLightMap(r_refdef.worldentity, surface);
6300 // add face to draw list
6301 surfacelist[numsurfacelist++] = surface;
6302 r_refdef.stats.world_triangles += surface->num_triangles;
6303 if (numsurfacelist >= maxsurfacelist)
6305 r_refdef.stats.world_surfaces += numsurfacelist;
6306 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6312 r_refdef.stats.world_surfaces += numsurfacelist;
6314 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6318 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6320 int i, j, f, flagsmask;
6321 msurface_t *surface, *endsurface;
6323 model_t *model = ent->model;
6324 const int maxsurfacelist = 1024;
6325 int numsurfacelist = 0;
6326 msurface_t *surfacelist[1024];
6330 // if the model is static it doesn't matter what value we give for
6331 // wantnormals and wanttangents, so this logic uses only rules applicable
6332 // to a model, knowing that they are meaningless otherwise
6333 if (ent == r_refdef.worldentity)
6334 RSurf_ActiveWorldEntity();
6335 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
6336 RSurf_ActiveModelEntity(ent, false, false);
6338 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader && !depthonly);
6340 // update light styles
6341 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6343 model_brush_lightstyleinfo_t *style;
6344 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6346 if (style->value != r_refdef.lightstylevalue[style->style])
6348 msurface_t *surfaces = model->data_surfaces;
6349 int *list = style->surfacelist;
6350 style->value = r_refdef.lightstylevalue[style->style];
6351 for (j = 0;j < style->numsurfaces;j++)
6352 surfaces[list[j]].cached_dlight = true;
6357 R_UpdateAllTextureInfo(ent);
6358 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6362 R_DrawDebugModel(ent);
6368 rsurface.uselightmaptexture = false;
6369 rsurface.texture = NULL;
6371 surface = model->data_surfaces + model->firstmodelsurface;
6372 endsurface = surface + model->nummodelsurfaces;
6373 for (;surface < endsurface;surface++)
6375 // if this surface fits the criteria, add it to the list
6376 if (surface->num_triangles)
6378 // if lightmap parameters changed, rebuild lightmap texture
6379 if (surface->cached_dlight)
6380 R_BuildLightMap(ent, surface);
6381 // add face to draw list
6382 surfacelist[numsurfacelist++] = surface;
6383 r_refdef.stats.entities_triangles += surface->num_triangles;
6384 if (numsurfacelist >= maxsurfacelist)
6386 r_refdef.stats.entities_surfaces += numsurfacelist;
6387 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6392 r_refdef.stats.entities_surfaces += numsurfacelist;
6394 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);