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_end = 1000000000;
254 float FogForDistance(vec_t dist)
256 unsigned int fogmasktableindex = (unsigned int)(bound(0, dist - r_refdef.fog_start, r_refdef.fog_end - r_refdef.fog_start) * 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"
613 "uniform float FogStart;\n"
614 "uniform float FogLength;\n"
616 "uniform myhalf AmbientScale;\n"
617 "uniform myhalf DiffuseScale;\n"
618 "uniform myhalf SpecularScale;\n"
619 "uniform myhalf SpecularPower;\n"
621 "#ifdef USEOFFSETMAPPING\n"
622 "vec2 OffsetMapping(vec2 TexCoord)\n"
624 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
625 " // 14 sample relief mapping: linear search and then binary search\n"
626 " // this basically steps forward a small amount repeatedly until it finds\n"
627 " // itself inside solid, then jitters forward and back using decreasing\n"
628 " // amounts to find the impact\n"
629 " //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
630 " //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
631 " vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
632 " vec3 RT = vec3(TexCoord, 1);\n"
633 " OffsetVector *= 0.1;\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);\n"
642 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
643 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) - 0.5);\n"
644 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5 - 0.25);\n"
645 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25 - 0.125);\n"
646 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125 - 0.0625);\n"
647 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
650 " // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
651 " // this basically moves forward the full distance, and then backs up based\n"
652 " // on height of samples\n"
653 " //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
654 " //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
655 " vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
656 " TexCoord += OffsetVector;\n"
657 " OffsetVector *= 0.333;\n"
658 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
659 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
660 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
661 " return TexCoord;\n"
664 "#endif // USEOFFSETMAPPING\n"
666 "#ifdef MODE_WATER\n"
671 "#ifdef USEOFFSETMAPPING\n"
672 " // apply offsetmapping\n"
673 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
674 "#define TexCoord TexCoordOffset\n"
677 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
678 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
679 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
680 " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 5.0) * ReflectFactor + ReflectOffset;\n"
681 " gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
684 "#else // MODE_WATER\n"
685 "#ifdef MODE_REFRACTION\n"
687 "// refraction pass\n"
690 "#ifdef USEOFFSETMAPPING\n"
691 " // apply offsetmapping\n"
692 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
693 "#define TexCoord TexCoordOffset\n"
696 " vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
697 " //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
698 " vec2 ScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
699 " gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
702 "#else // MODE_REFRACTION\n"
705 "#ifdef USEOFFSETMAPPING\n"
706 " // apply offsetmapping\n"
707 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
708 "#define TexCoord TexCoordOffset\n"
711 " // combine the diffuse textures (base, pants, shirt)\n"
712 " myhvec4 color = myhvec4(texture2D(Texture_Color, TexCoord));\n"
713 "#ifdef USECOLORMAPPING\n"
714 " color.rgb += myhvec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhvec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
720 "#ifdef MODE_LIGHTSOURCE\n"
723 " // calculate surface normal, light normal, and specular normal\n"
724 " // compute color intensity for the two textures (colormap and glossmap)\n"
725 " // scale by light color and attenuation as efficiently as possible\n"
726 " // (do as much scalar math as possible rather than vector math)\n"
727 "# ifdef USESPECULAR\n"
728 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
729 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
730 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
732 " // calculate directional shading\n"
733 " 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"
735 "# ifdef USEDIFFUSE\n"
736 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
737 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
739 " // calculate directional shading\n"
740 " 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"
742 " // calculate directionless shading\n"
743 " color.rgb = color.rgb * LightColor * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
747 "# ifdef USECUBEFILTER\n"
748 " // apply light cubemap filter\n"
749 " //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
750 " color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
752 " color *= myhvec4(gl_Color);\n"
753 "#endif // MODE_LIGHTSOURCE\n"
758 "#ifdef MODE_LIGHTDIRECTION\n"
759 " // directional model lighting\n"
760 "# ifdef USESPECULAR\n"
761 " // get the surface normal and light normal\n"
762 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
763 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
765 " // calculate directional shading\n"
766 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
767 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
768 " color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
770 "# ifdef USEDIFFUSE\n"
771 " // get the surface normal and light normal\n"
772 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
773 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
775 " // calculate directional shading\n"
776 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
778 " color.rgb *= AmbientColor;\n"
782 " color *= myhvec4(gl_Color);\n"
783 "#endif // MODE_LIGHTDIRECTION\n"
788 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
789 " // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
791 " // get the surface normal and light normal\n"
792 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
794 " myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5);\n"
795 " myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, myhvec3(VectorS)), dot(diffusenormal_modelspace, myhvec3(VectorT)), dot(diffusenormal_modelspace, myhvec3(VectorR))));\n"
796 " // calculate directional shading\n"
797 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
798 "# ifdef USESPECULAR\n"
799 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
800 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
803 " // apply lightmap color\n"
804 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
805 " color.a *= myhalf(gl_Color.a);\n"
806 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
811 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
812 " // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
814 " // get the surface normal and light normal\n"
815 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
817 " myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5));\n"
818 " // calculate directional shading\n"
819 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
820 "# ifdef USESPECULAR\n"
821 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
822 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
825 " // apply lightmap color\n"
826 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
827 " color.a *= myhalf(gl_Color.a);\n"
828 "#endif // MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
833 "#ifdef MODE_LIGHTMAP\n"
834 " // apply lightmap color\n"
835 " color *= myhvec4(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec4(gl_Color) * myhvec4(myhvec3(DiffuseScale), 1) + myhvec4(myhvec3(AmbientScale), 0);\n"
836 "#endif // MODE_LIGHTMAP\n"
846 " color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
849 "#ifndef MODE_LIGHTSOURCE\n"
850 "# ifdef USEREFLECTION\n"
851 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
852 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
853 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
854 " color.rgb = mix(color.rgb, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor.rgb, ReflectColor.a);\n"
858 "#ifdef USECONTRASTBOOST\n"
859 " color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
862 " color.rgb *= SceneBrightness;\n"
866 " color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(max(0.0, min(length(EyeVectorModelSpace) - FogStart, FogLength))*FogRangeRecip, 0.0))));\n"
867 //" color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
870 " gl_FragColor = vec4(color);\n"
872 "#endif // MODE_REFRACTION\n"
873 "#endif // MODE_WATER\n"
875 "#endif // FRAGMENT_SHADER\n"
878 #define SHADERPERMUTATION_COLORMAPPING (1<<0) // indicates this is a colormapped skin
879 #define SHADERPERMUTATION_CONTRASTBOOST (1<<1) // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma)
880 #define SHADERPERMUTATION_FOG (1<<2) // tint the color by fog color or black if using additive blend mode
881 #define SHADERPERMUTATION_CUBEFILTER (1<<3) // (lightsource) use cubemap light filter
882 #define SHADERPERMUTATION_GLOW (1<<4) // (lightmap) blend in an additive glow texture
883 #define SHADERPERMUTATION_DIFFUSE (1<<5) // (lightsource) whether to use directional shading
884 #define SHADERPERMUTATION_SPECULAR (1<<6) // (lightsource or deluxemapping) render specular effects
885 #define SHADERPERMUTATION_REFLECTION (1<<7) // normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
886 #define SHADERPERMUTATION_OFFSETMAPPING (1<<8) // adjust texcoords to roughly simulate a displacement mapped surface
887 #define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<9) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
888 #define SHADERPERMUTATION_MODEBASE (1<<10) // multiplier for the SHADERMODE_ values to get a valid index
890 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
891 const char *shaderpermutationinfo[][2] =
893 {"#define USECOLORMAPPING\n", " colormapping"},
894 {"#define USECONTRASTBOOST\n", " contrastboost"},
895 {"#define USEFOG\n", " fog"},
896 {"#define USECUBEFILTER\n", " cubefilter"},
897 {"#define USEGLOW\n", " glow"},
898 {"#define USEDIFFUSE\n", " diffuse"},
899 {"#define USESPECULAR\n", " specular"},
900 {"#define USEREFLECTION\n", " reflection"},
901 {"#define USEOFFSETMAPPING\n", " offsetmapping"},
902 {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
906 // this enum is multiplied by SHADERPERMUTATION_MODEBASE
907 typedef enum shadermode_e
909 SHADERMODE_LIGHTMAP, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
910 SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, // (lightmap) use directional pixel shading from texture containing modelspace light directions (deluxemap)
911 SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, // (lightmap) use directional pixel shading from texture containing tangentspace light directions (deluxemap)
912 SHADERMODE_LIGHTDIRECTION, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
913 SHADERMODE_LIGHTSOURCE, // (lightsource) use directional pixel shading from light source (rtlight)
914 SHADERMODE_REFRACTION, // refract background (the material is rendered normally after this pass)
915 SHADERMODE_WATER, // refract background and reflection (the material is rendered normally after this pass)
920 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
921 const char *shadermodeinfo[][2] =
923 {"#define MODE_LIGHTMAP\n", " lightmap"},
924 {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
925 {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
926 {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
927 {"#define MODE_LIGHTSOURCE\n", " lightsource"},
928 {"#define MODE_REFRACTION\n", " refraction"},
929 {"#define MODE_WATER\n", " water"},
933 #define SHADERPERMUTATION_INDICES (SHADERPERMUTATION_MODEBASE * SHADERMODE_COUNT)
935 typedef struct r_glsl_permutation_s
937 // indicates if we have tried compiling this permutation already
939 // 0 if compilation failed
941 // locations of detected uniforms in program object, or -1 if not found
942 int loc_Texture_Normal;
943 int loc_Texture_Color;
944 int loc_Texture_Gloss;
945 int loc_Texture_Cube;
946 int loc_Texture_Attenuation;
947 int loc_Texture_FogMask;
948 int loc_Texture_Pants;
949 int loc_Texture_Shirt;
950 int loc_Texture_Lightmap;
951 int loc_Texture_Deluxemap;
952 int loc_Texture_Glow;
953 int loc_Texture_Refraction;
954 int loc_Texture_Reflection;
956 int loc_LightPosition;
961 int loc_FogRangeRecip;
964 int loc_AmbientScale;
965 int loc_DiffuseScale;
966 int loc_SpecularScale;
967 int loc_SpecularPower;
969 int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost
970 int loc_OffsetMapping_Scale;
971 int loc_AmbientColor;
972 int loc_DiffuseColor;
973 int loc_SpecularColor;
975 int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost
976 int loc_DistortScaleRefractReflect;
977 int loc_ScreenScaleRefractReflect;
978 int loc_ScreenCenterRefractReflect;
979 int loc_RefractColor;
980 int loc_ReflectColor;
981 int loc_ReflectFactor;
982 int loc_ReflectOffset;
984 r_glsl_permutation_t;
986 // information about each possible shader permutation
987 r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_INDICES];
988 // currently selected permutation
989 r_glsl_permutation_t *r_glsl_permutation;
991 // these are additional flags used only by R_GLSL_CompilePermutation
992 #define SHADERTYPE_USES_VERTEXSHADER (1<<0)
993 #define SHADERTYPE_USES_GEOMETRYSHADER (1<<1)
994 #define SHADERTYPE_USES_FRAGMENTSHADER (1<<2)
996 static void R_GLSL_CompilePermutation(const char *filename, int permutation, int shadertype)
999 qboolean shaderfound;
1000 r_glsl_permutation_t *p = r_glsl_permutations + permutation;
1001 int vertstrings_count;
1002 int geomstrings_count;
1003 int fragstrings_count;
1005 const char *vertstrings_list[32+1];
1006 const char *geomstrings_list[32+1];
1007 const char *fragstrings_list[32+1];
1008 char permutationname[256];
1013 vertstrings_list[0] = "#define VERTEX_SHADER\n";
1014 geomstrings_list[0] = "#define GEOMETRY_SHADER\n";
1015 fragstrings_list[0] = "#define FRAGMENT_SHADER\n";
1016 vertstrings_count = 1;
1017 geomstrings_count = 1;
1018 fragstrings_count = 1;
1019 permutationname[0] = 0;
1020 i = permutation / SHADERPERMUTATION_MODEBASE;
1021 vertstrings_list[vertstrings_count++] = shadermodeinfo[i][0];
1022 geomstrings_list[geomstrings_count++] = shadermodeinfo[i][0];
1023 fragstrings_list[fragstrings_count++] = shadermodeinfo[i][0];
1024 strlcat(permutationname, shadermodeinfo[i][1], sizeof(permutationname));
1025 for (i = 0;shaderpermutationinfo[i][0];i++)
1027 if (permutation & (1<<i))
1029 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i][0];
1030 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i][0];
1031 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i][0];
1032 strlcat(permutationname, shaderpermutationinfo[i][1], sizeof(permutationname));
1036 // keep line numbers correct
1037 vertstrings_list[vertstrings_count++] = "\n";
1038 geomstrings_list[geomstrings_count++] = "\n";
1039 fragstrings_list[fragstrings_count++] = "\n";
1042 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1043 shaderfound = false;
1046 Con_DPrint("from disk... ");
1047 vertstrings_list[vertstrings_count++] = shaderstring;
1048 geomstrings_list[geomstrings_count++] = shaderstring;
1049 fragstrings_list[fragstrings_count++] = shaderstring;
1052 else if (!strcmp(filename, "glsl/default.glsl"))
1054 vertstrings_list[vertstrings_count++] = builtinshaderstring;
1055 geomstrings_list[geomstrings_count++] = builtinshaderstring;
1056 fragstrings_list[fragstrings_count++] = builtinshaderstring;
1059 // clear any lists that are not needed by this shader
1060 if (!(shadertype & SHADERTYPE_USES_VERTEXSHADER))
1061 vertstrings_count = 0;
1062 if (!(shadertype & SHADERTYPE_USES_GEOMETRYSHADER))
1063 geomstrings_count = 0;
1064 if (!(shadertype & SHADERTYPE_USES_FRAGMENTSHADER))
1065 fragstrings_count = 0;
1066 // compile the shader program
1067 if (shaderfound && vertstrings_count + geomstrings_count + fragstrings_count)
1068 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1072 qglUseProgramObjectARB(p->program);CHECKGLERROR
1073 // look up all the uniform variable names we care about, so we don't
1074 // have to look them up every time we set them
1075 p->loc_Texture_Normal = qglGetUniformLocationARB(p->program, "Texture_Normal");
1076 p->loc_Texture_Color = qglGetUniformLocationARB(p->program, "Texture_Color");
1077 p->loc_Texture_Gloss = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1078 p->loc_Texture_Cube = qglGetUniformLocationARB(p->program, "Texture_Cube");
1079 p->loc_Texture_Attenuation = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
1080 p->loc_Texture_FogMask = qglGetUniformLocationARB(p->program, "Texture_FogMask");
1081 p->loc_Texture_Pants = qglGetUniformLocationARB(p->program, "Texture_Pants");
1082 p->loc_Texture_Shirt = qglGetUniformLocationARB(p->program, "Texture_Shirt");
1083 p->loc_Texture_Lightmap = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
1084 p->loc_Texture_Deluxemap = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
1085 p->loc_Texture_Glow = qglGetUniformLocationARB(p->program, "Texture_Glow");
1086 p->loc_Texture_Refraction = qglGetUniformLocationARB(p->program, "Texture_Refraction");
1087 p->loc_Texture_Reflection = qglGetUniformLocationARB(p->program, "Texture_Reflection");
1088 p->loc_FogColor = qglGetUniformLocationARB(p->program, "FogColor");
1089 p->loc_LightPosition = qglGetUniformLocationARB(p->program, "LightPosition");
1090 p->loc_EyePosition = qglGetUniformLocationARB(p->program, "EyePosition");
1091 p->loc_LightColor = qglGetUniformLocationARB(p->program, "LightColor");
1092 p->loc_Color_Pants = qglGetUniformLocationARB(p->program, "Color_Pants");
1093 p->loc_Color_Shirt = qglGetUniformLocationARB(p->program, "Color_Shirt");
1094 p->loc_FogRangeRecip = qglGetUniformLocationARB(p->program, "FogRangeRecip");
1095 p->loc_FogStart = qglGetUniformLocationARB(p->program, "FogStart");
1096 p->loc_FogLength = qglGetUniformLocationARB(p->program, "FogLength");
1097 p->loc_AmbientScale = qglGetUniformLocationARB(p->program, "AmbientScale");
1098 p->loc_DiffuseScale = qglGetUniformLocationARB(p->program, "DiffuseScale");
1099 p->loc_SpecularPower = qglGetUniformLocationARB(p->program, "SpecularPower");
1100 p->loc_SpecularScale = qglGetUniformLocationARB(p->program, "SpecularScale");
1101 p->loc_GlowScale = qglGetUniformLocationARB(p->program, "GlowScale");
1102 p->loc_SceneBrightness = qglGetUniformLocationARB(p->program, "SceneBrightness");
1103 p->loc_OffsetMapping_Scale = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
1104 p->loc_AmbientColor = qglGetUniformLocationARB(p->program, "AmbientColor");
1105 p->loc_DiffuseColor = qglGetUniformLocationARB(p->program, "DiffuseColor");
1106 p->loc_SpecularColor = qglGetUniformLocationARB(p->program, "SpecularColor");
1107 p->loc_LightDir = qglGetUniformLocationARB(p->program, "LightDir");
1108 p->loc_ContrastBoostCoeff = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff");
1109 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
1110 p->loc_ScreenScaleRefractReflect = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
1111 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
1112 p->loc_RefractColor = qglGetUniformLocationARB(p->program, "RefractColor");
1113 p->loc_ReflectColor = qglGetUniformLocationARB(p->program, "ReflectColor");
1114 p->loc_ReflectFactor = qglGetUniformLocationARB(p->program, "ReflectFactor");
1115 p->loc_ReflectOffset = qglGetUniformLocationARB(p->program, "ReflectOffset");
1116 // initialize the samplers to refer to the texture units we use
1117 if (p->loc_Texture_Normal >= 0) qglUniform1iARB(p->loc_Texture_Normal, 0);
1118 if (p->loc_Texture_Color >= 0) qglUniform1iARB(p->loc_Texture_Color, 1);
1119 if (p->loc_Texture_Gloss >= 0) qglUniform1iARB(p->loc_Texture_Gloss, 2);
1120 if (p->loc_Texture_Cube >= 0) qglUniform1iARB(p->loc_Texture_Cube, 3);
1121 if (p->loc_Texture_FogMask >= 0) qglUniform1iARB(p->loc_Texture_FogMask, 4);
1122 if (p->loc_Texture_Pants >= 0) qglUniform1iARB(p->loc_Texture_Pants, 5);
1123 if (p->loc_Texture_Shirt >= 0) qglUniform1iARB(p->loc_Texture_Shirt, 6);
1124 if (p->loc_Texture_Lightmap >= 0) qglUniform1iARB(p->loc_Texture_Lightmap, 7);
1125 if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap, 8);
1126 if (p->loc_Texture_Glow >= 0) qglUniform1iARB(p->loc_Texture_Glow, 9);
1127 if (p->loc_Texture_Attenuation >= 0) qglUniform1iARB(p->loc_Texture_Attenuation, 10);
1128 if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction, 11);
1129 if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection, 12);
1131 qglUseProgramObjectARB(0);CHECKGLERROR
1132 if (developer.integer)
1133 Con_Printf("GLSL shader %s :%s compiled.\n", filename, permutationname);
1137 if (developer.integer)
1138 Con_Printf("GLSL shader %s :%s failed! source code line offset for above errors is %i.\n", permutationname, filename, -(vertstrings_count - 1));
1140 Con_Printf("GLSL shader %s :%s failed! some features may not work properly.\n", permutationname, filename);
1143 Mem_Free(shaderstring);
1146 void R_GLSL_Restart_f(void)
1149 for (i = 0;i < SHADERPERMUTATION_INDICES;i++)
1150 if (r_glsl_permutations[i].program)
1151 GL_Backend_FreeProgram(r_glsl_permutations[i].program);
1152 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1155 void R_GLSL_DumpShader_f(void)
1159 qfile_t *file = FS_Open("glsl/default.glsl", "w", false, false);
1162 Con_Printf("failed to write to glsl/default.glsl\n");
1166 FS_Print(file, "// The engine may define the following macros:\n");
1167 FS_Print(file, "// #define VERTEX_SHADER\n// #define GEOMETRY_SHADER\n// #define FRAGMENT_SHADER\n");
1168 for (i = 0;shadermodeinfo[i][0];i++)
1169 FS_Printf(file, "// %s", shadermodeinfo[i][0]);
1170 for (i = 0;shaderpermutationinfo[i][0];i++)
1171 FS_Printf(file, "// %s", shaderpermutationinfo[i][0]);
1172 FS_Print(file, "\n");
1173 FS_Print(file, builtinshaderstring);
1176 Con_Printf("glsl/default.glsl written\n");
1179 extern rtexture_t *r_shadow_attenuationgradienttexture;
1180 extern rtexture_t *r_shadow_attenuation2dtexture;
1181 extern rtexture_t *r_shadow_attenuation3dtexture;
1182 int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
1184 // select a permutation of the lighting shader appropriate to this
1185 // combination of texture, entity, light source, and fogging, only use the
1186 // minimum features necessary to avoid wasting rendering time in the
1187 // fragment shader on features that are not being used
1188 const char *shaderfilename = NULL;
1189 unsigned int permutation = 0;
1190 unsigned int shadertype = 0;
1191 shadermode_t mode = 0;
1192 r_glsl_permutation = NULL;
1193 shaderfilename = "glsl/default.glsl";
1194 shadertype = SHADERTYPE_USES_VERTEXSHADER | SHADERTYPE_USES_FRAGMENTSHADER;
1195 // TODO: implement geometry-shader based shadow volumes someday
1196 if (r_glsl_offsetmapping.integer)
1198 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1199 if (r_glsl_offsetmapping_reliefmapping.integer)
1200 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1202 if (rsurfacepass == RSURFPASS_BACKGROUND)
1204 // distorted background
1205 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
1206 mode = SHADERMODE_WATER;
1208 mode = SHADERMODE_REFRACTION;
1210 else if (rsurfacepass == RSURFPASS_RTLIGHT)
1213 mode = SHADERMODE_LIGHTSOURCE;
1214 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1215 permutation |= SHADERPERMUTATION_CUBEFILTER;
1216 if (diffusescale > 0)
1217 permutation |= SHADERPERMUTATION_DIFFUSE;
1218 if (specularscale > 0)
1219 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1220 if (r_refdef.fogenabled)
1221 permutation |= SHADERPERMUTATION_FOG;
1222 if (rsurface.texture->colormapping)
1223 permutation |= SHADERPERMUTATION_COLORMAPPING;
1224 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1225 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1226 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1227 permutation |= SHADERPERMUTATION_REFLECTION;
1229 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1231 // unshaded geometry (fullbright or ambient model lighting)
1232 mode = SHADERMODE_LIGHTMAP;
1233 if (rsurface.texture->currentskinframe->glow)
1234 permutation |= SHADERPERMUTATION_GLOW;
1235 if (r_refdef.fogenabled)
1236 permutation |= SHADERPERMUTATION_FOG;
1237 if (rsurface.texture->colormapping)
1238 permutation |= SHADERPERMUTATION_COLORMAPPING;
1239 if (r_glsl_offsetmapping.integer)
1241 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1242 if (r_glsl_offsetmapping_reliefmapping.integer)
1243 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1245 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1246 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1247 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1248 permutation |= SHADERPERMUTATION_REFLECTION;
1250 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
1252 // directional model lighting
1253 mode = SHADERMODE_LIGHTDIRECTION;
1254 if (rsurface.texture->currentskinframe->glow)
1255 permutation |= SHADERPERMUTATION_GLOW;
1256 permutation |= SHADERPERMUTATION_DIFFUSE;
1257 if (specularscale > 0)
1258 permutation |= SHADERPERMUTATION_SPECULAR;
1259 if (r_refdef.fogenabled)
1260 permutation |= SHADERPERMUTATION_FOG;
1261 if (rsurface.texture->colormapping)
1262 permutation |= SHADERPERMUTATION_COLORMAPPING;
1263 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1264 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1265 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1266 permutation |= SHADERPERMUTATION_REFLECTION;
1268 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
1270 // ambient model lighting
1271 mode = SHADERMODE_LIGHTDIRECTION;
1272 if (rsurface.texture->currentskinframe->glow)
1273 permutation |= SHADERPERMUTATION_GLOW;
1274 if (r_refdef.fogenabled)
1275 permutation |= SHADERPERMUTATION_FOG;
1276 if (rsurface.texture->colormapping)
1277 permutation |= SHADERPERMUTATION_COLORMAPPING;
1278 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1279 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1280 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1281 permutation |= SHADERPERMUTATION_REFLECTION;
1286 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
1288 // deluxemapping (light direction texture)
1289 if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
1290 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
1292 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1293 if (specularscale > 0)
1294 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1296 else if (r_glsl_deluxemapping.integer >= 2)
1298 // fake deluxemapping (uniform light direction in tangentspace)
1299 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1300 if (specularscale > 0)
1301 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1305 // ordinary lightmapping
1306 mode = SHADERMODE_LIGHTMAP;
1308 if (rsurface.texture->currentskinframe->glow)
1309 permutation |= SHADERPERMUTATION_GLOW;
1310 if (r_refdef.fogenabled)
1311 permutation |= SHADERPERMUTATION_FOG;
1312 if (rsurface.texture->colormapping)
1313 permutation |= SHADERPERMUTATION_COLORMAPPING;
1314 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1315 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1316 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1317 permutation |= SHADERPERMUTATION_REFLECTION;
1319 permutation |= mode * SHADERPERMUTATION_MODEBASE;
1320 if (!r_glsl_permutations[permutation].program)
1322 if (!r_glsl_permutations[permutation].compiled)
1323 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1324 if (!r_glsl_permutations[permutation].program)
1326 // remove features until we find a valid permutation
1328 for (i = (SHADERPERMUTATION_MODEBASE >> 1);;i>>=1)
1332 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");
1333 Cvar_SetValueQuick(&r_glsl, 0);
1334 return 0; // no bit left to clear
1336 // reduce i more quickly whenever it would not remove any bits
1337 if (!(permutation & i))
1340 if (!r_glsl_permutations[permutation].compiled)
1341 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1342 if (r_glsl_permutations[permutation].program)
1347 r_glsl_permutation = r_glsl_permutations + permutation;
1349 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
1350 if (mode == SHADERMODE_LIGHTSOURCE)
1352 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
1353 if (permutation & SHADERPERMUTATION_DIFFUSE)
1355 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
1356 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, ambientscale);
1357 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, diffusescale);
1358 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, specularscale);
1362 // ambient only is simpler
1363 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0] * ambientscale, lightcolorbase[1] * ambientscale, lightcolorbase[2] * ambientscale);
1364 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, 1);
1365 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, 0);
1366 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, 0);
1369 else if (mode == SHADERMODE_LIGHTDIRECTION)
1371 if (r_glsl_permutation->loc_AmbientColor >= 0)
1372 qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale, rsurface.modellight_ambient[1] * ambientscale, rsurface.modellight_ambient[2] * ambientscale);
1373 if (r_glsl_permutation->loc_DiffuseColor >= 0)
1374 qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface.modellight_diffuse[0] * diffusescale, rsurface.modellight_diffuse[1] * diffusescale, rsurface.modellight_diffuse[2] * diffusescale);
1375 if (r_glsl_permutation->loc_SpecularColor >= 0)
1376 qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale, rsurface.modellight_diffuse[1] * specularscale, rsurface.modellight_diffuse[2] * specularscale);
1377 if (r_glsl_permutation->loc_LightDir >= 0)
1378 qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
1382 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_ambient.value * 2.0f / 128.0f);
1383 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
1384 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
1386 if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
1387 if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
1389 // The formula used is actually:
1390 // color.rgb *= SceneBrightness;
1391 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
1392 // I simplify that to
1393 // color.rgb *= [[SceneBrightness * ContrastBoost]];
1394 // color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1;
1396 // color.rgb = [[SceneBrightness * ContrastBoost]] * color.rgb / ([[(ContrastBoost - 1) * SceneBrightness]] * color.rgb + 1);
1397 // and do [[calculations]] here in the engine
1398 qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale);
1399 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value);
1402 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
1403 if (r_glsl_permutation->loc_FogColor >= 0)
1405 // additive passes are only darkened by fog, not tinted
1406 if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
1407 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
1409 qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
1411 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
1412 if (r_glsl_permutation->loc_Color_Pants >= 0)
1414 if (rsurface.texture->currentskinframe->pants)
1415 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
1417 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
1419 if (r_glsl_permutation->loc_Color_Shirt >= 0)
1421 if (rsurface.texture->currentskinframe->shirt)
1422 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
1424 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
1426 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
1427 if (r_glsl_permutation->loc_FogStart >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogStart, r_refdef.fog_start);
1428 if (r_glsl_permutation->loc_FogLength >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogLength, r_refdef.fog_end - r_refdef.fog_start);
1429 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
1430 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
1431 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);
1432 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]);
1433 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]);
1434 if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
1435 if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
1436 if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
1437 if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
1442 #define SKINFRAME_HASH 1024
1446 int loadsequence; // incremented each level change
1447 memexpandablearray_t array;
1448 skinframe_t *hash[SKINFRAME_HASH];
1452 void R_SkinFrame_PrepareForPurge(void)
1454 r_skinframe.loadsequence++;
1455 // wrap it without hitting zero
1456 if (r_skinframe.loadsequence >= 200)
1457 r_skinframe.loadsequence = 1;
1460 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
1464 // mark the skinframe as used for the purging code
1465 skinframe->loadsequence = r_skinframe.loadsequence;
1468 void R_SkinFrame_Purge(void)
1472 for (i = 0;i < SKINFRAME_HASH;i++)
1474 for (s = r_skinframe.hash[i];s;s = s->next)
1476 if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
1478 if (s->merged == s->base)
1480 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
1481 R_PurgeTexture(s->stain );s->stain = NULL;
1482 R_PurgeTexture(s->merged);s->merged = NULL;
1483 R_PurgeTexture(s->base );s->base = NULL;
1484 R_PurgeTexture(s->pants );s->pants = NULL;
1485 R_PurgeTexture(s->shirt );s->shirt = NULL;
1486 R_PurgeTexture(s->nmap );s->nmap = NULL;
1487 R_PurgeTexture(s->gloss );s->gloss = NULL;
1488 R_PurgeTexture(s->glow );s->glow = NULL;
1489 R_PurgeTexture(s->fog );s->fog = NULL;
1490 s->loadsequence = 0;
1496 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
1498 char basename[MAX_QPATH];
1500 Image_StripImageExtension(name, basename, sizeof(basename));
1502 if( last == NULL ) {
1504 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1505 item = r_skinframe.hash[hashindex];
1510 // linearly search through the hash bucket
1511 for( ; item ; item = item->next ) {
1512 if( !strcmp( item->basename, basename ) ) {
1519 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
1523 char basename[MAX_QPATH];
1525 Image_StripImageExtension(name, basename, sizeof(basename));
1527 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1528 for (item = r_skinframe.hash[hashindex];item;item = item->next)
1529 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
1533 rtexture_t *dyntexture;
1534 // check whether its a dynamic texture
1535 dyntexture = CL_GetDynTexture( basename );
1536 if (!add && !dyntexture)
1538 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
1539 memset(item, 0, sizeof(*item));
1540 strlcpy(item->basename, basename, sizeof(item->basename));
1541 item->base = dyntexture; // either NULL or dyntexture handle
1542 item->textureflags = textureflags;
1543 item->comparewidth = comparewidth;
1544 item->compareheight = compareheight;
1545 item->comparecrc = comparecrc;
1546 item->next = r_skinframe.hash[hashindex];
1547 r_skinframe.hash[hashindex] = item;
1549 else if( item->base == NULL )
1551 rtexture_t *dyntexture;
1552 // check whether its a dynamic texture
1553 // 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]
1554 dyntexture = CL_GetDynTexture( basename );
1555 item->base = dyntexture; // either NULL or dyntexture handle
1558 R_SkinFrame_MarkUsed(item);
1562 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
1564 // FIXME: it should be possible to disable loading various layers using
1565 // cvars, to prevent wasted loading time and memory usage if the user does
1567 qboolean loadnormalmap = true;
1568 qboolean loadgloss = true;
1569 qboolean loadpantsandshirt = true;
1570 qboolean loadglow = true;
1572 unsigned char *pixels;
1573 unsigned char *bumppixels;
1574 unsigned char *basepixels = NULL;
1575 int basepixels_width;
1576 int basepixels_height;
1577 skinframe_t *skinframe;
1579 if (cls.state == ca_dedicated)
1582 // return an existing skinframe if already loaded
1583 // if loading of the first image fails, don't make a new skinframe as it
1584 // would cause all future lookups of this to be missing
1585 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
1586 if (skinframe && skinframe->base)
1589 basepixels = loadimagepixelsbgra(name, complain, true);
1590 if (basepixels == NULL)
1593 // we've got some pixels to store, so really allocate this new texture now
1595 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
1596 skinframe->stain = NULL;
1597 skinframe->merged = NULL;
1598 skinframe->base = r_texture_notexture;
1599 skinframe->pants = NULL;
1600 skinframe->shirt = NULL;
1601 skinframe->nmap = r_texture_blanknormalmap;
1602 skinframe->gloss = NULL;
1603 skinframe->glow = NULL;
1604 skinframe->fog = NULL;
1606 basepixels_width = image_width;
1607 basepixels_height = image_height;
1608 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);
1610 if (textureflags & TEXF_ALPHA)
1612 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
1613 if (basepixels[j] < 255)
1615 if (j < basepixels_width * basepixels_height * 4)
1617 // has transparent pixels
1618 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1619 for (j = 0;j < image_width * image_height * 4;j += 4)
1624 pixels[j+3] = basepixels[j+3];
1626 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);
1631 // _norm is the name used by tenebrae and has been adopted as standard
1634 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL)
1636 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);
1640 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL)
1642 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1643 Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
1644 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);
1646 Mem_Free(bumppixels);
1648 else if (r_shadow_bumpscale_basetexture.value > 0)
1650 pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
1651 Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
1652 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);
1656 // _luma is supported for tenebrae compatibility
1657 // (I think it's a very stupid name, but oh well)
1658 // _glow is the preferred name
1659 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;}
1660 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;}
1661 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;}
1662 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;}
1665 Mem_Free(basepixels);
1670 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)
1675 for (i = 0;i < width*height;i++)
1676 if (((unsigned char *)&palette[in[i]])[3] > 0)
1678 if (i == width*height)
1681 return R_LoadTexture2D (r_main_texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
1684 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
1685 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
1688 unsigned char *temp1, *temp2;
1689 skinframe_t *skinframe;
1691 if (cls.state == ca_dedicated)
1694 // if already loaded just return it, otherwise make a new skinframe
1695 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
1696 if (skinframe && skinframe->base)
1699 skinframe->stain = NULL;
1700 skinframe->merged = NULL;
1701 skinframe->base = r_texture_notexture;
1702 skinframe->pants = NULL;
1703 skinframe->shirt = NULL;
1704 skinframe->nmap = r_texture_blanknormalmap;
1705 skinframe->gloss = NULL;
1706 skinframe->glow = NULL;
1707 skinframe->fog = NULL;
1709 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1713 if (r_shadow_bumpscale_basetexture.value > 0)
1715 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1716 temp2 = temp1 + width * height * 4;
1717 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1718 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1721 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1722 if (textureflags & TEXF_ALPHA)
1724 for (i = 3;i < width * height * 4;i += 4)
1725 if (skindata[i] < 255)
1727 if (i < width * height * 4)
1729 unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
1730 memcpy(fogpixels, skindata, width * height * 4);
1731 for (i = 0;i < width * height * 4;i += 4)
1732 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
1733 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1734 Mem_Free(fogpixels);
1741 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
1744 unsigned char *temp1, *temp2;
1745 skinframe_t *skinframe;
1747 if (cls.state == ca_dedicated)
1750 // if already loaded just return it, otherwise make a new skinframe
1751 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
1752 if (skinframe && skinframe->base)
1755 skinframe->stain = NULL;
1756 skinframe->merged = NULL;
1757 skinframe->base = r_texture_notexture;
1758 skinframe->pants = NULL;
1759 skinframe->shirt = NULL;
1760 skinframe->nmap = r_texture_blanknormalmap;
1761 skinframe->gloss = NULL;
1762 skinframe->glow = NULL;
1763 skinframe->fog = NULL;
1765 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1769 if (r_shadow_bumpscale_basetexture.value > 0)
1771 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1772 temp2 = temp1 + width * height * 4;
1773 // use either a custom palette or the quake palette
1774 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
1775 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1776 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1779 // use either a custom palette, or the quake palette
1780 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
1781 if (loadglowtexture)
1782 skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_bgra_onlyfullbrights, skinframe->textureflags, false); // glow
1783 if (loadpantsandshirt)
1785 skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_bgra_pantsaswhite, skinframe->textureflags, false); // pants
1786 skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_bgra_shirtaswhite, skinframe->textureflags, false); // shirt
1788 if (skinframe->pants || skinframe->shirt)
1789 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
1790 if (textureflags & TEXF_ALPHA)
1792 for (i = 0;i < width * height;i++)
1793 if (((unsigned char *)palette_bgra_alpha)[skindata[i]*4+3] < 255)
1795 if (i < width * height)
1796 skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), palette_bgra_alpha, skinframe->textureflags, true); // fog mask
1802 skinframe_t *R_SkinFrame_LoadMissing(void)
1804 skinframe_t *skinframe;
1806 if (cls.state == ca_dedicated)
1809 skinframe = R_SkinFrame_Find("missing", TEXF_PRECACHE, 0, 0, 0, true);
1810 skinframe->stain = NULL;
1811 skinframe->merged = NULL;
1812 skinframe->base = r_texture_notexture;
1813 skinframe->pants = NULL;
1814 skinframe->shirt = NULL;
1815 skinframe->nmap = r_texture_blanknormalmap;
1816 skinframe->gloss = NULL;
1817 skinframe->glow = NULL;
1818 skinframe->fog = NULL;
1823 void gl_main_start(void)
1828 r = -16.0 / (1.0 * FOGMASKTABLEWIDTH * FOGMASKTABLEWIDTH);
1829 for (x = 0;x < FOGMASKTABLEWIDTH;x++)
1831 alpha = exp(r * ((double)x*(double)x));
1832 if (x == FOGMASKTABLEWIDTH - 1)
1834 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
1837 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1838 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1840 // set up r_skinframe loading system for textures
1841 memset(&r_skinframe, 0, sizeof(r_skinframe));
1842 r_skinframe.loadsequence = 1;
1843 Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
1845 r_main_texturepool = R_AllocTexturePool();
1846 R_BuildBlankTextures();
1848 if (gl_texturecubemap)
1851 R_BuildNormalizationCube();
1853 R_BuildFogTexture();
1854 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1855 memset(&r_waterstate, 0, sizeof(r_waterstate));
1856 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1857 memset(&r_svbsp, 0, sizeof (r_svbsp));
1860 void gl_main_shutdown(void)
1862 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1863 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1865 // clear out the r_skinframe state
1866 Mem_ExpandableArray_FreeArray(&r_skinframe.array);
1867 memset(&r_skinframe, 0, sizeof(r_skinframe));
1870 Mem_Free(r_svbsp.nodes);
1871 memset(&r_svbsp, 0, sizeof (r_svbsp));
1872 R_FreeTexturePool(&r_main_texturepool);
1873 r_texture_blanknormalmap = NULL;
1874 r_texture_white = NULL;
1875 r_texture_grey128 = NULL;
1876 r_texture_black = NULL;
1877 r_texture_whitecube = NULL;
1878 r_texture_normalizationcube = NULL;
1879 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1880 memset(&r_waterstate, 0, sizeof(r_waterstate));
1884 extern void CL_ParseEntityLump(char *entitystring);
1885 void gl_main_newmap(void)
1887 // FIXME: move this code to client
1889 char *entities, entname[MAX_QPATH];
1892 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
1893 l = (int)strlen(entname) - 4;
1894 if (l >= 0 && !strcmp(entname + l, ".bsp"))
1896 memcpy(entname + l, ".ent", 5);
1897 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
1899 CL_ParseEntityLump(entities);
1904 if (cl.worldmodel->brush.entities)
1905 CL_ParseEntityLump(cl.worldmodel->brush.entities);
1909 void GL_Main_Init(void)
1911 r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
1913 Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
1914 Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
1915 // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
1916 if (gamemode == GAME_NEHAHRA)
1918 Cvar_RegisterVariable (&gl_fogenable);
1919 Cvar_RegisterVariable (&gl_fogdensity);
1920 Cvar_RegisterVariable (&gl_fogred);
1921 Cvar_RegisterVariable (&gl_foggreen);
1922 Cvar_RegisterVariable (&gl_fogblue);
1923 Cvar_RegisterVariable (&gl_fogstart);
1924 Cvar_RegisterVariable (&gl_fogend);
1926 Cvar_RegisterVariable(&r_depthfirst);
1927 Cvar_RegisterVariable(&r_nearclip);
1928 Cvar_RegisterVariable(&r_showbboxes);
1929 Cvar_RegisterVariable(&r_showsurfaces);
1930 Cvar_RegisterVariable(&r_showtris);
1931 Cvar_RegisterVariable(&r_shownormals);
1932 Cvar_RegisterVariable(&r_showlighting);
1933 Cvar_RegisterVariable(&r_showshadowvolumes);
1934 Cvar_RegisterVariable(&r_showcollisionbrushes);
1935 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
1936 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
1937 Cvar_RegisterVariable(&r_showdisabledepthtest);
1938 Cvar_RegisterVariable(&r_drawportals);
1939 Cvar_RegisterVariable(&r_drawentities);
1940 Cvar_RegisterVariable(&r_cullentities_trace);
1941 Cvar_RegisterVariable(&r_cullentities_trace_samples);
1942 Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
1943 Cvar_RegisterVariable(&r_cullentities_trace_delay);
1944 Cvar_RegisterVariable(&r_drawviewmodel);
1945 Cvar_RegisterVariable(&r_speeds);
1946 Cvar_RegisterVariable(&r_fullbrights);
1947 Cvar_RegisterVariable(&r_wateralpha);
1948 Cvar_RegisterVariable(&r_dynamic);
1949 Cvar_RegisterVariable(&r_fullbright);
1950 Cvar_RegisterVariable(&r_shadows);
1951 Cvar_RegisterVariable(&r_shadows_throwdistance);
1952 Cvar_RegisterVariable(&r_q1bsp_skymasking);
1953 Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
1954 Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
1955 Cvar_RegisterVariable(&r_textureunits);
1956 Cvar_RegisterVariable(&r_glsl);
1957 Cvar_RegisterVariable(&r_glsl_offsetmapping);
1958 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
1959 Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
1960 Cvar_RegisterVariable(&r_glsl_deluxemapping);
1961 Cvar_RegisterVariable(&r_water);
1962 Cvar_RegisterVariable(&r_water_resolutionmultiplier);
1963 Cvar_RegisterVariable(&r_water_clippingplanebias);
1964 Cvar_RegisterVariable(&r_water_refractdistort);
1965 Cvar_RegisterVariable(&r_water_reflectdistort);
1966 Cvar_RegisterVariable(&r_lerpsprites);
1967 Cvar_RegisterVariable(&r_lerpmodels);
1968 Cvar_RegisterVariable(&r_lerplightstyles);
1969 Cvar_RegisterVariable(&r_waterscroll);
1970 Cvar_RegisterVariable(&r_bloom);
1971 Cvar_RegisterVariable(&r_bloom_colorscale);
1972 Cvar_RegisterVariable(&r_bloom_brighten);
1973 Cvar_RegisterVariable(&r_bloom_blur);
1974 Cvar_RegisterVariable(&r_bloom_resolution);
1975 Cvar_RegisterVariable(&r_bloom_colorexponent);
1976 Cvar_RegisterVariable(&r_bloom_colorsubtract);
1977 Cvar_RegisterVariable(&r_hdr);
1978 Cvar_RegisterVariable(&r_hdr_scenebrightness);
1979 Cvar_RegisterVariable(&r_glsl_contrastboost);
1980 Cvar_RegisterVariable(&r_hdr_glowintensity);
1981 Cvar_RegisterVariable(&r_hdr_range);
1982 Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
1983 Cvar_RegisterVariable(&developer_texturelogging);
1984 Cvar_RegisterVariable(&gl_lightmaps);
1985 Cvar_RegisterVariable(&r_test);
1986 Cvar_RegisterVariable(&r_batchmode);
1987 if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
1988 Cvar_SetValue("r_fullbrights", 0);
1989 R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
1991 Cvar_RegisterVariable(&r_track_sprites);
1992 Cvar_RegisterVariable(&r_track_sprites_flags);
1993 Cvar_RegisterVariable(&r_track_sprites_scalew);
1994 Cvar_RegisterVariable(&r_track_sprites_scaleh);
1997 extern void R_Textures_Init(void);
1998 extern void GL_Draw_Init(void);
1999 extern void GL_Main_Init(void);
2000 extern void R_Shadow_Init(void);
2001 extern void R_Sky_Init(void);
2002 extern void GL_Surf_Init(void);
2003 extern void R_Particles_Init(void);
2004 extern void R_Explosion_Init(void);
2005 extern void gl_backend_init(void);
2006 extern void Sbar_Init(void);
2007 extern void R_LightningBeams_Init(void);
2008 extern void Mod_RenderInit(void);
2010 void Render_Init(void)
2022 R_LightningBeams_Init();
2031 extern char *ENGINE_EXTENSIONS;
2034 VID_CheckExtensions();
2036 // LordHavoc: report supported extensions
2037 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2039 // clear to black (loading plaque will be seen over this)
2041 qglClearColor(0,0,0,1);CHECKGLERROR
2042 qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
2045 int R_CullBox(const vec3_t mins, const vec3_t maxs)
2049 for (i = 0;i < r_view.numfrustumplanes;i++)
2051 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
2054 p = r_view.frustum + i;
2059 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2063 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2067 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2071 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2075 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2079 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2083 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2087 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2095 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
2099 for (i = 0;i < numplanes;i++)
2106 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2110 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2114 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2118 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2122 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2126 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2130 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2134 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2142 //==================================================================================
2144 static void R_UpdateEntityLighting(entity_render_t *ent)
2146 vec3_t tempdiffusenormal;
2148 // fetch the lighting from the worldmodel data
2149 VectorSet(ent->modellight_ambient, r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f));
2150 VectorClear(ent->modellight_diffuse);
2151 VectorClear(tempdiffusenormal);
2152 if ((ent->flags & RENDER_LIGHT) && r_refdef.worldmodel && r_refdef.worldmodel->brush.LightPoint)
2155 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
2156 r_refdef.worldmodel->brush.LightPoint(r_refdef.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
2159 VectorSet(ent->modellight_ambient, 1, 1, 1);
2161 // move the light direction into modelspace coordinates for lighting code
2162 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
2163 if(VectorLength2(ent->modellight_lightdir) > 0)
2165 VectorNormalize(ent->modellight_lightdir);
2169 VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
2172 // scale ambient and directional light contributions according to rendering variables
2173 ent->modellight_ambient[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
2174 ent->modellight_ambient[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
2175 ent->modellight_ambient[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
2176 ent->modellight_diffuse[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
2177 ent->modellight_diffuse[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
2178 ent->modellight_diffuse[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
2181 static void R_View_UpdateEntityVisible (void)
2184 entity_render_t *ent;
2186 if (!r_drawentities.integer)
2189 renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
2190 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
2192 // worldmodel can check visibility
2193 for (i = 0;i < r_refdef.numentities;i++)
2195 ent = r_refdef.entities[i];
2196 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));
2199 if(r_cullentities_trace.integer)
2201 for (i = 0;i < r_refdef.numentities;i++)
2203 ent = r_refdef.entities[i];
2204 if(r_viewcache.entityvisible[i] && !(ent->effects & EF_NODEPTHTEST) && !(ent->flags & RENDER_VIEWMODEL) && !(ent->model && (ent->model->name[0] == '*')))
2206 if(Mod_CanSeeBox_Trace(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.worldmodel, r_view.origin, ent->mins, ent->maxs))
2207 ent->last_trace_visibility = realtime;
2208 if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
2209 r_viewcache.entityvisible[i] = 0;
2216 // no worldmodel or it can't check visibility
2217 for (i = 0;i < r_refdef.numentities;i++)
2219 ent = r_refdef.entities[i];
2220 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));
2224 // update entity lighting (even on hidden entities for r_shadows)
2225 for (i = 0;i < r_refdef.numentities;i++)
2226 R_UpdateEntityLighting(r_refdef.entities[i]);
2229 // only used if skyrendermasked, and normally returns false
2230 int R_DrawBrushModelsSky (void)
2233 entity_render_t *ent;
2235 if (!r_drawentities.integer)
2239 for (i = 0;i < r_refdef.numentities;i++)
2241 if (!r_viewcache.entityvisible[i])
2243 ent = r_refdef.entities[i];
2244 if (!ent->model || !ent->model->DrawSky)
2246 ent->model->DrawSky(ent);
2252 static void R_DrawNoModel(entity_render_t *ent);
2253 static void R_DrawModels(void)
2256 entity_render_t *ent;
2258 if (!r_drawentities.integer)
2261 for (i = 0;i < r_refdef.numentities;i++)
2263 if (!r_viewcache.entityvisible[i])
2265 ent = r_refdef.entities[i];
2266 r_refdef.stats.entities++;
2267 if (ent->model && ent->model->Draw != NULL)
2268 ent->model->Draw(ent);
2274 static void R_DrawModelsDepth(void)
2277 entity_render_t *ent;
2279 if (!r_drawentities.integer)
2282 for (i = 0;i < r_refdef.numentities;i++)
2284 if (!r_viewcache.entityvisible[i])
2286 ent = r_refdef.entities[i];
2287 if (ent->model && ent->model->DrawDepth != NULL)
2288 ent->model->DrawDepth(ent);
2292 static void R_DrawModelsDebug(void)
2295 entity_render_t *ent;
2297 if (!r_drawentities.integer)
2300 for (i = 0;i < r_refdef.numentities;i++)
2302 if (!r_viewcache.entityvisible[i])
2304 ent = r_refdef.entities[i];
2305 if (ent->model && ent->model->DrawDebug != NULL)
2306 ent->model->DrawDebug(ent);
2310 static void R_DrawModelsAddWaterPlanes(void)
2313 entity_render_t *ent;
2315 if (!r_drawentities.integer)
2318 for (i = 0;i < r_refdef.numentities;i++)
2320 if (!r_viewcache.entityvisible[i])
2322 ent = r_refdef.entities[i];
2323 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
2324 ent->model->DrawAddWaterPlanes(ent);
2328 static void R_View_SetFrustum(void)
2331 double slopex, slopey;
2333 // break apart the view matrix into vectors for various purposes
2334 Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
2335 VectorNegate(r_view.left, r_view.right);
2338 r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
2339 r_view.frustum[0].normal[1] = 0 - 0;
2340 r_view.frustum[0].normal[2] = -1 - 0;
2341 r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
2342 r_view.frustum[1].normal[1] = 0 + 0;
2343 r_view.frustum[1].normal[2] = -1 + 0;
2344 r_view.frustum[2].normal[0] = 0 - 0;
2345 r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
2346 r_view.frustum[2].normal[2] = -1 - 0;
2347 r_view.frustum[3].normal[0] = 0 + 0;
2348 r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
2349 r_view.frustum[3].normal[2] = -1 + 0;
2353 zNear = r_refdef.nearclip;
2354 nudge = 1.0 - 1.0 / (1<<23);
2355 r_view.frustum[4].normal[0] = 0 - 0;
2356 r_view.frustum[4].normal[1] = 0 - 0;
2357 r_view.frustum[4].normal[2] = -1 - -nudge;
2358 r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
2359 r_view.frustum[5].normal[0] = 0 + 0;
2360 r_view.frustum[5].normal[1] = 0 + 0;
2361 r_view.frustum[5].normal[2] = -1 + -nudge;
2362 r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
2368 r_view.frustum[0].normal[0] = m[3] - m[0];
2369 r_view.frustum[0].normal[1] = m[7] - m[4];
2370 r_view.frustum[0].normal[2] = m[11] - m[8];
2371 r_view.frustum[0].dist = m[15] - m[12];
2373 r_view.frustum[1].normal[0] = m[3] + m[0];
2374 r_view.frustum[1].normal[1] = m[7] + m[4];
2375 r_view.frustum[1].normal[2] = m[11] + m[8];
2376 r_view.frustum[1].dist = m[15] + m[12];
2378 r_view.frustum[2].normal[0] = m[3] - m[1];
2379 r_view.frustum[2].normal[1] = m[7] - m[5];
2380 r_view.frustum[2].normal[2] = m[11] - m[9];
2381 r_view.frustum[2].dist = m[15] - m[13];
2383 r_view.frustum[3].normal[0] = m[3] + m[1];
2384 r_view.frustum[3].normal[1] = m[7] + m[5];
2385 r_view.frustum[3].normal[2] = m[11] + m[9];
2386 r_view.frustum[3].dist = m[15] + m[13];
2388 r_view.frustum[4].normal[0] = m[3] - m[2];
2389 r_view.frustum[4].normal[1] = m[7] - m[6];
2390 r_view.frustum[4].normal[2] = m[11] - m[10];
2391 r_view.frustum[4].dist = m[15] - m[14];
2393 r_view.frustum[5].normal[0] = m[3] + m[2];
2394 r_view.frustum[5].normal[1] = m[7] + m[6];
2395 r_view.frustum[5].normal[2] = m[11] + m[10];
2396 r_view.frustum[5].dist = m[15] + m[14];
2399 if (r_view.useperspective)
2401 slopex = 1.0 / r_view.frustum_x;
2402 slopey = 1.0 / r_view.frustum_y;
2403 VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
2404 VectorMA(r_view.forward, slopex, r_view.left, r_view.frustum[1].normal);
2405 VectorMA(r_view.forward, -slopey, r_view.up , r_view.frustum[2].normal);
2406 VectorMA(r_view.forward, slopey, r_view.up , r_view.frustum[3].normal);
2407 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2409 // Leaving those out was a mistake, those were in the old code, and they
2410 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
2411 // I couldn't reproduce it after adding those normalizations. --blub
2412 VectorNormalize(r_view.frustum[0].normal);
2413 VectorNormalize(r_view.frustum[1].normal);
2414 VectorNormalize(r_view.frustum[2].normal);
2415 VectorNormalize(r_view.frustum[3].normal);
2417 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
2418 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
2419 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
2420 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[2]);
2421 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[3]);
2423 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
2424 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
2425 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
2426 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
2427 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2431 VectorScale(r_view.left, -r_view.ortho_x, r_view.frustum[0].normal);
2432 VectorScale(r_view.left, r_view.ortho_x, r_view.frustum[1].normal);
2433 VectorScale(r_view.up, -r_view.ortho_y, r_view.frustum[2].normal);
2434 VectorScale(r_view.up, r_view.ortho_y, r_view.frustum[3].normal);
2435 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2436 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal) + r_view.ortho_x;
2437 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal) + r_view.ortho_x;
2438 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal) + r_view.ortho_y;
2439 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal) + r_view.ortho_y;
2440 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2442 r_view.numfrustumplanes = 5;
2444 if (r_view.useclipplane)
2446 r_view.numfrustumplanes = 6;
2447 r_view.frustum[5] = r_view.clipplane;
2450 for (i = 0;i < r_view.numfrustumplanes;i++)
2451 PlaneClassify(r_view.frustum + i);
2453 // LordHavoc: note to all quake engine coders, Quake had a special case
2454 // for 90 degrees which assumed a square view (wrong), so I removed it,
2455 // Quake2 has it disabled as well.
2457 // rotate R_VIEWFORWARD right by FOV_X/2 degrees
2458 //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
2459 //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
2460 //PlaneClassify(&frustum[0]);
2462 // rotate R_VIEWFORWARD left by FOV_X/2 degrees
2463 //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
2464 //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
2465 //PlaneClassify(&frustum[1]);
2467 // rotate R_VIEWFORWARD up by FOV_X/2 degrees
2468 //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
2469 //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
2470 //PlaneClassify(&frustum[2]);
2472 // rotate R_VIEWFORWARD down by FOV_X/2 degrees
2473 //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
2474 //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
2475 //PlaneClassify(&frustum[3]);
2478 //VectorCopy(r_view.forward, r_view.frustum[4].normal);
2479 //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
2480 //PlaneClassify(&frustum[4]);
2483 void R_View_Update(void)
2485 R_View_SetFrustum();
2486 R_View_WorldVisibility(r_view.useclipplane);
2487 R_View_UpdateEntityVisible();
2490 void R_SetupView(void)
2492 if (!r_view.useperspective)
2493 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);
2494 else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
2495 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
2497 GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
2499 GL_SetupView_Orientation_FromEntity(&r_view.matrix);
2501 if (r_view.useclipplane)
2503 // LordHavoc: couldn't figure out how to make this approach the
2504 vec_t dist = r_view.clipplane.dist - r_water_clippingplanebias.value;
2505 vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
2506 if (viewdist < r_view.clipplane.dist + r_water_clippingplanebias.value)
2507 dist = r_view.clipplane.dist;
2508 GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
2512 void R_ResetViewRendering2D(void)
2514 if (gl_support_fragment_shader)
2516 qglUseProgramObjectARB(0);CHECKGLERROR
2521 // GL is weird because it's bottom to top, r_view.y is top to bottom
2522 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2523 GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
2524 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2525 GL_Color(1, 1, 1, 1);
2526 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2527 GL_BlendFunc(GL_ONE, GL_ZERO);
2528 GL_AlphaTest(false);
2529 GL_ScissorTest(false);
2530 GL_DepthMask(false);
2531 GL_DepthRange(0, 1);
2532 GL_DepthTest(false);
2533 R_Mesh_Matrix(&identitymatrix);
2534 R_Mesh_ResetTextureState();
2535 GL_PolygonOffset(0, 0);
2536 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2537 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2538 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2539 qglStencilMask(~0);CHECKGLERROR
2540 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2541 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2542 GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
2545 void R_ResetViewRendering3D(void)
2547 if (gl_support_fragment_shader)
2549 qglUseProgramObjectARB(0);CHECKGLERROR
2554 // GL is weird because it's bottom to top, r_view.y is top to bottom
2555 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2557 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2558 GL_Color(1, 1, 1, 1);
2559 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2560 GL_BlendFunc(GL_ONE, GL_ZERO);
2561 GL_AlphaTest(false);
2562 GL_ScissorTest(true);
2564 GL_DepthRange(0, 1);
2566 R_Mesh_Matrix(&identitymatrix);
2567 R_Mesh_ResetTextureState();
2568 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
2569 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2570 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2571 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2572 qglStencilMask(~0);CHECKGLERROR
2573 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2574 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2575 GL_CullFace(r_view.cullface_back);
2579 R_Bloom_SetupShader(
2581 "// written by Forest 'LordHavoc' Hale\n"
2583 "// common definitions between vertex shader and fragment shader:\n"
2585 "#ifdef __GLSL_CG_DATA_TYPES\n"
2586 "#define myhalf half\n"
2587 "#define myhvec2 hvec2\n"
2588 "#define myhvec3 hvec3\n"
2589 "#define myhvec4 hvec4\n"
2591 "#define myhalf float\n"
2592 "#define myhvec2 vec2\n"
2593 "#define myhvec3 vec3\n"
2594 "#define myhvec4 vec4\n"
2597 "varying vec2 ScreenTexCoord;\n"
2598 "varying vec2 BloomTexCoord;\n"
2603 "// vertex shader specific:\n"
2604 "#ifdef VERTEX_SHADER\n"
2608 " ScreenTexCoord = vec2(gl_MultiTexCoord0);\n"
2609 " BloomTexCoord = vec2(gl_MultiTexCoord1);\n"
2610 " // transform vertex to camera space, using ftransform to match non-VS\n"
2612 " gl_Position = ftransform();\n"
2615 "#endif // VERTEX_SHADER\n"
2620 "// fragment shader specific:\n"
2621 "#ifdef FRAGMENT_SHADER\n"
2626 " myhvec3 color = myhvec3(texture2D(Texture_Screen, ScreenTexCoord));\n"
2627 " for (x = -BLUR_X;x <= BLUR_X;x++)
2628 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2629 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2630 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2631 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2633 " gl_FragColor = vec4(color);\n"
2636 "#endif // FRAGMENT_SHADER\n"
2639 void R_RenderScene(qboolean addwaterplanes);
2641 static void R_Water_StartFrame(void)
2644 int waterwidth, waterheight, texturewidth, textureheight;
2645 r_waterstate_waterplane_t *p;
2647 // set waterwidth and waterheight to the water resolution that will be
2648 // used (often less than the screen resolution for faster rendering)
2649 waterwidth = (int)bound(1, r_view.width * r_water_resolutionmultiplier.value, r_view.width);
2650 waterheight = (int)bound(1, r_view.height * r_water_resolutionmultiplier.value, r_view.height);
2652 // calculate desired texture sizes
2653 // can't use water if the card does not support the texture size
2654 if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
2655 texturewidth = textureheight = waterwidth = waterheight = 0;
2656 else if (gl_support_arb_texture_non_power_of_two)
2658 texturewidth = waterwidth;
2659 textureheight = waterheight;
2663 for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
2664 for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
2667 // allocate textures as needed
2668 if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
2670 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2671 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
2673 if (p->texture_refraction)
2674 R_FreeTexture(p->texture_refraction);
2675 p->texture_refraction = NULL;
2676 if (p->texture_reflection)
2677 R_FreeTexture(p->texture_reflection);
2678 p->texture_reflection = NULL;
2680 memset(&r_waterstate, 0, sizeof(r_waterstate));
2681 r_waterstate.waterwidth = waterwidth;
2682 r_waterstate.waterheight = waterheight;
2683 r_waterstate.texturewidth = texturewidth;
2684 r_waterstate.textureheight = textureheight;
2687 if (r_waterstate.waterwidth)
2689 r_waterstate.enabled = true;
2691 // set up variables that will be used in shader setup
2692 r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2693 r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
2694 r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2695 r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
2698 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2699 r_waterstate.numwaterplanes = 0;
2702 static void R_Water_AddWaterPlane(msurface_t *surface)
2704 int triangleindex, planeindex;
2709 r_waterstate_waterplane_t *p;
2710 // just use the first triangle with a valid normal for any decisions
2711 VectorClear(normal);
2712 for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
2714 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
2715 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
2716 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
2717 TriangleNormal(vert[0], vert[1], vert[2], normal);
2718 if (VectorLength2(normal) >= 0.001)
2722 // find a matching plane if there is one
2723 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2724 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
2726 if (planeindex >= r_waterstate.maxwaterplanes)
2727 return; // nothing we can do, out of planes
2729 // if this triangle does not fit any known plane rendered this frame, add one
2730 if (planeindex >= r_waterstate.numwaterplanes)
2732 // store the new plane
2733 r_waterstate.numwaterplanes++;
2734 VectorCopy(normal, p->plane.normal);
2735 VectorNormalize(p->plane.normal);
2736 p->plane.dist = DotProduct(vert[0], p->plane.normal);
2737 PlaneClassify(&p->plane);
2738 // flip the plane if it does not face the viewer
2739 if (PlaneDiff(r_view.origin, &p->plane) < 0)
2741 VectorNegate(p->plane.normal, p->plane.normal);
2742 p->plane.dist *= -1;
2743 PlaneClassify(&p->plane);
2745 // clear materialflags and pvs
2746 p->materialflags = 0;
2747 p->pvsvalid = false;
2749 // merge this surface's materialflags into the waterplane
2750 p->materialflags |= surface->texture->currentframe->currentmaterialflags;
2751 // merge this surface's PVS into the waterplane
2752 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
2753 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS
2754 && r_refdef.worldmodel->brush.PointInLeaf && r_refdef.worldmodel->brush.PointInLeaf(r_refdef.worldmodel, center)->clusterindex >= 0)
2756 r_refdef.worldmodel->brush.FatPVS(r_refdef.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
2761 static void R_Water_ProcessPlanes(void)
2763 r_view_t originalview;
2765 r_waterstate_waterplane_t *p;
2767 originalview = r_view;
2769 // make sure enough textures are allocated
2770 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2772 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2774 if (!p->texture_refraction)
2775 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);
2776 if (!p->texture_refraction)
2780 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2782 if (!p->texture_reflection)
2783 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);
2784 if (!p->texture_reflection)
2790 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2792 r_view.showdebug = false;
2793 r_view.width = r_waterstate.waterwidth;
2794 r_view.height = r_waterstate.waterheight;
2795 r_view.useclipplane = true;
2796 r_waterstate.renderingscene = true;
2798 // render the normal view scene and copy into texture
2799 // (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)
2800 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2802 r_view.clipplane = p->plane;
2803 VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
2804 r_view.clipplane.dist = -r_view.clipplane.dist;
2805 PlaneClassify(&r_view.clipplane);
2807 R_RenderScene(false);
2809 // copy view into the screen texture
2810 R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
2811 GL_ActiveTexture(0);
2813 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
2816 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2818 // render reflected scene and copy into texture
2819 Matrix4x4_Reflect(&r_view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
2820 r_view.clipplane = p->plane;
2821 // reverse the cullface settings for this render
2822 r_view.cullface_front = GL_FRONT;
2823 r_view.cullface_back = GL_BACK;
2824 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.num_pvsclusterbytes)
2826 r_view.usecustompvs = true;
2828 memcpy(r_viewcache.world_pvsbits, p->pvsbits, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2830 memset(r_viewcache.world_pvsbits, 0xFF, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2833 R_ResetViewRendering3D();
2835 if (r_timereport_active)
2836 R_TimeReport("viewclear");
2838 R_RenderScene(false);
2840 R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
2841 GL_ActiveTexture(0);
2843 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
2845 R_ResetViewRendering3D();
2847 if (r_timereport_active)
2848 R_TimeReport("viewclear");
2851 r_view = originalview;
2852 r_view.clear = true;
2853 r_waterstate.renderingscene = false;
2857 r_view = originalview;
2858 r_waterstate.renderingscene = false;
2859 Cvar_SetValueQuick(&r_water, 0);
2860 Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
2864 void R_Bloom_StartFrame(void)
2866 int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
2868 // set bloomwidth and bloomheight to the bloom resolution that will be
2869 // used (often less than the screen resolution for faster rendering)
2870 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
2871 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_view.height / r_view.width;
2872 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_view.height);
2874 // calculate desired texture sizes
2875 if (gl_support_arb_texture_non_power_of_two)
2877 screentexturewidth = r_view.width;
2878 screentextureheight = r_view.height;
2879 bloomtexturewidth = r_bloomstate.bloomwidth;
2880 bloomtextureheight = r_bloomstate.bloomheight;
2884 for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
2885 for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
2886 for (bloomtexturewidth = 1;bloomtexturewidth < r_bloomstate.bloomwidth ;bloomtexturewidth *= 2);
2887 for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2);
2892 screentexturewidth = screentextureheight = 0;
2894 else if (r_bloom.integer)
2899 screentexturewidth = screentextureheight = 0;
2900 bloomtexturewidth = bloomtextureheight = 0;
2903 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)
2905 // can't use bloom if the parameters are too weird
2906 // can't use bloom if the card does not support the texture size
2907 if (r_bloomstate.texture_screen)
2908 R_FreeTexture(r_bloomstate.texture_screen);
2909 if (r_bloomstate.texture_bloom)
2910 R_FreeTexture(r_bloomstate.texture_bloom);
2911 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
2915 r_bloomstate.enabled = true;
2916 r_bloomstate.hdr = r_hdr.integer != 0;
2918 // allocate textures as needed
2919 if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
2921 if (r_bloomstate.texture_screen)
2922 R_FreeTexture(r_bloomstate.texture_screen);
2923 r_bloomstate.texture_screen = NULL;
2924 r_bloomstate.screentexturewidth = screentexturewidth;
2925 r_bloomstate.screentextureheight = screentextureheight;
2926 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
2927 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);
2929 if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
2931 if (r_bloomstate.texture_bloom)
2932 R_FreeTexture(r_bloomstate.texture_bloom);
2933 r_bloomstate.texture_bloom = NULL;
2934 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
2935 r_bloomstate.bloomtextureheight = bloomtextureheight;
2936 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
2937 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);
2940 // set up a texcoord array for the full resolution screen image
2941 // (we have to keep this around to copy back during final render)
2942 r_bloomstate.screentexcoord2f[0] = 0;
2943 r_bloomstate.screentexcoord2f[1] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2944 r_bloomstate.screentexcoord2f[2] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2945 r_bloomstate.screentexcoord2f[3] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2946 r_bloomstate.screentexcoord2f[4] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2947 r_bloomstate.screentexcoord2f[5] = 0;
2948 r_bloomstate.screentexcoord2f[6] = 0;
2949 r_bloomstate.screentexcoord2f[7] = 0;
2951 // set up a texcoord array for the reduced resolution bloom image
2952 // (which will be additive blended over the screen image)
2953 r_bloomstate.bloomtexcoord2f[0] = 0;
2954 r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2955 r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2956 r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2957 r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2958 r_bloomstate.bloomtexcoord2f[5] = 0;
2959 r_bloomstate.bloomtexcoord2f[6] = 0;
2960 r_bloomstate.bloomtexcoord2f[7] = 0;
2963 void R_Bloom_CopyScreenTexture(float colorscale)
2965 r_refdef.stats.bloom++;
2967 R_ResetViewRendering2D();
2968 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2969 R_Mesh_ColorPointer(NULL, 0, 0);
2970 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
2971 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
2973 // copy view into the screen texture
2974 GL_ActiveTexture(0);
2976 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
2977 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2979 // now scale it down to the bloom texture size
2981 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2982 GL_BlendFunc(GL_ONE, GL_ZERO);
2983 GL_Color(colorscale, colorscale, colorscale, 1);
2984 // TODO: optimize with multitexture or GLSL
2985 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2986 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2988 // we now have a bloom image in the framebuffer
2989 // copy it into the bloom image texture for later processing
2990 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2991 GL_ActiveTexture(0);
2993 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
2994 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2997 void R_Bloom_CopyHDRTexture(void)
2999 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3000 GL_ActiveTexture(0);
3002 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
3003 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
3006 void R_Bloom_MakeTexture(void)
3009 float xoffset, yoffset, r, brighten;
3011 r_refdef.stats.bloom++;
3013 R_ResetViewRendering2D();
3014 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3015 R_Mesh_ColorPointer(NULL, 0, 0);
3017 // we have a bloom image in the framebuffer
3019 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3021 for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
3024 r = bound(0, r_bloom_colorexponent.value / x, 1);
3025 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
3026 GL_Color(r, r, r, 1);
3027 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3028 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3029 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3030 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3032 // copy the vertically blurred bloom view to a texture
3033 GL_ActiveTexture(0);
3035 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
3036 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3039 range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
3040 brighten = r_bloom_brighten.value;
3042 brighten *= r_hdr_range.value;
3043 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3044 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
3046 for (dir = 0;dir < 2;dir++)
3048 // blend on at multiple vertical offsets to achieve a vertical blur
3049 // TODO: do offset blends using GLSL
3050 GL_BlendFunc(GL_ONE, GL_ZERO);
3051 for (x = -range;x <= range;x++)
3053 if (!dir){xoffset = 0;yoffset = x;}
3054 else {xoffset = x;yoffset = 0;}
3055 xoffset /= (float)r_bloomstate.bloomtexturewidth;
3056 yoffset /= (float)r_bloomstate.bloomtextureheight;
3057 // compute a texcoord array with the specified x and y offset
3058 r_bloomstate.offsettexcoord2f[0] = xoffset+0;
3059 r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3060 r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3061 r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3062 r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3063 r_bloomstate.offsettexcoord2f[5] = yoffset+0;
3064 r_bloomstate.offsettexcoord2f[6] = xoffset+0;
3065 r_bloomstate.offsettexcoord2f[7] = yoffset+0;
3066 // this r value looks like a 'dot' particle, fading sharply to
3067 // black at the edges
3068 // (probably not realistic but looks good enough)
3069 //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
3070 //r = (dir ? 1.0f : brighten)/(range*2+1);
3071 r = (dir ? 1.0f : brighten)/(range*2+1)*(1 - x*x/(float)(range*range));
3072 GL_Color(r, r, r, 1);
3073 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3074 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3075 GL_BlendFunc(GL_ONE, GL_ONE);
3078 // copy the vertically blurred bloom view to a texture
3079 GL_ActiveTexture(0);
3081 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
3082 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3085 // apply subtract last
3086 // (just like it would be in a GLSL shader)
3087 if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract)
3089 GL_BlendFunc(GL_ONE, GL_ZERO);
3090 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3091 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3092 GL_Color(1, 1, 1, 1);
3093 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3094 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3096 GL_BlendFunc(GL_ONE, GL_ONE);
3097 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
3098 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
3099 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3100 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
3101 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3102 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3103 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3105 // copy the darkened bloom view to a texture
3106 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3107 GL_ActiveTexture(0);
3109 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
3110 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3114 void R_HDR_RenderBloomTexture(void)
3116 int oldwidth, oldheight;
3118 oldwidth = r_view.width;
3119 oldheight = r_view.height;
3120 r_view.width = r_bloomstate.bloomwidth;
3121 r_view.height = r_bloomstate.bloomheight;
3123 // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer? it might improve SLI performance.
3124 // TODO: add exposure compensation features
3125 // TODO: add fp16 framebuffer support
3127 r_view.showdebug = false;
3128 r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
3130 r_view.colorscale /= r_hdr_range.value;
3131 r_waterstate.numwaterplanes = 0;
3132 R_RenderScene(r_waterstate.enabled);
3133 r_view.showdebug = true;
3135 R_ResetViewRendering2D();
3137 R_Bloom_CopyHDRTexture();
3138 R_Bloom_MakeTexture();
3140 R_ResetViewRendering3D();
3143 if (r_timereport_active)
3144 R_TimeReport("viewclear");
3146 // restore the view settings
3147 r_view.width = oldwidth;
3148 r_view.height = oldheight;
3151 static void R_BlendView(void)
3153 if (r_bloomstate.enabled && r_bloomstate.hdr)
3155 // render high dynamic range bloom effect
3156 // the bloom texture was made earlier this render, so we just need to
3157 // blend it onto the screen...
3158 R_ResetViewRendering2D();
3159 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3160 R_Mesh_ColorPointer(NULL, 0, 0);
3161 GL_Color(1, 1, 1, 1);
3162 GL_BlendFunc(GL_ONE, GL_ONE);
3163 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3164 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3165 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3166 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3168 else if (r_bloomstate.enabled)
3170 // render simple bloom effect
3171 // copy the screen and shrink it and darken it for the bloom process
3172 R_Bloom_CopyScreenTexture(r_bloom_colorscale.value);
3173 // make the bloom texture
3174 R_Bloom_MakeTexture();
3175 // put the original screen image back in place and blend the bloom
3177 R_ResetViewRendering2D();
3178 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3179 R_Mesh_ColorPointer(NULL, 0, 0);
3180 GL_Color(1, 1, 1, 1);
3181 GL_BlendFunc(GL_ONE, GL_ZERO);
3182 // do both in one pass if possible
3183 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3184 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3185 if (r_textureunits.integer >= 2 && gl_combine.integer)
3187 R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
3188 R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen));
3189 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0);
3193 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3194 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3195 // now blend on the bloom texture
3196 GL_BlendFunc(GL_ONE, GL_ONE);
3197 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3198 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3200 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3201 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3203 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
3205 // apply a color tint to the whole view
3206 R_ResetViewRendering2D();
3207 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3208 R_Mesh_ColorPointer(NULL, 0, 0);
3209 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3210 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
3211 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3215 void R_RenderScene(qboolean addwaterplanes);
3217 matrix4x4_t r_waterscrollmatrix;
3219 void R_UpdateVariables(void)
3223 r_refdef.farclip = 4096;
3224 if (r_refdef.worldmodel)
3225 r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
3226 r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
3228 if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
3229 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
3230 r_refdef.polygonfactor = 0;
3231 r_refdef.polygonoffset = 0;
3232 r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3233 r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3235 r_refdef.rtworld = r_shadow_realtime_world.integer;
3236 r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
3237 r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
3238 r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
3239 r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
3240 if (r_showsurfaces.integer)
3242 r_refdef.rtworld = false;
3243 r_refdef.rtworldshadows = false;
3244 r_refdef.rtdlight = false;
3245 r_refdef.rtdlightshadows = false;
3246 r_refdef.lightmapintensity = 0;
3249 if (gamemode == GAME_NEHAHRA)
3251 if (gl_fogenable.integer)
3253 r_refdef.oldgl_fogenable = true;
3254 r_refdef.fog_density = gl_fogdensity.value;
3255 r_refdef.fog_red = gl_fogred.value;
3256 r_refdef.fog_green = gl_foggreen.value;
3257 r_refdef.fog_blue = gl_fogblue.value;
3259 else if (r_refdef.oldgl_fogenable)
3261 r_refdef.oldgl_fogenable = false;
3262 r_refdef.fog_density = 0;
3263 r_refdef.fog_red = 0;
3264 r_refdef.fog_green = 0;
3265 r_refdef.fog_blue = 0;
3268 if (r_refdef.fog_density)
3270 r_refdef.fogcolor[0] = r_refdef.fog_red;
3271 r_refdef.fogcolor[1] = r_refdef.fog_green;
3272 r_refdef.fogcolor[2] = r_refdef.fog_blue;
3276 // color.rgb *= SceneBrightness;
3277 VectorScale(r_refdef.fogcolor, r_view.colorscale, fogvec);
3278 if(r_glsl.integer && (r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)) // need to support contrast boost
3280 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
3281 fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
3282 fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
3283 fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
3285 r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
3286 r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
3287 r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
3291 if (r_refdef.fog_start >= r_refdef.fog_end || r_refdef.fog_start < 0)
3293 r_refdef.fog_start = 0;
3294 r_refdef.fog_end = 1000000000;
3295 // TODO update fog cvars here too
3298 if (r_refdef.fog_density)
3300 r_refdef.fogenabled = true;
3301 // this is the point where the fog reaches 0.9986 alpha, which we
3302 // consider a good enough cutoff point for the texture
3303 // (0.9986 * 256 == 255.6)
3304 r_refdef.fogrange = 16 / (r_refdef.fog_density * r_refdef.fog_density);
3305 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
3306 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
3307 // fog color was already set
3310 r_refdef.fogenabled = false;
3318 void R_RenderView(void)
3320 if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
3321 return; //Host_Error ("R_RenderView: NULL worldmodel");
3323 R_Shadow_UpdateWorldLightSelection();
3325 R_Bloom_StartFrame();
3326 R_Water_StartFrame();
3329 if (r_timereport_active)
3330 R_TimeReport("viewsetup");
3332 R_ResetViewRendering3D();
3337 if (r_timereport_active)
3338 R_TimeReport("viewclear");
3340 r_view.clear = true;
3342 r_view.showdebug = true;
3344 // this produces a bloom texture to be used in R_BlendView() later
3346 R_HDR_RenderBloomTexture();
3348 r_view.colorscale = r_hdr_scenebrightness.value;
3349 r_waterstate.numwaterplanes = 0;
3350 R_RenderScene(r_waterstate.enabled);
3353 if (r_timereport_active)
3354 R_TimeReport("blendview");
3356 GL_Scissor(0, 0, vid.width, vid.height);
3357 GL_ScissorTest(false);
3361 extern void R_DrawLightningBeams (void);
3362 extern void VM_CL_AddPolygonsToMeshQueue (void);
3363 extern void R_DrawPortals (void);
3364 extern cvar_t cl_locs_show;
3365 static void R_DrawLocs(void);
3366 static void R_DrawEntityBBoxes(void);
3367 void R_RenderScene(qboolean addwaterplanes)
3371 R_ResetViewRendering3D();
3374 if (r_timereport_active)
3375 R_TimeReport("watervis");
3377 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawAddWaterPlanes)
3379 r_refdef.worldmodel->DrawAddWaterPlanes(r_refdef.worldentity);
3380 if (r_timereport_active)
3381 R_TimeReport("waterworld");
3384 // don't let sound skip if going slow
3385 if (r_refdef.extraupdate)
3388 R_DrawModelsAddWaterPlanes();
3389 if (r_timereport_active)
3390 R_TimeReport("watermodels");
3392 R_Water_ProcessPlanes();
3393 if (r_timereport_active)
3394 R_TimeReport("waterscenes");
3397 R_ResetViewRendering3D();
3399 // don't let sound skip if going slow
3400 if (r_refdef.extraupdate)
3403 R_MeshQueue_BeginScene();
3408 if (r_timereport_active)
3409 R_TimeReport("visibility");
3411 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);
3413 if (cl.csqc_vidvars.drawworld)
3415 // don't let sound skip if going slow
3416 if (r_refdef.extraupdate)
3419 if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
3421 r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
3422 if (r_timereport_active)
3423 R_TimeReport("worldsky");
3426 if (R_DrawBrushModelsSky() && r_timereport_active)
3427 R_TimeReport("bmodelsky");
3430 if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawDepth)
3432 r_refdef.worldmodel->DrawDepth(r_refdef.worldentity);
3433 if (r_timereport_active)
3434 R_TimeReport("worlddepth");
3436 if (r_depthfirst.integer >= 2)
3438 R_DrawModelsDepth();
3439 if (r_timereport_active)
3440 R_TimeReport("modeldepth");
3443 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->Draw)
3445 r_refdef.worldmodel->Draw(r_refdef.worldentity);
3446 if (r_timereport_active)
3447 R_TimeReport("world");
3450 // don't let sound skip if going slow
3451 if (r_refdef.extraupdate)
3455 if (r_timereport_active)
3456 R_TimeReport("models");
3458 // don't let sound skip if going slow
3459 if (r_refdef.extraupdate)
3462 if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
3464 R_DrawModelShadows();
3466 R_ResetViewRendering3D();
3468 // don't let sound skip if going slow
3469 if (r_refdef.extraupdate)
3473 R_ShadowVolumeLighting(false);
3474 if (r_timereport_active)
3475 R_TimeReport("rtlights");
3477 // don't let sound skip if going slow
3478 if (r_refdef.extraupdate)
3481 if (cl.csqc_vidvars.drawworld)
3483 R_DrawLightningBeams();
3484 if (r_timereport_active)
3485 R_TimeReport("lightning");
3488 if (r_timereport_active)
3489 R_TimeReport("decals");
3492 if (r_timereport_active)
3493 R_TimeReport("particles");
3496 if (r_timereport_active)
3497 R_TimeReport("explosions");
3500 if (gl_support_fragment_shader)
3502 qglUseProgramObjectARB(0);CHECKGLERROR
3504 VM_CL_AddPolygonsToMeshQueue();
3506 if (r_view.showdebug)
3508 if (cl_locs_show.integer)
3511 if (r_timereport_active)
3512 R_TimeReport("showlocs");
3515 if (r_drawportals.integer)
3518 if (r_timereport_active)
3519 R_TimeReport("portals");
3522 if (r_showbboxes.value > 0)
3524 R_DrawEntityBBoxes();
3525 if (r_timereport_active)
3526 R_TimeReport("bboxes");
3530 if (gl_support_fragment_shader)
3532 qglUseProgramObjectARB(0);CHECKGLERROR
3534 R_MeshQueue_RenderTransparent();
3535 if (r_timereport_active)
3536 R_TimeReport("drawtrans");
3538 if (gl_support_fragment_shader)
3540 qglUseProgramObjectARB(0);CHECKGLERROR
3543 if (r_view.showdebug && r_refdef.worldmodel && r_refdef.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value > 0 || r_showcollisionbrushes.value > 0))
3545 r_refdef.worldmodel->DrawDebug(r_refdef.worldentity);
3546 if (r_timereport_active)
3547 R_TimeReport("worlddebug");
3548 R_DrawModelsDebug();
3549 if (r_timereport_active)
3550 R_TimeReport("modeldebug");
3553 if (gl_support_fragment_shader)
3555 qglUseProgramObjectARB(0);CHECKGLERROR
3558 if (cl.csqc_vidvars.drawworld)
3561 if (r_timereport_active)
3562 R_TimeReport("coronas");
3565 // don't let sound skip if going slow
3566 if (r_refdef.extraupdate)
3569 R_ResetViewRendering2D();
3572 static const int bboxelements[36] =
3582 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
3585 float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
3586 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3587 GL_DepthMask(false);
3588 GL_DepthRange(0, 1);
3589 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3590 R_Mesh_Matrix(&identitymatrix);
3591 R_Mesh_ResetTextureState();
3593 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
3594 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
3595 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
3596 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
3597 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
3598 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
3599 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
3600 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
3601 R_FillColors(color4f, 8, cr, cg, cb, ca);
3602 if (r_refdef.fogenabled)
3604 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
3606 f1 = FogPoint_World(v);
3608 c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
3609 c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
3610 c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
3613 R_Mesh_VertexPointer(vertex3f, 0, 0);
3614 R_Mesh_ColorPointer(color4f, 0, 0);
3615 R_Mesh_ResetTextureState();
3616 R_Mesh_Draw(0, 8, 12, bboxelements, 0, 0);
3619 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3623 prvm_edict_t *edict;
3624 // this function draws bounding boxes of server entities
3628 for (i = 0;i < numsurfaces;i++)
3630 edict = PRVM_EDICT_NUM(surfacelist[i]);
3631 switch ((int)edict->fields.server->solid)
3633 case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
3634 case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
3635 case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
3636 case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
3637 case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
3638 default: Vector4Set(color, 0, 0, 0, 0.50);break;
3640 color[3] *= r_showbboxes.value;
3641 color[3] = bound(0, color[3], 1);
3642 GL_DepthTest(!r_showdisabledepthtest.integer);
3643 GL_CullFace(r_view.cullface_front);
3644 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
3649 static void R_DrawEntityBBoxes(void)
3652 prvm_edict_t *edict;
3654 // this function draws bounding boxes of server entities
3658 for (i = 0;i < prog->num_edicts;i++)
3660 edict = PRVM_EDICT_NUM(i);
3661 if (edict->priv.server->free)
3663 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
3664 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
3669 int nomodelelements[24] =
3681 float nomodelvertex3f[6*3] =
3691 float nomodelcolor4f[6*4] =
3693 0.0f, 0.0f, 0.5f, 1.0f,
3694 0.0f, 0.0f, 0.5f, 1.0f,
3695 0.0f, 0.5f, 0.0f, 1.0f,
3696 0.0f, 0.5f, 0.0f, 1.0f,
3697 0.5f, 0.0f, 0.0f, 1.0f,
3698 0.5f, 0.0f, 0.0f, 1.0f
3701 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3706 // this is only called once per entity so numsurfaces is always 1, and
3707 // surfacelist is always {0}, so this code does not handle batches
3708 R_Mesh_Matrix(&ent->matrix);
3710 if (ent->flags & EF_ADDITIVE)
3712 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
3713 GL_DepthMask(false);
3715 else if (ent->alpha < 1)
3717 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3718 GL_DepthMask(false);
3722 GL_BlendFunc(GL_ONE, GL_ZERO);
3725 GL_DepthRange(0, (ent->flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
3726 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3727 GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
3728 GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : r_view.cullface_back);
3729 R_Mesh_VertexPointer(nomodelvertex3f, 0, 0);
3730 if (r_refdef.fogenabled)
3733 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3734 R_Mesh_ColorPointer(color4f, 0, 0);
3735 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3736 f1 = FogPoint_World(org);
3738 for (i = 0, c = color4f;i < 6;i++, c += 4)
3740 c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
3741 c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
3742 c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
3746 else if (ent->alpha != 1)
3748 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3749 R_Mesh_ColorPointer(color4f, 0, 0);
3750 for (i = 0, c = color4f;i < 6;i++, c += 4)
3754 R_Mesh_ColorPointer(nomodelcolor4f, 0, 0);
3755 R_Mesh_ResetTextureState();
3756 R_Mesh_Draw(0, 6, 8, nomodelelements, 0, 0);
3759 void R_DrawNoModel(entity_render_t *ent)
3762 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3763 //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
3764 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
3766 // R_DrawNoModelCallback(ent, 0);
3769 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
3771 vec3_t right1, right2, diff, normal;
3773 VectorSubtract (org2, org1, normal);
3775 // calculate 'right' vector for start
3776 VectorSubtract (r_view.origin, org1, diff);
3777 CrossProduct (normal, diff, right1);
3778 VectorNormalize (right1);
3780 // calculate 'right' vector for end
3781 VectorSubtract (r_view.origin, org2, diff);
3782 CrossProduct (normal, diff, right2);
3783 VectorNormalize (right2);
3785 vert[ 0] = org1[0] + width * right1[0];
3786 vert[ 1] = org1[1] + width * right1[1];
3787 vert[ 2] = org1[2] + width * right1[2];
3788 vert[ 3] = org1[0] - width * right1[0];
3789 vert[ 4] = org1[1] - width * right1[1];
3790 vert[ 5] = org1[2] - width * right1[2];
3791 vert[ 6] = org2[0] - width * right2[0];
3792 vert[ 7] = org2[1] - width * right2[1];
3793 vert[ 8] = org2[2] - width * right2[2];
3794 vert[ 9] = org2[0] + width * right2[0];
3795 vert[10] = org2[1] + width * right2[1];
3796 vert[11] = org2[2] + width * right2[2];
3799 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
3801 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)
3806 if (r_refdef.fogenabled)
3807 fog = FogPoint_World(origin);
3809 R_Mesh_Matrix(&identitymatrix);
3810 GL_BlendFunc(blendfunc1, blendfunc2);
3816 GL_CullFace(r_view.cullface_front);
3819 GL_CullFace(r_view.cullface_back);
3821 GL_DepthMask(false);
3822 GL_DepthRange(0, depthshort ? 0.0625 : 1);
3823 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3824 GL_DepthTest(!depthdisable);
3826 vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
3827 vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
3828 vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
3829 vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
3830 vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
3831 vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
3832 vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
3833 vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
3834 vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
3835 vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
3836 vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
3837 vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
3839 R_Mesh_VertexPointer(vertex3f, 0, 0);
3840 R_Mesh_ColorPointer(NULL, 0, 0);
3841 R_Mesh_ResetTextureState();
3842 R_Mesh_TexBind(0, R_GetTexture(texture));
3843 R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f, 0, 0);
3844 // FIXME: fixed function path can't properly handle r_view.colorscale > 1
3845 GL_Color(cr * fog * r_view.colorscale, cg * fog * r_view.colorscale, cb * fog * r_view.colorscale, ca);
3846 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3848 if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
3850 R_Mesh_TexBind(0, R_GetTexture(fogtexture));
3851 GL_BlendFunc(blendfunc1, GL_ONE);
3853 GL_Color(r_refdef.fogcolor[0] * fog, r_refdef.fogcolor[1] * fog, r_refdef.fogcolor[2] * fog, ca);
3854 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3858 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
3863 VectorSet(v, x, y, z);
3864 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
3865 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
3867 if (i == mesh->numvertices)
3869 if (mesh->numvertices < mesh->maxvertices)
3871 VectorCopy(v, vertex3f);
3872 mesh->numvertices++;
3874 return mesh->numvertices;
3880 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
3884 element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3885 element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3886 e = mesh->element3i + mesh->numtriangles * 3;
3887 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
3889 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
3890 if (mesh->numtriangles < mesh->maxtriangles)
3895 mesh->numtriangles++;
3897 element[1] = element[2];
3901 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
3905 element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3906 element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3907 e = mesh->element3i + mesh->numtriangles * 3;
3908 for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
3910 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
3911 if (mesh->numtriangles < mesh->maxtriangles)
3916 mesh->numtriangles++;
3918 element[1] = element[2];
3922 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
3923 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
3925 int planenum, planenum2;
3928 mplane_t *plane, *plane2;
3930 double temppoints[2][256*3];
3931 // figure out how large a bounding box we need to properly compute this brush
3933 for (w = 0;w < numplanes;w++)
3934 maxdist = max(maxdist, planes[w].dist);
3935 // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
3936 maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
3937 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
3941 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
3942 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
3944 if (planenum2 == planenum)
3946 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);
3949 if (tempnumpoints < 3)
3951 // generate elements forming a triangle fan for this polygon
3952 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
3956 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)
3958 texturelayer_t *layer;
3959 layer = t->currentlayers + t->currentnumlayers++;
3961 layer->depthmask = depthmask;
3962 layer->blendfunc1 = blendfunc1;
3963 layer->blendfunc2 = blendfunc2;
3964 layer->texture = texture;
3965 layer->texmatrix = *matrix;
3966 layer->color[0] = r * r_view.colorscale;
3967 layer->color[1] = g * r_view.colorscale;
3968 layer->color[2] = b * r_view.colorscale;
3969 layer->color[3] = a;
3972 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
3975 index = parms[2] + r_refdef.time * parms[3];
3976 index -= floor(index);
3980 case Q3WAVEFUNC_NONE:
3981 case Q3WAVEFUNC_NOISE:
3982 case Q3WAVEFUNC_COUNT:
3985 case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
3986 case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
3987 case Q3WAVEFUNC_SAWTOOTH: f = index;break;
3988 case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
3989 case Q3WAVEFUNC_TRIANGLE:
3991 f = index - floor(index);
4002 return (float)(parms[0] + parms[1] * f);
4005 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
4008 model_t *model = ent->model;
4011 q3shaderinfo_layer_tcmod_t *tcmod;
4013 // switch to an alternate material if this is a q1bsp animated material
4015 texture_t *texture = t;
4016 int s = ent->skinnum;
4017 if ((unsigned int)s >= (unsigned int)model->numskins)
4019 if (model->skinscenes)
4021 if (model->skinscenes[s].framecount > 1)
4022 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
4024 s = model->skinscenes[s].firstframe;
4027 t = t + s * model->num_surfaces;
4030 // use an alternate animation if the entity's frame is not 0,
4031 // and only if the texture has an alternate animation
4032 if (ent->frame2 != 0 && t->anim_total[1])
4033 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
4035 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
4037 texture->currentframe = t;
4040 // update currentskinframe to be a qw skin or animation frame
4041 if ((i = ent->entitynumber - 1) >= 0 && i < cl.maxclients)
4043 if (strcmp(r_qwskincache[i], cl.scores[i].qw_skin))
4045 strlcpy(r_qwskincache[i], cl.scores[i].qw_skin, sizeof(r_qwskincache[i]));
4046 Con_DPrintf("loading skins/%s\n", r_qwskincache[i]);
4047 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);
4049 t->currentskinframe = r_qwskincache_skinframe[i];
4050 if (t->currentskinframe == NULL)
4051 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4053 else if (t->numskinframes >= 2)
4054 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4055 if (t->backgroundnumskinframes >= 2)
4056 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - ent->frame2time)) % t->backgroundnumskinframes];
4058 t->currentmaterialflags = t->basematerialflags;
4059 t->currentalpha = ent->alpha;
4060 if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
4062 t->currentalpha *= r_wateralpha.value;
4064 * FIXME what is this supposed to do?
4065 // if rendering refraction/reflection, disable transparency
4066 if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
4067 t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
4070 if(!r_waterstate.enabled)
4071 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
4072 if (!(ent->flags & RENDER_LIGHT))
4073 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
4074 else if (rsurface.modeltexcoordlightmap2f == NULL)
4076 // pick a model lighting mode
4077 if (VectorLength2(ent->modellight_diffuse) >= (1.0f / 256.0f))
4078 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
4080 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
4082 if (ent->effects & EF_ADDITIVE)
4083 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4084 else if (t->currentalpha < 1)
4085 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4086 if (ent->effects & EF_DOUBLESIDED)
4087 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
4088 if (ent->effects & EF_NODEPTHTEST)
4089 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4090 if (ent->flags & RENDER_VIEWMODEL)
4091 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4092 if (t->backgroundnumskinframes && !(t->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
4093 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
4095 // make sure that the waterscroll matrix is used on water surfaces when
4096 // there is no tcmod
4097 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4098 t->currenttexmatrix = r_waterscrollmatrix;
4100 for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
4103 switch(tcmod->tcmod)
4107 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4108 matrix = r_waterscrollmatrix;
4110 matrix = identitymatrix;
4112 case Q3TCMOD_ENTITYTRANSLATE:
4113 // this is used in Q3 to allow the gamecode to control texcoord
4114 // scrolling on the entity, which is not supported in darkplaces yet.
4115 Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
4117 case Q3TCMOD_ROTATE:
4118 Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
4119 Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.time, 0, 0, 1);
4120 Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
4123 Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
4125 case Q3TCMOD_SCROLL:
4126 Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.time, tcmod->parms[1] * r_refdef.time, 0);
4128 case Q3TCMOD_STRETCH:
4129 f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
4130 Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
4132 case Q3TCMOD_TRANSFORM:
4133 VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
4134 VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
4135 VectorSet(tcmat + 6, 0 , 0 , 1);
4136 VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
4137 Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
4139 case Q3TCMOD_TURBULENT:
4140 // this is handled in the RSurf_PrepareVertices function
4141 matrix = identitymatrix;
4144 // either replace or concatenate the transformation
4146 t->currenttexmatrix = matrix;
4149 matrix4x4_t temp = t->currenttexmatrix;
4150 Matrix4x4_Concat(&t->currenttexmatrix, &matrix, &temp);
4154 t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
4155 t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4156 t->glosstexture = r_texture_black;
4157 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
4158 t->backgroundglosstexture = r_texture_black;
4159 t->specularpower = r_shadow_glossexponent.value;
4160 // TODO: store reference values for these in the texture?
4161 t->specularscale = 0;
4162 if (r_shadow_gloss.integer > 0)
4164 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
4166 if (r_shadow_glossintensity.value > 0)
4168 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
4169 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
4170 t->specularscale = r_shadow_glossintensity.value;
4173 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
4175 t->glosstexture = r_texture_white;
4176 t->backgroundglosstexture = r_texture_white;
4177 t->specularscale = r_shadow_gloss2intensity.value;
4181 // lightmaps mode looks bad with dlights using actual texturing, so turn
4182 // off the colormap and glossmap, but leave the normalmap on as it still
4183 // accurately represents the shading involved
4184 if (gl_lightmaps.integer && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
4186 t->basetexture = r_texture_white;
4187 t->specularscale = 0;
4190 t->currentpolygonfactor = r_refdef.polygonfactor + t->basepolygonfactor;
4191 t->currentpolygonoffset = r_refdef.polygonoffset + t->basepolygonoffset;
4192 // submodels are biased to avoid z-fighting with world surfaces that they
4193 // may be exactly overlapping (avoids z-fighting artifacts on certain
4194 // doors and things in Quake maps)
4195 if (ent->model->brush.submodel)
4197 t->currentpolygonfactor += r_polygonoffset_submodel_factor.value;
4198 t->currentpolygonoffset += r_polygonoffset_submodel_offset.value;
4201 VectorClear(t->dlightcolor);
4202 t->currentnumlayers = 0;
4203 if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
4205 if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
4207 int blendfunc1, blendfunc2, depthmask;
4208 if (t->currentmaterialflags & MATERIALFLAG_ADD)
4210 blendfunc1 = GL_SRC_ALPHA;
4211 blendfunc2 = GL_ONE;
4213 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
4215 blendfunc1 = GL_SRC_ALPHA;
4216 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
4218 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
4220 blendfunc1 = t->customblendfunc[0];
4221 blendfunc2 = t->customblendfunc[1];
4225 blendfunc1 = GL_ONE;
4226 blendfunc2 = GL_ZERO;
4228 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
4229 if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
4231 rtexture_t *currentbasetexture;
4233 if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
4234 layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
4235 currentbasetexture = (VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) < (1.0f / 1048576.0f) && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4236 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
4238 // fullbright is not affected by r_refdef.lightmapintensity
4239 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
4240 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4241 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);
4242 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4243 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);
4248 // set the color tint used for lights affecting this surface
4249 VectorSet(t->dlightcolor, ent->colormod[0] * t->currentalpha, ent->colormod[1] * t->currentalpha, ent->colormod[2] * t->currentalpha);
4251 // q3bsp has no lightmap updates, so the lightstylevalue that
4252 // would normally be baked into the lightmap must be
4253 // applied to the color
4254 // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
4255 if (ent->model->type == mod_brushq3)
4256 colorscale *= r_refdef.rtlightstylevalue[0];
4257 colorscale *= r_refdef.lightmapintensity;
4258 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);
4259 if (r_ambient.value >= (1.0f/64.0f))
4260 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);
4261 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4263 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);
4264 if (r_ambient.value >= (1.0f/64.0f))
4265 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);
4267 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4269 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);
4270 if (r_ambient.value >= (1.0f/64.0f))
4271 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);
4274 if (t->currentskinframe->glow != NULL)
4275 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);
4276 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
4278 // if this is opaque use alpha blend which will darken the earlier
4281 // if this is an alpha blended material, all the earlier passes
4282 // were darkened by fog already, so we only need to add the fog
4283 // color ontop through the fog mask texture
4285 // if this is an additive blended material, all the earlier passes
4286 // were darkened by fog already, and we should not add fog color
4287 // (because the background was not darkened, there is no fog color
4288 // that was lost behind it).
4289 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);
4296 void R_UpdateAllTextureInfo(entity_render_t *ent)
4300 for (i = 0;i < ent->model->num_texturesperskin;i++)
4301 R_UpdateTextureInfo(ent, ent->model->data_textures + i);
4304 rsurfacestate_t rsurface;
4306 void R_Mesh_ResizeArrays(int newvertices)
4309 if (rsurface.array_size >= newvertices)
4311 if (rsurface.array_modelvertex3f)
4312 Mem_Free(rsurface.array_modelvertex3f);
4313 rsurface.array_size = (newvertices + 1023) & ~1023;
4314 base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
4315 rsurface.array_modelvertex3f = base + rsurface.array_size * 0;
4316 rsurface.array_modelsvector3f = base + rsurface.array_size * 3;
4317 rsurface.array_modeltvector3f = base + rsurface.array_size * 6;
4318 rsurface.array_modelnormal3f = base + rsurface.array_size * 9;
4319 rsurface.array_deformedvertex3f = base + rsurface.array_size * 12;
4320 rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
4321 rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
4322 rsurface.array_deformednormal3f = base + rsurface.array_size * 21;
4323 rsurface.array_texcoord3f = base + rsurface.array_size * 24;
4324 rsurface.array_color4f = base + rsurface.array_size * 27;
4325 rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
4328 void RSurf_CleanUp(void)
4331 if (rsurface.mode == RSURFMODE_GLSL)
4333 qglUseProgramObjectARB(0);CHECKGLERROR
4335 GL_AlphaTest(false);
4336 rsurface.mode = RSURFMODE_NONE;
4337 rsurface.uselightmaptexture = false;
4338 rsurface.texture = NULL;
4341 void RSurf_ActiveWorldEntity(void)
4343 model_t *model = r_refdef.worldmodel;
4345 if (rsurface.array_size < model->surfmesh.num_vertices)
4346 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4347 rsurface.matrix = identitymatrix;
4348 rsurface.inversematrix = identitymatrix;
4349 R_Mesh_Matrix(&identitymatrix);
4350 VectorCopy(r_view.origin, rsurface.modelorg);
4351 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
4352 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
4353 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
4354 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
4355 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
4356 rsurface.frameblend[0].frame = 0;
4357 rsurface.frameblend[0].lerp = 1;
4358 rsurface.frameblend[1].frame = 0;
4359 rsurface.frameblend[1].lerp = 0;
4360 rsurface.frameblend[2].frame = 0;
4361 rsurface.frameblend[2].lerp = 0;
4362 rsurface.frameblend[3].frame = 0;
4363 rsurface.frameblend[3].lerp = 0;
4364 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4365 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4366 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4367 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4368 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4369 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4370 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4371 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4372 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4373 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4374 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4375 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4376 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4377 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4378 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4379 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4380 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4381 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4382 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4383 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4384 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4385 rsurface.modelelement3i = model->surfmesh.data_element3i;
4386 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4387 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4388 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4389 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4390 rsurface.modelsurfaces = model->data_surfaces;
4391 rsurface.generatedvertex = false;
4392 rsurface.vertex3f = rsurface.modelvertex3f;
4393 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4394 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4395 rsurface.svector3f = rsurface.modelsvector3f;
4396 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4397 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4398 rsurface.tvector3f = rsurface.modeltvector3f;
4399 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4400 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4401 rsurface.normal3f = rsurface.modelnormal3f;
4402 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4403 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4404 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4407 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4409 model_t *model = ent->model;
4411 if (rsurface.array_size < model->surfmesh.num_vertices)
4412 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4413 rsurface.matrix = ent->matrix;
4414 rsurface.inversematrix = ent->inversematrix;
4415 R_Mesh_Matrix(&rsurface.matrix);
4416 Matrix4x4_Transform(&rsurface.inversematrix, r_view.origin, rsurface.modelorg);
4417 VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
4418 VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
4419 VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
4420 VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
4421 VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
4422 rsurface.frameblend[0] = ent->frameblend[0];
4423 rsurface.frameblend[1] = ent->frameblend[1];
4424 rsurface.frameblend[2] = ent->frameblend[2];
4425 rsurface.frameblend[3] = ent->frameblend[3];
4426 if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0))
4430 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4431 rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4432 rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4433 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4434 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
4436 else if (wantnormals)
4438 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4439 rsurface.modelsvector3f = NULL;
4440 rsurface.modeltvector3f = NULL;
4441 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4442 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
4446 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4447 rsurface.modelsvector3f = NULL;
4448 rsurface.modeltvector3f = NULL;
4449 rsurface.modelnormal3f = NULL;
4450 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL);
4452 rsurface.modelvertex3f_bufferobject = 0;
4453 rsurface.modelvertex3f_bufferoffset = 0;
4454 rsurface.modelsvector3f_bufferobject = 0;
4455 rsurface.modelsvector3f_bufferoffset = 0;
4456 rsurface.modeltvector3f_bufferobject = 0;
4457 rsurface.modeltvector3f_bufferoffset = 0;
4458 rsurface.modelnormal3f_bufferobject = 0;
4459 rsurface.modelnormal3f_bufferoffset = 0;
4460 rsurface.generatedvertex = true;
4464 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4465 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4466 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4467 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4468 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4469 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4470 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4471 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4472 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4473 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4474 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4475 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4476 rsurface.generatedvertex = false;
4478 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4479 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4480 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4481 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4482 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4483 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4484 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4485 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4486 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4487 rsurface.modelelement3i = model->surfmesh.data_element3i;
4488 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4489 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4490 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4491 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4492 rsurface.modelsurfaces = model->data_surfaces;
4493 rsurface.vertex3f = rsurface.modelvertex3f;
4494 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4495 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4496 rsurface.svector3f = rsurface.modelsvector3f;
4497 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4498 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4499 rsurface.tvector3f = rsurface.modeltvector3f;
4500 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4501 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4502 rsurface.normal3f = rsurface.modelnormal3f;
4503 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4504 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4505 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4508 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
4509 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
4512 int texturesurfaceindex;
4517 const float *v1, *in_tc;
4519 float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
4521 q3shaderinfo_deform_t *deform;
4522 // 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
4523 if (rsurface.generatedvertex)
4525 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
4526 generatenormals = true;
4527 for (i = 0;i < Q3MAXDEFORMS;i++)
4529 if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
4531 generatetangents = true;
4532 generatenormals = true;
4534 if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
4535 generatenormals = true;
4537 if (generatenormals && !rsurface.modelnormal3f)
4539 rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4540 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
4541 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
4542 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer);
4544 if (generatetangents && !rsurface.modelsvector3f)
4546 rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4547 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
4548 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
4549 rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4550 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
4551 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
4552 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);
4555 rsurface.vertex3f = rsurface.modelvertex3f;
4556 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4557 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4558 rsurface.svector3f = rsurface.modelsvector3f;
4559 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4560 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4561 rsurface.tvector3f = rsurface.modeltvector3f;
4562 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4563 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4564 rsurface.normal3f = rsurface.modelnormal3f;
4565 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4566 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4567 // if vertices are deformed (sprite flares and things in maps, possibly
4568 // water waves, bulges and other deformations), generate them into
4569 // rsurface.deform* arrays from whatever the rsurface.* arrays point to
4570 // (may be static model data or generated data for an animated model, or
4571 // the previous deform pass)
4572 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
4574 switch (deform->deform)
4577 case Q3DEFORM_PROJECTIONSHADOW:
4578 case Q3DEFORM_TEXT0:
4579 case Q3DEFORM_TEXT1:
4580 case Q3DEFORM_TEXT2:
4581 case Q3DEFORM_TEXT3:
4582 case Q3DEFORM_TEXT4:
4583 case Q3DEFORM_TEXT5:
4584 case Q3DEFORM_TEXT6:
4585 case Q3DEFORM_TEXT7:
4588 case Q3DEFORM_AUTOSPRITE:
4589 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4590 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4591 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4592 VectorNormalize(newforward);
4593 VectorNormalize(newright);
4594 VectorNormalize(newup);
4595 // make deformed versions of only the model vertices used by the specified surfaces
4596 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4598 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4599 // a single autosprite surface can contain multiple sprites...
4600 for (j = 0;j < surface->num_vertices - 3;j += 4)
4602 VectorClear(center);
4603 for (i = 0;i < 4;i++)
4604 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4605 VectorScale(center, 0.25f, center);
4606 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, forward);
4607 VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
4608 VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
4609 for (i = 0;i < 4;i++)
4611 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
4612 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4615 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);
4616 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);
4618 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4619 rsurface.vertex3f_bufferobject = 0;
4620 rsurface.vertex3f_bufferoffset = 0;
4621 rsurface.svector3f = rsurface.array_deformedsvector3f;
4622 rsurface.svector3f_bufferobject = 0;
4623 rsurface.svector3f_bufferoffset = 0;
4624 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4625 rsurface.tvector3f_bufferobject = 0;
4626 rsurface.tvector3f_bufferoffset = 0;
4627 rsurface.normal3f = rsurface.array_deformednormal3f;
4628 rsurface.normal3f_bufferobject = 0;
4629 rsurface.normal3f_bufferoffset = 0;
4631 case Q3DEFORM_AUTOSPRITE2:
4632 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4633 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4634 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4635 VectorNormalize(newforward);
4636 VectorNormalize(newright);
4637 VectorNormalize(newup);
4638 // make deformed versions of only the model vertices used by the specified surfaces
4639 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4641 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4642 const float *v1, *v2;
4652 memset(shortest, 0, sizeof(shortest));
4653 // a single autosprite surface can contain multiple sprites...
4654 for (j = 0;j < surface->num_vertices - 3;j += 4)
4656 VectorClear(center);
4657 for (i = 0;i < 4;i++)
4658 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4659 VectorScale(center, 0.25f, center);
4660 // find the two shortest edges, then use them to define the
4661 // axis vectors for rotating around the central axis
4662 for (i = 0;i < 6;i++)
4664 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
4665 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
4667 Debug_PolygonBegin(NULL, 0, false, 0);
4668 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
4669 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);
4670 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
4673 l = VectorDistance2(v1, v2);
4674 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
4676 l += (1.0f / 1024.0f);
4677 if (shortest[0].length2 > l || i == 0)
4679 shortest[1] = shortest[0];
4680 shortest[0].length2 = l;
4681 shortest[0].v1 = v1;
4682 shortest[0].v2 = v2;
4684 else if (shortest[1].length2 > l || i == 1)
4686 shortest[1].length2 = l;
4687 shortest[1].v1 = v1;
4688 shortest[1].v2 = v2;
4691 VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
4692 VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
4694 Debug_PolygonBegin(NULL, 0, false, 0);
4695 Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
4696 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);
4697 Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
4700 // this calculates the right vector from the shortest edge
4701 // and the up vector from the edge midpoints
4702 VectorSubtract(shortest[0].v1, shortest[0].v2, right);
4703 VectorNormalize(right);
4704 VectorSubtract(end, start, up);
4705 VectorNormalize(up);
4706 // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
4707 //VectorSubtract(rsurface.modelorg, center, forward);
4708 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, forward);
4709 VectorNegate(forward, forward);
4710 VectorReflect(forward, 0, up, forward);
4711 VectorNormalize(forward);
4712 CrossProduct(up, forward, newright);
4713 VectorNormalize(newright);
4715 Debug_PolygonBegin(NULL, 0, false, 0);
4716 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);
4717 Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
4718 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4722 Debug_PolygonBegin(NULL, 0, false, 0);
4723 Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
4724 Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
4725 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4728 // rotate the quad around the up axis vector, this is made
4729 // especially easy by the fact we know the quad is flat,
4730 // so we only have to subtract the center position and
4731 // measure distance along the right vector, and then
4732 // multiply that by the newright vector and add back the
4734 // we also need to subtract the old position to undo the
4735 // displacement from the center, which we do with a
4736 // DotProduct, the subtraction/addition of center is also
4737 // optimized into DotProducts here
4738 l = DotProduct(right, center);
4739 for (i = 0;i < 4;i++)
4741 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
4742 f = DotProduct(right, v1) - l;
4743 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4746 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);
4747 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);
4749 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4750 rsurface.vertex3f_bufferobject = 0;
4751 rsurface.vertex3f_bufferoffset = 0;
4752 rsurface.svector3f = rsurface.array_deformedsvector3f;
4753 rsurface.svector3f_bufferobject = 0;
4754 rsurface.svector3f_bufferoffset = 0;
4755 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4756 rsurface.tvector3f_bufferobject = 0;
4757 rsurface.tvector3f_bufferoffset = 0;
4758 rsurface.normal3f = rsurface.array_deformednormal3f;
4759 rsurface.normal3f_bufferobject = 0;
4760 rsurface.normal3f_bufferoffset = 0;
4762 case Q3DEFORM_NORMAL:
4763 // deform the normals to make reflections wavey
4764 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4766 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4767 for (j = 0;j < surface->num_vertices;j++)
4770 float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3;
4771 VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
4772 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal);
4773 normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4774 normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4775 normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4776 VectorNormalize(normal);
4778 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);
4780 rsurface.svector3f = rsurface.array_deformedsvector3f;
4781 rsurface.svector3f_bufferobject = 0;
4782 rsurface.svector3f_bufferoffset = 0;
4783 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4784 rsurface.tvector3f_bufferobject = 0;
4785 rsurface.tvector3f_bufferoffset = 0;
4786 rsurface.normal3f = rsurface.array_deformednormal3f;
4787 rsurface.normal3f_bufferobject = 0;
4788 rsurface.normal3f_bufferoffset = 0;
4791 // deform vertex array to make wavey water and flags and such
4792 waveparms[0] = deform->waveparms[0];
4793 waveparms[1] = deform->waveparms[1];
4794 waveparms[2] = deform->waveparms[2];
4795 waveparms[3] = deform->waveparms[3];
4796 // this is how a divisor of vertex influence on deformation
4797 animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
4798 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4799 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4801 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4802 for (j = 0;j < surface->num_vertices;j++)
4804 float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3;
4805 VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex);
4806 // if the wavefunc depends on time, evaluate it per-vertex
4809 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
4810 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4812 VectorMA(vertex, scale, (rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, vertex);
4815 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4816 rsurface.vertex3f_bufferobject = 0;
4817 rsurface.vertex3f_bufferoffset = 0;
4819 case Q3DEFORM_BULGE:
4820 // deform vertex array to make the surface have moving bulges
4821 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4823 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4824 for (j = 0;j < surface->num_vertices;j++)
4826 scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.time * deform->parms[2])) * deform->parms[1];
4827 VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4830 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4831 rsurface.vertex3f_bufferobject = 0;
4832 rsurface.vertex3f_bufferoffset = 0;
4835 // deform vertex array
4836 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
4837 VectorScale(deform->parms, scale, waveparms);
4838 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4840 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4841 for (j = 0;j < surface->num_vertices;j++)
4842 VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4844 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4845 rsurface.vertex3f_bufferobject = 0;
4846 rsurface.vertex3f_bufferoffset = 0;
4850 // generate texcoords based on the chosen texcoord source
4851 switch(rsurface.texture->tcgen.tcgen)
4854 case Q3TCGEN_TEXTURE:
4855 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4856 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordtexture2f_bufferobject;
4857 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
4859 case Q3TCGEN_LIGHTMAP:
4860 rsurface.texcoordtexture2f = rsurface.modeltexcoordlightmap2f;
4861 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4862 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4864 case Q3TCGEN_VECTOR:
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, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, out_tc += 2)
4870 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
4871 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
4874 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4875 rsurface.texcoordtexture2f_bufferobject = 0;
4876 rsurface.texcoordtexture2f_bufferoffset = 0;
4878 case Q3TCGEN_ENVIRONMENT:
4879 // make environment reflections using a spheremap
4880 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4882 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4883 const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
4884 const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
4885 float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
4886 for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
4888 float l, d, eyedir[3];
4889 VectorSubtract(rsurface.modelorg, vertex, eyedir);
4890 l = 0.5f / VectorLength(eyedir);
4891 d = DotProduct(normal, eyedir)*2;
4892 out_tc[0] = 0.5f + (normal[1]*d - eyedir[1])*l;
4893 out_tc[1] = 0.5f - (normal[2]*d - eyedir[2])*l;
4896 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4897 rsurface.texcoordtexture2f_bufferobject = 0;
4898 rsurface.texcoordtexture2f_bufferoffset = 0;
4901 // the only tcmod that needs software vertex processing is turbulent, so
4902 // check for it here and apply the changes if needed
4903 // and we only support that as the first one
4904 // (handling a mixture of turbulent and other tcmods would be problematic
4905 // without punting it entirely to a software path)
4906 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
4908 amplitude = rsurface.texture->tcmods[0].parms[1];
4909 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.time * rsurface.texture->tcmods[0].parms[3];
4910 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4912 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4913 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)
4915 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4916 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4919 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4920 rsurface.texcoordtexture2f_bufferobject = 0;
4921 rsurface.texcoordtexture2f_bufferoffset = 0;
4923 rsurface.texcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
4924 rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4925 rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4926 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
4929 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
4932 const msurface_t *surface = texturesurfacelist[0];
4933 const msurface_t *surface2;
4938 // TODO: lock all array ranges before render, rather than on each surface
4939 if (texturenumsurfaces == 1)
4941 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4942 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));
4944 else if (r_batchmode.integer == 2)
4946 #define MAXBATCHTRIANGLES 4096
4947 int batchtriangles = 0;
4948 int batchelements[MAXBATCHTRIANGLES*3];
4949 for (i = 0;i < texturenumsurfaces;i = j)
4951 surface = texturesurfacelist[i];
4953 if (surface->num_triangles > MAXBATCHTRIANGLES)
4955 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 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
4959 batchtriangles = surface->num_triangles;
4960 firstvertex = surface->num_firstvertex;
4961 endvertex = surface->num_firstvertex + surface->num_vertices;
4962 for (;j < texturenumsurfaces;j++)
4964 surface2 = texturesurfacelist[j];
4965 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
4967 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
4968 batchtriangles += surface2->num_triangles;
4969 firstvertex = min(firstvertex, surface2->num_firstvertex);
4970 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
4972 surface2 = texturesurfacelist[j-1];
4973 numvertices = endvertex - firstvertex;
4974 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
4977 else if (r_batchmode.integer == 1)
4979 for (i = 0;i < texturenumsurfaces;i = j)
4981 surface = texturesurfacelist[i];
4982 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
4983 if (texturesurfacelist[j] != surface2)
4985 surface2 = texturesurfacelist[j-1];
4986 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
4987 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
4988 GL_LockArrays(surface->num_firstvertex, numvertices);
4989 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
4994 for (i = 0;i < texturenumsurfaces;i++)
4996 surface = texturesurfacelist[i];
4997 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4998 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));
5003 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit, int refractiontexunit, int reflectiontexunit)
5005 int i, planeindex, vertexindex;
5009 r_waterstate_waterplane_t *p, *bestp;
5010 msurface_t *surface;
5011 if (r_waterstate.renderingscene)
5013 for (i = 0;i < texturenumsurfaces;i++)
5015 surface = texturesurfacelist[i];
5016 if (lightmaptexunit >= 0)
5017 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5018 if (deluxemaptexunit >= 0)
5019 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5020 // pick the closest matching water plane
5023 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5026 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
5028 Matrix4x4_Transform(&rsurface.matrix, v, vert);
5029 d += fabs(PlaneDiff(vert, &p->plane));
5031 if (bestd > d || !bestp)
5039 if (refractiontexunit >= 0)
5040 R_Mesh_TexBind(refractiontexunit, R_GetTexture(bestp->texture_refraction));
5041 if (reflectiontexunit >= 0)
5042 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(bestp->texture_reflection));
5046 if (refractiontexunit >= 0)
5047 R_Mesh_TexBind(refractiontexunit, R_GetTexture(r_texture_black));
5048 if (reflectiontexunit >= 0)
5049 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(r_texture_black));
5051 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5052 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));
5056 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit)
5060 const msurface_t *surface = texturesurfacelist[0];
5061 const msurface_t *surface2;
5066 // TODO: lock all array ranges before render, rather than on each surface
5067 if (texturenumsurfaces == 1)
5069 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5070 if (deluxemaptexunit >= 0)
5071 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5072 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5073 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));
5075 else if (r_batchmode.integer == 2)
5077 #define MAXBATCHTRIANGLES 4096
5078 int batchtriangles = 0;
5079 int batchelements[MAXBATCHTRIANGLES*3];
5080 for (i = 0;i < texturenumsurfaces;i = j)
5082 surface = texturesurfacelist[i];
5083 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5084 if (deluxemaptexunit >= 0)
5085 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5087 if (surface->num_triangles > MAXBATCHTRIANGLES)
5089 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));
5092 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
5093 batchtriangles = surface->num_triangles;
5094 firstvertex = surface->num_firstvertex;
5095 endvertex = surface->num_firstvertex + surface->num_vertices;
5096 for (;j < texturenumsurfaces;j++)
5098 surface2 = texturesurfacelist[j];
5099 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
5101 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
5102 batchtriangles += surface2->num_triangles;
5103 firstvertex = min(firstvertex, surface2->num_firstvertex);
5104 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
5106 surface2 = texturesurfacelist[j-1];
5107 numvertices = endvertex - firstvertex;
5108 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
5111 else if (r_batchmode.integer == 1)
5114 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
5115 for (i = 0;i < texturenumsurfaces;i = j)
5117 surface = texturesurfacelist[i];
5118 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5119 if (texturesurfacelist[j] != surface2)
5121 Con_Printf(" %i", j - i);
5124 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
5126 for (i = 0;i < texturenumsurfaces;i = j)
5128 surface = texturesurfacelist[i];
5129 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5130 if (deluxemaptexunit >= 0)
5131 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5132 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5133 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
5136 Con_Printf(" %i", j - i);
5138 surface2 = texturesurfacelist[j-1];
5139 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
5140 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
5141 GL_LockArrays(surface->num_firstvertex, numvertices);
5142 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5150 for (i = 0;i < texturenumsurfaces;i++)
5152 surface = texturesurfacelist[i];
5153 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5154 if (deluxemaptexunit >= 0)
5155 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5156 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5157 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));
5162 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5165 int texturesurfaceindex;
5166 if (r_showsurfaces.integer == 2)
5168 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5170 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5171 for (j = 0;j < surface->num_triangles;j++)
5173 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_view.colorscale;
5174 GL_Color(f, f, f, 1);
5175 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)));
5181 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5183 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5184 int k = (int)(((size_t)surface) / sizeof(msurface_t));
5185 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);
5186 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5187 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));
5192 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **texturesurfacelist)
5194 int texturesurfaceindex;
5198 if (rsurface.lightmapcolor4f)
5200 // generate color arrays for the surfaces in this list
5201 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5203 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5204 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)
5206 f = FogPoint_Model(v);
5216 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5218 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5219 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)
5221 f = FogPoint_Model(v);
5229 rsurface.lightmapcolor4f = rsurface.array_color4f;
5230 rsurface.lightmapcolor4f_bufferobject = 0;
5231 rsurface.lightmapcolor4f_bufferoffset = 0;
5234 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a)
5236 int texturesurfaceindex;
5239 if (!rsurface.lightmapcolor4f)
5241 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5243 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5244 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)
5252 rsurface.lightmapcolor4f = rsurface.array_color4f;
5253 rsurface.lightmapcolor4f_bufferobject = 0;
5254 rsurface.lightmapcolor4f_bufferoffset = 0;
5257 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5260 rsurface.lightmapcolor4f = NULL;
5261 rsurface.lightmapcolor4f_bufferobject = 0;
5262 rsurface.lightmapcolor4f_bufferoffset = 0;
5263 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5264 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5265 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5266 GL_Color(r, g, b, a);
5267 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1);
5270 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5272 // TODO: optimize applyfog && applycolor case
5273 // just apply fog if necessary, and tint the fog color array if necessary
5274 rsurface.lightmapcolor4f = NULL;
5275 rsurface.lightmapcolor4f_bufferobject = 0;
5276 rsurface.lightmapcolor4f_bufferoffset = 0;
5277 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5278 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5279 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5280 GL_Color(r, g, b, a);
5281 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5284 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5286 int texturesurfaceindex;
5290 if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
5292 // generate color arrays for the surfaces in this list
5293 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5295 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5296 for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
5298 if (surface->lightmapinfo->samples)
5300 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
5301 float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
5302 VectorScale(lm, scale, c);
5303 if (surface->lightmapinfo->styles[1] != 255)
5305 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
5307 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
5308 VectorMA(c, scale, lm, c);
5309 if (surface->lightmapinfo->styles[2] != 255)
5312 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
5313 VectorMA(c, scale, lm, c);
5314 if (surface->lightmapinfo->styles[3] != 255)
5317 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
5318 VectorMA(c, scale, lm, c);
5328 rsurface.lightmapcolor4f = rsurface.array_color4f;
5329 rsurface.lightmapcolor4f_bufferobject = 0;
5330 rsurface.lightmapcolor4f_bufferoffset = 0;
5334 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
5335 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
5336 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
5338 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5339 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5340 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5341 GL_Color(r, g, b, a);
5342 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5345 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5347 int texturesurfaceindex;
5351 vec3_t ambientcolor;
5352 vec3_t diffusecolor;
5356 VectorCopy(rsurface.modellight_lightdir, lightdir);
5357 ambientcolor[0] = rsurface.modellight_ambient[0] * r * 0.5f;
5358 ambientcolor[1] = rsurface.modellight_ambient[1] * g * 0.5f;
5359 ambientcolor[2] = rsurface.modellight_ambient[2] * b * 0.5f;
5360 diffusecolor[0] = rsurface.modellight_diffuse[0] * r * 0.5f;
5361 diffusecolor[1] = rsurface.modellight_diffuse[1] * g * 0.5f;
5362 diffusecolor[2] = rsurface.modellight_diffuse[2] * b * 0.5f;
5363 if (VectorLength2(diffusecolor) > 0)
5365 // generate color arrays for the surfaces in this list
5366 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5368 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5369 int numverts = surface->num_vertices;
5370 v = rsurface.vertex3f + 3 * surface->num_firstvertex;
5371 c2 = rsurface.normal3f + 3 * surface->num_firstvertex;
5372 c = rsurface.array_color4f + 4 * surface->num_firstvertex;
5373 // q3-style directional shading
5374 for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
5376 if ((f = DotProduct(c2, lightdir)) > 0)
5377 VectorMA(ambientcolor, f, diffusecolor, c);
5379 VectorCopy(ambientcolor, c);
5388 rsurface.lightmapcolor4f = rsurface.array_color4f;
5389 rsurface.lightmapcolor4f_bufferobject = 0;
5390 rsurface.lightmapcolor4f_bufferoffset = 0;
5394 r = ambientcolor[0];
5395 g = ambientcolor[1];
5396 b = ambientcolor[2];
5397 rsurface.lightmapcolor4f = NULL;
5398 rsurface.lightmapcolor4f_bufferobject = 0;
5399 rsurface.lightmapcolor4f_bufferoffset = 0;
5401 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5402 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5403 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5404 GL_Color(r, g, b, a);
5405 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5408 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5410 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5411 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5412 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5413 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5414 if (rsurface.mode != RSURFMODE_SHOWSURFACES)
5416 rsurface.mode = RSURFMODE_SHOWSURFACES;
5418 GL_BlendFunc(GL_ONE, GL_ZERO);
5419 R_Mesh_ColorPointer(NULL, 0, 0);
5420 R_Mesh_ResetTextureState();
5422 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5423 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5426 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
5428 // transparent sky would be ridiculous
5429 if ((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5431 if (rsurface.mode != RSURFMODE_SKY)
5433 if (rsurface.mode == RSURFMODE_GLSL)
5435 qglUseProgramObjectARB(0);CHECKGLERROR
5437 rsurface.mode = RSURFMODE_SKY;
5441 skyrendernow = false;
5443 // restore entity matrix
5444 R_Mesh_Matrix(&rsurface.matrix);
5446 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5447 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5448 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5449 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5451 // LordHavoc: HalfLife maps have freaky skypolys so don't use
5452 // skymasking on them, and Quake3 never did sky masking (unlike
5453 // software Quake and software Quake2), so disable the sky masking
5454 // in Quake3 maps as it causes problems with q3map2 sky tricks,
5455 // and skymasking also looks very bad when noclipping outside the
5456 // level, so don't use it then either.
5457 if (r_refdef.worldmodel && r_refdef.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
5459 GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
5460 R_Mesh_ColorPointer(NULL, 0, 0);
5461 R_Mesh_ResetTextureState();
5462 if (skyrendermasked)
5464 // depth-only (masking)
5465 GL_ColorMask(0,0,0,0);
5466 // just to make sure that braindead drivers don't draw
5467 // anything despite that colormask...
5468 GL_BlendFunc(GL_ZERO, GL_ONE);
5473 GL_BlendFunc(GL_ONE, GL_ZERO);
5475 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5476 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5477 if (skyrendermasked)
5478 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5482 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
5484 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
5487 if (rsurface.mode != RSURFMODE_GLSL)
5489 rsurface.mode = RSURFMODE_GLSL;
5490 R_Mesh_ResetTextureState();
5493 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
5494 R_Mesh_TexBind(0, R_GetTexture(rsurface.texture->currentskinframe->nmap));
5495 R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
5496 R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
5497 R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
5498 R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
5499 R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
5500 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5502 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5503 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5504 R_Mesh_ColorPointer(NULL, 0, 0);
5506 else if (rsurface.uselightmaptexture)
5508 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5509 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5510 R_Mesh_ColorPointer(NULL, 0, 0);
5514 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5515 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5516 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5518 R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow));
5519 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5520 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5522 if (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5524 // render background
5525 GL_BlendFunc(GL_ONE, GL_ZERO);
5527 GL_AlphaTest(false);
5529 GL_Color(1, 1, 1, 1);
5530 R_Mesh_ColorPointer(NULL, 0, 0);
5532 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
5533 if (r_glsl_permutation)
5535 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
5536 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5537 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5538 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5539 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5540 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5541 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection ? 12 : -1);
5544 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5545 GL_DepthMask(false);
5546 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5547 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5549 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5550 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5551 R_Mesh_ColorPointer(NULL, 0, 0);
5553 else if (rsurface.uselightmaptexture)
5555 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5556 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5557 R_Mesh_ColorPointer(NULL, 0, 0);
5561 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5562 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5563 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5565 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5566 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5569 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
5570 if (!r_glsl_permutation)
5573 RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0 || r_glsl_permutation->loc_LightDir >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
5574 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5575 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5576 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5577 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5578 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5579 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]);
5581 if (r_glsl_permutation->loc_Texture_Refraction >= 0)
5583 GL_BlendFunc(GL_ONE, GL_ZERO);
5585 GL_AlphaTest(false);
5588 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
5590 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5591 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);
5593 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
5597 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5598 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);
5600 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5602 if (rsurface.texture->backgroundnumskinframes && !(rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5607 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
5609 // OpenGL 1.3 path - anything not completely ancient
5610 int texturesurfaceindex;
5611 qboolean applycolor;
5615 const texturelayer_t *layer;
5616 if (rsurface.mode != RSURFMODE_MULTIPASS)
5617 rsurface.mode = RSURFMODE_MULTIPASS;
5618 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5620 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5623 int layertexrgbscale;
5624 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5626 if (layerindex == 0)
5630 GL_AlphaTest(false);
5631 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5634 GL_DepthMask(layer->depthmask);
5635 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5636 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
5638 layertexrgbscale = 4;
5639 VectorScale(layer->color, 0.25f, layercolor);
5641 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
5643 layertexrgbscale = 2;
5644 VectorScale(layer->color, 0.5f, layercolor);
5648 layertexrgbscale = 1;
5649 VectorScale(layer->color, 1.0f, layercolor);
5651 layercolor[3] = layer->color[3];
5652 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
5653 R_Mesh_ColorPointer(NULL, 0, 0);
5654 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5655 switch (layer->type)
5657 case TEXTURELAYERTYPE_LITTEXTURE:
5658 memset(&m, 0, sizeof(m));
5659 m.tex[0] = R_GetTexture(r_texture_white);
5660 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5661 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5662 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5663 m.tex[1] = R_GetTexture(layer->texture);
5664 m.texmatrix[1] = layer->texmatrix;
5665 m.texrgbscale[1] = layertexrgbscale;
5666 m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
5667 m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
5668 m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
5669 R_Mesh_TextureState(&m);
5670 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5671 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5672 else if (rsurface.uselightmaptexture)
5673 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5675 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5677 case TEXTURELAYERTYPE_TEXTURE:
5678 memset(&m, 0, sizeof(m));
5679 m.tex[0] = R_GetTexture(layer->texture);
5680 m.texmatrix[0] = layer->texmatrix;
5681 m.texrgbscale[0] = layertexrgbscale;
5682 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5683 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5684 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5685 R_Mesh_TextureState(&m);
5686 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5688 case TEXTURELAYERTYPE_FOG:
5689 memset(&m, 0, sizeof(m));
5690 m.texrgbscale[0] = layertexrgbscale;
5693 m.tex[0] = R_GetTexture(layer->texture);
5694 m.texmatrix[0] = layer->texmatrix;
5695 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5696 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5697 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5699 R_Mesh_TextureState(&m);
5700 // generate a color array for the fog pass
5701 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5702 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5706 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5707 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)
5709 f = 1 - FogPoint_Model(v);
5710 c[0] = layercolor[0];
5711 c[1] = layercolor[1];
5712 c[2] = layercolor[2];
5713 c[3] = f * layercolor[3];
5716 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5719 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5721 GL_LockArrays(0, 0);
5724 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5726 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5727 GL_AlphaTest(false);
5731 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist)
5733 // OpenGL 1.1 - crusty old voodoo path
5734 int texturesurfaceindex;
5738 const texturelayer_t *layer;
5739 if (rsurface.mode != RSURFMODE_MULTIPASS)
5740 rsurface.mode = RSURFMODE_MULTIPASS;
5741 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5743 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5745 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5747 if (layerindex == 0)
5751 GL_AlphaTest(false);
5752 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5755 GL_DepthMask(layer->depthmask);
5756 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5757 R_Mesh_ColorPointer(NULL, 0, 0);
5758 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5759 switch (layer->type)
5761 case TEXTURELAYERTYPE_LITTEXTURE:
5762 if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
5764 // two-pass lit texture with 2x rgbscale
5765 // first the lightmap pass
5766 memset(&m, 0, sizeof(m));
5767 m.tex[0] = R_GetTexture(r_texture_white);
5768 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5769 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5770 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5771 R_Mesh_TextureState(&m);
5772 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5773 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5774 else if (rsurface.uselightmaptexture)
5775 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5777 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5778 GL_LockArrays(0, 0);
5779 // then apply the texture to it
5780 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5781 memset(&m, 0, sizeof(m));
5782 m.tex[0] = R_GetTexture(layer->texture);
5783 m.texmatrix[0] = layer->texmatrix;
5784 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5785 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5786 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5787 R_Mesh_TextureState(&m);
5788 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);
5792 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
5793 memset(&m, 0, sizeof(m));
5794 m.tex[0] = R_GetTexture(layer->texture);
5795 m.texmatrix[0] = layer->texmatrix;
5796 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5797 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5798 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5799 R_Mesh_TextureState(&m);
5800 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5801 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);
5803 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);
5806 case TEXTURELAYERTYPE_TEXTURE:
5807 // singletexture unlit texture with transparency support
5808 memset(&m, 0, sizeof(m));
5809 m.tex[0] = R_GetTexture(layer->texture);
5810 m.texmatrix[0] = layer->texmatrix;
5811 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5812 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5813 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5814 R_Mesh_TextureState(&m);
5815 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);
5817 case TEXTURELAYERTYPE_FOG:
5818 // singletexture fogging
5819 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5822 memset(&m, 0, sizeof(m));
5823 m.tex[0] = R_GetTexture(layer->texture);
5824 m.texmatrix[0] = layer->texmatrix;
5825 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5826 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5827 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5828 R_Mesh_TextureState(&m);
5831 R_Mesh_ResetTextureState();
5832 // generate a color array for the fog pass
5833 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5837 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5838 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)
5840 f = 1 - FogPoint_Model(v);
5841 c[0] = layer->color[0];
5842 c[1] = layer->color[1];
5843 c[2] = layer->color[2];
5844 c[3] = f * layer->color[3];
5847 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5850 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5852 GL_LockArrays(0, 0);
5855 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5857 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5858 GL_AlphaTest(false);
5862 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly)
5864 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW)
5866 rsurface.rtlight = NULL;
5870 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
5872 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
5874 if (rsurface.mode != RSURFMODE_MULTIPASS)
5875 rsurface.mode = RSURFMODE_MULTIPASS;
5876 if (r_depthfirst.integer == 3)
5878 int i = (int)(texturesurfacelist[0] - rsurface.modelsurfaces);
5879 if (!r_view.showdebug)
5880 GL_Color(0, 0, 0, 1);
5882 GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1);
5886 GL_ColorMask(0,0,0,0);
5889 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5890 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5891 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5893 GL_BlendFunc(GL_ONE, GL_ZERO);
5895 GL_AlphaTest(false);
5896 R_Mesh_ColorPointer(NULL, 0, 0);
5897 R_Mesh_ResetTextureState();
5898 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5899 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5900 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5902 else if (r_depthfirst.integer == 3)
5904 else if (!r_view.showdebug && (r_showsurfaces.integer || gl_lightmaps.integer))
5906 GL_Color(0, 0, 0, 1);
5907 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5909 else if (r_showsurfaces.integer)
5911 if (rsurface.mode != RSURFMODE_MULTIPASS)
5912 rsurface.mode = RSURFMODE_MULTIPASS;
5913 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5914 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5916 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5917 GL_BlendFunc(GL_ONE, GL_ZERO);
5918 GL_DepthMask(writedepth);
5920 GL_AlphaTest(false);
5921 R_Mesh_ColorPointer(NULL, 0, 0);
5922 R_Mesh_ResetTextureState();
5923 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5924 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5926 else if (gl_lightmaps.integer)
5929 if (rsurface.mode != RSURFMODE_MULTIPASS)
5930 rsurface.mode = RSURFMODE_MULTIPASS;
5931 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5933 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5934 GL_BlendFunc(GL_ONE, GL_ZERO);
5935 GL_DepthMask(writedepth);
5937 GL_AlphaTest(false);
5938 R_Mesh_ColorPointer(NULL, 0, 0);
5939 memset(&m, 0, sizeof(m));
5940 m.tex[0] = R_GetTexture(r_texture_white);
5941 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5942 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5943 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5944 R_Mesh_TextureState(&m);
5945 RSurf_PrepareVerticesForBatch(rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, false, texturenumsurfaces, texturesurfacelist);
5946 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5947 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5948 else if (rsurface.uselightmaptexture)
5949 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5951 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5953 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
5954 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
5955 else if (rsurface.texture->currentnumlayers)
5957 // write depth for anything we skipped on the depth-only pass earlier
5958 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5960 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5961 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5962 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5963 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5964 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5965 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
5966 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5967 if (r_glsl.integer && gl_support_fragment_shader)
5968 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
5969 else if (gl_combine.integer && r_textureunits.integer >= 2)
5970 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist);
5972 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist);
5975 GL_LockArrays(0, 0);
5978 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5981 int texturenumsurfaces, endsurface;
5983 msurface_t *surface;
5984 msurface_t *texturesurfacelist[1024];
5986 // if the model is static it doesn't matter what value we give for
5987 // wantnormals and wanttangents, so this logic uses only rules applicable
5988 // to a model, knowing that they are meaningless otherwise
5989 if (ent == r_refdef.worldentity)
5990 RSurf_ActiveWorldEntity();
5991 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
5992 RSurf_ActiveModelEntity(ent, false, false);
5994 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
5996 for (i = 0;i < numsurfaces;i = j)
5999 surface = rsurface.modelsurfaces + surfacelist[i];
6000 texture = surface->texture;
6001 R_UpdateTextureInfo(ent, texture);
6002 rsurface.texture = texture->currentframe;
6003 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
6004 // scan ahead until we find a different texture
6005 endsurface = min(i + 1024, numsurfaces);
6006 texturenumsurfaces = 0;
6007 texturesurfacelist[texturenumsurfaces++] = surface;
6008 for (;j < endsurface;j++)
6010 surface = rsurface.modelsurfaces + surfacelist[j];
6011 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
6013 texturesurfacelist[texturenumsurfaces++] = surface;
6015 // render the range of surfaces
6016 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist, true, false);
6022 void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
6025 vec3_t tempcenter, center;
6027 // if we're rendering water textures (extra scene renders), use a separate loop to avoid burdening the main one
6030 for (i = 0;i < numsurfaces;i++)
6031 if (surfacelist[i]->texture->currentframe->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
6032 R_Water_AddWaterPlane(surfacelist[i]);
6035 // break the surface list down into batches by texture and use of lightmapping
6036 for (i = 0;i < numsurfaces;i = j)
6039 // texture is the base texture pointer, rsurface.texture is the
6040 // current frame/skin the texture is directing us to use (for example
6041 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
6042 // use skin 1 instead)
6043 texture = surfacelist[i]->texture;
6044 rsurface.texture = texture->currentframe;
6045 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
6046 if (!(rsurface.texture->currentmaterialflags & flagsmask))
6048 // if this texture is not the kind we want, skip ahead to the next one
6049 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
6053 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
6055 // transparent surfaces get pushed off into the transparent queue
6056 const msurface_t *surface = surfacelist[i];
6059 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
6060 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
6061 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
6062 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
6063 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.modelsurfaces, rsurface.rtlight);
6067 // simply scan ahead until we find a different texture or lightmap state
6068 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
6070 // render the range of surfaces
6071 R_DrawTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly);
6076 float locboxvertex3f[6*4*3] =
6078 1,0,1, 1,0,0, 1,1,0, 1,1,1,
6079 0,1,1, 0,1,0, 0,0,0, 0,0,1,
6080 1,1,1, 1,1,0, 0,1,0, 0,1,1,
6081 0,0,1, 0,0,0, 1,0,0, 1,0,1,
6082 0,0,1, 1,0,1, 1,1,1, 0,1,1,
6083 1,0,0, 0,0,0, 0,1,0, 1,1,0
6086 int locboxelement3i[6*2*3] =
6096 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6099 cl_locnode_t *loc = (cl_locnode_t *)ent;
6101 float vertex3f[6*4*3];
6103 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6104 GL_DepthMask(false);
6105 GL_DepthRange(0, 1);
6106 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6108 GL_CullFace(GL_NONE);
6109 R_Mesh_Matrix(&identitymatrix);
6111 R_Mesh_VertexPointer(vertex3f, 0, 0);
6112 R_Mesh_ColorPointer(NULL, 0, 0);
6113 R_Mesh_ResetTextureState();
6116 GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_view.colorscale,
6117 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_view.colorscale,
6118 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_view.colorscale,
6119 surfacelist[0] < 0 ? 0.5f : 0.125f);
6121 if (VectorCompare(loc->mins, loc->maxs))
6123 VectorSet(size, 2, 2, 2);
6124 VectorMA(loc->mins, -0.5f, size, mins);
6128 VectorCopy(loc->mins, mins);
6129 VectorSubtract(loc->maxs, loc->mins, size);
6132 for (i = 0;i < 6*4*3;)
6133 for (j = 0;j < 3;j++, i++)
6134 vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
6136 R_Mesh_Draw(0, 6*4, 6*2, locboxelement3i, 0, 0);
6139 void R_DrawLocs(void)
6142 cl_locnode_t *loc, *nearestloc;
6144 nearestloc = CL_Locs_FindNearest(cl.movement_origin);
6145 for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
6147 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
6148 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
6152 void R_DrawDebugModel(entity_render_t *ent)
6154 int i, j, k, l, flagsmask;
6155 const int *elements;
6157 msurface_t *surface;
6158 model_t *model = ent->model;
6161 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WATER | MATERIALFLAG_WALL;
6163 R_Mesh_ColorPointer(NULL, 0, 0);
6164 R_Mesh_ResetTextureState();
6165 GL_DepthRange(0, 1);
6166 GL_DepthTest(!r_showdisabledepthtest.integer);
6167 GL_DepthMask(false);
6168 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6170 if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
6172 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
6173 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
6175 if (brush->colbrushf && brush->colbrushf->numtriangles)
6177 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
6178 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);
6179 R_Mesh_Draw(0, brush->colbrushf->numpoints, brush->colbrushf->numtriangles, brush->colbrushf->elements, 0, 0);
6182 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
6184 if (surface->num_collisiontriangles)
6186 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
6187 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);
6188 R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i, 0, 0);
6193 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6195 if (r_showtris.integer || r_shownormals.integer)
6197 if (r_showdisabledepthtest.integer)
6199 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6200 GL_DepthMask(false);
6204 GL_BlendFunc(GL_ONE, GL_ZERO);
6207 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
6209 if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
6211 rsurface.texture = surface->texture->currentframe;
6212 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
6214 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
6215 if (r_showtris.value > 0)
6217 if (!rsurface.texture->currentlayers->depthmask)
6218 GL_Color(r_view.colorscale, 0, 0, r_showtris.value);
6219 else if (ent == r_refdef.worldentity)
6220 GL_Color(r_view.colorscale, r_view.colorscale, r_view.colorscale, r_showtris.value);
6222 GL_Color(0, r_view.colorscale, 0, r_showtris.value);
6223 elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
6226 for (k = 0;k < surface->num_triangles;k++, elements += 3)
6228 #define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
6229 GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
6230 GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
6231 GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
6236 if (r_shownormals.value > 0)
6239 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6241 VectorCopy(rsurface.vertex3f + l * 3, v);
6242 GL_Color(r_view.colorscale, 0, 0, 1);
6243 qglVertex3f(v[0], v[1], v[2]);
6244 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
6245 GL_Color(r_view.colorscale, 1, 1, 1);
6246 qglVertex3f(v[0], v[1], v[2]);
6251 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6253 VectorCopy(rsurface.vertex3f + l * 3, v);
6254 GL_Color(0, r_view.colorscale, 0, 1);
6255 qglVertex3f(v[0], v[1], v[2]);
6256 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
6257 GL_Color(r_view.colorscale, 1, 1, 1);
6258 qglVertex3f(v[0], v[1], v[2]);
6263 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6265 VectorCopy(rsurface.vertex3f + l * 3, v);
6266 GL_Color(0, 0, r_view.colorscale, 1);
6267 qglVertex3f(v[0], v[1], v[2]);
6268 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
6269 GL_Color(r_view.colorscale, 1, 1, 1);
6270 qglVertex3f(v[0], v[1], v[2]);
6277 rsurface.texture = NULL;
6281 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
6282 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6284 int i, j, endj, f, flagsmask;
6285 msurface_t *surface;
6287 model_t *model = r_refdef.worldmodel;
6288 const int maxsurfacelist = 1024;
6289 int numsurfacelist = 0;
6290 msurface_t *surfacelist[1024];
6294 RSurf_ActiveWorldEntity();
6296 // update light styles on this submodel
6297 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6299 model_brush_lightstyleinfo_t *style;
6300 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6302 if (style->value != r_refdef.lightstylevalue[style->style])
6304 msurface_t *surfaces = model->data_surfaces;
6305 int *list = style->surfacelist;
6306 style->value = r_refdef.lightstylevalue[style->style];
6307 for (j = 0;j < style->numsurfaces;j++)
6308 surfaces[list[j]].cached_dlight = true;
6313 R_UpdateAllTextureInfo(r_refdef.worldentity);
6314 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6318 R_DrawDebugModel(r_refdef.worldentity);
6324 rsurface.uselightmaptexture = false;
6325 rsurface.texture = NULL;
6327 j = model->firstmodelsurface;
6328 endj = j + model->nummodelsurfaces;
6331 // quickly skip over non-visible surfaces
6332 for (;j < endj && !r_viewcache.world_surfacevisible[j];j++)
6334 // quickly iterate over visible surfaces
6335 for (;j < endj && r_viewcache.world_surfacevisible[j];j++)
6337 // process this surface
6338 surface = model->data_surfaces + j;
6339 // if this surface fits the criteria, add it to the list
6340 if (surface->num_triangles)
6342 // if lightmap parameters changed, rebuild lightmap texture
6343 if (surface->cached_dlight)
6344 R_BuildLightMap(r_refdef.worldentity, surface);
6345 // add face to draw list
6346 surfacelist[numsurfacelist++] = surface;
6347 r_refdef.stats.world_triangles += surface->num_triangles;
6348 if (numsurfacelist >= maxsurfacelist)
6350 r_refdef.stats.world_surfaces += numsurfacelist;
6351 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6357 r_refdef.stats.world_surfaces += numsurfacelist;
6359 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6363 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6365 int i, j, f, flagsmask;
6366 msurface_t *surface, *endsurface;
6368 model_t *model = ent->model;
6369 const int maxsurfacelist = 1024;
6370 int numsurfacelist = 0;
6371 msurface_t *surfacelist[1024];
6375 // if the model is static it doesn't matter what value we give for
6376 // wantnormals and wanttangents, so this logic uses only rules applicable
6377 // to a model, knowing that they are meaningless otherwise
6378 if (ent == r_refdef.worldentity)
6379 RSurf_ActiveWorldEntity();
6380 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
6381 RSurf_ActiveModelEntity(ent, false, false);
6383 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader && !depthonly);
6385 // update light styles
6386 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6388 model_brush_lightstyleinfo_t *style;
6389 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6391 if (style->value != r_refdef.lightstylevalue[style->style])
6393 msurface_t *surfaces = model->data_surfaces;
6394 int *list = style->surfacelist;
6395 style->value = r_refdef.lightstylevalue[style->style];
6396 for (j = 0;j < style->numsurfaces;j++)
6397 surfaces[list[j]].cached_dlight = true;
6402 R_UpdateAllTextureInfo(ent);
6403 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6407 R_DrawDebugModel(ent);
6413 rsurface.uselightmaptexture = false;
6414 rsurface.texture = NULL;
6416 surface = model->data_surfaces + model->firstmodelsurface;
6417 endsurface = surface + model->nummodelsurfaces;
6418 for (;surface < endsurface;surface++)
6420 // if this surface fits the criteria, add it to the list
6421 if (surface->num_triangles)
6423 // if lightmap parameters changed, rebuild lightmap texture
6424 if (surface->cached_dlight)
6425 R_BuildLightMap(ent, surface);
6426 // add face to draw list
6427 surfacelist[numsurfacelist++] = surface;
6428 r_refdef.stats.entities_triangles += surface->num_triangles;
6429 if (numsurfacelist >= maxsurfacelist)
6431 r_refdef.stats.entities_surfaces += numsurfacelist;
6432 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6437 r_refdef.stats.entities_surfaces += numsurfacelist;
6439 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);