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;
252 float FogPoint_World(const vec3_t p)
254 unsigned int fogmasktableindex = (unsigned int)(VectorDistance((p), r_view.origin) * r_refdef.fogmasktabledistmultiplier);
255 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
258 float FogPoint_Model(const vec3_t p)
260 unsigned int fogmasktableindex = (unsigned int)(VectorDistance((p), rsurface.modelorg) * r_refdef.fogmasktabledistmultiplier);
261 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
264 static void R_BuildBlankTextures(void)
266 unsigned char data[4];
267 data[2] = 128; // normal X
268 data[1] = 128; // normal Y
269 data[0] = 255; // normal Z
270 data[3] = 128; // height
271 r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
276 r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
281 r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
286 r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
289 static void R_BuildNoTexture(void)
292 unsigned char pix[16][16][4];
293 // this makes a light grey/dark grey checkerboard texture
294 for (y = 0;y < 16;y++)
296 for (x = 0;x < 16;x++)
298 if ((y < 8) ^ (x < 8))
314 r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, NULL);
317 static void R_BuildWhiteCube(void)
319 unsigned char data[6*1*1*4];
320 memset(data, 255, sizeof(data));
321 r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
324 static void R_BuildNormalizationCube(void)
328 vec_t s, t, intensity;
330 unsigned char data[6][NORMSIZE][NORMSIZE][4];
331 for (side = 0;side < 6;side++)
333 for (y = 0;y < NORMSIZE;y++)
335 for (x = 0;x < NORMSIZE;x++)
337 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
338 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
373 intensity = 127.0f / sqrt(DotProduct(v, v));
374 data[side][y][x][2] = (unsigned char)(128.0f + intensity * v[0]);
375 data[side][y][x][1] = (unsigned char)(128.0f + intensity * v[1]);
376 data[side][y][x][0] = (unsigned char)(128.0f + intensity * v[2]);
377 data[side][y][x][3] = 255;
381 r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
384 static void R_BuildFogTexture(void)
388 unsigned char data1[FOGWIDTH][4];
389 //unsigned char data2[FOGWIDTH][4];
390 for (x = 0;x < FOGWIDTH;x++)
392 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
397 //data2[x][0] = 255 - b;
398 //data2[x][1] = 255 - b;
399 //data2[x][2] = 255 - b;
402 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);
403 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
406 static const char *builtinshaderstring =
407 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
408 "// written by Forest 'LordHavoc' Hale\n"
410 "// common definitions between vertex shader and fragment shader:\n"
412 "#ifdef __GLSL_CG_DATA_TYPES\n"
413 "# define myhalf half\n"
414 "# define myhvec2 hvec2\n"
415 "# define myhvec3 hvec3\n"
416 "# define myhvec4 hvec4\n"
418 "# define myhalf float\n"
419 "# define myhvec2 vec2\n"
420 "# define myhvec3 vec3\n"
421 "# define myhvec4 vec4\n"
424 "varying vec2 TexCoord;\n"
425 "varying vec2 TexCoordLightmap;\n"
427 "//#ifdef MODE_LIGHTSOURCE\n"
428 "varying vec3 CubeVector;\n"
431 "//#ifdef MODE_LIGHTSOURCE\n"
432 "varying vec3 LightVector;\n"
434 "//# ifdef MODE_LIGHTDIRECTION\n"
435 "//varying vec3 LightVector;\n"
439 "varying vec3 EyeVector;\n"
441 "varying vec3 EyeVectorModelSpace;\n"
444 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
445 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
446 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
448 "//#ifdef MODE_WATER\n"
449 "varying vec4 ModelViewProjectionPosition;\n"
451 "//# ifdef MODE_REFRACTION\n"
452 "//varying vec4 ModelViewProjectionPosition;\n"
454 "//# ifdef USEREFLECTION\n"
455 "//varying vec4 ModelViewProjectionPosition;\n"
464 "// vertex shader specific:\n"
465 "#ifdef VERTEX_SHADER\n"
467 "uniform vec3 LightPosition;\n"
468 "uniform vec3 EyePosition;\n"
469 "uniform vec3 LightDir;\n"
471 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)\n"
475 " gl_FrontColor = gl_Color;\n"
476 " // copy the surface texcoord\n"
477 " TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);\n"
478 "#ifndef MODE_LIGHTSOURCE\n"
479 "# ifndef MODE_LIGHTDIRECTION\n"
480 " TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
484 "#ifdef MODE_LIGHTSOURCE\n"
485 " // transform vertex position into light attenuation/cubemap space\n"
486 " // (-1 to +1 across the light box)\n"
487 " CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n"
489 " // transform unnormalized light direction into tangent space\n"
490 " // (we use unnormalized to ensure that it interpolates correctly and then\n"
491 " // normalize it per pixel)\n"
492 " vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
493 " LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
494 " LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
495 " LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
498 "#ifdef MODE_LIGHTDIRECTION\n"
499 " LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
500 " LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
501 " LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
504 " // transform unnormalized eye direction into tangent space\n"
506 " vec3 EyeVectorModelSpace;\n"
508 " EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
509 " EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
510 " EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
511 " EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
513 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
514 " VectorS = gl_MultiTexCoord1.xyz;\n"
515 " VectorT = gl_MultiTexCoord2.xyz;\n"
516 " VectorR = gl_MultiTexCoord3.xyz;\n"
519 "//#if defined(MODE_WATER) || defined(MODE_REFRACTION) || defined(USEREFLECTION)\n"
520 "// ModelViewProjectionPosition = gl_Vertex * gl_ModelViewProjectionMatrix;\n"
521 "// //ModelViewProjectionPosition_svector = (gl_Vertex + vec4(gl_MultiTexCoord1.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
522 "// //ModelViewProjectionPosition_tvector = (gl_Vertex + vec4(gl_MultiTexCoord2.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
525 "// transform vertex to camera space, using ftransform to match non-VS\n"
527 " gl_Position = ftransform();\n"
529 "#ifdef MODE_WATER\n"
530 " ModelViewProjectionPosition = gl_Position;\n"
532 "#ifdef MODE_REFRACTION\n"
533 " ModelViewProjectionPosition = gl_Position;\n"
535 "#ifdef USEREFLECTION\n"
536 " ModelViewProjectionPosition = gl_Position;\n"
540 "#endif // VERTEX_SHADER\n"
545 "// fragment shader specific:\n"
546 "#ifdef FRAGMENT_SHADER\n"
548 "// 13 textures, we can only use up to 16 on DX9-class hardware\n"
549 "uniform sampler2D Texture_Normal;\n"
550 "uniform sampler2D Texture_Color;\n"
551 "uniform sampler2D Texture_Gloss;\n"
552 "uniform samplerCube Texture_Cube;\n"
553 "uniform sampler2D Texture_Attenuation;\n"
554 "uniform sampler2D Texture_FogMask;\n"
555 "uniform sampler2D Texture_Pants;\n"
556 "uniform sampler2D Texture_Shirt;\n"
557 "uniform sampler2D Texture_Lightmap;\n"
558 "uniform sampler2D Texture_Deluxemap;\n"
559 "uniform sampler2D Texture_Glow;\n"
560 "uniform sampler2D Texture_Reflection;\n"
561 "uniform sampler2D Texture_Refraction;\n"
563 "uniform myhvec3 LightColor;\n"
564 "uniform myhvec3 AmbientColor;\n"
565 "uniform myhvec3 DiffuseColor;\n"
566 "uniform myhvec3 SpecularColor;\n"
567 "uniform myhvec3 Color_Pants;\n"
568 "uniform myhvec3 Color_Shirt;\n"
569 "uniform myhvec3 FogColor;\n"
571 "//#ifdef MODE_WATER\n"
572 "uniform vec4 DistortScaleRefractReflect;\n"
573 "uniform vec4 ScreenScaleRefractReflect;\n"
574 "uniform vec4 ScreenCenterRefractReflect;\n"
575 "uniform myhvec4 RefractColor;\n"
576 "uniform myhvec4 ReflectColor;\n"
577 "uniform myhalf ReflectFactor;\n"
578 "uniform myhalf ReflectOffset;\n"
580 "//# ifdef MODE_REFRACTION\n"
581 "//uniform vec4 DistortScaleRefractReflect;\n"
582 "//uniform vec4 ScreenScaleRefractReflect;\n"
583 "//uniform vec4 ScreenCenterRefractReflect;\n"
584 "//uniform myhvec4 RefractColor;\n"
585 "//# ifdef USEREFLECTION\n"
586 "//uniform myhvec4 ReflectColor;\n"
589 "//# ifdef USEREFLECTION\n"
590 "//uniform vec4 DistortScaleRefractReflect;\n"
591 "//uniform vec4 ScreenScaleRefractReflect;\n"
592 "//uniform vec4 ScreenCenterRefractReflect;\n"
593 "//uniform myhvec4 ReflectColor;\n"
598 "uniform myhalf GlowScale;\n"
599 "uniform myhalf SceneBrightness;\n"
600 "#ifdef USECONTRASTBOOST\n"
601 "uniform myhalf ContrastBoostCoeff;\n"
604 "uniform float OffsetMapping_Scale;\n"
605 "uniform float OffsetMapping_Bias;\n"
606 "uniform float FogRangeRecip;\n"
608 "uniform myhalf AmbientScale;\n"
609 "uniform myhalf DiffuseScale;\n"
610 "uniform myhalf SpecularScale;\n"
611 "uniform myhalf SpecularPower;\n"
613 "#ifdef USEOFFSETMAPPING\n"
614 "vec2 OffsetMapping(vec2 TexCoord)\n"
616 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
617 " // 14 sample relief mapping: linear search and then binary search\n"
618 " // this basically steps forward a small amount repeatedly until it finds\n"
619 " // itself inside solid, then jitters forward and back using decreasing\n"
620 " // amounts to find the impact\n"
621 " //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
622 " //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
623 " vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
624 " vec3 RT = vec3(TexCoord, 1);\n"
625 " OffsetVector *= 0.1;\n"
626 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
627 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
628 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
629 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
630 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
631 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
632 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
633 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
634 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
635 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) - 0.5);\n"
636 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5 - 0.25);\n"
637 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25 - 0.125);\n"
638 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125 - 0.0625);\n"
639 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
642 " // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
643 " // this basically moves forward the full distance, and then backs up based\n"
644 " // on height of samples\n"
645 " //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
646 " //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
647 " vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
648 " TexCoord += OffsetVector;\n"
649 " OffsetVector *= 0.333;\n"
650 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
651 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
652 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
653 " return TexCoord;\n"
656 "#endif // USEOFFSETMAPPING\n"
658 "#ifdef MODE_WATER\n"
663 "#ifdef USEOFFSETMAPPING\n"
664 " // apply offsetmapping\n"
665 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
666 "#define TexCoord TexCoordOffset\n"
669 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
670 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
671 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
672 " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 5.0) * ReflectFactor + ReflectOffset;\n"
673 " gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
676 "#else // MODE_WATER\n"
677 "#ifdef MODE_REFRACTION\n"
679 "// refraction pass\n"
682 "#ifdef USEOFFSETMAPPING\n"
683 " // apply offsetmapping\n"
684 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
685 "#define TexCoord TexCoordOffset\n"
688 " vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
689 " //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
690 " vec2 ScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
691 " gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
694 "#else // MODE_REFRACTION\n"
697 "#ifdef USEOFFSETMAPPING\n"
698 " // apply offsetmapping\n"
699 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
700 "#define TexCoord TexCoordOffset\n"
703 " // combine the diffuse textures (base, pants, shirt)\n"
704 " myhvec4 color = myhvec4(texture2D(Texture_Color, TexCoord));\n"
705 "#ifdef USECOLORMAPPING\n"
706 " color.rgb += myhvec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhvec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
712 "#ifdef MODE_LIGHTSOURCE\n"
715 " // calculate surface normal, light normal, and specular normal\n"
716 " // compute color intensity for the two textures (colormap and glossmap)\n"
717 " // scale by light color and attenuation as efficiently as possible\n"
718 " // (do as much scalar math as possible rather than vector math)\n"
719 "# ifdef USESPECULAR\n"
720 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
721 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
722 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
724 " // calculate directional shading\n"
725 " 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"
727 "# ifdef USEDIFFUSE\n"
728 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
729 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
731 " // calculate directional shading\n"
732 " 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"
734 " // calculate directionless shading\n"
735 " color.rgb = color.rgb * LightColor * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
739 "# ifdef USECUBEFILTER\n"
740 " // apply light cubemap filter\n"
741 " //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
742 " color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
744 " color *= myhvec4(gl_Color);\n"
745 "#endif // MODE_LIGHTSOURCE\n"
750 "#ifdef MODE_LIGHTDIRECTION\n"
751 " // directional model lighting\n"
752 "# ifdef USESPECULAR\n"
753 " // get the surface normal and light normal\n"
754 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
755 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
757 " // calculate directional shading\n"
758 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
759 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
760 " color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
762 "# ifdef USEDIFFUSE\n"
763 " // get the surface normal and light normal\n"
764 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
765 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
767 " // calculate directional shading\n"
768 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
770 " color.rgb *= AmbientColor;\n"
774 " color *= myhvec4(gl_Color);\n"
775 "#endif // MODE_LIGHTDIRECTION\n"
780 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
781 " // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
783 " // get the surface normal and light normal\n"
784 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
786 " myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5);\n"
787 " myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, myhvec3(VectorS)), dot(diffusenormal_modelspace, myhvec3(VectorT)), dot(diffusenormal_modelspace, myhvec3(VectorR))));\n"
788 " // calculate directional shading\n"
789 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
790 "# ifdef USESPECULAR\n"
791 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
792 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
795 " // apply lightmap color\n"
796 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
797 " color.a *= myhalf(gl_Color.a);\n"
798 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
803 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
804 " // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
806 " // get the surface normal and light normal\n"
807 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
809 " myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5));\n"
810 " // calculate directional shading\n"
811 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
812 "# ifdef USESPECULAR\n"
813 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
814 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
817 " // apply lightmap color\n"
818 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
819 " color.a *= myhalf(gl_Color.a);\n"
820 "#endif // MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
825 "#ifdef MODE_LIGHTMAP\n"
826 " // apply lightmap color\n"
827 " color *= myhvec4(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec4(gl_Color) * myhvec4(myhvec3(DiffuseScale), 1) + myhvec4(myhvec3(AmbientScale), 0);\n"
828 "#endif // MODE_LIGHTMAP\n"
838 " color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
841 "#ifndef MODE_LIGHTSOURCE\n"
842 "# ifdef USEREFLECTION\n"
843 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
844 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
845 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
846 " color.rgb = mix(color.rgb, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor.rgb, ReflectColor.a);\n"
850 "#ifdef USECONTRASTBOOST\n"
851 " color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
854 " color.rgb *= SceneBrightness;\n"
858 " color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
861 " gl_FragColor = vec4(color);\n"
863 "#endif // MODE_REFRACTION\n"
864 "#endif // MODE_WATER\n"
866 "#endif // FRAGMENT_SHADER\n"
869 #define SHADERPERMUTATION_COLORMAPPING (1<<0) // indicates this is a colormapped skin
870 #define SHADERPERMUTATION_CONTRASTBOOST (1<<1) // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma)
871 #define SHADERPERMUTATION_FOG (1<<2) // tint the color by fog color or black if using additive blend mode
872 #define SHADERPERMUTATION_CUBEFILTER (1<<3) // (lightsource) use cubemap light filter
873 #define SHADERPERMUTATION_GLOW (1<<4) // (lightmap) blend in an additive glow texture
874 #define SHADERPERMUTATION_DIFFUSE (1<<5) // (lightsource) whether to use directional shading
875 #define SHADERPERMUTATION_SPECULAR (1<<6) // (lightsource or deluxemapping) render specular effects
876 #define SHADERPERMUTATION_REFLECTION (1<<7) // normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
877 #define SHADERPERMUTATION_OFFSETMAPPING (1<<8) // adjust texcoords to roughly simulate a displacement mapped surface
878 #define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<9) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
879 #define SHADERPERMUTATION_MODEBASE (1<<10) // multiplier for the SHADERMODE_ values to get a valid index
881 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
882 const char *shaderpermutationinfo[][2] =
884 {"#define USECOLORMAPPING\n", " colormapping"},
885 {"#define USECONTRASTBOOST\n", " contrastboost"},
886 {"#define USEFOG\n", " fog"},
887 {"#define USECUBEFILTER\n", " cubefilter"},
888 {"#define USEGLOW\n", " glow"},
889 {"#define USEDIFFUSE\n", " diffuse"},
890 {"#define USESPECULAR\n", " specular"},
891 {"#define USEREFLECTION\n", " reflection"},
892 {"#define USEOFFSETMAPPING\n", " offsetmapping"},
893 {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
897 // this enum is multiplied by SHADERPERMUTATION_MODEBASE
898 typedef enum shadermode_e
900 SHADERMODE_LIGHTMAP, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
901 SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, // (lightmap) use directional pixel shading from texture containing modelspace light directions (deluxemap)
902 SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, // (lightmap) use directional pixel shading from texture containing tangentspace light directions (deluxemap)
903 SHADERMODE_LIGHTDIRECTION, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
904 SHADERMODE_LIGHTSOURCE, // (lightsource) use directional pixel shading from light source (rtlight)
905 SHADERMODE_REFRACTION, // refract background (the material is rendered normally after this pass)
906 SHADERMODE_WATER, // refract background and reflection (the material is rendered normally after this pass)
911 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
912 const char *shadermodeinfo[][2] =
914 {"#define MODE_LIGHTMAP\n", " lightmap"},
915 {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
916 {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
917 {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
918 {"#define MODE_LIGHTSOURCE\n", " lightsource"},
919 {"#define MODE_REFRACTION\n", " refraction"},
920 {"#define MODE_WATER\n", " water"},
924 #define SHADERPERMUTATION_INDICES (SHADERPERMUTATION_MODEBASE * SHADERMODE_COUNT)
926 typedef struct r_glsl_permutation_s
928 // indicates if we have tried compiling this permutation already
930 // 0 if compilation failed
932 // locations of detected uniforms in program object, or -1 if not found
933 int loc_Texture_Normal;
934 int loc_Texture_Color;
935 int loc_Texture_Gloss;
936 int loc_Texture_Cube;
937 int loc_Texture_Attenuation;
938 int loc_Texture_FogMask;
939 int loc_Texture_Pants;
940 int loc_Texture_Shirt;
941 int loc_Texture_Lightmap;
942 int loc_Texture_Deluxemap;
943 int loc_Texture_Glow;
944 int loc_Texture_Refraction;
945 int loc_Texture_Reflection;
947 int loc_LightPosition;
952 int loc_FogRangeRecip;
953 int loc_AmbientScale;
954 int loc_DiffuseScale;
955 int loc_SpecularScale;
956 int loc_SpecularPower;
958 int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost
959 int loc_OffsetMapping_Scale;
960 int loc_AmbientColor;
961 int loc_DiffuseColor;
962 int loc_SpecularColor;
964 int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost
965 int loc_DistortScaleRefractReflect;
966 int loc_ScreenScaleRefractReflect;
967 int loc_ScreenCenterRefractReflect;
968 int loc_RefractColor;
969 int loc_ReflectColor;
970 int loc_ReflectFactor;
971 int loc_ReflectOffset;
973 r_glsl_permutation_t;
975 // information about each possible shader permutation
976 r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_INDICES];
977 // currently selected permutation
978 r_glsl_permutation_t *r_glsl_permutation;
980 // these are additional flags used only by R_GLSL_CompilePermutation
981 #define SHADERTYPE_USES_VERTEXSHADER (1<<0)
982 #define SHADERTYPE_USES_GEOMETRYSHADER (1<<1)
983 #define SHADERTYPE_USES_FRAGMENTSHADER (1<<2)
985 static void R_GLSL_CompilePermutation(const char *filename, int permutation, int shadertype)
988 qboolean shaderfound;
989 r_glsl_permutation_t *p = r_glsl_permutations + permutation;
990 int vertstrings_count;
991 int geomstrings_count;
992 int fragstrings_count;
994 const char *vertstrings_list[32+1];
995 const char *geomstrings_list[32+1];
996 const char *fragstrings_list[32+1];
997 char permutationname[256];
1002 vertstrings_list[0] = "#define VERTEX_SHADER\n";
1003 geomstrings_list[0] = "#define GEOMETRY_SHADER\n";
1004 fragstrings_list[0] = "#define FRAGMENT_SHADER\n";
1005 vertstrings_count = 1;
1006 geomstrings_count = 1;
1007 fragstrings_count = 1;
1008 permutationname[0] = 0;
1009 i = permutation / SHADERPERMUTATION_MODEBASE;
1010 vertstrings_list[vertstrings_count++] = shadermodeinfo[i][0];
1011 geomstrings_list[geomstrings_count++] = shadermodeinfo[i][0];
1012 fragstrings_list[fragstrings_count++] = shadermodeinfo[i][0];
1013 strlcat(permutationname, shadermodeinfo[i][1], sizeof(permutationname));
1014 for (i = 0;shaderpermutationinfo[i][0];i++)
1016 if (permutation & (1<<i))
1018 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i][0];
1019 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i][0];
1020 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i][0];
1021 strlcat(permutationname, shaderpermutationinfo[i][1], sizeof(permutationname));
1025 // keep line numbers correct
1026 vertstrings_list[vertstrings_count++] = "\n";
1027 geomstrings_list[geomstrings_count++] = "\n";
1028 fragstrings_list[fragstrings_count++] = "\n";
1031 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1032 shaderfound = false;
1035 Con_DPrint("from disk... ");
1036 vertstrings_list[vertstrings_count++] = shaderstring;
1037 geomstrings_list[geomstrings_count++] = shaderstring;
1038 fragstrings_list[fragstrings_count++] = shaderstring;
1041 else if (!strcmp(filename, "glsl/default.glsl"))
1043 vertstrings_list[vertstrings_count++] = builtinshaderstring;
1044 geomstrings_list[geomstrings_count++] = builtinshaderstring;
1045 fragstrings_list[fragstrings_count++] = builtinshaderstring;
1048 // clear any lists that are not needed by this shader
1049 if (!(shadertype & SHADERTYPE_USES_VERTEXSHADER))
1050 vertstrings_count = 0;
1051 if (!(shadertype & SHADERTYPE_USES_GEOMETRYSHADER))
1052 geomstrings_count = 0;
1053 if (!(shadertype & SHADERTYPE_USES_FRAGMENTSHADER))
1054 fragstrings_count = 0;
1055 // compile the shader program
1056 if (shaderfound && vertstrings_count + geomstrings_count + fragstrings_count)
1057 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1061 qglUseProgramObjectARB(p->program);CHECKGLERROR
1062 // look up all the uniform variable names we care about, so we don't
1063 // have to look them up every time we set them
1064 p->loc_Texture_Normal = qglGetUniformLocationARB(p->program, "Texture_Normal");
1065 p->loc_Texture_Color = qglGetUniformLocationARB(p->program, "Texture_Color");
1066 p->loc_Texture_Gloss = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1067 p->loc_Texture_Cube = qglGetUniformLocationARB(p->program, "Texture_Cube");
1068 p->loc_Texture_Attenuation = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
1069 p->loc_Texture_FogMask = qglGetUniformLocationARB(p->program, "Texture_FogMask");
1070 p->loc_Texture_Pants = qglGetUniformLocationARB(p->program, "Texture_Pants");
1071 p->loc_Texture_Shirt = qglGetUniformLocationARB(p->program, "Texture_Shirt");
1072 p->loc_Texture_Lightmap = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
1073 p->loc_Texture_Deluxemap = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
1074 p->loc_Texture_Glow = qglGetUniformLocationARB(p->program, "Texture_Glow");
1075 p->loc_Texture_Refraction = qglGetUniformLocationARB(p->program, "Texture_Refraction");
1076 p->loc_Texture_Reflection = qglGetUniformLocationARB(p->program, "Texture_Reflection");
1077 p->loc_FogColor = qglGetUniformLocationARB(p->program, "FogColor");
1078 p->loc_LightPosition = qglGetUniformLocationARB(p->program, "LightPosition");
1079 p->loc_EyePosition = qglGetUniformLocationARB(p->program, "EyePosition");
1080 p->loc_LightColor = qglGetUniformLocationARB(p->program, "LightColor");
1081 p->loc_Color_Pants = qglGetUniformLocationARB(p->program, "Color_Pants");
1082 p->loc_Color_Shirt = qglGetUniformLocationARB(p->program, "Color_Shirt");
1083 p->loc_FogRangeRecip = qglGetUniformLocationARB(p->program, "FogRangeRecip");
1084 p->loc_AmbientScale = qglGetUniformLocationARB(p->program, "AmbientScale");
1085 p->loc_DiffuseScale = qglGetUniformLocationARB(p->program, "DiffuseScale");
1086 p->loc_SpecularPower = qglGetUniformLocationARB(p->program, "SpecularPower");
1087 p->loc_SpecularScale = qglGetUniformLocationARB(p->program, "SpecularScale");
1088 p->loc_GlowScale = qglGetUniformLocationARB(p->program, "GlowScale");
1089 p->loc_SceneBrightness = qglGetUniformLocationARB(p->program, "SceneBrightness");
1090 p->loc_OffsetMapping_Scale = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
1091 p->loc_AmbientColor = qglGetUniformLocationARB(p->program, "AmbientColor");
1092 p->loc_DiffuseColor = qglGetUniformLocationARB(p->program, "DiffuseColor");
1093 p->loc_SpecularColor = qglGetUniformLocationARB(p->program, "SpecularColor");
1094 p->loc_LightDir = qglGetUniformLocationARB(p->program, "LightDir");
1095 p->loc_ContrastBoostCoeff = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff");
1096 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
1097 p->loc_ScreenScaleRefractReflect = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
1098 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
1099 p->loc_RefractColor = qglGetUniformLocationARB(p->program, "RefractColor");
1100 p->loc_ReflectColor = qglGetUniformLocationARB(p->program, "ReflectColor");
1101 p->loc_ReflectFactor = qglGetUniformLocationARB(p->program, "ReflectFactor");
1102 p->loc_ReflectOffset = qglGetUniformLocationARB(p->program, "ReflectOffset");
1103 // initialize the samplers to refer to the texture units we use
1104 if (p->loc_Texture_Normal >= 0) qglUniform1iARB(p->loc_Texture_Normal, 0);
1105 if (p->loc_Texture_Color >= 0) qglUniform1iARB(p->loc_Texture_Color, 1);
1106 if (p->loc_Texture_Gloss >= 0) qglUniform1iARB(p->loc_Texture_Gloss, 2);
1107 if (p->loc_Texture_Cube >= 0) qglUniform1iARB(p->loc_Texture_Cube, 3);
1108 if (p->loc_Texture_FogMask >= 0) qglUniform1iARB(p->loc_Texture_FogMask, 4);
1109 if (p->loc_Texture_Pants >= 0) qglUniform1iARB(p->loc_Texture_Pants, 5);
1110 if (p->loc_Texture_Shirt >= 0) qglUniform1iARB(p->loc_Texture_Shirt, 6);
1111 if (p->loc_Texture_Lightmap >= 0) qglUniform1iARB(p->loc_Texture_Lightmap, 7);
1112 if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap, 8);
1113 if (p->loc_Texture_Glow >= 0) qglUniform1iARB(p->loc_Texture_Glow, 9);
1114 if (p->loc_Texture_Attenuation >= 0) qglUniform1iARB(p->loc_Texture_Attenuation, 10);
1115 if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction, 11);
1116 if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection, 12);
1118 qglUseProgramObjectARB(0);CHECKGLERROR
1119 if (developer.integer)
1120 Con_Printf("GLSL shader %s :%s compiled.\n", filename, permutationname);
1124 if (developer.integer)
1125 Con_Printf("GLSL shader %s :%s failed! source code line offset for above errors is %i.\n", permutationname, filename, -(vertstrings_count - 1));
1127 Con_Printf("GLSL shader %s :%s failed! some features may not work properly.\n", permutationname, filename);
1130 Mem_Free(shaderstring);
1133 void R_GLSL_Restart_f(void)
1136 for (i = 0;i < SHADERPERMUTATION_INDICES;i++)
1137 if (r_glsl_permutations[i].program)
1138 GL_Backend_FreeProgram(r_glsl_permutations[i].program);
1139 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1142 void R_GLSL_DumpShader_f(void)
1146 qfile_t *file = FS_Open("glsl/default.glsl", "w", false, false);
1149 Con_Printf("failed to write to glsl/default.glsl\n");
1153 FS_Print(file, "// The engine may define the following macros:\n");
1154 FS_Print(file, "// #define VERTEX_SHADER\n// #define GEOMETRY_SHADER\n// #define FRAGMENT_SHADER\n");
1155 for (i = 0;shadermodeinfo[i][0];i++)
1156 FS_Printf(file, "// %s", shadermodeinfo[i][0]);
1157 for (i = 0;shaderpermutationinfo[i][0];i++)
1158 FS_Printf(file, "// %s", shaderpermutationinfo[i][0]);
1159 FS_Print(file, "\n");
1160 FS_Print(file, builtinshaderstring);
1163 Con_Printf("glsl/default.glsl written\n");
1166 extern rtexture_t *r_shadow_attenuationgradienttexture;
1167 extern rtexture_t *r_shadow_attenuation2dtexture;
1168 extern rtexture_t *r_shadow_attenuation3dtexture;
1169 int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
1171 // select a permutation of the lighting shader appropriate to this
1172 // combination of texture, entity, light source, and fogging, only use the
1173 // minimum features necessary to avoid wasting rendering time in the
1174 // fragment shader on features that are not being used
1175 const char *shaderfilename = NULL;
1176 unsigned int permutation = 0;
1177 unsigned int shadertype = 0;
1178 shadermode_t mode = 0;
1179 r_glsl_permutation = NULL;
1180 shaderfilename = "glsl/default.glsl";
1181 shadertype = SHADERTYPE_USES_VERTEXSHADER | SHADERTYPE_USES_FRAGMENTSHADER;
1182 // TODO: implement geometry-shader based shadow volumes someday
1183 if (r_glsl_offsetmapping.integer)
1185 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1186 if (r_glsl_offsetmapping_reliefmapping.integer)
1187 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1189 if (rsurfacepass == RSURFPASS_BACKGROUND)
1191 // distorted background
1192 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
1193 mode = SHADERMODE_WATER;
1195 mode = SHADERMODE_REFRACTION;
1197 else if (rsurfacepass == RSURFPASS_RTLIGHT)
1200 mode = SHADERMODE_LIGHTSOURCE;
1201 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1202 permutation |= SHADERPERMUTATION_CUBEFILTER;
1203 if (diffusescale > 0)
1204 permutation |= SHADERPERMUTATION_DIFFUSE;
1205 if (specularscale > 0)
1206 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1207 if (r_refdef.fogenabled)
1208 permutation |= SHADERPERMUTATION_FOG;
1209 if (rsurface.texture->colormapping)
1210 permutation |= SHADERPERMUTATION_COLORMAPPING;
1211 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1212 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1213 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1214 permutation |= SHADERPERMUTATION_REFLECTION;
1216 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1218 // unshaded geometry (fullbright or ambient model lighting)
1219 mode = SHADERMODE_LIGHTMAP;
1220 if (rsurface.texture->currentskinframe->glow)
1221 permutation |= SHADERPERMUTATION_GLOW;
1222 if (r_refdef.fogenabled)
1223 permutation |= SHADERPERMUTATION_FOG;
1224 if (rsurface.texture->colormapping)
1225 permutation |= SHADERPERMUTATION_COLORMAPPING;
1226 if (r_glsl_offsetmapping.integer)
1228 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1229 if (r_glsl_offsetmapping_reliefmapping.integer)
1230 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1232 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1233 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1234 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1235 permutation |= SHADERPERMUTATION_REFLECTION;
1237 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
1239 // directional model lighting
1240 mode = SHADERMODE_LIGHTDIRECTION;
1241 if (rsurface.texture->currentskinframe->glow)
1242 permutation |= SHADERPERMUTATION_GLOW;
1243 permutation |= SHADERPERMUTATION_DIFFUSE;
1244 if (specularscale > 0)
1245 permutation |= SHADERPERMUTATION_SPECULAR;
1246 if (r_refdef.fogenabled)
1247 permutation |= SHADERPERMUTATION_FOG;
1248 if (rsurface.texture->colormapping)
1249 permutation |= SHADERPERMUTATION_COLORMAPPING;
1250 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1251 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1252 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1253 permutation |= SHADERPERMUTATION_REFLECTION;
1255 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
1257 // ambient model lighting
1258 mode = SHADERMODE_LIGHTDIRECTION;
1259 if (rsurface.texture->currentskinframe->glow)
1260 permutation |= SHADERPERMUTATION_GLOW;
1261 if (r_refdef.fogenabled)
1262 permutation |= SHADERPERMUTATION_FOG;
1263 if (rsurface.texture->colormapping)
1264 permutation |= SHADERPERMUTATION_COLORMAPPING;
1265 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1266 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1267 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1268 permutation |= SHADERPERMUTATION_REFLECTION;
1273 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
1275 // deluxemapping (light direction texture)
1276 if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
1277 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
1279 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1280 if (specularscale > 0)
1281 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1283 else if (r_glsl_deluxemapping.integer >= 2)
1285 // fake deluxemapping (uniform light direction in tangentspace)
1286 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1287 if (specularscale > 0)
1288 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1292 // ordinary lightmapping
1293 mode = SHADERMODE_LIGHTMAP;
1295 if (rsurface.texture->currentskinframe->glow)
1296 permutation |= SHADERPERMUTATION_GLOW;
1297 if (r_refdef.fogenabled)
1298 permutation |= SHADERPERMUTATION_FOG;
1299 if (rsurface.texture->colormapping)
1300 permutation |= SHADERPERMUTATION_COLORMAPPING;
1301 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1302 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1303 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1304 permutation |= SHADERPERMUTATION_REFLECTION;
1306 permutation |= mode * SHADERPERMUTATION_MODEBASE;
1307 if (!r_glsl_permutations[permutation].program)
1309 if (!r_glsl_permutations[permutation].compiled)
1310 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1311 if (!r_glsl_permutations[permutation].program)
1313 // remove features until we find a valid permutation
1315 for (i = (SHADERPERMUTATION_MODEBASE >> 1);;i>>=1)
1319 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");
1320 Cvar_SetValueQuick(&r_glsl, 0);
1321 return 0; // no bit left to clear
1323 // reduce i more quickly whenever it would not remove any bits
1324 if (!(permutation & i))
1327 if (!r_glsl_permutations[permutation].compiled)
1328 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1329 if (r_glsl_permutations[permutation].program)
1334 r_glsl_permutation = r_glsl_permutations + permutation;
1336 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
1337 if (mode == SHADERMODE_LIGHTSOURCE)
1339 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
1340 if (permutation & SHADERPERMUTATION_DIFFUSE)
1342 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
1343 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, ambientscale);
1344 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, diffusescale);
1345 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, specularscale);
1349 // ambient only is simpler
1350 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0] * ambientscale, lightcolorbase[1] * ambientscale, lightcolorbase[2] * ambientscale);
1351 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, 1);
1352 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, 0);
1353 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, 0);
1356 else if (mode == SHADERMODE_LIGHTDIRECTION)
1358 if (r_glsl_permutation->loc_AmbientColor >= 0)
1359 qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale, rsurface.modellight_ambient[1] * ambientscale, rsurface.modellight_ambient[2] * ambientscale);
1360 if (r_glsl_permutation->loc_DiffuseColor >= 0)
1361 qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface.modellight_diffuse[0] * diffusescale, rsurface.modellight_diffuse[1] * diffusescale, rsurface.modellight_diffuse[2] * diffusescale);
1362 if (r_glsl_permutation->loc_SpecularColor >= 0)
1363 qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale, rsurface.modellight_diffuse[1] * specularscale, rsurface.modellight_diffuse[2] * specularscale);
1364 if (r_glsl_permutation->loc_LightDir >= 0)
1365 qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
1369 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_ambient.value * 2.0f / 128.0f);
1370 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
1371 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
1373 if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
1374 if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
1376 // The formula used is actually:
1377 // color.rgb *= SceneBrightness;
1378 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
1379 // I simplify that to
1380 // color.rgb *= [[SceneBrightness * ContrastBoost]];
1381 // color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1;
1383 // color.rgb = [[SceneBrightness * ContrastBoost]] * color.rgb / ([[(ContrastBoost - 1) * SceneBrightness]] * color.rgb + 1);
1384 // and do [[calculations]] here in the engine
1385 qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale);
1386 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value);
1389 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
1390 if (r_glsl_permutation->loc_FogColor >= 0)
1392 // additive passes are only darkened by fog, not tinted
1393 if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
1394 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
1396 qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
1398 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
1399 if (r_glsl_permutation->loc_Color_Pants >= 0)
1401 if (rsurface.texture->currentskinframe->pants)
1402 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
1404 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
1406 if (r_glsl_permutation->loc_Color_Shirt >= 0)
1408 if (rsurface.texture->currentskinframe->shirt)
1409 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
1411 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
1413 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
1414 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
1415 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
1416 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);
1417 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]);
1418 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]);
1419 if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
1420 if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
1421 if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
1422 if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
1427 #define SKINFRAME_HASH 1024
1431 int loadsequence; // incremented each level change
1432 memexpandablearray_t array;
1433 skinframe_t *hash[SKINFRAME_HASH];
1437 void R_SkinFrame_PrepareForPurge(void)
1439 r_skinframe.loadsequence++;
1440 // wrap it without hitting zero
1441 if (r_skinframe.loadsequence >= 200)
1442 r_skinframe.loadsequence = 1;
1445 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
1449 // mark the skinframe as used for the purging code
1450 skinframe->loadsequence = r_skinframe.loadsequence;
1453 void R_SkinFrame_Purge(void)
1457 for (i = 0;i < SKINFRAME_HASH;i++)
1459 for (s = r_skinframe.hash[i];s;s = s->next)
1461 if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
1463 if (s->merged == s->base)
1465 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
1466 R_PurgeTexture(s->stain );s->stain = NULL;
1467 R_PurgeTexture(s->merged);s->merged = NULL;
1468 R_PurgeTexture(s->base );s->base = NULL;
1469 R_PurgeTexture(s->pants );s->pants = NULL;
1470 R_PurgeTexture(s->shirt );s->shirt = NULL;
1471 R_PurgeTexture(s->nmap );s->nmap = NULL;
1472 R_PurgeTexture(s->gloss );s->gloss = NULL;
1473 R_PurgeTexture(s->glow );s->glow = NULL;
1474 R_PurgeTexture(s->fog );s->fog = NULL;
1475 s->loadsequence = 0;
1481 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
1483 char basename[MAX_QPATH];
1485 Image_StripImageExtension(name, basename, sizeof(basename));
1487 if( last == NULL ) {
1489 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1490 item = r_skinframe.hash[hashindex];
1495 // linearly search through the hash bucket
1496 for( ; item ; item = item->next ) {
1497 if( !strcmp( item->basename, basename ) ) {
1504 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
1508 char basename[MAX_QPATH];
1510 Image_StripImageExtension(name, basename, sizeof(basename));
1512 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1513 for (item = r_skinframe.hash[hashindex];item;item = item->next)
1514 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
1518 rtexture_t *dyntexture;
1519 // check whether its a dynamic texture
1520 dyntexture = CL_GetDynTexture( basename );
1521 if (!add && !dyntexture)
1523 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
1524 memset(item, 0, sizeof(*item));
1525 strlcpy(item->basename, basename, sizeof(item->basename));
1526 item->base = dyntexture; // either NULL or dyntexture handle
1527 item->textureflags = textureflags;
1528 item->comparewidth = comparewidth;
1529 item->compareheight = compareheight;
1530 item->comparecrc = comparecrc;
1531 item->next = r_skinframe.hash[hashindex];
1532 r_skinframe.hash[hashindex] = item;
1534 else if( item->base == NULL )
1536 rtexture_t *dyntexture;
1537 // check whether its a dynamic texture
1538 // 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]
1539 dyntexture = CL_GetDynTexture( basename );
1540 item->base = dyntexture; // either NULL or dyntexture handle
1543 R_SkinFrame_MarkUsed(item);
1547 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
1549 // FIXME: it should be possible to disable loading various layers using
1550 // cvars, to prevent wasted loading time and memory usage if the user does
1552 qboolean loadnormalmap = true;
1553 qboolean loadgloss = true;
1554 qboolean loadpantsandshirt = true;
1555 qboolean loadglow = true;
1557 unsigned char *pixels;
1558 unsigned char *bumppixels;
1559 unsigned char *basepixels = NULL;
1560 int basepixels_width;
1561 int basepixels_height;
1562 skinframe_t *skinframe;
1564 if (cls.state == ca_dedicated)
1567 // return an existing skinframe if already loaded
1568 // if loading of the first image fails, don't make a new skinframe as it
1569 // would cause all future lookups of this to be missing
1570 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
1571 if (skinframe && skinframe->base)
1574 basepixels = loadimagepixelsbgra(name, complain, true);
1575 if (basepixels == NULL)
1578 // we've got some pixels to store, so really allocate this new texture now
1580 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
1581 skinframe->stain = NULL;
1582 skinframe->merged = NULL;
1583 skinframe->base = r_texture_notexture;
1584 skinframe->pants = NULL;
1585 skinframe->shirt = NULL;
1586 skinframe->nmap = r_texture_blanknormalmap;
1587 skinframe->gloss = NULL;
1588 skinframe->glow = NULL;
1589 skinframe->fog = NULL;
1591 basepixels_width = image_width;
1592 basepixels_height = image_height;
1593 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);
1595 if (textureflags & TEXF_ALPHA)
1597 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
1598 if (basepixels[j] < 255)
1600 if (j < basepixels_width * basepixels_height * 4)
1602 // has transparent pixels
1603 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1604 for (j = 0;j < image_width * image_height * 4;j += 4)
1609 pixels[j+3] = basepixels[j+3];
1611 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);
1616 // _norm is the name used by tenebrae and has been adopted as standard
1619 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL)
1621 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);
1625 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL)
1627 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1628 Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
1629 skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
1631 Mem_Free(bumppixels);
1633 else if (r_shadow_bumpscale_basetexture.value > 0)
1635 pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
1636 Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
1637 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);
1641 // _luma is supported for tenebrae compatibility
1642 // (I think it's a very stupid name, but oh well)
1643 // _glow is the preferred name
1644 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;}
1645 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;}
1646 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;}
1647 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;}
1650 Mem_Free(basepixels);
1655 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)
1660 for (i = 0;i < width*height;i++)
1661 if (((unsigned char *)&palette[in[i]])[3] > 0)
1663 if (i == width*height)
1666 return R_LoadTexture2D (r_main_texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
1669 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
1670 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
1673 unsigned char *temp1, *temp2;
1674 skinframe_t *skinframe;
1676 if (cls.state == ca_dedicated)
1679 // if already loaded just return it, otherwise make a new skinframe
1680 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
1681 if (skinframe && skinframe->base)
1684 skinframe->stain = NULL;
1685 skinframe->merged = NULL;
1686 skinframe->base = r_texture_notexture;
1687 skinframe->pants = NULL;
1688 skinframe->shirt = NULL;
1689 skinframe->nmap = r_texture_blanknormalmap;
1690 skinframe->gloss = NULL;
1691 skinframe->glow = NULL;
1692 skinframe->fog = NULL;
1694 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1698 if (r_shadow_bumpscale_basetexture.value > 0)
1700 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1701 temp2 = temp1 + width * height * 4;
1702 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1703 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1706 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1707 if (textureflags & TEXF_ALPHA)
1709 for (i = 3;i < width * height * 4;i += 4)
1710 if (skindata[i] < 255)
1712 if (i < width * height * 4)
1714 unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
1715 memcpy(fogpixels, skindata, width * height * 4);
1716 for (i = 0;i < width * height * 4;i += 4)
1717 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
1718 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1719 Mem_Free(fogpixels);
1726 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
1729 unsigned char *temp1, *temp2;
1730 skinframe_t *skinframe;
1732 if (cls.state == ca_dedicated)
1735 // if already loaded just return it, otherwise make a new skinframe
1736 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
1737 if (skinframe && skinframe->base)
1740 skinframe->stain = NULL;
1741 skinframe->merged = NULL;
1742 skinframe->base = r_texture_notexture;
1743 skinframe->pants = NULL;
1744 skinframe->shirt = NULL;
1745 skinframe->nmap = r_texture_blanknormalmap;
1746 skinframe->gloss = NULL;
1747 skinframe->glow = NULL;
1748 skinframe->fog = NULL;
1750 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1754 if (r_shadow_bumpscale_basetexture.value > 0)
1756 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1757 temp2 = temp1 + width * height * 4;
1758 // use either a custom palette or the quake palette
1759 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
1760 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1761 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1764 // use either a custom palette, or the quake palette
1765 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
1766 if (loadglowtexture)
1767 skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_bgra_onlyfullbrights, skinframe->textureflags, false); // glow
1768 if (loadpantsandshirt)
1770 skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_bgra_pantsaswhite, skinframe->textureflags, false); // pants
1771 skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_bgra_shirtaswhite, skinframe->textureflags, false); // shirt
1773 if (skinframe->pants || skinframe->shirt)
1774 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
1775 if (textureflags & TEXF_ALPHA)
1777 for (i = 0;i < width * height;i++)
1778 if (((unsigned char *)palette_bgra_alpha)[skindata[i]*4+3] < 255)
1780 if (i < width * height)
1781 skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), palette_bgra_alpha, skinframe->textureflags, true); // fog mask
1787 skinframe_t *R_SkinFrame_LoadMissing(void)
1789 skinframe_t *skinframe;
1791 if (cls.state == ca_dedicated)
1794 skinframe = R_SkinFrame_Find("missing", TEXF_PRECACHE, 0, 0, 0, true);
1795 skinframe->stain = NULL;
1796 skinframe->merged = NULL;
1797 skinframe->base = r_texture_notexture;
1798 skinframe->pants = NULL;
1799 skinframe->shirt = NULL;
1800 skinframe->nmap = r_texture_blanknormalmap;
1801 skinframe->gloss = NULL;
1802 skinframe->glow = NULL;
1803 skinframe->fog = NULL;
1808 void gl_main_start(void)
1813 r = -16.0 / (1.0 * FOGMASKTABLEWIDTH * FOGMASKTABLEWIDTH);
1814 for (x = 0;x < FOGMASKTABLEWIDTH;x++)
1816 alpha = exp(r * ((double)x*(double)x));
1817 if (x == FOGMASKTABLEWIDTH - 1)
1819 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
1822 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1823 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1825 // set up r_skinframe loading system for textures
1826 memset(&r_skinframe, 0, sizeof(r_skinframe));
1827 r_skinframe.loadsequence = 1;
1828 Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
1830 r_main_texturepool = R_AllocTexturePool();
1831 R_BuildBlankTextures();
1833 if (gl_texturecubemap)
1836 R_BuildNormalizationCube();
1838 R_BuildFogTexture();
1839 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1840 memset(&r_waterstate, 0, sizeof(r_waterstate));
1841 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1842 memset(&r_svbsp, 0, sizeof (r_svbsp));
1845 void gl_main_shutdown(void)
1847 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1848 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1850 // clear out the r_skinframe state
1851 Mem_ExpandableArray_FreeArray(&r_skinframe.array);
1852 memset(&r_skinframe, 0, sizeof(r_skinframe));
1855 Mem_Free(r_svbsp.nodes);
1856 memset(&r_svbsp, 0, sizeof (r_svbsp));
1857 R_FreeTexturePool(&r_main_texturepool);
1858 r_texture_blanknormalmap = NULL;
1859 r_texture_white = NULL;
1860 r_texture_grey128 = NULL;
1861 r_texture_black = NULL;
1862 r_texture_whitecube = NULL;
1863 r_texture_normalizationcube = NULL;
1864 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1865 memset(&r_waterstate, 0, sizeof(r_waterstate));
1869 extern void CL_ParseEntityLump(char *entitystring);
1870 void gl_main_newmap(void)
1872 // FIXME: move this code to client
1874 char *entities, entname[MAX_QPATH];
1877 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
1878 l = (int)strlen(entname) - 4;
1879 if (l >= 0 && !strcmp(entname + l, ".bsp"))
1881 memcpy(entname + l, ".ent", 5);
1882 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
1884 CL_ParseEntityLump(entities);
1889 if (cl.worldmodel->brush.entities)
1890 CL_ParseEntityLump(cl.worldmodel->brush.entities);
1894 void GL_Main_Init(void)
1896 r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
1898 Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
1899 Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
1900 // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
1901 if (gamemode == GAME_NEHAHRA)
1903 Cvar_RegisterVariable (&gl_fogenable);
1904 Cvar_RegisterVariable (&gl_fogdensity);
1905 Cvar_RegisterVariable (&gl_fogred);
1906 Cvar_RegisterVariable (&gl_foggreen);
1907 Cvar_RegisterVariable (&gl_fogblue);
1908 Cvar_RegisterVariable (&gl_fogstart);
1909 Cvar_RegisterVariable (&gl_fogend);
1911 Cvar_RegisterVariable(&r_depthfirst);
1912 Cvar_RegisterVariable(&r_nearclip);
1913 Cvar_RegisterVariable(&r_showbboxes);
1914 Cvar_RegisterVariable(&r_showsurfaces);
1915 Cvar_RegisterVariable(&r_showtris);
1916 Cvar_RegisterVariable(&r_shownormals);
1917 Cvar_RegisterVariable(&r_showlighting);
1918 Cvar_RegisterVariable(&r_showshadowvolumes);
1919 Cvar_RegisterVariable(&r_showcollisionbrushes);
1920 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
1921 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
1922 Cvar_RegisterVariable(&r_showdisabledepthtest);
1923 Cvar_RegisterVariable(&r_drawportals);
1924 Cvar_RegisterVariable(&r_drawentities);
1925 Cvar_RegisterVariable(&r_cullentities_trace);
1926 Cvar_RegisterVariable(&r_cullentities_trace_samples);
1927 Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
1928 Cvar_RegisterVariable(&r_cullentities_trace_delay);
1929 Cvar_RegisterVariable(&r_drawviewmodel);
1930 Cvar_RegisterVariable(&r_speeds);
1931 Cvar_RegisterVariable(&r_fullbrights);
1932 Cvar_RegisterVariable(&r_wateralpha);
1933 Cvar_RegisterVariable(&r_dynamic);
1934 Cvar_RegisterVariable(&r_fullbright);
1935 Cvar_RegisterVariable(&r_shadows);
1936 Cvar_RegisterVariable(&r_shadows_throwdistance);
1937 Cvar_RegisterVariable(&r_q1bsp_skymasking);
1938 Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
1939 Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
1940 Cvar_RegisterVariable(&r_textureunits);
1941 Cvar_RegisterVariable(&r_glsl);
1942 Cvar_RegisterVariable(&r_glsl_offsetmapping);
1943 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
1944 Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
1945 Cvar_RegisterVariable(&r_glsl_deluxemapping);
1946 Cvar_RegisterVariable(&r_water);
1947 Cvar_RegisterVariable(&r_water_resolutionmultiplier);
1948 Cvar_RegisterVariable(&r_water_clippingplanebias);
1949 Cvar_RegisterVariable(&r_water_refractdistort);
1950 Cvar_RegisterVariable(&r_water_reflectdistort);
1951 Cvar_RegisterVariable(&r_lerpsprites);
1952 Cvar_RegisterVariable(&r_lerpmodels);
1953 Cvar_RegisterVariable(&r_lerplightstyles);
1954 Cvar_RegisterVariable(&r_waterscroll);
1955 Cvar_RegisterVariable(&r_bloom);
1956 Cvar_RegisterVariable(&r_bloom_colorscale);
1957 Cvar_RegisterVariable(&r_bloom_brighten);
1958 Cvar_RegisterVariable(&r_bloom_blur);
1959 Cvar_RegisterVariable(&r_bloom_resolution);
1960 Cvar_RegisterVariable(&r_bloom_colorexponent);
1961 Cvar_RegisterVariable(&r_bloom_colorsubtract);
1962 Cvar_RegisterVariable(&r_hdr);
1963 Cvar_RegisterVariable(&r_hdr_scenebrightness);
1964 Cvar_RegisterVariable(&r_glsl_contrastboost);
1965 Cvar_RegisterVariable(&r_hdr_glowintensity);
1966 Cvar_RegisterVariable(&r_hdr_range);
1967 Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
1968 Cvar_RegisterVariable(&developer_texturelogging);
1969 Cvar_RegisterVariable(&gl_lightmaps);
1970 Cvar_RegisterVariable(&r_test);
1971 Cvar_RegisterVariable(&r_batchmode);
1972 if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
1973 Cvar_SetValue("r_fullbrights", 0);
1974 R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
1976 Cvar_RegisterVariable(&r_track_sprites);
1977 Cvar_RegisterVariable(&r_track_sprites_flags);
1978 Cvar_RegisterVariable(&r_track_sprites_scalew);
1979 Cvar_RegisterVariable(&r_track_sprites_scaleh);
1982 extern void R_Textures_Init(void);
1983 extern void GL_Draw_Init(void);
1984 extern void GL_Main_Init(void);
1985 extern void R_Shadow_Init(void);
1986 extern void R_Sky_Init(void);
1987 extern void GL_Surf_Init(void);
1988 extern void R_Particles_Init(void);
1989 extern void R_Explosion_Init(void);
1990 extern void gl_backend_init(void);
1991 extern void Sbar_Init(void);
1992 extern void R_LightningBeams_Init(void);
1993 extern void Mod_RenderInit(void);
1995 void Render_Init(void)
2007 R_LightningBeams_Init();
2016 extern char *ENGINE_EXTENSIONS;
2019 VID_CheckExtensions();
2021 // LordHavoc: report supported extensions
2022 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2024 // clear to black (loading plaque will be seen over this)
2026 qglClearColor(0,0,0,1);CHECKGLERROR
2027 qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
2030 int R_CullBox(const vec3_t mins, const vec3_t maxs)
2034 for (i = 0;i < r_view.numfrustumplanes;i++)
2036 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
2039 p = r_view.frustum + i;
2044 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2048 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2052 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2056 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2060 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2064 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2068 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2072 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2080 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
2084 for (i = 0;i < numplanes;i++)
2091 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2095 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2099 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2103 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2107 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2111 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2115 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2119 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2127 //==================================================================================
2129 static void R_UpdateEntityLighting(entity_render_t *ent)
2131 vec3_t tempdiffusenormal;
2133 // fetch the lighting from the worldmodel data
2134 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));
2135 VectorClear(ent->modellight_diffuse);
2136 VectorClear(tempdiffusenormal);
2137 if ((ent->flags & RENDER_LIGHT) && r_refdef.worldmodel && r_refdef.worldmodel->brush.LightPoint)
2140 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
2141 r_refdef.worldmodel->brush.LightPoint(r_refdef.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
2144 VectorSet(ent->modellight_ambient, 1, 1, 1);
2146 // move the light direction into modelspace coordinates for lighting code
2147 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
2148 if(VectorLength2(ent->modellight_lightdir) > 0)
2150 VectorNormalize(ent->modellight_lightdir);
2154 VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
2157 // scale ambient and directional light contributions according to rendering variables
2158 ent->modellight_ambient[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
2159 ent->modellight_ambient[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
2160 ent->modellight_ambient[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
2161 ent->modellight_diffuse[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
2162 ent->modellight_diffuse[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
2163 ent->modellight_diffuse[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
2166 static void R_View_UpdateEntityVisible (void)
2169 entity_render_t *ent;
2171 if (!r_drawentities.integer)
2174 renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
2175 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
2177 // worldmodel can check visibility
2178 for (i = 0;i < r_refdef.numentities;i++)
2180 ent = r_refdef.entities[i];
2181 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));
2184 if(r_cullentities_trace.integer)
2186 for (i = 0;i < r_refdef.numentities;i++)
2188 ent = r_refdef.entities[i];
2189 if(r_viewcache.entityvisible[i] && !(ent->effects & EF_NODEPTHTEST) && !(ent->flags & RENDER_VIEWMODEL) && !(ent->model && (ent->model->name[0] == '*')))
2191 if(Mod_CanSeeBox_Trace(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.worldmodel, r_view.origin, ent->mins, ent->maxs))
2192 ent->last_trace_visibility = realtime;
2193 if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
2194 r_viewcache.entityvisible[i] = 0;
2201 // no worldmodel or it can't check visibility
2202 for (i = 0;i < r_refdef.numentities;i++)
2204 ent = r_refdef.entities[i];
2205 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));
2209 // update entity lighting (even on hidden entities for r_shadows)
2210 for (i = 0;i < r_refdef.numentities;i++)
2211 R_UpdateEntityLighting(r_refdef.entities[i]);
2214 // only used if skyrendermasked, and normally returns false
2215 int R_DrawBrushModelsSky (void)
2218 entity_render_t *ent;
2220 if (!r_drawentities.integer)
2224 for (i = 0;i < r_refdef.numentities;i++)
2226 if (!r_viewcache.entityvisible[i])
2228 ent = r_refdef.entities[i];
2229 if (!ent->model || !ent->model->DrawSky)
2231 ent->model->DrawSky(ent);
2237 static void R_DrawNoModel(entity_render_t *ent);
2238 static void R_DrawModels(void)
2241 entity_render_t *ent;
2243 if (!r_drawentities.integer)
2246 for (i = 0;i < r_refdef.numentities;i++)
2248 if (!r_viewcache.entityvisible[i])
2250 ent = r_refdef.entities[i];
2251 r_refdef.stats.entities++;
2252 if (ent->model && ent->model->Draw != NULL)
2253 ent->model->Draw(ent);
2259 static void R_DrawModelsDepth(void)
2262 entity_render_t *ent;
2264 if (!r_drawentities.integer)
2267 for (i = 0;i < r_refdef.numentities;i++)
2269 if (!r_viewcache.entityvisible[i])
2271 ent = r_refdef.entities[i];
2272 if (ent->model && ent->model->DrawDepth != NULL)
2273 ent->model->DrawDepth(ent);
2277 static void R_DrawModelsDebug(void)
2280 entity_render_t *ent;
2282 if (!r_drawentities.integer)
2285 for (i = 0;i < r_refdef.numentities;i++)
2287 if (!r_viewcache.entityvisible[i])
2289 ent = r_refdef.entities[i];
2290 if (ent->model && ent->model->DrawDebug != NULL)
2291 ent->model->DrawDebug(ent);
2295 static void R_DrawModelsAddWaterPlanes(void)
2298 entity_render_t *ent;
2300 if (!r_drawentities.integer)
2303 for (i = 0;i < r_refdef.numentities;i++)
2305 if (!r_viewcache.entityvisible[i])
2307 ent = r_refdef.entities[i];
2308 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
2309 ent->model->DrawAddWaterPlanes(ent);
2313 static void R_View_SetFrustum(void)
2316 double slopex, slopey;
2318 // break apart the view matrix into vectors for various purposes
2319 Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
2320 VectorNegate(r_view.left, r_view.right);
2323 r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
2324 r_view.frustum[0].normal[1] = 0 - 0;
2325 r_view.frustum[0].normal[2] = -1 - 0;
2326 r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
2327 r_view.frustum[1].normal[1] = 0 + 0;
2328 r_view.frustum[1].normal[2] = -1 + 0;
2329 r_view.frustum[2].normal[0] = 0 - 0;
2330 r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
2331 r_view.frustum[2].normal[2] = -1 - 0;
2332 r_view.frustum[3].normal[0] = 0 + 0;
2333 r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
2334 r_view.frustum[3].normal[2] = -1 + 0;
2338 zNear = r_refdef.nearclip;
2339 nudge = 1.0 - 1.0 / (1<<23);
2340 r_view.frustum[4].normal[0] = 0 - 0;
2341 r_view.frustum[4].normal[1] = 0 - 0;
2342 r_view.frustum[4].normal[2] = -1 - -nudge;
2343 r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
2344 r_view.frustum[5].normal[0] = 0 + 0;
2345 r_view.frustum[5].normal[1] = 0 + 0;
2346 r_view.frustum[5].normal[2] = -1 + -nudge;
2347 r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
2353 r_view.frustum[0].normal[0] = m[3] - m[0];
2354 r_view.frustum[0].normal[1] = m[7] - m[4];
2355 r_view.frustum[0].normal[2] = m[11] - m[8];
2356 r_view.frustum[0].dist = m[15] - m[12];
2358 r_view.frustum[1].normal[0] = m[3] + m[0];
2359 r_view.frustum[1].normal[1] = m[7] + m[4];
2360 r_view.frustum[1].normal[2] = m[11] + m[8];
2361 r_view.frustum[1].dist = m[15] + m[12];
2363 r_view.frustum[2].normal[0] = m[3] - m[1];
2364 r_view.frustum[2].normal[1] = m[7] - m[5];
2365 r_view.frustum[2].normal[2] = m[11] - m[9];
2366 r_view.frustum[2].dist = m[15] - m[13];
2368 r_view.frustum[3].normal[0] = m[3] + m[1];
2369 r_view.frustum[3].normal[1] = m[7] + m[5];
2370 r_view.frustum[3].normal[2] = m[11] + m[9];
2371 r_view.frustum[3].dist = m[15] + m[13];
2373 r_view.frustum[4].normal[0] = m[3] - m[2];
2374 r_view.frustum[4].normal[1] = m[7] - m[6];
2375 r_view.frustum[4].normal[2] = m[11] - m[10];
2376 r_view.frustum[4].dist = m[15] - m[14];
2378 r_view.frustum[5].normal[0] = m[3] + m[2];
2379 r_view.frustum[5].normal[1] = m[7] + m[6];
2380 r_view.frustum[5].normal[2] = m[11] + m[10];
2381 r_view.frustum[5].dist = m[15] + m[14];
2384 if (r_view.useperspective)
2386 slopex = 1.0 / r_view.frustum_x;
2387 slopey = 1.0 / r_view.frustum_y;
2388 VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
2389 VectorMA(r_view.forward, slopex, r_view.left, r_view.frustum[1].normal);
2390 VectorMA(r_view.forward, -slopey, r_view.up , r_view.frustum[2].normal);
2391 VectorMA(r_view.forward, slopey, r_view.up , r_view.frustum[3].normal);
2392 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2394 // Leaving those out was a mistake, those were in the old code, and they
2395 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
2396 // I couldn't reproduce it after adding those normalizations. --blub
2397 VectorNormalize(r_view.frustum[0].normal);
2398 VectorNormalize(r_view.frustum[1].normal);
2399 VectorNormalize(r_view.frustum[2].normal);
2400 VectorNormalize(r_view.frustum[3].normal);
2402 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
2403 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
2404 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
2405 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[2]);
2406 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[3]);
2408 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
2409 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
2410 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
2411 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
2412 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2416 VectorScale(r_view.left, -r_view.ortho_x, r_view.frustum[0].normal);
2417 VectorScale(r_view.left, r_view.ortho_x, r_view.frustum[1].normal);
2418 VectorScale(r_view.up, -r_view.ortho_y, r_view.frustum[2].normal);
2419 VectorScale(r_view.up, r_view.ortho_y, r_view.frustum[3].normal);
2420 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2421 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal) + r_view.ortho_x;
2422 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal) + r_view.ortho_x;
2423 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal) + r_view.ortho_y;
2424 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal) + r_view.ortho_y;
2425 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2427 r_view.numfrustumplanes = 5;
2429 if (r_view.useclipplane)
2431 r_view.numfrustumplanes = 6;
2432 r_view.frustum[5] = r_view.clipplane;
2435 for (i = 0;i < r_view.numfrustumplanes;i++)
2436 PlaneClassify(r_view.frustum + i);
2438 // LordHavoc: note to all quake engine coders, Quake had a special case
2439 // for 90 degrees which assumed a square view (wrong), so I removed it,
2440 // Quake2 has it disabled as well.
2442 // rotate R_VIEWFORWARD right by FOV_X/2 degrees
2443 //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
2444 //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
2445 //PlaneClassify(&frustum[0]);
2447 // rotate R_VIEWFORWARD left by FOV_X/2 degrees
2448 //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
2449 //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
2450 //PlaneClassify(&frustum[1]);
2452 // rotate R_VIEWFORWARD up by FOV_X/2 degrees
2453 //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
2454 //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
2455 //PlaneClassify(&frustum[2]);
2457 // rotate R_VIEWFORWARD down by FOV_X/2 degrees
2458 //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
2459 //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
2460 //PlaneClassify(&frustum[3]);
2463 //VectorCopy(r_view.forward, r_view.frustum[4].normal);
2464 //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
2465 //PlaneClassify(&frustum[4]);
2468 void R_View_Update(void)
2470 R_View_SetFrustum();
2471 R_View_WorldVisibility(r_view.useclipplane);
2472 R_View_UpdateEntityVisible();
2475 void R_SetupView(void)
2477 if (!r_view.useperspective)
2478 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);
2479 else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
2480 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
2482 GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
2484 GL_SetupView_Orientation_FromEntity(&r_view.matrix);
2486 if (r_view.useclipplane)
2488 // LordHavoc: couldn't figure out how to make this approach the
2489 vec_t dist = r_view.clipplane.dist - r_water_clippingplanebias.value;
2490 vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
2491 if (viewdist < r_view.clipplane.dist + r_water_clippingplanebias.value)
2492 dist = r_view.clipplane.dist;
2493 GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
2497 void R_ResetViewRendering2D(void)
2499 if (gl_support_fragment_shader)
2501 qglUseProgramObjectARB(0);CHECKGLERROR
2506 // GL is weird because it's bottom to top, r_view.y is top to bottom
2507 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2508 GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
2509 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2510 GL_Color(1, 1, 1, 1);
2511 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2512 GL_BlendFunc(GL_ONE, GL_ZERO);
2513 GL_AlphaTest(false);
2514 GL_ScissorTest(false);
2515 GL_DepthMask(false);
2516 GL_DepthRange(0, 1);
2517 GL_DepthTest(false);
2518 R_Mesh_Matrix(&identitymatrix);
2519 R_Mesh_ResetTextureState();
2520 GL_PolygonOffset(0, 0);
2521 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2522 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2523 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2524 qglStencilMask(~0);CHECKGLERROR
2525 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2526 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2527 GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
2530 void R_ResetViewRendering3D(void)
2532 if (gl_support_fragment_shader)
2534 qglUseProgramObjectARB(0);CHECKGLERROR
2539 // GL is weird because it's bottom to top, r_view.y is top to bottom
2540 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2542 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2543 GL_Color(1, 1, 1, 1);
2544 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2545 GL_BlendFunc(GL_ONE, GL_ZERO);
2546 GL_AlphaTest(false);
2547 GL_ScissorTest(true);
2549 GL_DepthRange(0, 1);
2551 R_Mesh_Matrix(&identitymatrix);
2552 R_Mesh_ResetTextureState();
2553 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
2554 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2555 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2556 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2557 qglStencilMask(~0);CHECKGLERROR
2558 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2559 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2560 GL_CullFace(r_view.cullface_back);
2564 R_Bloom_SetupShader(
2566 "// written by Forest 'LordHavoc' Hale\n"
2568 "// common definitions between vertex shader and fragment shader:\n"
2570 "#ifdef __GLSL_CG_DATA_TYPES\n"
2571 "#define myhalf half\n"
2572 "#define myhvec2 hvec2\n"
2573 "#define myhvec3 hvec3\n"
2574 "#define myhvec4 hvec4\n"
2576 "#define myhalf float\n"
2577 "#define myhvec2 vec2\n"
2578 "#define myhvec3 vec3\n"
2579 "#define myhvec4 vec4\n"
2582 "varying vec2 ScreenTexCoord;\n"
2583 "varying vec2 BloomTexCoord;\n"
2588 "// vertex shader specific:\n"
2589 "#ifdef VERTEX_SHADER\n"
2593 " ScreenTexCoord = vec2(gl_MultiTexCoord0);\n"
2594 " BloomTexCoord = vec2(gl_MultiTexCoord1);\n"
2595 " // transform vertex to camera space, using ftransform to match non-VS\n"
2597 " gl_Position = ftransform();\n"
2600 "#endif // VERTEX_SHADER\n"
2605 "// fragment shader specific:\n"
2606 "#ifdef FRAGMENT_SHADER\n"
2611 " myhvec3 color = myhvec3(texture2D(Texture_Screen, ScreenTexCoord));\n"
2612 " for (x = -BLUR_X;x <= BLUR_X;x++)
2613 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2614 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2615 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2616 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2618 " gl_FragColor = vec4(color);\n"
2621 "#endif // FRAGMENT_SHADER\n"
2624 void R_RenderScene(qboolean addwaterplanes);
2626 static void R_Water_StartFrame(void)
2629 int waterwidth, waterheight, texturewidth, textureheight;
2630 r_waterstate_waterplane_t *p;
2632 // set waterwidth and waterheight to the water resolution that will be
2633 // used (often less than the screen resolution for faster rendering)
2634 waterwidth = (int)bound(1, r_view.width * r_water_resolutionmultiplier.value, r_view.width);
2635 waterheight = (int)bound(1, r_view.height * r_water_resolutionmultiplier.value, r_view.height);
2637 // calculate desired texture sizes
2638 // can't use water if the card does not support the texture size
2639 if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
2640 texturewidth = textureheight = waterwidth = waterheight = 0;
2641 else if (gl_support_arb_texture_non_power_of_two)
2643 texturewidth = waterwidth;
2644 textureheight = waterheight;
2648 for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
2649 for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
2652 // allocate textures as needed
2653 if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
2655 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2656 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
2658 if (p->texture_refraction)
2659 R_FreeTexture(p->texture_refraction);
2660 p->texture_refraction = NULL;
2661 if (p->texture_reflection)
2662 R_FreeTexture(p->texture_reflection);
2663 p->texture_reflection = NULL;
2665 memset(&r_waterstate, 0, sizeof(r_waterstate));
2666 r_waterstate.waterwidth = waterwidth;
2667 r_waterstate.waterheight = waterheight;
2668 r_waterstate.texturewidth = texturewidth;
2669 r_waterstate.textureheight = textureheight;
2672 if (r_waterstate.waterwidth)
2674 r_waterstate.enabled = true;
2676 // set up variables that will be used in shader setup
2677 r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2678 r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
2679 r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2680 r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
2683 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2684 r_waterstate.numwaterplanes = 0;
2687 static void R_Water_AddWaterPlane(msurface_t *surface)
2689 int triangleindex, planeindex;
2694 r_waterstate_waterplane_t *p;
2695 // just use the first triangle with a valid normal for any decisions
2696 VectorClear(normal);
2697 for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
2699 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
2700 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
2701 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
2702 TriangleNormal(vert[0], vert[1], vert[2], normal);
2703 if (VectorLength2(normal) >= 0.001)
2707 // find a matching plane if there is one
2708 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2709 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
2711 if (planeindex >= r_waterstate.maxwaterplanes)
2712 return; // nothing we can do, out of planes
2714 // if this triangle does not fit any known plane rendered this frame, add one
2715 if (planeindex >= r_waterstate.numwaterplanes)
2717 // store the new plane
2718 r_waterstate.numwaterplanes++;
2719 VectorCopy(normal, p->plane.normal);
2720 VectorNormalize(p->plane.normal);
2721 p->plane.dist = DotProduct(vert[0], p->plane.normal);
2722 PlaneClassify(&p->plane);
2723 // flip the plane if it does not face the viewer
2724 if (PlaneDiff(r_view.origin, &p->plane) < 0)
2726 VectorNegate(p->plane.normal, p->plane.normal);
2727 p->plane.dist *= -1;
2728 PlaneClassify(&p->plane);
2730 // clear materialflags and pvs
2731 p->materialflags = 0;
2732 p->pvsvalid = false;
2734 // merge this surface's materialflags into the waterplane
2735 p->materialflags |= surface->texture->currentframe->currentmaterialflags;
2736 // merge this surface's PVS into the waterplane
2737 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
2738 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS
2739 && r_refdef.worldmodel->brush.PointInLeaf && r_refdef.worldmodel->brush.PointInLeaf(r_refdef.worldmodel, center)->clusterindex >= 0)
2741 r_refdef.worldmodel->brush.FatPVS(r_refdef.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
2746 static void R_Water_ProcessPlanes(void)
2748 r_view_t originalview;
2750 r_waterstate_waterplane_t *p;
2752 originalview = r_view;
2754 // make sure enough textures are allocated
2755 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2757 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2759 if (!p->texture_refraction)
2760 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);
2761 if (!p->texture_refraction)
2765 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2767 if (!p->texture_reflection)
2768 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);
2769 if (!p->texture_reflection)
2775 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2777 r_view.showdebug = false;
2778 r_view.width = r_waterstate.waterwidth;
2779 r_view.height = r_waterstate.waterheight;
2780 r_view.useclipplane = true;
2781 r_waterstate.renderingscene = true;
2783 // render the normal view scene and copy into texture
2784 // (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)
2785 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2787 r_view.clipplane = p->plane;
2788 VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
2789 r_view.clipplane.dist = -r_view.clipplane.dist;
2790 PlaneClassify(&r_view.clipplane);
2792 R_RenderScene(false);
2794 // copy view into the screen texture
2795 R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
2796 GL_ActiveTexture(0);
2798 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
2801 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2803 // render reflected scene and copy into texture
2804 Matrix4x4_Reflect(&r_view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
2805 r_view.clipplane = p->plane;
2806 // reverse the cullface settings for this render
2807 r_view.cullface_front = GL_FRONT;
2808 r_view.cullface_back = GL_BACK;
2809 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.num_pvsclusterbytes)
2811 r_view.usecustompvs = true;
2813 memcpy(r_viewcache.world_pvsbits, p->pvsbits, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2815 memset(r_viewcache.world_pvsbits, 0xFF, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2818 R_ResetViewRendering3D();
2820 if (r_timereport_active)
2821 R_TimeReport("viewclear");
2823 R_RenderScene(false);
2825 R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
2826 GL_ActiveTexture(0);
2828 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
2830 R_ResetViewRendering3D();
2832 if (r_timereport_active)
2833 R_TimeReport("viewclear");
2836 r_view = originalview;
2837 r_view.clear = true;
2838 r_waterstate.renderingscene = false;
2842 r_view = originalview;
2843 r_waterstate.renderingscene = false;
2844 Cvar_SetValueQuick(&r_water, 0);
2845 Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
2849 void R_Bloom_StartFrame(void)
2851 int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
2853 // set bloomwidth and bloomheight to the bloom resolution that will be
2854 // used (often less than the screen resolution for faster rendering)
2855 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
2856 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_view.height / r_view.width;
2857 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_view.height);
2859 // calculate desired texture sizes
2860 if (gl_support_arb_texture_non_power_of_two)
2862 screentexturewidth = r_view.width;
2863 screentextureheight = r_view.height;
2864 bloomtexturewidth = r_bloomstate.bloomwidth;
2865 bloomtextureheight = r_bloomstate.bloomheight;
2869 for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
2870 for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
2871 for (bloomtexturewidth = 1;bloomtexturewidth < r_bloomstate.bloomwidth ;bloomtexturewidth *= 2);
2872 for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2);
2877 screentexturewidth = screentextureheight = 0;
2879 else if (r_bloom.integer)
2884 screentexturewidth = screentextureheight = 0;
2885 bloomtexturewidth = bloomtextureheight = 0;
2888 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)
2890 // can't use bloom if the parameters are too weird
2891 // can't use bloom if the card does not support the texture size
2892 if (r_bloomstate.texture_screen)
2893 R_FreeTexture(r_bloomstate.texture_screen);
2894 if (r_bloomstate.texture_bloom)
2895 R_FreeTexture(r_bloomstate.texture_bloom);
2896 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
2900 r_bloomstate.enabled = true;
2901 r_bloomstate.hdr = r_hdr.integer != 0;
2903 // allocate textures as needed
2904 if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
2906 if (r_bloomstate.texture_screen)
2907 R_FreeTexture(r_bloomstate.texture_screen);
2908 r_bloomstate.texture_screen = NULL;
2909 r_bloomstate.screentexturewidth = screentexturewidth;
2910 r_bloomstate.screentextureheight = screentextureheight;
2911 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
2912 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);
2914 if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
2916 if (r_bloomstate.texture_bloom)
2917 R_FreeTexture(r_bloomstate.texture_bloom);
2918 r_bloomstate.texture_bloom = NULL;
2919 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
2920 r_bloomstate.bloomtextureheight = bloomtextureheight;
2921 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
2922 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);
2925 // set up a texcoord array for the full resolution screen image
2926 // (we have to keep this around to copy back during final render)
2927 r_bloomstate.screentexcoord2f[0] = 0;
2928 r_bloomstate.screentexcoord2f[1] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2929 r_bloomstate.screentexcoord2f[2] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2930 r_bloomstate.screentexcoord2f[3] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2931 r_bloomstate.screentexcoord2f[4] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2932 r_bloomstate.screentexcoord2f[5] = 0;
2933 r_bloomstate.screentexcoord2f[6] = 0;
2934 r_bloomstate.screentexcoord2f[7] = 0;
2936 // set up a texcoord array for the reduced resolution bloom image
2937 // (which will be additive blended over the screen image)
2938 r_bloomstate.bloomtexcoord2f[0] = 0;
2939 r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2940 r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2941 r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2942 r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2943 r_bloomstate.bloomtexcoord2f[5] = 0;
2944 r_bloomstate.bloomtexcoord2f[6] = 0;
2945 r_bloomstate.bloomtexcoord2f[7] = 0;
2948 void R_Bloom_CopyScreenTexture(float colorscale)
2950 r_refdef.stats.bloom++;
2952 R_ResetViewRendering2D();
2953 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2954 R_Mesh_ColorPointer(NULL, 0, 0);
2955 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
2956 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
2958 // copy view into the screen texture
2959 GL_ActiveTexture(0);
2961 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
2962 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2964 // now scale it down to the bloom texture size
2966 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2967 GL_BlendFunc(GL_ONE, GL_ZERO);
2968 GL_Color(colorscale, colorscale, colorscale, 1);
2969 // TODO: optimize with multitexture or GLSL
2970 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2971 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2973 // we now have a bloom image in the framebuffer
2974 // copy it into the bloom image texture for later processing
2975 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2976 GL_ActiveTexture(0);
2978 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
2979 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2982 void R_Bloom_CopyHDRTexture(void)
2984 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2985 GL_ActiveTexture(0);
2987 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
2988 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2991 void R_Bloom_MakeTexture(void)
2994 float xoffset, yoffset, r, brighten;
2996 r_refdef.stats.bloom++;
2998 R_ResetViewRendering2D();
2999 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3000 R_Mesh_ColorPointer(NULL, 0, 0);
3002 // we have a bloom image in the framebuffer
3004 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3006 for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
3009 r = bound(0, r_bloom_colorexponent.value / x, 1);
3010 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
3011 GL_Color(r, r, r, 1);
3012 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3013 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3014 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3015 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3017 // copy the vertically blurred bloom view to a texture
3018 GL_ActiveTexture(0);
3020 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
3021 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3024 range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
3025 brighten = r_bloom_brighten.value;
3027 brighten *= r_hdr_range.value;
3028 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3029 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
3031 for (dir = 0;dir < 2;dir++)
3033 // blend on at multiple vertical offsets to achieve a vertical blur
3034 // TODO: do offset blends using GLSL
3035 GL_BlendFunc(GL_ONE, GL_ZERO);
3036 for (x = -range;x <= range;x++)
3038 if (!dir){xoffset = 0;yoffset = x;}
3039 else {xoffset = x;yoffset = 0;}
3040 xoffset /= (float)r_bloomstate.bloomtexturewidth;
3041 yoffset /= (float)r_bloomstate.bloomtextureheight;
3042 // compute a texcoord array with the specified x and y offset
3043 r_bloomstate.offsettexcoord2f[0] = xoffset+0;
3044 r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3045 r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3046 r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3047 r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3048 r_bloomstate.offsettexcoord2f[5] = yoffset+0;
3049 r_bloomstate.offsettexcoord2f[6] = xoffset+0;
3050 r_bloomstate.offsettexcoord2f[7] = yoffset+0;
3051 // this r value looks like a 'dot' particle, fading sharply to
3052 // black at the edges
3053 // (probably not realistic but looks good enough)
3054 //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
3055 //r = (dir ? 1.0f : brighten)/(range*2+1);
3056 r = (dir ? 1.0f : brighten)/(range*2+1)*(1 - x*x/(float)(range*range));
3057 GL_Color(r, r, r, 1);
3058 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3059 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3060 GL_BlendFunc(GL_ONE, GL_ONE);
3063 // copy the vertically blurred bloom view to a texture
3064 GL_ActiveTexture(0);
3066 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
3067 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3070 // apply subtract last
3071 // (just like it would be in a GLSL shader)
3072 if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract)
3074 GL_BlendFunc(GL_ONE, GL_ZERO);
3075 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3076 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3077 GL_Color(1, 1, 1, 1);
3078 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3079 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3081 GL_BlendFunc(GL_ONE, GL_ONE);
3082 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
3083 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
3084 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3085 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
3086 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3087 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3088 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3090 // copy the darkened bloom view to a texture
3091 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3092 GL_ActiveTexture(0);
3094 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
3095 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3099 void R_HDR_RenderBloomTexture(void)
3101 int oldwidth, oldheight;
3103 oldwidth = r_view.width;
3104 oldheight = r_view.height;
3105 r_view.width = r_bloomstate.bloomwidth;
3106 r_view.height = r_bloomstate.bloomheight;
3108 // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer? it might improve SLI performance.
3109 // TODO: add exposure compensation features
3110 // TODO: add fp16 framebuffer support
3112 r_view.showdebug = false;
3113 r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
3115 r_view.colorscale /= r_hdr_range.value;
3116 r_waterstate.numwaterplanes = 0;
3117 R_RenderScene(r_waterstate.enabled);
3118 r_view.showdebug = true;
3120 R_ResetViewRendering2D();
3122 R_Bloom_CopyHDRTexture();
3123 R_Bloom_MakeTexture();
3125 R_ResetViewRendering3D();
3128 if (r_timereport_active)
3129 R_TimeReport("viewclear");
3131 // restore the view settings
3132 r_view.width = oldwidth;
3133 r_view.height = oldheight;
3136 static void R_BlendView(void)
3138 if (r_bloomstate.enabled && r_bloomstate.hdr)
3140 // render high dynamic range bloom effect
3141 // the bloom texture was made earlier this render, so we just need to
3142 // blend it onto the screen...
3143 R_ResetViewRendering2D();
3144 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3145 R_Mesh_ColorPointer(NULL, 0, 0);
3146 GL_Color(1, 1, 1, 1);
3147 GL_BlendFunc(GL_ONE, GL_ONE);
3148 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3149 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3150 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3151 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3153 else if (r_bloomstate.enabled)
3155 // render simple bloom effect
3156 // copy the screen and shrink it and darken it for the bloom process
3157 R_Bloom_CopyScreenTexture(r_bloom_colorscale.value);
3158 // make the bloom texture
3159 R_Bloom_MakeTexture();
3160 // put the original screen image back in place and blend the bloom
3162 R_ResetViewRendering2D();
3163 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3164 R_Mesh_ColorPointer(NULL, 0, 0);
3165 GL_Color(1, 1, 1, 1);
3166 GL_BlendFunc(GL_ONE, GL_ZERO);
3167 // do both in one pass if possible
3168 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3169 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3170 if (r_textureunits.integer >= 2 && gl_combine.integer)
3172 R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
3173 R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen));
3174 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0);
3178 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3179 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3180 // now blend on the bloom texture
3181 GL_BlendFunc(GL_ONE, GL_ONE);
3182 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3183 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3185 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3186 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3188 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
3190 // apply a color tint to the whole view
3191 R_ResetViewRendering2D();
3192 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3193 R_Mesh_ColorPointer(NULL, 0, 0);
3194 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3195 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
3196 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3200 void R_RenderScene(qboolean addwaterplanes);
3202 matrix4x4_t r_waterscrollmatrix;
3204 void R_UpdateVariables(void)
3208 r_refdef.farclip = 4096;
3209 if (r_refdef.worldmodel)
3210 r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
3211 r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
3213 if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
3214 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
3215 r_refdef.polygonfactor = 0;
3216 r_refdef.polygonoffset = 0;
3217 r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3218 r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3220 r_refdef.rtworld = r_shadow_realtime_world.integer;
3221 r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
3222 r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
3223 r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
3224 r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
3225 if (r_showsurfaces.integer)
3227 r_refdef.rtworld = false;
3228 r_refdef.rtworldshadows = false;
3229 r_refdef.rtdlight = false;
3230 r_refdef.rtdlightshadows = false;
3231 r_refdef.lightmapintensity = 0;
3234 if (gamemode == GAME_NEHAHRA)
3236 if (gl_fogenable.integer)
3238 r_refdef.oldgl_fogenable = true;
3239 r_refdef.fog_density = gl_fogdensity.value;
3240 r_refdef.fog_red = gl_fogred.value;
3241 r_refdef.fog_green = gl_foggreen.value;
3242 r_refdef.fog_blue = gl_fogblue.value;
3244 else if (r_refdef.oldgl_fogenable)
3246 r_refdef.oldgl_fogenable = false;
3247 r_refdef.fog_density = 0;
3248 r_refdef.fog_red = 0;
3249 r_refdef.fog_green = 0;
3250 r_refdef.fog_blue = 0;
3253 if (r_refdef.fog_density)
3255 r_refdef.fogcolor[0] = r_refdef.fog_red;
3256 r_refdef.fogcolor[1] = r_refdef.fog_green;
3257 r_refdef.fogcolor[2] = r_refdef.fog_blue;
3261 // color.rgb *= SceneBrightness;
3262 VectorScale(r_refdef.fogcolor, r_view.colorscale, fogvec);
3263 if(r_glsl.integer && (r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)) // need to support contrast boost
3265 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
3266 fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
3267 fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
3268 fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
3270 r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
3271 r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
3272 r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
3276 if (r_refdef.fog_density)
3278 r_refdef.fogenabled = true;
3279 // this is the point where the fog reaches 0.9986 alpha, which we
3280 // consider a good enough cutoff point for the texture
3281 // (0.9986 * 256 == 255.6)
3282 r_refdef.fogrange = 16 / (r_refdef.fog_density * r_refdef.fog_density);
3283 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
3284 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
3285 // fog color was already set
3288 r_refdef.fogenabled = false;
3296 void R_RenderView(void)
3298 if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
3299 return; //Host_Error ("R_RenderView: NULL worldmodel");
3301 R_Shadow_UpdateWorldLightSelection();
3303 R_Bloom_StartFrame();
3304 R_Water_StartFrame();
3307 if (r_timereport_active)
3308 R_TimeReport("viewsetup");
3310 R_ResetViewRendering3D();
3315 if (r_timereport_active)
3316 R_TimeReport("viewclear");
3318 r_view.clear = true;
3320 r_view.showdebug = true;
3322 // this produces a bloom texture to be used in R_BlendView() later
3324 R_HDR_RenderBloomTexture();
3326 r_view.colorscale = r_hdr_scenebrightness.value;
3327 r_waterstate.numwaterplanes = 0;
3328 R_RenderScene(r_waterstate.enabled);
3331 if (r_timereport_active)
3332 R_TimeReport("blendview");
3334 GL_Scissor(0, 0, vid.width, vid.height);
3335 GL_ScissorTest(false);
3339 extern void R_DrawLightningBeams (void);
3340 extern void VM_CL_AddPolygonsToMeshQueue (void);
3341 extern void R_DrawPortals (void);
3342 extern cvar_t cl_locs_show;
3343 static void R_DrawLocs(void);
3344 static void R_DrawEntityBBoxes(void);
3345 void R_RenderScene(qboolean addwaterplanes)
3349 R_ResetViewRendering3D();
3352 if (r_timereport_active)
3353 R_TimeReport("watervis");
3355 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawAddWaterPlanes)
3357 r_refdef.worldmodel->DrawAddWaterPlanes(r_refdef.worldentity);
3358 if (r_timereport_active)
3359 R_TimeReport("waterworld");
3362 // don't let sound skip if going slow
3363 if (r_refdef.extraupdate)
3366 R_DrawModelsAddWaterPlanes();
3367 if (r_timereport_active)
3368 R_TimeReport("watermodels");
3370 R_Water_ProcessPlanes();
3371 if (r_timereport_active)
3372 R_TimeReport("waterscenes");
3375 R_ResetViewRendering3D();
3377 // don't let sound skip if going slow
3378 if (r_refdef.extraupdate)
3381 R_MeshQueue_BeginScene();
3386 if (r_timereport_active)
3387 R_TimeReport("visibility");
3389 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);
3391 if (cl.csqc_vidvars.drawworld)
3393 // don't let sound skip if going slow
3394 if (r_refdef.extraupdate)
3397 if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
3399 r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
3400 if (r_timereport_active)
3401 R_TimeReport("worldsky");
3404 if (R_DrawBrushModelsSky() && r_timereport_active)
3405 R_TimeReport("bmodelsky");
3408 if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawDepth)
3410 r_refdef.worldmodel->DrawDepth(r_refdef.worldentity);
3411 if (r_timereport_active)
3412 R_TimeReport("worlddepth");
3414 if (r_depthfirst.integer >= 2)
3416 R_DrawModelsDepth();
3417 if (r_timereport_active)
3418 R_TimeReport("modeldepth");
3421 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->Draw)
3423 r_refdef.worldmodel->Draw(r_refdef.worldentity);
3424 if (r_timereport_active)
3425 R_TimeReport("world");
3428 // don't let sound skip if going slow
3429 if (r_refdef.extraupdate)
3433 if (r_timereport_active)
3434 R_TimeReport("models");
3436 // don't let sound skip if going slow
3437 if (r_refdef.extraupdate)
3440 if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
3442 R_DrawModelShadows();
3444 R_ResetViewRendering3D();
3446 // don't let sound skip if going slow
3447 if (r_refdef.extraupdate)
3451 R_ShadowVolumeLighting(false);
3452 if (r_timereport_active)
3453 R_TimeReport("rtlights");
3455 // don't let sound skip if going slow
3456 if (r_refdef.extraupdate)
3459 if (cl.csqc_vidvars.drawworld)
3461 R_DrawLightningBeams();
3462 if (r_timereport_active)
3463 R_TimeReport("lightning");
3466 if (r_timereport_active)
3467 R_TimeReport("decals");
3470 if (r_timereport_active)
3471 R_TimeReport("particles");
3474 if (r_timereport_active)
3475 R_TimeReport("explosions");
3478 if (gl_support_fragment_shader)
3480 qglUseProgramObjectARB(0);CHECKGLERROR
3482 VM_CL_AddPolygonsToMeshQueue();
3484 if (r_view.showdebug)
3486 if (cl_locs_show.integer)
3489 if (r_timereport_active)
3490 R_TimeReport("showlocs");
3493 if (r_drawportals.integer)
3496 if (r_timereport_active)
3497 R_TimeReport("portals");
3500 if (r_showbboxes.value > 0)
3502 R_DrawEntityBBoxes();
3503 if (r_timereport_active)
3504 R_TimeReport("bboxes");
3508 if (gl_support_fragment_shader)
3510 qglUseProgramObjectARB(0);CHECKGLERROR
3512 R_MeshQueue_RenderTransparent();
3513 if (r_timereport_active)
3514 R_TimeReport("drawtrans");
3516 if (gl_support_fragment_shader)
3518 qglUseProgramObjectARB(0);CHECKGLERROR
3521 if (r_view.showdebug && r_refdef.worldmodel && r_refdef.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value > 0 || r_showcollisionbrushes.value > 0))
3523 r_refdef.worldmodel->DrawDebug(r_refdef.worldentity);
3524 if (r_timereport_active)
3525 R_TimeReport("worlddebug");
3526 R_DrawModelsDebug();
3527 if (r_timereport_active)
3528 R_TimeReport("modeldebug");
3531 if (gl_support_fragment_shader)
3533 qglUseProgramObjectARB(0);CHECKGLERROR
3536 if (cl.csqc_vidvars.drawworld)
3539 if (r_timereport_active)
3540 R_TimeReport("coronas");
3543 // don't let sound skip if going slow
3544 if (r_refdef.extraupdate)
3547 R_ResetViewRendering2D();
3550 static const int bboxelements[36] =
3560 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
3563 float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
3564 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3565 GL_DepthMask(false);
3566 GL_DepthRange(0, 1);
3567 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3568 R_Mesh_Matrix(&identitymatrix);
3569 R_Mesh_ResetTextureState();
3571 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
3572 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
3573 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
3574 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
3575 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
3576 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
3577 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
3578 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
3579 R_FillColors(color4f, 8, cr, cg, cb, ca);
3580 if (r_refdef.fogenabled)
3582 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
3584 f1 = FogPoint_World(v);
3586 c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
3587 c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
3588 c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
3591 R_Mesh_VertexPointer(vertex3f, 0, 0);
3592 R_Mesh_ColorPointer(color4f, 0, 0);
3593 R_Mesh_ResetTextureState();
3594 R_Mesh_Draw(0, 8, 12, bboxelements, 0, 0);
3597 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3601 prvm_edict_t *edict;
3602 // this function draws bounding boxes of server entities
3606 for (i = 0;i < numsurfaces;i++)
3608 edict = PRVM_EDICT_NUM(surfacelist[i]);
3609 switch ((int)edict->fields.server->solid)
3611 case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
3612 case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
3613 case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
3614 case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
3615 case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
3616 default: Vector4Set(color, 0, 0, 0, 0.50);break;
3618 color[3] *= r_showbboxes.value;
3619 color[3] = bound(0, color[3], 1);
3620 GL_DepthTest(!r_showdisabledepthtest.integer);
3621 GL_CullFace(r_view.cullface_front);
3622 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
3627 static void R_DrawEntityBBoxes(void)
3630 prvm_edict_t *edict;
3632 // this function draws bounding boxes of server entities
3636 for (i = 0;i < prog->num_edicts;i++)
3638 edict = PRVM_EDICT_NUM(i);
3639 if (edict->priv.server->free)
3641 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
3642 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
3647 int nomodelelements[24] =
3659 float nomodelvertex3f[6*3] =
3669 float nomodelcolor4f[6*4] =
3671 0.0f, 0.0f, 0.5f, 1.0f,
3672 0.0f, 0.0f, 0.5f, 1.0f,
3673 0.0f, 0.5f, 0.0f, 1.0f,
3674 0.0f, 0.5f, 0.0f, 1.0f,
3675 0.5f, 0.0f, 0.0f, 1.0f,
3676 0.5f, 0.0f, 0.0f, 1.0f
3679 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3684 // this is only called once per entity so numsurfaces is always 1, and
3685 // surfacelist is always {0}, so this code does not handle batches
3686 R_Mesh_Matrix(&ent->matrix);
3688 if (ent->flags & EF_ADDITIVE)
3690 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
3691 GL_DepthMask(false);
3693 else if (ent->alpha < 1)
3695 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3696 GL_DepthMask(false);
3700 GL_BlendFunc(GL_ONE, GL_ZERO);
3703 GL_DepthRange(0, (ent->flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
3704 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3705 GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
3706 GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : r_view.cullface_back);
3707 R_Mesh_VertexPointer(nomodelvertex3f, 0, 0);
3708 if (r_refdef.fogenabled)
3711 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3712 R_Mesh_ColorPointer(color4f, 0, 0);
3713 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3714 f1 = FogPoint_World(org);
3716 for (i = 0, c = color4f;i < 6;i++, c += 4)
3718 c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
3719 c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
3720 c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
3724 else if (ent->alpha != 1)
3726 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3727 R_Mesh_ColorPointer(color4f, 0, 0);
3728 for (i = 0, c = color4f;i < 6;i++, c += 4)
3732 R_Mesh_ColorPointer(nomodelcolor4f, 0, 0);
3733 R_Mesh_ResetTextureState();
3734 R_Mesh_Draw(0, 6, 8, nomodelelements, 0, 0);
3737 void R_DrawNoModel(entity_render_t *ent)
3740 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3741 //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
3742 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
3744 // R_DrawNoModelCallback(ent, 0);
3747 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
3749 vec3_t right1, right2, diff, normal;
3751 VectorSubtract (org2, org1, normal);
3753 // calculate 'right' vector for start
3754 VectorSubtract (r_view.origin, org1, diff);
3755 CrossProduct (normal, diff, right1);
3756 VectorNormalize (right1);
3758 // calculate 'right' vector for end
3759 VectorSubtract (r_view.origin, org2, diff);
3760 CrossProduct (normal, diff, right2);
3761 VectorNormalize (right2);
3763 vert[ 0] = org1[0] + width * right1[0];
3764 vert[ 1] = org1[1] + width * right1[1];
3765 vert[ 2] = org1[2] + width * right1[2];
3766 vert[ 3] = org1[0] - width * right1[0];
3767 vert[ 4] = org1[1] - width * right1[1];
3768 vert[ 5] = org1[2] - width * right1[2];
3769 vert[ 6] = org2[0] - width * right2[0];
3770 vert[ 7] = org2[1] - width * right2[1];
3771 vert[ 8] = org2[2] - width * right2[2];
3772 vert[ 9] = org2[0] + width * right2[0];
3773 vert[10] = org2[1] + width * right2[1];
3774 vert[11] = org2[2] + width * right2[2];
3777 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
3779 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)
3784 if (r_refdef.fogenabled)
3785 fog = FogPoint_World(origin);
3787 R_Mesh_Matrix(&identitymatrix);
3788 GL_BlendFunc(blendfunc1, blendfunc2);
3794 GL_CullFace(r_view.cullface_front);
3797 GL_CullFace(r_view.cullface_back);
3799 GL_DepthMask(false);
3800 GL_DepthRange(0, depthshort ? 0.0625 : 1);
3801 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3802 GL_DepthTest(!depthdisable);
3804 vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
3805 vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
3806 vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
3807 vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
3808 vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
3809 vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
3810 vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
3811 vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
3812 vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
3813 vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
3814 vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
3815 vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
3817 R_Mesh_VertexPointer(vertex3f, 0, 0);
3818 R_Mesh_ColorPointer(NULL, 0, 0);
3819 R_Mesh_ResetTextureState();
3820 R_Mesh_TexBind(0, R_GetTexture(texture));
3821 R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f, 0, 0);
3822 // FIXME: fixed function path can't properly handle r_view.colorscale > 1
3823 GL_Color(cr * fog * r_view.colorscale, cg * fog * r_view.colorscale, cb * fog * r_view.colorscale, ca);
3824 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3826 if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
3828 R_Mesh_TexBind(0, R_GetTexture(fogtexture));
3829 GL_BlendFunc(blendfunc1, GL_ONE);
3831 GL_Color(r_refdef.fogcolor[0] * fog * r_view.colorscale, r_refdef.fogcolor[1] * fog * r_view.colorscale, r_refdef.fogcolor[2] * fog * r_view.colorscale, ca);
3832 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3836 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
3841 VectorSet(v, x, y, z);
3842 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
3843 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
3845 if (i == mesh->numvertices)
3847 if (mesh->numvertices < mesh->maxvertices)
3849 VectorCopy(v, vertex3f);
3850 mesh->numvertices++;
3852 return mesh->numvertices;
3858 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
3862 element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3863 element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3864 e = mesh->element3i + mesh->numtriangles * 3;
3865 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
3867 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
3868 if (mesh->numtriangles < mesh->maxtriangles)
3873 mesh->numtriangles++;
3875 element[1] = element[2];
3879 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
3883 element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3884 element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3885 e = mesh->element3i + mesh->numtriangles * 3;
3886 for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
3888 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
3889 if (mesh->numtriangles < mesh->maxtriangles)
3894 mesh->numtriangles++;
3896 element[1] = element[2];
3900 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
3901 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
3903 int planenum, planenum2;
3906 mplane_t *plane, *plane2;
3908 double temppoints[2][256*3];
3909 // figure out how large a bounding box we need to properly compute this brush
3911 for (w = 0;w < numplanes;w++)
3912 maxdist = max(maxdist, planes[w].dist);
3913 // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
3914 maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
3915 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
3919 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
3920 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
3922 if (planenum2 == planenum)
3924 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);
3927 if (tempnumpoints < 3)
3929 // generate elements forming a triangle fan for this polygon
3930 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
3934 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)
3936 texturelayer_t *layer;
3937 layer = t->currentlayers + t->currentnumlayers++;
3939 layer->depthmask = depthmask;
3940 layer->blendfunc1 = blendfunc1;
3941 layer->blendfunc2 = blendfunc2;
3942 layer->texture = texture;
3943 layer->texmatrix = *matrix;
3944 layer->color[0] = r * r_view.colorscale;
3945 layer->color[1] = g * r_view.colorscale;
3946 layer->color[2] = b * r_view.colorscale;
3947 layer->color[3] = a;
3950 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
3953 index = parms[2] + r_refdef.time * parms[3];
3954 index -= floor(index);
3958 case Q3WAVEFUNC_NONE:
3959 case Q3WAVEFUNC_NOISE:
3960 case Q3WAVEFUNC_COUNT:
3963 case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
3964 case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
3965 case Q3WAVEFUNC_SAWTOOTH: f = index;break;
3966 case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
3967 case Q3WAVEFUNC_TRIANGLE:
3969 f = index - floor(index);
3980 return (float)(parms[0] + parms[1] * f);
3983 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
3986 model_t *model = ent->model;
3989 q3shaderinfo_layer_tcmod_t *tcmod;
3991 // switch to an alternate material if this is a q1bsp animated material
3993 texture_t *texture = t;
3994 int s = ent->skinnum;
3995 if ((unsigned int)s >= (unsigned int)model->numskins)
3997 if (model->skinscenes)
3999 if (model->skinscenes[s].framecount > 1)
4000 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
4002 s = model->skinscenes[s].firstframe;
4005 t = t + s * model->num_surfaces;
4008 // use an alternate animation if the entity's frame is not 0,
4009 // and only if the texture has an alternate animation
4010 if (ent->frame2 != 0 && t->anim_total[1])
4011 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
4013 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
4015 texture->currentframe = t;
4018 // update currentskinframe to be a qw skin or animation frame
4019 if ((i = ent->entitynumber - 1) >= 0 && i < cl.maxclients)
4021 if (strcmp(r_qwskincache[i], cl.scores[i].qw_skin))
4023 strlcpy(r_qwskincache[i], cl.scores[i].qw_skin, sizeof(r_qwskincache[i]));
4024 Con_DPrintf("loading skins/%s\n", r_qwskincache[i]);
4025 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);
4027 t->currentskinframe = r_qwskincache_skinframe[i];
4028 if (t->currentskinframe == NULL)
4029 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4031 else if (t->numskinframes >= 2)
4032 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4033 if (t->backgroundnumskinframes >= 2)
4034 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - ent->frame2time)) % t->backgroundnumskinframes];
4036 t->currentmaterialflags = t->basematerialflags;
4037 t->currentalpha = ent->alpha;
4038 if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
4040 t->currentalpha *= r_wateralpha.value;
4042 * FIXME what is this supposed to do?
4043 // if rendering refraction/reflection, disable transparency
4044 if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
4045 t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
4048 if(!r_waterstate.enabled)
4049 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
4050 if (!(ent->flags & RENDER_LIGHT))
4051 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
4052 else if (rsurface.modeltexcoordlightmap2f == NULL)
4054 // pick a model lighting mode
4055 if (VectorLength2(ent->modellight_diffuse) >= (1.0f / 256.0f))
4056 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
4058 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
4060 if (ent->effects & EF_ADDITIVE)
4061 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4062 else if (t->currentalpha < 1)
4063 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4064 if (ent->effects & EF_DOUBLESIDED)
4065 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
4066 if (ent->effects & EF_NODEPTHTEST)
4067 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4068 if (ent->flags & RENDER_VIEWMODEL)
4069 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4070 if (t->backgroundnumskinframes && !(t->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
4071 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
4073 // make sure that the waterscroll matrix is used on water surfaces when
4074 // there is no tcmod
4075 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4076 t->currenttexmatrix = r_waterscrollmatrix;
4078 for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
4081 switch(tcmod->tcmod)
4085 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4086 matrix = r_waterscrollmatrix;
4088 matrix = identitymatrix;
4090 case Q3TCMOD_ENTITYTRANSLATE:
4091 // this is used in Q3 to allow the gamecode to control texcoord
4092 // scrolling on the entity, which is not supported in darkplaces yet.
4093 Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
4095 case Q3TCMOD_ROTATE:
4096 Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
4097 Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.time, 0, 0, 1);
4098 Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
4101 Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
4103 case Q3TCMOD_SCROLL:
4104 Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.time, tcmod->parms[1] * r_refdef.time, 0);
4106 case Q3TCMOD_STRETCH:
4107 f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
4108 Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
4110 case Q3TCMOD_TRANSFORM:
4111 VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
4112 VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
4113 VectorSet(tcmat + 6, 0 , 0 , 1);
4114 VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
4115 Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
4117 case Q3TCMOD_TURBULENT:
4118 // this is handled in the RSurf_PrepareVertices function
4119 matrix = identitymatrix;
4122 // either replace or concatenate the transformation
4124 t->currenttexmatrix = matrix;
4127 matrix4x4_t temp = t->currenttexmatrix;
4128 Matrix4x4_Concat(&t->currenttexmatrix, &matrix, &temp);
4132 t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
4133 t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4134 t->glosstexture = r_texture_black;
4135 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
4136 t->backgroundglosstexture = r_texture_black;
4137 t->specularpower = r_shadow_glossexponent.value;
4138 // TODO: store reference values for these in the texture?
4139 t->specularscale = 0;
4140 if (r_shadow_gloss.integer > 0)
4142 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
4144 if (r_shadow_glossintensity.value > 0)
4146 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
4147 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
4148 t->specularscale = r_shadow_glossintensity.value;
4151 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
4153 t->glosstexture = r_texture_white;
4154 t->backgroundglosstexture = r_texture_white;
4155 t->specularscale = r_shadow_gloss2intensity.value;
4159 // lightmaps mode looks bad with dlights using actual texturing, so turn
4160 // off the colormap and glossmap, but leave the normalmap on as it still
4161 // accurately represents the shading involved
4162 if (gl_lightmaps.integer && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
4164 t->basetexture = r_texture_white;
4165 t->specularscale = 0;
4168 t->currentpolygonfactor = r_refdef.polygonfactor + t->basepolygonfactor;
4169 t->currentpolygonoffset = r_refdef.polygonoffset + t->basepolygonoffset;
4170 // submodels are biased to avoid z-fighting with world surfaces that they
4171 // may be exactly overlapping (avoids z-fighting artifacts on certain
4172 // doors and things in Quake maps)
4173 if (ent->model->brush.submodel)
4175 t->currentpolygonfactor += r_polygonoffset_submodel_factor.value;
4176 t->currentpolygonoffset += r_polygonoffset_submodel_offset.value;
4179 VectorClear(t->dlightcolor);
4180 t->currentnumlayers = 0;
4181 if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
4183 if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
4185 int blendfunc1, blendfunc2, depthmask;
4186 if (t->currentmaterialflags & MATERIALFLAG_ADD)
4188 blendfunc1 = GL_SRC_ALPHA;
4189 blendfunc2 = GL_ONE;
4191 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
4193 blendfunc1 = GL_SRC_ALPHA;
4194 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
4196 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
4198 blendfunc1 = t->customblendfunc[0];
4199 blendfunc2 = t->customblendfunc[1];
4203 blendfunc1 = GL_ONE;
4204 blendfunc2 = GL_ZERO;
4206 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
4207 if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
4209 rtexture_t *currentbasetexture;
4211 if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
4212 layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
4213 currentbasetexture = (VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) < (1.0f / 1048576.0f) && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4214 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
4216 // fullbright is not affected by r_refdef.lightmapintensity
4217 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
4218 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4219 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);
4220 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4221 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);
4226 // set the color tint used for lights affecting this surface
4227 VectorSet(t->dlightcolor, ent->colormod[0] * t->currentalpha, ent->colormod[1] * t->currentalpha, ent->colormod[2] * t->currentalpha);
4229 // q3bsp has no lightmap updates, so the lightstylevalue that
4230 // would normally be baked into the lightmap must be
4231 // applied to the color
4232 // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
4233 if (ent->model->type == mod_brushq3)
4234 colorscale *= r_refdef.rtlightstylevalue[0];
4235 colorscale *= r_refdef.lightmapintensity;
4236 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);
4237 if (r_ambient.value >= (1.0f/64.0f))
4238 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);
4239 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4241 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);
4242 if (r_ambient.value >= (1.0f/64.0f))
4243 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);
4245 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4247 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);
4248 if (r_ambient.value >= (1.0f/64.0f))
4249 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);
4252 if (t->currentskinframe->glow != NULL)
4253 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);
4254 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
4256 // if this is opaque use alpha blend which will darken the earlier
4259 // if this is an alpha blended material, all the earlier passes
4260 // were darkened by fog already, so we only need to add the fog
4261 // color ontop through the fog mask texture
4263 // if this is an additive blended material, all the earlier passes
4264 // were darkened by fog already, and we should not add fog color
4265 // (because the background was not darkened, there is no fog color
4266 // that was lost behind it).
4267 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);
4274 void R_UpdateAllTextureInfo(entity_render_t *ent)
4278 for (i = 0;i < ent->model->num_texturesperskin;i++)
4279 R_UpdateTextureInfo(ent, ent->model->data_textures + i);
4282 rsurfacestate_t rsurface;
4284 void R_Mesh_ResizeArrays(int newvertices)
4287 if (rsurface.array_size >= newvertices)
4289 if (rsurface.array_modelvertex3f)
4290 Mem_Free(rsurface.array_modelvertex3f);
4291 rsurface.array_size = (newvertices + 1023) & ~1023;
4292 base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
4293 rsurface.array_modelvertex3f = base + rsurface.array_size * 0;
4294 rsurface.array_modelsvector3f = base + rsurface.array_size * 3;
4295 rsurface.array_modeltvector3f = base + rsurface.array_size * 6;
4296 rsurface.array_modelnormal3f = base + rsurface.array_size * 9;
4297 rsurface.array_deformedvertex3f = base + rsurface.array_size * 12;
4298 rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
4299 rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
4300 rsurface.array_deformednormal3f = base + rsurface.array_size * 21;
4301 rsurface.array_texcoord3f = base + rsurface.array_size * 24;
4302 rsurface.array_color4f = base + rsurface.array_size * 27;
4303 rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
4306 void RSurf_CleanUp(void)
4309 if (rsurface.mode == RSURFMODE_GLSL)
4311 qglUseProgramObjectARB(0);CHECKGLERROR
4313 GL_AlphaTest(false);
4314 rsurface.mode = RSURFMODE_NONE;
4315 rsurface.uselightmaptexture = false;
4316 rsurface.texture = NULL;
4319 void RSurf_ActiveWorldEntity(void)
4321 model_t *model = r_refdef.worldmodel;
4323 if (rsurface.array_size < model->surfmesh.num_vertices)
4324 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4325 rsurface.matrix = identitymatrix;
4326 rsurface.inversematrix = identitymatrix;
4327 R_Mesh_Matrix(&identitymatrix);
4328 VectorCopy(r_view.origin, rsurface.modelorg);
4329 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
4330 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
4331 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
4332 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
4333 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
4334 rsurface.frameblend[0].frame = 0;
4335 rsurface.frameblend[0].lerp = 1;
4336 rsurface.frameblend[1].frame = 0;
4337 rsurface.frameblend[1].lerp = 0;
4338 rsurface.frameblend[2].frame = 0;
4339 rsurface.frameblend[2].lerp = 0;
4340 rsurface.frameblend[3].frame = 0;
4341 rsurface.frameblend[3].lerp = 0;
4342 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4343 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4344 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4345 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4346 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4347 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4348 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4349 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4350 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4351 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4352 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4353 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4354 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4355 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4356 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4357 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4358 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4359 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4360 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4361 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4362 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4363 rsurface.modelelement3i = model->surfmesh.data_element3i;
4364 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4365 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4366 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4367 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4368 rsurface.modelsurfaces = model->data_surfaces;
4369 rsurface.generatedvertex = false;
4370 rsurface.vertex3f = rsurface.modelvertex3f;
4371 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4372 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4373 rsurface.svector3f = rsurface.modelsvector3f;
4374 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4375 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4376 rsurface.tvector3f = rsurface.modeltvector3f;
4377 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4378 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4379 rsurface.normal3f = rsurface.modelnormal3f;
4380 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4381 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4382 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4385 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4387 model_t *model = ent->model;
4389 if (rsurface.array_size < model->surfmesh.num_vertices)
4390 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4391 rsurface.matrix = ent->matrix;
4392 rsurface.inversematrix = ent->inversematrix;
4393 R_Mesh_Matrix(&rsurface.matrix);
4394 Matrix4x4_Transform(&rsurface.inversematrix, r_view.origin, rsurface.modelorg);
4395 VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
4396 VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
4397 VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
4398 VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
4399 VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
4400 rsurface.frameblend[0] = ent->frameblend[0];
4401 rsurface.frameblend[1] = ent->frameblend[1];
4402 rsurface.frameblend[2] = ent->frameblend[2];
4403 rsurface.frameblend[3] = ent->frameblend[3];
4404 if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0))
4408 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4409 rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4410 rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4411 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4412 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
4414 else if (wantnormals)
4416 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4417 rsurface.modelsvector3f = NULL;
4418 rsurface.modeltvector3f = NULL;
4419 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4420 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
4424 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4425 rsurface.modelsvector3f = NULL;
4426 rsurface.modeltvector3f = NULL;
4427 rsurface.modelnormal3f = NULL;
4428 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL);
4430 rsurface.modelvertex3f_bufferobject = 0;
4431 rsurface.modelvertex3f_bufferoffset = 0;
4432 rsurface.modelsvector3f_bufferobject = 0;
4433 rsurface.modelsvector3f_bufferoffset = 0;
4434 rsurface.modeltvector3f_bufferobject = 0;
4435 rsurface.modeltvector3f_bufferoffset = 0;
4436 rsurface.modelnormal3f_bufferobject = 0;
4437 rsurface.modelnormal3f_bufferoffset = 0;
4438 rsurface.generatedvertex = true;
4442 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4443 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4444 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4445 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4446 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4447 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4448 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4449 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4450 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4451 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4452 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4453 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4454 rsurface.generatedvertex = false;
4456 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4457 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4458 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4459 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4460 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4461 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4462 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4463 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4464 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4465 rsurface.modelelement3i = model->surfmesh.data_element3i;
4466 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4467 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4468 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4469 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4470 rsurface.modelsurfaces = model->data_surfaces;
4471 rsurface.vertex3f = rsurface.modelvertex3f;
4472 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4473 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4474 rsurface.svector3f = rsurface.modelsvector3f;
4475 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4476 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4477 rsurface.tvector3f = rsurface.modeltvector3f;
4478 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4479 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4480 rsurface.normal3f = rsurface.modelnormal3f;
4481 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4482 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4483 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4486 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
4487 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
4490 int texturesurfaceindex;
4495 const float *v1, *in_tc;
4497 float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
4499 q3shaderinfo_deform_t *deform;
4500 // 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
4501 if (rsurface.generatedvertex)
4503 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
4504 generatenormals = true;
4505 for (i = 0;i < Q3MAXDEFORMS;i++)
4507 if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
4509 generatetangents = true;
4510 generatenormals = true;
4512 if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
4513 generatenormals = true;
4515 if (generatenormals && !rsurface.modelnormal3f)
4517 rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4518 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
4519 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
4520 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer);
4522 if (generatetangents && !rsurface.modelsvector3f)
4524 rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4525 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
4526 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
4527 rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4528 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
4529 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
4530 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);
4533 rsurface.vertex3f = rsurface.modelvertex3f;
4534 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4535 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4536 rsurface.svector3f = rsurface.modelsvector3f;
4537 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4538 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4539 rsurface.tvector3f = rsurface.modeltvector3f;
4540 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4541 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4542 rsurface.normal3f = rsurface.modelnormal3f;
4543 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4544 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4545 // if vertices are deformed (sprite flares and things in maps, possibly
4546 // water waves, bulges and other deformations), generate them into
4547 // rsurface.deform* arrays from whatever the rsurface.* arrays point to
4548 // (may be static model data or generated data for an animated model, or
4549 // the previous deform pass)
4550 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
4552 switch (deform->deform)
4555 case Q3DEFORM_PROJECTIONSHADOW:
4556 case Q3DEFORM_TEXT0:
4557 case Q3DEFORM_TEXT1:
4558 case Q3DEFORM_TEXT2:
4559 case Q3DEFORM_TEXT3:
4560 case Q3DEFORM_TEXT4:
4561 case Q3DEFORM_TEXT5:
4562 case Q3DEFORM_TEXT6:
4563 case Q3DEFORM_TEXT7:
4566 case Q3DEFORM_AUTOSPRITE:
4567 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4568 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4569 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4570 VectorNormalize(newforward);
4571 VectorNormalize(newright);
4572 VectorNormalize(newup);
4573 // make deformed versions of only the model vertices used by the specified surfaces
4574 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4576 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4577 // a single autosprite surface can contain multiple sprites...
4578 for (j = 0;j < surface->num_vertices - 3;j += 4)
4580 VectorClear(center);
4581 for (i = 0;i < 4;i++)
4582 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4583 VectorScale(center, 0.25f, center);
4584 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, forward);
4585 VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
4586 VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
4587 for (i = 0;i < 4;i++)
4589 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
4590 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4593 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);
4594 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);
4596 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4597 rsurface.vertex3f_bufferobject = 0;
4598 rsurface.vertex3f_bufferoffset = 0;
4599 rsurface.svector3f = rsurface.array_deformedsvector3f;
4600 rsurface.svector3f_bufferobject = 0;
4601 rsurface.svector3f_bufferoffset = 0;
4602 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4603 rsurface.tvector3f_bufferobject = 0;
4604 rsurface.tvector3f_bufferoffset = 0;
4605 rsurface.normal3f = rsurface.array_deformednormal3f;
4606 rsurface.normal3f_bufferobject = 0;
4607 rsurface.normal3f_bufferoffset = 0;
4609 case Q3DEFORM_AUTOSPRITE2:
4610 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4611 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4612 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4613 VectorNormalize(newforward);
4614 VectorNormalize(newright);
4615 VectorNormalize(newup);
4616 // make deformed versions of only the model vertices used by the specified surfaces
4617 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4619 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4620 const float *v1, *v2;
4630 memset(shortest, 0, sizeof(shortest));
4631 // a single autosprite surface can contain multiple sprites...
4632 for (j = 0;j < surface->num_vertices - 3;j += 4)
4634 VectorClear(center);
4635 for (i = 0;i < 4;i++)
4636 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4637 VectorScale(center, 0.25f, center);
4638 // find the two shortest edges, then use them to define the
4639 // axis vectors for rotating around the central axis
4640 for (i = 0;i < 6;i++)
4642 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
4643 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
4645 Debug_PolygonBegin(NULL, 0, false, 0);
4646 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
4647 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);
4648 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
4651 l = VectorDistance2(v1, v2);
4652 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
4654 l += (1.0f / 1024.0f);
4655 if (shortest[0].length2 > l || i == 0)
4657 shortest[1] = shortest[0];
4658 shortest[0].length2 = l;
4659 shortest[0].v1 = v1;
4660 shortest[0].v2 = v2;
4662 else if (shortest[1].length2 > l || i == 1)
4664 shortest[1].length2 = l;
4665 shortest[1].v1 = v1;
4666 shortest[1].v2 = v2;
4669 VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
4670 VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
4672 Debug_PolygonBegin(NULL, 0, false, 0);
4673 Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
4674 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);
4675 Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
4678 // this calculates the right vector from the shortest edge
4679 // and the up vector from the edge midpoints
4680 VectorSubtract(shortest[0].v1, shortest[0].v2, right);
4681 VectorNormalize(right);
4682 VectorSubtract(end, start, up);
4683 VectorNormalize(up);
4684 // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
4685 //VectorSubtract(rsurface.modelorg, center, forward);
4686 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, forward);
4687 VectorNegate(forward, forward);
4688 VectorReflect(forward, 0, up, forward);
4689 VectorNormalize(forward);
4690 CrossProduct(up, forward, newright);
4691 VectorNormalize(newright);
4693 Debug_PolygonBegin(NULL, 0, false, 0);
4694 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);
4695 Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
4696 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4700 Debug_PolygonBegin(NULL, 0, false, 0);
4701 Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
4702 Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
4703 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4706 // rotate the quad around the up axis vector, this is made
4707 // especially easy by the fact we know the quad is flat,
4708 // so we only have to subtract the center position and
4709 // measure distance along the right vector, and then
4710 // multiply that by the newright vector and add back the
4712 // we also need to subtract the old position to undo the
4713 // displacement from the center, which we do with a
4714 // DotProduct, the subtraction/addition of center is also
4715 // optimized into DotProducts here
4716 l = DotProduct(right, center);
4717 for (i = 0;i < 4;i++)
4719 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
4720 f = DotProduct(right, v1) - l;
4721 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4724 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);
4725 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);
4727 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4728 rsurface.vertex3f_bufferobject = 0;
4729 rsurface.vertex3f_bufferoffset = 0;
4730 rsurface.svector3f = rsurface.array_deformedsvector3f;
4731 rsurface.svector3f_bufferobject = 0;
4732 rsurface.svector3f_bufferoffset = 0;
4733 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4734 rsurface.tvector3f_bufferobject = 0;
4735 rsurface.tvector3f_bufferoffset = 0;
4736 rsurface.normal3f = rsurface.array_deformednormal3f;
4737 rsurface.normal3f_bufferobject = 0;
4738 rsurface.normal3f_bufferoffset = 0;
4740 case Q3DEFORM_NORMAL:
4741 // deform the normals to make reflections wavey
4742 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4744 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4745 for (j = 0;j < surface->num_vertices;j++)
4748 float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3;
4749 VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
4750 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal);
4751 normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4752 normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4753 normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4754 VectorNormalize(normal);
4756 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);
4758 rsurface.svector3f = rsurface.array_deformedsvector3f;
4759 rsurface.svector3f_bufferobject = 0;
4760 rsurface.svector3f_bufferoffset = 0;
4761 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4762 rsurface.tvector3f_bufferobject = 0;
4763 rsurface.tvector3f_bufferoffset = 0;
4764 rsurface.normal3f = rsurface.array_deformednormal3f;
4765 rsurface.normal3f_bufferobject = 0;
4766 rsurface.normal3f_bufferoffset = 0;
4769 // deform vertex array to make wavey water and flags and such
4770 waveparms[0] = deform->waveparms[0];
4771 waveparms[1] = deform->waveparms[1];
4772 waveparms[2] = deform->waveparms[2];
4773 waveparms[3] = deform->waveparms[3];
4774 // this is how a divisor of vertex influence on deformation
4775 animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
4776 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4777 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4779 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4780 for (j = 0;j < surface->num_vertices;j++)
4782 float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3;
4783 VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex);
4784 // if the wavefunc depends on time, evaluate it per-vertex
4787 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
4788 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4790 VectorMA(vertex, scale, (rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, vertex);
4793 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4794 rsurface.vertex3f_bufferobject = 0;
4795 rsurface.vertex3f_bufferoffset = 0;
4797 case Q3DEFORM_BULGE:
4798 // deform vertex array to make the surface have moving bulges
4799 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4801 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4802 for (j = 0;j < surface->num_vertices;j++)
4804 scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.time * deform->parms[2])) * deform->parms[1];
4805 VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4808 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4809 rsurface.vertex3f_bufferobject = 0;
4810 rsurface.vertex3f_bufferoffset = 0;
4813 // deform vertex array
4814 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
4815 VectorScale(deform->parms, scale, waveparms);
4816 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4818 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4819 for (j = 0;j < surface->num_vertices;j++)
4820 VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4822 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4823 rsurface.vertex3f_bufferobject = 0;
4824 rsurface.vertex3f_bufferoffset = 0;
4828 // generate texcoords based on the chosen texcoord source
4829 switch(rsurface.texture->tcgen.tcgen)
4832 case Q3TCGEN_TEXTURE:
4833 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4834 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordtexture2f_bufferobject;
4835 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
4837 case Q3TCGEN_LIGHTMAP:
4838 rsurface.texcoordtexture2f = rsurface.modeltexcoordlightmap2f;
4839 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4840 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4842 case Q3TCGEN_VECTOR:
4843 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4845 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4846 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)
4848 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
4849 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
4852 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4853 rsurface.texcoordtexture2f_bufferobject = 0;
4854 rsurface.texcoordtexture2f_bufferoffset = 0;
4856 case Q3TCGEN_ENVIRONMENT:
4857 // make environment reflections using a spheremap
4858 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4860 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4861 const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
4862 const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
4863 float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
4864 for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
4866 float l, d, eyedir[3];
4867 VectorSubtract(rsurface.modelorg, vertex, eyedir);
4868 l = 0.5f / VectorLength(eyedir);
4869 d = DotProduct(normal, eyedir)*2;
4870 out_tc[0] = 0.5f + (normal[1]*d - eyedir[1])*l;
4871 out_tc[1] = 0.5f - (normal[2]*d - eyedir[2])*l;
4874 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4875 rsurface.texcoordtexture2f_bufferobject = 0;
4876 rsurface.texcoordtexture2f_bufferoffset = 0;
4879 // the only tcmod that needs software vertex processing is turbulent, so
4880 // check for it here and apply the changes if needed
4881 // and we only support that as the first one
4882 // (handling a mixture of turbulent and other tcmods would be problematic
4883 // without punting it entirely to a software path)
4884 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
4886 amplitude = rsurface.texture->tcmods[0].parms[1];
4887 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.time * rsurface.texture->tcmods[0].parms[3];
4888 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4890 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4891 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)
4893 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4894 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4897 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4898 rsurface.texcoordtexture2f_bufferobject = 0;
4899 rsurface.texcoordtexture2f_bufferoffset = 0;
4901 rsurface.texcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
4902 rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4903 rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4904 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
4907 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
4910 const msurface_t *surface = texturesurfacelist[0];
4911 const msurface_t *surface2;
4916 // TODO: lock all array ranges before render, rather than on each surface
4917 if (texturenumsurfaces == 1)
4919 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4920 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));
4922 else if (r_batchmode.integer == 2)
4924 #define MAXBATCHTRIANGLES 4096
4925 int batchtriangles = 0;
4926 int batchelements[MAXBATCHTRIANGLES*3];
4927 for (i = 0;i < texturenumsurfaces;i = j)
4929 surface = texturesurfacelist[i];
4931 if (surface->num_triangles > MAXBATCHTRIANGLES)
4933 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));
4936 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
4937 batchtriangles = surface->num_triangles;
4938 firstvertex = surface->num_firstvertex;
4939 endvertex = surface->num_firstvertex + surface->num_vertices;
4940 for (;j < texturenumsurfaces;j++)
4942 surface2 = texturesurfacelist[j];
4943 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
4945 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
4946 batchtriangles += surface2->num_triangles;
4947 firstvertex = min(firstvertex, surface2->num_firstvertex);
4948 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
4950 surface2 = texturesurfacelist[j-1];
4951 numvertices = endvertex - firstvertex;
4952 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
4955 else if (r_batchmode.integer == 1)
4957 for (i = 0;i < texturenumsurfaces;i = j)
4959 surface = texturesurfacelist[i];
4960 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
4961 if (texturesurfacelist[j] != surface2)
4963 surface2 = texturesurfacelist[j-1];
4964 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
4965 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
4966 GL_LockArrays(surface->num_firstvertex, numvertices);
4967 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
4972 for (i = 0;i < texturenumsurfaces;i++)
4974 surface = texturesurfacelist[i];
4975 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4976 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));
4981 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit, int refractiontexunit, int reflectiontexunit)
4983 int i, planeindex, vertexindex;
4987 r_waterstate_waterplane_t *p, *bestp;
4988 msurface_t *surface;
4989 if (r_waterstate.renderingscene)
4991 for (i = 0;i < texturenumsurfaces;i++)
4993 surface = texturesurfacelist[i];
4994 if (lightmaptexunit >= 0)
4995 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
4996 if (deluxemaptexunit >= 0)
4997 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
4998 // pick the closest matching water plane
5001 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5004 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
5006 Matrix4x4_Transform(&rsurface.matrix, v, vert);
5007 d += fabs(PlaneDiff(vert, &p->plane));
5009 if (bestd > d || !bestp)
5017 if (refractiontexunit >= 0)
5018 R_Mesh_TexBind(refractiontexunit, R_GetTexture(bestp->texture_refraction));
5019 if (reflectiontexunit >= 0)
5020 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(bestp->texture_reflection));
5024 if (refractiontexunit >= 0)
5025 R_Mesh_TexBind(refractiontexunit, R_GetTexture(r_texture_black));
5026 if (reflectiontexunit >= 0)
5027 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(r_texture_black));
5029 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5030 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));
5034 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit)
5038 const msurface_t *surface = texturesurfacelist[0];
5039 const msurface_t *surface2;
5044 // TODO: lock all array ranges before render, rather than on each surface
5045 if (texturenumsurfaces == 1)
5047 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5048 if (deluxemaptexunit >= 0)
5049 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5050 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5051 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));
5053 else if (r_batchmode.integer == 2)
5055 #define MAXBATCHTRIANGLES 4096
5056 int batchtriangles = 0;
5057 int batchelements[MAXBATCHTRIANGLES*3];
5058 for (i = 0;i < texturenumsurfaces;i = j)
5060 surface = texturesurfacelist[i];
5061 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5062 if (deluxemaptexunit >= 0)
5063 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5065 if (surface->num_triangles > MAXBATCHTRIANGLES)
5067 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));
5070 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
5071 batchtriangles = surface->num_triangles;
5072 firstvertex = surface->num_firstvertex;
5073 endvertex = surface->num_firstvertex + surface->num_vertices;
5074 for (;j < texturenumsurfaces;j++)
5076 surface2 = texturesurfacelist[j];
5077 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
5079 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
5080 batchtriangles += surface2->num_triangles;
5081 firstvertex = min(firstvertex, surface2->num_firstvertex);
5082 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
5084 surface2 = texturesurfacelist[j-1];
5085 numvertices = endvertex - firstvertex;
5086 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
5089 else if (r_batchmode.integer == 1)
5092 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
5093 for (i = 0;i < texturenumsurfaces;i = j)
5095 surface = texturesurfacelist[i];
5096 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5097 if (texturesurfacelist[j] != surface2)
5099 Con_Printf(" %i", j - i);
5102 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
5104 for (i = 0;i < texturenumsurfaces;i = j)
5106 surface = texturesurfacelist[i];
5107 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5108 if (deluxemaptexunit >= 0)
5109 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5110 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5111 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
5114 Con_Printf(" %i", j - i);
5116 surface2 = texturesurfacelist[j-1];
5117 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
5118 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
5119 GL_LockArrays(surface->num_firstvertex, numvertices);
5120 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5128 for (i = 0;i < texturenumsurfaces;i++)
5130 surface = texturesurfacelist[i];
5131 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5132 if (deluxemaptexunit >= 0)
5133 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5134 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5135 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));
5140 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5143 int texturesurfaceindex;
5144 if (r_showsurfaces.integer == 2)
5146 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5148 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5149 for (j = 0;j < surface->num_triangles;j++)
5151 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_view.colorscale;
5152 GL_Color(f, f, f, 1);
5153 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)));
5159 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5161 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5162 int k = (int)(((size_t)surface) / sizeof(msurface_t));
5163 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);
5164 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5165 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));
5170 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **texturesurfacelist)
5172 int texturesurfaceindex;
5176 if (rsurface.lightmapcolor4f)
5178 // generate color arrays for the surfaces in this list
5179 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5181 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5182 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)
5184 f = FogPoint_Model(v);
5194 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5196 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5197 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)
5199 f = FogPoint_Model(v);
5207 rsurface.lightmapcolor4f = rsurface.array_color4f;
5208 rsurface.lightmapcolor4f_bufferobject = 0;
5209 rsurface.lightmapcolor4f_bufferoffset = 0;
5212 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a)
5214 int texturesurfaceindex;
5217 if (!rsurface.lightmapcolor4f)
5219 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5221 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5222 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)
5230 rsurface.lightmapcolor4f = rsurface.array_color4f;
5231 rsurface.lightmapcolor4f_bufferobject = 0;
5232 rsurface.lightmapcolor4f_bufferoffset = 0;
5235 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5238 rsurface.lightmapcolor4f = NULL;
5239 rsurface.lightmapcolor4f_bufferobject = 0;
5240 rsurface.lightmapcolor4f_bufferoffset = 0;
5241 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5242 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5243 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5244 GL_Color(r, g, b, a);
5245 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1);
5248 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5250 // TODO: optimize applyfog && applycolor case
5251 // just apply fog if necessary, and tint the fog color array if necessary
5252 rsurface.lightmapcolor4f = NULL;
5253 rsurface.lightmapcolor4f_bufferobject = 0;
5254 rsurface.lightmapcolor4f_bufferoffset = 0;
5255 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5256 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5257 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5258 GL_Color(r, g, b, a);
5259 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5262 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5264 int texturesurfaceindex;
5268 if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
5270 // generate color arrays for the surfaces in this list
5271 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5273 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5274 for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
5276 if (surface->lightmapinfo->samples)
5278 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
5279 float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
5280 VectorScale(lm, scale, c);
5281 if (surface->lightmapinfo->styles[1] != 255)
5283 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
5285 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
5286 VectorMA(c, scale, lm, c);
5287 if (surface->lightmapinfo->styles[2] != 255)
5290 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
5291 VectorMA(c, scale, lm, c);
5292 if (surface->lightmapinfo->styles[3] != 255)
5295 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
5296 VectorMA(c, scale, lm, c);
5306 rsurface.lightmapcolor4f = rsurface.array_color4f;
5307 rsurface.lightmapcolor4f_bufferobject = 0;
5308 rsurface.lightmapcolor4f_bufferoffset = 0;
5312 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
5313 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
5314 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
5316 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5317 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5318 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5319 GL_Color(r, g, b, a);
5320 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5323 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5325 int texturesurfaceindex;
5329 vec3_t ambientcolor;
5330 vec3_t diffusecolor;
5334 VectorCopy(rsurface.modellight_lightdir, lightdir);
5335 ambientcolor[0] = rsurface.modellight_ambient[0] * r * 0.5f;
5336 ambientcolor[1] = rsurface.modellight_ambient[1] * g * 0.5f;
5337 ambientcolor[2] = rsurface.modellight_ambient[2] * b * 0.5f;
5338 diffusecolor[0] = rsurface.modellight_diffuse[0] * r * 0.5f;
5339 diffusecolor[1] = rsurface.modellight_diffuse[1] * g * 0.5f;
5340 diffusecolor[2] = rsurface.modellight_diffuse[2] * b * 0.5f;
5341 if (VectorLength2(diffusecolor) > 0)
5343 // generate color arrays for the surfaces in this list
5344 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5346 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5347 int numverts = surface->num_vertices;
5348 v = rsurface.vertex3f + 3 * surface->num_firstvertex;
5349 c2 = rsurface.normal3f + 3 * surface->num_firstvertex;
5350 c = rsurface.array_color4f + 4 * surface->num_firstvertex;
5351 // q3-style directional shading
5352 for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
5354 if ((f = DotProduct(c2, lightdir)) > 0)
5355 VectorMA(ambientcolor, f, diffusecolor, c);
5357 VectorCopy(ambientcolor, c);
5366 rsurface.lightmapcolor4f = rsurface.array_color4f;
5367 rsurface.lightmapcolor4f_bufferobject = 0;
5368 rsurface.lightmapcolor4f_bufferoffset = 0;
5372 r = ambientcolor[0];
5373 g = ambientcolor[1];
5374 b = ambientcolor[2];
5375 rsurface.lightmapcolor4f = NULL;
5376 rsurface.lightmapcolor4f_bufferobject = 0;
5377 rsurface.lightmapcolor4f_bufferoffset = 0;
5379 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5380 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5381 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5382 GL_Color(r, g, b, a);
5383 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5386 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5388 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5389 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5390 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5391 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5392 if (rsurface.mode != RSURFMODE_SHOWSURFACES)
5394 rsurface.mode = RSURFMODE_SHOWSURFACES;
5396 GL_BlendFunc(GL_ONE, GL_ZERO);
5397 R_Mesh_ColorPointer(NULL, 0, 0);
5398 R_Mesh_ResetTextureState();
5400 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5401 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5404 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
5406 // transparent sky would be ridiculous
5407 if ((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5409 if (rsurface.mode != RSURFMODE_SKY)
5411 if (rsurface.mode == RSURFMODE_GLSL)
5413 qglUseProgramObjectARB(0);CHECKGLERROR
5415 rsurface.mode = RSURFMODE_SKY;
5419 skyrendernow = false;
5421 // restore entity matrix
5422 R_Mesh_Matrix(&rsurface.matrix);
5424 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5425 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5426 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5427 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5429 // LordHavoc: HalfLife maps have freaky skypolys so don't use
5430 // skymasking on them, and Quake3 never did sky masking (unlike
5431 // software Quake and software Quake2), so disable the sky masking
5432 // in Quake3 maps as it causes problems with q3map2 sky tricks,
5433 // and skymasking also looks very bad when noclipping outside the
5434 // level, so don't use it then either.
5435 if (r_refdef.worldmodel && r_refdef.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
5437 GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
5438 R_Mesh_ColorPointer(NULL, 0, 0);
5439 R_Mesh_ResetTextureState();
5440 if (skyrendermasked)
5442 // depth-only (masking)
5443 GL_ColorMask(0,0,0,0);
5444 // just to make sure that braindead drivers don't draw
5445 // anything despite that colormask...
5446 GL_BlendFunc(GL_ZERO, GL_ONE);
5451 GL_BlendFunc(GL_ONE, GL_ZERO);
5453 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5454 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5455 if (skyrendermasked)
5456 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5460 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
5462 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
5465 if (rsurface.mode != RSURFMODE_GLSL)
5467 rsurface.mode = RSURFMODE_GLSL;
5468 R_Mesh_ResetTextureState();
5471 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
5472 R_Mesh_TexBind(0, R_GetTexture(rsurface.texture->currentskinframe->nmap));
5473 R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
5474 R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
5475 R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
5476 R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
5477 R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
5478 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5480 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5481 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5482 R_Mesh_ColorPointer(NULL, 0, 0);
5484 else if (rsurface.uselightmaptexture)
5486 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5487 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5488 R_Mesh_ColorPointer(NULL, 0, 0);
5492 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5493 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5494 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5496 R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow));
5497 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5498 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5500 if (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5502 // render background
5503 GL_BlendFunc(GL_ONE, GL_ZERO);
5505 GL_AlphaTest(false);
5507 GL_Color(1, 1, 1, 1);
5508 R_Mesh_ColorPointer(NULL, 0, 0);
5510 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
5511 if (r_glsl_permutation)
5513 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
5514 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5515 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5516 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5517 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5518 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5519 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection ? 12 : -1);
5522 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5523 GL_DepthMask(false);
5524 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5525 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5527 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5528 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5529 R_Mesh_ColorPointer(NULL, 0, 0);
5531 else if (rsurface.uselightmaptexture)
5533 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5534 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5535 R_Mesh_ColorPointer(NULL, 0, 0);
5539 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5540 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5541 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5543 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5544 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5547 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
5548 if (!r_glsl_permutation)
5551 RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0 || r_glsl_permutation->loc_LightDir >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
5552 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5553 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5554 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5555 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5556 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5557 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]);
5559 if (r_glsl_permutation->loc_Texture_Refraction >= 0)
5561 GL_BlendFunc(GL_ONE, GL_ZERO);
5563 GL_AlphaTest(false);
5566 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
5568 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5569 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);
5571 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
5575 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5576 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);
5578 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5580 if (rsurface.texture->backgroundnumskinframes && !(rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5585 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
5587 // OpenGL 1.3 path - anything not completely ancient
5588 int texturesurfaceindex;
5589 qboolean applycolor;
5593 const texturelayer_t *layer;
5594 if (rsurface.mode != RSURFMODE_MULTIPASS)
5595 rsurface.mode = RSURFMODE_MULTIPASS;
5596 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5598 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5601 int layertexrgbscale;
5602 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5604 if (layerindex == 0)
5608 GL_AlphaTest(false);
5609 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5612 GL_DepthMask(layer->depthmask);
5613 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5614 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
5616 layertexrgbscale = 4;
5617 VectorScale(layer->color, 0.25f, layercolor);
5619 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
5621 layertexrgbscale = 2;
5622 VectorScale(layer->color, 0.5f, layercolor);
5626 layertexrgbscale = 1;
5627 VectorScale(layer->color, 1.0f, layercolor);
5629 layercolor[3] = layer->color[3];
5630 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
5631 R_Mesh_ColorPointer(NULL, 0, 0);
5632 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5633 switch (layer->type)
5635 case TEXTURELAYERTYPE_LITTEXTURE:
5636 memset(&m, 0, sizeof(m));
5637 m.tex[0] = R_GetTexture(r_texture_white);
5638 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5639 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5640 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5641 m.tex[1] = R_GetTexture(layer->texture);
5642 m.texmatrix[1] = layer->texmatrix;
5643 m.texrgbscale[1] = layertexrgbscale;
5644 m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
5645 m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
5646 m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
5647 R_Mesh_TextureState(&m);
5648 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5649 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5650 else if (rsurface.uselightmaptexture)
5651 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5653 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5655 case TEXTURELAYERTYPE_TEXTURE:
5656 memset(&m, 0, sizeof(m));
5657 m.tex[0] = R_GetTexture(layer->texture);
5658 m.texmatrix[0] = layer->texmatrix;
5659 m.texrgbscale[0] = layertexrgbscale;
5660 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5661 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5662 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5663 R_Mesh_TextureState(&m);
5664 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5666 case TEXTURELAYERTYPE_FOG:
5667 memset(&m, 0, sizeof(m));
5668 m.texrgbscale[0] = layertexrgbscale;
5671 m.tex[0] = R_GetTexture(layer->texture);
5672 m.texmatrix[0] = layer->texmatrix;
5673 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5674 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5675 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5677 R_Mesh_TextureState(&m);
5678 // generate a color array for the fog pass
5679 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5680 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5684 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5685 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)
5687 f = 1 - FogPoint_Model(v);
5688 c[0] = layercolor[0];
5689 c[1] = layercolor[1];
5690 c[2] = layercolor[2];
5691 c[3] = f * layercolor[3];
5694 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5697 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5699 GL_LockArrays(0, 0);
5702 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5704 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5705 GL_AlphaTest(false);
5709 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist)
5711 // OpenGL 1.1 - crusty old voodoo path
5712 int texturesurfaceindex;
5716 const texturelayer_t *layer;
5717 if (rsurface.mode != RSURFMODE_MULTIPASS)
5718 rsurface.mode = RSURFMODE_MULTIPASS;
5719 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5721 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5723 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5725 if (layerindex == 0)
5729 GL_AlphaTest(false);
5730 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5733 GL_DepthMask(layer->depthmask);
5734 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5735 R_Mesh_ColorPointer(NULL, 0, 0);
5736 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5737 switch (layer->type)
5739 case TEXTURELAYERTYPE_LITTEXTURE:
5740 if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
5742 // two-pass lit texture with 2x rgbscale
5743 // first the lightmap pass
5744 memset(&m, 0, sizeof(m));
5745 m.tex[0] = R_GetTexture(r_texture_white);
5746 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5747 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5748 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5749 R_Mesh_TextureState(&m);
5750 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5751 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5752 else if (rsurface.uselightmaptexture)
5753 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5755 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5756 GL_LockArrays(0, 0);
5757 // then apply the texture to it
5758 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5759 memset(&m, 0, sizeof(m));
5760 m.tex[0] = R_GetTexture(layer->texture);
5761 m.texmatrix[0] = layer->texmatrix;
5762 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5763 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5764 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5765 R_Mesh_TextureState(&m);
5766 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);
5770 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
5771 memset(&m, 0, sizeof(m));
5772 m.tex[0] = R_GetTexture(layer->texture);
5773 m.texmatrix[0] = layer->texmatrix;
5774 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5775 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5776 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5777 R_Mesh_TextureState(&m);
5778 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5779 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);
5781 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);
5784 case TEXTURELAYERTYPE_TEXTURE:
5785 // singletexture unlit texture with transparency support
5786 memset(&m, 0, sizeof(m));
5787 m.tex[0] = R_GetTexture(layer->texture);
5788 m.texmatrix[0] = layer->texmatrix;
5789 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5790 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5791 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5792 R_Mesh_TextureState(&m);
5793 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);
5795 case TEXTURELAYERTYPE_FOG:
5796 // singletexture fogging
5797 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5800 memset(&m, 0, sizeof(m));
5801 m.tex[0] = R_GetTexture(layer->texture);
5802 m.texmatrix[0] = layer->texmatrix;
5803 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5804 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5805 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5806 R_Mesh_TextureState(&m);
5809 R_Mesh_ResetTextureState();
5810 // generate a color array for the fog pass
5811 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5815 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5816 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)
5818 f = 1 - FogPoint_Model(v);
5819 c[0] = layer->color[0];
5820 c[1] = layer->color[1];
5821 c[2] = layer->color[2];
5822 c[3] = f * layer->color[3];
5825 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5828 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5830 GL_LockArrays(0, 0);
5833 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5835 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5836 GL_AlphaTest(false);
5840 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly)
5842 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW)
5844 rsurface.rtlight = NULL;
5848 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
5850 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
5852 if (rsurface.mode != RSURFMODE_MULTIPASS)
5853 rsurface.mode = RSURFMODE_MULTIPASS;
5854 if (r_depthfirst.integer == 3)
5856 int i = (int)(texturesurfacelist[0] - rsurface.modelsurfaces);
5857 if (!r_view.showdebug)
5858 GL_Color(0, 0, 0, 1);
5860 GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1);
5864 GL_ColorMask(0,0,0,0);
5867 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5868 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5869 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5871 GL_BlendFunc(GL_ONE, GL_ZERO);
5873 GL_AlphaTest(false);
5874 R_Mesh_ColorPointer(NULL, 0, 0);
5875 R_Mesh_ResetTextureState();
5876 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5877 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5878 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5880 else if (r_depthfirst.integer == 3)
5882 else if (!r_view.showdebug && (r_showsurfaces.integer || gl_lightmaps.integer))
5884 GL_Color(0, 0, 0, 1);
5885 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5887 else if (r_showsurfaces.integer)
5889 if (rsurface.mode != RSURFMODE_MULTIPASS)
5890 rsurface.mode = RSURFMODE_MULTIPASS;
5891 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5892 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5894 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5895 GL_BlendFunc(GL_ONE, GL_ZERO);
5896 GL_DepthMask(writedepth);
5898 GL_AlphaTest(false);
5899 R_Mesh_ColorPointer(NULL, 0, 0);
5900 R_Mesh_ResetTextureState();
5901 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5902 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5904 else if (gl_lightmaps.integer)
5907 if (rsurface.mode != RSURFMODE_MULTIPASS)
5908 rsurface.mode = RSURFMODE_MULTIPASS;
5909 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5911 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5912 GL_BlendFunc(GL_ONE, GL_ZERO);
5913 GL_DepthMask(writedepth);
5915 GL_AlphaTest(false);
5916 R_Mesh_ColorPointer(NULL, 0, 0);
5917 memset(&m, 0, sizeof(m));
5918 m.tex[0] = R_GetTexture(r_texture_white);
5919 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5920 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5921 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5922 R_Mesh_TextureState(&m);
5923 RSurf_PrepareVerticesForBatch(rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, false, texturenumsurfaces, texturesurfacelist);
5924 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5925 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5926 else if (rsurface.uselightmaptexture)
5927 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5929 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5931 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
5932 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
5933 else if (rsurface.texture->currentnumlayers)
5935 // write depth for anything we skipped on the depth-only pass earlier
5936 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5938 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5939 GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset);
5940 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5941 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5942 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5943 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
5944 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5945 if (r_glsl.integer && gl_support_fragment_shader)
5946 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
5947 else if (gl_combine.integer && r_textureunits.integer >= 2)
5948 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist);
5950 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist);
5953 GL_LockArrays(0, 0);
5956 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5959 int texturenumsurfaces, endsurface;
5961 msurface_t *surface;
5962 msurface_t *texturesurfacelist[1024];
5964 // if the model is static it doesn't matter what value we give for
5965 // wantnormals and wanttangents, so this logic uses only rules applicable
5966 // to a model, knowing that they are meaningless otherwise
5967 if (ent == r_refdef.worldentity)
5968 RSurf_ActiveWorldEntity();
5969 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
5970 RSurf_ActiveModelEntity(ent, false, false);
5972 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
5974 for (i = 0;i < numsurfaces;i = j)
5977 surface = rsurface.modelsurfaces + surfacelist[i];
5978 texture = surface->texture;
5979 R_UpdateTextureInfo(ent, texture);
5980 rsurface.texture = texture->currentframe;
5981 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
5982 // scan ahead until we find a different texture
5983 endsurface = min(i + 1024, numsurfaces);
5984 texturenumsurfaces = 0;
5985 texturesurfacelist[texturenumsurfaces++] = surface;
5986 for (;j < endsurface;j++)
5988 surface = rsurface.modelsurfaces + surfacelist[j];
5989 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
5991 texturesurfacelist[texturenumsurfaces++] = surface;
5993 // render the range of surfaces
5994 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist, true, false);
6000 void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
6003 vec3_t tempcenter, center;
6005 // if we're rendering water textures (extra scene renders), use a separate loop to avoid burdening the main one
6008 for (i = 0;i < numsurfaces;i++)
6009 if (surfacelist[i]->texture->currentframe->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
6010 R_Water_AddWaterPlane(surfacelist[i]);
6013 // break the surface list down into batches by texture and use of lightmapping
6014 for (i = 0;i < numsurfaces;i = j)
6017 // texture is the base texture pointer, rsurface.texture is the
6018 // current frame/skin the texture is directing us to use (for example
6019 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
6020 // use skin 1 instead)
6021 texture = surfacelist[i]->texture;
6022 rsurface.texture = texture->currentframe;
6023 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
6024 if (!(rsurface.texture->currentmaterialflags & flagsmask))
6026 // if this texture is not the kind we want, skip ahead to the next one
6027 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
6031 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
6033 // transparent surfaces get pushed off into the transparent queue
6034 const msurface_t *surface = surfacelist[i];
6037 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
6038 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
6039 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
6040 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
6041 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.modelsurfaces, rsurface.rtlight);
6045 // simply scan ahead until we find a different texture or lightmap state
6046 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
6048 // render the range of surfaces
6049 R_DrawTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly);
6054 float locboxvertex3f[6*4*3] =
6056 1,0,1, 1,0,0, 1,1,0, 1,1,1,
6057 0,1,1, 0,1,0, 0,0,0, 0,0,1,
6058 1,1,1, 1,1,0, 0,1,0, 0,1,1,
6059 0,0,1, 0,0,0, 1,0,0, 1,0,1,
6060 0,0,1, 1,0,1, 1,1,1, 0,1,1,
6061 1,0,0, 0,0,0, 0,1,0, 1,1,0
6064 int locboxelement3i[6*2*3] =
6074 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6077 cl_locnode_t *loc = (cl_locnode_t *)ent;
6079 float vertex3f[6*4*3];
6081 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6082 GL_DepthMask(false);
6083 GL_DepthRange(0, 1);
6084 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6086 GL_CullFace(GL_NONE);
6087 R_Mesh_Matrix(&identitymatrix);
6089 R_Mesh_VertexPointer(vertex3f, 0, 0);
6090 R_Mesh_ColorPointer(NULL, 0, 0);
6091 R_Mesh_ResetTextureState();
6094 GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_view.colorscale,
6095 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_view.colorscale,
6096 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_view.colorscale,
6097 surfacelist[0] < 0 ? 0.5f : 0.125f);
6099 if (VectorCompare(loc->mins, loc->maxs))
6101 VectorSet(size, 2, 2, 2);
6102 VectorMA(loc->mins, -0.5f, size, mins);
6106 VectorCopy(loc->mins, mins);
6107 VectorSubtract(loc->maxs, loc->mins, size);
6110 for (i = 0;i < 6*4*3;)
6111 for (j = 0;j < 3;j++, i++)
6112 vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
6114 R_Mesh_Draw(0, 6*4, 6*2, locboxelement3i, 0, 0);
6117 void R_DrawLocs(void)
6120 cl_locnode_t *loc, *nearestloc;
6122 nearestloc = CL_Locs_FindNearest(cl.movement_origin);
6123 for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
6125 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
6126 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
6130 void R_DrawDebugModel(entity_render_t *ent)
6132 int i, j, k, l, flagsmask;
6133 const int *elements;
6135 msurface_t *surface;
6136 model_t *model = ent->model;
6139 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WATER | MATERIALFLAG_WALL;
6141 R_Mesh_ColorPointer(NULL, 0, 0);
6142 R_Mesh_ResetTextureState();
6143 GL_DepthRange(0, 1);
6144 GL_DepthTest(!r_showdisabledepthtest.integer);
6145 GL_DepthMask(false);
6146 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6148 if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
6150 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
6151 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
6153 if (brush->colbrushf && brush->colbrushf->numtriangles)
6155 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
6156 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);
6157 R_Mesh_Draw(0, brush->colbrushf->numpoints, brush->colbrushf->numtriangles, brush->colbrushf->elements, 0, 0);
6160 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
6162 if (surface->num_collisiontriangles)
6164 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
6165 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);
6166 R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i, 0, 0);
6171 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6173 if (r_showtris.integer || r_shownormals.integer)
6175 if (r_showdisabledepthtest.integer)
6177 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6178 GL_DepthMask(false);
6182 GL_BlendFunc(GL_ONE, GL_ZERO);
6185 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
6187 if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
6189 rsurface.texture = surface->texture->currentframe;
6190 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
6192 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
6193 if (r_showtris.value > 0)
6195 if (!rsurface.texture->currentlayers->depthmask)
6196 GL_Color(r_view.colorscale, 0, 0, r_showtris.value);
6197 else if (ent == r_refdef.worldentity)
6198 GL_Color(r_view.colorscale, r_view.colorscale, r_view.colorscale, r_showtris.value);
6200 GL_Color(0, r_view.colorscale, 0, r_showtris.value);
6201 elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
6204 for (k = 0;k < surface->num_triangles;k++, elements += 3)
6206 #define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
6207 GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
6208 GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
6209 GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
6214 if (r_shownormals.value > 0)
6217 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6219 VectorCopy(rsurface.vertex3f + l * 3, v);
6220 GL_Color(r_view.colorscale, 0, 0, 1);
6221 qglVertex3f(v[0], v[1], v[2]);
6222 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
6223 GL_Color(r_view.colorscale, 1, 1, 1);
6224 qglVertex3f(v[0], v[1], v[2]);
6229 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6231 VectorCopy(rsurface.vertex3f + l * 3, v);
6232 GL_Color(0, r_view.colorscale, 0, 1);
6233 qglVertex3f(v[0], v[1], v[2]);
6234 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
6235 GL_Color(r_view.colorscale, 1, 1, 1);
6236 qglVertex3f(v[0], v[1], v[2]);
6241 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6243 VectorCopy(rsurface.vertex3f + l * 3, v);
6244 GL_Color(0, 0, r_view.colorscale, 1);
6245 qglVertex3f(v[0], v[1], v[2]);
6246 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
6247 GL_Color(r_view.colorscale, 1, 1, 1);
6248 qglVertex3f(v[0], v[1], v[2]);
6255 rsurface.texture = NULL;
6259 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
6260 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6262 int i, j, endj, f, flagsmask;
6263 msurface_t *surface;
6265 model_t *model = r_refdef.worldmodel;
6266 const int maxsurfacelist = 1024;
6267 int numsurfacelist = 0;
6268 msurface_t *surfacelist[1024];
6272 RSurf_ActiveWorldEntity();
6274 // update light styles on this submodel
6275 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6277 model_brush_lightstyleinfo_t *style;
6278 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6280 if (style->value != r_refdef.lightstylevalue[style->style])
6282 msurface_t *surfaces = model->data_surfaces;
6283 int *list = style->surfacelist;
6284 style->value = r_refdef.lightstylevalue[style->style];
6285 for (j = 0;j < style->numsurfaces;j++)
6286 surfaces[list[j]].cached_dlight = true;
6291 R_UpdateAllTextureInfo(r_refdef.worldentity);
6292 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6296 R_DrawDebugModel(r_refdef.worldentity);
6302 rsurface.uselightmaptexture = false;
6303 rsurface.texture = NULL;
6305 j = model->firstmodelsurface;
6306 endj = j + model->nummodelsurfaces;
6309 // quickly skip over non-visible surfaces
6310 for (;j < endj && !r_viewcache.world_surfacevisible[j];j++)
6312 // quickly iterate over visible surfaces
6313 for (;j < endj && r_viewcache.world_surfacevisible[j];j++)
6315 // process this surface
6316 surface = model->data_surfaces + j;
6317 // if this surface fits the criteria, add it to the list
6318 if (surface->num_triangles)
6320 // if lightmap parameters changed, rebuild lightmap texture
6321 if (surface->cached_dlight)
6322 R_BuildLightMap(r_refdef.worldentity, surface);
6323 // add face to draw list
6324 surfacelist[numsurfacelist++] = surface;
6325 r_refdef.stats.world_triangles += surface->num_triangles;
6326 if (numsurfacelist >= maxsurfacelist)
6328 r_refdef.stats.world_surfaces += numsurfacelist;
6329 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6335 r_refdef.stats.world_surfaces += numsurfacelist;
6337 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6341 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6343 int i, j, f, flagsmask;
6344 msurface_t *surface, *endsurface;
6346 model_t *model = ent->model;
6347 const int maxsurfacelist = 1024;
6348 int numsurfacelist = 0;
6349 msurface_t *surfacelist[1024];
6353 // if the model is static it doesn't matter what value we give for
6354 // wantnormals and wanttangents, so this logic uses only rules applicable
6355 // to a model, knowing that they are meaningless otherwise
6356 if (ent == r_refdef.worldentity)
6357 RSurf_ActiveWorldEntity();
6358 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
6359 RSurf_ActiveModelEntity(ent, false, false);
6361 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader && !depthonly);
6363 // update light styles
6364 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6366 model_brush_lightstyleinfo_t *style;
6367 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6369 if (style->value != r_refdef.lightstylevalue[style->style])
6371 msurface_t *surfaces = model->data_surfaces;
6372 int *list = style->surfacelist;
6373 style->value = r_refdef.lightstylevalue[style->style];
6374 for (j = 0;j < style->numsurfaces;j++)
6375 surfaces[list[j]].cached_dlight = true;
6380 R_UpdateAllTextureInfo(ent);
6381 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6385 R_DrawDebugModel(ent);
6391 rsurface.uselightmaptexture = false;
6392 rsurface.texture = NULL;
6394 surface = model->data_surfaces + model->firstmodelsurface;
6395 endsurface = surface + model->nummodelsurfaces;
6396 for (;surface < endsurface;surface++)
6398 // if this surface fits the criteria, add it to the list
6399 if (surface->num_triangles)
6401 // if lightmap parameters changed, rebuild lightmap texture
6402 if (surface->cached_dlight)
6403 R_BuildLightMap(ent, surface);
6404 // add face to draw list
6405 surfacelist[numsurfacelist++] = surface;
6406 r_refdef.stats.entities_triangles += surface->num_triangles;
6407 if (numsurfacelist >= maxsurfacelist)
6409 r_refdef.stats.entities_surfaces += numsurfacelist;
6410 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6415 r_refdef.stats.entities_surfaces += numsurfacelist;
6417 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);