2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #include "cl_dyntexture.h"
28 mempool_t *r_main_mempool;
29 rtexturepool_t *r_main_texturepool;
36 r_viewcache_t r_viewcache;
38 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "1", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"};
39 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
40 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%, 10 = 100%)"};
41 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as different colors, or a value of 2 shows triangle draw order (for analyzing whether meshes are optimized for vertex cache)"};
42 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
43 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
44 cvar_t r_showlighting = {0, "r_showlighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
45 cvar_t r_showshadowvolumes = {0, "r_showshadowvolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
46 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
47 cvar_t r_showcollisionbrushes_polygonfactor = {0, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
48 cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
49 cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};
50 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
51 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
52 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
53 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
54 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling"};
55 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
56 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
57 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
58 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
59 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
60 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
61 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
62 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this)"};
63 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
64 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
65 cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
66 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "2", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
68 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
69 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
70 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
71 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
72 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
73 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
74 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
76 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of hardware texture units reported by driver (note: setting this to 1 turns off gl_combine)"};
78 cvar_t r_glsl = {CVAR_SAVE, "r_glsl", "1", "enables use of OpenGL 2.0 pixel shaders for lighting"};
79 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
80 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
81 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
82 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
83 cvar_t r_glsl_contrastboost = {CVAR_SAVE, "r_glsl_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"};
85 cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
86 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
87 cvar_t r_water_resolutionmultiplier = {CVAR_SAVE, "r_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
88 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
89 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
91 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
92 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
93 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
94 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
96 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
97 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
98 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
99 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
100 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
101 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
102 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
104 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
105 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
106 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
107 cvar_t r_hdr_range = {CVAR_SAVE, "r_hdr_range", "4", "how much dynamic range to render bloom with (equivilant to multiplying r_bloom_brighten by this value and dividing r_bloom_colorscale by this value)"};
109 cvar_t r_smoothnormals_areaweighting = {0, "r_smoothnormals_areaweighting", "1", "uses significantly faster (and supposedly higher quality) area-weighted vertex normals and tangent vectors rather than summing normalized triangle normals and tangents"};
111 cvar_t developer_texturelogging = {0, "developer_texturelogging", "0", "produces a textures.log file containing names of skins and map textures the engine tried to load"};
113 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
115 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
116 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
117 cvar_t r_track_sprites = {CVAR_SAVE, "r_track_sprites", "1", "track SPR_LABEL* sprites by putting them as indicator at the screen border to rotate to"};
118 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
119 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
120 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
122 extern qboolean v_flipped_state;
124 typedef struct r_glsl_bloomshader_s
127 int loc_Texture_Bloom;
129 r_glsl_bloomshader_t;
131 static struct r_bloomstate_s
136 int bloomwidth, bloomheight;
138 int screentexturewidth, screentextureheight;
139 rtexture_t *texture_screen;
141 int bloomtexturewidth, bloomtextureheight;
142 rtexture_t *texture_bloom;
144 r_glsl_bloomshader_t *shader;
146 // arrays for rendering the screen passes
147 float screentexcoord2f[8];
148 float bloomtexcoord2f[8];
149 float offsettexcoord2f[8];
153 typedef struct r_waterstate_waterplane_s
155 rtexture_t *texture_refraction;
156 rtexture_t *texture_reflection;
158 int materialflags; // combined flags of all water surfaces on this plane
159 unsigned char pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps
162 r_waterstate_waterplane_t;
164 #define MAX_WATERPLANES 16
166 static struct r_waterstate_s
170 qboolean renderingscene; // true while rendering a refraction or reflection texture, disables water surfaces
172 int waterwidth, waterheight;
173 int texturewidth, textureheight;
175 int maxwaterplanes; // same as MAX_WATERPLANES
177 r_waterstate_waterplane_t waterplanes[MAX_WATERPLANES];
179 float screenscale[2];
180 float screencenter[2];
184 // shadow volume bsp struct with automatically growing nodes buffer
187 rtexture_t *r_texture_blanknormalmap;
188 rtexture_t *r_texture_white;
189 rtexture_t *r_texture_grey128;
190 rtexture_t *r_texture_black;
191 rtexture_t *r_texture_notexture;
192 rtexture_t *r_texture_whitecube;
193 rtexture_t *r_texture_normalizationcube;
194 rtexture_t *r_texture_fogattenuation;
195 //rtexture_t *r_texture_fogintensity;
197 char r_qwskincache[MAX_SCOREBOARD][MAX_QPATH];
198 skinframe_t *r_qwskincache_skinframe[MAX_SCOREBOARD];
200 // vertex coordinates for a quad that covers the screen exactly
201 const static float r_screenvertex3f[12] =
209 extern void R_DrawModelShadows(void);
211 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
214 for (i = 0;i < verts;i++)
225 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
228 for (i = 0;i < verts;i++)
238 // FIXME: move this to client?
241 if (gamemode == GAME_NEHAHRA)
243 Cvar_Set("gl_fogenable", "0");
244 Cvar_Set("gl_fogdensity", "0.2");
245 Cvar_Set("gl_fogred", "0.3");
246 Cvar_Set("gl_foggreen", "0.3");
247 Cvar_Set("gl_fogblue", "0.3");
249 r_refdef.fog_density = r_refdef.fog_red = r_refdef.fog_green = r_refdef.fog_blue = 0.0f;
250 r_refdef.fog_start = 0;
251 r_refdef.fog_alpha = 1;
254 float FogForDistance(vec_t dist)
256 unsigned int fogmasktableindex = (unsigned int)(dist * r_refdef.fogmasktabledistmultiplier);
257 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
260 float FogPoint_World(const vec3_t p)
262 return FogForDistance(VectorDistance((p), r_view.origin));
265 float FogPoint_Model(const vec3_t p)
267 return FogForDistance(VectorDistance((p), rsurface.modelorg));
270 static void R_BuildBlankTextures(void)
272 unsigned char data[4];
273 data[2] = 128; // normal X
274 data[1] = 128; // normal Y
275 data[0] = 255; // normal Z
276 data[3] = 128; // height
277 r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
282 r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
287 r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
292 r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_PERSISTENT, NULL);
295 static void R_BuildNoTexture(void)
298 unsigned char pix[16][16][4];
299 // this makes a light grey/dark grey checkerboard texture
300 for (y = 0;y < 16;y++)
302 for (x = 0;x < 16;x++)
304 if ((y < 8) ^ (x < 8))
320 r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, NULL);
323 static void R_BuildWhiteCube(void)
325 unsigned char data[6*1*1*4];
326 memset(data, 255, sizeof(data));
327 r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
330 static void R_BuildNormalizationCube(void)
334 vec_t s, t, intensity;
336 unsigned char data[6][NORMSIZE][NORMSIZE][4];
337 for (side = 0;side < 6;side++)
339 for (y = 0;y < NORMSIZE;y++)
341 for (x = 0;x < NORMSIZE;x++)
343 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
344 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
379 intensity = 127.0f / sqrt(DotProduct(v, v));
380 data[side][y][x][2] = (unsigned char)(128.0f + intensity * v[0]);
381 data[side][y][x][1] = (unsigned char)(128.0f + intensity * v[1]);
382 data[side][y][x][0] = (unsigned char)(128.0f + intensity * v[2]);
383 data[side][y][x][3] = 255;
387 r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_PERSISTENT, NULL);
390 static void R_BuildFogTexture(void)
394 unsigned char data1[FOGWIDTH][4];
395 //unsigned char data2[FOGWIDTH][4];
398 r_refdef.fogmasktable_start = r_refdef.fog_start;
399 r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
401 s = r_refdef.fogmasktable_start / r_refdef.fogrange;
402 s = bound(0, s, 0.999);
403 for (x = 0;x < FOGMASKTABLEWIDTH;x++)
405 d = ((double)x / FOGMASKTABLEWIDTH);
406 Con_Printf("%f ", d);
407 d = (d - s) / (1 - s);
408 Con_Printf("%f ", d);
410 Con_Printf(" = %f ", d);
411 alpha = exp(-16 * d*d);
412 Con_Printf(" : %f ", alpha);
413 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
414 Con_Printf(" = %f\n", alpha);
415 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
418 for (x = 0;x < FOGWIDTH;x++)
420 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
425 //data2[x][0] = 255 - b;
426 //data2[x][1] = 255 - b;
427 //data2[x][2] = 255 - b;
430 if (r_texture_fogattenuation)
432 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
433 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
437 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);
438 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
442 static const char *builtinshaderstring =
443 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
444 "// written by Forest 'LordHavoc' Hale\n"
446 "// common definitions between vertex shader and fragment shader:\n"
448 "#ifdef __GLSL_CG_DATA_TYPES\n"
449 "# define myhalf half\n"
450 "# define myhvec2 hvec2\n"
451 "# define myhvec3 hvec3\n"
452 "# define myhvec4 hvec4\n"
454 "# define myhalf float\n"
455 "# define myhvec2 vec2\n"
456 "# define myhvec3 vec3\n"
457 "# define myhvec4 vec4\n"
460 "varying vec2 TexCoord;\n"
461 "varying vec2 TexCoordLightmap;\n"
463 "//#ifdef MODE_LIGHTSOURCE\n"
464 "varying vec3 CubeVector;\n"
467 "//#ifdef MODE_LIGHTSOURCE\n"
468 "varying vec3 LightVector;\n"
470 "//# ifdef MODE_LIGHTDIRECTION\n"
471 "//varying vec3 LightVector;\n"
475 "varying vec3 EyeVector;\n"
477 "varying vec3 EyeVectorModelSpace;\n"
480 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
481 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
482 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
484 "//#ifdef MODE_WATER\n"
485 "varying vec4 ModelViewProjectionPosition;\n"
487 "//# ifdef MODE_REFRACTION\n"
488 "//varying vec4 ModelViewProjectionPosition;\n"
490 "//# ifdef USEREFLECTION\n"
491 "//varying vec4 ModelViewProjectionPosition;\n"
500 "// vertex shader specific:\n"
501 "#ifdef VERTEX_SHADER\n"
503 "uniform vec3 LightPosition;\n"
504 "uniform vec3 EyePosition;\n"
505 "uniform vec3 LightDir;\n"
507 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)\n"
511 " gl_FrontColor = gl_Color;\n"
512 " // copy the surface texcoord\n"
513 " TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);\n"
514 "#ifndef MODE_LIGHTSOURCE\n"
515 "# ifndef MODE_LIGHTDIRECTION\n"
516 " TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
520 "#ifdef MODE_LIGHTSOURCE\n"
521 " // transform vertex position into light attenuation/cubemap space\n"
522 " // (-1 to +1 across the light box)\n"
523 " CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n"
525 " // transform unnormalized light direction into tangent space\n"
526 " // (we use unnormalized to ensure that it interpolates correctly and then\n"
527 " // normalize it per pixel)\n"
528 " vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
529 " LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
530 " LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
531 " LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
534 "#ifdef MODE_LIGHTDIRECTION\n"
535 " LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
536 " LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
537 " LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
540 " // transform unnormalized eye direction into tangent space\n"
542 " vec3 EyeVectorModelSpace;\n"
544 " EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
545 " EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
546 " EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
547 " EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
549 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
550 " VectorS = gl_MultiTexCoord1.xyz;\n"
551 " VectorT = gl_MultiTexCoord2.xyz;\n"
552 " VectorR = gl_MultiTexCoord3.xyz;\n"
555 "//#if defined(MODE_WATER) || defined(MODE_REFRACTION) || defined(USEREFLECTION)\n"
556 "// ModelViewProjectionPosition = gl_Vertex * gl_ModelViewProjectionMatrix;\n"
557 "// //ModelViewProjectionPosition_svector = (gl_Vertex + vec4(gl_MultiTexCoord1.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
558 "// //ModelViewProjectionPosition_tvector = (gl_Vertex + vec4(gl_MultiTexCoord2.xyz, 0)) * gl_ModelViewProjectionMatrix - ModelViewProjectionPosition;\n"
561 "// transform vertex to camera space, using ftransform to match non-VS\n"
563 " gl_Position = ftransform();\n"
565 "#ifdef MODE_WATER\n"
566 " ModelViewProjectionPosition = gl_Position;\n"
568 "#ifdef MODE_REFRACTION\n"
569 " ModelViewProjectionPosition = gl_Position;\n"
571 "#ifdef USEREFLECTION\n"
572 " ModelViewProjectionPosition = gl_Position;\n"
576 "#endif // VERTEX_SHADER\n"
581 "// fragment shader specific:\n"
582 "#ifdef FRAGMENT_SHADER\n"
584 "// 13 textures, we can only use up to 16 on DX9-class hardware\n"
585 "uniform sampler2D Texture_Normal;\n"
586 "uniform sampler2D Texture_Color;\n"
587 "uniform sampler2D Texture_Gloss;\n"
588 "uniform samplerCube Texture_Cube;\n"
589 "uniform sampler2D Texture_Attenuation;\n"
590 "uniform sampler2D Texture_FogMask;\n"
591 "uniform sampler2D Texture_Pants;\n"
592 "uniform sampler2D Texture_Shirt;\n"
593 "uniform sampler2D Texture_Lightmap;\n"
594 "uniform sampler2D Texture_Deluxemap;\n"
595 "uniform sampler2D Texture_Glow;\n"
596 "uniform sampler2D Texture_Reflection;\n"
597 "uniform sampler2D Texture_Refraction;\n"
599 "uniform myhvec3 LightColor;\n"
600 "uniform myhvec3 AmbientColor;\n"
601 "uniform myhvec3 DiffuseColor;\n"
602 "uniform myhvec3 SpecularColor;\n"
603 "uniform myhvec3 Color_Pants;\n"
604 "uniform myhvec3 Color_Shirt;\n"
605 "uniform myhvec3 FogColor;\n"
607 "//#ifdef MODE_WATER\n"
608 "uniform vec4 DistortScaleRefractReflect;\n"
609 "uniform vec4 ScreenScaleRefractReflect;\n"
610 "uniform vec4 ScreenCenterRefractReflect;\n"
611 "uniform myhvec4 RefractColor;\n"
612 "uniform myhvec4 ReflectColor;\n"
613 "uniform myhalf ReflectFactor;\n"
614 "uniform myhalf ReflectOffset;\n"
616 "//# ifdef MODE_REFRACTION\n"
617 "//uniform vec4 DistortScaleRefractReflect;\n"
618 "//uniform vec4 ScreenScaleRefractReflect;\n"
619 "//uniform vec4 ScreenCenterRefractReflect;\n"
620 "//uniform myhvec4 RefractColor;\n"
621 "//# ifdef USEREFLECTION\n"
622 "//uniform myhvec4 ReflectColor;\n"
625 "//# ifdef USEREFLECTION\n"
626 "//uniform vec4 DistortScaleRefractReflect;\n"
627 "//uniform vec4 ScreenScaleRefractReflect;\n"
628 "//uniform vec4 ScreenCenterRefractReflect;\n"
629 "//uniform myhvec4 ReflectColor;\n"
634 "uniform myhalf GlowScale;\n"
635 "uniform myhalf SceneBrightness;\n"
636 "#ifdef USECONTRASTBOOST\n"
637 "uniform myhalf ContrastBoostCoeff;\n"
640 "uniform float OffsetMapping_Scale;\n"
641 "uniform float OffsetMapping_Bias;\n"
642 "uniform float FogRangeRecip;\n"
644 "uniform myhalf AmbientScale;\n"
645 "uniform myhalf DiffuseScale;\n"
646 "uniform myhalf SpecularScale;\n"
647 "uniform myhalf SpecularPower;\n"
649 "#ifdef USEOFFSETMAPPING\n"
650 "vec2 OffsetMapping(vec2 TexCoord)\n"
652 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
653 " // 14 sample relief mapping: linear search and then binary search\n"
654 " // this basically steps forward a small amount repeatedly until it finds\n"
655 " // itself inside solid, then jitters forward and back using decreasing\n"
656 " // amounts to find the impact\n"
657 " //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
658 " //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
659 " vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
660 " vec3 RT = vec3(TexCoord, 1);\n"
661 " OffsetVector *= 0.1;\n"
662 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
663 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
664 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
665 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
666 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
667 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
668 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
669 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
670 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
671 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) - 0.5);\n"
672 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5 - 0.25);\n"
673 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25 - 0.125);\n"
674 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125 - 0.0625);\n"
675 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
678 " // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
679 " // this basically moves forward the full distance, and then backs up based\n"
680 " // on height of samples\n"
681 " //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
682 " //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
683 " vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
684 " TexCoord += OffsetVector;\n"
685 " OffsetVector *= 0.333;\n"
686 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
687 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
688 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
689 " return TexCoord;\n"
692 "#endif // USEOFFSETMAPPING\n"
694 "#ifdef MODE_WATER\n"
699 "#ifdef USEOFFSETMAPPING\n"
700 " // apply offsetmapping\n"
701 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
702 "#define TexCoord TexCoordOffset\n"
705 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
706 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
707 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
708 " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 5.0) * ReflectFactor + ReflectOffset;\n"
709 " gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
712 "#else // MODE_WATER\n"
713 "#ifdef MODE_REFRACTION\n"
715 "// refraction pass\n"
718 "#ifdef USEOFFSETMAPPING\n"
719 " // apply offsetmapping\n"
720 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
721 "#define TexCoord TexCoordOffset\n"
724 " vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
725 " //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
726 " vec2 ScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy + vec2(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
727 " gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
730 "#else // MODE_REFRACTION\n"
733 "#ifdef USEOFFSETMAPPING\n"
734 " // apply offsetmapping\n"
735 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
736 "#define TexCoord TexCoordOffset\n"
739 " // combine the diffuse textures (base, pants, shirt)\n"
740 " myhvec4 color = myhvec4(texture2D(Texture_Color, TexCoord));\n"
741 "#ifdef USECOLORMAPPING\n"
742 " color.rgb += myhvec3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhvec3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
748 "#ifdef MODE_LIGHTSOURCE\n"
751 " // calculate surface normal, light normal, and specular normal\n"
752 " // compute color intensity for the two textures (colormap and glossmap)\n"
753 " // scale by light color and attenuation as efficiently as possible\n"
754 " // (do as much scalar math as possible rather than vector math)\n"
755 "# ifdef USESPECULAR\n"
756 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
757 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
758 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
760 " // calculate directional shading\n"
761 " 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"
763 "# ifdef USEDIFFUSE\n"
764 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
765 " myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
767 " // calculate directional shading\n"
768 " 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"
770 " // calculate directionless shading\n"
771 " color.rgb = color.rgb * LightColor * myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
775 "# ifdef USECUBEFILTER\n"
776 " // apply light cubemap filter\n"
777 " //color.rgb *= normalize(CubeVector) * 0.5 + 0.5;//vec3(textureCube(Texture_Cube, CubeVector));\n"
778 " color.rgb *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
780 " color *= myhvec4(gl_Color);\n"
781 "#endif // MODE_LIGHTSOURCE\n"
786 "#ifdef MODE_LIGHTDIRECTION\n"
787 " // directional model lighting\n"
788 "# ifdef USESPECULAR\n"
789 " // get the surface normal and light normal\n"
790 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
791 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
793 " // calculate directional shading\n"
794 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
795 " myhvec3 specularnormal = normalize(diffusenormal + myhvec3(normalize(EyeVector)));\n"
796 " color.rgb += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularColor * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
798 "# ifdef USEDIFFUSE\n"
799 " // get the surface normal and light normal\n"
800 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
801 " myhvec3 diffusenormal = myhvec3(LightVector);\n"
803 " // calculate directional shading\n"
804 " color.rgb *= AmbientColor + DiffuseColor * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0));\n"
806 " color.rgb *= AmbientColor;\n"
810 " color *= myhvec4(gl_Color);\n"
811 "#endif // MODE_LIGHTDIRECTION\n"
816 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
817 " // deluxemap lightmapping using light vectors in modelspace (evil q3map2)\n"
819 " // get the surface normal and light normal\n"
820 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
822 " myhvec3 diffusenormal_modelspace = myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5);\n"
823 " myhvec3 diffusenormal = normalize(myhvec3(dot(diffusenormal_modelspace, myhvec3(VectorS)), dot(diffusenormal_modelspace, myhvec3(VectorT)), dot(diffusenormal_modelspace, myhvec3(VectorR))));\n"
824 " // calculate directional shading\n"
825 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
826 "# ifdef USESPECULAR\n"
827 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
828 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
831 " // apply lightmap color\n"
832 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
833 " color.a *= myhalf(gl_Color.a);\n"
834 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
839 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
840 " // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
842 " // get the surface normal and light normal\n"
843 " myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5));\n"
845 " myhvec3 diffusenormal = normalize(myhvec3(texture2D(Texture_Deluxemap, TexCoordLightmap)) - myhvec3(0.5));\n"
846 " // calculate directional shading\n"
847 " myhvec3 tempcolor = color.rgb * (DiffuseScale * myhalf(max(float(dot(surfacenormal, diffusenormal)), 0.0)));\n"
848 "# ifdef USESPECULAR\n"
849 " myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
850 " tempcolor += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
853 " // apply lightmap color\n"
854 " color.rgb = color.rgb * AmbientScale + tempcolor * myhvec3(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec3(gl_Color);\n"
855 " color.a *= myhalf(gl_Color.a);\n"
856 "#endif // MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
861 "#ifdef MODE_LIGHTMAP\n"
862 " // apply lightmap color\n"
863 " color *= myhvec4(texture2D(Texture_Lightmap, TexCoordLightmap)) * myhvec4(gl_Color) * myhvec4(myhvec3(DiffuseScale), 1) + myhvec4(myhvec3(AmbientScale), 0);\n"
864 "#endif // MODE_LIGHTMAP\n"
874 " color.rgb += myhvec3(texture2D(Texture_Glow, TexCoord)) * GlowScale;\n"
877 "#ifndef MODE_LIGHTSOURCE\n"
878 "# ifdef USEREFLECTION\n"
879 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
880 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
881 " vec4 ScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect + vec3(normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - myhvec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
882 " color.rgb = mix(color.rgb, myhvec3(texture2D(Texture_Reflection, ScreenTexCoord.zw)) * ReflectColor.rgb, ReflectColor.a);\n"
886 "#ifdef USECONTRASTBOOST\n"
887 " color.rgb = color.rgb / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n"
890 " color.rgb *= SceneBrightness;\n"
894 " color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n"
897 " gl_FragColor = vec4(color);\n"
899 "#endif // MODE_REFRACTION\n"
900 "#endif // MODE_WATER\n"
902 "#endif // FRAGMENT_SHADER\n"
905 #define SHADERPERMUTATION_COLORMAPPING (1<<0) // indicates this is a colormapped skin
906 #define SHADERPERMUTATION_CONTRASTBOOST (1<<1) // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma)
907 #define SHADERPERMUTATION_FOG (1<<2) // tint the color by fog color or black if using additive blend mode
908 #define SHADERPERMUTATION_CUBEFILTER (1<<3) // (lightsource) use cubemap light filter
909 #define SHADERPERMUTATION_GLOW (1<<4) // (lightmap) blend in an additive glow texture
910 #define SHADERPERMUTATION_DIFFUSE (1<<5) // (lightsource) whether to use directional shading
911 #define SHADERPERMUTATION_SPECULAR (1<<6) // (lightsource or deluxemapping) render specular effects
912 #define SHADERPERMUTATION_REFLECTION (1<<7) // normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
913 #define SHADERPERMUTATION_OFFSETMAPPING (1<<8) // adjust texcoords to roughly simulate a displacement mapped surface
914 #define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<9) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
915 #define SHADERPERMUTATION_MODEBASE (1<<10) // multiplier for the SHADERMODE_ values to get a valid index
917 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
918 const char *shaderpermutationinfo[][2] =
920 {"#define USECOLORMAPPING\n", " colormapping"},
921 {"#define USECONTRASTBOOST\n", " contrastboost"},
922 {"#define USEFOG\n", " fog"},
923 {"#define USECUBEFILTER\n", " cubefilter"},
924 {"#define USEGLOW\n", " glow"},
925 {"#define USEDIFFUSE\n", " diffuse"},
926 {"#define USESPECULAR\n", " specular"},
927 {"#define USEREFLECTION\n", " reflection"},
928 {"#define USEOFFSETMAPPING\n", " offsetmapping"},
929 {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
933 // this enum is multiplied by SHADERPERMUTATION_MODEBASE
934 typedef enum shadermode_e
936 SHADERMODE_LIGHTMAP, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
937 SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, // (lightmap) use directional pixel shading from texture containing modelspace light directions (deluxemap)
938 SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, // (lightmap) use directional pixel shading from texture containing tangentspace light directions (deluxemap)
939 SHADERMODE_LIGHTDIRECTION, // (lightmap) use directional pixel shading from fixed light direction (q3bsp)
940 SHADERMODE_LIGHTSOURCE, // (lightsource) use directional pixel shading from light source (rtlight)
941 SHADERMODE_REFRACTION, // refract background (the material is rendered normally after this pass)
942 SHADERMODE_WATER, // refract background and reflection (the material is rendered normally after this pass)
947 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
948 const char *shadermodeinfo[][2] =
950 {"#define MODE_LIGHTMAP\n", " lightmap"},
951 {"#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
952 {"#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
953 {"#define MODE_LIGHTDIRECTION\n", " lightdirection"},
954 {"#define MODE_LIGHTSOURCE\n", " lightsource"},
955 {"#define MODE_REFRACTION\n", " refraction"},
956 {"#define MODE_WATER\n", " water"},
960 #define SHADERPERMUTATION_INDICES (SHADERPERMUTATION_MODEBASE * SHADERMODE_COUNT)
962 typedef struct r_glsl_permutation_s
964 // indicates if we have tried compiling this permutation already
966 // 0 if compilation failed
968 // locations of detected uniforms in program object, or -1 if not found
969 int loc_Texture_Normal;
970 int loc_Texture_Color;
971 int loc_Texture_Gloss;
972 int loc_Texture_Cube;
973 int loc_Texture_Attenuation;
974 int loc_Texture_FogMask;
975 int loc_Texture_Pants;
976 int loc_Texture_Shirt;
977 int loc_Texture_Lightmap;
978 int loc_Texture_Deluxemap;
979 int loc_Texture_Glow;
980 int loc_Texture_Refraction;
981 int loc_Texture_Reflection;
983 int loc_LightPosition;
988 int loc_FogRangeRecip;
989 int loc_AmbientScale;
990 int loc_DiffuseScale;
991 int loc_SpecularScale;
992 int loc_SpecularPower;
994 int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost
995 int loc_OffsetMapping_Scale;
996 int loc_AmbientColor;
997 int loc_DiffuseColor;
998 int loc_SpecularColor;
1000 int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost
1001 int loc_DistortScaleRefractReflect;
1002 int loc_ScreenScaleRefractReflect;
1003 int loc_ScreenCenterRefractReflect;
1004 int loc_RefractColor;
1005 int loc_ReflectColor;
1006 int loc_ReflectFactor;
1007 int loc_ReflectOffset;
1009 r_glsl_permutation_t;
1011 // information about each possible shader permutation
1012 r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_INDICES];
1013 // currently selected permutation
1014 r_glsl_permutation_t *r_glsl_permutation;
1016 // these are additional flags used only by R_GLSL_CompilePermutation
1017 #define SHADERTYPE_USES_VERTEXSHADER (1<<0)
1018 #define SHADERTYPE_USES_GEOMETRYSHADER (1<<1)
1019 #define SHADERTYPE_USES_FRAGMENTSHADER (1<<2)
1021 static void R_GLSL_CompilePermutation(const char *filename, int permutation, int shadertype)
1024 qboolean shaderfound;
1025 r_glsl_permutation_t *p = r_glsl_permutations + permutation;
1026 int vertstrings_count;
1027 int geomstrings_count;
1028 int fragstrings_count;
1030 const char *vertstrings_list[32+1];
1031 const char *geomstrings_list[32+1];
1032 const char *fragstrings_list[32+1];
1033 char permutationname[256];
1038 vertstrings_list[0] = "#define VERTEX_SHADER\n";
1039 geomstrings_list[0] = "#define GEOMETRY_SHADER\n";
1040 fragstrings_list[0] = "#define FRAGMENT_SHADER\n";
1041 vertstrings_count = 1;
1042 geomstrings_count = 1;
1043 fragstrings_count = 1;
1044 permutationname[0] = 0;
1045 i = permutation / SHADERPERMUTATION_MODEBASE;
1046 vertstrings_list[vertstrings_count++] = shadermodeinfo[i][0];
1047 geomstrings_list[geomstrings_count++] = shadermodeinfo[i][0];
1048 fragstrings_list[fragstrings_count++] = shadermodeinfo[i][0];
1049 strlcat(permutationname, shadermodeinfo[i][1], sizeof(permutationname));
1050 for (i = 0;shaderpermutationinfo[i][0];i++)
1052 if (permutation & (1<<i))
1054 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i][0];
1055 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i][0];
1056 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i][0];
1057 strlcat(permutationname, shaderpermutationinfo[i][1], sizeof(permutationname));
1061 // keep line numbers correct
1062 vertstrings_list[vertstrings_count++] = "\n";
1063 geomstrings_list[geomstrings_count++] = "\n";
1064 fragstrings_list[fragstrings_count++] = "\n";
1067 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1068 shaderfound = false;
1071 Con_DPrint("from disk... ");
1072 vertstrings_list[vertstrings_count++] = shaderstring;
1073 geomstrings_list[geomstrings_count++] = shaderstring;
1074 fragstrings_list[fragstrings_count++] = shaderstring;
1077 else if (!strcmp(filename, "glsl/default.glsl"))
1079 vertstrings_list[vertstrings_count++] = builtinshaderstring;
1080 geomstrings_list[geomstrings_count++] = builtinshaderstring;
1081 fragstrings_list[fragstrings_count++] = builtinshaderstring;
1084 // clear any lists that are not needed by this shader
1085 if (!(shadertype & SHADERTYPE_USES_VERTEXSHADER))
1086 vertstrings_count = 0;
1087 if (!(shadertype & SHADERTYPE_USES_GEOMETRYSHADER))
1088 geomstrings_count = 0;
1089 if (!(shadertype & SHADERTYPE_USES_FRAGMENTSHADER))
1090 fragstrings_count = 0;
1091 // compile the shader program
1092 if (shaderfound && vertstrings_count + geomstrings_count + fragstrings_count)
1093 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1097 qglUseProgramObjectARB(p->program);CHECKGLERROR
1098 // look up all the uniform variable names we care about, so we don't
1099 // have to look them up every time we set them
1100 p->loc_Texture_Normal = qglGetUniformLocationARB(p->program, "Texture_Normal");
1101 p->loc_Texture_Color = qglGetUniformLocationARB(p->program, "Texture_Color");
1102 p->loc_Texture_Gloss = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1103 p->loc_Texture_Cube = qglGetUniformLocationARB(p->program, "Texture_Cube");
1104 p->loc_Texture_Attenuation = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
1105 p->loc_Texture_FogMask = qglGetUniformLocationARB(p->program, "Texture_FogMask");
1106 p->loc_Texture_Pants = qglGetUniformLocationARB(p->program, "Texture_Pants");
1107 p->loc_Texture_Shirt = qglGetUniformLocationARB(p->program, "Texture_Shirt");
1108 p->loc_Texture_Lightmap = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
1109 p->loc_Texture_Deluxemap = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
1110 p->loc_Texture_Glow = qglGetUniformLocationARB(p->program, "Texture_Glow");
1111 p->loc_Texture_Refraction = qglGetUniformLocationARB(p->program, "Texture_Refraction");
1112 p->loc_Texture_Reflection = qglGetUniformLocationARB(p->program, "Texture_Reflection");
1113 p->loc_FogColor = qglGetUniformLocationARB(p->program, "FogColor");
1114 p->loc_LightPosition = qglGetUniformLocationARB(p->program, "LightPosition");
1115 p->loc_EyePosition = qglGetUniformLocationARB(p->program, "EyePosition");
1116 p->loc_LightColor = qglGetUniformLocationARB(p->program, "LightColor");
1117 p->loc_Color_Pants = qglGetUniformLocationARB(p->program, "Color_Pants");
1118 p->loc_Color_Shirt = qglGetUniformLocationARB(p->program, "Color_Shirt");
1119 p->loc_FogRangeRecip = qglGetUniformLocationARB(p->program, "FogRangeRecip");
1120 p->loc_AmbientScale = qglGetUniformLocationARB(p->program, "AmbientScale");
1121 p->loc_DiffuseScale = qglGetUniformLocationARB(p->program, "DiffuseScale");
1122 p->loc_SpecularPower = qglGetUniformLocationARB(p->program, "SpecularPower");
1123 p->loc_SpecularScale = qglGetUniformLocationARB(p->program, "SpecularScale");
1124 p->loc_GlowScale = qglGetUniformLocationARB(p->program, "GlowScale");
1125 p->loc_SceneBrightness = qglGetUniformLocationARB(p->program, "SceneBrightness");
1126 p->loc_OffsetMapping_Scale = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
1127 p->loc_AmbientColor = qglGetUniformLocationARB(p->program, "AmbientColor");
1128 p->loc_DiffuseColor = qglGetUniformLocationARB(p->program, "DiffuseColor");
1129 p->loc_SpecularColor = qglGetUniformLocationARB(p->program, "SpecularColor");
1130 p->loc_LightDir = qglGetUniformLocationARB(p->program, "LightDir");
1131 p->loc_ContrastBoostCoeff = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff");
1132 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
1133 p->loc_ScreenScaleRefractReflect = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
1134 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
1135 p->loc_RefractColor = qglGetUniformLocationARB(p->program, "RefractColor");
1136 p->loc_ReflectColor = qglGetUniformLocationARB(p->program, "ReflectColor");
1137 p->loc_ReflectFactor = qglGetUniformLocationARB(p->program, "ReflectFactor");
1138 p->loc_ReflectOffset = qglGetUniformLocationARB(p->program, "ReflectOffset");
1139 // initialize the samplers to refer to the texture units we use
1140 if (p->loc_Texture_Normal >= 0) qglUniform1iARB(p->loc_Texture_Normal, 0);
1141 if (p->loc_Texture_Color >= 0) qglUniform1iARB(p->loc_Texture_Color, 1);
1142 if (p->loc_Texture_Gloss >= 0) qglUniform1iARB(p->loc_Texture_Gloss, 2);
1143 if (p->loc_Texture_Cube >= 0) qglUniform1iARB(p->loc_Texture_Cube, 3);
1144 if (p->loc_Texture_FogMask >= 0) qglUniform1iARB(p->loc_Texture_FogMask, 4);
1145 if (p->loc_Texture_Pants >= 0) qglUniform1iARB(p->loc_Texture_Pants, 5);
1146 if (p->loc_Texture_Shirt >= 0) qglUniform1iARB(p->loc_Texture_Shirt, 6);
1147 if (p->loc_Texture_Lightmap >= 0) qglUniform1iARB(p->loc_Texture_Lightmap, 7);
1148 if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap, 8);
1149 if (p->loc_Texture_Glow >= 0) qglUniform1iARB(p->loc_Texture_Glow, 9);
1150 if (p->loc_Texture_Attenuation >= 0) qglUniform1iARB(p->loc_Texture_Attenuation, 10);
1151 if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction, 11);
1152 if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection, 12);
1154 qglUseProgramObjectARB(0);CHECKGLERROR
1155 if (developer.integer)
1156 Con_Printf("GLSL shader %s :%s compiled.\n", filename, permutationname);
1160 if (developer.integer)
1161 Con_Printf("GLSL shader %s :%s failed! source code line offset for above errors is %i.\n", permutationname, filename, -(vertstrings_count - 1));
1163 Con_Printf("GLSL shader %s :%s failed! some features may not work properly.\n", permutationname, filename);
1166 Mem_Free(shaderstring);
1169 void R_GLSL_Restart_f(void)
1172 for (i = 0;i < SHADERPERMUTATION_INDICES;i++)
1173 if (r_glsl_permutations[i].program)
1174 GL_Backend_FreeProgram(r_glsl_permutations[i].program);
1175 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1178 void R_GLSL_DumpShader_f(void)
1182 qfile_t *file = FS_Open("glsl/default.glsl", "w", false, false);
1185 Con_Printf("failed to write to glsl/default.glsl\n");
1189 FS_Print(file, "// The engine may define the following macros:\n");
1190 FS_Print(file, "// #define VERTEX_SHADER\n// #define GEOMETRY_SHADER\n// #define FRAGMENT_SHADER\n");
1191 for (i = 0;shadermodeinfo[i][0];i++)
1192 FS_Printf(file, "// %s", shadermodeinfo[i][0]);
1193 for (i = 0;shaderpermutationinfo[i][0];i++)
1194 FS_Printf(file, "// %s", shaderpermutationinfo[i][0]);
1195 FS_Print(file, "\n");
1196 FS_Print(file, builtinshaderstring);
1199 Con_Printf("glsl/default.glsl written\n");
1202 extern rtexture_t *r_shadow_attenuationgradienttexture;
1203 extern rtexture_t *r_shadow_attenuation2dtexture;
1204 extern rtexture_t *r_shadow_attenuation3dtexture;
1205 int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
1207 // select a permutation of the lighting shader appropriate to this
1208 // combination of texture, entity, light source, and fogging, only use the
1209 // minimum features necessary to avoid wasting rendering time in the
1210 // fragment shader on features that are not being used
1211 const char *shaderfilename = NULL;
1212 unsigned int permutation = 0;
1213 unsigned int shadertype = 0;
1214 shadermode_t mode = 0;
1215 r_glsl_permutation = NULL;
1216 shaderfilename = "glsl/default.glsl";
1217 shadertype = SHADERTYPE_USES_VERTEXSHADER | SHADERTYPE_USES_FRAGMENTSHADER;
1218 // TODO: implement geometry-shader based shadow volumes someday
1219 if (r_glsl_offsetmapping.integer)
1221 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1222 if (r_glsl_offsetmapping_reliefmapping.integer)
1223 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1225 if (rsurfacepass == RSURFPASS_BACKGROUND)
1227 // distorted background
1228 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
1229 mode = SHADERMODE_WATER;
1231 mode = SHADERMODE_REFRACTION;
1233 else if (rsurfacepass == RSURFPASS_RTLIGHT)
1236 mode = SHADERMODE_LIGHTSOURCE;
1237 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1238 permutation |= SHADERPERMUTATION_CUBEFILTER;
1239 if (diffusescale > 0)
1240 permutation |= SHADERPERMUTATION_DIFFUSE;
1241 if (specularscale > 0)
1242 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1243 if (r_refdef.fogenabled)
1244 permutation |= SHADERPERMUTATION_FOG;
1245 if (rsurface.texture->colormapping)
1246 permutation |= SHADERPERMUTATION_COLORMAPPING;
1247 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1248 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1249 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1250 permutation |= SHADERPERMUTATION_REFLECTION;
1252 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
1254 // unshaded geometry (fullbright or ambient model lighting)
1255 mode = SHADERMODE_LIGHTMAP;
1256 if (rsurface.texture->currentskinframe->glow)
1257 permutation |= SHADERPERMUTATION_GLOW;
1258 if (r_refdef.fogenabled)
1259 permutation |= SHADERPERMUTATION_FOG;
1260 if (rsurface.texture->colormapping)
1261 permutation |= SHADERPERMUTATION_COLORMAPPING;
1262 if (r_glsl_offsetmapping.integer)
1264 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
1265 if (r_glsl_offsetmapping_reliefmapping.integer)
1266 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
1268 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1269 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1270 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1271 permutation |= SHADERPERMUTATION_REFLECTION;
1273 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
1275 // directional model lighting
1276 mode = SHADERMODE_LIGHTDIRECTION;
1277 if (rsurface.texture->currentskinframe->glow)
1278 permutation |= SHADERPERMUTATION_GLOW;
1279 permutation |= SHADERPERMUTATION_DIFFUSE;
1280 if (specularscale > 0)
1281 permutation |= SHADERPERMUTATION_SPECULAR;
1282 if (r_refdef.fogenabled)
1283 permutation |= SHADERPERMUTATION_FOG;
1284 if (rsurface.texture->colormapping)
1285 permutation |= SHADERPERMUTATION_COLORMAPPING;
1286 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1287 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1288 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1289 permutation |= SHADERPERMUTATION_REFLECTION;
1291 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
1293 // ambient model lighting
1294 mode = SHADERMODE_LIGHTDIRECTION;
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;
1309 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping)
1311 // deluxemapping (light direction texture)
1312 if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace)
1313 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
1315 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1316 if (specularscale > 0)
1317 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1319 else if (r_glsl_deluxemapping.integer >= 2)
1321 // fake deluxemapping (uniform light direction in tangentspace)
1322 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
1323 if (specularscale > 0)
1324 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
1328 // ordinary lightmapping
1329 mode = SHADERMODE_LIGHTMAP;
1331 if (rsurface.texture->currentskinframe->glow)
1332 permutation |= SHADERPERMUTATION_GLOW;
1333 if (r_refdef.fogenabled)
1334 permutation |= SHADERPERMUTATION_FOG;
1335 if (rsurface.texture->colormapping)
1336 permutation |= SHADERPERMUTATION_COLORMAPPING;
1337 if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)
1338 permutation |= SHADERPERMUTATION_CONTRASTBOOST;
1339 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
1340 permutation |= SHADERPERMUTATION_REFLECTION;
1342 permutation |= mode * SHADERPERMUTATION_MODEBASE;
1343 if (!r_glsl_permutations[permutation].program)
1345 if (!r_glsl_permutations[permutation].compiled)
1346 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1347 if (!r_glsl_permutations[permutation].program)
1349 // remove features until we find a valid permutation
1351 for (i = (SHADERPERMUTATION_MODEBASE >> 1);;i>>=1)
1355 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");
1356 Cvar_SetValueQuick(&r_glsl, 0);
1357 return 0; // no bit left to clear
1359 // reduce i more quickly whenever it would not remove any bits
1360 if (!(permutation & i))
1363 if (!r_glsl_permutations[permutation].compiled)
1364 R_GLSL_CompilePermutation(shaderfilename, permutation, shadertype);
1365 if (r_glsl_permutations[permutation].program)
1370 r_glsl_permutation = r_glsl_permutations + permutation;
1372 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
1373 if (mode == SHADERMODE_LIGHTSOURCE)
1375 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
1376 if (permutation & SHADERPERMUTATION_DIFFUSE)
1378 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
1379 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, ambientscale);
1380 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, diffusescale);
1381 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, specularscale);
1385 // ambient only is simpler
1386 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0] * ambientscale, lightcolorbase[1] * ambientscale, lightcolorbase[2] * ambientscale);
1387 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, 1);
1388 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, 0);
1389 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, 0);
1392 else if (mode == SHADERMODE_LIGHTDIRECTION)
1394 if (r_glsl_permutation->loc_AmbientColor >= 0)
1395 qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale * r_refdef.lightmapintensity, rsurface.modellight_ambient[1] * ambientscale * r_refdef.lightmapintensity, rsurface.modellight_ambient[2] * ambientscale * r_refdef.lightmapintensity);
1396 if (r_glsl_permutation->loc_DiffuseColor >= 0)
1397 qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface.modellight_diffuse[0] * diffusescale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[1] * diffusescale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[2] * diffusescale * r_refdef.lightmapintensity);
1398 if (r_glsl_permutation->loc_SpecularColor >= 0)
1399 qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[1] * specularscale * r_refdef.lightmapintensity, rsurface.modellight_diffuse[2] * specularscale * r_refdef.lightmapintensity);
1400 if (r_glsl_permutation->loc_LightDir >= 0)
1401 qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
1405 if (r_glsl_permutation->loc_AmbientScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_AmbientScale, r_ambient.value * 2.0f / 128.0f);
1406 if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f);
1407 if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f);
1409 if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value);
1410 if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0)
1412 // The formula used is actually:
1413 // color.rgb *= SceneBrightness;
1414 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
1415 // I simplify that to
1416 // color.rgb *= [[SceneBrightness * ContrastBoost]];
1417 // color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1;
1419 // color.rgb = [[SceneBrightness * ContrastBoost]] * color.rgb / ([[(ContrastBoost - 1) * SceneBrightness]] * color.rgb + 1);
1420 // and do [[calculations]] here in the engine
1421 qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale);
1422 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value);
1425 if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale);
1426 if (r_glsl_permutation->loc_FogColor >= 0)
1428 // additive passes are only darkened by fog, not tinted
1429 if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD))
1430 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
1432 qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
1434 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]);
1435 if (r_glsl_permutation->loc_Color_Pants >= 0)
1437 if (rsurface.texture->currentskinframe->pants)
1438 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
1440 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
1442 if (r_glsl_permutation->loc_Color_Shirt >= 0)
1444 if (rsurface.texture->currentskinframe->shirt)
1445 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
1447 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
1449 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip);
1450 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower);
1451 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
1452 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);
1453 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]);
1454 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]);
1455 if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
1456 if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
1457 if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
1458 if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
1463 #define SKINFRAME_HASH 1024
1467 int loadsequence; // incremented each level change
1468 memexpandablearray_t array;
1469 skinframe_t *hash[SKINFRAME_HASH];
1473 void R_SkinFrame_PrepareForPurge(void)
1475 r_skinframe.loadsequence++;
1476 // wrap it without hitting zero
1477 if (r_skinframe.loadsequence >= 200)
1478 r_skinframe.loadsequence = 1;
1481 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
1485 // mark the skinframe as used for the purging code
1486 skinframe->loadsequence = r_skinframe.loadsequence;
1489 void R_SkinFrame_Purge(void)
1493 for (i = 0;i < SKINFRAME_HASH;i++)
1495 for (s = r_skinframe.hash[i];s;s = s->next)
1497 if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
1499 if (s->merged == s->base)
1501 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
1502 R_PurgeTexture(s->stain );s->stain = NULL;
1503 R_PurgeTexture(s->merged);s->merged = NULL;
1504 R_PurgeTexture(s->base );s->base = NULL;
1505 R_PurgeTexture(s->pants );s->pants = NULL;
1506 R_PurgeTexture(s->shirt );s->shirt = NULL;
1507 R_PurgeTexture(s->nmap );s->nmap = NULL;
1508 R_PurgeTexture(s->gloss );s->gloss = NULL;
1509 R_PurgeTexture(s->glow );s->glow = NULL;
1510 R_PurgeTexture(s->fog );s->fog = NULL;
1511 s->loadsequence = 0;
1517 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
1519 char basename[MAX_QPATH];
1521 Image_StripImageExtension(name, basename, sizeof(basename));
1523 if( last == NULL ) {
1525 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1526 item = r_skinframe.hash[hashindex];
1531 // linearly search through the hash bucket
1532 for( ; item ; item = item->next ) {
1533 if( !strcmp( item->basename, basename ) ) {
1540 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
1544 char basename[MAX_QPATH];
1546 Image_StripImageExtension(name, basename, sizeof(basename));
1548 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
1549 for (item = r_skinframe.hash[hashindex];item;item = item->next)
1550 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
1554 rtexture_t *dyntexture;
1555 // check whether its a dynamic texture
1556 dyntexture = CL_GetDynTexture( basename );
1557 if (!add && !dyntexture)
1559 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
1560 memset(item, 0, sizeof(*item));
1561 strlcpy(item->basename, basename, sizeof(item->basename));
1562 item->base = dyntexture; // either NULL or dyntexture handle
1563 item->textureflags = textureflags;
1564 item->comparewidth = comparewidth;
1565 item->compareheight = compareheight;
1566 item->comparecrc = comparecrc;
1567 item->next = r_skinframe.hash[hashindex];
1568 r_skinframe.hash[hashindex] = item;
1570 else if( item->base == NULL )
1572 rtexture_t *dyntexture;
1573 // check whether its a dynamic texture
1574 // 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]
1575 dyntexture = CL_GetDynTexture( basename );
1576 item->base = dyntexture; // either NULL or dyntexture handle
1579 R_SkinFrame_MarkUsed(item);
1583 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
1585 // FIXME: it should be possible to disable loading various layers using
1586 // cvars, to prevent wasted loading time and memory usage if the user does
1588 qboolean loadnormalmap = true;
1589 qboolean loadgloss = true;
1590 qboolean loadpantsandshirt = true;
1591 qboolean loadglow = true;
1593 unsigned char *pixels;
1594 unsigned char *bumppixels;
1595 unsigned char *basepixels = NULL;
1596 int basepixels_width;
1597 int basepixels_height;
1598 skinframe_t *skinframe;
1600 if (cls.state == ca_dedicated)
1603 // return an existing skinframe if already loaded
1604 // if loading of the first image fails, don't make a new skinframe as it
1605 // would cause all future lookups of this to be missing
1606 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
1607 if (skinframe && skinframe->base)
1610 basepixels = loadimagepixelsbgra(name, complain, true);
1611 if (basepixels == NULL)
1614 // we've got some pixels to store, so really allocate this new texture now
1616 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
1617 skinframe->stain = NULL;
1618 skinframe->merged = NULL;
1619 skinframe->base = r_texture_notexture;
1620 skinframe->pants = NULL;
1621 skinframe->shirt = NULL;
1622 skinframe->nmap = r_texture_blanknormalmap;
1623 skinframe->gloss = NULL;
1624 skinframe->glow = NULL;
1625 skinframe->fog = NULL;
1627 basepixels_width = image_width;
1628 basepixels_height = image_height;
1629 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);
1631 if (textureflags & TEXF_ALPHA)
1633 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
1634 if (basepixels[j] < 255)
1636 if (j < basepixels_width * basepixels_height * 4)
1638 // has transparent pixels
1639 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1640 for (j = 0;j < image_width * image_height * 4;j += 4)
1645 pixels[j+3] = basepixels[j+3];
1647 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);
1652 // _norm is the name used by tenebrae and has been adopted as standard
1655 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL)
1657 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);
1661 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL)
1663 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
1664 Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
1665 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);
1667 Mem_Free(bumppixels);
1669 else if (r_shadow_bumpscale_basetexture.value > 0)
1671 pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
1672 Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
1673 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);
1677 // _luma is supported for tenebrae compatibility
1678 // (I think it's a very stupid name, but oh well)
1679 // _glow is the preferred name
1680 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;}
1681 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;}
1682 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;}
1683 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;}
1686 Mem_Free(basepixels);
1691 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)
1696 for (i = 0;i < width*height;i++)
1697 if (((unsigned char *)&palette[in[i]])[3] > 0)
1699 if (i == width*height)
1702 return R_LoadTexture2D (r_main_texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
1705 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
1706 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
1709 unsigned char *temp1, *temp2;
1710 skinframe_t *skinframe;
1712 if (cls.state == ca_dedicated)
1715 // if already loaded just return it, otherwise make a new skinframe
1716 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
1717 if (skinframe && skinframe->base)
1720 skinframe->stain = NULL;
1721 skinframe->merged = NULL;
1722 skinframe->base = r_texture_notexture;
1723 skinframe->pants = NULL;
1724 skinframe->shirt = NULL;
1725 skinframe->nmap = r_texture_blanknormalmap;
1726 skinframe->gloss = NULL;
1727 skinframe->glow = NULL;
1728 skinframe->fog = NULL;
1730 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1734 if (r_shadow_bumpscale_basetexture.value > 0)
1736 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1737 temp2 = temp1 + width * height * 4;
1738 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1739 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1742 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1743 if (textureflags & TEXF_ALPHA)
1745 for (i = 3;i < width * height * 4;i += 4)
1746 if (skindata[i] < 255)
1748 if (i < width * height * 4)
1750 unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
1751 memcpy(fogpixels, skindata, width * height * 4);
1752 for (i = 0;i < width * height * 4;i += 4)
1753 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
1754 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, NULL);
1755 Mem_Free(fogpixels);
1762 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
1765 unsigned char *temp1, *temp2;
1766 skinframe_t *skinframe;
1768 if (cls.state == ca_dedicated)
1771 // if already loaded just return it, otherwise make a new skinframe
1772 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
1773 if (skinframe && skinframe->base)
1776 skinframe->stain = NULL;
1777 skinframe->merged = NULL;
1778 skinframe->base = r_texture_notexture;
1779 skinframe->pants = NULL;
1780 skinframe->shirt = NULL;
1781 skinframe->nmap = r_texture_blanknormalmap;
1782 skinframe->gloss = NULL;
1783 skinframe->glow = NULL;
1784 skinframe->fog = NULL;
1786 // if no data was provided, then clearly the caller wanted to get a blank skinframe
1790 if (r_shadow_bumpscale_basetexture.value > 0)
1792 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
1793 temp2 = temp1 + width * height * 4;
1794 // use either a custom palette or the quake palette
1795 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
1796 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
1797 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
1800 // use either a custom palette, or the quake palette
1801 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
1802 if (loadglowtexture)
1803 skinframe->glow = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_glow", skinframe->basename), palette_bgra_onlyfullbrights, skinframe->textureflags, false); // glow
1804 if (loadpantsandshirt)
1806 skinframe->pants = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_pants", skinframe->basename), palette_bgra_pantsaswhite, skinframe->textureflags, false); // pants
1807 skinframe->shirt = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_shirt", skinframe->basename), palette_bgra_shirtaswhite, skinframe->textureflags, false); // shirt
1809 if (skinframe->pants || skinframe->shirt)
1810 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
1811 if (textureflags & TEXF_ALPHA)
1813 for (i = 0;i < width * height;i++)
1814 if (((unsigned char *)palette_bgra_alpha)[skindata[i]*4+3] < 255)
1816 if (i < width * height)
1817 skinframe->fog = R_SkinFrame_TextureForSkinLayer(skindata, width, height, va("%s_fog", skinframe->basename), palette_bgra_alpha, skinframe->textureflags, true); // fog mask
1823 skinframe_t *R_SkinFrame_LoadMissing(void)
1825 skinframe_t *skinframe;
1827 if (cls.state == ca_dedicated)
1830 skinframe = R_SkinFrame_Find("missing", TEXF_PRECACHE, 0, 0, 0, true);
1831 skinframe->stain = NULL;
1832 skinframe->merged = NULL;
1833 skinframe->base = r_texture_notexture;
1834 skinframe->pants = NULL;
1835 skinframe->shirt = NULL;
1836 skinframe->nmap = r_texture_blanknormalmap;
1837 skinframe->gloss = NULL;
1838 skinframe->glow = NULL;
1839 skinframe->fog = NULL;
1844 void gl_main_start(void)
1846 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1847 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1849 // set up r_skinframe loading system for textures
1850 memset(&r_skinframe, 0, sizeof(r_skinframe));
1851 r_skinframe.loadsequence = 1;
1852 Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
1854 r_main_texturepool = R_AllocTexturePool();
1855 R_BuildBlankTextures();
1857 if (gl_texturecubemap)
1860 R_BuildNormalizationCube();
1862 r_texture_fogattenuation = NULL;
1863 //r_texture_fogintensity = NULL;
1864 R_BuildFogTexture();
1865 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1866 memset(&r_waterstate, 0, sizeof(r_waterstate));
1867 memset(r_glsl_permutations, 0, sizeof(r_glsl_permutations));
1868 memset(&r_svbsp, 0, sizeof (r_svbsp));
1871 void gl_main_shutdown(void)
1873 memset(r_qwskincache, 0, sizeof(r_qwskincache));
1874 memset(r_qwskincache_skinframe, 0, sizeof(r_qwskincache_skinframe));
1876 // clear out the r_skinframe state
1877 Mem_ExpandableArray_FreeArray(&r_skinframe.array);
1878 memset(&r_skinframe, 0, sizeof(r_skinframe));
1881 Mem_Free(r_svbsp.nodes);
1882 memset(&r_svbsp, 0, sizeof (r_svbsp));
1883 R_FreeTexturePool(&r_main_texturepool);
1884 r_texture_blanknormalmap = NULL;
1885 r_texture_white = NULL;
1886 r_texture_grey128 = NULL;
1887 r_texture_black = NULL;
1888 r_texture_whitecube = NULL;
1889 r_texture_normalizationcube = NULL;
1890 r_texture_fogattenuation = NULL;
1891 //r_texture_fogintensity = NULL;
1892 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
1893 memset(&r_waterstate, 0, sizeof(r_waterstate));
1897 extern void CL_ParseEntityLump(char *entitystring);
1898 void gl_main_newmap(void)
1900 // FIXME: move this code to client
1902 char *entities, entname[MAX_QPATH];
1905 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
1906 l = (int)strlen(entname) - 4;
1907 if (l >= 0 && !strcmp(entname + l, ".bsp"))
1909 memcpy(entname + l, ".ent", 5);
1910 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
1912 CL_ParseEntityLump(entities);
1917 if (cl.worldmodel->brush.entities)
1918 CL_ParseEntityLump(cl.worldmodel->brush.entities);
1922 void GL_Main_Init(void)
1924 r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
1926 Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
1927 Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
1928 // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
1929 if (gamemode == GAME_NEHAHRA)
1931 Cvar_RegisterVariable (&gl_fogenable);
1932 Cvar_RegisterVariable (&gl_fogdensity);
1933 Cvar_RegisterVariable (&gl_fogred);
1934 Cvar_RegisterVariable (&gl_foggreen);
1935 Cvar_RegisterVariable (&gl_fogblue);
1936 Cvar_RegisterVariable (&gl_fogstart);
1937 Cvar_RegisterVariable (&gl_fogend);
1939 Cvar_RegisterVariable(&r_depthfirst);
1940 Cvar_RegisterVariable(&r_nearclip);
1941 Cvar_RegisterVariable(&r_showbboxes);
1942 Cvar_RegisterVariable(&r_showsurfaces);
1943 Cvar_RegisterVariable(&r_showtris);
1944 Cvar_RegisterVariable(&r_shownormals);
1945 Cvar_RegisterVariable(&r_showlighting);
1946 Cvar_RegisterVariable(&r_showshadowvolumes);
1947 Cvar_RegisterVariable(&r_showcollisionbrushes);
1948 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
1949 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
1950 Cvar_RegisterVariable(&r_showdisabledepthtest);
1951 Cvar_RegisterVariable(&r_drawportals);
1952 Cvar_RegisterVariable(&r_drawentities);
1953 Cvar_RegisterVariable(&r_cullentities_trace);
1954 Cvar_RegisterVariable(&r_cullentities_trace_samples);
1955 Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
1956 Cvar_RegisterVariable(&r_cullentities_trace_delay);
1957 Cvar_RegisterVariable(&r_drawviewmodel);
1958 Cvar_RegisterVariable(&r_speeds);
1959 Cvar_RegisterVariable(&r_fullbrights);
1960 Cvar_RegisterVariable(&r_wateralpha);
1961 Cvar_RegisterVariable(&r_dynamic);
1962 Cvar_RegisterVariable(&r_fullbright);
1963 Cvar_RegisterVariable(&r_shadows);
1964 Cvar_RegisterVariable(&r_shadows_throwdistance);
1965 Cvar_RegisterVariable(&r_q1bsp_skymasking);
1966 Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
1967 Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
1968 Cvar_RegisterVariable(&r_textureunits);
1969 Cvar_RegisterVariable(&r_glsl);
1970 Cvar_RegisterVariable(&r_glsl_offsetmapping);
1971 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
1972 Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
1973 Cvar_RegisterVariable(&r_glsl_deluxemapping);
1974 Cvar_RegisterVariable(&r_water);
1975 Cvar_RegisterVariable(&r_water_resolutionmultiplier);
1976 Cvar_RegisterVariable(&r_water_clippingplanebias);
1977 Cvar_RegisterVariable(&r_water_refractdistort);
1978 Cvar_RegisterVariable(&r_water_reflectdistort);
1979 Cvar_RegisterVariable(&r_lerpsprites);
1980 Cvar_RegisterVariable(&r_lerpmodels);
1981 Cvar_RegisterVariable(&r_lerplightstyles);
1982 Cvar_RegisterVariable(&r_waterscroll);
1983 Cvar_RegisterVariable(&r_bloom);
1984 Cvar_RegisterVariable(&r_bloom_colorscale);
1985 Cvar_RegisterVariable(&r_bloom_brighten);
1986 Cvar_RegisterVariable(&r_bloom_blur);
1987 Cvar_RegisterVariable(&r_bloom_resolution);
1988 Cvar_RegisterVariable(&r_bloom_colorexponent);
1989 Cvar_RegisterVariable(&r_bloom_colorsubtract);
1990 Cvar_RegisterVariable(&r_hdr);
1991 Cvar_RegisterVariable(&r_hdr_scenebrightness);
1992 Cvar_RegisterVariable(&r_glsl_contrastboost);
1993 Cvar_RegisterVariable(&r_hdr_glowintensity);
1994 Cvar_RegisterVariable(&r_hdr_range);
1995 Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
1996 Cvar_RegisterVariable(&developer_texturelogging);
1997 Cvar_RegisterVariable(&gl_lightmaps);
1998 Cvar_RegisterVariable(&r_test);
1999 Cvar_RegisterVariable(&r_batchmode);
2000 if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
2001 Cvar_SetValue("r_fullbrights", 0);
2002 R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
2004 Cvar_RegisterVariable(&r_track_sprites);
2005 Cvar_RegisterVariable(&r_track_sprites_flags);
2006 Cvar_RegisterVariable(&r_track_sprites_scalew);
2007 Cvar_RegisterVariable(&r_track_sprites_scaleh);
2010 extern void R_Textures_Init(void);
2011 extern void GL_Draw_Init(void);
2012 extern void GL_Main_Init(void);
2013 extern void R_Shadow_Init(void);
2014 extern void R_Sky_Init(void);
2015 extern void GL_Surf_Init(void);
2016 extern void R_Particles_Init(void);
2017 extern void R_Explosion_Init(void);
2018 extern void gl_backend_init(void);
2019 extern void Sbar_Init(void);
2020 extern void R_LightningBeams_Init(void);
2021 extern void Mod_RenderInit(void);
2023 void Render_Init(void)
2035 R_LightningBeams_Init();
2044 extern char *ENGINE_EXTENSIONS;
2047 VID_CheckExtensions();
2049 // LordHavoc: report supported extensions
2050 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
2052 // clear to black (loading plaque will be seen over this)
2054 qglClearColor(0,0,0,1);CHECKGLERROR
2055 qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
2058 int R_CullBox(const vec3_t mins, const vec3_t maxs)
2062 for (i = 0;i < r_view.numfrustumplanes;i++)
2064 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
2067 p = r_view.frustum + i;
2072 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2076 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2080 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2084 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2088 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2092 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2096 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2100 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2108 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
2112 for (i = 0;i < numplanes;i++)
2119 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2123 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
2127 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2131 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
2135 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2139 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
2143 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2147 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
2155 //==================================================================================
2157 static void R_View_UpdateEntityVisible (void)
2160 entity_render_t *ent;
2162 if (!r_drawentities.integer)
2165 renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
2166 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
2168 // worldmodel can check visibility
2169 for (i = 0;i < r_refdef.numentities;i++)
2171 ent = r_refdef.entities[i];
2172 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));
2175 if(r_cullentities_trace.integer)
2177 for (i = 0;i < r_refdef.numentities;i++)
2179 ent = r_refdef.entities[i];
2180 if(r_viewcache.entityvisible[i] && !(ent->effects & EF_NODEPTHTEST) && !(ent->flags & RENDER_VIEWMODEL) && !(ent->model && (ent->model->name[0] == '*')))
2182 if(Mod_CanSeeBox_Trace(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.worldmodel, r_view.origin, ent->mins, ent->maxs))
2183 ent->last_trace_visibility = realtime;
2184 if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
2185 r_viewcache.entityvisible[i] = 0;
2192 // no worldmodel or it can't check visibility
2193 for (i = 0;i < r_refdef.numentities;i++)
2195 ent = r_refdef.entities[i];
2196 r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs));
2201 // only used if skyrendermasked, and normally returns false
2202 int R_DrawBrushModelsSky (void)
2205 entity_render_t *ent;
2207 if (!r_drawentities.integer)
2211 for (i = 0;i < r_refdef.numentities;i++)
2213 if (!r_viewcache.entityvisible[i])
2215 ent = r_refdef.entities[i];
2216 if (!ent->model || !ent->model->DrawSky)
2218 ent->model->DrawSky(ent);
2224 static void R_DrawNoModel(entity_render_t *ent);
2225 static void R_DrawModels(void)
2228 entity_render_t *ent;
2230 if (!r_drawentities.integer)
2233 for (i = 0;i < r_refdef.numentities;i++)
2235 if (!r_viewcache.entityvisible[i])
2237 ent = r_refdef.entities[i];
2238 r_refdef.stats.entities++;
2239 if (ent->model && ent->model->Draw != NULL)
2240 ent->model->Draw(ent);
2246 static void R_DrawModelsDepth(void)
2249 entity_render_t *ent;
2251 if (!r_drawentities.integer)
2254 for (i = 0;i < r_refdef.numentities;i++)
2256 if (!r_viewcache.entityvisible[i])
2258 ent = r_refdef.entities[i];
2259 if (ent->model && ent->model->DrawDepth != NULL)
2260 ent->model->DrawDepth(ent);
2264 static void R_DrawModelsDebug(void)
2267 entity_render_t *ent;
2269 if (!r_drawentities.integer)
2272 for (i = 0;i < r_refdef.numentities;i++)
2274 if (!r_viewcache.entityvisible[i])
2276 ent = r_refdef.entities[i];
2277 if (ent->model && ent->model->DrawDebug != NULL)
2278 ent->model->DrawDebug(ent);
2282 static void R_DrawModelsAddWaterPlanes(void)
2285 entity_render_t *ent;
2287 if (!r_drawentities.integer)
2290 for (i = 0;i < r_refdef.numentities;i++)
2292 if (!r_viewcache.entityvisible[i])
2294 ent = r_refdef.entities[i];
2295 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
2296 ent->model->DrawAddWaterPlanes(ent);
2300 static void R_View_SetFrustum(void)
2303 double slopex, slopey;
2305 // break apart the view matrix into vectors for various purposes
2306 Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
2307 VectorNegate(r_view.left, r_view.right);
2310 r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
2311 r_view.frustum[0].normal[1] = 0 - 0;
2312 r_view.frustum[0].normal[2] = -1 - 0;
2313 r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
2314 r_view.frustum[1].normal[1] = 0 + 0;
2315 r_view.frustum[1].normal[2] = -1 + 0;
2316 r_view.frustum[2].normal[0] = 0 - 0;
2317 r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
2318 r_view.frustum[2].normal[2] = -1 - 0;
2319 r_view.frustum[3].normal[0] = 0 + 0;
2320 r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
2321 r_view.frustum[3].normal[2] = -1 + 0;
2325 zNear = r_refdef.nearclip;
2326 nudge = 1.0 - 1.0 / (1<<23);
2327 r_view.frustum[4].normal[0] = 0 - 0;
2328 r_view.frustum[4].normal[1] = 0 - 0;
2329 r_view.frustum[4].normal[2] = -1 - -nudge;
2330 r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
2331 r_view.frustum[5].normal[0] = 0 + 0;
2332 r_view.frustum[5].normal[1] = 0 + 0;
2333 r_view.frustum[5].normal[2] = -1 + -nudge;
2334 r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
2340 r_view.frustum[0].normal[0] = m[3] - m[0];
2341 r_view.frustum[0].normal[1] = m[7] - m[4];
2342 r_view.frustum[0].normal[2] = m[11] - m[8];
2343 r_view.frustum[0].dist = m[15] - m[12];
2345 r_view.frustum[1].normal[0] = m[3] + m[0];
2346 r_view.frustum[1].normal[1] = m[7] + m[4];
2347 r_view.frustum[1].normal[2] = m[11] + m[8];
2348 r_view.frustum[1].dist = m[15] + m[12];
2350 r_view.frustum[2].normal[0] = m[3] - m[1];
2351 r_view.frustum[2].normal[1] = m[7] - m[5];
2352 r_view.frustum[2].normal[2] = m[11] - m[9];
2353 r_view.frustum[2].dist = m[15] - m[13];
2355 r_view.frustum[3].normal[0] = m[3] + m[1];
2356 r_view.frustum[3].normal[1] = m[7] + m[5];
2357 r_view.frustum[3].normal[2] = m[11] + m[9];
2358 r_view.frustum[3].dist = m[15] + m[13];
2360 r_view.frustum[4].normal[0] = m[3] - m[2];
2361 r_view.frustum[4].normal[1] = m[7] - m[6];
2362 r_view.frustum[4].normal[2] = m[11] - m[10];
2363 r_view.frustum[4].dist = m[15] - m[14];
2365 r_view.frustum[5].normal[0] = m[3] + m[2];
2366 r_view.frustum[5].normal[1] = m[7] + m[6];
2367 r_view.frustum[5].normal[2] = m[11] + m[10];
2368 r_view.frustum[5].dist = m[15] + m[14];
2371 if (r_view.useperspective)
2373 slopex = 1.0 / r_view.frustum_x;
2374 slopey = 1.0 / r_view.frustum_y;
2375 VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
2376 VectorMA(r_view.forward, slopex, r_view.left, r_view.frustum[1].normal);
2377 VectorMA(r_view.forward, -slopey, r_view.up , r_view.frustum[2].normal);
2378 VectorMA(r_view.forward, slopey, r_view.up , r_view.frustum[3].normal);
2379 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2381 // Leaving those out was a mistake, those were in the old code, and they
2382 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
2383 // I couldn't reproduce it after adding those normalizations. --blub
2384 VectorNormalize(r_view.frustum[0].normal);
2385 VectorNormalize(r_view.frustum[1].normal);
2386 VectorNormalize(r_view.frustum[2].normal);
2387 VectorNormalize(r_view.frustum[3].normal);
2389 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
2390 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
2391 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
2392 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[2]);
2393 VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[3]);
2395 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
2396 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
2397 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
2398 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
2399 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2403 VectorScale(r_view.left, -r_view.ortho_x, r_view.frustum[0].normal);
2404 VectorScale(r_view.left, r_view.ortho_x, r_view.frustum[1].normal);
2405 VectorScale(r_view.up, -r_view.ortho_y, r_view.frustum[2].normal);
2406 VectorScale(r_view.up, r_view.ortho_y, r_view.frustum[3].normal);
2407 VectorCopy(r_view.forward, r_view.frustum[4].normal);
2408 r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal) + r_view.ortho_x;
2409 r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal) + r_view.ortho_x;
2410 r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal) + r_view.ortho_y;
2411 r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal) + r_view.ortho_y;
2412 r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
2414 r_view.numfrustumplanes = 5;
2416 if (r_view.useclipplane)
2418 r_view.numfrustumplanes = 6;
2419 r_view.frustum[5] = r_view.clipplane;
2422 for (i = 0;i < r_view.numfrustumplanes;i++)
2423 PlaneClassify(r_view.frustum + i);
2425 // LordHavoc: note to all quake engine coders, Quake had a special case
2426 // for 90 degrees which assumed a square view (wrong), so I removed it,
2427 // Quake2 has it disabled as well.
2429 // rotate R_VIEWFORWARD right by FOV_X/2 degrees
2430 //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
2431 //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
2432 //PlaneClassify(&frustum[0]);
2434 // rotate R_VIEWFORWARD left by FOV_X/2 degrees
2435 //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
2436 //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
2437 //PlaneClassify(&frustum[1]);
2439 // rotate R_VIEWFORWARD up by FOV_X/2 degrees
2440 //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
2441 //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
2442 //PlaneClassify(&frustum[2]);
2444 // rotate R_VIEWFORWARD down by FOV_X/2 degrees
2445 //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
2446 //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
2447 //PlaneClassify(&frustum[3]);
2450 //VectorCopy(r_view.forward, r_view.frustum[4].normal);
2451 //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
2452 //PlaneClassify(&frustum[4]);
2455 void R_View_Update(void)
2457 R_View_SetFrustum();
2458 R_View_WorldVisibility(r_view.useclipplane);
2459 R_View_UpdateEntityVisible();
2462 void R_SetupView(void)
2464 if (!r_view.useperspective)
2465 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);
2466 else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
2467 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
2469 GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
2471 GL_SetupView_Orientation_FromEntity(&r_view.matrix);
2473 if (r_view.useclipplane)
2475 // LordHavoc: couldn't figure out how to make this approach the
2476 vec_t dist = r_view.clipplane.dist - r_water_clippingplanebias.value;
2477 vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
2478 if (viewdist < r_view.clipplane.dist + r_water_clippingplanebias.value)
2479 dist = r_view.clipplane.dist;
2480 GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
2484 void R_ResetViewRendering2D(void)
2486 if (gl_support_fragment_shader)
2488 qglUseProgramObjectARB(0);CHECKGLERROR
2493 // GL is weird because it's bottom to top, r_view.y is top to bottom
2494 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2495 GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
2496 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2497 GL_Color(1, 1, 1, 1);
2498 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2499 GL_BlendFunc(GL_ONE, GL_ZERO);
2500 GL_AlphaTest(false);
2501 GL_ScissorTest(false);
2502 GL_DepthMask(false);
2503 GL_DepthRange(0, 1);
2504 GL_DepthTest(false);
2505 R_Mesh_Matrix(&identitymatrix);
2506 R_Mesh_ResetTextureState();
2507 GL_PolygonOffset(0, 0);
2508 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2509 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2510 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2511 qglStencilMask(~0);CHECKGLERROR
2512 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2513 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2514 GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
2517 void R_ResetViewRendering3D(void)
2519 if (gl_support_fragment_shader)
2521 qglUseProgramObjectARB(0);CHECKGLERROR
2526 // GL is weird because it's bottom to top, r_view.y is top to bottom
2527 qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
2529 GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
2530 GL_Color(1, 1, 1, 1);
2531 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
2532 GL_BlendFunc(GL_ONE, GL_ZERO);
2533 GL_AlphaTest(false);
2534 GL_ScissorTest(true);
2536 GL_DepthRange(0, 1);
2538 R_Mesh_Matrix(&identitymatrix);
2539 R_Mesh_ResetTextureState();
2540 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
2541 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
2542 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2543 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2544 qglStencilMask(~0);CHECKGLERROR
2545 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
2546 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
2547 GL_CullFace(r_view.cullface_back);
2551 R_Bloom_SetupShader(
2553 "// written by Forest 'LordHavoc' Hale\n"
2555 "// common definitions between vertex shader and fragment shader:\n"
2557 "#ifdef __GLSL_CG_DATA_TYPES\n"
2558 "#define myhalf half\n"
2559 "#define myhvec2 hvec2\n"
2560 "#define myhvec3 hvec3\n"
2561 "#define myhvec4 hvec4\n"
2563 "#define myhalf float\n"
2564 "#define myhvec2 vec2\n"
2565 "#define myhvec3 vec3\n"
2566 "#define myhvec4 vec4\n"
2569 "varying vec2 ScreenTexCoord;\n"
2570 "varying vec2 BloomTexCoord;\n"
2575 "// vertex shader specific:\n"
2576 "#ifdef VERTEX_SHADER\n"
2580 " ScreenTexCoord = vec2(gl_MultiTexCoord0);\n"
2581 " BloomTexCoord = vec2(gl_MultiTexCoord1);\n"
2582 " // transform vertex to camera space, using ftransform to match non-VS\n"
2584 " gl_Position = ftransform();\n"
2587 "#endif // VERTEX_SHADER\n"
2592 "// fragment shader specific:\n"
2593 "#ifdef FRAGMENT_SHADER\n"
2598 " myhvec3 color = myhvec3(texture2D(Texture_Screen, ScreenTexCoord));\n"
2599 " for (x = -BLUR_X;x <= BLUR_X;x++)
2600 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2601 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2602 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2603 " color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
2605 " gl_FragColor = vec4(color);\n"
2608 "#endif // FRAGMENT_SHADER\n"
2611 void R_RenderScene(qboolean addwaterplanes);
2613 static void R_Water_StartFrame(void)
2616 int waterwidth, waterheight, texturewidth, textureheight;
2617 r_waterstate_waterplane_t *p;
2619 // set waterwidth and waterheight to the water resolution that will be
2620 // used (often less than the screen resolution for faster rendering)
2621 waterwidth = (int)bound(1, r_view.width * r_water_resolutionmultiplier.value, r_view.width);
2622 waterheight = (int)bound(1, r_view.height * r_water_resolutionmultiplier.value, r_view.height);
2624 // calculate desired texture sizes
2625 // can't use water if the card does not support the texture size
2626 if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
2627 texturewidth = textureheight = waterwidth = waterheight = 0;
2628 else if (gl_support_arb_texture_non_power_of_two)
2630 texturewidth = waterwidth;
2631 textureheight = waterheight;
2635 for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
2636 for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
2639 // allocate textures as needed
2640 if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
2642 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2643 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
2645 if (p->texture_refraction)
2646 R_FreeTexture(p->texture_refraction);
2647 p->texture_refraction = NULL;
2648 if (p->texture_reflection)
2649 R_FreeTexture(p->texture_reflection);
2650 p->texture_reflection = NULL;
2652 memset(&r_waterstate, 0, sizeof(r_waterstate));
2653 r_waterstate.waterwidth = waterwidth;
2654 r_waterstate.waterheight = waterheight;
2655 r_waterstate.texturewidth = texturewidth;
2656 r_waterstate.textureheight = textureheight;
2659 if (r_waterstate.waterwidth)
2661 r_waterstate.enabled = true;
2663 // set up variables that will be used in shader setup
2664 r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2665 r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
2666 r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
2667 r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
2670 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
2671 r_waterstate.numwaterplanes = 0;
2674 static void R_Water_AddWaterPlane(msurface_t *surface)
2676 int triangleindex, planeindex;
2681 r_waterstate_waterplane_t *p;
2682 // just use the first triangle with a valid normal for any decisions
2683 VectorClear(normal);
2684 for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
2686 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
2687 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
2688 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
2689 TriangleNormal(vert[0], vert[1], vert[2], normal);
2690 if (VectorLength2(normal) >= 0.001)
2694 // find a matching plane if there is one
2695 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2696 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
2698 if (planeindex >= r_waterstate.maxwaterplanes)
2699 return; // nothing we can do, out of planes
2701 // if this triangle does not fit any known plane rendered this frame, add one
2702 if (planeindex >= r_waterstate.numwaterplanes)
2704 // store the new plane
2705 r_waterstate.numwaterplanes++;
2706 VectorCopy(normal, p->plane.normal);
2707 VectorNormalize(p->plane.normal);
2708 p->plane.dist = DotProduct(vert[0], p->plane.normal);
2709 PlaneClassify(&p->plane);
2710 // flip the plane if it does not face the viewer
2711 if (PlaneDiff(r_view.origin, &p->plane) < 0)
2713 VectorNegate(p->plane.normal, p->plane.normal);
2714 p->plane.dist *= -1;
2715 PlaneClassify(&p->plane);
2717 // clear materialflags and pvs
2718 p->materialflags = 0;
2719 p->pvsvalid = false;
2721 // merge this surface's materialflags into the waterplane
2722 p->materialflags |= surface->texture->currentframe->currentmaterialflags;
2723 // merge this surface's PVS into the waterplane
2724 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
2725 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS
2726 && r_refdef.worldmodel->brush.PointInLeaf && r_refdef.worldmodel->brush.PointInLeaf(r_refdef.worldmodel, center)->clusterindex >= 0)
2728 r_refdef.worldmodel->brush.FatPVS(r_refdef.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
2733 static void R_Water_ProcessPlanes(void)
2735 r_view_t originalview;
2737 r_waterstate_waterplane_t *p;
2739 originalview = r_view;
2741 // make sure enough textures are allocated
2742 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2744 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2746 if (!p->texture_refraction)
2747 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);
2748 if (!p->texture_refraction)
2752 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2754 if (!p->texture_reflection)
2755 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);
2756 if (!p->texture_reflection)
2762 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
2764 r_view.showdebug = false;
2765 r_view.width = r_waterstate.waterwidth;
2766 r_view.height = r_waterstate.waterheight;
2767 r_view.useclipplane = true;
2768 r_waterstate.renderingscene = true;
2770 // render the normal view scene and copy into texture
2771 // (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)
2772 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
2774 r_view.clipplane = p->plane;
2775 VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
2776 r_view.clipplane.dist = -r_view.clipplane.dist;
2777 PlaneClassify(&r_view.clipplane);
2779 R_RenderScene(false);
2781 // copy view into the screen texture
2782 R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
2783 GL_ActiveTexture(0);
2785 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
2788 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
2790 // render reflected scene and copy into texture
2791 Matrix4x4_Reflect(&r_view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
2792 r_view.clipplane = p->plane;
2793 // reverse the cullface settings for this render
2794 r_view.cullface_front = GL_FRONT;
2795 r_view.cullface_back = GL_BACK;
2796 if (r_refdef.worldmodel && r_refdef.worldmodel->brush.num_pvsclusterbytes)
2798 r_view.usecustompvs = true;
2800 memcpy(r_viewcache.world_pvsbits, p->pvsbits, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2802 memset(r_viewcache.world_pvsbits, 0xFF, r_refdef.worldmodel->brush.num_pvsclusterbytes);
2805 R_ResetViewRendering3D();
2807 if (r_timereport_active)
2808 R_TimeReport("viewclear");
2810 R_RenderScene(false);
2812 R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
2813 GL_ActiveTexture(0);
2815 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
2817 R_ResetViewRendering3D();
2819 if (r_timereport_active)
2820 R_TimeReport("viewclear");
2823 r_view = originalview;
2824 r_view.clear = true;
2825 r_waterstate.renderingscene = false;
2829 r_view = originalview;
2830 r_waterstate.renderingscene = false;
2831 Cvar_SetValueQuick(&r_water, 0);
2832 Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
2836 void R_Bloom_StartFrame(void)
2838 int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
2840 // set bloomwidth and bloomheight to the bloom resolution that will be
2841 // used (often less than the screen resolution for faster rendering)
2842 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
2843 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_view.height / r_view.width;
2844 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_view.height);
2846 // calculate desired texture sizes
2847 if (gl_support_arb_texture_non_power_of_two)
2849 screentexturewidth = r_view.width;
2850 screentextureheight = r_view.height;
2851 bloomtexturewidth = r_bloomstate.bloomwidth;
2852 bloomtextureheight = r_bloomstate.bloomheight;
2856 for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
2857 for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
2858 for (bloomtexturewidth = 1;bloomtexturewidth < r_bloomstate.bloomwidth ;bloomtexturewidth *= 2);
2859 for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2);
2864 screentexturewidth = screentextureheight = 0;
2866 else if (r_bloom.integer)
2871 screentexturewidth = screentextureheight = 0;
2872 bloomtexturewidth = bloomtextureheight = 0;
2875 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)
2877 // can't use bloom if the parameters are too weird
2878 // can't use bloom if the card does not support the texture size
2879 if (r_bloomstate.texture_screen)
2880 R_FreeTexture(r_bloomstate.texture_screen);
2881 if (r_bloomstate.texture_bloom)
2882 R_FreeTexture(r_bloomstate.texture_bloom);
2883 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
2887 r_bloomstate.enabled = true;
2888 r_bloomstate.hdr = r_hdr.integer != 0;
2890 // allocate textures as needed
2891 if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
2893 if (r_bloomstate.texture_screen)
2894 R_FreeTexture(r_bloomstate.texture_screen);
2895 r_bloomstate.texture_screen = NULL;
2896 r_bloomstate.screentexturewidth = screentexturewidth;
2897 r_bloomstate.screentextureheight = screentextureheight;
2898 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
2899 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);
2901 if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
2903 if (r_bloomstate.texture_bloom)
2904 R_FreeTexture(r_bloomstate.texture_bloom);
2905 r_bloomstate.texture_bloom = NULL;
2906 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
2907 r_bloomstate.bloomtextureheight = bloomtextureheight;
2908 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
2909 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);
2912 // set up a texcoord array for the full resolution screen image
2913 // (we have to keep this around to copy back during final render)
2914 r_bloomstate.screentexcoord2f[0] = 0;
2915 r_bloomstate.screentexcoord2f[1] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2916 r_bloomstate.screentexcoord2f[2] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2917 r_bloomstate.screentexcoord2f[3] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
2918 r_bloomstate.screentexcoord2f[4] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
2919 r_bloomstate.screentexcoord2f[5] = 0;
2920 r_bloomstate.screentexcoord2f[6] = 0;
2921 r_bloomstate.screentexcoord2f[7] = 0;
2923 // set up a texcoord array for the reduced resolution bloom image
2924 // (which will be additive blended over the screen image)
2925 r_bloomstate.bloomtexcoord2f[0] = 0;
2926 r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2927 r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2928 r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
2929 r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
2930 r_bloomstate.bloomtexcoord2f[5] = 0;
2931 r_bloomstate.bloomtexcoord2f[6] = 0;
2932 r_bloomstate.bloomtexcoord2f[7] = 0;
2935 void R_Bloom_CopyScreenTexture(float colorscale)
2937 r_refdef.stats.bloom++;
2939 R_ResetViewRendering2D();
2940 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2941 R_Mesh_ColorPointer(NULL, 0, 0);
2942 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
2943 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
2945 // copy view into the screen texture
2946 GL_ActiveTexture(0);
2948 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
2949 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2951 // now scale it down to the bloom texture size
2953 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2954 GL_BlendFunc(GL_ONE, GL_ZERO);
2955 GL_Color(colorscale, colorscale, colorscale, 1);
2956 // TODO: optimize with multitexture or GLSL
2957 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
2958 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2960 // we now have a bloom image in the framebuffer
2961 // copy it into the bloom image texture for later processing
2962 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2963 GL_ActiveTexture(0);
2965 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
2966 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
2969 void R_Bloom_CopyHDRTexture(void)
2971 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
2972 GL_ActiveTexture(0);
2974 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
2975 r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
2978 void R_Bloom_MakeTexture(void)
2981 float xoffset, yoffset, r, brighten;
2983 r_refdef.stats.bloom++;
2985 R_ResetViewRendering2D();
2986 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
2987 R_Mesh_ColorPointer(NULL, 0, 0);
2989 // we have a bloom image in the framebuffer
2991 qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
2993 for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
2996 r = bound(0, r_bloom_colorexponent.value / x, 1);
2997 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
2998 GL_Color(r, r, r, 1);
2999 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3000 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3001 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3002 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3004 // copy the vertically blurred bloom view to a texture
3005 GL_ActiveTexture(0);
3007 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
3008 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3011 range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
3012 brighten = r_bloom_brighten.value;
3014 brighten *= r_hdr_range.value;
3015 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3016 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
3018 for (dir = 0;dir < 2;dir++)
3020 // blend on at multiple vertical offsets to achieve a vertical blur
3021 // TODO: do offset blends using GLSL
3022 GL_BlendFunc(GL_ONE, GL_ZERO);
3023 for (x = -range;x <= range;x++)
3025 if (!dir){xoffset = 0;yoffset = x;}
3026 else {xoffset = x;yoffset = 0;}
3027 xoffset /= (float)r_bloomstate.bloomtexturewidth;
3028 yoffset /= (float)r_bloomstate.bloomtextureheight;
3029 // compute a texcoord array with the specified x and y offset
3030 r_bloomstate.offsettexcoord2f[0] = xoffset+0;
3031 r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3032 r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3033 r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
3034 r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
3035 r_bloomstate.offsettexcoord2f[5] = yoffset+0;
3036 r_bloomstate.offsettexcoord2f[6] = xoffset+0;
3037 r_bloomstate.offsettexcoord2f[7] = yoffset+0;
3038 // this r value looks like a 'dot' particle, fading sharply to
3039 // black at the edges
3040 // (probably not realistic but looks good enough)
3041 //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
3042 //r = (dir ? 1.0f : brighten)/(range*2+1);
3043 r = (dir ? 1.0f : brighten)/(range*2+1)*(1 - x*x/(float)(range*range));
3044 GL_Color(r, r, r, 1);
3045 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3046 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3047 GL_BlendFunc(GL_ONE, GL_ONE);
3050 // copy the vertically blurred bloom view to a texture
3051 GL_ActiveTexture(0);
3053 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
3054 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3057 // apply subtract last
3058 // (just like it would be in a GLSL shader)
3059 if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract)
3061 GL_BlendFunc(GL_ONE, GL_ZERO);
3062 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3063 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3064 GL_Color(1, 1, 1, 1);
3065 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3066 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3068 GL_BlendFunc(GL_ONE, GL_ONE);
3069 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
3070 R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
3071 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3072 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
3073 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3074 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3075 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3077 // copy the darkened bloom view to a texture
3078 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3079 GL_ActiveTexture(0);
3081 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
3082 r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
3086 static void R_UpdateFogColor(void); // needs to be called before HDR subrender too, as that changes colorscale!
3088 void R_HDR_RenderBloomTexture(void)
3090 int oldwidth, oldheight;
3092 oldwidth = r_view.width;
3093 oldheight = r_view.height;
3094 r_view.width = r_bloomstate.bloomwidth;
3095 r_view.height = r_bloomstate.bloomheight;
3097 // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer? it might improve SLI performance.
3098 // TODO: add exposure compensation features
3099 // TODO: add fp16 framebuffer support
3101 r_view.showdebug = false;
3102 r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
3104 r_view.colorscale /= r_hdr_range.value;
3108 r_waterstate.numwaterplanes = 0;
3109 R_RenderScene(r_waterstate.enabled);
3110 r_view.showdebug = true;
3112 R_ResetViewRendering2D();
3114 R_Bloom_CopyHDRTexture();
3115 R_Bloom_MakeTexture();
3117 R_ResetViewRendering3D();
3120 if (r_timereport_active)
3121 R_TimeReport("viewclear");
3123 // restore the view settings
3124 r_view.width = oldwidth;
3125 r_view.height = oldheight;
3128 static void R_BlendView(void)
3130 if (r_bloomstate.enabled && r_bloomstate.hdr)
3132 // render high dynamic range bloom effect
3133 // the bloom texture was made earlier this render, so we just need to
3134 // blend it onto the screen...
3135 R_ResetViewRendering2D();
3136 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3137 R_Mesh_ColorPointer(NULL, 0, 0);
3138 GL_Color(1, 1, 1, 1);
3139 GL_BlendFunc(GL_ONE, GL_ONE);
3140 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3141 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3142 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3143 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3145 else if (r_bloomstate.enabled)
3147 // render simple bloom effect
3148 // copy the screen and shrink it and darken it for the bloom process
3149 R_Bloom_CopyScreenTexture(r_bloom_colorscale.value);
3150 // make the bloom texture
3151 R_Bloom_MakeTexture();
3152 // put the original screen image back in place and blend the bloom
3154 R_ResetViewRendering2D();
3155 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3156 R_Mesh_ColorPointer(NULL, 0, 0);
3157 GL_Color(1, 1, 1, 1);
3158 GL_BlendFunc(GL_ONE, GL_ZERO);
3159 // do both in one pass if possible
3160 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
3161 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
3162 if (r_textureunits.integer >= 2 && gl_combine.integer)
3164 R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
3165 R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen));
3166 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0);
3170 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3171 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3172 // now blend on the bloom texture
3173 GL_BlendFunc(GL_ONE, GL_ONE);
3174 R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
3175 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
3177 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3178 r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
3180 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
3182 // apply a color tint to the whole view
3183 R_ResetViewRendering2D();
3184 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
3185 R_Mesh_ColorPointer(NULL, 0, 0);
3186 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3187 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
3188 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3192 void R_RenderScene(qboolean addwaterplanes);
3194 matrix4x4_t r_waterscrollmatrix;
3196 static void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
3198 if (r_refdef.fog_density)
3200 r_refdef.fogcolor[0] = r_refdef.fog_red;
3201 r_refdef.fogcolor[1] = r_refdef.fog_green;
3202 r_refdef.fogcolor[2] = r_refdef.fog_blue;
3206 // color.rgb *= SceneBrightness;
3207 VectorScale(r_refdef.fogcolor, r_view.colorscale, fogvec);
3208 if(r_glsl.integer && (r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0)) // need to support contrast boost
3210 // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1);
3211 fogvec[0] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[0] + 1);
3212 fogvec[1] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[1] + 1);
3213 fogvec[2] *= r_glsl_contrastboost.value / ((r_glsl_contrastboost.value - 1) * fogvec[2] + 1);
3215 r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
3216 r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
3217 r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
3222 void R_UpdateVariables(void)
3226 r_refdef.farclip = 4096;
3227 if (r_refdef.worldmodel)
3228 r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
3229 r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
3231 if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
3232 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
3233 r_refdef.polygonfactor = 0;
3234 r_refdef.polygonoffset = 0;
3235 r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3236 r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
3238 r_refdef.rtworld = r_shadow_realtime_world.integer;
3239 r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
3240 r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
3241 r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
3242 r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
3243 if (r_showsurfaces.integer)
3245 r_refdef.rtworld = false;
3246 r_refdef.rtworldshadows = false;
3247 r_refdef.rtdlight = false;
3248 r_refdef.rtdlightshadows = false;
3249 r_refdef.lightmapintensity = 0;
3252 if (gamemode == GAME_NEHAHRA)
3254 if (gl_fogenable.integer)
3256 r_refdef.oldgl_fogenable = true;
3257 r_refdef.fog_density = gl_fogdensity.value;
3258 r_refdef.fog_red = gl_fogred.value;
3259 r_refdef.fog_green = gl_foggreen.value;
3260 r_refdef.fog_blue = gl_fogblue.value;
3262 else if (r_refdef.oldgl_fogenable)
3264 r_refdef.oldgl_fogenable = false;
3265 r_refdef.fog_density = 0;
3266 r_refdef.fog_red = 0;
3267 r_refdef.fog_green = 0;
3268 r_refdef.fog_blue = 0;
3272 r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
3273 r_refdef.fog_start = max(0, r_refdef.fog_start);
3277 if (r_refdef.fog_density)
3279 r_refdef.fogenabled = true;
3280 // this is the point where the fog reaches 0.9986 alpha, which we
3281 // consider a good enough cutoff point for the texture
3282 // (0.9986 * 256 == 255.6)
3283 r_refdef.fogrange = 16 / (r_refdef.fog_density * r_refdef.fog_density);
3284 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
3285 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
3286 // fog color was already set
3287 // update the fog texture
3288 if (r_refdef.fogmasktable_start != r_refdef.fog_start || r_refdef.fogmasktable_alpha != r_refdef.fog_alpha)
3289 R_BuildFogTexture();
3292 r_refdef.fogenabled = false;
3300 void R_RenderView(void)
3302 if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
3303 return; //Host_Error ("R_RenderView: NULL worldmodel");
3305 R_Shadow_UpdateWorldLightSelection();
3307 R_Bloom_StartFrame();
3308 R_Water_StartFrame();
3311 if (r_timereport_active)
3312 R_TimeReport("viewsetup");
3314 R_ResetViewRendering3D();
3319 if (r_timereport_active)
3320 R_TimeReport("viewclear");
3322 r_view.clear = true;
3324 r_view.showdebug = true;
3326 // this produces a bloom texture to be used in R_BlendView() later
3328 R_HDR_RenderBloomTexture();
3330 r_view.colorscale = r_hdr_scenebrightness.value;
3331 r_waterstate.numwaterplanes = 0;
3332 R_RenderScene(r_waterstate.enabled);
3335 if (r_timereport_active)
3336 R_TimeReport("blendview");
3338 GL_Scissor(0, 0, vid.width, vid.height);
3339 GL_ScissorTest(false);
3343 extern void R_DrawLightningBeams (void);
3344 extern void VM_CL_AddPolygonsToMeshQueue (void);
3345 extern void R_DrawPortals (void);
3346 extern cvar_t cl_locs_show;
3347 static void R_DrawLocs(void);
3348 static void R_DrawEntityBBoxes(void);
3349 void R_RenderScene(qboolean addwaterplanes)
3353 R_ResetViewRendering3D();
3356 if (r_timereport_active)
3357 R_TimeReport("watervis");
3359 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawAddWaterPlanes)
3361 r_refdef.worldmodel->DrawAddWaterPlanes(r_refdef.worldentity);
3362 if (r_timereport_active)
3363 R_TimeReport("waterworld");
3366 // don't let sound skip if going slow
3367 if (r_refdef.extraupdate)
3370 R_DrawModelsAddWaterPlanes();
3371 if (r_timereport_active)
3372 R_TimeReport("watermodels");
3374 R_Water_ProcessPlanes();
3375 if (r_timereport_active)
3376 R_TimeReport("waterscenes");
3379 R_ResetViewRendering3D();
3381 // don't let sound skip if going slow
3382 if (r_refdef.extraupdate)
3385 R_MeshQueue_BeginScene();
3390 if (r_timereport_active)
3391 R_TimeReport("visibility");
3393 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);
3395 if (cl.csqc_vidvars.drawworld)
3397 // don't let sound skip if going slow
3398 if (r_refdef.extraupdate)
3401 if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
3403 r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
3404 if (r_timereport_active)
3405 R_TimeReport("worldsky");
3408 if (R_DrawBrushModelsSky() && r_timereport_active)
3409 R_TimeReport("bmodelsky");
3412 if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawDepth)
3414 r_refdef.worldmodel->DrawDepth(r_refdef.worldentity);
3415 if (r_timereport_active)
3416 R_TimeReport("worlddepth");
3418 if (r_depthfirst.integer >= 2)
3420 R_DrawModelsDepth();
3421 if (r_timereport_active)
3422 R_TimeReport("modeldepth");
3425 if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->Draw)
3427 r_refdef.worldmodel->Draw(r_refdef.worldentity);
3428 if (r_timereport_active)
3429 R_TimeReport("world");
3432 // don't let sound skip if going slow
3433 if (r_refdef.extraupdate)
3437 if (r_timereport_active)
3438 R_TimeReport("models");
3440 // don't let sound skip if going slow
3441 if (r_refdef.extraupdate)
3444 if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
3446 R_DrawModelShadows();
3448 R_ResetViewRendering3D();
3450 // don't let sound skip if going slow
3451 if (r_refdef.extraupdate)
3455 R_ShadowVolumeLighting(false);
3456 if (r_timereport_active)
3457 R_TimeReport("rtlights");
3459 // don't let sound skip if going slow
3460 if (r_refdef.extraupdate)
3463 if (cl.csqc_vidvars.drawworld)
3465 R_DrawLightningBeams();
3466 if (r_timereport_active)
3467 R_TimeReport("lightning");
3470 if (r_timereport_active)
3471 R_TimeReport("decals");
3474 if (r_timereport_active)
3475 R_TimeReport("particles");
3478 if (r_timereport_active)
3479 R_TimeReport("explosions");
3482 if (gl_support_fragment_shader)
3484 qglUseProgramObjectARB(0);CHECKGLERROR
3486 VM_CL_AddPolygonsToMeshQueue();
3488 if (r_view.showdebug)
3490 if (cl_locs_show.integer)
3493 if (r_timereport_active)
3494 R_TimeReport("showlocs");
3497 if (r_drawportals.integer)
3500 if (r_timereport_active)
3501 R_TimeReport("portals");
3504 if (r_showbboxes.value > 0)
3506 R_DrawEntityBBoxes();
3507 if (r_timereport_active)
3508 R_TimeReport("bboxes");
3512 if (gl_support_fragment_shader)
3514 qglUseProgramObjectARB(0);CHECKGLERROR
3516 R_MeshQueue_RenderTransparent();
3517 if (r_timereport_active)
3518 R_TimeReport("drawtrans");
3520 if (gl_support_fragment_shader)
3522 qglUseProgramObjectARB(0);CHECKGLERROR
3525 if (r_view.showdebug && r_refdef.worldmodel && r_refdef.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value > 0 || r_showcollisionbrushes.value > 0))
3527 r_refdef.worldmodel->DrawDebug(r_refdef.worldentity);
3528 if (r_timereport_active)
3529 R_TimeReport("worlddebug");
3530 R_DrawModelsDebug();
3531 if (r_timereport_active)
3532 R_TimeReport("modeldebug");
3535 if (gl_support_fragment_shader)
3537 qglUseProgramObjectARB(0);CHECKGLERROR
3540 if (cl.csqc_vidvars.drawworld)
3543 if (r_timereport_active)
3544 R_TimeReport("coronas");
3547 // don't let sound skip if going slow
3548 if (r_refdef.extraupdate)
3551 R_ResetViewRendering2D();
3554 static const int bboxelements[36] =
3564 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
3567 float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
3568 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3569 GL_DepthMask(false);
3570 GL_DepthRange(0, 1);
3571 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3572 R_Mesh_Matrix(&identitymatrix);
3573 R_Mesh_ResetTextureState();
3575 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
3576 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
3577 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
3578 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
3579 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
3580 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
3581 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
3582 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
3583 R_FillColors(color4f, 8, cr, cg, cb, ca);
3584 if (r_refdef.fogenabled)
3586 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
3588 f1 = FogPoint_World(v);
3590 c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
3591 c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
3592 c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
3595 R_Mesh_VertexPointer(vertex3f, 0, 0);
3596 R_Mesh_ColorPointer(color4f, 0, 0);
3597 R_Mesh_ResetTextureState();
3598 R_Mesh_Draw(0, 8, 12, bboxelements, 0, 0);
3601 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3605 prvm_edict_t *edict;
3606 // this function draws bounding boxes of server entities
3610 for (i = 0;i < numsurfaces;i++)
3612 edict = PRVM_EDICT_NUM(surfacelist[i]);
3613 switch ((int)edict->fields.server->solid)
3615 case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
3616 case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
3617 case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
3618 case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
3619 case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
3620 default: Vector4Set(color, 0, 0, 0, 0.50);break;
3622 color[3] *= r_showbboxes.value;
3623 color[3] = bound(0, color[3], 1);
3624 GL_DepthTest(!r_showdisabledepthtest.integer);
3625 GL_CullFace(r_view.cullface_front);
3626 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
3631 static void R_DrawEntityBBoxes(void)
3634 prvm_edict_t *edict;
3636 // this function draws bounding boxes of server entities
3640 for (i = 0;i < prog->num_edicts;i++)
3642 edict = PRVM_EDICT_NUM(i);
3643 if (edict->priv.server->free)
3645 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
3646 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
3651 int nomodelelements[24] =
3663 float nomodelvertex3f[6*3] =
3673 float nomodelcolor4f[6*4] =
3675 0.0f, 0.0f, 0.5f, 1.0f,
3676 0.0f, 0.0f, 0.5f, 1.0f,
3677 0.0f, 0.5f, 0.0f, 1.0f,
3678 0.0f, 0.5f, 0.0f, 1.0f,
3679 0.5f, 0.0f, 0.0f, 1.0f,
3680 0.5f, 0.0f, 0.0f, 1.0f
3683 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3688 // this is only called once per entity so numsurfaces is always 1, and
3689 // surfacelist is always {0}, so this code does not handle batches
3690 R_Mesh_Matrix(&ent->matrix);
3692 if (ent->flags & EF_ADDITIVE)
3694 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
3695 GL_DepthMask(false);
3697 else if (ent->alpha < 1)
3699 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3700 GL_DepthMask(false);
3704 GL_BlendFunc(GL_ONE, GL_ZERO);
3707 GL_DepthRange(0, (ent->flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
3708 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3709 GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
3710 GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : r_view.cullface_back);
3711 R_Mesh_VertexPointer(nomodelvertex3f, 0, 0);
3712 if (r_refdef.fogenabled)
3715 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3716 R_Mesh_ColorPointer(color4f, 0, 0);
3717 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3718 f1 = FogPoint_World(org);
3720 for (i = 0, c = color4f;i < 6;i++, c += 4)
3722 c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
3723 c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
3724 c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
3728 else if (ent->alpha != 1)
3730 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
3731 R_Mesh_ColorPointer(color4f, 0, 0);
3732 for (i = 0, c = color4f;i < 6;i++, c += 4)
3736 R_Mesh_ColorPointer(nomodelcolor4f, 0, 0);
3737 R_Mesh_ResetTextureState();
3738 R_Mesh_Draw(0, 6, 8, nomodelelements, 0, 0);
3741 void R_DrawNoModel(entity_render_t *ent)
3744 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3745 //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
3746 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
3748 // R_DrawNoModelCallback(ent, 0);
3751 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
3753 vec3_t right1, right2, diff, normal;
3755 VectorSubtract (org2, org1, normal);
3757 // calculate 'right' vector for start
3758 VectorSubtract (r_view.origin, org1, diff);
3759 CrossProduct (normal, diff, right1);
3760 VectorNormalize (right1);
3762 // calculate 'right' vector for end
3763 VectorSubtract (r_view.origin, org2, diff);
3764 CrossProduct (normal, diff, right2);
3765 VectorNormalize (right2);
3767 vert[ 0] = org1[0] + width * right1[0];
3768 vert[ 1] = org1[1] + width * right1[1];
3769 vert[ 2] = org1[2] + width * right1[2];
3770 vert[ 3] = org1[0] - width * right1[0];
3771 vert[ 4] = org1[1] - width * right1[1];
3772 vert[ 5] = org1[2] - width * right1[2];
3773 vert[ 6] = org2[0] - width * right2[0];
3774 vert[ 7] = org2[1] - width * right2[1];
3775 vert[ 8] = org2[2] - width * right2[2];
3776 vert[ 9] = org2[0] + width * right2[0];
3777 vert[10] = org2[1] + width * right2[1];
3778 vert[11] = org2[2] + width * right2[2];
3781 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
3783 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)
3788 if (r_refdef.fogenabled)
3789 fog = FogPoint_World(origin);
3791 R_Mesh_Matrix(&identitymatrix);
3792 GL_BlendFunc(blendfunc1, blendfunc2);
3798 GL_CullFace(r_view.cullface_front);
3801 GL_CullFace(r_view.cullface_back);
3803 GL_DepthMask(false);
3804 GL_DepthRange(0, depthshort ? 0.0625 : 1);
3805 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
3806 GL_DepthTest(!depthdisable);
3808 vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
3809 vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
3810 vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
3811 vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
3812 vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
3813 vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
3814 vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
3815 vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
3816 vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
3817 vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
3818 vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
3819 vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
3821 R_Mesh_VertexPointer(vertex3f, 0, 0);
3822 R_Mesh_ColorPointer(NULL, 0, 0);
3823 R_Mesh_ResetTextureState();
3824 R_Mesh_TexBind(0, R_GetTexture(texture));
3825 R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f, 0, 0);
3826 // FIXME: fixed function path can't properly handle r_view.colorscale > 1
3827 GL_Color(cr * fog * r_view.colorscale, cg * fog * r_view.colorscale, cb * fog * r_view.colorscale, ca);
3828 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3830 if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
3832 R_Mesh_TexBind(0, R_GetTexture(fogtexture));
3833 GL_BlendFunc(blendfunc1, GL_ONE);
3835 GL_Color(r_refdef.fogcolor[0] * fog, r_refdef.fogcolor[1] * fog, r_refdef.fogcolor[2] * fog, ca);
3836 R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
3840 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
3845 VectorSet(v, x, y, z);
3846 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
3847 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
3849 if (i == mesh->numvertices)
3851 if (mesh->numvertices < mesh->maxvertices)
3853 VectorCopy(v, vertex3f);
3854 mesh->numvertices++;
3856 return mesh->numvertices;
3862 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
3866 element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3867 element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
3868 e = mesh->element3i + mesh->numtriangles * 3;
3869 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
3871 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
3872 if (mesh->numtriangles < mesh->maxtriangles)
3877 mesh->numtriangles++;
3879 element[1] = element[2];
3883 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
3887 element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3888 element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
3889 e = mesh->element3i + mesh->numtriangles * 3;
3890 for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
3892 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
3893 if (mesh->numtriangles < mesh->maxtriangles)
3898 mesh->numtriangles++;
3900 element[1] = element[2];
3904 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
3905 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
3907 int planenum, planenum2;
3910 mplane_t *plane, *plane2;
3912 double temppoints[2][256*3];
3913 // figure out how large a bounding box we need to properly compute this brush
3915 for (w = 0;w < numplanes;w++)
3916 maxdist = max(maxdist, planes[w].dist);
3917 // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
3918 maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
3919 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
3923 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
3924 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
3926 if (planenum2 == planenum)
3928 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);
3931 if (tempnumpoints < 3)
3933 // generate elements forming a triangle fan for this polygon
3934 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
3938 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)
3940 texturelayer_t *layer;
3941 layer = t->currentlayers + t->currentnumlayers++;
3943 layer->depthmask = depthmask;
3944 layer->blendfunc1 = blendfunc1;
3945 layer->blendfunc2 = blendfunc2;
3946 layer->texture = texture;
3947 layer->texmatrix = *matrix;
3948 layer->color[0] = r * r_view.colorscale;
3949 layer->color[1] = g * r_view.colorscale;
3950 layer->color[2] = b * r_view.colorscale;
3951 layer->color[3] = a;
3954 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
3957 index = parms[2] + r_refdef.time * parms[3];
3958 index -= floor(index);
3962 case Q3WAVEFUNC_NONE:
3963 case Q3WAVEFUNC_NOISE:
3964 case Q3WAVEFUNC_COUNT:
3967 case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
3968 case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
3969 case Q3WAVEFUNC_SAWTOOTH: f = index;break;
3970 case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
3971 case Q3WAVEFUNC_TRIANGLE:
3973 f = index - floor(index);
3984 return (float)(parms[0] + parms[1] * f);
3987 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
3990 model_t *model = ent->model;
3993 q3shaderinfo_layer_tcmod_t *tcmod;
3995 // switch to an alternate material if this is a q1bsp animated material
3997 texture_t *texture = t;
3998 int s = ent->skinnum;
3999 if ((unsigned int)s >= (unsigned int)model->numskins)
4001 if (model->skinscenes)
4003 if (model->skinscenes[s].framecount > 1)
4004 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
4006 s = model->skinscenes[s].firstframe;
4009 t = t + s * model->num_surfaces;
4012 // use an alternate animation if the entity's frame is not 0,
4013 // and only if the texture has an alternate animation
4014 if (ent->frame2 != 0 && t->anim_total[1])
4015 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
4017 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
4019 texture->currentframe = t;
4022 // update currentskinframe to be a qw skin or animation frame
4023 if ((i = ent->entitynumber - 1) >= 0 && i < cl.maxclients)
4025 if (strcmp(r_qwskincache[i], cl.scores[i].qw_skin))
4027 strlcpy(r_qwskincache[i], cl.scores[i].qw_skin, sizeof(r_qwskincache[i]));
4028 Con_DPrintf("loading skins/%s\n", r_qwskincache[i]);
4029 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);
4031 t->currentskinframe = r_qwskincache_skinframe[i];
4032 if (t->currentskinframe == NULL)
4033 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4035 else if (t->numskinframes >= 2)
4036 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
4037 if (t->backgroundnumskinframes >= 2)
4038 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - ent->frame2time)) % t->backgroundnumskinframes];
4040 t->currentmaterialflags = t->basematerialflags;
4041 t->currentalpha = ent->alpha;
4042 if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
4044 t->currentalpha *= r_wateralpha.value;
4046 * FIXME what is this supposed to do?
4047 // if rendering refraction/reflection, disable transparency
4048 if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
4049 t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
4052 if(!r_waterstate.enabled)
4053 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
4054 if (!(ent->flags & RENDER_LIGHT))
4055 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
4056 else if (rsurface.modeltexcoordlightmap2f == NULL)
4058 // pick a model lighting mode
4059 if (VectorLength2(ent->modellight_diffuse) >= (1.0f / 256.0f))
4060 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
4062 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
4064 if (ent->effects & EF_ADDITIVE)
4065 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4066 else if (t->currentalpha < 1)
4067 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
4068 if (ent->effects & EF_DOUBLESIDED)
4069 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
4070 if (ent->effects & EF_NODEPTHTEST)
4071 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4072 if (ent->flags & RENDER_VIEWMODEL)
4073 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
4074 if (t->backgroundnumskinframes && !(t->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
4075 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
4077 // make sure that the waterscroll matrix is used on water surfaces when
4078 // there is no tcmod
4079 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4080 t->currenttexmatrix = r_waterscrollmatrix;
4082 for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
4085 switch(tcmod->tcmod)
4089 if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
4090 matrix = r_waterscrollmatrix;
4092 matrix = identitymatrix;
4094 case Q3TCMOD_ENTITYTRANSLATE:
4095 // this is used in Q3 to allow the gamecode to control texcoord
4096 // scrolling on the entity, which is not supported in darkplaces yet.
4097 Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
4099 case Q3TCMOD_ROTATE:
4100 Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
4101 Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.time, 0, 0, 1);
4102 Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
4105 Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
4107 case Q3TCMOD_SCROLL:
4108 Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.time, tcmod->parms[1] * r_refdef.time, 0);
4110 case Q3TCMOD_STRETCH:
4111 f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
4112 Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
4114 case Q3TCMOD_TRANSFORM:
4115 VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
4116 VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
4117 VectorSet(tcmat + 6, 0 , 0 , 1);
4118 VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
4119 Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
4121 case Q3TCMOD_TURBULENT:
4122 // this is handled in the RSurf_PrepareVertices function
4123 matrix = identitymatrix;
4126 // either replace or concatenate the transformation
4128 t->currenttexmatrix = matrix;
4131 matrix4x4_t temp = t->currenttexmatrix;
4132 Matrix4x4_Concat(&t->currenttexmatrix, &matrix, &temp);
4136 t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
4137 t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4138 t->glosstexture = r_texture_black;
4139 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
4140 t->backgroundglosstexture = r_texture_black;
4141 t->specularpower = r_shadow_glossexponent.value;
4142 // TODO: store reference values for these in the texture?
4143 t->specularscale = 0;
4144 if (r_shadow_gloss.integer > 0)
4146 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
4148 if (r_shadow_glossintensity.value > 0)
4150 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
4151 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
4152 t->specularscale = r_shadow_glossintensity.value;
4155 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
4157 t->glosstexture = r_texture_white;
4158 t->backgroundglosstexture = r_texture_white;
4159 t->specularscale = r_shadow_gloss2intensity.value;
4163 // lightmaps mode looks bad with dlights using actual texturing, so turn
4164 // off the colormap and glossmap, but leave the normalmap on as it still
4165 // accurately represents the shading involved
4166 if (gl_lightmaps.integer && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
4168 t->basetexture = r_texture_white;
4169 t->specularscale = 0;
4172 VectorClear(t->dlightcolor);
4173 t->currentnumlayers = 0;
4174 if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
4176 if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
4178 int blendfunc1, blendfunc2, depthmask;
4179 if (t->currentmaterialflags & MATERIALFLAG_ADD)
4181 blendfunc1 = GL_SRC_ALPHA;
4182 blendfunc2 = GL_ONE;
4184 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
4186 blendfunc1 = GL_SRC_ALPHA;
4187 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
4189 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
4191 blendfunc1 = t->customblendfunc[0];
4192 blendfunc2 = t->customblendfunc[1];
4196 blendfunc1 = GL_ONE;
4197 blendfunc2 = GL_ZERO;
4199 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
4200 if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
4202 rtexture_t *currentbasetexture;
4204 if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
4205 layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
4206 currentbasetexture = (VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) < (1.0f / 1048576.0f) && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
4207 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
4209 // fullbright is not affected by r_refdef.lightmapintensity
4210 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
4211 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4212 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);
4213 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4214 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);
4219 // set the color tint used for lights affecting this surface
4220 VectorSet(t->dlightcolor, ent->colormod[0] * t->currentalpha, ent->colormod[1] * t->currentalpha, ent->colormod[2] * t->currentalpha);
4222 // q3bsp has no lightmap updates, so the lightstylevalue that
4223 // would normally be baked into the lightmap must be
4224 // applied to the color
4225 // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
4226 if (ent->model->type == mod_brushq3)
4227 colorscale *= r_refdef.rtlightstylevalue[0];
4228 colorscale *= r_refdef.lightmapintensity;
4229 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);
4230 if (r_ambient.value >= (1.0f/64.0f))
4231 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);
4232 if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
4234 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);
4235 if (r_ambient.value >= (1.0f/64.0f))
4236 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);
4238 if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
4240 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);
4241 if (r_ambient.value >= (1.0f/64.0f))
4242 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);
4245 if (t->currentskinframe->glow != NULL)
4246 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);
4247 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
4249 // if this is opaque use alpha blend which will darken the earlier
4252 // if this is an alpha blended material, all the earlier passes
4253 // were darkened by fog already, so we only need to add the fog
4254 // color ontop through the fog mask texture
4256 // if this is an additive blended material, all the earlier passes
4257 // were darkened by fog already, and we should not add fog color
4258 // (because the background was not darkened, there is no fog color
4259 // that was lost behind it).
4260 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);
4267 void R_UpdateAllTextureInfo(entity_render_t *ent)
4271 for (i = 0;i < ent->model->num_texturesperskin;i++)
4272 R_UpdateTextureInfo(ent, ent->model->data_textures + i);
4275 rsurfacestate_t rsurface;
4277 void R_Mesh_ResizeArrays(int newvertices)
4280 if (rsurface.array_size >= newvertices)
4282 if (rsurface.array_modelvertex3f)
4283 Mem_Free(rsurface.array_modelvertex3f);
4284 rsurface.array_size = (newvertices + 1023) & ~1023;
4285 base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
4286 rsurface.array_modelvertex3f = base + rsurface.array_size * 0;
4287 rsurface.array_modelsvector3f = base + rsurface.array_size * 3;
4288 rsurface.array_modeltvector3f = base + rsurface.array_size * 6;
4289 rsurface.array_modelnormal3f = base + rsurface.array_size * 9;
4290 rsurface.array_deformedvertex3f = base + rsurface.array_size * 12;
4291 rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
4292 rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
4293 rsurface.array_deformednormal3f = base + rsurface.array_size * 21;
4294 rsurface.array_texcoord3f = base + rsurface.array_size * 24;
4295 rsurface.array_color4f = base + rsurface.array_size * 27;
4296 rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
4299 void RSurf_CleanUp(void)
4302 if (rsurface.mode == RSURFMODE_GLSL)
4304 qglUseProgramObjectARB(0);CHECKGLERROR
4306 GL_AlphaTest(false);
4307 rsurface.mode = RSURFMODE_NONE;
4308 rsurface.uselightmaptexture = false;
4309 rsurface.texture = NULL;
4312 void RSurf_ActiveWorldEntity(void)
4314 model_t *model = r_refdef.worldmodel;
4316 if (rsurface.array_size < model->surfmesh.num_vertices)
4317 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4318 rsurface.matrix = identitymatrix;
4319 rsurface.inversematrix = identitymatrix;
4320 R_Mesh_Matrix(&identitymatrix);
4321 VectorCopy(r_view.origin, rsurface.modelorg);
4322 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
4323 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
4324 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
4325 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
4326 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
4327 rsurface.frameblend[0].frame = 0;
4328 rsurface.frameblend[0].lerp = 1;
4329 rsurface.frameblend[1].frame = 0;
4330 rsurface.frameblend[1].lerp = 0;
4331 rsurface.frameblend[2].frame = 0;
4332 rsurface.frameblend[2].lerp = 0;
4333 rsurface.frameblend[3].frame = 0;
4334 rsurface.frameblend[3].lerp = 0;
4335 rsurface.basepolygonfactor = r_refdef.polygonfactor;
4336 rsurface.basepolygonoffset = r_refdef.polygonoffset;
4337 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4338 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4339 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4340 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4341 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4342 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4343 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4344 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4345 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4346 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4347 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4348 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4349 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4350 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4351 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4352 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4353 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4354 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4355 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4356 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4357 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4358 rsurface.modelelement3i = model->surfmesh.data_element3i;
4359 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4360 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4361 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4362 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4363 rsurface.modelsurfaces = model->data_surfaces;
4364 rsurface.generatedvertex = false;
4365 rsurface.vertex3f = rsurface.modelvertex3f;
4366 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4367 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4368 rsurface.svector3f = rsurface.modelsvector3f;
4369 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4370 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4371 rsurface.tvector3f = rsurface.modeltvector3f;
4372 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4373 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4374 rsurface.normal3f = rsurface.modelnormal3f;
4375 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4376 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4377 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4380 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4382 model_t *model = ent->model;
4384 if (rsurface.array_size < model->surfmesh.num_vertices)
4385 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
4386 rsurface.matrix = ent->matrix;
4387 rsurface.inversematrix = ent->inversematrix;
4388 R_Mesh_Matrix(&rsurface.matrix);
4389 Matrix4x4_Transform(&rsurface.inversematrix, r_view.origin, rsurface.modelorg);
4390 VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
4391 VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
4392 VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
4393 VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
4394 VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
4395 rsurface.frameblend[0] = ent->frameblend[0];
4396 rsurface.frameblend[1] = ent->frameblend[1];
4397 rsurface.frameblend[2] = ent->frameblend[2];
4398 rsurface.frameblend[3] = ent->frameblend[3];
4399 rsurface.basepolygonfactor = r_refdef.polygonfactor;
4400 rsurface.basepolygonoffset = r_refdef.polygonoffset;
4401 if (ent->model->brush.submodel)
4403 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
4404 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
4406 if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0))
4410 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4411 rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4412 rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4413 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4414 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
4416 else if (wantnormals)
4418 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4419 rsurface.modelsvector3f = NULL;
4420 rsurface.modeltvector3f = NULL;
4421 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4422 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
4426 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
4427 rsurface.modelsvector3f = NULL;
4428 rsurface.modeltvector3f = NULL;
4429 rsurface.modelnormal3f = NULL;
4430 Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL);
4432 rsurface.modelvertex3f_bufferobject = 0;
4433 rsurface.modelvertex3f_bufferoffset = 0;
4434 rsurface.modelsvector3f_bufferobject = 0;
4435 rsurface.modelsvector3f_bufferoffset = 0;
4436 rsurface.modeltvector3f_bufferobject = 0;
4437 rsurface.modeltvector3f_bufferoffset = 0;
4438 rsurface.modelnormal3f_bufferobject = 0;
4439 rsurface.modelnormal3f_bufferoffset = 0;
4440 rsurface.generatedvertex = true;
4444 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
4445 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
4446 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
4447 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
4448 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
4449 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
4450 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
4451 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
4452 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
4453 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
4454 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
4455 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
4456 rsurface.generatedvertex = false;
4458 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
4459 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
4460 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
4461 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
4462 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
4463 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
4464 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
4465 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
4466 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
4467 rsurface.modelelement3i = model->surfmesh.data_element3i;
4468 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
4469 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
4470 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
4471 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
4472 rsurface.modelsurfaces = model->data_surfaces;
4473 rsurface.vertex3f = rsurface.modelvertex3f;
4474 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4475 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4476 rsurface.svector3f = rsurface.modelsvector3f;
4477 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4478 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4479 rsurface.tvector3f = rsurface.modeltvector3f;
4480 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4481 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4482 rsurface.normal3f = rsurface.modelnormal3f;
4483 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4484 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4485 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4488 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
4489 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
4492 int texturesurfaceindex;
4497 const float *v1, *in_tc;
4499 float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
4501 q3shaderinfo_deform_t *deform;
4502 // 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
4503 if (rsurface.generatedvertex)
4505 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
4506 generatenormals = true;
4507 for (i = 0;i < Q3MAXDEFORMS;i++)
4509 if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
4511 generatetangents = true;
4512 generatenormals = true;
4514 if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
4515 generatenormals = true;
4517 if (generatenormals && !rsurface.modelnormal3f)
4519 rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
4520 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
4521 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
4522 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer);
4524 if (generatetangents && !rsurface.modelsvector3f)
4526 rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
4527 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
4528 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
4529 rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
4530 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
4531 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
4532 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);
4535 rsurface.vertex3f = rsurface.modelvertex3f;
4536 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
4537 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
4538 rsurface.svector3f = rsurface.modelsvector3f;
4539 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
4540 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
4541 rsurface.tvector3f = rsurface.modeltvector3f;
4542 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
4543 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
4544 rsurface.normal3f = rsurface.modelnormal3f;
4545 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
4546 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
4547 // if vertices are deformed (sprite flares and things in maps, possibly
4548 // water waves, bulges and other deformations), generate them into
4549 // rsurface.deform* arrays from whatever the rsurface.* arrays point to
4550 // (may be static model data or generated data for an animated model, or
4551 // the previous deform pass)
4552 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
4554 switch (deform->deform)
4557 case Q3DEFORM_PROJECTIONSHADOW:
4558 case Q3DEFORM_TEXT0:
4559 case Q3DEFORM_TEXT1:
4560 case Q3DEFORM_TEXT2:
4561 case Q3DEFORM_TEXT3:
4562 case Q3DEFORM_TEXT4:
4563 case Q3DEFORM_TEXT5:
4564 case Q3DEFORM_TEXT6:
4565 case Q3DEFORM_TEXT7:
4568 case Q3DEFORM_AUTOSPRITE:
4569 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4570 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4571 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4572 VectorNormalize(newforward);
4573 VectorNormalize(newright);
4574 VectorNormalize(newup);
4575 // make deformed versions of only the model vertices used by the specified surfaces
4576 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4578 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4579 // a single autosprite surface can contain multiple sprites...
4580 for (j = 0;j < surface->num_vertices - 3;j += 4)
4582 VectorClear(center);
4583 for (i = 0;i < 4;i++)
4584 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4585 VectorScale(center, 0.25f, center);
4586 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, forward);
4587 VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
4588 VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
4589 for (i = 0;i < 4;i++)
4591 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
4592 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4595 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);
4596 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);
4598 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4599 rsurface.vertex3f_bufferobject = 0;
4600 rsurface.vertex3f_bufferoffset = 0;
4601 rsurface.svector3f = rsurface.array_deformedsvector3f;
4602 rsurface.svector3f_bufferobject = 0;
4603 rsurface.svector3f_bufferoffset = 0;
4604 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4605 rsurface.tvector3f_bufferobject = 0;
4606 rsurface.tvector3f_bufferoffset = 0;
4607 rsurface.normal3f = rsurface.array_deformednormal3f;
4608 rsurface.normal3f_bufferobject = 0;
4609 rsurface.normal3f_bufferoffset = 0;
4611 case Q3DEFORM_AUTOSPRITE2:
4612 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
4613 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
4614 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
4615 VectorNormalize(newforward);
4616 VectorNormalize(newright);
4617 VectorNormalize(newup);
4618 // make deformed versions of only the model vertices used by the specified surfaces
4619 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4621 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4622 const float *v1, *v2;
4632 memset(shortest, 0, sizeof(shortest));
4633 // a single autosprite surface can contain multiple sprites...
4634 for (j = 0;j < surface->num_vertices - 3;j += 4)
4636 VectorClear(center);
4637 for (i = 0;i < 4;i++)
4638 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
4639 VectorScale(center, 0.25f, center);
4640 // find the two shortest edges, then use them to define the
4641 // axis vectors for rotating around the central axis
4642 for (i = 0;i < 6;i++)
4644 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
4645 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
4647 Debug_PolygonBegin(NULL, 0, false, 0);
4648 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
4649 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);
4650 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
4653 l = VectorDistance2(v1, v2);
4654 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
4656 l += (1.0f / 1024.0f);
4657 if (shortest[0].length2 > l || i == 0)
4659 shortest[1] = shortest[0];
4660 shortest[0].length2 = l;
4661 shortest[0].v1 = v1;
4662 shortest[0].v2 = v2;
4664 else if (shortest[1].length2 > l || i == 1)
4666 shortest[1].length2 = l;
4667 shortest[1].v1 = v1;
4668 shortest[1].v2 = v2;
4671 VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
4672 VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
4674 Debug_PolygonBegin(NULL, 0, false, 0);
4675 Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
4676 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);
4677 Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
4680 // this calculates the right vector from the shortest edge
4681 // and the up vector from the edge midpoints
4682 VectorSubtract(shortest[0].v1, shortest[0].v2, right);
4683 VectorNormalize(right);
4684 VectorSubtract(end, start, up);
4685 VectorNormalize(up);
4686 // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
4687 //VectorSubtract(rsurface.modelorg, center, forward);
4688 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, forward);
4689 VectorNegate(forward, forward);
4690 VectorReflect(forward, 0, up, forward);
4691 VectorNormalize(forward);
4692 CrossProduct(up, forward, newright);
4693 VectorNormalize(newright);
4695 Debug_PolygonBegin(NULL, 0, false, 0);
4696 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);
4697 Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
4698 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4702 Debug_PolygonBegin(NULL, 0, false, 0);
4703 Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
4704 Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
4705 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
4708 // rotate the quad around the up axis vector, this is made
4709 // especially easy by the fact we know the quad is flat,
4710 // so we only have to subtract the center position and
4711 // measure distance along the right vector, and then
4712 // multiply that by the newright vector and add back the
4714 // we also need to subtract the old position to undo the
4715 // displacement from the center, which we do with a
4716 // DotProduct, the subtraction/addition of center is also
4717 // optimized into DotProducts here
4718 l = DotProduct(right, center);
4719 for (i = 0;i < 4;i++)
4721 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
4722 f = DotProduct(right, v1) - l;
4723 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
4726 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);
4727 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);
4729 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4730 rsurface.vertex3f_bufferobject = 0;
4731 rsurface.vertex3f_bufferoffset = 0;
4732 rsurface.svector3f = rsurface.array_deformedsvector3f;
4733 rsurface.svector3f_bufferobject = 0;
4734 rsurface.svector3f_bufferoffset = 0;
4735 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4736 rsurface.tvector3f_bufferobject = 0;
4737 rsurface.tvector3f_bufferoffset = 0;
4738 rsurface.normal3f = rsurface.array_deformednormal3f;
4739 rsurface.normal3f_bufferobject = 0;
4740 rsurface.normal3f_bufferoffset = 0;
4742 case Q3DEFORM_NORMAL:
4743 // deform the normals to make reflections wavey
4744 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4746 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4747 for (j = 0;j < surface->num_vertices;j++)
4750 float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3;
4751 VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
4752 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal);
4753 normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4754 normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4755 normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
4756 VectorNormalize(normal);
4758 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);
4760 rsurface.svector3f = rsurface.array_deformedsvector3f;
4761 rsurface.svector3f_bufferobject = 0;
4762 rsurface.svector3f_bufferoffset = 0;
4763 rsurface.tvector3f = rsurface.array_deformedtvector3f;
4764 rsurface.tvector3f_bufferobject = 0;
4765 rsurface.tvector3f_bufferoffset = 0;
4766 rsurface.normal3f = rsurface.array_deformednormal3f;
4767 rsurface.normal3f_bufferobject = 0;
4768 rsurface.normal3f_bufferoffset = 0;
4771 // deform vertex array to make wavey water and flags and such
4772 waveparms[0] = deform->waveparms[0];
4773 waveparms[1] = deform->waveparms[1];
4774 waveparms[2] = deform->waveparms[2];
4775 waveparms[3] = deform->waveparms[3];
4776 // this is how a divisor of vertex influence on deformation
4777 animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
4778 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4779 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4781 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4782 for (j = 0;j < surface->num_vertices;j++)
4784 float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3;
4785 VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex);
4786 // if the wavefunc depends on time, evaluate it per-vertex
4789 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
4790 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
4792 VectorMA(vertex, scale, (rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, vertex);
4795 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4796 rsurface.vertex3f_bufferobject = 0;
4797 rsurface.vertex3f_bufferoffset = 0;
4799 case Q3DEFORM_BULGE:
4800 // deform vertex array to make the surface have moving bulges
4801 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4803 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4804 for (j = 0;j < surface->num_vertices;j++)
4806 scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.time * deform->parms[2])) * deform->parms[1];
4807 VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4810 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4811 rsurface.vertex3f_bufferobject = 0;
4812 rsurface.vertex3f_bufferoffset = 0;
4815 // deform vertex array
4816 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
4817 VectorScale(deform->parms, scale, waveparms);
4818 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4820 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4821 for (j = 0;j < surface->num_vertices;j++)
4822 VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
4824 rsurface.vertex3f = rsurface.array_deformedvertex3f;
4825 rsurface.vertex3f_bufferobject = 0;
4826 rsurface.vertex3f_bufferoffset = 0;
4830 // generate texcoords based on the chosen texcoord source
4831 switch(rsurface.texture->tcgen.tcgen)
4834 case Q3TCGEN_TEXTURE:
4835 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
4836 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordtexture2f_bufferobject;
4837 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
4839 case Q3TCGEN_LIGHTMAP:
4840 rsurface.texcoordtexture2f = rsurface.modeltexcoordlightmap2f;
4841 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4842 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4844 case Q3TCGEN_VECTOR:
4845 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4847 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4848 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)
4850 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
4851 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
4854 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4855 rsurface.texcoordtexture2f_bufferobject = 0;
4856 rsurface.texcoordtexture2f_bufferoffset = 0;
4858 case Q3TCGEN_ENVIRONMENT:
4859 // make environment reflections using a spheremap
4860 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4862 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4863 const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
4864 const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
4865 float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
4866 for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
4868 float l, d, eyedir[3];
4869 VectorSubtract(rsurface.modelorg, vertex, eyedir);
4870 l = 0.5f / VectorLength(eyedir);
4871 d = DotProduct(normal, eyedir)*2;
4872 out_tc[0] = 0.5f + (normal[1]*d - eyedir[1])*l;
4873 out_tc[1] = 0.5f - (normal[2]*d - eyedir[2])*l;
4876 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4877 rsurface.texcoordtexture2f_bufferobject = 0;
4878 rsurface.texcoordtexture2f_bufferoffset = 0;
4881 // the only tcmod that needs software vertex processing is turbulent, so
4882 // check for it here and apply the changes if needed
4883 // and we only support that as the first one
4884 // (handling a mixture of turbulent and other tcmods would be problematic
4885 // without punting it entirely to a software path)
4886 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
4888 amplitude = rsurface.texture->tcmods[0].parms[1];
4889 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.time * rsurface.texture->tcmods[0].parms[3];
4890 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
4892 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
4893 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)
4895 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4896 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
4899 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
4900 rsurface.texcoordtexture2f_bufferobject = 0;
4901 rsurface.texcoordtexture2f_bufferoffset = 0;
4903 rsurface.texcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
4904 rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
4905 rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
4906 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
4909 void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
4912 const msurface_t *surface = texturesurfacelist[0];
4913 const msurface_t *surface2;
4918 // TODO: lock all array ranges before render, rather than on each surface
4919 if (texturenumsurfaces == 1)
4921 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4922 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));
4924 else if (r_batchmode.integer == 2)
4926 #define MAXBATCHTRIANGLES 4096
4927 int batchtriangles = 0;
4928 int batchelements[MAXBATCHTRIANGLES*3];
4929 for (i = 0;i < texturenumsurfaces;i = j)
4931 surface = texturesurfacelist[i];
4933 if (surface->num_triangles > MAXBATCHTRIANGLES)
4935 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));
4938 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
4939 batchtriangles = surface->num_triangles;
4940 firstvertex = surface->num_firstvertex;
4941 endvertex = surface->num_firstvertex + surface->num_vertices;
4942 for (;j < texturenumsurfaces;j++)
4944 surface2 = texturesurfacelist[j];
4945 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
4947 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
4948 batchtriangles += surface2->num_triangles;
4949 firstvertex = min(firstvertex, surface2->num_firstvertex);
4950 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
4952 surface2 = texturesurfacelist[j-1];
4953 numvertices = endvertex - firstvertex;
4954 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
4957 else if (r_batchmode.integer == 1)
4959 for (i = 0;i < texturenumsurfaces;i = j)
4961 surface = texturesurfacelist[i];
4962 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
4963 if (texturesurfacelist[j] != surface2)
4965 surface2 = texturesurfacelist[j-1];
4966 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
4967 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
4968 GL_LockArrays(surface->num_firstvertex, numvertices);
4969 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
4974 for (i = 0;i < texturenumsurfaces;i++)
4976 surface = texturesurfacelist[i];
4977 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
4978 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));
4983 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit, int refractiontexunit, int reflectiontexunit)
4985 int i, planeindex, vertexindex;
4989 r_waterstate_waterplane_t *p, *bestp;
4990 msurface_t *surface;
4991 if (r_waterstate.renderingscene)
4993 for (i = 0;i < texturenumsurfaces;i++)
4995 surface = texturesurfacelist[i];
4996 if (lightmaptexunit >= 0)
4997 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
4998 if (deluxemaptexunit >= 0)
4999 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5000 // pick the closest matching water plane
5003 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5006 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
5008 Matrix4x4_Transform(&rsurface.matrix, v, vert);
5009 d += fabs(PlaneDiff(vert, &p->plane));
5011 if (bestd > d || !bestp)
5019 if (refractiontexunit >= 0)
5020 R_Mesh_TexBind(refractiontexunit, R_GetTexture(bestp->texture_refraction));
5021 if (reflectiontexunit >= 0)
5022 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(bestp->texture_reflection));
5026 if (refractiontexunit >= 0)
5027 R_Mesh_TexBind(refractiontexunit, R_GetTexture(r_texture_black));
5028 if (reflectiontexunit >= 0)
5029 R_Mesh_TexBind(reflectiontexunit, R_GetTexture(r_texture_black));
5031 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5032 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));
5036 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurface_t **texturesurfacelist, int lightmaptexunit, int deluxemaptexunit)
5040 const msurface_t *surface = texturesurfacelist[0];
5041 const msurface_t *surface2;
5046 // TODO: lock all array ranges before render, rather than on each surface
5047 if (texturenumsurfaces == 1)
5049 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5050 if (deluxemaptexunit >= 0)
5051 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5052 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5053 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));
5055 else if (r_batchmode.integer == 2)
5057 #define MAXBATCHTRIANGLES 4096
5058 int batchtriangles = 0;
5059 int batchelements[MAXBATCHTRIANGLES*3];
5060 for (i = 0;i < texturenumsurfaces;i = j)
5062 surface = texturesurfacelist[i];
5063 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5064 if (deluxemaptexunit >= 0)
5065 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5067 if (surface->num_triangles > MAXBATCHTRIANGLES)
5069 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));
5072 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
5073 batchtriangles = surface->num_triangles;
5074 firstvertex = surface->num_firstvertex;
5075 endvertex = surface->num_firstvertex + surface->num_vertices;
5076 for (;j < texturenumsurfaces;j++)
5078 surface2 = texturesurfacelist[j];
5079 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
5081 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
5082 batchtriangles += surface2->num_triangles;
5083 firstvertex = min(firstvertex, surface2->num_firstvertex);
5084 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
5086 surface2 = texturesurfacelist[j-1];
5087 numvertices = endvertex - firstvertex;
5088 R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
5091 else if (r_batchmode.integer == 1)
5094 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
5095 for (i = 0;i < texturenumsurfaces;i = j)
5097 surface = texturesurfacelist[i];
5098 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5099 if (texturesurfacelist[j] != surface2)
5101 Con_Printf(" %i", j - i);
5104 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
5106 for (i = 0;i < texturenumsurfaces;i = j)
5108 surface = texturesurfacelist[i];
5109 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5110 if (deluxemaptexunit >= 0)
5111 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5112 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
5113 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
5116 Con_Printf(" %i", j - i);
5118 surface2 = texturesurfacelist[j-1];
5119 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
5120 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
5121 GL_LockArrays(surface->num_firstvertex, numvertices);
5122 R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
5130 for (i = 0;i < texturenumsurfaces;i++)
5132 surface = texturesurfacelist[i];
5133 R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
5134 if (deluxemaptexunit >= 0)
5135 R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
5136 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5137 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));
5142 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5145 int texturesurfaceindex;
5146 if (r_showsurfaces.integer == 2)
5148 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5150 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5151 for (j = 0;j < surface->num_triangles;j++)
5153 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_view.colorscale;
5154 GL_Color(f, f, f, 1);
5155 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)));
5161 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5163 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5164 int k = (int)(((size_t)surface) / sizeof(msurface_t));
5165 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);
5166 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
5167 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));
5172 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **texturesurfacelist)
5174 int texturesurfaceindex;
5178 if (rsurface.lightmapcolor4f)
5180 // generate color arrays for the surfaces in this list
5181 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5183 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5184 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)
5186 f = FogPoint_Model(v);
5196 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5198 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5199 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)
5201 f = FogPoint_Model(v);
5209 rsurface.lightmapcolor4f = rsurface.array_color4f;
5210 rsurface.lightmapcolor4f_bufferobject = 0;
5211 rsurface.lightmapcolor4f_bufferoffset = 0;
5214 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a)
5216 int texturesurfaceindex;
5219 if (!rsurface.lightmapcolor4f)
5221 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5223 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5224 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)
5232 rsurface.lightmapcolor4f = rsurface.array_color4f;
5233 rsurface.lightmapcolor4f_bufferobject = 0;
5234 rsurface.lightmapcolor4f_bufferoffset = 0;
5237 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5240 rsurface.lightmapcolor4f = NULL;
5241 rsurface.lightmapcolor4f_bufferobject = 0;
5242 rsurface.lightmapcolor4f_bufferoffset = 0;
5243 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5244 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5245 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5246 GL_Color(r, g, b, a);
5247 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1);
5250 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5252 // TODO: optimize applyfog && applycolor case
5253 // just apply fog if necessary, and tint the fog color array if necessary
5254 rsurface.lightmapcolor4f = NULL;
5255 rsurface.lightmapcolor4f_bufferobject = 0;
5256 rsurface.lightmapcolor4f_bufferoffset = 0;
5257 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5258 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5259 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5260 GL_Color(r, g, b, a);
5261 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5264 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5266 int texturesurfaceindex;
5270 if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
5272 // generate color arrays for the surfaces in this list
5273 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5275 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5276 for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
5278 if (surface->lightmapinfo->samples)
5280 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
5281 float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
5282 VectorScale(lm, scale, c);
5283 if (surface->lightmapinfo->styles[1] != 255)
5285 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
5287 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
5288 VectorMA(c, scale, lm, c);
5289 if (surface->lightmapinfo->styles[2] != 255)
5292 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
5293 VectorMA(c, scale, lm, c);
5294 if (surface->lightmapinfo->styles[3] != 255)
5297 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
5298 VectorMA(c, scale, lm, c);
5308 rsurface.lightmapcolor4f = rsurface.array_color4f;
5309 rsurface.lightmapcolor4f_bufferobject = 0;
5310 rsurface.lightmapcolor4f_bufferoffset = 0;
5314 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
5315 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
5316 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
5318 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5319 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5320 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5321 GL_Color(r, g, b, a);
5322 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5325 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
5327 int texturesurfaceindex;
5331 vec3_t ambientcolor;
5332 vec3_t diffusecolor;
5336 VectorCopy(rsurface.modellight_lightdir, lightdir);
5337 f = 0.5f * r_refdef.lightmapintensity;
5338 ambientcolor[0] = rsurface.modellight_ambient[0] * r * f;
5339 ambientcolor[1] = rsurface.modellight_ambient[1] * g * f;
5340 ambientcolor[2] = rsurface.modellight_ambient[2] * b * f;
5341 diffusecolor[0] = rsurface.modellight_diffuse[0] * r * f;
5342 diffusecolor[1] = rsurface.modellight_diffuse[1] * g * f;
5343 diffusecolor[2] = rsurface.modellight_diffuse[2] * b * f;
5344 if (VectorLength2(diffusecolor) > 0)
5346 // generate color arrays for the surfaces in this list
5347 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5349 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5350 int numverts = surface->num_vertices;
5351 v = rsurface.vertex3f + 3 * surface->num_firstvertex;
5352 c2 = rsurface.normal3f + 3 * surface->num_firstvertex;
5353 c = rsurface.array_color4f + 4 * surface->num_firstvertex;
5354 // q3-style directional shading
5355 for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
5357 if ((f = DotProduct(c2, lightdir)) > 0)
5358 VectorMA(ambientcolor, f, diffusecolor, c);
5360 VectorCopy(ambientcolor, c);
5369 rsurface.lightmapcolor4f = rsurface.array_color4f;
5370 rsurface.lightmapcolor4f_bufferobject = 0;
5371 rsurface.lightmapcolor4f_bufferoffset = 0;
5375 r = ambientcolor[0];
5376 g = ambientcolor[1];
5377 b = ambientcolor[2];
5378 rsurface.lightmapcolor4f = NULL;
5379 rsurface.lightmapcolor4f_bufferobject = 0;
5380 rsurface.lightmapcolor4f_bufferoffset = 0;
5382 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
5383 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
5384 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
5385 GL_Color(r, g, b, a);
5386 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5389 void RSurf_SetupDepthAndCulling(void)
5391 // submodels are biased to avoid z-fighting with world surfaces that they
5392 // may be exactly overlapping (avoids z-fighting artifacts on certain
5393 // doors and things in Quake maps)
5394 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5395 GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
5396 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
5397 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5400 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
5402 RSurf_SetupDepthAndCulling();
5403 if (rsurface.mode != RSURFMODE_SHOWSURFACES)
5405 rsurface.mode = RSURFMODE_SHOWSURFACES;
5407 GL_BlendFunc(GL_ONE, GL_ZERO);
5408 R_Mesh_ColorPointer(NULL, 0, 0);
5409 R_Mesh_ResetTextureState();
5411 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5412 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5415 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
5417 // transparent sky would be ridiculous
5418 if ((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5420 if (rsurface.mode != RSURFMODE_SKY)
5422 if (rsurface.mode == RSURFMODE_GLSL)
5424 qglUseProgramObjectARB(0);CHECKGLERROR
5426 rsurface.mode = RSURFMODE_SKY;
5430 skyrendernow = false;
5432 // restore entity matrix
5433 R_Mesh_Matrix(&rsurface.matrix);
5435 RSurf_SetupDepthAndCulling();
5437 // LordHavoc: HalfLife maps have freaky skypolys so don't use
5438 // skymasking on them, and Quake3 never did sky masking (unlike
5439 // software Quake and software Quake2), so disable the sky masking
5440 // in Quake3 maps as it causes problems with q3map2 sky tricks,
5441 // and skymasking also looks very bad when noclipping outside the
5442 // level, so don't use it then either.
5443 if (r_refdef.worldmodel && r_refdef.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis)
5445 GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1);
5446 R_Mesh_ColorPointer(NULL, 0, 0);
5447 R_Mesh_ResetTextureState();
5448 if (skyrendermasked)
5450 // depth-only (masking)
5451 GL_ColorMask(0,0,0,0);
5452 // just to make sure that braindead drivers don't draw
5453 // anything despite that colormask...
5454 GL_BlendFunc(GL_ZERO, GL_ONE);
5459 GL_BlendFunc(GL_ONE, GL_ZERO);
5461 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5462 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5463 if (skyrendermasked)
5464 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5468 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
5470 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
5473 if (rsurface.mode != RSURFMODE_GLSL)
5475 rsurface.mode = RSURFMODE_GLSL;
5476 R_Mesh_ResetTextureState();
5479 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
5480 R_Mesh_TexBind(0, R_GetTexture(rsurface.texture->currentskinframe->nmap));
5481 R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture));
5482 R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture));
5483 R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation));
5484 R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants));
5485 R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt));
5486 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5488 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5489 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5490 R_Mesh_ColorPointer(NULL, 0, 0);
5492 else if (rsurface.uselightmaptexture)
5494 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5495 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5496 R_Mesh_ColorPointer(NULL, 0, 0);
5500 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5501 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5502 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5504 R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow));
5505 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5506 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5508 if (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5510 // render background
5511 GL_BlendFunc(GL_ONE, GL_ZERO);
5513 GL_AlphaTest(false);
5515 GL_Color(1, 1, 1, 1);
5516 R_Mesh_ColorPointer(NULL, 0, 0);
5518 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
5519 if (r_glsl_permutation)
5521 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
5522 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5523 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5524 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5525 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5526 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5527 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist, -1, -1, r_glsl_permutation->loc_Texture_Refraction ? 11 : -1, r_glsl_permutation->loc_Texture_Reflection ? 12 : -1);
5530 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5531 GL_DepthMask(false);
5532 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5533 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
5535 R_Mesh_TexBind(7, R_GetTexture(r_texture_grey128));
5536 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5537 R_Mesh_ColorPointer(NULL, 0, 0);
5539 else if (rsurface.uselightmaptexture)
5541 R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
5542 R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
5543 R_Mesh_ColorPointer(NULL, 0, 0);
5547 R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
5548 R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
5549 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
5551 R_Mesh_TexBind(11, R_GetTexture(r_texture_white)); // changed per surface
5552 R_Mesh_TexBind(12, R_GetTexture(r_texture_white)); // changed per surface
5555 R_SetupSurfaceShader(vec3_origin, rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE);
5556 if (!r_glsl_permutation)
5559 RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0 || r_glsl_permutation->loc_LightDir >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
5560 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
5561 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
5562 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
5563 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
5564 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
5565 // FIXME MOVE THIS TO A UNIFORM
5566 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]);
5568 if (r_glsl_permutation->loc_Texture_Refraction >= 0)
5570 GL_BlendFunc(GL_ONE, GL_ZERO);
5572 GL_AlphaTest(false);
5575 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
5577 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5578 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);
5580 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
5584 if (r_glsl_permutation->loc_Texture_Refraction >= 0 || r_glsl_permutation->loc_Texture_Reflection >= 0)
5585 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);
5587 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5589 if (rsurface.texture->backgroundnumskinframes && !(rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
5594 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
5596 // OpenGL 1.3 path - anything not completely ancient
5597 int texturesurfaceindex;
5598 qboolean applycolor;
5602 const texturelayer_t *layer;
5603 if (rsurface.mode != RSURFMODE_MULTIPASS)
5604 rsurface.mode = RSURFMODE_MULTIPASS;
5605 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5607 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5610 int layertexrgbscale;
5611 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5613 if (layerindex == 0)
5617 GL_AlphaTest(false);
5618 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5621 GL_DepthMask(layer->depthmask);
5622 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5623 if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
5625 layertexrgbscale = 4;
5626 VectorScale(layer->color, 0.25f, layercolor);
5628 else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
5630 layertexrgbscale = 2;
5631 VectorScale(layer->color, 0.5f, layercolor);
5635 layertexrgbscale = 1;
5636 VectorScale(layer->color, 1.0f, layercolor);
5638 layercolor[3] = layer->color[3];
5639 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
5640 R_Mesh_ColorPointer(NULL, 0, 0);
5641 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5642 switch (layer->type)
5644 case TEXTURELAYERTYPE_LITTEXTURE:
5645 memset(&m, 0, sizeof(m));
5646 m.tex[0] = R_GetTexture(r_texture_white);
5647 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5648 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5649 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5650 m.tex[1] = R_GetTexture(layer->texture);
5651 m.texmatrix[1] = layer->texmatrix;
5652 m.texrgbscale[1] = layertexrgbscale;
5653 m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
5654 m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
5655 m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
5656 R_Mesh_TextureState(&m);
5657 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5658 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5659 else if (rsurface.uselightmaptexture)
5660 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5662 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5664 case TEXTURELAYERTYPE_TEXTURE:
5665 memset(&m, 0, sizeof(m));
5666 m.tex[0] = R_GetTexture(layer->texture);
5667 m.texmatrix[0] = layer->texmatrix;
5668 m.texrgbscale[0] = layertexrgbscale;
5669 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5670 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5671 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5672 R_Mesh_TextureState(&m);
5673 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
5675 case TEXTURELAYERTYPE_FOG:
5676 memset(&m, 0, sizeof(m));
5677 m.texrgbscale[0] = layertexrgbscale;
5680 m.tex[0] = R_GetTexture(layer->texture);
5681 m.texmatrix[0] = layer->texmatrix;
5682 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5683 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5684 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5686 R_Mesh_TextureState(&m);
5687 // generate a color array for the fog pass
5688 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5689 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5693 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5694 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)
5696 f = 1 - FogPoint_Model(v);
5697 c[0] = layercolor[0];
5698 c[1] = layercolor[1];
5699 c[2] = layercolor[2];
5700 c[3] = f * layercolor[3];
5703 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5706 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5708 GL_LockArrays(0, 0);
5711 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5713 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5714 GL_AlphaTest(false);
5718 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist)
5720 // OpenGL 1.1 - crusty old voodoo path
5721 int texturesurfaceindex;
5725 const texturelayer_t *layer;
5726 if (rsurface.mode != RSURFMODE_MULTIPASS)
5727 rsurface.mode = RSURFMODE_MULTIPASS;
5728 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
5730 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
5732 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5734 if (layerindex == 0)
5738 GL_AlphaTest(false);
5739 qglDepthFunc(GL_EQUAL);CHECKGLERROR
5742 GL_DepthMask(layer->depthmask);
5743 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
5744 R_Mesh_ColorPointer(NULL, 0, 0);
5745 applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
5746 switch (layer->type)
5748 case TEXTURELAYERTYPE_LITTEXTURE:
5749 if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
5751 // two-pass lit texture with 2x rgbscale
5752 // first the lightmap pass
5753 memset(&m, 0, sizeof(m));
5754 m.tex[0] = R_GetTexture(r_texture_white);
5755 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5756 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5757 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5758 R_Mesh_TextureState(&m);
5759 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5760 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5761 else if (rsurface.uselightmaptexture)
5762 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5764 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5765 GL_LockArrays(0, 0);
5766 // then apply the texture to it
5767 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5768 memset(&m, 0, sizeof(m));
5769 m.tex[0] = R_GetTexture(layer->texture);
5770 m.texmatrix[0] = layer->texmatrix;
5771 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5772 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5773 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5774 R_Mesh_TextureState(&m);
5775 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);
5779 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
5780 memset(&m, 0, sizeof(m));
5781 m.tex[0] = R_GetTexture(layer->texture);
5782 m.texmatrix[0] = layer->texmatrix;
5783 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5784 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5785 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5786 R_Mesh_TextureState(&m);
5787 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5788 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);
5790 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);
5793 case TEXTURELAYERTYPE_TEXTURE:
5794 // singletexture unlit texture with transparency support
5795 memset(&m, 0, sizeof(m));
5796 m.tex[0] = R_GetTexture(layer->texture);
5797 m.texmatrix[0] = layer->texmatrix;
5798 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5799 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5800 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5801 R_Mesh_TextureState(&m);
5802 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);
5804 case TEXTURELAYERTYPE_FOG:
5805 // singletexture fogging
5806 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
5809 memset(&m, 0, sizeof(m));
5810 m.tex[0] = R_GetTexture(layer->texture);
5811 m.texmatrix[0] = layer->texmatrix;
5812 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
5813 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
5814 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
5815 R_Mesh_TextureState(&m);
5818 R_Mesh_ResetTextureState();
5819 // generate a color array for the fog pass
5820 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
5824 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
5825 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)
5827 f = 1 - FogPoint_Model(v);
5828 c[0] = layer->color[0];
5829 c[1] = layer->color[1];
5830 c[2] = layer->color[2];
5831 c[3] = f * layer->color[3];
5834 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5837 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
5839 GL_LockArrays(0, 0);
5842 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5844 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5845 GL_AlphaTest(false);
5849 static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly)
5851 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW)
5853 rsurface.rtlight = NULL;
5857 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
5859 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
5861 if (rsurface.mode != RSURFMODE_MULTIPASS)
5862 rsurface.mode = RSURFMODE_MULTIPASS;
5863 if (r_depthfirst.integer == 3)
5865 int i = (int)(texturesurfacelist[0] - rsurface.modelsurfaces);
5866 if (!r_view.showdebug)
5867 GL_Color(0, 0, 0, 1);
5869 GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1);
5873 GL_ColorMask(0,0,0,0);
5876 RSurf_SetupDepthAndCulling();
5878 GL_BlendFunc(GL_ONE, GL_ZERO);
5880 GL_AlphaTest(false);
5881 R_Mesh_ColorPointer(NULL, 0, 0);
5882 R_Mesh_ResetTextureState();
5883 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5884 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5885 GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
5887 else if (r_depthfirst.integer == 3)
5889 else if (!r_view.showdebug && (r_showsurfaces.integer || gl_lightmaps.integer))
5891 GL_Color(0, 0, 0, 1);
5892 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
5894 else if (r_showsurfaces.integer)
5896 if (rsurface.mode != RSURFMODE_MULTIPASS)
5897 rsurface.mode = RSURFMODE_MULTIPASS;
5898 RSurf_SetupDepthAndCulling();
5900 GL_BlendFunc(GL_ONE, GL_ZERO);
5901 GL_DepthMask(writedepth);
5903 GL_AlphaTest(false);
5904 R_Mesh_ColorPointer(NULL, 0, 0);
5905 R_Mesh_ResetTextureState();
5906 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
5907 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
5909 else if (gl_lightmaps.integer)
5912 if (rsurface.mode != RSURFMODE_MULTIPASS)
5913 rsurface.mode = RSURFMODE_MULTIPASS;
5914 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
5916 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_view.cullface_back);
5917 GL_BlendFunc(GL_ONE, GL_ZERO);
5918 GL_DepthMask(writedepth);
5920 GL_AlphaTest(false);
5921 R_Mesh_ColorPointer(NULL, 0, 0);
5922 memset(&m, 0, sizeof(m));
5923 m.tex[0] = R_GetTexture(r_texture_white);
5924 m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f;
5925 m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject;
5926 m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset;
5927 R_Mesh_TextureState(&m);
5928 RSurf_PrepareVerticesForBatch(rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT, false, texturenumsurfaces, texturesurfacelist);
5929 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
5930 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5931 else if (rsurface.uselightmaptexture)
5932 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5934 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
5936 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
5937 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
5938 else if (rsurface.texture->currentnumlayers)
5940 // write depth for anything we skipped on the depth-only pass earlier
5941 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
5943 RSurf_SetupDepthAndCulling();
5944 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
5945 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
5946 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
5947 if (r_glsl.integer && gl_support_fragment_shader)
5948 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
5949 else if (gl_combine.integer && r_textureunits.integer >= 2)
5950 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist);
5952 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist);
5955 GL_LockArrays(0, 0);
5958 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5961 int texturenumsurfaces, endsurface;
5963 msurface_t *surface;
5964 msurface_t *texturesurfacelist[1024];
5966 // if the model is static it doesn't matter what value we give for
5967 // wantnormals and wanttangents, so this logic uses only rules applicable
5968 // to a model, knowing that they are meaningless otherwise
5969 if (ent == r_refdef.worldentity)
5970 RSurf_ActiveWorldEntity();
5971 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
5972 RSurf_ActiveModelEntity(ent, false, false);
5974 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
5976 for (i = 0;i < numsurfaces;i = j)
5979 surface = rsurface.modelsurfaces + surfacelist[i];
5980 texture = surface->texture;
5981 R_UpdateTextureInfo(ent, texture);
5982 rsurface.texture = texture->currentframe;
5983 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
5984 // scan ahead until we find a different texture
5985 endsurface = min(i + 1024, numsurfaces);
5986 texturenumsurfaces = 0;
5987 texturesurfacelist[texturenumsurfaces++] = surface;
5988 for (;j < endsurface;j++)
5990 surface = rsurface.modelsurfaces + surfacelist[j];
5991 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
5993 texturesurfacelist[texturenumsurfaces++] = surface;
5995 // render the range of surfaces
5996 R_DrawTextureSurfaceList(texturenumsurfaces, texturesurfacelist, true, false);
6002 void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes)
6005 vec3_t tempcenter, center;
6007 // if we're rendering water textures (extra scene renders), use a separate loop to avoid burdening the main one
6010 for (i = 0;i < numsurfaces;i++)
6011 if (surfacelist[i]->texture->currentframe->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))
6012 R_Water_AddWaterPlane(surfacelist[i]);
6015 // break the surface list down into batches by texture and use of lightmapping
6016 for (i = 0;i < numsurfaces;i = j)
6019 // texture is the base texture pointer, rsurface.texture is the
6020 // current frame/skin the texture is directing us to use (for example
6021 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
6022 // use skin 1 instead)
6023 texture = surfacelist[i]->texture;
6024 rsurface.texture = texture->currentframe;
6025 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
6026 if (!(rsurface.texture->currentmaterialflags & flagsmask))
6028 // if this texture is not the kind we want, skip ahead to the next one
6029 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
6033 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
6035 // transparent surfaces get pushed off into the transparent queue
6036 const msurface_t *surface = surfacelist[i];
6039 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
6040 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
6041 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
6042 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
6043 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.modelsurfaces, rsurface.rtlight);
6047 // simply scan ahead until we find a different texture or lightmap state
6048 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
6050 // render the range of surfaces
6051 R_DrawTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly);
6056 float locboxvertex3f[6*4*3] =
6058 1,0,1, 1,0,0, 1,1,0, 1,1,1,
6059 0,1,1, 0,1,0, 0,0,0, 0,0,1,
6060 1,1,1, 1,1,0, 0,1,0, 0,1,1,
6061 0,0,1, 0,0,0, 1,0,0, 1,0,1,
6062 0,0,1, 1,0,1, 1,1,1, 0,1,1,
6063 1,0,0, 0,0,0, 0,1,0, 1,1,0
6066 int locboxelement3i[6*2*3] =
6076 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6079 cl_locnode_t *loc = (cl_locnode_t *)ent;
6081 float vertex3f[6*4*3];
6083 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6084 GL_DepthMask(false);
6085 GL_DepthRange(0, 1);
6086 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6088 GL_CullFace(GL_NONE);
6089 R_Mesh_Matrix(&identitymatrix);
6091 R_Mesh_VertexPointer(vertex3f, 0, 0);
6092 R_Mesh_ColorPointer(NULL, 0, 0);
6093 R_Mesh_ResetTextureState();
6096 GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_view.colorscale,
6097 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_view.colorscale,
6098 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_view.colorscale,
6099 surfacelist[0] < 0 ? 0.5f : 0.125f);
6101 if (VectorCompare(loc->mins, loc->maxs))
6103 VectorSet(size, 2, 2, 2);
6104 VectorMA(loc->mins, -0.5f, size, mins);
6108 VectorCopy(loc->mins, mins);
6109 VectorSubtract(loc->maxs, loc->mins, size);
6112 for (i = 0;i < 6*4*3;)
6113 for (j = 0;j < 3;j++, i++)
6114 vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
6116 R_Mesh_Draw(0, 6*4, 6*2, locboxelement3i, 0, 0);
6119 void R_DrawLocs(void)
6122 cl_locnode_t *loc, *nearestloc;
6124 nearestloc = CL_Locs_FindNearest(cl.movement_origin);
6125 for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
6127 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
6128 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
6132 void R_DrawDebugModel(entity_render_t *ent)
6134 int i, j, k, l, flagsmask;
6135 const int *elements;
6137 msurface_t *surface;
6138 model_t *model = ent->model;
6141 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WATER | MATERIALFLAG_WALL;
6143 R_Mesh_ColorPointer(NULL, 0, 0);
6144 R_Mesh_ResetTextureState();
6145 GL_DepthRange(0, 1);
6146 GL_DepthTest(!r_showdisabledepthtest.integer);
6147 GL_DepthMask(false);
6148 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6150 if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
6152 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
6153 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
6155 if (brush->colbrushf && brush->colbrushf->numtriangles)
6157 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
6158 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);
6159 R_Mesh_Draw(0, brush->colbrushf->numpoints, brush->colbrushf->numtriangles, brush->colbrushf->elements, 0, 0);
6162 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
6164 if (surface->num_collisiontriangles)
6166 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
6167 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);
6168 R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i, 0, 0);
6173 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6175 if (r_showtris.integer || r_shownormals.integer)
6177 if (r_showdisabledepthtest.integer)
6179 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6180 GL_DepthMask(false);
6184 GL_BlendFunc(GL_ONE, GL_ZERO);
6187 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
6189 if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j])
6191 rsurface.texture = surface->texture->currentframe;
6192 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
6194 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
6195 if (r_showtris.value > 0)
6197 if (!rsurface.texture->currentlayers->depthmask)
6198 GL_Color(r_view.colorscale, 0, 0, r_showtris.value);
6199 else if (ent == r_refdef.worldentity)
6200 GL_Color(r_view.colorscale, r_view.colorscale, r_view.colorscale, r_showtris.value);
6202 GL_Color(0, r_view.colorscale, 0, r_showtris.value);
6203 elements = (ent->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
6206 for (k = 0;k < surface->num_triangles;k++, elements += 3)
6208 #define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2])
6209 GLVERTEXELEMENT(0);GLVERTEXELEMENT(1);
6210 GLVERTEXELEMENT(1);GLVERTEXELEMENT(2);
6211 GLVERTEXELEMENT(2);GLVERTEXELEMENT(0);
6216 if (r_shownormals.value > 0)
6219 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6221 VectorCopy(rsurface.vertex3f + l * 3, v);
6222 GL_Color(r_view.colorscale, 0, 0, 1);
6223 qglVertex3f(v[0], v[1], v[2]);
6224 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
6225 GL_Color(r_view.colorscale, 1, 1, 1);
6226 qglVertex3f(v[0], v[1], v[2]);
6231 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6233 VectorCopy(rsurface.vertex3f + l * 3, v);
6234 GL_Color(0, r_view.colorscale, 0, 1);
6235 qglVertex3f(v[0], v[1], v[2]);
6236 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
6237 GL_Color(r_view.colorscale, 1, 1, 1);
6238 qglVertex3f(v[0], v[1], v[2]);
6243 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
6245 VectorCopy(rsurface.vertex3f + l * 3, v);
6246 GL_Color(0, 0, r_view.colorscale, 1);
6247 qglVertex3f(v[0], v[1], v[2]);
6248 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
6249 GL_Color(r_view.colorscale, 1, 1, 1);
6250 qglVertex3f(v[0], v[1], v[2]);
6257 rsurface.texture = NULL;
6261 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
6262 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6264 int i, j, endj, f, flagsmask;
6265 msurface_t *surface;
6267 model_t *model = r_refdef.worldmodel;
6268 const int maxsurfacelist = 1024;
6269 int numsurfacelist = 0;
6270 msurface_t *surfacelist[1024];
6274 RSurf_ActiveWorldEntity();
6276 // update light styles on this submodel
6277 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6279 model_brush_lightstyleinfo_t *style;
6280 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6282 if (style->value != r_refdef.lightstylevalue[style->style])
6284 msurface_t *surfaces = model->data_surfaces;
6285 int *list = style->surfacelist;
6286 style->value = r_refdef.lightstylevalue[style->style];
6287 for (j = 0;j < style->numsurfaces;j++)
6288 surfaces[list[j]].cached_dlight = true;
6293 R_UpdateAllTextureInfo(r_refdef.worldentity);
6294 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6298 R_DrawDebugModel(r_refdef.worldentity);
6304 rsurface.uselightmaptexture = false;
6305 rsurface.texture = NULL;
6307 j = model->firstmodelsurface;
6308 endj = j + model->nummodelsurfaces;
6311 // quickly skip over non-visible surfaces
6312 for (;j < endj && !r_viewcache.world_surfacevisible[j];j++)
6314 // quickly iterate over visible surfaces
6315 for (;j < endj && r_viewcache.world_surfacevisible[j];j++)
6317 // process this surface
6318 surface = model->data_surfaces + j;
6319 // if this surface fits the criteria, add it to the list
6320 if (surface->num_triangles)
6322 // if lightmap parameters changed, rebuild lightmap texture
6323 if (surface->cached_dlight)
6324 R_BuildLightMap(r_refdef.worldentity, surface);
6325 // add face to draw list
6326 surfacelist[numsurfacelist++] = surface;
6327 r_refdef.stats.world_triangles += surface->num_triangles;
6328 if (numsurfacelist >= maxsurfacelist)
6330 r_refdef.stats.world_surfaces += numsurfacelist;
6331 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6337 r_refdef.stats.world_surfaces += numsurfacelist;
6339 R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6343 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean addwaterplanes, qboolean debug)
6345 int i, j, f, flagsmask;
6346 msurface_t *surface, *endsurface;
6348 model_t *model = ent->model;
6349 const int maxsurfacelist = 1024;
6350 int numsurfacelist = 0;
6351 msurface_t *surfacelist[1024];
6355 // if the model is static it doesn't matter what value we give for
6356 // wantnormals and wanttangents, so this logic uses only rules applicable
6357 // to a model, knowing that they are meaningless otherwise
6358 if (ent == r_refdef.worldentity)
6359 RSurf_ActiveWorldEntity();
6360 else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
6361 RSurf_ActiveModelEntity(ent, false, false);
6363 RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader && !depthonly);
6365 // update light styles
6366 if (!skysurfaces && !depthonly && !addwaterplanes && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
6368 model_brush_lightstyleinfo_t *style;
6369 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
6371 if (style->value != r_refdef.lightstylevalue[style->style])
6373 msurface_t *surfaces = model->data_surfaces;
6374 int *list = style->surfacelist;
6375 style->value = r_refdef.lightstylevalue[style->style];
6376 for (j = 0;j < style->numsurfaces;j++)
6377 surfaces[list[j]].cached_dlight = true;
6382 R_UpdateAllTextureInfo(ent);
6383 flagsmask = addwaterplanes ? (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) : (skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL));
6387 R_DrawDebugModel(ent);
6393 rsurface.uselightmaptexture = false;
6394 rsurface.texture = NULL;
6396 surface = model->data_surfaces + model->firstmodelsurface;
6397 endsurface = surface + model->nummodelsurfaces;
6398 for (;surface < endsurface;surface++)
6400 // if this surface fits the criteria, add it to the list
6401 if (surface->num_triangles)
6403 // if lightmap parameters changed, rebuild lightmap texture
6404 if (surface->cached_dlight)
6405 R_BuildLightMap(ent, surface);
6406 // add face to draw list
6407 surfacelist[numsurfacelist++] = surface;
6408 r_refdef.stats.entities_triangles += surface->num_triangles;
6409 if (numsurfacelist >= maxsurfacelist)
6411 r_refdef.stats.entities_surfaces += numsurfacelist;
6412 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);
6417 r_refdef.stats.entities_surfaces += numsurfacelist;
6419 R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly, addwaterplanes);