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"
29 mempool_t *r_main_mempool;
30 rtexturepool_t *r_main_texturepool;
32 static int r_frame = 0; ///< used only by R_GetCurrentTexture
34 qboolean r_loadnormalmap;
43 cvar_t r_motionblur = {CVAR_SAVE, "r_motionblur", "0", "motionblur value scale - 0.5 recommended"};
44 cvar_t r_damageblur = {CVAR_SAVE, "r_damageblur", "0", "motionblur based on damage"};
45 cvar_t r_motionblur_vmin = {CVAR_SAVE, "r_motionblur_vmin", "300", "minimum influence from velocity"};
46 cvar_t r_motionblur_vmax = {CVAR_SAVE, "r_motionblur_vmax", "600", "maximum influence from velocity"};
47 cvar_t r_motionblur_bmin = {CVAR_SAVE, "r_motionblur_bmin", "0.5", "velocity at which there is no blur yet (may be negative to always have some blur)"};
48 cvar_t r_motionblur_vcoeff = {CVAR_SAVE, "r_motionblur_vcoeff", "0.05", "sliding average reaction time for velocity"};
49 cvar_t r_motionblur_maxblur = {CVAR_SAVE, "r_motionblur_maxblur", "0.88", "cap for motionblur alpha value"};
50 cvar_t r_motionblur_randomize = {CVAR_SAVE, "r_motionblur_randomize", "0.1", "randomizing coefficient to workaround ghosting"};
52 // TODO do we want a r_equalize_entities cvar that works on all ents, or would that be a cheat?
53 cvar_t r_equalize_entities_fullbright = {CVAR_SAVE, "r_equalize_entities_fullbright", "0", "render fullbright entities by equalizing their lightness, not by not rendering light"};
54 cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambient", "0.5", "light equalizing: ensure at least this ambient/diffuse ratio"};
55 cvar_t r_equalize_entities_by = {CVAR_SAVE, "r_equalize_entities_by", "0.7", "light equalizing: exponent of dynamics compression (0 = no compression, 1 = full compression)"};
56 cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"};
58 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "0", "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"};
59 cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"};
60 cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"};
61 cvar_t r_farclip_world = {0, "r_farclip_world", "2", "adds map size to farclip multiplied by this value"};
62 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
63 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%, 10 = 100%)"};
64 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)"};
65 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
66 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
67 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"};
68 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"};
69 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
70 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"};
71 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"};
72 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"};
73 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
74 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
75 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
76 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
77 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling (in addition to center sample)"};
78 cvar_t r_cullentities_trace_tempentitysamples = {0, "r_cullentities_trace_tempentitysamples", "-1", "number of samples to test for entity culling of temp entities (including all CSQC entities), -1 disables trace culling on these entities to prevent flicker (pvs still applies)"};
79 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
80 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
81 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
82 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
83 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
84 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
85 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
86 cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this); when set to 2, always cast the shadows in the direction set by r_shadows_throwdirection, otherwise use the model lighting."};
87 cvar_t r_shadows_darken = {CVAR_SAVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};
88 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
89 cvar_t r_shadows_throwdirection = {CVAR_SAVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};
90 cvar_t r_shadows_drawafterrtlighting = {CVAR_SAVE, "r_shadows_drawafterrtlighting", "0", "draw fake shadows AFTER realtime lightning is drawn. May be useful for simulating fast sunlight on large outdoor maps with only one noshadow rtlight. The price is less realistic appearance of dynamic light shadows."};
91 cvar_t r_shadows_castfrombmodels = {CVAR_SAVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};
92 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
93 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"};
94 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "14", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
95 cvar_t r_polygonoffset_decals_factor = {0, "r_polygonoffset_decals_factor", "0", "biases depth values of decals to prevent z-fighting artifacts"};
96 cvar_t r_polygonoffset_decals_offset = {0, "r_polygonoffset_decals_offset", "-14", "biases depth values of decals to prevent z-fighting artifacts"};
97 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
98 cvar_t r_drawfog = {CVAR_SAVE, "r_drawfog", "1", "allows one to disable fog rendering"};
99 cvar_t r_transparentdepthmasking = {CVAR_SAVE, "r_transparentdepthmasking", "0", "enables depth writes on transparent meshes whose materially is normally opaque, this prevents seeing the inside of a transparent mesh"};
101 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
102 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
103 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
104 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
105 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
106 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
107 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
108 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
110 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"};
111 static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"};
112 static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"};
114 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)"};
115 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
116 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
117 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
118 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
119 cvar_t r_glsl_postprocess_uservec1 = {CVAR_SAVE, "r_glsl_postprocess_uservec1", "0 0 0 0", "a 4-component vector to pass as uservec1 to the postprocessing shader (only useful if default.glsl has been customized)"};
120 cvar_t r_glsl_postprocess_uservec2 = {CVAR_SAVE, "r_glsl_postprocess_uservec2", "0 0 0 0", "a 4-component vector to pass as uservec2 to the postprocessing shader (only useful if default.glsl has been customized)"};
121 cvar_t r_glsl_postprocess_uservec3 = {CVAR_SAVE, "r_glsl_postprocess_uservec3", "0 0 0 0", "a 4-component vector to pass as uservec3 to the postprocessing shader (only useful if default.glsl has been customized)"};
122 cvar_t r_glsl_postprocess_uservec4 = {CVAR_SAVE, "r_glsl_postprocess_uservec4", "0 0 0 0", "a 4-component vector to pass as uservec4 to the postprocessing shader (only useful if default.glsl has been customized)"};
124 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)"};
125 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
126 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"};
127 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
128 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
130 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites"};
131 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
132 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
133 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
135 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
136 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
137 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
138 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
139 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
140 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exagerated the glow is"};
141 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
143 cvar_t r_hdr = {CVAR_SAVE, "r_hdr", "0", "enables High Dynamic Range bloom effect (higher quality version of r_bloom)"};
144 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
145 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
146 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)"};
148 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"};
150 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"};
152 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
154 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
155 cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"};
156 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"};
157 cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"};
158 cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"};
159 cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"};
160 cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"};
162 cvar_t r_framedatasize = {CVAR_SAVE, "r_framedatasize", "1", "size of renderer data cache used during one frame (for skeletal animation caching, light processing, etc)"};
164 extern cvar_t v_glslgamma;
166 extern qboolean v_flipped_state;
168 static struct r_bloomstate_s
173 int bloomwidth, bloomheight;
175 int screentexturewidth, screentextureheight;
176 rtexture_t *texture_screen; /// \note also used for motion blur if enabled!
178 int bloomtexturewidth, bloomtextureheight;
179 rtexture_t *texture_bloom;
181 // arrays for rendering the screen passes
182 float screentexcoord2f[8];
183 float bloomtexcoord2f[8];
184 float offsettexcoord2f[8];
186 r_viewport_t viewport;
190 r_waterstate_t r_waterstate;
192 /// shadow volume bsp struct with automatically growing nodes buffer
195 rtexture_t *r_texture_blanknormalmap;
196 rtexture_t *r_texture_white;
197 rtexture_t *r_texture_grey128;
198 rtexture_t *r_texture_black;
199 rtexture_t *r_texture_notexture;
200 rtexture_t *r_texture_whitecube;
201 rtexture_t *r_texture_normalizationcube;
202 rtexture_t *r_texture_fogattenuation;
203 rtexture_t *r_texture_gammaramps;
204 unsigned int r_texture_gammaramps_serial;
205 //rtexture_t *r_texture_fogintensity;
207 unsigned int r_queries[MAX_OCCLUSION_QUERIES];
208 unsigned int r_numqueries;
209 unsigned int r_maxqueries;
211 typedef struct r_qwskincache_s
213 char name[MAX_QPATH];
214 skinframe_t *skinframe;
218 static r_qwskincache_t *r_qwskincache;
219 static int r_qwskincache_size;
221 /// vertex coordinates for a quad that covers the screen exactly
222 const float r_screenvertex3f[12] =
230 extern void R_DrawModelShadows(void);
232 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
235 for (i = 0;i < verts;i++)
246 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
249 for (i = 0;i < verts;i++)
259 // FIXME: move this to client?
262 if (gamemode == GAME_NEHAHRA)
264 Cvar_Set("gl_fogenable", "0");
265 Cvar_Set("gl_fogdensity", "0.2");
266 Cvar_Set("gl_fogred", "0.3");
267 Cvar_Set("gl_foggreen", "0.3");
268 Cvar_Set("gl_fogblue", "0.3");
270 r_refdef.fog_density = 0;
271 r_refdef.fog_red = 0;
272 r_refdef.fog_green = 0;
273 r_refdef.fog_blue = 0;
274 r_refdef.fog_alpha = 1;
275 r_refdef.fog_start = 0;
276 r_refdef.fog_end = 16384;
277 r_refdef.fog_height = 1<<30;
278 r_refdef.fog_fadedepth = 128;
281 static void R_BuildBlankTextures(void)
283 unsigned char data[4];
284 data[2] = 128; // normal X
285 data[1] = 128; // normal Y
286 data[0] = 255; // normal Z
287 data[3] = 128; // height
288 r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
293 r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
298 r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
303 r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, NULL);
306 static void R_BuildNoTexture(void)
309 unsigned char pix[16][16][4];
310 // this makes a light grey/dark grey checkerboard texture
311 for (y = 0;y < 16;y++)
313 for (x = 0;x < 16;x++)
315 if ((y < 8) ^ (x < 8))
331 r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, NULL);
334 static void R_BuildWhiteCube(void)
336 unsigned char data[6*1*1*4];
337 memset(data, 255, sizeof(data));
338 r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, NULL);
341 static void R_BuildNormalizationCube(void)
345 vec_t s, t, intensity;
348 data = Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4);
349 for (side = 0;side < 6;side++)
351 for (y = 0;y < NORMSIZE;y++)
353 for (x = 0;x < NORMSIZE;x++)
355 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
356 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
391 intensity = 127.0f / sqrt(DotProduct(v, v));
392 data[((side*64+y)*64+x)*4+2] = (unsigned char)(128.0f + intensity * v[0]);
393 data[((side*64+y)*64+x)*4+1] = (unsigned char)(128.0f + intensity * v[1]);
394 data[((side*64+y)*64+x)*4+0] = (unsigned char)(128.0f + intensity * v[2]);
395 data[((side*64+y)*64+x)*4+3] = 255;
399 r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, NULL);
403 static void R_BuildFogTexture(void)
407 unsigned char data1[FOGWIDTH][4];
408 //unsigned char data2[FOGWIDTH][4];
411 r_refdef.fogmasktable_start = r_refdef.fog_start;
412 r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
413 r_refdef.fogmasktable_range = r_refdef.fogrange;
414 r_refdef.fogmasktable_density = r_refdef.fog_density;
416 r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
417 for (x = 0;x < FOGMASKTABLEWIDTH;x++)
419 d = (x * r - r_refdef.fogmasktable_start);
420 if(developer.integer >= 100)
421 Con_Printf("%f ", d);
423 if (r_fog_exp2.integer)
424 alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
426 alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
427 if(developer.integer >= 100)
428 Con_Printf(" : %f ", alpha);
429 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
430 if(developer.integer >= 100)
431 Con_Printf(" = %f\n", alpha);
432 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
435 for (x = 0;x < FOGWIDTH;x++)
437 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
442 //data2[x][0] = 255 - b;
443 //data2[x][1] = 255 - b;
444 //data2[x][2] = 255 - b;
447 if (r_texture_fogattenuation)
449 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, FOGWIDTH, 1);
450 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, FOGWIDTH, 1);
454 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, NULL);
455 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALLOWUPDATES, NULL);
459 static const char *builtinshaderstring =
460 "// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
461 "// written by Forest 'LordHavoc' Hale\n"
463 "// enable various extensions depending on permutation:\n"
465 "#ifdef VERTEX_SHADER\n"
466 "uniform mat4 ModelViewProjectionMatrix;\n"
469 "#ifdef MODE_DEPTH_OR_SHADOW\n"
470 "#ifdef VERTEX_SHADER\n"
473 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
476 "#else // !MODE_DEPTH_ORSHADOW\n"
477 "#ifdef MODE_SHOWDEPTH\n"
478 "#ifdef VERTEX_SHADER\n"
481 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
482 " gl_FrontColor = vec4(gl_Position.z, gl_Position.z, gl_Position.z, 1.0);\n"
486 "#ifdef FRAGMENT_SHADER\n"
489 " gl_FragColor = gl_Color;\n"
492 "#else // !MODE_SHOWDEPTH\n"
493 "#ifdef MODE_POSTPROCESS\n"
494 "varying vec2 TexCoord1;\n"
495 "varying vec2 TexCoord2;\n"
497 "#ifdef VERTEX_SHADER\n"
500 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
501 " TexCoord1 = gl_MultiTexCoord0.xy;\n"
503 " TexCoord2 = gl_MultiTexCoord1.xy;\n"
508 "#ifdef FRAGMENT_SHADER\n"
509 "uniform sampler2D Texture_First;\n"
511 "uniform sampler2D Texture_Second;\n"
513 "#ifdef USEGAMMARAMPS\n"
514 "uniform sampler2D Texture_GammaRamps;\n"
516 "#ifdef USESATURATION\n"
517 "uniform float Saturation;\n"
519 "#ifdef USEVIEWTINT\n"
520 "uniform vec4 ViewTintColor;\n"
522 "//uncomment these if you want to use them:\n"
523 "uniform vec4 UserVec1;\n"
524 "// uniform vec4 UserVec2;\n"
525 "// uniform vec4 UserVec3;\n"
526 "// uniform vec4 UserVec4;\n"
527 "// uniform float ClientTime;\n"
528 "uniform vec2 PixelSize;\n"
531 " gl_FragColor = texture2D(Texture_First, TexCoord1);\n"
533 " gl_FragColor += texture2D(Texture_Second, TexCoord2);\n"
535 "#ifdef USEVIEWTINT\n"
536 " gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n"
539 "#ifdef USEPOSTPROCESSING\n"
540 "// do r_glsl_dumpshader, edit glsl/default.glsl, and replace this by your own postprocessing if you want\n"
541 "// this code does a blur with the radius specified in the first component of r_glsl_postprocess_uservec1 and blends it using the second component\n"
542 " gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.987688, -0.156434)) * UserVec1.y;\n"
543 " gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.156434, -0.891007)) * UserVec1.y;\n"
544 " gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.891007, -0.453990)) * UserVec1.y;\n"
545 " gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2( 0.707107, 0.707107)) * UserVec1.y;\n"
546 " gl_FragColor += texture2D(Texture_First, TexCoord1 + PixelSize*UserVec1.x*vec2(-0.453990, 0.891007)) * UserVec1.y;\n"
547 " gl_FragColor /= (1 + 5 * UserVec1.y);\n"
550 "#ifdef USESATURATION\n"
551 " //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n"
552 " float y = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
553 " //gl_FragColor = vec3(y) + (gl_FragColor.rgb - vec3(y)) * Saturation;\n"
554 " gl_FragColor.rgb = mix(vec3(y), gl_FragColor.rgb, Saturation);\n"
557 "#ifdef USEGAMMARAMPS\n"
558 " gl_FragColor.r = texture2D(Texture_GammaRamps, vec2(gl_FragColor.r, 0)).r;\n"
559 " gl_FragColor.g = texture2D(Texture_GammaRamps, vec2(gl_FragColor.g, 0)).g;\n"
560 " gl_FragColor.b = texture2D(Texture_GammaRamps, vec2(gl_FragColor.b, 0)).b;\n"
564 "#else // !MODE_POSTPROCESS\n"
565 "#ifdef MODE_GENERIC\n"
566 "#ifdef USEDIFFUSE\n"
567 "varying vec2 TexCoord1;\n"
569 "#ifdef USESPECULAR\n"
570 "varying vec2 TexCoord2;\n"
572 "#ifdef VERTEX_SHADER\n"
575 " gl_FrontColor = gl_Color;\n"
576 "#ifdef USEDIFFUSE\n"
577 " TexCoord1 = gl_MultiTexCoord0.xy;\n"
579 "#ifdef USESPECULAR\n"
580 " TexCoord2 = gl_MultiTexCoord1.xy;\n"
582 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
586 "#ifdef FRAGMENT_SHADER\n"
587 "#ifdef USEDIFFUSE\n"
588 "uniform sampler2D Texture_First;\n"
590 "#ifdef USESPECULAR\n"
591 "uniform sampler2D Texture_Second;\n"
596 " gl_FragColor = gl_Color;\n"
597 "#ifdef USEDIFFUSE\n"
598 " gl_FragColor *= texture2D(Texture_First, TexCoord1);\n"
601 "#ifdef USESPECULAR\n"
602 " vec4 tex2 = texture2D(Texture_Second, TexCoord2);\n"
603 "# ifdef USECOLORMAPPING\n"
604 " gl_FragColor *= tex2;\n"
607 " gl_FragColor += tex2;\n"
609 "# ifdef USEVERTEXTEXTUREBLEND\n"
610 " gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n"
615 "#else // !MODE_GENERIC\n"
616 "#ifdef MODE_BLOOMBLUR\n"
617 "varying TexCoord;\n"
618 "#ifdef VERTEX_SHADER\n"
621 " gl_FrontColor = gl_Color;\n"
622 " TexCoord = gl_MultiTexCoord0.xy;\n"
623 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
627 "#ifdef FRAGMENT_SHADER\n"
628 "uniform sampler2D Texture_First;\n"
629 "uniform vec4 BloomBlur_Parameters;\n"
634 " vec2 tc = TexCoord;\n"
635 " vec3 color = texture2D(Texture_First, tc).rgb;\n"
636 " tc += BloomBlur_Parameters.xy;\n"
637 " for (i = 1;i < SAMPLES;i++)\n"
639 " color += texture2D(Texture_First, tc).rgb;\n"
640 " tc += BloomBlur_Parameters.xy;\n"
642 " gl_FragColor = vec4(color * BloomBlur_Parameters.z + vec3(BloomBlur_Parameters.w), 1);\n"
645 "#else // !MODE_BLOOMBLUR\n"
646 "#ifdef MODE_REFRACTION\n"
647 "varying vec2 TexCoord;\n"
648 "varying vec4 ModelViewProjectionPosition;\n"
649 "uniform mat4 TexMatrix;\n"
650 "#ifdef VERTEX_SHADER\n"
654 " TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
655 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
656 " ModelViewProjectionPosition = gl_Position;\n"
660 "#ifdef FRAGMENT_SHADER\n"
661 "uniform sampler2D Texture_Normal;\n"
662 "uniform sampler2D Texture_Refraction;\n"
663 "uniform sampler2D Texture_Reflection;\n"
665 "uniform vec4 DistortScaleRefractReflect;\n"
666 "uniform vec4 ScreenScaleRefractReflect;\n"
667 "uniform vec4 ScreenCenterRefractReflect;\n"
668 "uniform vec4 RefractColor;\n"
669 "uniform vec4 ReflectColor;\n"
670 "uniform float ReflectFactor;\n"
671 "uniform float ReflectOffset;\n"
675 " vec2 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect.xy * (1.0 / ModelViewProjectionPosition.w);\n"
676 " //vec2 ScreenTexCoord = (ModelViewProjectionPosition.xy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xy * DistortScaleRefractReflect.xy * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
677 " vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect.xy;\n"
678 " vec2 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xy * DistortScaleRefractReflect.xy;\n"
679 " // FIXME temporary hack to detect the case that the reflection\n"
680 " // gets blackened at edges due to leaving the area that contains actual\n"
682 " // Remove this 'ack once we have a better way to stop this thing from\n"
684 " float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
685 " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
686 " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
687 " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
688 " ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
689 " gl_FragColor = texture2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n"
692 "#else // !MODE_REFRACTION\n"
693 "#ifdef MODE_WATER\n"
694 "varying vec2 TexCoord;\n"
695 "varying vec3 EyeVector;\n"
696 "varying vec4 ModelViewProjectionPosition;\n"
697 "#ifdef VERTEX_SHADER\n"
698 "uniform vec3 EyePosition;\n"
699 "uniform mat4 TexMatrix;\n"
703 " TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
704 " vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
705 " EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
706 " EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
707 " EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
708 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
709 " ModelViewProjectionPosition = gl_Position;\n"
713 "#ifdef FRAGMENT_SHADER\n"
714 "uniform sampler2D Texture_Normal;\n"
715 "uniform sampler2D Texture_Refraction;\n"
716 "uniform sampler2D Texture_Reflection;\n"
718 "uniform vec4 DistortScaleRefractReflect;\n"
719 "uniform vec4 ScreenScaleRefractReflect;\n"
720 "uniform vec4 ScreenCenterRefractReflect;\n"
721 "uniform vec4 RefractColor;\n"
722 "uniform vec4 ReflectColor;\n"
723 "uniform float ReflectFactor;\n"
724 "uniform float ReflectOffset;\n"
728 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
729 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
730 " vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
731 " vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n"
732 " // FIXME temporary hack to detect the case that the reflection\n"
733 " // gets blackened at edges due to leaving the area that contains actual\n"
735 " // Remove this 'ack once we have a better way to stop this thing from\n"
737 " float f = min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, 0.01)).rgb) / 0.05);\n"
738 " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(0.01, -0.01)).rgb) / 0.05);\n"
739 " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
740 " f *= min(1.0, length(texture2D(Texture_Refraction, ScreenTexCoord.xy + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
741 " ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n"
742 " f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, 0.01)).rgb) / 0.05);\n"
743 " f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(0.01, -0.01)).rgb) / 0.05);\n"
744 " f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
745 " f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord.zw + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
746 " ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n"
747 " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n"
748 " gl_FragColor = mix(texture2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, texture2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n"
751 "#else // !MODE_WATER\n"
753 "#if defined(USESHADOWMAPRECT) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USEDEFERREDLIGHTMAP)\n"
754 "# extension GL_ARB_texture_rectangle : enable\n"
757 "#ifdef USESHADOWMAP2D\n"
758 "# ifdef GL_EXT_gpu_shader4\n"
759 "# extension GL_EXT_gpu_shader4 : enable\n"
761 "# ifdef GL_ARB_texture_gather\n"
762 "# extension GL_ARB_texture_gather : enable\n"
764 "# ifdef GL_AMD_texture_texture4\n"
765 "# extension GL_AMD_texture_texture4 : enable\n"
770 "#ifdef USESHADOWMAPCUBE\n"
771 "# extension GL_EXT_gpu_shader4 : enable\n"
774 "#ifdef USESHADOWSAMPLER\n"
775 "# extension GL_ARB_shadow : enable\n"
778 "// common definitions between vertex shader and fragment shader:\n"
780 "//#ifdef __GLSL_CG_DATA_TYPES\n"
781 "//# define myhalf half\n"
782 "//# define myhalf2 half2\n"
783 "//# define myhalf3half3\n"
784 "//# define myhalf4 half4\n"
786 "# define myhalf float\n"
787 "# define myhalf2 vec2\n"
788 "# define myhalf3 vec3\n"
789 "# define myhalf4 vec4\n"
792 "#if defined(USEFOGINSIDE) || defined(USEFOGOUTSIDE)\n"
796 "varying vec2 TexCoord;\n"
797 "#ifdef USEVERTEXTEXTUREBLEND\n"
798 "varying vec2 TexCoord2;\n"
800 "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
801 "#define USELIGHTMAP\n"
802 "varying vec2 TexCoordLightmap;\n"
805 "#ifdef MODE_LIGHTSOURCE\n"
806 "varying vec3 CubeVector;\n"
809 "#ifdef MODE_LIGHTSOURCE\n"
810 "varying vec3 LightVector;\n"
812 "#if defined(MODE_LIGHTDIRECTION)\n"
813 "varying vec3 LightVector;\n"
816 "#if defined(USEOFFSETMAPPING) || defined(USESPECULAR)\n"
817 "//#if defined(USEOFFSETMAPPING) || defined(USESPECULAR) || defined(MODE_LIGHTDIRECTION) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
818 "#define USEEYEVECTOR\n"
819 "varying vec3 EyeVector;\n"
822 "varying vec3 EyeVectorModelSpace;\n"
823 "varying float FogPlaneVertexDist;\n"
826 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY)\n"
827 "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n"
828 "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n"
829 "varying vec3 VectorR; // direction of R texcoord (surface normal)\n"
832 "#ifdef USEREFLECTION\n"
833 "varying vec4 ModelViewProjectionPosition;\n"
835 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
836 "uniform vec3 LightPosition;\n"
837 "varying vec4 ModelViewPosition;\n"
840 "#ifdef MODE_LIGHTSOURCE\n"
841 "uniform vec3 LightPosition;\n"
843 "uniform vec3 EyePosition;\n"
844 "#ifdef MODE_LIGHTDIRECTION\n"
845 "uniform vec3 LightDir;\n"
847 "uniform vec4 FogPlane;\n"
853 "// vertex shader specific:\n"
854 "#ifdef VERTEX_SHADER\n"
856 "// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3), this would require sending a 4 component texcoord1 with W as 1 or -1 according to which side the texcoord2 should be on\n"
858 "#ifdef MODE_DEFERREDGEOMETRY\n"
859 "uniform mat4 TexMatrix;\n"
860 "#ifdef USEVERTEXTEXTUREBLEND\n"
861 "uniform mat4 BackgroundTexMatrix;\n"
863 "uniform mat4 ModelViewMatrix;\n"
866 " TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
867 "#ifdef USEVERTEXTEXTUREBLEND\n"
868 " gl_FrontColor = gl_Color;\n"
869 " TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
872 " // transform unnormalized eye direction into tangent space\n"
873 "#ifdef USEOFFSETMAPPING\n"
874 " vec3 EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
875 " EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
876 " EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
877 " EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
880 " VectorS = (ModelViewMatrix * vec4(gl_MultiTexCoord1.xyz, 0)).xyz;\n"
881 " VectorT = (ModelViewMatrix * vec4(gl_MultiTexCoord2.xyz, 0)).xyz;\n"
882 " VectorR = (ModelViewMatrix * vec4(gl_MultiTexCoord3.xyz, 0)).xyz;\n"
883 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
885 "#else // !MODE_DEFERREDGEOMETRY\n"
886 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
887 "uniform mat4 ModelViewMatrix;\n"
890 " ModelViewPosition = ModelViewMatrix * gl_Vertex;\n"
891 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
893 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
894 "uniform mat4 TexMatrix;\n"
895 "#ifdef USEVERTEXTEXTUREBLEND\n"
896 "uniform mat4 BackgroundTexMatrix;\n"
898 "#ifdef MODE_LIGHTSOURCE\n"
899 "uniform mat4 ModelToLight;\n"
903 "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n"
904 " gl_FrontColor = gl_Color;\n"
906 " // copy the surface texcoord\n"
907 " TexCoord = vec2(TexMatrix * gl_MultiTexCoord0);\n"
908 "#ifdef USEVERTEXTEXTUREBLEND\n"
909 " TexCoord2 = vec2(BackgroundTexMatrix * gl_MultiTexCoord0);\n"
911 "#ifdef USELIGHTMAP\n"
912 " TexCoordLightmap = vec2(gl_MultiTexCoord4);\n"
915 "#ifdef MODE_LIGHTSOURCE\n"
916 " // transform vertex position into light attenuation/cubemap space\n"
917 " // (-1 to +1 across the light box)\n"
918 " CubeVector = vec3(ModelToLight * gl_Vertex);\n"
920 "# ifdef USEDIFFUSE\n"
921 " // transform unnormalized light direction into tangent space\n"
922 " // (we use unnormalized to ensure that it interpolates correctly and then\n"
923 " // normalize it per pixel)\n"
924 " vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n"
925 " LightVector.x = dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n"
926 " LightVector.y = dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n"
927 " LightVector.z = dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n"
931 "#if defined(MODE_LIGHTDIRECTION) && defined(USEDIFFUSE)\n"
932 " LightVector.x = dot(LightDir, gl_MultiTexCoord1.xyz);\n"
933 " LightVector.y = dot(LightDir, gl_MultiTexCoord2.xyz);\n"
934 " LightVector.z = dot(LightDir, gl_MultiTexCoord3.xyz);\n"
937 " // transform unnormalized eye direction into tangent space\n"
938 "#ifdef USEEYEVECTOR\n"
940 " vec3 EyeVectorModelSpace;\n"
942 " EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
943 " EyeVector.x = dot(EyeVectorModelSpace, gl_MultiTexCoord1.xyz);\n"
944 " EyeVector.y = dot(EyeVectorModelSpace, gl_MultiTexCoord2.xyz);\n"
945 " EyeVector.z = dot(EyeVectorModelSpace, gl_MultiTexCoord3.xyz);\n"
949 "#ifndef USEEYEVECTOR\n"
950 " EyeVectorModelSpace = EyePosition - gl_Vertex.xyz;\n"
952 " FogPlaneVertexDist = dot(FogPlane, gl_Vertex);\n"
955 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
956 " VectorS = gl_MultiTexCoord1.xyz;\n"
957 " VectorT = gl_MultiTexCoord2.xyz;\n"
958 " VectorR = gl_MultiTexCoord3.xyz;\n"
961 " // transform vertex to camera space, using ftransform to match non-VS rendering\n"
962 " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n"
964 "#ifdef USEREFLECTION\n"
965 " ModelViewProjectionPosition = gl_Position;\n"
968 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
969 "#endif // !MODE_DEFERREDGEOMETRY\n"
971 "#endif // VERTEX_SHADER\n"
976 "// fragment shader specific:\n"
977 "#ifdef FRAGMENT_SHADER\n"
979 "uniform sampler2D Texture_Normal;\n"
980 "uniform sampler2D Texture_Color;\n"
981 "//#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
982 "uniform sampler2D Texture_Gloss;\n"
985 "uniform sampler2D Texture_Glow;\n"
987 "#ifdef USEVERTEXTEXTUREBLEND\n"
988 "uniform sampler2D Texture_SecondaryNormal;\n"
989 "uniform sampler2D Texture_SecondaryColor;\n"
990 "//#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
991 "uniform sampler2D Texture_SecondaryGloss;\n"
994 "uniform sampler2D Texture_SecondaryGlow;\n"
997 "#ifdef USECOLORMAPPING\n"
998 "uniform sampler2D Texture_Pants;\n"
999 "uniform sampler2D Texture_Shirt;\n"
1002 "uniform sampler2D Texture_FogMask;\n"
1004 "#ifdef USELIGHTMAP\n"
1005 "uniform sampler2D Texture_Lightmap;\n"
1007 "#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n"
1008 "uniform sampler2D Texture_Deluxemap;\n"
1010 "#ifdef USEREFLECTION\n"
1011 "uniform sampler2D Texture_Reflection;\n"
1014 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1015 "uniform sampler2DRect Texture_ScreenDepth;\n"
1016 "uniform sampler2DRect Texture_ScreenNormalMap;\n"
1018 "#ifdef USEDEFERREDLIGHTMAP\n"
1019 "uniform sampler2DRect Texture_ScreenDiffuse;\n"
1020 "uniform sampler2DRect Texture_ScreenSpecular;\n"
1023 "uniform myhalf3 Color_Pants;\n"
1024 "uniform myhalf3 Color_Shirt;\n"
1025 "uniform myhalf3 FogColor;\n"
1028 "uniform float FogRangeRecip;\n"
1029 "uniform float FogPlaneViewDist;\n"
1030 "uniform float FogHeightFade;\n"
1031 "myhalf FogVertex(void)\n"
1034 "#ifdef USEFOGOUTSIDE\n"
1035 " fogfrac = min(0.0, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0, min(0.0, FogPlaneVertexDist) * FogHeightFade);\n"
1037 " fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0, FogPlaneVertexDist)) * min(1.0, (min(0.0, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);\n"
1039 " return myhalf(texture2D(Texture_FogMask, myhalf2(length(EyeVectorModelSpace)*fogfrac*FogRangeRecip, 0.0)));\n"
1043 "#ifdef USEOFFSETMAPPING\n"
1044 "uniform float OffsetMapping_Scale;\n"
1045 "vec2 OffsetMapping(vec2 TexCoord)\n"
1047 "#ifdef USEOFFSETMAPPING_RELIEFMAPPING\n"
1048 " // 14 sample relief mapping: linear search and then binary search\n"
1049 " // this basically steps forward a small amount repeatedly until it finds\n"
1050 " // itself inside solid, then jitters forward and back using decreasing\n"
1051 " // amounts to find the impact\n"
1052 " //vec3 OffsetVector = vec3(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1), -1);\n"
1053 " //vec3 OffsetVector = vec3(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1054 " vec3 OffsetVector = vec3(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1), -1);\n"
1055 " vec3 RT = vec3(TexCoord, 1);\n"
1056 " OffsetVector *= 0.1;\n"
1057 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1058 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1059 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1060 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1061 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1062 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1063 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1064 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1065 " RT += OffsetVector * step(texture2D(Texture_Normal, RT.xy).a, RT.z);\n"
1066 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) - 0.5);\n"
1067 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.5 - 0.25);\n"
1068 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.25 - 0.125);\n"
1069 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.125 - 0.0625);\n"
1070 " RT += OffsetVector * (step(texture2D(Texture_Normal, RT.xy).a, RT.z) * 0.0625 - 0.03125);\n"
1073 " // 3 sample offset mapping (only 3 samples because of ATI Radeon 9500-9800/X300 limits)\n"
1074 " // this basically moves forward the full distance, and then backs up based\n"
1075 " // on height of samples\n"
1076 " //vec2 OffsetVector = vec2(EyeVector.xy * ((1.0 / EyeVector.z) * OffsetMapping_Scale) * vec2(-1, 1));\n"
1077 " //vec2 OffsetVector = vec2(normalize(EyeVector.xy) * OffsetMapping_Scale * vec2(-1, 1));\n"
1078 " vec2 OffsetVector = vec2(normalize(EyeVector).xy * OffsetMapping_Scale * vec2(-1, 1));\n"
1079 " TexCoord += OffsetVector;\n"
1080 " OffsetVector *= 0.333;\n"
1081 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1082 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1083 " TexCoord -= OffsetVector * texture2D(Texture_Normal, TexCoord).a;\n"
1084 " return TexCoord;\n"
1087 "#endif // USEOFFSETMAPPING\n"
1089 "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n"
1090 "uniform sampler2D Texture_Attenuation;\n"
1091 "uniform samplerCube Texture_Cube;\n"
1093 "#ifdef USESHADOWMAPRECT\n"
1094 "# ifdef USESHADOWSAMPLER\n"
1095 "uniform sampler2DRectShadow Texture_ShadowMapRect;\n"
1097 "uniform sampler2DRect Texture_ShadowMapRect;\n"
1101 "#ifdef USESHADOWMAP2D\n"
1102 "# ifdef USESHADOWSAMPLER\n"
1103 "uniform sampler2DShadow Texture_ShadowMap2D;\n"
1105 "uniform sampler2D Texture_ShadowMap2D;\n"
1109 "#ifdef USESHADOWMAPVSDCT\n"
1110 "uniform samplerCube Texture_CubeProjection;\n"
1113 "#ifdef USESHADOWMAPCUBE\n"
1114 "# ifdef USESHADOWSAMPLER\n"
1115 "uniform samplerCubeShadow Texture_ShadowMapCube;\n"
1117 "uniform samplerCube Texture_ShadowMapCube;\n"
1121 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPCUBE)\n"
1122 "uniform vec2 ShadowMap_TextureScale;\n"
1123 "uniform vec4 ShadowMap_Parameters;\n"
1126 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1127 "vec3 GetShadowMapTC2D(vec3 dir)\n"
1129 " vec3 adir = abs(dir);\n"
1130 "# ifndef USESHADOWMAPVSDCT\n"
1134 " if (adir.x > adir.y)\n"
1136 " if (adir.x > adir.z) // X\n"
1140 " offset = vec2(mix(0.5, 1.5, dir.x < 0.0), 0.5);\n"
1146 " offset = vec2(mix(0.5, 1.5, dir.z < 0.0), 2.5);\n"
1151 " if (adir.y > adir.z) // Y\n"
1155 " offset = vec2(mix(0.5, 1.5, dir.y < 0.0), 1.5);\n"
1161 " offset = vec2(mix(0.5, 1.5, dir.z < 0.0), 2.5);\n"
1165 " vec3 stc = vec3(tc * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n"
1166 " stc.xy += offset * ShadowMap_Parameters.y;\n"
1167 " stc.z += ShadowMap_Parameters.z;\n"
1170 " vec4 proj = textureCube(Texture_CubeProjection, dir);\n"
1171 " float ma = max(max(adir.x, adir.y), adir.z);\n"
1172 " vec3 stc = vec3(mix(dir.xy, dir.zz, proj.xy) * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n"
1173 " stc.xy += proj.zw * ShadowMap_Parameters.y;\n"
1174 " stc.z += ShadowMap_Parameters.z;\n"
1178 "#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n"
1180 "#ifdef USESHADOWMAPCUBE\n"
1181 "vec4 GetShadowMapTCCube(vec3 dir)\n"
1183 " vec3 adir = abs(dir);\n"
1184 " return vec4(dir, ShadowMap_Parameters.z + ShadowMap_Parameters.w / max(max(adir.x, adir.y), adir.z));\n"
1188 "# ifdef USESHADOWMAPRECT\n"
1189 "float ShadowMapCompare(vec3 dir)\n"
1191 " vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1193 "# ifdef USESHADOWSAMPLER\n"
1195 "# ifdef USESHADOWMAPPCF\n"
1196 "# define texval(x, y) shadow2DRect(Texture_ShadowMapRect, shadowmaptc + vec3(x, y, 0.0)).r\n"
1197 " f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
1199 " f = shadow2DRect(Texture_ShadowMapRect, shadowmaptc).r;\n"
1204 "# ifdef USESHADOWMAPPCF\n"
1205 "# if USESHADOWMAPPCF > 1\n"
1206 "# define texval(x, y) texture2DRect(Texture_ShadowMapRect, center + vec2(x, y)).r\n"
1207 " vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1208 " vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
1209 " vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n"
1210 " vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n"
1211 " vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n"
1212 " vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1213 " f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1215 "# define texval(x, y) texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy + vec2(x, y)).r\n"
1216 " vec2 offset = fract(shadowmaptc.xy);\n"
1217 " vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1218 " vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n"
1219 " vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n"
1220 " vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1221 " f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1224 " f = step(shadowmaptc.z, texture2DRect(Texture_ShadowMapRect, shadowmaptc.xy).r);\n"
1232 "# ifdef USESHADOWMAP2D\n"
1233 "float ShadowMapCompare(vec3 dir)\n"
1235 " vec3 shadowmaptc = GetShadowMapTC2D(dir);\n"
1238 "# ifdef USESHADOWSAMPLER\n"
1239 "# ifdef USESHADOWMAPPCF\n"
1240 "# define texval(x, y) shadow2D(Texture_ShadowMap2D, vec3(center + vec2(x, y)*ShadowMap_TextureScale, shadowmaptc.z)).r \n"
1241 " vec2 center = shadowmaptc.xy*ShadowMap_TextureScale;\n"
1242 " f = dot(vec4(0.25), vec4(texval(-0.4, 1.0), texval(-1.0, -0.4), texval(0.4, -1.0), texval(1.0, 0.4)));\n"
1244 " f = shadow2D(Texture_ShadowMap2D, vec3(shadowmaptc.xy*ShadowMap_TextureScale, shadowmaptc.z)).r;\n"
1247 "# ifdef USESHADOWMAPPCF\n"
1248 "# if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n"
1249 "# ifdef GL_ARB_texture_gather\n"
1250 "# define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec(x, y))\n"
1252 "# define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x,y)*ShadowMap_TextureScale)\n"
1254 " vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1255 " center *= ShadowMap_TextureScale;\n"
1256 " vec4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n"
1257 " vec4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n"
1258 " vec4 group3 = step(shadowmaptc.z, texval(-1.0, 1.0));\n"
1259 " vec4 group4 = step(shadowmaptc.z, texval( 1.0, 1.0));\n"
1260 " vec4 cols = vec4(group1.rg, group2.rg) + vec4(group3.ab, group4.ab) +\n"
1261 " mix(vec4(group1.ab, group2.ab), vec4(group3.rg, group4.rg), offset.y);\n"
1262 " f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1264 "# ifdef GL_EXT_gpu_shader4\n"
1265 "# define texval(x, y) texture2DOffset(Texture_ShadowMap2D, center, ivec2(x, y)).r\n"
1267 "# define texval(x, y) texture2D(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale).r \n"
1269 "# if USESHADOWMAPPCF > 1\n"
1270 " vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n"
1271 " center *= ShadowMap_TextureScale;\n"
1272 " vec4 row1 = step(shadowmaptc.z, vec4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n"
1273 " vec4 row2 = step(shadowmaptc.z, vec4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n"
1274 " vec4 row3 = step(shadowmaptc.z, vec4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n"
1275 " vec4 row4 = step(shadowmaptc.z, vec4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n"
1276 " vec4 cols = row2 + row3 + mix(row1, row4, offset.y);\n"
1277 " f = dot(mix(cols.xyz, cols.yzw, offset.x), vec3(1.0/9.0));\n"
1279 " vec2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n"
1280 " vec3 row1 = step(shadowmaptc.z, vec3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n"
1281 " vec3 row2 = step(shadowmaptc.z, vec3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n"
1282 " vec3 row3 = step(shadowmaptc.z, vec3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n"
1283 " vec3 cols = row2 + mix(row1, row3, offset.y);\n"
1284 " f = dot(mix(cols.xy, cols.yz, offset.x), vec2(0.25));\n"
1288 " f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n"
1295 "# ifdef USESHADOWMAPCUBE\n"
1296 "float ShadowMapCompare(vec3 dir)\n"
1298 " // apply depth texture cubemap as light filter\n"
1299 " vec4 shadowmaptc = GetShadowMapTCCube(dir);\n"
1301 "# ifdef USESHADOWSAMPLER\n"
1302 " f = shadowCube(Texture_ShadowMapCube, shadowmaptc).r;\n"
1304 " f = step(shadowmaptc.w, textureCube(Texture_ShadowMapCube, shadowmaptc.xyz).r);\n"
1309 "#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE)\n"
1311 "#ifdef MODE_DEFERREDGEOMETRY\n"
1314 "#ifdef USEOFFSETMAPPING\n"
1315 " // apply offsetmapping\n"
1316 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1317 "#define TexCoord TexCoordOffset\n"
1320 "#ifdef USEALPHAKILL\n"
1321 " if (texture2D(Texture_Color, TexCoord).a < 0.5)\n"
1325 "#ifdef USEVERTEXTEXTUREBLEND\n"
1326 " float alpha = texture2D(Texture_Color, TexCoord).a;\n"
1327 " float terrainblend = clamp(float(gl_Color.a) * alpha * 2.0 - 0.5, float(0.0), float(1.0));\n"
1328 " //float terrainblend = min(float(gl_Color.a) * alpha * 2.0, float(1.0));\n"
1329 " //float terrainblend = float(gl_Color.a) * alpha > 0.5;\n"
1332 "#ifdef USEVERTEXTEXTUREBLEND\n"
1333 " vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n"
1335 " vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n"
1338 " gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), 1);\n"
1340 "#else // !MODE_DEFERREDGEOMETRY\n"
1341 "#ifdef MODE_DEFERREDLIGHTSOURCE\n"
1342 "uniform mat4 ViewToLight;\n"
1343 "// ScreenToDepth = vec2(Far / (Far - Near), Far * Near / (Near - Far));\n"
1344 "uniform vec2 ScreenToDepth;\n"
1345 "uniform myhalf3 DeferredColor_Ambient;\n"
1346 "uniform myhalf3 DeferredColor_Diffuse;\n"
1347 "#ifdef USESPECULAR\n"
1348 "uniform myhalf3 DeferredColor_Specular;\n"
1349 "uniform myhalf SpecularPower;\n"
1353 " // calculate viewspace pixel position\n"
1355 " position.z = ScreenToDepth.y / (texture2DRect(Texture_ScreenDepth, gl_FragCoord.xy).r + ScreenToDepth.x);\n"
1356 " position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n"
1357 " // decode viewspace pixel normal\n"
1358 " myhalf4 normalmap = texture2DRect(Texture_ScreenNormalMap, gl_FragCoord.xy);\n"
1359 " myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n"
1360 " // surfacenormal = pixel normal in viewspace\n"
1361 " // LightVector = pixel to light in viewspace\n"
1362 " // CubeVector = position in lightspace\n"
1363 " // eyevector = pixel to view in viewspace\n"
1364 " vec3 CubeVector = vec3(ViewToLight * vec4(position,1));\n"
1365 " myhalf fade = myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1366 "#ifdef USEDIFFUSE\n"
1367 " // calculate diffuse shading\n"
1368 " myhalf3 lightnormal = myhalf3(normalize(LightPosition - position));\n"
1369 " myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1371 "#ifdef USESPECULAR\n"
1372 " // calculate directional shading\n"
1373 " vec3 eyevector = position * -1.0;\n"
1374 "# ifdef USEEXACTSPECULARMATH\n"
1375 " myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower);\n"
1377 " myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n"
1378 " myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
1382 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1383 " fade *= ShadowMapCompare(CubeVector);\n"
1386 "#ifdef USEDIFFUSE\n"
1387 " gl_FragData[0] = vec4((DeferredColor_Ambient + DeferredColor_Diffuse * diffuse) * fade, 1.0);\n"
1389 " gl_FragData[0] = vec4(DeferredColor_Ambient * fade, 1.0);\n"
1391 "#ifdef USESPECULAR\n"
1392 " gl_FragData[1] = vec4(DeferredColor_Specular * (specular * fade), 1.0);\n"
1394 " gl_FragData[1] = vec4(0.0, 0.0, 0.0, 1.0);\n"
1397 "# ifdef USECUBEFILTER\n"
1398 " vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n"
1399 " gl_FragData[0] *= cubecolor;\n"
1400 " gl_FragData[1] *= cubecolor;\n"
1403 "#else // !MODE_DEFERREDLIGHTSOURCE\n"
1404 "#ifdef USEDEFERREDLIGHTMAP\n"
1405 "uniform myhalf3 DeferredMod_Diffuse;\n"
1406 "uniform myhalf3 DeferredMod_Specular;\n"
1408 "uniform myhalf3 Color_Ambient;\n"
1409 "uniform myhalf3 Color_Diffuse;\n"
1410 "uniform myhalf3 Color_Specular;\n"
1411 "uniform myhalf SpecularPower;\n"
1413 "uniform myhalf3 Color_Glow;\n"
1415 "uniform myhalf Alpha;\n"
1416 "#ifdef USEREFLECTION\n"
1417 "uniform vec4 DistortScaleRefractReflect;\n"
1418 "uniform vec4 ScreenScaleRefractReflect;\n"
1419 "uniform vec4 ScreenCenterRefractReflect;\n"
1420 "uniform myhalf4 ReflectColor;\n"
1422 "#ifdef MODE_LIGHTDIRECTION\n"
1423 "uniform myhalf3 LightColor;\n"
1425 "#ifdef MODE_LIGHTSOURCE\n"
1426 "uniform myhalf3 LightColor;\n"
1430 "#ifdef USEOFFSETMAPPING\n"
1431 " // apply offsetmapping\n"
1432 " vec2 TexCoordOffset = OffsetMapping(TexCoord);\n"
1433 "#define TexCoord TexCoordOffset\n"
1436 " // combine the diffuse textures (base, pants, shirt)\n"
1437 " myhalf4 color = myhalf4(texture2D(Texture_Color, TexCoord));\n"
1438 "#ifdef USEALPHAKILL\n"
1439 " if (color.a < 0.5)\n"
1442 " color.a *= Alpha;\n"
1443 "#ifdef USECOLORMAPPING\n"
1444 " color.rgb += myhalf3(texture2D(Texture_Pants, TexCoord)) * Color_Pants + myhalf3(texture2D(Texture_Shirt, TexCoord)) * Color_Shirt;\n"
1446 "#ifdef USEVERTEXTEXTUREBLEND\n"
1447 " myhalf terrainblend = clamp(myhalf(gl_Color.a) * color.a * 2.0 - 0.5, myhalf(0.0), myhalf(1.0));\n"
1448 " //myhalf terrainblend = min(myhalf(gl_Color.a) * color.a * 2.0, myhalf(1.0));\n"
1449 " //myhalf terrainblend = myhalf(gl_Color.a) * color.a > 0.5;\n"
1450 " color.rgb = mix(myhalf3(texture2D(Texture_SecondaryColor, TexCoord2)), color.rgb, terrainblend);\n"
1452 " //color = mix(myhalf4(1, 0, 0, 1), color, terrainblend);\n"
1455 " // get the surface normal\n"
1456 "#ifdef USEVERTEXTEXTUREBLEND\n"
1457 " myhalf3 surfacenormal = normalize(mix(myhalf3(texture2D(Texture_SecondaryNormal, TexCoord2)), myhalf3(texture2D(Texture_Normal, TexCoord)), terrainblend) - myhalf3(0.5, 0.5, 0.5));\n"
1459 " myhalf3 surfacenormal = normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5, 0.5, 0.5));\n"
1462 " // get the material colors\n"
1463 " myhalf3 diffusetex = color.rgb;\n"
1464 "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n"
1465 "# ifdef USEVERTEXTEXTUREBLEND\n"
1466 " myhalf3 glosstex = mix(myhalf3(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf3(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n"
1468 " myhalf3 glosstex = myhalf3(texture2D(Texture_Gloss, TexCoord));\n"
1475 "#ifdef MODE_LIGHTSOURCE\n"
1476 " // light source\n"
1477 " myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1478 " myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1479 " color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n"
1480 "#ifdef USESPECULAR\n"
1481 "#ifdef USEEXACTSPECULARMATH\n"
1482 " myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n"
1484 " myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1485 " myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
1487 " color.rgb += glosstex * (specular * Color_Specular);\n"
1489 " color.rgb *= LightColor;\n"
1490 " color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n"
1491 "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAPCUBE) || defined(USESHADOWMAP2D)\n"
1492 " color.rgb *= ShadowMapCompare(CubeVector);\n"
1494 "# ifdef USECUBEFILTER\n"
1495 " color.rgb *= myhalf3(textureCube(Texture_Cube, CubeVector));\n"
1497 "#endif // MODE_LIGHTSOURCE\n"
1502 "#ifdef MODE_LIGHTDIRECTION\n"
1504 " myhalf3 lightnormal = myhalf3(normalize(LightVector));\n"
1505 "#define lightcolor LightColor\n"
1506 "#endif // MODE_LIGHTDIRECTION\n"
1507 "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1509 " // deluxemap lightmapping using light vectors in modelspace (q3map2 -light -deluxe)\n"
1510 " myhalf3 lightnormal_modelspace = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1511 " myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1512 " // convert modelspace light vector to tangentspace\n"
1513 " myhalf3 lightnormal;\n"
1514 " lightnormal.x = dot(lightnormal_modelspace, myhalf3(VectorS));\n"
1515 " lightnormal.y = dot(lightnormal_modelspace, myhalf3(VectorT));\n"
1516 " lightnormal.z = dot(lightnormal_modelspace, myhalf3(VectorR));\n"
1517 " // calculate directional shading (and undoing the existing angle attenuation on the lightmap by the division)\n"
1518 " // note that q3map2 is too stupid to calculate proper surface normals when q3map_nonplanar\n"
1519 " // is used (the lightmap and deluxemap coords correspond to virtually random coordinates\n"
1520 " // on that luxel, and NOT to its center, because recursive triangle subdivision is used\n"
1521 " // to map the luxels to coordinates on the draw surfaces), which also causes\n"
1522 " // deluxemaps to be wrong because light contributions from the wrong side of the surface\n"
1523 " // are added up. To prevent divisions by zero or strong exaggerations, a max()\n"
1524 " // nudge is done here at expense of some additional fps. This is ONLY needed for\n"
1525 " // deluxemaps, tangentspace deluxemap avoid this problem by design.\n"
1526 " lightcolor *= 1.0 / max(0.25, lightnormal.z);\n"
1527 "#endif // MODE_LIGHTDIRECTIONMAP_MODELSPACE\n"
1528 "#ifdef MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n"
1530 " // deluxemap lightmapping using light vectors in tangentspace (hmap2 -light)\n"
1531 " myhalf3 lightnormal = myhalf3(texture2D(Texture_Deluxemap, TexCoordLightmap)) * 2.0 + myhalf3(-1.0, -1.0, -1.0);\n"
1532 " myhalf3 lightcolor = myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap));\n"
1538 "#ifdef MODE_LIGHTMAP\n"
1539 " color.rgb = diffusetex * (Color_Ambient + myhalf3(texture2D(Texture_Lightmap, TexCoordLightmap)) * Color_Diffuse);\n"
1540 "#endif // MODE_LIGHTMAP\n"
1541 "#ifdef MODE_VERTEXCOLOR\n"
1542 " color.rgb = diffusetex * (Color_Ambient + myhalf3(gl_Color.rgb) * Color_Diffuse);\n"
1543 "#endif // MODE_VERTEXCOLOR\n"
1544 "#ifdef MODE_FLATCOLOR\n"
1545 " color.rgb = diffusetex * Color_Ambient;\n"
1546 "#endif // MODE_FLATCOLOR\n"
1552 "# ifdef USEDIFFUSE\n"
1553 " myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n"
1554 "# ifdef USESPECULAR\n"
1555 "# ifdef USEEXACTSPECULARMATH\n"
1556 " myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n"
1558 " myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n"
1559 " myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n"
1561 " color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex * Color_Specular * specular) * lightcolor;\n"
1563 " color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n"
1566 " color.rgb = diffusetex * Color_Ambient;\n"
1570 "#ifdef USEDEFERREDLIGHTMAP\n"
1571 " color.rgb += diffusetex * myhalf3(texture2DRect(Texture_ScreenDiffuse, gl_FragCoord.xy)) * DeferredMod_Diffuse;\n"
1572 " color.rgb += glosstex * myhalf3(texture2DRect(Texture_ScreenSpecular, gl_FragCoord.xy)) * DeferredMod_Specular;\n"
1576 "#ifdef USEVERTEXTEXTUREBLEND\n"
1577 " color.rgb += mix(myhalf3(texture2D(Texture_SecondaryGlow, TexCoord2)), myhalf3(texture2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n"
1579 " color.rgb += myhalf3(texture2D(Texture_Glow, TexCoord)) * Color_Glow;\n"
1584 " color.rgb = mix(FogColor, color.rgb, FogVertex());\n"
1587 " // reflection must come last because it already contains exactly the correct fog (the reflection render preserves camera distance from the plane, it only flips the side) and ContrastBoost/SceneBrightness\n"
1588 "#ifdef USEREFLECTION\n"
1589 " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n"
1590 " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n"
1591 " vec2 SafeScreenTexCoord = ModelViewProjectionPosition.xy * ScreenScaleRefractReflectIW.zw + ScreenCenterRefractReflect.zw;\n"
1592 " vec2 ScreenTexCoord = SafeScreenTexCoord + vec3(normalize(myhalf3(texture2D(Texture_Normal, TexCoord)) - myhalf3(0.5))).xy * DistortScaleRefractReflect.zw;\n"
1593 " // FIXME temporary hack to detect the case that the reflection\n"
1594 " // gets blackened at edges due to leaving the area that contains actual\n"
1596 " // Remove this 'ack once we have a better way to stop this thing from\n"
1598 " float f = min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, 0.01)).rgb) / 0.05);\n"
1599 " f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(0.01, -0.01)).rgb) / 0.05);\n"
1600 " f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, 0.01)).rgb) / 0.05);\n"
1601 " f *= min(1.0, length(texture2D(Texture_Reflection, ScreenTexCoord + vec2(-0.01, -0.01)).rgb) / 0.05);\n"
1602 " ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n"
1603 " color.rgb = mix(color.rgb, myhalf3(texture2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n"
1606 " gl_FragColor = vec4(color);\n"
1608 "#endif // !MODE_DEFERREDLIGHTSOURCE\n"
1609 "#endif // !MODE_DEFERREDGEOMETRY\n"
1611 "#endif // FRAGMENT_SHADER\n"
1613 "#endif // !MODE_WATER\n"
1614 "#endif // !MODE_REFRACTION\n"
1615 "#endif // !MODE_BLOOMBLUR\n"
1616 "#endif // !MODE_GENERIC\n"
1617 "#endif // !MODE_POSTPROCESS\n"
1618 "#endif // !MODE_SHOWDEPTH\n"
1619 "#endif // !MODE_DEPTH_OR_SHADOW\n"
1622 const char *builtincgshaderstring = "";
1624 typedef struct shaderpermutationinfo_s
1626 const char *pretext;
1629 shaderpermutationinfo_t;
1631 typedef struct shadermodeinfo_s
1633 const char *vertexfilename;
1634 const char *geometryfilename;
1635 const char *fragmentfilename;
1636 const char *pretext;
1641 typedef enum shaderpermutation_e
1643 SHADERPERMUTATION_DIFFUSE = 1<<0, ///< (lightsource) whether to use directional shading
1644 SHADERPERMUTATION_VERTEXTEXTUREBLEND = 1<<1, ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp)
1645 SHADERPERMUTATION_VIEWTINT = 1<<2, ///< view tint (postprocessing only)
1646 SHADERPERMUTATION_COLORMAPPING = 1<<3, ///< indicates this is a colormapped skin
1647 SHADERPERMUTATION_SATURATION = 1<<4, ///< saturation (postprocessing only)
1648 SHADERPERMUTATION_FOGINSIDE = 1<<5, ///< tint the color by fog color or black if using additive blend mode
1649 SHADERPERMUTATION_FOGOUTSIDE = 1<<6, ///< tint the color by fog color or black if using additive blend mode
1650 SHADERPERMUTATION_GAMMARAMPS = 1<<7, ///< gamma (postprocessing only)
1651 SHADERPERMUTATION_CUBEFILTER = 1<<8, ///< (lightsource) use cubemap light filter
1652 SHADERPERMUTATION_GLOW = 1<<9, ///< (lightmap) blend in an additive glow texture
1653 SHADERPERMUTATION_BLOOM = 1<<10, ///< bloom (postprocessing only)
1654 SHADERPERMUTATION_SPECULAR = 1<<11, ///< (lightsource or deluxemapping) render specular effects
1655 SHADERPERMUTATION_POSTPROCESSING = 1<<12, ///< user defined postprocessing (postprocessing only)
1656 SHADERPERMUTATION_EXACTSPECULARMATH = 1<<13, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation
1657 SHADERPERMUTATION_REFLECTION = 1<<14, ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
1658 SHADERPERMUTATION_OFFSETMAPPING = 1<<15, ///< adjust texcoords to roughly simulate a displacement mapped surface
1659 SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING = 1<<16, ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
1660 SHADERPERMUTATION_SHADOWMAPRECT = 1<<17, ///< (lightsource) use shadowmap rectangle texture as light filter
1661 SHADERPERMUTATION_SHADOWMAPCUBE = 1<<18, ///< (lightsource) use shadowmap cubemap texture as light filter
1662 SHADERPERMUTATION_SHADOWMAP2D = 1<<19, ///< (lightsource) use shadowmap rectangle texture as light filter
1663 SHADERPERMUTATION_SHADOWMAPPCF = 1<<20, ///< (lightsource) use percentage closer filtering on shadowmap test results
1664 SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<21, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results
1665 SHADERPERMUTATION_SHADOWSAMPLER = 1<<22, ///< (lightsource) use hardware shadowmap test
1666 SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<23, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
1667 SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<24, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
1668 SHADERPERMUTATION_ALPHAKILL = 1<<25, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5
1669 SHADERPERMUTATION_LIMIT = 1<<26, ///< size of permutations array
1670 SHADERPERMUTATION_COUNT = 27 ///< size of shaderpermutationinfo array
1672 shaderpermutation_t;
1674 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
1675 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
1677 {"#define USEDIFFUSE\n", " diffuse"},
1678 {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
1679 {"#define USEVIEWTINT\n", " viewtint"},
1680 {"#define USECOLORMAPPING\n", " colormapping"},
1681 {"#define USESATURATION\n", " saturation"},
1682 {"#define USEFOGINSIDE\n", " foginside"},
1683 {"#define USEFOGOUTSIDE\n", " fogoutside"},
1684 {"#define USEGAMMARAMPS\n", " gammaramps"},
1685 {"#define USECUBEFILTER\n", " cubefilter"},
1686 {"#define USEGLOW\n", " glow"},
1687 {"#define USEBLOOM\n", " bloom"},
1688 {"#define USESPECULAR\n", " specular"},
1689 {"#define USEPOSTPROCESSING\n", " postprocessing"},
1690 {"#define USEEXACTSPECULARMATH\n", " exactspecularmath"},
1691 {"#define USEREFLECTION\n", " reflection"},
1692 {"#define USEOFFSETMAPPING\n", " offsetmapping"},
1693 {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
1694 {"#define USESHADOWMAPRECT\n", " shadowmaprect"},
1695 {"#define USESHADOWMAPCUBE\n", " shadowmapcube"},
1696 {"#define USESHADOWMAP2D\n", " shadowmap2d"},
1697 {"#define USESHADOWMAPPCF 1\n", " shadowmappcf"},
1698 {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"},
1699 {"#define USESHADOWSAMPLER\n", " shadowsampler"},
1700 {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"},
1701 {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"},
1702 {"#define USEALPHAKILL\n", " alphakill"},
1705 /// this enum is multiplied by SHADERPERMUTATION_MODEBASE
1706 typedef enum shadermode_e
1708 SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture
1709 SHADERMODE_POSTPROCESS, ///< postprocessing shader (r_glsl_postprocess)
1710 SHADERMODE_DEPTH_OR_SHADOW, ///< (depthfirst/shadows) vertex shader only
1711 SHADERMODE_FLATCOLOR, ///< (lightmap) modulate texture by uniform color (q1bsp, q3bsp)
1712 SHADERMODE_VERTEXCOLOR, ///< (lightmap) modulate texture by vertex colors (q3bsp)
1713 SHADERMODE_LIGHTMAP, ///< (lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
1714 SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, ///< (lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
1715 SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, ///< (lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
1716 SHADERMODE_LIGHTDIRECTION, ///< (lightmap) use directional pixel shading from fixed light direction (q3bsp)
1717 SHADERMODE_LIGHTSOURCE, ///< (lightsource) use directional pixel shading from light source (rtlight)
1718 SHADERMODE_REFRACTION, ///< refract background (the material is rendered normally after this pass)
1719 SHADERMODE_WATER, ///< refract background and reflection (the material is rendered normally after this pass)
1720 SHADERMODE_SHOWDEPTH, ///< (debugging) renders depth as color
1721 SHADERMODE_DEFERREDGEOMETRY, ///< (deferred) render material properties to screenspace geometry buffers
1722 SHADERMODE_DEFERREDLIGHTSOURCE, ///< (deferred) use directional pixel shading from light source (rtlight) on screenspace geometry buffers
1727 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
1728 shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] =
1730 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
1731 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
1732 {"glsl/default.glsl", NULL, NULL , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
1733 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
1734 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
1735 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
1736 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
1737 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
1738 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
1739 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
1740 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
1741 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
1742 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
1743 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
1744 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
1748 shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] =
1750 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"},
1751 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"},
1752 {"cg/default.cg", NULL, NULL , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
1753 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"},
1754 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
1755 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"},
1756 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
1757 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
1758 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
1759 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTSOURCE\n", " lightsource"},
1760 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_REFRACTION\n", " refraction"},
1761 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_WATER\n", " water"},
1762 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_SHOWDEPTH\n", " showdepth"},
1763 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
1764 {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
1768 struct r_glsl_permutation_s;
1769 typedef struct r_glsl_permutation_s
1771 /// hash lookup data
1772 struct r_glsl_permutation_s *hashnext;
1774 unsigned int permutation;
1776 /// indicates if we have tried compiling this permutation already
1778 /// 0 if compilation failed
1780 /// locations of detected uniforms in program object, or -1 if not found
1781 int loc_Texture_First;
1782 int loc_Texture_Second;
1783 int loc_Texture_GammaRamps;
1784 int loc_Texture_Normal;
1785 int loc_Texture_Color;
1786 int loc_Texture_Gloss;
1787 int loc_Texture_Glow;
1788 int loc_Texture_SecondaryNormal;
1789 int loc_Texture_SecondaryColor;
1790 int loc_Texture_SecondaryGloss;
1791 int loc_Texture_SecondaryGlow;
1792 int loc_Texture_Pants;
1793 int loc_Texture_Shirt;
1794 int loc_Texture_FogMask;
1795 int loc_Texture_Lightmap;
1796 int loc_Texture_Deluxemap;
1797 int loc_Texture_Attenuation;
1798 int loc_Texture_Cube;
1799 int loc_Texture_Refraction;
1800 int loc_Texture_Reflection;
1801 int loc_Texture_ShadowMapRect;
1802 int loc_Texture_ShadowMapCube;
1803 int loc_Texture_ShadowMap2D;
1804 int loc_Texture_CubeProjection;
1805 int loc_Texture_ScreenDepth;
1806 int loc_Texture_ScreenNormalMap;
1807 int loc_Texture_ScreenDiffuse;
1808 int loc_Texture_ScreenSpecular;
1810 int loc_BloomBlur_Parameters;
1812 int loc_Color_Ambient;
1813 int loc_Color_Diffuse;
1814 int loc_Color_Specular;
1816 int loc_Color_Pants;
1817 int loc_Color_Shirt;
1818 int loc_DeferredColor_Ambient;
1819 int loc_DeferredColor_Diffuse;
1820 int loc_DeferredColor_Specular;
1821 int loc_DeferredMod_Diffuse;
1822 int loc_DeferredMod_Specular;
1823 int loc_DistortScaleRefractReflect;
1824 int loc_EyePosition;
1826 int loc_FogHeightFade;
1828 int loc_FogPlaneViewDist;
1829 int loc_FogRangeRecip;
1832 int loc_LightPosition;
1833 int loc_OffsetMapping_Scale;
1835 int loc_ReflectColor;
1836 int loc_ReflectFactor;
1837 int loc_ReflectOffset;
1838 int loc_RefractColor;
1840 int loc_ScreenCenterRefractReflect;
1841 int loc_ScreenScaleRefractReflect;
1842 int loc_ScreenToDepth;
1843 int loc_ShadowMap_Parameters;
1844 int loc_ShadowMap_TextureScale;
1845 int loc_SpecularPower;
1850 int loc_ViewTintColor;
1851 int loc_ViewToLight;
1852 int loc_ModelToLight;
1854 int loc_BackgroundTexMatrix;
1855 int loc_ModelViewProjectionMatrix;
1856 int loc_ModelViewMatrix;
1858 r_glsl_permutation_t;
1860 #define SHADERPERMUTATION_HASHSIZE 256
1862 /// information about each possible shader permutation
1863 r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
1864 /// currently selected permutation
1865 r_glsl_permutation_t *r_glsl_permutation;
1866 /// storage for permutations linked in the hash table
1867 memexpandablearray_t r_glsl_permutationarray;
1869 static r_glsl_permutation_t *R_GLSL_FindPermutation(unsigned int mode, unsigned int permutation)
1871 //unsigned int hashdepth = 0;
1872 unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
1873 r_glsl_permutation_t *p;
1874 for (p = r_glsl_permutationhash[mode][hashindex];p;p = p->hashnext)
1876 if (p->mode == mode && p->permutation == permutation)
1878 //if (hashdepth > 10)
1879 // Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
1884 p = (r_glsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_glsl_permutationarray);
1886 p->permutation = permutation;
1887 p->hashnext = r_glsl_permutationhash[mode][hashindex];
1888 r_glsl_permutationhash[mode][hashindex] = p;
1889 //if (hashdepth > 10)
1890 // Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
1894 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
1897 if (!filename || !filename[0])
1899 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1902 if (printfromdisknotice)
1903 Con_DPrintf("from disk %s... ", filename);
1904 return shaderstring;
1906 else if (!strcmp(filename, "glsl/default.glsl"))
1908 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(builtinshaderstring) + 1);
1909 memcpy(shaderstring, builtinshaderstring, strlen(builtinshaderstring) + 1);
1911 return shaderstring;
1914 static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode, unsigned int permutation)
1917 shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
1918 int vertstrings_count = 0;
1919 int geomstrings_count = 0;
1920 int fragstrings_count = 0;
1921 char *vertexstring, *geometrystring, *fragmentstring;
1922 const char *vertstrings_list[32+3];
1923 const char *geomstrings_list[32+3];
1924 const char *fragstrings_list[32+3];
1925 char permutationname[256];
1932 permutationname[0] = 0;
1933 vertexstring = R_GLSL_GetText(modeinfo->vertexfilename, true);
1934 geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
1935 fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
1937 strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
1939 // the first pretext is which type of shader to compile as
1940 // (later these will all be bound together as a program object)
1941 vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
1942 geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
1943 fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
1945 // the second pretext is the mode (for example a light source)
1946 vertstrings_list[vertstrings_count++] = modeinfo->pretext;
1947 geomstrings_list[geomstrings_count++] = modeinfo->pretext;
1948 fragstrings_list[fragstrings_count++] = modeinfo->pretext;
1949 strlcat(permutationname, modeinfo->name, sizeof(permutationname));
1951 // now add all the permutation pretexts
1952 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1954 if (permutation & (1<<i))
1956 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
1957 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
1958 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
1959 strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
1963 // keep line numbers correct
1964 vertstrings_list[vertstrings_count++] = "\n";
1965 geomstrings_list[geomstrings_count++] = "\n";
1966 fragstrings_list[fragstrings_count++] = "\n";
1970 // now append the shader text itself
1971 vertstrings_list[vertstrings_count++] = vertexstring;
1972 geomstrings_list[geomstrings_count++] = geometrystring;
1973 fragstrings_list[fragstrings_count++] = fragmentstring;
1975 // if any sources were NULL, clear the respective list
1977 vertstrings_count = 0;
1978 if (!geometrystring)
1979 geomstrings_count = 0;
1980 if (!fragmentstring)
1981 fragstrings_count = 0;
1983 // compile the shader program
1984 if (vertstrings_count + geomstrings_count + fragstrings_count)
1985 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1989 qglUseProgramObjectARB(p->program);CHECKGLERROR
1990 // look up all the uniform variable names we care about, so we don't
1991 // have to look them up every time we set them
1993 p->loc_Texture_First = qglGetUniformLocationARB(p->program, "Texture_First");
1994 p->loc_Texture_Second = qglGetUniformLocationARB(p->program, "Texture_Second");
1995 p->loc_Texture_GammaRamps = qglGetUniformLocationARB(p->program, "Texture_GammaRamps");
1996 p->loc_Texture_Normal = qglGetUniformLocationARB(p->program, "Texture_Normal");
1997 p->loc_Texture_Color = qglGetUniformLocationARB(p->program, "Texture_Color");
1998 p->loc_Texture_Gloss = qglGetUniformLocationARB(p->program, "Texture_Gloss");
1999 p->loc_Texture_Glow = qglGetUniformLocationARB(p->program, "Texture_Glow");
2000 p->loc_Texture_SecondaryNormal = qglGetUniformLocationARB(p->program, "Texture_SecondaryNormal");
2001 p->loc_Texture_SecondaryColor = qglGetUniformLocationARB(p->program, "Texture_SecondaryColor");
2002 p->loc_Texture_SecondaryGloss = qglGetUniformLocationARB(p->program, "Texture_SecondaryGloss");
2003 p->loc_Texture_SecondaryGlow = qglGetUniformLocationARB(p->program, "Texture_SecondaryGlow");
2004 p->loc_Texture_Pants = qglGetUniformLocationARB(p->program, "Texture_Pants");
2005 p->loc_Texture_Shirt = qglGetUniformLocationARB(p->program, "Texture_Shirt");
2006 p->loc_Texture_FogMask = qglGetUniformLocationARB(p->program, "Texture_FogMask");
2007 p->loc_Texture_Lightmap = qglGetUniformLocationARB(p->program, "Texture_Lightmap");
2008 p->loc_Texture_Deluxemap = qglGetUniformLocationARB(p->program, "Texture_Deluxemap");
2009 p->loc_Texture_Attenuation = qglGetUniformLocationARB(p->program, "Texture_Attenuation");
2010 p->loc_Texture_Cube = qglGetUniformLocationARB(p->program, "Texture_Cube");
2011 p->loc_Texture_Refraction = qglGetUniformLocationARB(p->program, "Texture_Refraction");
2012 p->loc_Texture_Reflection = qglGetUniformLocationARB(p->program, "Texture_Reflection");
2013 p->loc_Texture_ShadowMapRect = qglGetUniformLocationARB(p->program, "Texture_ShadowMapRect");
2014 p->loc_Texture_ShadowMapCube = qglGetUniformLocationARB(p->program, "Texture_ShadowMapCube");
2015 p->loc_Texture_ShadowMap2D = qglGetUniformLocationARB(p->program, "Texture_ShadowMap2D");
2016 p->loc_Texture_CubeProjection = qglGetUniformLocationARB(p->program, "Texture_CubeProjection");
2017 p->loc_Texture_ScreenDepth = qglGetUniformLocationARB(p->program, "Texture_ScreenDepth");
2018 p->loc_Texture_ScreenNormalMap = qglGetUniformLocationARB(p->program, "Texture_ScreenNormalMap");
2019 p->loc_Texture_ScreenDiffuse = qglGetUniformLocationARB(p->program, "Texture_ScreenDiffuse");
2020 p->loc_Texture_ScreenSpecular = qglGetUniformLocationARB(p->program, "Texture_ScreenSpecular");
2021 p->loc_Alpha = qglGetUniformLocationARB(p->program, "Alpha");
2022 p->loc_BloomBlur_Parameters = qglGetUniformLocationARB(p->program, "BloomBlur_Parameters");
2023 p->loc_ClientTime = qglGetUniformLocationARB(p->program, "ClientTime");
2024 p->loc_Color_Ambient = qglGetUniformLocationARB(p->program, "Color_Ambient");
2025 p->loc_Color_Diffuse = qglGetUniformLocationARB(p->program, "Color_Diffuse");
2026 p->loc_Color_Specular = qglGetUniformLocationARB(p->program, "Color_Specular");
2027 p->loc_Color_Glow = qglGetUniformLocationARB(p->program, "Color_Glow");
2028 p->loc_Color_Pants = qglGetUniformLocationARB(p->program, "Color_Pants");
2029 p->loc_Color_Shirt = qglGetUniformLocationARB(p->program, "Color_Shirt");
2030 p->loc_DeferredColor_Ambient = qglGetUniformLocationARB(p->program, "DeferredColor_Ambient");
2031 p->loc_DeferredColor_Diffuse = qglGetUniformLocationARB(p->program, "DeferredColor_Diffuse");
2032 p->loc_DeferredColor_Specular = qglGetUniformLocationARB(p->program, "DeferredColor_Specular");
2033 p->loc_DeferredMod_Diffuse = qglGetUniformLocationARB(p->program, "DeferredMod_Diffuse");
2034 p->loc_DeferredMod_Specular = qglGetUniformLocationARB(p->program, "DeferredMod_Specular");
2035 p->loc_DistortScaleRefractReflect = qglGetUniformLocationARB(p->program, "DistortScaleRefractReflect");
2036 p->loc_EyePosition = qglGetUniformLocationARB(p->program, "EyePosition");
2037 p->loc_FogColor = qglGetUniformLocationARB(p->program, "FogColor");
2038 p->loc_FogHeightFade = qglGetUniformLocationARB(p->program, "FogHeightFade");
2039 p->loc_FogPlane = qglGetUniformLocationARB(p->program, "FogPlane");
2040 p->loc_FogPlaneViewDist = qglGetUniformLocationARB(p->program, "FogPlaneViewDist");
2041 p->loc_FogRangeRecip = qglGetUniformLocationARB(p->program, "FogRangeRecip");
2042 p->loc_LightColor = qglGetUniformLocationARB(p->program, "LightColor");
2043 p->loc_LightDir = qglGetUniformLocationARB(p->program, "LightDir");
2044 p->loc_LightPosition = qglGetUniformLocationARB(p->program, "LightPosition");
2045 p->loc_OffsetMapping_Scale = qglGetUniformLocationARB(p->program, "OffsetMapping_Scale");
2046 p->loc_PixelSize = qglGetUniformLocationARB(p->program, "PixelSize");
2047 p->loc_ReflectColor = qglGetUniformLocationARB(p->program, "ReflectColor");
2048 p->loc_ReflectFactor = qglGetUniformLocationARB(p->program, "ReflectFactor");
2049 p->loc_ReflectOffset = qglGetUniformLocationARB(p->program, "ReflectOffset");
2050 p->loc_RefractColor = qglGetUniformLocationARB(p->program, "RefractColor");
2051 p->loc_Saturation = qglGetUniformLocationARB(p->program, "Saturation");
2052 p->loc_ScreenCenterRefractReflect = qglGetUniformLocationARB(p->program, "ScreenCenterRefractReflect");
2053 p->loc_ScreenScaleRefractReflect = qglGetUniformLocationARB(p->program, "ScreenScaleRefractReflect");
2054 p->loc_ScreenToDepth = qglGetUniformLocationARB(p->program, "ScreenToDepth");
2055 p->loc_ShadowMap_Parameters = qglGetUniformLocationARB(p->program, "ShadowMap_Parameters");
2056 p->loc_ShadowMap_TextureScale = qglGetUniformLocationARB(p->program, "ShadowMap_TextureScale");
2057 p->loc_SpecularPower = qglGetUniformLocationARB(p->program, "SpecularPower");
2058 p->loc_UserVec1 = qglGetUniformLocationARB(p->program, "UserVec1");
2059 p->loc_UserVec2 = qglGetUniformLocationARB(p->program, "UserVec2");
2060 p->loc_UserVec3 = qglGetUniformLocationARB(p->program, "UserVec3");
2061 p->loc_UserVec4 = qglGetUniformLocationARB(p->program, "UserVec4");
2062 p->loc_ViewTintColor = qglGetUniformLocationARB(p->program, "ViewTintColor");
2063 p->loc_ViewToLight = qglGetUniformLocationARB(p->program, "ViewToLight");
2064 p->loc_ModelToLight = qglGetUniformLocationARB(p->program, "ModelToLight");
2065 p->loc_TexMatrix = qglGetUniformLocationARB(p->program, "TexMatrix");
2066 p->loc_BackgroundTexMatrix = qglGetUniformLocationARB(p->program, "BackgroundTexMatrix");
2067 p->loc_ModelViewMatrix = qglGetUniformLocationARB(p->program, "ModelViewMatrix");
2068 p->loc_ModelViewProjectionMatrix = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix");
2069 // initialize the samplers to refer to the texture units we use
2070 if (p->loc_Texture_First >= 0) qglUniform1iARB(p->loc_Texture_First , GL20TU_FIRST);
2071 if (p->loc_Texture_Second >= 0) qglUniform1iARB(p->loc_Texture_Second , GL20TU_SECOND);
2072 if (p->loc_Texture_GammaRamps >= 0) qglUniform1iARB(p->loc_Texture_GammaRamps , GL20TU_GAMMARAMPS);
2073 if (p->loc_Texture_Normal >= 0) qglUniform1iARB(p->loc_Texture_Normal , GL20TU_NORMAL);
2074 if (p->loc_Texture_Color >= 0) qglUniform1iARB(p->loc_Texture_Color , GL20TU_COLOR);
2075 if (p->loc_Texture_Gloss >= 0) qglUniform1iARB(p->loc_Texture_Gloss , GL20TU_GLOSS);
2076 if (p->loc_Texture_Glow >= 0) qglUniform1iARB(p->loc_Texture_Glow , GL20TU_GLOW);
2077 if (p->loc_Texture_SecondaryNormal >= 0) qglUniform1iARB(p->loc_Texture_SecondaryNormal, GL20TU_SECONDARY_NORMAL);
2078 if (p->loc_Texture_SecondaryColor >= 0) qglUniform1iARB(p->loc_Texture_SecondaryColor , GL20TU_SECONDARY_COLOR);
2079 if (p->loc_Texture_SecondaryGloss >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGloss , GL20TU_SECONDARY_GLOSS);
2080 if (p->loc_Texture_SecondaryGlow >= 0) qglUniform1iARB(p->loc_Texture_SecondaryGlow , GL20TU_SECONDARY_GLOW);
2081 if (p->loc_Texture_Pants >= 0) qglUniform1iARB(p->loc_Texture_Pants , GL20TU_PANTS);
2082 if (p->loc_Texture_Shirt >= 0) qglUniform1iARB(p->loc_Texture_Shirt , GL20TU_SHIRT);
2083 if (p->loc_Texture_FogMask >= 0) qglUniform1iARB(p->loc_Texture_FogMask , GL20TU_FOGMASK);
2084 if (p->loc_Texture_Lightmap >= 0) qglUniform1iARB(p->loc_Texture_Lightmap , GL20TU_LIGHTMAP);
2085 if (p->loc_Texture_Deluxemap >= 0) qglUniform1iARB(p->loc_Texture_Deluxemap , GL20TU_DELUXEMAP);
2086 if (p->loc_Texture_Attenuation >= 0) qglUniform1iARB(p->loc_Texture_Attenuation , GL20TU_ATTENUATION);
2087 if (p->loc_Texture_Cube >= 0) qglUniform1iARB(p->loc_Texture_Cube , GL20TU_CUBE);
2088 if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction , GL20TU_REFRACTION);
2089 if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection , GL20TU_REFLECTION);
2090 if (p->loc_Texture_ShadowMapRect >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapRect , GL20TU_SHADOWMAPRECT);
2091 if (p->loc_Texture_ShadowMapCube >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapCube , GL20TU_SHADOWMAPCUBE);
2092 if (p->loc_Texture_ShadowMap2D >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D , GL20TU_SHADOWMAP2D);
2093 if (p->loc_Texture_CubeProjection >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION);
2094 if (p->loc_Texture_ScreenDepth >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth , GL20TU_SCREENDEPTH);
2095 if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP);
2096 if (p->loc_Texture_ScreenDiffuse >= 0) qglUniform1iARB(p->loc_Texture_ScreenDiffuse , GL20TU_SCREENDIFFUSE);
2097 if (p->loc_Texture_ScreenSpecular >= 0) qglUniform1iARB(p->loc_Texture_ScreenSpecular , GL20TU_SCREENSPECULAR);
2099 if (developer.integer)
2100 Con_Printf("^5GLSL shader %s compiled.\n", permutationname);
2103 Con_Printf("^1GLSL shader %s failed! some features may not work properly.\n", permutationname);
2107 Mem_Free(vertexstring);
2109 Mem_Free(geometrystring);
2111 Mem_Free(fragmentstring);
2114 void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutation)
2116 r_glsl_permutation_t *perm = R_GLSL_FindPermutation(mode, permutation);
2117 if (r_glsl_permutation != perm)
2119 r_glsl_permutation = perm;
2120 if (!r_glsl_permutation->program)
2122 if (!r_glsl_permutation->compiled)
2123 R_GLSL_CompilePermutation(perm, mode, permutation);
2124 if (!r_glsl_permutation->program)
2126 // remove features until we find a valid permutation
2128 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2130 // reduce i more quickly whenever it would not remove any bits
2131 int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
2132 if (!(permutation & j))
2135 r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
2136 if (!r_glsl_permutation->compiled)
2137 R_GLSL_CompilePermutation(perm, mode, permutation);
2138 if (r_glsl_permutation->program)
2141 if (i >= SHADERPERMUTATION_COUNT)
2143 //Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
2144 r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
2145 qglUseProgramObjectARB(0);CHECKGLERROR
2146 return; // no bit left to clear, entire mode is broken
2151 qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR
2153 if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
2157 #include <Cg/cgGL.h>
2158 struct r_cg_permutation_s;
2159 typedef struct r_cg_permutation_s
2161 /// hash lookup data
2162 struct r_cg_permutation_s *hashnext;
2164 unsigned int permutation;
2166 /// indicates if we have tried compiling this permutation already
2168 /// 0 if compilation failed
2171 /// locations of detected parameters in programs, or NULL if not found
2172 CGparameter vp_EyePosition;
2173 CGparameter vp_FogPlane;
2174 CGparameter vp_LightDir;
2175 CGparameter vp_LightPosition;
2176 CGparameter vp_ModelToLight;
2177 CGparameter vp_TexMatrix;
2178 CGparameter vp_BackgroundTexMatrix;
2179 CGparameter vp_ModelViewProjectionMatrix;
2180 CGparameter vp_ModelViewMatrix;
2182 CGparameter fp_Texture_First;
2183 CGparameter fp_Texture_Second;
2184 CGparameter fp_Texture_GammaRamps;
2185 CGparameter fp_Texture_Normal;
2186 CGparameter fp_Texture_Color;
2187 CGparameter fp_Texture_Gloss;
2188 CGparameter fp_Texture_Glow;
2189 CGparameter fp_Texture_SecondaryNormal;
2190 CGparameter fp_Texture_SecondaryColor;
2191 CGparameter fp_Texture_SecondaryGloss;
2192 CGparameter fp_Texture_SecondaryGlow;
2193 CGparameter fp_Texture_Pants;
2194 CGparameter fp_Texture_Shirt;
2195 CGparameter fp_Texture_FogMask;
2196 CGparameter fp_Texture_Lightmap;
2197 CGparameter fp_Texture_Deluxemap;
2198 CGparameter fp_Texture_Attenuation;
2199 CGparameter fp_Texture_Cube;
2200 CGparameter fp_Texture_Refraction;
2201 CGparameter fp_Texture_Reflection;
2202 CGparameter fp_Texture_ShadowMapRect;
2203 CGparameter fp_Texture_ShadowMapCube;
2204 CGparameter fp_Texture_ShadowMap2D;
2205 CGparameter fp_Texture_CubeProjection;
2206 CGparameter fp_Texture_ScreenDepth;
2207 CGparameter fp_Texture_ScreenNormalMap;
2208 CGparameter fp_Texture_ScreenDiffuse;
2209 CGparameter fp_Texture_ScreenSpecular;
2210 CGparameter fp_Alpha;
2211 CGparameter fp_BloomBlur_Parameters;
2212 CGparameter fp_ClientTime;
2213 CGparameter fp_Color_Ambient;
2214 CGparameter fp_Color_Diffuse;
2215 CGparameter fp_Color_Specular;
2216 CGparameter fp_Color_Glow;
2217 CGparameter fp_Color_Pants;
2218 CGparameter fp_Color_Shirt;
2219 CGparameter fp_DeferredColor_Ambient;
2220 CGparameter fp_DeferredColor_Diffuse;
2221 CGparameter fp_DeferredColor_Specular;
2222 CGparameter fp_DeferredMod_Diffuse;
2223 CGparameter fp_DeferredMod_Specular;
2224 CGparameter fp_DistortScaleRefractReflect;
2225 CGparameter fp_EyePosition;
2226 CGparameter fp_FogColor;
2227 CGparameter fp_FogHeightFade;
2228 CGparameter fp_FogPlane;
2229 CGparameter fp_FogPlaneViewDist;
2230 CGparameter fp_FogRangeRecip;
2231 CGparameter fp_LightColor;
2232 CGparameter fp_LightDir;
2233 CGparameter fp_LightPosition;
2234 CGparameter fp_OffsetMapping_Scale;
2235 CGparameter fp_PixelSize;
2236 CGparameter fp_ReflectColor;
2237 CGparameter fp_ReflectFactor;
2238 CGparameter fp_ReflectOffset;
2239 CGparameter fp_RefractColor;
2240 CGparameter fp_Saturation;
2241 CGparameter fp_ScreenCenterRefractReflect;
2242 CGparameter fp_ScreenScaleRefractReflect;
2243 CGparameter fp_ScreenToDepth;
2244 CGparameter fp_ShadowMap_Parameters;
2245 CGparameter fp_ShadowMap_TextureScale;
2246 CGparameter fp_SpecularPower;
2247 CGparameter fp_UserVec1;
2248 CGparameter fp_UserVec2;
2249 CGparameter fp_UserVec3;
2250 CGparameter fp_UserVec4;
2251 CGparameter fp_ViewTintColor;
2252 CGparameter fp_ViewToLight;
2256 /// information about each possible shader permutation
2257 r_cg_permutation_t *r_cg_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
2258 /// currently selected permutation
2259 r_cg_permutation_t *r_cg_permutation;
2260 /// storage for permutations linked in the hash table
2261 memexpandablearray_t r_cg_permutationarray;
2263 #define CHECKCGERROR {CGerror err;const char *errorstring = cgGetLastErrorString(&err);if (err){Con_Printf("%s:%i CG error %i: %s\n", __FILE__, __LINE__, err, errorstring);if (err == 1) Con_Printf("last listing:\n%s\n", cgGetLastListing(vid.cgcontext));}}
2265 static r_cg_permutation_t *R_CG_FindPermutation(unsigned int mode, unsigned int permutation)
2267 //unsigned int hashdepth = 0;
2268 unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
2269 r_cg_permutation_t *p;
2270 for (p = r_cg_permutationhash[mode][hashindex];p;p = p->hashnext)
2272 if (p->mode == mode && p->permutation == permutation)
2274 //if (hashdepth > 10)
2275 // Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
2280 p = (r_cg_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_cg_permutationarray);
2282 p->permutation = permutation;
2283 p->hashnext = r_cg_permutationhash[mode][hashindex];
2284 r_cg_permutationhash[mode][hashindex] = p;
2285 //if (hashdepth > 10)
2286 // Con_Printf("R_CG_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
2290 static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice)
2293 if (!filename || !filename[0])
2295 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
2298 if (printfromdisknotice)
2299 Con_DPrintf("from disk %s... ", filename);
2300 return shaderstring;
2302 else if (!strcmp(filename, "cg/default.cg"))
2304 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(builtincgshaderstring) + 1);
2305 memcpy(shaderstring, builtincgshaderstring, strlen(builtincgshaderstring) + 1);
2307 return shaderstring;
2310 static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, unsigned int permutation)
2313 shadermodeinfo_t *modeinfo = cgshadermodeinfo + mode;
2314 int vertstrings_count = 0, vertstring_length = 0;
2315 int geomstrings_count = 0, geomstring_length = 0;
2316 int fragstrings_count = 0, fragstring_length = 0;
2318 char *vertexstring, *geometrystring, *fragmentstring;
2319 char *vertstring, *geomstring, *fragstring;
2320 const char *vertstrings_list[32+3];
2321 const char *geomstrings_list[32+3];
2322 const char *fragstrings_list[32+3];
2323 char permutationname[256];
2324 CGprofile vertexProfile;
2325 CGprofile fragmentProfile;
2333 permutationname[0] = 0;
2334 vertexstring = R_CG_GetText(modeinfo->vertexfilename, true);
2335 geometrystring = R_CG_GetText(modeinfo->geometryfilename, false);
2336 fragmentstring = R_CG_GetText(modeinfo->fragmentfilename, false);
2338 strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
2340 // the first pretext is which type of shader to compile as
2341 // (later these will all be bound together as a program object)
2342 vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
2343 geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
2344 fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
2346 // the second pretext is the mode (for example a light source)
2347 vertstrings_list[vertstrings_count++] = modeinfo->pretext;
2348 geomstrings_list[geomstrings_count++] = modeinfo->pretext;
2349 fragstrings_list[fragstrings_count++] = modeinfo->pretext;
2350 strlcat(permutationname, modeinfo->name, sizeof(permutationname));
2352 // now add all the permutation pretexts
2353 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2355 if (permutation & (1<<i))
2357 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
2358 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
2359 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
2360 strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
2364 // keep line numbers correct
2365 vertstrings_list[vertstrings_count++] = "\n";
2366 geomstrings_list[geomstrings_count++] = "\n";
2367 fragstrings_list[fragstrings_count++] = "\n";
2371 // now append the shader text itself
2372 vertstrings_list[vertstrings_count++] = vertexstring;
2373 geomstrings_list[geomstrings_count++] = geometrystring;
2374 fragstrings_list[fragstrings_count++] = fragmentstring;
2376 // if any sources were NULL, clear the respective list
2378 vertstrings_count = 0;
2379 if (!geometrystring)
2380 geomstrings_count = 0;
2381 if (!fragmentstring)
2382 fragstrings_count = 0;
2384 vertstring_length = 0;
2385 for (i = 0;i < vertstrings_count;i++)
2386 vertstring_length += strlen(vertstrings_list[i]);
2387 vertstring = t = Mem_Alloc(tempmempool, vertstring_length + 1);
2388 for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
2389 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
2391 geomstring_length = 0;
2392 for (i = 0;i < geomstrings_count;i++)
2393 geomstring_length += strlen(geomstrings_list[i]);
2394 geomstring = t = Mem_Alloc(tempmempool, geomstring_length + 1);
2395 for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
2396 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
2398 fragstring_length = 0;
2399 for (i = 0;i < fragstrings_count;i++)
2400 fragstring_length += strlen(fragstrings_list[i]);
2401 fragstring = t = Mem_Alloc(tempmempool, fragstring_length + 1);
2402 for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
2403 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
2407 //vertexProfile = CG_PROFILE_ARBVP1;
2408 //fragmentProfile = CG_PROFILE_ARBFP1;
2409 vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);CHECKCGERROR
2410 fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);CHECKCGERROR
2411 //cgGLSetOptimalOptions(vertexProfile);CHECKCGERROR
2412 //cgGLSetOptimalOptions(fragmentProfile);CHECKCGERROR
2413 //cgSetAutoCompile(vid.cgcontext, CG_COMPILE_MANUAL);CHECKCGERROR
2416 // compile the vertex program
2417 if (vertstring[0] && (p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, CG_PROFILE_ARBVP1, NULL, NULL)))
2420 cgCompileProgram(p->vprogram);CHECKCGERROR
2421 if (!cgIsProgramCompiled(p->vprogram))
2424 cgDestroyProgram(p->vprogram);CHECKCGERROR
2429 cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR
2430 cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR
2431 // look up all the uniform variable names we care about, so we don't
2432 // have to look them up every time we set them
2434 p->vp_EyePosition = cgGetNamedParameter(p->vprogram, "EyePosition");
2435 p->vp_FogPlane = cgGetNamedParameter(p->vprogram, "FogPlane");
2436 p->vp_LightDir = cgGetNamedParameter(p->vprogram, "LightDir");
2437 p->vp_LightPosition = cgGetNamedParameter(p->vprogram, "LightPosition");
2438 p->vp_ModelToLight = cgGetNamedParameter(p->vprogram, "ModelToLight");
2439 p->vp_TexMatrix = cgGetNamedParameter(p->vprogram, "TexMatrix");
2440 p->vp_BackgroundTexMatrix = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix");
2441 p->vp_ModelViewProjectionMatrix = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix");
2442 p->vp_ModelViewMatrix = cgGetNamedParameter(p->vprogram, "ModelViewMatrix");
2447 // compile the fragment program
2448 if (fragstring[0] && (p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, CG_PROFILE_ARBFP1, NULL, NULL)))
2450 cgCompileProgram(p->fprogram);CHECKCGERROR
2451 if (!cgIsProgramCompiled(p->fprogram))
2454 cgDestroyProgram(p->fprogram);CHECKCGERROR
2459 cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR
2460 cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR
2462 p->fp_Texture_First = cgGetNamedParameter(p->fprogram, "Texture_First");
2463 p->fp_Texture_Second = cgGetNamedParameter(p->fprogram, "Texture_Second");
2464 p->fp_Texture_GammaRamps = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps");
2465 p->fp_Texture_Normal = cgGetNamedParameter(p->fprogram, "Texture_Normal");
2466 p->fp_Texture_Color = cgGetNamedParameter(p->fprogram, "Texture_Color");
2467 p->fp_Texture_Gloss = cgGetNamedParameter(p->fprogram, "Texture_Gloss");
2468 p->fp_Texture_Glow = cgGetNamedParameter(p->fprogram, "Texture_Glow");
2469 p->fp_Texture_SecondaryNormal = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal");
2470 p->fp_Texture_SecondaryColor = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor");
2471 p->fp_Texture_SecondaryGloss = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss");
2472 p->fp_Texture_SecondaryGlow = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow");
2473 p->fp_Texture_Pants = cgGetNamedParameter(p->fprogram, "Texture_Pants");
2474 p->fp_Texture_Shirt = cgGetNamedParameter(p->fprogram, "Texture_Shirt");
2475 p->fp_Texture_FogMask = cgGetNamedParameter(p->fprogram, "Texture_FogMask");
2476 p->fp_Texture_Lightmap = cgGetNamedParameter(p->fprogram, "Texture_Lightmap");
2477 p->fp_Texture_Deluxemap = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap");
2478 p->fp_Texture_Attenuation = cgGetNamedParameter(p->fprogram, "Texture_Attenuation");
2479 p->fp_Texture_Cube = cgGetNamedParameter(p->fprogram, "Texture_Cube");
2480 p->fp_Texture_Refraction = cgGetNamedParameter(p->fprogram, "Texture_Refraction");
2481 p->fp_Texture_Reflection = cgGetNamedParameter(p->fprogram, "Texture_Reflection");
2482 p->fp_Texture_ShadowMapRect = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapRect");
2483 p->fp_Texture_ShadowMapCube = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapCube");
2484 p->fp_Texture_ShadowMap2D = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D");
2485 p->fp_Texture_CubeProjection = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection");
2486 p->fp_Texture_ScreenDepth = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth");
2487 p->fp_Texture_ScreenNormalMap = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap");
2488 p->fp_Texture_ScreenDiffuse = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse");
2489 p->fp_Texture_ScreenSpecular = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular");
2490 p->fp_Alpha = cgGetNamedParameter(p->fprogram, "Alpha");
2491 p->fp_BloomBlur_Parameters = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters");
2492 p->fp_ClientTime = cgGetNamedParameter(p->fprogram, "ClientTime");
2493 p->fp_Color_Ambient = cgGetNamedParameter(p->fprogram, "Color_Ambient");
2494 p->fp_Color_Diffuse = cgGetNamedParameter(p->fprogram, "Color_Diffuse");
2495 p->fp_Color_Specular = cgGetNamedParameter(p->fprogram, "Color_Specular");
2496 p->fp_Color_Glow = cgGetNamedParameter(p->fprogram, "Color_Glow");
2497 p->fp_Color_Pants = cgGetNamedParameter(p->fprogram, "Color_Pants");
2498 p->fp_Color_Shirt = cgGetNamedParameter(p->fprogram, "Color_Shirt");
2499 p->fp_DeferredColor_Ambient = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient");
2500 p->fp_DeferredColor_Diffuse = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse");
2501 p->fp_DeferredColor_Specular = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular");
2502 p->fp_DeferredMod_Diffuse = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse");
2503 p->fp_DeferredMod_Specular = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular");
2504 p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect");
2505 p->fp_EyePosition = cgGetNamedParameter(p->fprogram, "EyePosition");
2506 p->fp_FogColor = cgGetNamedParameter(p->fprogram, "FogColor");
2507 p->fp_FogHeightFade = cgGetNamedParameter(p->fprogram, "FogHeightFade");
2508 p->fp_FogPlane = cgGetNamedParameter(p->fprogram, "FogPlane");
2509 p->fp_FogPlaneViewDist = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist");
2510 p->fp_FogRangeRecip = cgGetNamedParameter(p->fprogram, "FogRangeRecip");
2511 p->fp_LightColor = cgGetNamedParameter(p->fprogram, "LightColor");
2512 p->fp_LightDir = cgGetNamedParameter(p->fprogram, "LightDir");
2513 p->fp_LightPosition = cgGetNamedParameter(p->fprogram, "LightPosition");
2514 p->fp_OffsetMapping_Scale = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale");
2515 p->fp_PixelSize = cgGetNamedParameter(p->fprogram, "PixelSize");
2516 p->fp_ReflectColor = cgGetNamedParameter(p->fprogram, "ReflectColor");
2517 p->fp_ReflectFactor = cgGetNamedParameter(p->fprogram, "ReflectFactor");
2518 p->fp_ReflectOffset = cgGetNamedParameter(p->fprogram, "ReflectOffset");
2519 p->fp_RefractColor = cgGetNamedParameter(p->fprogram, "RefractColor");
2520 p->fp_Saturation = cgGetNamedParameter(p->fprogram, "Saturation");
2521 p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect");
2522 p->fp_ScreenScaleRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect");
2523 p->fp_ScreenToDepth = cgGetNamedParameter(p->fprogram, "ScreenToDepth");
2524 p->fp_ShadowMap_Parameters = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters");
2525 p->fp_ShadowMap_TextureScale = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale");
2526 p->fp_SpecularPower = cgGetNamedParameter(p->fprogram, "SpecularPower");
2527 p->fp_UserVec1 = cgGetNamedParameter(p->fprogram, "UserVec1");
2528 p->fp_UserVec2 = cgGetNamedParameter(p->fprogram, "UserVec2");
2529 p->fp_UserVec3 = cgGetNamedParameter(p->fprogram, "UserVec3");
2530 p->fp_UserVec4 = cgGetNamedParameter(p->fprogram, "UserVec4");
2531 p->fp_ViewTintColor = cgGetNamedParameter(p->fprogram, "ViewTintColor");
2532 p->fp_ViewToLight = cgGetNamedParameter(p->fprogram, "ViewToLight");
2537 if ((p->vprogram || !vertstring[0]) && (p->fprogram || !fragstring[0]))
2538 Con_DPrintf("^5CG shader %s compiled.\n", permutationname);
2540 Con_Printf("^1CG shader %s failed! some features may not work properly.\n", permutationname);
2544 Mem_Free(vertstring);
2546 Mem_Free(geomstring);
2548 Mem_Free(fragstring);
2550 Mem_Free(vertexstring);
2552 Mem_Free(geometrystring);
2554 Mem_Free(fragmentstring);
2557 void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation)
2559 r_cg_permutation_t *perm = R_CG_FindPermutation(mode, permutation);
2562 if (r_cg_permutation != perm)
2564 r_cg_permutation = perm;
2565 if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
2567 if (!r_cg_permutation->compiled)
2568 R_CG_CompilePermutation(perm, mode, permutation);
2569 if (!r_cg_permutation->vprogram && !r_cg_permutation->fprogram)
2571 // remove features until we find a valid permutation
2573 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2575 // reduce i more quickly whenever it would not remove any bits
2576 int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
2577 if (!(permutation & j))
2580 r_cg_permutation = R_CG_FindPermutation(mode, permutation);
2581 if (!r_cg_permutation->compiled)
2582 R_CG_CompilePermutation(perm, mode, permutation);
2583 if (r_cg_permutation->vprogram || r_cg_permutation->fprogram)
2586 if (i >= SHADERPERMUTATION_COUNT)
2588 //Con_Printf("Could not find a working Cg shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
2589 r_cg_permutation = R_CG_FindPermutation(mode, permutation);
2590 return; // no bit left to clear, entire mode is broken
2596 if (r_cg_permutation->vprogram)
2598 //cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
2599 cgGLBindProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR
2600 //cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
2604 //cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
2605 cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR
2607 if (r_cg_permutation->fprogram)
2609 //cgGLLoadProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
2610 cgGLBindProgram(r_cg_permutation->fprogram);CHECKCGERROR CHECKGLERROR
2611 //cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
2615 //cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
2616 cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR
2620 if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
2623 void CG_BindTexture(CGparameter param, int texnum)
2625 cgGLSetTextureParameter(param, texnum);
2626 cgGLEnableTextureParameter(param);
2630 void R_GLSL_Restart_f(void)
2632 unsigned int i, limit;
2633 switch(vid.renderpath)
2635 case RENDERPATH_GL20:
2637 r_glsl_permutation_t *p;
2638 limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
2639 for (i = 0;i < limit;i++)
2641 if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
2643 GL_Backend_FreeProgram(p->program);
2644 Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
2647 memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
2650 case RENDERPATH_CGGL:
2653 r_cg_permutation_t *p;
2654 limit = Mem_ExpandableArray_IndexRange(&r_cg_permutationarray);
2655 for (i = 0;i < limit;i++)
2657 if ((p = (r_cg_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_cg_permutationarray, i)))
2660 cgDestroyProgram(p->vprogram);
2662 cgDestroyProgram(p->fprogram);
2663 Mem_ExpandableArray_FreeRecord(&r_cg_permutationarray, (void*)p);
2667 memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
2670 case RENDERPATH_GL13:
2671 case RENDERPATH_GL11:
2676 void R_GLSL_DumpShader_f(void)
2681 file = FS_OpenRealFile("glsl/default.glsl", "w", false);
2684 FS_Print(file, "/* The engine may define the following macros:\n");
2685 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
2686 for (i = 0;i < SHADERMODE_COUNT;i++)
2687 FS_Print(file, glslshadermodeinfo[i].pretext);
2688 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2689 FS_Print(file, shaderpermutationinfo[i].pretext);
2690 FS_Print(file, "*/\n");
2691 FS_Print(file, builtinshaderstring);
2693 Con_Printf("glsl/default.glsl written\n");
2696 Con_Printf("failed to write to glsl/default.glsl\n");
2699 file = FS_OpenRealFile("cg/default.cg", "w", false);
2702 FS_Print(file, "/* The engine may define the following macros:\n");
2703 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
2704 for (i = 0;i < SHADERMODE_COUNT;i++)
2705 FS_Print(file, cgshadermodeinfo[i].pretext);
2706 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
2707 FS_Print(file, shaderpermutationinfo[i].pretext);
2708 FS_Print(file, "*/\n");
2709 FS_Print(file, builtincgshaderstring);
2711 Con_Printf("cg/default.cg written\n");
2714 Con_Printf("failed to write to cg/default.cg\n");
2718 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale)
2721 texturemode = GL_MODULATE;
2722 switch (vid.renderpath)
2724 case RENDERPATH_GL20:
2725 R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
2726 if (r_glsl_permutation->loc_Texture_First ) R_Mesh_TexBind(GL20TU_FIRST , R_GetTexture(first ));
2727 if (r_glsl_permutation->loc_Texture_Second) R_Mesh_TexBind(GL20TU_SECOND, R_GetTexture(second));
2729 case RENDERPATH_CGGL:
2732 R_SetupShader_SetPermutationCG(SHADERMODE_GENERIC, (first ? SHADERPERMUTATION_DIFFUSE : 0) | (second ? SHADERPERMUTATION_SPECULAR : 0) | (r_shadow_glossexact.integer ? SHADERPERMUTATION_EXACTSPECULARMATH : 0) | (texturemode == GL_MODULATE ? SHADERPERMUTATION_COLORMAPPING : (texturemode == GL_ADD ? SHADERPERMUTATION_GLOW : (texturemode == GL_DECAL ? SHADERPERMUTATION_VERTEXTEXTUREBLEND : 0))));
2733 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , R_GetTexture(first ));CHECKCGERROR
2734 if (r_cg_permutation->fp_Texture_Second) CG_BindTexture(r_cg_permutation->fp_Texture_Second, R_GetTexture(second));CHECKCGERROR
2737 case RENDERPATH_GL13:
2738 R_Mesh_TexBind(0, R_GetTexture(first ));
2739 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
2740 R_Mesh_TexBind(1, R_GetTexture(second));
2742 R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
2744 case RENDERPATH_GL11:
2745 R_Mesh_TexBind(0, R_GetTexture(first ));
2750 void R_SetupShader_DepthOrShadow(void)
2752 switch (vid.renderpath)
2754 case RENDERPATH_GL20:
2755 R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, 0);
2757 case RENDERPATH_CGGL:
2759 R_SetupShader_SetPermutationCG(SHADERMODE_DEPTH_OR_SHADOW, 0);
2762 case RENDERPATH_GL13:
2763 R_Mesh_TexBind(0, 0);
2764 R_Mesh_TexBind(1, 0);
2766 case RENDERPATH_GL11:
2767 R_Mesh_TexBind(0, 0);
2772 void R_SetupShader_ShowDepth(void)
2774 switch (vid.renderpath)
2776 case RENDERPATH_GL20:
2777 R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, 0);
2779 case RENDERPATH_CGGL:
2781 R_SetupShader_SetPermutationCG(SHADERMODE_SHOWDEPTH, 0);
2784 case RENDERPATH_GL13:
2786 case RENDERPATH_GL11:
2791 extern qboolean r_shadow_usingdeferredprepass;
2792 extern cvar_t r_shadow_deferred_8bitrange;
2793 extern rtexture_t *r_shadow_attenuationgradienttexture;
2794 extern rtexture_t *r_shadow_attenuation2dtexture;
2795 extern rtexture_t *r_shadow_attenuation3dtexture;
2796 extern qboolean r_shadow_usingshadowmaprect;
2797 extern qboolean r_shadow_usingshadowmapcube;
2798 extern qboolean r_shadow_usingshadowmap2d;
2799 extern float r_shadow_shadowmap_texturescale[2];
2800 extern float r_shadow_shadowmap_parameters[4];
2801 extern qboolean r_shadow_shadowmapvsdct;
2802 extern qboolean r_shadow_shadowmapsampler;
2803 extern int r_shadow_shadowmappcf;
2804 extern rtexture_t *r_shadow_shadowmaprectangletexture;
2805 extern rtexture_t *r_shadow_shadowmap2dtexture;
2806 extern rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
2807 extern rtexture_t *r_shadow_shadowmapvsdcttexture;
2808 extern int r_shadow_shadowmaplod; // changes for each light based on distance
2809 extern int r_shadow_prepass_width;
2810 extern int r_shadow_prepass_height;
2811 extern rtexture_t *r_shadow_prepassgeometrydepthtexture;
2812 extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
2813 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
2814 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
2815 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass)
2817 // select a permutation of the lighting shader appropriate to this
2818 // combination of texture, entity, light source, and fogging, only use the
2819 // minimum features necessary to avoid wasting rendering time in the
2820 // fragment shader on features that are not being used
2821 unsigned int permutation = 0;
2822 unsigned int mode = 0;
2824 // TODO: implement geometry-shader based shadow volumes someday
2825 if (r_glsl_offsetmapping.integer)
2827 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
2828 if (r_glsl_offsetmapping_reliefmapping.integer)
2829 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
2831 if (rsurfacepass == RSURFPASS_BACKGROUND)
2833 // distorted background
2834 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
2835 mode = SHADERMODE_WATER;
2837 mode = SHADERMODE_REFRACTION;
2839 else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
2841 // normalmap (deferred prepass), may use alpha test on diffuse
2842 mode = SHADERMODE_DEFERREDGEOMETRY;
2843 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2844 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2845 if (r_glsl_offsetmapping.integer)
2847 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
2848 if (r_glsl_offsetmapping_reliefmapping.integer)
2849 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
2852 else if (rsurfacepass == RSURFPASS_RTLIGHT)
2855 mode = SHADERMODE_LIGHTSOURCE;
2856 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2857 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2858 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2859 permutation |= SHADERPERMUTATION_CUBEFILTER;
2860 if (diffusescale > 0)
2861 permutation |= SHADERPERMUTATION_DIFFUSE;
2862 if (specularscale > 0)
2863 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2864 if (r_refdef.fogenabled)
2865 permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2866 if (rsurface.texture->colormapping)
2867 permutation |= SHADERPERMUTATION_COLORMAPPING;
2868 if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
2870 if (r_shadow_usingshadowmaprect)
2871 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
2872 if (r_shadow_usingshadowmap2d)
2873 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
2874 if (r_shadow_usingshadowmapcube)
2875 permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
2876 else if(r_shadow_shadowmapvsdct)
2877 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
2879 if (r_shadow_shadowmapsampler)
2880 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
2881 if (r_shadow_shadowmappcf > 1)
2882 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
2883 else if (r_shadow_shadowmappcf)
2884 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
2887 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
2889 // unshaded geometry (fullbright or ambient model lighting)
2890 mode = SHADERMODE_FLATCOLOR;
2891 ambientscale = diffusescale = specularscale = 0;
2892 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2893 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2894 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2895 permutation |= SHADERPERMUTATION_GLOW;
2896 if (r_refdef.fogenabled)
2897 permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2898 if (rsurface.texture->colormapping)
2899 permutation |= SHADERPERMUTATION_COLORMAPPING;
2900 if (r_glsl_offsetmapping.integer)
2902 permutation |= SHADERPERMUTATION_OFFSETMAPPING;
2903 if (r_glsl_offsetmapping_reliefmapping.integer)
2904 permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;
2906 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2907 permutation |= SHADERPERMUTATION_REFLECTION;
2909 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
2911 // directional model lighting
2912 mode = SHADERMODE_LIGHTDIRECTION;
2913 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2914 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2915 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2916 permutation |= SHADERPERMUTATION_GLOW;
2917 permutation |= SHADERPERMUTATION_DIFFUSE;
2918 if (specularscale > 0)
2919 permutation |= SHADERPERMUTATION_SPECULAR;
2920 if (r_refdef.fogenabled)
2921 permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2922 if (rsurface.texture->colormapping)
2923 permutation |= SHADERPERMUTATION_COLORMAPPING;
2924 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2925 permutation |= SHADERPERMUTATION_REFLECTION;
2926 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2927 permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2929 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
2931 // ambient model lighting
2932 mode = SHADERMODE_LIGHTDIRECTION;
2933 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2934 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2935 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2936 permutation |= SHADERPERMUTATION_GLOW;
2937 if (r_refdef.fogenabled)
2938 permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2939 if (rsurface.texture->colormapping)
2940 permutation |= SHADERPERMUTATION_COLORMAPPING;
2941 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2942 permutation |= SHADERPERMUTATION_REFLECTION;
2943 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2944 permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2949 if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
2951 // deluxemapping (light direction texture)
2952 if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
2953 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
2955 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
2956 permutation |= SHADERPERMUTATION_DIFFUSE;
2957 if (specularscale > 0)
2958 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2960 else if (r_glsl_deluxemapping.integer >= 2)
2962 // fake deluxemapping (uniform light direction in tangentspace)
2963 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
2964 permutation |= SHADERPERMUTATION_DIFFUSE;
2965 if (specularscale > 0)
2966 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2968 else if (rsurface.uselightmaptexture)
2970 // ordinary lightmapping (q1bsp, q3bsp)
2971 mode = SHADERMODE_LIGHTMAP;
2975 // ordinary vertex coloring (q3bsp)
2976 mode = SHADERMODE_VERTEXCOLOR;
2978 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2979 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2980 if (rsurface.texture->glowtexture && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2981 permutation |= SHADERPERMUTATION_GLOW;
2982 if (r_refdef.fogenabled)
2983 permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE;
2984 if (rsurface.texture->colormapping)
2985 permutation |= SHADERPERMUTATION_COLORMAPPING;
2986 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2987 permutation |= SHADERPERMUTATION_REFLECTION;
2988 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2989 permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2991 if(permutation & SHADERPERMUTATION_SPECULAR)
2992 if(r_shadow_glossexact.integer)
2993 permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
2994 if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) && r_shadow_usingdeferredprepass)
2995 permutation |= SHADERPERMUTATION_ALPHAKILL;
2996 switch(vid.renderpath)
2998 case RENDERPATH_GL20:
2999 R_SetupShader_SetPermutationGLSL(mode, permutation);
3000 if (mode == SHADERMODE_LIGHTSOURCE)
3002 if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
3003 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
3004 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
3005 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, rsurface.colormod[0] * ambientscale, rsurface.colormod[1] * ambientscale, rsurface.colormod[2] * ambientscale);
3006 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, rsurface.colormod[0] * diffusescale, rsurface.colormod[1] * diffusescale, rsurface.colormod[2] * diffusescale);
3007 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, specularscale, specularscale, specularscale);
3009 // additive passes are only darkened by fog, not tinted
3010 if (r_glsl_permutation->loc_FogColor >= 0)
3011 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
3012 if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2fARB(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
3013 if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
3014 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
3018 if (mode == SHADERMODE_FLATCOLOR)
3020 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2]);
3022 else if (mode == SHADERMODE_LIGHTDIRECTION)
3024 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * rsurface.colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * rsurface.colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * rsurface.colormod[2]);
3025 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, r_refdef.lightmapintensity, r_refdef.lightmapintensity, r_refdef.lightmapintensity);
3026 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);
3027 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, rsurface.colormod[0] * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * r_shadow_deferred_8bitrange.value);
3028 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
3029 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);
3030 if (r_glsl_permutation->loc_LightDir >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
3034 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Ambient, r_refdef.scene.ambient * rsurface.colormod[0], r_refdef.scene.ambient * rsurface.colormod[1], r_refdef.scene.ambient * rsurface.colormod[2]);
3035 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
3036 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);
3037 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Diffuse, rsurface.colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);
3038 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3fARB(r_glsl_permutation->loc_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);
3040 // additive passes are only darkened by fog, not tinted
3041 if (r_glsl_permutation->loc_FogColor >= 0)
3043 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
3044 qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0);
3046 qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
3048 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);
3049 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]);
3050 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]);
3051 if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_RefractColor, 1, rsurface.texture->refractcolor4f);
3052 if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4fvARB(r_glsl_permutation->loc_ReflectColor, 1, rsurface.texture->reflectcolor4f);
3053 if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
3054 if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1fARB(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
3055 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
3057 if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
3058 if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
3059 if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
3060 if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
3061 if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3]);
3062 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
3063 if (r_glsl_permutation->loc_Color_Pants >= 0)
3065 if (rsurface.texture->pantstexture)
3066 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
3068 qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
3070 if (r_glsl_permutation->loc_Color_Shirt >= 0)
3072 if (rsurface.texture->shirttexture)
3073 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
3075 qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
3077 if (r_glsl_permutation->loc_FogPlane >= 0) qglUniform4fARB(r_glsl_permutation->loc_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
3078 if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
3079 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
3080 if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
3081 if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);
3082 if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2fARB(r_glsl_permutation->loc_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
3084 // if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST , R_GetTexture(r_texture_white ));
3085 // if (r_glsl_permutation->loc_Texture_Second >= 0) R_Mesh_TexBind(GL20TU_SECOND , R_GetTexture(r_texture_white ));
3086 // if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS , R_GetTexture(r_texture_gammaramps ));
3087 if (r_glsl_permutation->loc_Texture_Normal >= 0) R_Mesh_TexBind(GL20TU_NORMAL , R_GetTexture(rsurface.texture->nmaptexture ));
3088 if (r_glsl_permutation->loc_Texture_Color >= 0) R_Mesh_TexBind(GL20TU_COLOR , R_GetTexture(rsurface.texture->basetexture ));
3089 if (r_glsl_permutation->loc_Texture_Gloss >= 0) R_Mesh_TexBind(GL20TU_GLOSS , R_GetTexture(rsurface.texture->glosstexture ));
3090 if (r_glsl_permutation->loc_Texture_Glow >= 0) R_Mesh_TexBind(GL20TU_GLOW , R_GetTexture(rsurface.texture->glowtexture ));
3091 if (r_glsl_permutation->loc_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL , R_GetTexture(rsurface.texture->backgroundnmaptexture ));
3092 if (r_glsl_permutation->loc_Texture_SecondaryColor >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR , R_GetTexture(rsurface.texture->backgroundbasetexture ));
3093 if (r_glsl_permutation->loc_Texture_SecondaryGloss >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS , R_GetTexture(rsurface.texture->backgroundglosstexture ));
3094 if (r_glsl_permutation->loc_Texture_SecondaryGlow >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW , R_GetTexture(rsurface.texture->backgroundglowtexture ));
3095 if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(GL20TU_PANTS , R_GetTexture(rsurface.texture->pantstexture ));
3096 if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(GL20TU_SHIRT , R_GetTexture(rsurface.texture->shirttexture ));
3097 if (r_glsl_permutation->loc_Texture_FogMask >= 0) R_Mesh_TexBind(GL20TU_FOGMASK , R_GetTexture(r_texture_fogattenuation ));
3098 if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , R_GetTexture(r_texture_white ));
3099 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , R_GetTexture(r_texture_blanknormalmap ));
3100 if (r_glsl_permutation->loc_Texture_Attenuation >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION , R_GetTexture(r_shadow_attenuationgradienttexture ));
3101 if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION , R_GetTexture(r_texture_white ));
3102 if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION , R_GetTexture(r_texture_white ));
3103 if (r_glsl_permutation->loc_Texture_ScreenDepth >= 0) R_Mesh_TexBindAll(GL20TU_SCREENDEPTH , 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrydepthtexture ));
3104 if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBindAll(GL20TU_SCREENNORMALMAP, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture ));
3105 if (r_glsl_permutation->loc_Texture_ScreenDiffuse >= 0) R_Mesh_TexBindAll(GL20TU_SCREENDIFFUSE , 0, 0, 0, R_GetTexture(r_shadow_prepasslightingdiffusetexture ));
3106 if (r_glsl_permutation->loc_Texture_ScreenSpecular >= 0) R_Mesh_TexBindAll(GL20TU_SCREENSPECULAR , 0, 0, 0, R_GetTexture(r_shadow_prepasslightingspeculartexture ));
3107 if (rsurface.rtlight)
3109 if (r_glsl_permutation->loc_Texture_Cube >= 0) R_Mesh_TexBindAll(GL20TU_CUBE , 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap ), 0);
3110 if (r_glsl_permutation->loc_Texture_ShadowMapRect >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPRECT , 0, 0, 0, R_GetTexture(r_shadow_shadowmaprectangletexture ));
3111 if (r_shadow_usingshadowmapcube)
3112 if (r_glsl_permutation->loc_Texture_ShadowMapCube >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPCUBE , 0, 0, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);
3113 if (r_glsl_permutation->loc_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D , R_GetTexture(r_shadow_shadowmap2dtexture ));
3114 if (r_glsl_permutation->loc_Texture_CubeProjection >= 0) R_Mesh_TexBindAll(GL20TU_CUBEPROJECTION , 0, 0, R_GetTexture(r_shadow_shadowmapvsdcttexture ), 0);
3118 case RENDERPATH_CGGL:
3120 R_SetupShader_SetPermutationCG(mode, permutation);
3121 if (mode == SHADERMODE_LIGHTSOURCE)
3123 if (r_cg_permutation->vp_ModelToLight) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelToLight, m16f);}CHECKCGERROR
3124 if (r_cg_permutation->vp_LightPosition) cgGLSetParameter3f(r_cg_permutation->vp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
3128 if (mode == SHADERMODE_LIGHTDIRECTION)
3130 if (r_cg_permutation->vp_LightDir) cgGLSetParameter3f(r_cg_permutation->vp_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);CHECKCGERROR
3133 if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelviewprojection16f);CHECKCGERROR
3134 if (r_cg_permutation->vp_TexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_TexMatrix, m16f);}CHECKCGERROR
3135 if (r_cg_permutation->vp_BackgroundTexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_BackgroundTexMatrix, m16f);}CHECKCGERROR
3136 if (r_cg_permutation->vp_EyePosition) cgGLSetParameter3f(r_cg_permutation->vp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
3137 if (r_cg_permutation->vp_FogPlane) cgGLSetParameter4f(r_cg_permutation->vp_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);CHECKCGERROR
3140 if (mode == SHADERMODE_LIGHTSOURCE)
3142 if (r_cg_permutation->fp_LightPosition) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);CHECKCGERROR
3143 if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);CHECKCGERROR
3144 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, rsurface.colormod[0] * ambientscale, rsurface.colormod[1] * ambientscale, rsurface.colormod[2] * ambientscale);CHECKCGERROR
3145 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, rsurface.colormod[0] * diffusescale, rsurface.colormod[1] * diffusescale, rsurface.colormod[2] * diffusescale);CHECKCGERROR
3146 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, specularscale, specularscale, specularscale);CHECKCGERROR
3148 // additive passes are only darkened by fog, not tinted
3149 if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR
3150 if (r_cg_permutation->fp_ShadowMap_TextureScale) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR
3151 if (r_cg_permutation->fp_ShadowMap_Parameters) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR
3152 if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
3156 if (mode == SHADERMODE_FLATCOLOR)
3158 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2]);CHECKCGERROR
3160 else if (mode == SHADERMODE_LIGHTDIRECTION)
3162 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * rsurface.colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * rsurface.colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * rsurface.colormod[2]);CHECKCGERROR
3163 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, r_refdef.lightmapintensity, r_refdef.lightmapintensity, r_refdef.lightmapintensity);CHECKCGERROR
3164 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);CHECKCGERROR
3165 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, rsurface.colormod[0] * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3166 if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3167 if (r_cg_permutation->fp_LightColor) cgGLSetParameter3f(r_cg_permutation->fp_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);CHECKCGERROR
3168 if (r_cg_permutation->fp_LightDir) cgGLSetParameter3f(r_cg_permutation->fp_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);CHECKCGERROR
3172 if (r_cg_permutation->fp_Color_Ambient) cgGLSetParameter3f(r_cg_permutation->fp_Color_Ambient, r_refdef.scene.ambient * rsurface.colormod[0], r_refdef.scene.ambient * rsurface.colormod[1], r_refdef.scene.ambient * rsurface.colormod[2]);CHECKCGERROR
3173 if (r_cg_permutation->fp_Color_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);CHECKCGERROR
3174 if (r_cg_permutation->fp_Color_Specular) cgGLSetParameter3f(r_cg_permutation->fp_Color_Specular, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale, r_refdef.lightmapintensity * specularscale);CHECKCGERROR
3175 if (r_cg_permutation->fp_DeferredMod_Diffuse) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Diffuse, rsurface.colormod[0] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[1] * diffusescale * r_shadow_deferred_8bitrange.value, rsurface.colormod[2] * diffusescale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3176 if (r_cg_permutation->fp_DeferredMod_Specular) cgGLSetParameter3f(r_cg_permutation->fp_DeferredMod_Specular, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value, specularscale * r_shadow_deferred_8bitrange.value);CHECKCGERROR
3178 // additive passes are only darkened by fog, not tinted
3179 if (r_cg_permutation->fp_FogColor)
3181 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
3182 cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);
3184 cgGLSetParameter3f(r_cg_permutation->fp_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
3187 if (r_cg_permutation->fp_DistortScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_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);CHECKCGERROR
3188 if (r_cg_permutation->fp_ScreenScaleRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenScaleRefractReflect, r_waterstate.screenscale[0], r_waterstate.screenscale[1], r_waterstate.screenscale[0], r_waterstate.screenscale[1]);CHECKCGERROR
3189 if (r_cg_permutation->fp_ScreenCenterRefractReflect) cgGLSetParameter4f(r_cg_permutation->fp_ScreenCenterRefractReflect, r_waterstate.screencenter[0], r_waterstate.screencenter[1], r_waterstate.screencenter[0], r_waterstate.screencenter[1]);CHECKCGERROR
3190 if (r_cg_permutation->fp_RefractColor) cgGLSetParameter4fv(r_cg_permutation->fp_RefractColor, rsurface.texture->refractcolor4f);CHECKCGERROR
3191 if (r_cg_permutation->fp_ReflectColor) cgGLSetParameter4fv(r_cg_permutation->fp_ReflectColor, rsurface.texture->reflectcolor4f);CHECKCGERROR
3192 if (r_cg_permutation->fp_ReflectFactor) cgGLSetParameter1f(r_cg_permutation->fp_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);CHECKCGERROR
3193 if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR
3194 if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
3196 if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR
3197 if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3]);CHECKCGERROR
3198 if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR
3199 if (r_cg_permutation->fp_Color_Pants)
3201 if (rsurface.texture->pantstexture)
3202 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
3204 cgGLSetParameter3f(r_cg_permutation->fp_Color_Pants, 0, 0, 0);
3207 if (r_cg_permutation->fp_Color_Shirt)
3209 if (rsurface.texture->shirttexture)
3210 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
3212 cgGLSetParameter3f(r_cg_permutation->fp_Color_Shirt, 0, 0, 0);
3215 if (r_cg_permutation->fp_FogPlane) cgGLSetParameter4f(r_cg_permutation->fp_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);CHECKCGERROR
3216 if (r_cg_permutation->fp_FogPlaneViewDist) cgGLSetParameter1f(r_cg_permutation->fp_FogPlaneViewDist, rsurface.fogplaneviewdist);CHECKCGERROR
3217 if (r_cg_permutation->fp_FogRangeRecip) cgGLSetParameter1f(r_cg_permutation->fp_FogRangeRecip, rsurface.fograngerecip);CHECKCGERROR
3218 if (r_cg_permutation->fp_FogHeightFade) cgGLSetParameter1f(r_cg_permutation->fp_FogHeightFade, rsurface.fogheightfade);CHECKCGERROR
3219 if (r_cg_permutation->fp_OffsetMapping_Scale) cgGLSetParameter1f(r_cg_permutation->fp_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);CHECKCGERROR
3220 if (r_cg_permutation->fp_ScreenToDepth) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR
3222 // if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , R_GetTexture(r_texture_white ));CHECKCGERROR
3223 // if (r_cg_permutation->fp_Texture_Second ) CG_BindTexture(r_cg_permutation->fp_Texture_Second , R_GetTexture(r_texture_white ));CHECKCGERROR
3224 // if (r_cg_permutation->fp_Texture_GammaRamps ) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps , R_GetTexture(r_texture_gammaramps ));CHECKCGERROR
3225 if (r_cg_permutation->fp_Texture_Normal ) CG_BindTexture(r_cg_permutation->fp_Texture_Normal , R_GetTexture(rsurface.texture->nmaptexture ));CHECKCGERROR
3226 if (r_cg_permutation->fp_Texture_Color ) CG_BindTexture(r_cg_permutation->fp_Texture_Color , R_GetTexture(rsurface.texture->basetexture ));CHECKCGERROR
3227 if (r_cg_permutation->fp_Texture_Gloss ) CG_BindTexture(r_cg_permutation->fp_Texture_Gloss , R_GetTexture(rsurface.texture->glosstexture ));CHECKCGERROR
3228 if (r_cg_permutation->fp_Texture_Glow ) CG_BindTexture(r_cg_permutation->fp_Texture_Glow , R_GetTexture(rsurface.texture->glowtexture ));CHECKCGERROR
3229 if (r_cg_permutation->fp_Texture_SecondaryNormal) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryNormal, R_GetTexture(rsurface.texture->backgroundnmaptexture ));CHECKCGERROR
3230 if (r_cg_permutation->fp_Texture_SecondaryColor ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryColor , R_GetTexture(rsurface.texture->backgroundbasetexture ));CHECKCGERROR
3231 if (r_cg_permutation->fp_Texture_SecondaryGloss ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGloss , R_GetTexture(rsurface.texture->backgroundglosstexture ));CHECKCGERROR
3232 if (r_cg_permutation->fp_Texture_SecondaryGlow ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGlow , R_GetTexture(rsurface.texture->backgroundglowtexture ));CHECKCGERROR
3233 if (r_cg_permutation->fp_Texture_Pants ) CG_BindTexture(r_cg_permutation->fp_Texture_Pants , R_GetTexture(rsurface.texture->pantstexture ));CHECKCGERROR
3234 if (r_cg_permutation->fp_Texture_Shirt ) CG_BindTexture(r_cg_permutation->fp_Texture_Shirt , R_GetTexture(rsurface.texture->shirttexture ));CHECKCGERROR
3235 if (r_cg_permutation->fp_Texture_FogMask ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask , R_GetTexture(r_texture_fogattenuation ));CHECKCGERROR
3236 if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , R_GetTexture(r_texture_white ));CHECKCGERROR
3237 if (r_cg_permutation->fp_Texture_Deluxemap ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap , R_GetTexture(r_texture_blanknormalmap ));CHECKCGERROR
3238 if (r_cg_permutation->fp_Texture_Attenuation ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation , R_GetTexture(r_shadow_attenuationgradienttexture ));CHECKCGERROR
3239 if (r_cg_permutation->fp_Texture_Refraction ) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction , R_GetTexture(r_texture_white ));CHECKCGERROR
3240 if (r_cg_permutation->fp_Texture_Reflection ) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection , R_GetTexture(r_texture_white ));CHECKCGERROR
3241 if (r_cg_permutation->fp_Texture_ScreenDepth ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth , R_GetTexture(r_shadow_prepassgeometrydepthtexture ));CHECKCGERROR
3242 if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture ));CHECKCGERROR
3243 if (r_cg_permutation->fp_Texture_ScreenDiffuse ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse , R_GetTexture(r_shadow_prepasslightingdiffusetexture ));CHECKCGERROR
3244 if (r_cg_permutation->fp_Texture_ScreenSpecular ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenSpecular , R_GetTexture(r_shadow_prepasslightingspeculartexture ));CHECKCGERROR
3245 if (rsurface.rtlight)
3247 if (r_cg_permutation->fp_Texture_Cube ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube , R_GetTexture(rsurface.rtlight->currentcubemap ));CHECKCGERROR
3248 if (r_cg_permutation->fp_Texture_ShadowMapRect ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect , R_GetTexture(r_shadow_shadowmaprectangletexture ));CHECKCGERROR
3249 if (r_shadow_usingshadowmapcube)
3250 if (r_cg_permutation->fp_Texture_ShadowMapCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube , R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]));CHECKCGERROR
3251 if (r_cg_permutation->fp_Texture_ShadowMap2D ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D , R_GetTexture(r_shadow_shadowmap2dtexture ));CHECKCGERROR
3252 if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , R_GetTexture(r_shadow_shadowmapvsdcttexture ));CHECKCGERROR
3258 case RENDERPATH_GL13:
3259 case RENDERPATH_GL11:
3264 void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
3266 // select a permutation of the lighting shader appropriate to this
3267 // combination of texture, entity, light source, and fogging, only use the
3268 // minimum features necessary to avoid wasting rendering time in the
3269 // fragment shader on features that are not being used
3270 unsigned int permutation = 0;
3271 unsigned int mode = 0;
3272 const float *lightcolorbase = rtlight->currentcolor;
3273 float ambientscale = rtlight->ambientscale;
3274 float diffusescale = rtlight->diffusescale;
3275 float specularscale = rtlight->specularscale;
3276 // this is the location of the light in view space
3277 vec3_t viewlightorigin;
3278 // this transforms from view space (camera) to light space (cubemap)
3279 matrix4x4_t viewtolight;
3280 matrix4x4_t lighttoview;
3281 float viewtolight16f[16];
3282 float range = 1.0f / r_shadow_deferred_8bitrange.value;
3284 mode = SHADERMODE_DEFERREDLIGHTSOURCE;
3285 if (rtlight->currentcubemap != r_texture_whitecube)
3286 permutation |= SHADERPERMUTATION_CUBEFILTER;
3287 if (diffusescale > 0)
3288 permutation |= SHADERPERMUTATION_DIFFUSE;
3289 if (specularscale > 0)
3291 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
3292 if (r_shadow_glossexact.integer)
3293 permutation |= SHADERPERMUTATION_EXACTSPECULARMATH;
3295 if (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d || r_shadow_usingshadowmapcube)
3297 if (r_shadow_usingshadowmaprect)
3298 permutation |= SHADERPERMUTATION_SHADOWMAPRECT;
3299 if (r_shadow_usingshadowmap2d)
3300 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
3301 if (r_shadow_usingshadowmapcube)
3302 permutation |= SHADERPERMUTATION_SHADOWMAPCUBE;
3303 else if(r_shadow_shadowmapvsdct)
3304 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
3306 if (r_shadow_shadowmapsampler)
3307 permutation |= SHADERPERMUTATION_SHADOWSAMPLER;
3308 if (r_shadow_shadowmappcf > 1)
3309 permutation |= SHADERPERMUTATION_SHADOWMAPPCF2;
3310 else if (r_shadow_shadowmappcf)
3311 permutation |= SHADERPERMUTATION_SHADOWMAPPCF;
3313 Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
3314 Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
3315 Matrix4x4_Invert_Simple(&viewtolight, &lighttoview);
3316 Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
3317 switch(vid.renderpath)
3319 case RENDERPATH_GL20:
3320 R_SetupShader_SetPermutationGLSL(mode, permutation);
3321 if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
3322 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB( r_glsl_permutation->loc_LightPosition , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
3323 if (r_glsl_permutation->loc_ViewToLight >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ViewToLight , 1, false, viewtolight16f);
3324 if (r_glsl_permutation->loc_DeferredColor_Ambient >= 0) qglUniform3fARB( r_glsl_permutation->loc_DeferredColor_Ambient , lightcolorbase[0] * ambientscale * range, lightcolorbase[1] * ambientscale * range, lightcolorbase[2] * ambientscale * range);
3325 if (r_glsl_permutation->loc_DeferredColor_Diffuse >= 0) qglUniform3fARB( r_glsl_permutation->loc_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale * range, lightcolorbase[1] * diffusescale * range, lightcolorbase[2] * diffusescale * range);
3326 if (r_glsl_permutation->loc_DeferredColor_Specular >= 0) qglUniform3fARB( r_glsl_permutation->loc_DeferredColor_Specular , lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);
3327 if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2fARB( r_glsl_permutation->loc_ShadowMap_TextureScale , r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
3328 if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB( r_glsl_permutation->loc_ShadowMap_Parameters , r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
3329 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB( r_glsl_permutation->loc_SpecularPower , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));
3330 if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2fARB( r_glsl_permutation->loc_ScreenToDepth , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
3332 if (r_glsl_permutation->loc_Texture_Attenuation >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION , R_GetTexture(r_shadow_attenuationgradienttexture ));
3333 if (r_glsl_permutation->loc_Texture_ScreenDepth >= 0) R_Mesh_TexBindAll(GL20TU_SCREENDEPTH , 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrydepthtexture ));
3334 if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBindAll(GL20TU_SCREENNORMALMAP, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture ));
3335 if (r_glsl_permutation->loc_Texture_Cube >= 0) R_Mesh_TexBindAll(GL20TU_CUBE , 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap ), 0);
3336 if (r_glsl_permutation->loc_Texture_ShadowMapRect >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPRECT , 0, 0, 0, R_GetTexture(r_shadow_shadowmaprectangletexture ));
3337 if (r_shadow_usingshadowmapcube)
3338 if (r_glsl_permutation->loc_Texture_ShadowMapCube >= 0) R_Mesh_TexBindAll(GL20TU_SHADOWMAPCUBE , 0, 0, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);
3339 if (r_glsl_permutation->loc_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D , R_GetTexture(r_shadow_shadowmap2dtexture ));
3340 if (r_glsl_permutation->loc_Texture_CubeProjection >= 0) R_Mesh_TexBindAll(GL20TU_CUBEPROJECTION , 0, 0, R_GetTexture(r_shadow_shadowmapvsdcttexture ), 0);
3342 case RENDERPATH_CGGL:
3344 R_SetupShader_SetPermutationCG(mode, permutation);
3345 if (r_cg_permutation->vp_ModelViewMatrix ) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelviewprojection16f);CHECKCGERROR
3346 if (r_cg_permutation->fp_LightPosition ) cgGLSetParameter3f(r_cg_permutation->fp_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);CHECKCGERROR
3347 if (r_cg_permutation->fp_ViewToLight ) cgGLSetMatrixParameterfc(r_cg_permutation->fp_ViewToLight, viewtolight16f);CHECKCGERROR
3348 if (r_cg_permutation->fp_DeferredColor_Ambient ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Ambient , lightcolorbase[0] * ambientscale * range, lightcolorbase[1] * ambientscale * range, lightcolorbase[2] * ambientscale * range);CHECKCGERROR
3349 if (r_cg_permutation->fp_DeferredColor_Diffuse ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale * range, lightcolorbase[1] * diffusescale * range, lightcolorbase[2] * diffusescale * range);CHECKCGERROR
3350 if (r_cg_permutation->fp_DeferredColor_Specular ) cgGLSetParameter3f(r_cg_permutation->fp_DeferredColor_Specular, lightcolorbase[0] * specularscale * range, lightcolorbase[1] * specularscale * range, lightcolorbase[2] * specularscale * range);CHECKCGERROR
3351 if (r_cg_permutation->fp_ShadowMap_TextureScale ) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR
3352 if (r_cg_permutation->fp_ShadowMap_Parameters ) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR
3353 if (r_cg_permutation->fp_SpecularPower ) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR
3354 if (r_cg_permutation->fp_ScreenToDepth ) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR
3356 if (r_cg_permutation->fp_Texture_Attenuation ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation , R_GetTexture(r_shadow_attenuationgradienttexture ));CHECKCGERROR
3357 if (r_cg_permutation->fp_Texture_ScreenDepth ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth , R_GetTexture(r_shadow_prepassgeometrydepthtexture ));CHECKCGERROR
3358 if (r_cg_permutation->fp_Texture_ScreenNormalMap ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture ));CHECKCGERROR
3359 if (r_cg_permutation->fp_Texture_Cube ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube , R_GetTexture(rsurface.rtlight->currentcubemap ));CHECKCGERROR
3360 if (r_cg_permutation->fp_Texture_ShadowMapRect ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect , R_GetTexture(r_shadow_shadowmaprectangletexture ));CHECKCGERROR
3361 if (r_shadow_usingshadowmapcube)
3362 if (r_cg_permutation->fp_Texture_ShadowMapCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube , R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]));CHECKCGERROR
3363 if (r_cg_permutation->fp_Texture_ShadowMap2D ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D , R_GetTexture(r_shadow_shadowmap2dtexture ));CHECKCGERROR
3364 if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , R_GetTexture(r_shadow_shadowmapvsdcttexture ));CHECKCGERROR
3367 case RENDERPATH_GL13:
3368 case RENDERPATH_GL11:
3373 #define SKINFRAME_HASH 1024
3377 int loadsequence; // incremented each level change
3378 memexpandablearray_t array;
3379 skinframe_t *hash[SKINFRAME_HASH];
3382 r_skinframe_t r_skinframe;
3384 void R_SkinFrame_PrepareForPurge(void)
3386 r_skinframe.loadsequence++;
3387 // wrap it without hitting zero
3388 if (r_skinframe.loadsequence >= 200)
3389 r_skinframe.loadsequence = 1;
3392 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
3396 // mark the skinframe as used for the purging code
3397 skinframe->loadsequence = r_skinframe.loadsequence;
3400 void R_SkinFrame_Purge(void)
3404 for (i = 0;i < SKINFRAME_HASH;i++)
3406 for (s = r_skinframe.hash[i];s;s = s->next)
3408 if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
3410 if (s->merged == s->base)
3412 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
3413 R_PurgeTexture(s->stain );s->stain = NULL;
3414 R_PurgeTexture(s->merged);s->merged = NULL;
3415 R_PurgeTexture(s->base );s->base = NULL;
3416 R_PurgeTexture(s->pants );s->pants = NULL;
3417 R_PurgeTexture(s->shirt );s->shirt = NULL;
3418 R_PurgeTexture(s->nmap );s->nmap = NULL;
3419 R_PurgeTexture(s->gloss );s->gloss = NULL;
3420 R_PurgeTexture(s->glow );s->glow = NULL;
3421 R_PurgeTexture(s->fog );s->fog = NULL;
3422 s->loadsequence = 0;
3428 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
3430 char basename[MAX_QPATH];
3432 Image_StripImageExtension(name, basename, sizeof(basename));
3434 if( last == NULL ) {
3436 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
3437 item = r_skinframe.hash[hashindex];
3442 // linearly search through the hash bucket
3443 for( ; item ; item = item->next ) {
3444 if( !strcmp( item->basename, basename ) ) {
3451 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
3455 char basename[MAX_QPATH];
3457 Image_StripImageExtension(name, basename, sizeof(basename));
3459 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
3460 for (item = r_skinframe.hash[hashindex];item;item = item->next)
3461 if (!strcmp(item->basename, basename) && item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)
3465 rtexture_t *dyntexture;
3466 // check whether its a dynamic texture
3467 dyntexture = CL_GetDynTexture( basename );
3468 if (!add && !dyntexture)
3470 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
3471 memset(item, 0, sizeof(*item));
3472 strlcpy(item->basename, basename, sizeof(item->basename));
3473 item->base = dyntexture; // either NULL or dyntexture handle
3474 item->textureflags = textureflags;
3475 item->comparewidth = comparewidth;
3476 item->compareheight = compareheight;
3477 item->comparecrc = comparecrc;
3478 item->next = r_skinframe.hash[hashindex];
3479 r_skinframe.hash[hashindex] = item;
3481 else if( item->base == NULL )
3483 rtexture_t *dyntexture;
3484 // check whether its a dynamic texture
3485 // 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]
3486 dyntexture = CL_GetDynTexture( basename );
3487 item->base = dyntexture; // either NULL or dyntexture handle
3490 R_SkinFrame_MarkUsed(item);
3494 #define R_SKINFRAME_LOAD_AVERAGE_COLORS(cnt, getpixel) \
3496 unsigned long long avgcolor[5], wsum; \
3504 for(pix = 0; pix < cnt; ++pix) \
3507 for(comp = 0; comp < 3; ++comp) \
3509 if(w) /* ignore perfectly black pixels because that is better for model skins */ \
3512 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
3514 for(comp = 0; comp < 3; ++comp) \
3515 avgcolor[comp] += getpixel * w; \
3518 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
3519 avgcolor[4] += getpixel; \
3521 if(avgcolor[3] == 0) /* no pixels seen? even worse */ \
3523 skinframe->avgcolor[0] = avgcolor[2] / (255.0 * avgcolor[3]); \
3524 skinframe->avgcolor[1] = avgcolor[1] / (255.0 * avgcolor[3]); \
3525 skinframe->avgcolor[2] = avgcolor[0] / (255.0 * avgcolor[3]); \
3526 skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
3529 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
3532 unsigned char *pixels;
3533 unsigned char *bumppixels;
3534 unsigned char *basepixels = NULL;
3535 int basepixels_width;
3536 int basepixels_height;
3537 skinframe_t *skinframe;
3539 if (cls.state == ca_dedicated)
3542 // return an existing skinframe if already loaded
3543 // if loading of the first image fails, don't make a new skinframe as it
3544 // would cause all future lookups of this to be missing
3545 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
3546 if (skinframe && skinframe->base)
3549 basepixels = loadimagepixelsbgra(name, complain, true);
3550 if (basepixels == NULL)
3553 if (developer_loading.integer)
3554 Con_Printf("loading skin \"%s\"\n", name);
3556 // we've got some pixels to store, so really allocate this new texture now
3558 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
3559 skinframe->stain = NULL;
3560 skinframe->merged = NULL;
3561 skinframe->base = r_texture_notexture;
3562 skinframe->pants = NULL;
3563 skinframe->shirt = NULL;
3564 skinframe->nmap = r_texture_blanknormalmap;
3565 skinframe->gloss = NULL;
3566 skinframe->glow = NULL;
3567 skinframe->fog = NULL;
3568 skinframe->hasalpha = false;
3570 basepixels_width = image_width;
3571 basepixels_height = image_height;
3572 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);
3574 if (textureflags & TEXF_ALPHA)
3576 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
3578 if (basepixels[j] < 255)
3580 skinframe->hasalpha = true;
3584 if (r_loadfog && skinframe->hasalpha)
3586 // has transparent pixels
3587 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
3588 for (j = 0;j < image_width * image_height * 4;j += 4)
3593 pixels[j+3] = basepixels[j+3];
3595 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);
3600 R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
3601 //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3603 // _norm is the name used by tenebrae and has been adopted as standard
3604 if (r_loadnormalmap)
3606 if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL)
3608 skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
3612 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL)
3614 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
3615 Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
3616 skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
3618 Mem_Free(bumppixels);
3620 else if (r_shadow_bumpscale_basetexture.value > 0)
3622 pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
3623 Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
3624 skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL);
3628 // _luma is supported for tenebrae compatibility
3629 // (I think it's a very stupid name, but oh well)
3630 // _glow is the preferred name
3631 if ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false))) {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;}
3632 if (r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false))) {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;}
3633 if ((pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false))) {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;}
3634 if ((pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false))) {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;}
3637 Mem_Free(basepixels);
3642 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
3643 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height)
3646 unsigned char *temp1, *temp2;
3647 skinframe_t *skinframe;
3649 if (cls.state == ca_dedicated)
3652 // if already loaded just return it, otherwise make a new skinframe
3653 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height*4) : 0, true);
3654 if (skinframe && skinframe->base)
3657 skinframe->stain = NULL;
3658 skinframe->merged = NULL;
3659 skinframe->base = r_texture_notexture;
3660 skinframe->pants = NULL;
3661 skinframe->shirt = NULL;
3662 skinframe->nmap = r_texture_blanknormalmap;
3663 skinframe->gloss = NULL;
3664 skinframe->glow = NULL;
3665 skinframe->fog = NULL;
3666 skinframe->hasalpha = false;
3668 // if no data was provided, then clearly the caller wanted to get a blank skinframe
3672 if (developer_loading.integer)
3673 Con_Printf("loading 32bit skin \"%s\"\n", name);
3675 if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
3677 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
3678 temp2 = temp1 + width * height * 4;
3679 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
3680 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
3683 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_BGRA, skinframe->textureflags, NULL);
3684 if (textureflags & TEXF_ALPHA)
3686 for (i = 3;i < width * height * 4;i += 4)
3688 if (skindata[i] < 255)
3690 skinframe->hasalpha = true;
3694 if (r_loadfog && skinframe->hasalpha)
3696 unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
3697 memcpy(fogpixels, skindata, width * height * 4);
3698 for (i = 0;i < width * height * 4;i += 4)
3699 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
3700 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, skinframe->textureflags, NULL);
3701 Mem_Free(fogpixels);
3705 R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
3706 //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3711 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
3715 skinframe_t *skinframe;
3717 if (cls.state == ca_dedicated)
3720 // if already loaded just return it, otherwise make a new skinframe
3721 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
3722 if (skinframe && skinframe->base)
3725 skinframe->stain = NULL;
3726 skinframe->merged = NULL;
3727 skinframe->base = r_texture_notexture;
3728 skinframe->pants = NULL;
3729 skinframe->shirt = NULL;
3730 skinframe->nmap = r_texture_blanknormalmap;
3731 skinframe->gloss = NULL;
3732 skinframe->glow = NULL;
3733 skinframe->fog = NULL;
3734 skinframe->hasalpha = false;
3736 // if no data was provided, then clearly the caller wanted to get a blank skinframe
3740 if (developer_loading.integer)
3741 Con_Printf("loading quake skin \"%s\"\n", name);
3743 // we actually don't upload anything until the first use, because mdl skins frequently go unused, and are almost never used in both modes (colormapped and non-colormapped)
3744 skinframe->qpixels = Mem_Alloc(r_main_mempool, width*height);
3745 memcpy(skinframe->qpixels, skindata, width*height);
3746 skinframe->qwidth = width;
3747 skinframe->qheight = height;
3750 for (i = 0;i < width * height;i++)
3751 featuresmask |= palette_featureflags[skindata[i]];
3753 skinframe->hasalpha = false;
3754 skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
3755 skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
3756 skinframe->qgeneratemerged = true;
3757 skinframe->qgeneratebase = skinframe->qhascolormapping;
3758 skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
3760 R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
3761 //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3766 static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped)
3770 unsigned char *skindata;
3772 if (!skinframe->qpixels)
3775 if (!skinframe->qhascolormapping)
3776 colormapped = false;
3780 if (!skinframe->qgeneratebase)
3785 if (!skinframe->qgeneratemerged)
3789 width = skinframe->qwidth;
3790 height = skinframe->qheight;
3791 skindata = skinframe->qpixels;
3793 if (skinframe->qgeneratenmap)
3795 unsigned char *temp1, *temp2;
3796 skinframe->qgeneratenmap = false;
3797 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
3798 temp2 = temp1 + width * height * 4;
3799 // use either a custom palette or the quake palette
3800 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
3801 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
3802 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va("%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, skinframe->textureflags | TEXF_ALPHA, NULL);
3806 if (skinframe->qgenerateglow)
3808 skinframe->qgenerateglow = false;
3809 skinframe->glow = R_LoadTexture2D(r_main_texturepool, va("%s_glow", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_onlyfullbrights); // glow
3814 skinframe->qgeneratebase = false;
3815 skinframe->base = R_LoadTexture2D(r_main_texturepool, va("%s_nospecial", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, skinframe->glow ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap);
3816 skinframe->pants = R_LoadTexture2D(r_main_texturepool, va("%s_pants", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_pantsaswhite);
3817 skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va("%s_shirt", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette_bgra_shirtaswhite);
3821 skinframe->qgeneratemerged = false;
3822 skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, skinframe->glow ? palette_bgra_nofullbrights : palette_bgra_complete);
3825 if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase)
3827 Mem_Free(skinframe->qpixels);
3828 skinframe->qpixels = NULL;
3832 skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, const unsigned char *skindata, int width, int height, const unsigned int *palette, const unsigned int *alphapalette)
3835 skinframe_t *skinframe;
3837 if (cls.state == ca_dedicated)
3840 // if already loaded just return it, otherwise make a new skinframe
3841 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
3842 if (skinframe && skinframe->base)
3845 skinframe->stain = NULL;
3846 skinframe->merged = NULL;
3847 skinframe->base = r_texture_notexture;
3848 skinframe->pants = NULL;
3849 skinframe->shirt = NULL;
3850 skinframe->nmap = r_texture_blanknormalmap;
3851 skinframe->gloss = NULL;
3852 skinframe->glow = NULL;
3853 skinframe->fog = NULL;
3854 skinframe->hasalpha = false;
3856 // if no data was provided, then clearly the caller wanted to get a blank skinframe
3860 if (developer_loading.integer)
3861 Con_Printf("loading embedded 8bit image \"%s\"\n", name);
3863 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, palette);
3864 if (textureflags & TEXF_ALPHA)
3866 for (i = 0;i < width * height;i++)
3868 if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
3870 skinframe->hasalpha = true;
3874 if (r_loadfog && skinframe->hasalpha)
3875 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va("%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, skinframe->textureflags, alphapalette);
3878 R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
3879 //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
3884 skinframe_t *R_SkinFrame_LoadMissing(void)
3886 skinframe_t *skinframe;
3888 if (cls.state == ca_dedicated)
3891 skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
3892 skinframe->stain = NULL;
3893 skinframe->merged = NULL;
3894 skinframe->base = r_texture_notexture;
3895 skinframe->pants = NULL;
3896 skinframe->shirt = NULL;
3897 skinframe->nmap = r_texture_blanknormalmap;
3898 skinframe->gloss = NULL;
3899 skinframe->glow = NULL;
3900 skinframe->fog = NULL;
3901 skinframe->hasalpha = false;
3903 skinframe->avgcolor[0] = rand() / RAND_MAX;
3904 skinframe->avgcolor[1] = rand() / RAND_MAX;
3905 skinframe->avgcolor[2] = rand() / RAND_MAX;
3906 skinframe->avgcolor[3] = 1;
3911 void R_Main_FreeViewCache(void)
3913 if (r_refdef.viewcache.entityvisible)
3914 Mem_Free(r_refdef.viewcache.entityvisible);
3915 if (r_refdef.viewcache.world_pvsbits)
3916 Mem_Free(r_refdef.viewcache.world_pvsbits);
3917 if (r_refdef.viewcache.world_leafvisible)
3918 Mem_Free(r_refdef.viewcache.world_leafvisible);
3919 if (r_refdef.viewcache.world_surfacevisible)
3920 Mem_Free(r_refdef.viewcache.world_surfacevisible);
3921 memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache));
3924 void R_Main_ResizeViewCache(void)
3926 int numentities = r_refdef.scene.numentities;
3927 int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1;
3928 int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1;
3929 int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1;
3930 int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1;
3931 if (r_refdef.viewcache.maxentities < numentities)
3933 r_refdef.viewcache.maxentities = numentities;
3934 if (r_refdef.viewcache.entityvisible)
3935 Mem_Free(r_refdef.viewcache.entityvisible);
3936 r_refdef.viewcache.entityvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities);
3938 if (r_refdef.viewcache.world_numclusters != numclusters)
3940 r_refdef.viewcache.world_numclusters = numclusters;
3941 r_refdef.viewcache.world_numclusterbytes = numclusterbytes;
3942 if (r_refdef.viewcache.world_pvsbits)
3943 Mem_Free(r_refdef.viewcache.world_pvsbits);
3944 r_refdef.viewcache.world_pvsbits = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes);
3946 if (r_refdef.viewcache.world_numleafs != numleafs)
3948 r_refdef.viewcache.world_numleafs = numleafs;
3949 if (r_refdef.viewcache.world_leafvisible)
3950 Mem_Free(r_refdef.viewcache.world_leafvisible);
3951 r_refdef.viewcache.world_leafvisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs);
3953 if (r_refdef.viewcache.world_numsurfaces != numsurfaces)
3955 r_refdef.viewcache.world_numsurfaces = numsurfaces;
3956 if (r_refdef.viewcache.world_surfacevisible)
3957 Mem_Free(r_refdef.viewcache.world_surfacevisible);
3958 r_refdef.viewcache.world_surfacevisible = Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces);
3962 extern rtexture_t *loadingscreentexture;
3963 void gl_main_start(void)
3965 loadingscreentexture = NULL;
3966 r_texture_blanknormalmap = NULL;
3967 r_texture_white = NULL;
3968 r_texture_grey128 = NULL;
3969 r_texture_black = NULL;
3970 r_texture_whitecube = NULL;
3971 r_texture_normalizationcube = NULL;
3972 r_texture_fogattenuation = NULL;
3973 r_texture_gammaramps = NULL;
3975 switch(vid.renderpath)
3977 case RENDERPATH_GL20:
3978 case RENDERPATH_CGGL:
3979 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3980 Cvar_SetValueQuick(&gl_combine, 1);
3981 Cvar_SetValueQuick(&r_glsl, 1);
3982 r_loadnormalmap = true;
3986 case RENDERPATH_GL13:
3987 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3988 Cvar_SetValueQuick(&gl_combine, 1);
3989 Cvar_SetValueQuick(&r_glsl, 0);
3990 r_loadnormalmap = false;
3991 r_loadgloss = false;
3994 case RENDERPATH_GL11:
3995 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3996 Cvar_SetValueQuick(&gl_combine, 0);
3997 Cvar_SetValueQuick(&r_glsl, 0);
3998 r_loadnormalmap = false;
3999 r_loadgloss = false;
4005 R_FrameData_Reset();
4009 memset(r_queries, 0, sizeof(r_queries));
4011 r_qwskincache = NULL;
4012 r_qwskincache_size = 0;
4014 // set up r_skinframe loading system for textures
4015 memset(&r_skinframe, 0, sizeof(r_skinframe));
4016 r_skinframe.loadsequence = 1;
4017 Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
4019 r_main_texturepool = R_AllocTexturePool();
4020 R_BuildBlankTextures();
4022 if (vid.support.arb_texture_cube_map)
4025 R_BuildNormalizationCube();
4027 r_texture_fogattenuation = NULL;
4028 r_texture_gammaramps = NULL;
4029 //r_texture_fogintensity = NULL;
4030 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
4031 memset(&r_waterstate, 0, sizeof(r_waterstate));
4032 memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
4033 Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
4035 memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash));
4036 Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256);
4038 memset(&r_svbsp, 0, sizeof (r_svbsp));
4040 r_refdef.fogmasktable_density = 0;
4043 void gl_main_shutdown(void)
4046 R_FrameData_Reset();
4048 R_Main_FreeViewCache();
4051 qglDeleteQueriesARB(r_maxqueries, r_queries);
4055 memset(r_queries, 0, sizeof(r_queries));
4057 r_qwskincache = NULL;
4058 r_qwskincache_size = 0;
4060 // clear out the r_skinframe state
4061 Mem_ExpandableArray_FreeArray(&r_skinframe.array);
4062 memset(&r_skinframe, 0, sizeof(r_skinframe));
4065 Mem_Free(r_svbsp.nodes);
4066 memset(&r_svbsp, 0, sizeof (r_svbsp));
4067 R_FreeTexturePool(&r_main_texturepool);
4068 loadingscreentexture = NULL;
4069 r_texture_blanknormalmap = NULL;
4070 r_texture_white = NULL;
4071 r_texture_grey128 = NULL;
4072 r_texture_black = NULL;
4073 r_texture_whitecube = NULL;
4074 r_texture_normalizationcube = NULL;
4075 r_texture_fogattenuation = NULL;
4076 r_texture_gammaramps = NULL;
4077 //r_texture_fogintensity = NULL;
4078 memset(&r_bloomstate, 0, sizeof(r_bloomstate));
4079 memset(&r_waterstate, 0, sizeof(r_waterstate));
4083 extern void CL_ParseEntityLump(char *entitystring);
4084 void gl_main_newmap(void)
4086 // FIXME: move this code to client
4088 char *entities, entname[MAX_QPATH];
4090 Mem_Free(r_qwskincache);
4091 r_qwskincache = NULL;
4092 r_qwskincache_size = 0;
4095 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
4096 l = (int)strlen(entname) - 4;
4097 if (l >= 0 && !strcmp(entname + l, ".bsp"))
4099 memcpy(entname + l, ".ent", 5);
4100 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
4102 CL_ParseEntityLump(entities);
4107 if (cl.worldmodel->brush.entities)
4108 CL_ParseEntityLump(cl.worldmodel->brush.entities);
4110 R_Main_FreeViewCache();
4112 R_FrameData_Reset();
4115 void GL_Main_Init(void)
4117 r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
4119 Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
4120 Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
4121 // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
4122 if (gamemode == GAME_NEHAHRA)
4124 Cvar_RegisterVariable (&gl_fogenable);
4125 Cvar_RegisterVariable (&gl_fogdensity);
4126 Cvar_RegisterVariable (&gl_fogred);
4127 Cvar_RegisterVariable (&gl_foggreen);
4128 Cvar_RegisterVariable (&gl_fogblue);
4129 Cvar_RegisterVariable (&gl_fogstart);
4130 Cvar_RegisterVariable (&gl_fogend);
4131 Cvar_RegisterVariable (&gl_skyclip);
4133 Cvar_RegisterVariable(&r_motionblur);
4134 Cvar_RegisterVariable(&r_motionblur_maxblur);
4135 Cvar_RegisterVariable(&r_motionblur_bmin);
4136 Cvar_RegisterVariable(&r_motionblur_vmin);
4137 Cvar_RegisterVariable(&r_motionblur_vmax);
4138 Cvar_RegisterVariable(&r_motionblur_vcoeff);
4139 Cvar_RegisterVariable(&r_motionblur_randomize);
4140 Cvar_RegisterVariable(&r_damageblur);
4141 Cvar_RegisterVariable(&r_equalize_entities_fullbright);
4142 Cvar_RegisterVariable(&r_equalize_entities_minambient);
4143 Cvar_RegisterVariable(&r_equalize_entities_by);
4144 Cvar_RegisterVariable(&r_equalize_entities_to);
4145 Cvar_RegisterVariable(&r_depthfirst);
4146 Cvar_RegisterVariable(&r_useinfinitefarclip);
4147 Cvar_RegisterVariable(&r_farclip_base);
4148 Cvar_RegisterVariable(&r_farclip_world);
4149 Cvar_RegisterVariable(&r_nearclip);
4150 Cvar_RegisterVariable(&r_showbboxes);
4151 Cvar_RegisterVariable(&r_showsurfaces);
4152 Cvar_RegisterVariable(&r_showtris);
4153 Cvar_RegisterVariable(&r_shownormals);
4154 Cvar_RegisterVariable(&r_showlighting);
4155 Cvar_RegisterVariable(&r_showshadowvolumes);
4156 Cvar_RegisterVariable(&r_showcollisionbrushes);
4157 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
4158 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
4159 Cvar_RegisterVariable(&r_showdisabledepthtest);
4160 Cvar_RegisterVariable(&r_drawportals);
4161 Cvar_RegisterVariable(&r_drawentities);
4162 Cvar_RegisterVariable(&r_cullentities_trace);
4163 Cvar_RegisterVariable(&r_cullentities_trace_samples);
4164 Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
4165 Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
4166 Cvar_RegisterVariable(&r_cullentities_trace_delay);
4167 Cvar_RegisterVariable(&r_drawviewmodel);
4168 Cvar_RegisterVariable(&r_speeds);
4169 Cvar_RegisterVariable(&r_fullbrights);
4170 Cvar_RegisterVariable(&r_wateralpha);
4171 Cvar_RegisterVariable(&r_dynamic);
4172 Cvar_RegisterVariable(&r_fullbright);
4173 Cvar_RegisterVariable(&r_shadows);
4174 Cvar_RegisterVariable(&r_shadows_darken);
4175 Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
4176 Cvar_RegisterVariable(&r_shadows_castfrombmodels);
4177 Cvar_RegisterVariable(&r_shadows_throwdistance);
4178 Cvar_RegisterVariable(&r_shadows_throwdirection);
4179 Cvar_RegisterVariable(&r_q1bsp_skymasking);
4180 Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
4181 Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
4182 Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
4183 Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
4184 Cvar_RegisterVariable(&r_fog_exp2);
4185 Cvar_RegisterVariable(&r_drawfog);
4186 Cvar_RegisterVariable(&r_transparentdepthmasking);
4187 Cvar_RegisterVariable(&r_textureunits);
4188 Cvar_RegisterVariable(&gl_combine);
4189 Cvar_RegisterVariable(&r_glsl);
4190 Cvar_RegisterVariable(&r_glsl_deluxemapping);
4191 Cvar_RegisterVariable(&r_glsl_offsetmapping);
4192 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
4193 Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
4194 Cvar_RegisterVariable(&r_glsl_postprocess);
4195 Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
4196 Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
4197 Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
4198 Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
4199 Cvar_RegisterVariable(&r_water);
4200 Cvar_RegisterVariable(&r_water_resolutionmultiplier);
4201 Cvar_RegisterVariable(&r_water_clippingplanebias);
4202 Cvar_RegisterVariable(&r_water_refractdistort);
4203 Cvar_RegisterVariable(&r_water_reflectdistort);
4204 Cvar_RegisterVariable(&r_lerpsprites);
4205 Cvar_RegisterVariable(&r_lerpmodels);
4206 Cvar_RegisterVariable(&r_lerplightstyles);
4207 Cvar_RegisterVariable(&r_waterscroll);
4208 Cvar_RegisterVariable(&r_bloom);
4209 Cvar_RegisterVariable(&r_bloom_colorscale);
4210 Cvar_RegisterVariable(&r_bloom_brighten);
4211 Cvar_RegisterVariable(&r_bloom_blur);
4212 Cvar_RegisterVariable(&r_bloom_resolution);
4213 Cvar_RegisterVariable(&r_bloom_colorexponent);
4214 Cvar_RegisterVariable(&r_bloom_colorsubtract);
4215 Cvar_RegisterVariable(&r_hdr);
4216 Cvar_RegisterVariable(&r_hdr_scenebrightness);
4217 Cvar_RegisterVariable(&r_hdr_glowintensity);
4218 Cvar_RegisterVariable(&r_hdr_range);
4219 Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
4220 Cvar_RegisterVariable(&developer_texturelogging);
4221 Cvar_RegisterVariable(&gl_lightmaps);
4222 Cvar_RegisterVariable(&r_test);
4223 Cvar_RegisterVariable(&r_batchmode);
4224 Cvar_RegisterVariable(&r_glsl_saturation);
4225 Cvar_RegisterVariable(&r_framedatasize);
4226 if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
4227 Cvar_SetValue("r_fullbrights", 0);
4228 R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
4230 Cvar_RegisterVariable(&r_track_sprites);
4231 Cvar_RegisterVariable(&r_track_sprites_flags);
4232 Cvar_RegisterVariable(&r_track_sprites_scalew);
4233 Cvar_RegisterVariable(&r_track_sprites_scaleh);
4236 extern void R_Textures_Init(void);
4237 extern void GL_Draw_Init(void);
4238 extern void GL_Main_Init(void);
4239 extern void R_Shadow_Init(void);
4240 extern void R_Sky_Init(void);
4241 extern void GL_Surf_Init(void);
4242 extern void R_Particles_Init(void);
4243 extern void R_Explosion_Init(void);
4244 extern void gl_backend_init(void);
4245 extern void Sbar_Init(void);
4246 extern void R_LightningBeams_Init(void);
4247 extern void Mod_RenderInit(void);
4248 extern void Font_Init(void);
4250 void Render_Init(void)
4263 R_LightningBeams_Init();
4272 extern char *ENGINE_EXTENSIONS;
4275 gl_renderer = (const char *)qglGetString(GL_RENDERER);
4276 gl_vendor = (const char *)qglGetString(GL_VENDOR);
4277 gl_version = (const char *)qglGetString(GL_VERSION);
4278 gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
4282 if (!gl_platformextensions)
4283 gl_platformextensions = "";
4285 Con_Printf("GL_VENDOR: %s\n", gl_vendor);
4286 Con_Printf("GL_RENDERER: %s\n", gl_renderer);
4287 Con_Printf("GL_VERSION: %s\n", gl_version);
4288 Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
4289 Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
4291 VID_CheckExtensions();
4293 // LordHavoc: report supported extensions
4294 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
4296 // clear to black (loading plaque will be seen over this)
4298 qglClearColor(0,0,0,1);CHECKGLERROR
4299 qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
4302 int R_CullBox(const vec3_t mins, const vec3_t maxs)
4306 for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
4308 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
4311 p = r_refdef.view.frustum + i;
4316 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4320 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4324 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4328 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4332 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4336 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4340 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4344 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4352 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
4356 for (i = 0;i < numplanes;i++)
4363 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4367 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4371 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4375 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4379 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4383 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4387 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4391 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4399 //==================================================================================
4401 // LordHavoc: this stores temporary data used within the same frame
4403 qboolean r_framedata_failed;
4404 static size_t r_framedata_size;
4405 static size_t r_framedata_current;
4406 static void *r_framedata_base;
4408 void R_FrameData_Reset(void)
4410 if (r_framedata_base);
4411 Mem_Free(r_framedata_base);
4412 r_framedata_base = NULL;
4413 r_framedata_size = 0;
4414 r_framedata_current = 0;
4415 r_framedata_failed = false;
4418 void R_FrameData_NewFrame(void)
4421 if (r_framedata_failed)
4422 Cvar_SetValueQuick(&r_framedatasize, r_framedatasize.value + 1.0f);
4423 wantedsize = (size_t)(r_framedatasize.value * 1024*1024);
4424 wantedsize = bound(65536, wantedsize, 128*1024*1024);
4425 if (r_framedata_size != wantedsize)
4427 r_framedata_size = wantedsize;
4428 if (r_framedata_base);
4429 Mem_Free(r_framedata_base);
4430 r_framedata_base = Mem_Alloc(r_main_mempool, r_framedata_size);
4432 r_framedata_current = 0;
4433 r_framedata_failed = false;
4436 void *R_FrameData_Alloc(size_t size)
4440 // align to 16 byte boundary
4441 size = (size + 15) & ~15;
4442 data = (void *)((unsigned char*)r_framedata_base + r_framedata_current);
4443 r_framedata_current += size;
4446 if (r_framedata_current > r_framedata_size)
4447 r_framedata_failed = true;
4449 // return NULL on everything after a failure
4450 if (r_framedata_failed)
4456 void *R_FrameData_Store(size_t size, void *data)
4458 void *d = R_FrameData_Alloc(size);
4460 memcpy(d, data, size);
4464 //==================================================================================
4466 // LordHavoc: animcache originally written by Echon, rewritten since then
4469 * Animation cache prevents re-generating mesh data for an animated model
4470 * multiple times in one frame for lighting, shadowing, reflections, etc.
4473 void R_AnimCache_Free(void)
4477 void R_AnimCache_ClearCache(void)
4480 entity_render_t *ent;
4482 for (i = 0;i < r_refdef.scene.numentities;i++)
4484 ent = r_refdef.scene.entities[i];
4485 ent->animcache_vertex3f = NULL;
4486 ent->animcache_normal3f = NULL;
4487 ent->animcache_svector3f = NULL;
4488 ent->animcache_tvector3f = NULL;
4492 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4494 dp_model_t *model = ent->model;
4496 // see if it's already cached this frame
4497 if (ent->animcache_vertex3f)
4499 // add normals/tangents if needed
4500 if (wantnormals || wanttangents)
4502 if (ent->animcache_normal3f)
4503 wantnormals = false;
4504 if (ent->animcache_svector3f)
4505 wanttangents = false;
4506 if (wantnormals || wanttangents)
4508 numvertices = model->surfmesh.num_vertices;
4510 ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4513 ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4514 ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4516 if (!r_framedata_failed)
4517 model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
4523 // see if this ent is worth caching
4524 if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices || (ent->frameblend[0].lerp == 1 && ent->frameblend[0].subframe == 0 && !ent->skeleton))
4526 // get some memory for this entity and generate mesh data
4527 numvertices = model->surfmesh.num_vertices;
4528 ent->animcache_vertex3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4530 ent->animcache_normal3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4533 ent->animcache_svector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4534 ent->animcache_tvector3f = R_FrameData_Alloc(sizeof(float[3])*numvertices);
4536 if (!r_framedata_failed)
4537 model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
4539 return !r_framedata_failed;
4542 void R_AnimCache_CacheVisibleEntities(void)
4545 qboolean wantnormals = !r_showsurfaces.integer;
4546 qboolean wanttangents = !r_showsurfaces.integer;
4548 switch(vid.renderpath)
4550 case RENDERPATH_GL20:
4551 case RENDERPATH_CGGL:
4553 case RENDERPATH_GL13:
4554 case RENDERPATH_GL11:
4555 wanttangents = false;
4559 // TODO: thread this
4560 // NOTE: R_PrepareRTLights() also caches entities
4562 for (i = 0;i < r_refdef.scene.numentities;i++)
4563 if (r_refdef.viewcache.entityvisible[i])
4564 R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
4566 if (r_shadows.integer)
4567 for (i = 0;i < r_refdef.scene.numentities;i++)
4568 if (!r_refdef.viewcache.entityvisible[i])
4569 R_AnimCache_GetEntity(r_refdef.scene.entities[i], false, false);
4572 //==================================================================================
4574 static void R_View_UpdateEntityLighting (void)
4577 entity_render_t *ent;
4578 vec3_t tempdiffusenormal, avg;
4579 vec_t f, fa, fd, fdd;
4581 for (i = 0;i < r_refdef.scene.numentities;i++)
4583 ent = r_refdef.scene.entities[i];
4585 // skip unseen models
4586 if (!r_refdef.viewcache.entityvisible[i] && r_shadows.integer != 1)
4590 if (ent->model && ent->model->brush.num_leafs)
4592 // TODO: use modellight for r_ambient settings on world?
4593 VectorSet(ent->modellight_ambient, 0, 0, 0);
4594 VectorSet(ent->modellight_diffuse, 0, 0, 0);
4595 VectorSet(ent->modellight_lightdir, 0, 0, 1);
4599 // fetch the lighting from the worldmodel data
4600 VectorClear(ent->modellight_ambient);
4601 VectorClear(ent->modellight_diffuse);
4602 VectorClear(tempdiffusenormal);
4603 if ((ent->flags & RENDER_LIGHT) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
4606 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4607 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
4608 if(ent->flags & RENDER_EQUALIZE)
4610 // first fix up ambient lighting...
4611 if(r_equalize_entities_minambient.value > 0)
4613 fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
4616 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
4617 if(fa < r_equalize_entities_minambient.value * fd)
4620 // fa'/fd' = minambient
4621 // fa'+0.25*fd' = fa+0.25*fd
4623 // fa' = fd' * minambient
4624 // fd'*(0.25+minambient) = fa+0.25*fd
4626 // fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
4627 // fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
4629 fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
4630 f = fdd / fd; // f>0 because all this is additive; f<1 because fdd<fd because this follows from fa < r_equalize_entities_minambient.value * fd
4631 VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
4632 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
4637 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
4639 VectorMA(ent->modellight_ambient, 0.25f, ent->modellight_diffuse, avg);
4640 f = 0.299f * avg[0] + 0.587f * avg[1] + 0.114f * avg[2];
4643 f = pow(f / r_equalize_entities_to.value, -r_equalize_entities_by.value);
4644 VectorScale(ent->modellight_ambient, f, ent->modellight_ambient);
4645 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
4651 VectorSet(ent->modellight_ambient, 1, 1, 1);
4653 // move the light direction into modelspace coordinates for lighting code
4654 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
4655 if(VectorLength2(ent->modellight_lightdir) == 0)
4656 VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
4657 VectorNormalize(ent->modellight_lightdir);
4661 #define MAX_LINEOFSIGHTTRACES 64
4663 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
4666 vec3_t boxmins, boxmaxs;
4669 dp_model_t *model = r_refdef.scene.worldmodel;
4671 if (!model || !model->brush.TraceLineOfSight)
4674 // expand the box a little
4675 boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
4676 boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
4677 boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
4678 boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
4679 boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
4680 boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
4683 VectorCopy(eye, start);
4684 VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
4685 if (model->brush.TraceLineOfSight(model, start, end))
4688 // try various random positions
4689 for (i = 0;i < numsamples;i++)
4691 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
4692 if (model->brush.TraceLineOfSight(model, start, end))
4700 static void R_View_UpdateEntityVisible (void)
4705 entity_render_t *ent;
4707 renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
4708 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
4710 // worldmodel can check visibility
4711 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
4712 for (i = 0;i < r_refdef.scene.numentities;i++)
4714 ent = r_refdef.scene.entities[i];
4715 if (!(ent->flags & renderimask))
4716 if (!R_CullBox(ent->mins, ent->maxs) || (ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)))
4717 if ((ent->flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL)) || r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, ent->mins, ent->maxs))
4718 r_refdef.viewcache.entityvisible[i] = true;
4720 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight)
4722 for (i = 0;i < r_refdef.scene.numentities;i++)
4724 ent = r_refdef.scene.entities[i];
4725 if(r_refdef.viewcache.entityvisible[i] && !(ent->flags & (RENDER_VIEWMODEL | RENDER_NOCULL | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
4727 samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
4729 continue; // temp entities do pvs only
4730 if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
4731 ent->last_trace_visibility = realtime;
4732 if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
4733 r_refdef.viewcache.entityvisible[i] = 0;
4740 // no worldmodel or it can't check visibility
4741 for (i = 0;i < r_refdef.scene.numentities;i++)
4743 ent = r_refdef.scene.entities[i];
4744 r_refdef.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));
4749 /// only used if skyrendermasked, and normally returns false
4750 int R_DrawBrushModelsSky (void)
4753 entity_render_t *ent;
4756 for (i = 0;i < r_refdef.scene.numentities;i++)
4758 if (!r_refdef.viewcache.entityvisible[i])
4760 ent = r_refdef.scene.entities[i];
4761 if (!ent->model || !ent->model->DrawSky)
4763 ent->model->DrawSky(ent);
4769 static void R_DrawNoModel(entity_render_t *ent);
4770 static void R_DrawModels(void)
4773 entity_render_t *ent;
4775 for (i = 0;i < r_refdef.scene.numentities;i++)
4777 if (!r_refdef.viewcache.entityvisible[i])
4779 ent = r_refdef.scene.entities[i];
4780 r_refdef.stats.entities++;
4781 if (ent->model && ent->model->Draw != NULL)
4782 ent->model->Draw(ent);
4788 static void R_DrawModelsDepth(void)
4791 entity_render_t *ent;
4793 for (i = 0;i < r_refdef.scene.numentities;i++)
4795 if (!r_refdef.viewcache.entityvisible[i])
4797 ent = r_refdef.scene.entities[i];
4798 if (ent->model && ent->model->DrawDepth != NULL)
4799 ent->model->DrawDepth(ent);
4803 static void R_DrawModelsDebug(void)
4806 entity_render_t *ent;
4808 for (i = 0;i < r_refdef.scene.numentities;i++)
4810 if (!r_refdef.viewcache.entityvisible[i])
4812 ent = r_refdef.scene.entities[i];
4813 if (ent->model && ent->model->DrawDebug != NULL)
4814 ent->model->DrawDebug(ent);
4818 static void R_DrawModelsAddWaterPlanes(void)
4821 entity_render_t *ent;
4823 for (i = 0;i < r_refdef.scene.numentities;i++)
4825 if (!r_refdef.viewcache.entityvisible[i])
4827 ent = r_refdef.scene.entities[i];
4828 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
4829 ent->model->DrawAddWaterPlanes(ent);
4833 static void R_View_SetFrustum(void)
4836 double slopex, slopey;
4837 vec3_t forward, left, up, origin;
4839 // we can't trust r_refdef.view.forward and friends in reflected scenes
4840 Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
4843 r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
4844 r_refdef.view.frustum[0].normal[1] = 0 - 0;
4845 r_refdef.view.frustum[0].normal[2] = -1 - 0;
4846 r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
4847 r_refdef.view.frustum[1].normal[1] = 0 + 0;
4848 r_refdef.view.frustum[1].normal[2] = -1 + 0;
4849 r_refdef.view.frustum[2].normal[0] = 0 - 0;
4850 r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
4851 r_refdef.view.frustum[2].normal[2] = -1 - 0;
4852 r_refdef.view.frustum[3].normal[0] = 0 + 0;
4853 r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
4854 r_refdef.view.frustum[3].normal[2] = -1 + 0;
4858 zNear = r_refdef.nearclip;
4859 nudge = 1.0 - 1.0 / (1<<23);
4860 r_refdef.view.frustum[4].normal[0] = 0 - 0;
4861 r_refdef.view.frustum[4].normal[1] = 0 - 0;
4862 r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
4863 r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
4864 r_refdef.view.frustum[5].normal[0] = 0 + 0;
4865 r_refdef.view.frustum[5].normal[1] = 0 + 0;
4866 r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
4867 r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
4873 r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
4874 r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
4875 r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
4876 r_refdef.view.frustum[0].dist = m[15] - m[12];
4878 r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
4879 r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
4880 r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
4881 r_refdef.view.frustum[1].dist = m[15] + m[12];
4883 r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
4884 r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
4885 r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
4886 r_refdef.view.frustum[2].dist = m[15] - m[13];
4888 r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
4889 r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
4890 r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
4891 r_refdef.view.frustum[3].dist = m[15] + m[13];
4893 r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
4894 r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
4895 r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
4896 r_refdef.view.frustum[4].dist = m[15] - m[14];
4898 r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
4899 r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
4900 r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
4901 r_refdef.view.frustum[5].dist = m[15] + m[14];
4904 if (r_refdef.view.useperspective)
4906 slopex = 1.0 / r_refdef.view.frustum_x;
4907 slopey = 1.0 / r_refdef.view.frustum_y;
4908 VectorMA(forward, -slopex, left, r_refdef.view.frustum[0].normal);
4909 VectorMA(forward, slopex, left, r_refdef.view.frustum[1].normal);
4910 VectorMA(forward, -slopey, up , r_refdef.view.frustum[2].normal);
4911 VectorMA(forward, slopey, up , r_refdef.view.frustum[3].normal);
4912 VectorCopy(forward, r_refdef.view.frustum[4].normal);
4914 // Leaving those out was a mistake, those were in the old code, and they
4915 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
4916 // I couldn't reproduce it after adding those normalizations. --blub
4917 VectorNormalize(r_refdef.view.frustum[0].normal);
4918 VectorNormalize(r_refdef.view.frustum[1].normal);
4919 VectorNormalize(r_refdef.view.frustum[2].normal);
4920 VectorNormalize(r_refdef.view.frustum[3].normal);
4922 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
4923 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]);
4924 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, 1024 * r_refdef.view.frustum_x, left, -1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]);
4925 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, -1024 * r_refdef.view.frustum_x, left, 1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]);
4926 VectorMAMAMAM(1, r_refdef.view.origin, 1024, forward, 1024 * r_refdef.view.frustum_x, left, 1024 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]);
4928 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
4929 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
4930 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
4931 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
4932 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
4936 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
4937 VectorScale(left, r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
4938 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
4939 VectorScale(up, r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
4940 VectorCopy(forward, r_refdef.view.frustum[4].normal);
4941 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
4942 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
4943 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
4944 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
4945 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
4947 r_refdef.view.numfrustumplanes = 5;
4949 if (r_refdef.view.useclipplane)
4951 r_refdef.view.numfrustumplanes = 6;
4952 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
4955 for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
4956 PlaneClassify(r_refdef.view.frustum + i);
4958 // LordHavoc: note to all quake engine coders, Quake had a special case
4959 // for 90 degrees which assumed a square view (wrong), so I removed it,
4960 // Quake2 has it disabled as well.
4962 // rotate R_VIEWFORWARD right by FOV_X/2 degrees
4963 //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
4964 //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
4965 //PlaneClassify(&frustum[0]);
4967 // rotate R_VIEWFORWARD left by FOV_X/2 degrees
4968 //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
4969 //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
4970 //PlaneClassify(&frustum[1]);
4972 // rotate R_VIEWFORWARD up by FOV_X/2 degrees
4973 //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
4974 //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
4975 //PlaneClassify(&frustum[2]);
4977 // rotate R_VIEWFORWARD down by FOV_X/2 degrees
4978 //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
4979 //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
4980 //PlaneClassify(&frustum[3]);
4983 //VectorCopy(forward, r_refdef.view.frustum[4].normal);
4984 //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
4985 //PlaneClassify(&frustum[4]);
4988 void R_View_Update(void)
4990 R_Main_ResizeViewCache();
4991 R_View_SetFrustum();
4992 R_View_WorldVisibility(r_refdef.view.useclipplane);
4993 R_View_UpdateEntityVisible();
4994 R_View_UpdateEntityLighting();
4997 void R_SetupView(qboolean allowwaterclippingplane)
4999 const float *customclipplane = NULL;
5001 if (r_refdef.view.useclipplane && allowwaterclippingplane)
5003 // LordHavoc: couldn't figure out how to make this approach the
5004 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
5005 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
5006 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
5007 dist = r_refdef.view.clipplane.dist;
5008 plane[0] = r_refdef.view.clipplane.normal[0];
5009 plane[1] = r_refdef.view.clipplane.normal[1];
5010 plane[2] = r_refdef.view.clipplane.normal[2];
5012 customclipplane = plane;
5015 if (!r_refdef.view.useperspective)
5016 R_Viewport_InitOrtho(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, -r_refdef.view.ortho_x, -r_refdef.view.ortho_y, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip, customclipplane);
5017 else if (vid.stencil && r_useinfinitefarclip.integer)
5018 R_Viewport_InitPerspectiveInfinite(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, customclipplane);
5020 R_Viewport_InitPerspective(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip, customclipplane);
5021 R_SetViewport(&r_refdef.view.viewport);
5024 void R_EntityMatrix(const matrix4x4_t *matrix)
5026 if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
5028 gl_modelmatrixchanged = false;
5029 gl_modelmatrix = *matrix;
5030 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
5031 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
5032 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
5033 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
5035 switch(vid.renderpath)
5037 case RENDERPATH_GL20:
5038 if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
5039 qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5041 case RENDERPATH_CGGL:
5043 if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
5044 qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5047 case RENDERPATH_GL13:
5048 case RENDERPATH_GL11:
5049 qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5055 void R_ResetViewRendering2D(void)
5057 r_viewport_t viewport;
5060 // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
5061 R_Viewport_InitOrtho(&viewport, &identitymatrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, 0, 0, 1, 1, -10, 100, NULL);
5062 R_SetViewport(&viewport);
5063 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
5064 GL_Color(1, 1, 1, 1);
5065 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5066 GL_BlendFunc(GL_ONE, GL_ZERO);
5067 GL_AlphaTest(false);
5068 GL_ScissorTest(false);
5069 GL_DepthMask(false);
5070 GL_DepthRange(0, 1);
5071 GL_DepthTest(false);
5072 R_EntityMatrix(&identitymatrix);
5073 R_Mesh_ResetTextureState();
5074 GL_PolygonOffset(0, 0);
5075 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5076 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5077 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5078 qglStencilMask(~0);CHECKGLERROR
5079 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5080 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5081 GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
5084 void R_ResetViewRendering3D(void)
5089 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5090 GL_Color(1, 1, 1, 1);
5091 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5092 GL_BlendFunc(GL_ONE, GL_ZERO);
5093 GL_AlphaTest(false);
5094 GL_ScissorTest(true);
5096 GL_DepthRange(0, 1);
5098 R_EntityMatrix(&identitymatrix);
5099 R_Mesh_ResetTextureState();
5100 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
5101 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5102 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5103 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5104 qglStencilMask(~0);CHECKGLERROR
5105 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5106 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5107 GL_CullFace(r_refdef.view.cullface_back);
5110 void R_RenderScene(void);
5111 void R_RenderWaterPlanes(void);
5113 static void R_Water_StartFrame(void)
5116 int waterwidth, waterheight, texturewidth, textureheight;
5117 r_waterstate_waterplane_t *p;
5119 if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
5122 switch(vid.renderpath)
5124 case RENDERPATH_GL20:
5125 case RENDERPATH_CGGL:
5127 case RENDERPATH_GL13:
5128 case RENDERPATH_GL11:
5132 // set waterwidth and waterheight to the water resolution that will be
5133 // used (often less than the screen resolution for faster rendering)
5134 waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
5135 waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
5137 // calculate desired texture sizes
5138 // can't use water if the card does not support the texture size
5139 if (!r_water.integer || r_showsurfaces.integer)
5140 texturewidth = textureheight = waterwidth = waterheight = 0;
5141 else if (vid.support.arb_texture_non_power_of_two)
5143 texturewidth = waterwidth;
5144 textureheight = waterheight;
5148 for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
5149 for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
5152 // allocate textures as needed
5153 if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
5155 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5156 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
5158 if (p->texture_refraction)
5159 R_FreeTexture(p->texture_refraction);
5160 p->texture_refraction = NULL;
5161 if (p->texture_reflection)
5162 R_FreeTexture(p->texture_reflection);
5163 p->texture_reflection = NULL;
5165 memset(&r_waterstate, 0, sizeof(r_waterstate));
5166 r_waterstate.texturewidth = texturewidth;
5167 r_waterstate.textureheight = textureheight;
5170 if (r_waterstate.texturewidth)
5172 r_waterstate.enabled = true;
5174 // when doing a reduced render (HDR) we want to use a smaller area
5175 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
5176 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
5178 // set up variables that will be used in shader setup
5179 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5180 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5181 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5182 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5185 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5186 r_waterstate.numwaterplanes = 0;
5189 void R_Water_AddWaterPlane(msurface_t *surface)
5191 int triangleindex, planeindex;
5197 r_waterstate_waterplane_t *p;
5198 texture_t *t = R_GetCurrentTexture(surface->texture);
5199 // just use the first triangle with a valid normal for any decisions
5200 VectorClear(normal);
5201 for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
5203 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
5204 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
5205 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
5206 TriangleNormal(vert[0], vert[1], vert[2], normal);
5207 if (VectorLength2(normal) >= 0.001)
5211 VectorCopy(normal, plane.normal);
5212 VectorNormalize(plane.normal);
5213 plane.dist = DotProduct(vert[0], plane.normal);
5214 PlaneClassify(&plane);
5215 if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
5217 // skip backfaces (except if nocullface is set)
5218 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
5220 VectorNegate(plane.normal, plane.normal);
5222 PlaneClassify(&plane);
5226 // find a matching plane if there is one
5227 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5228 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
5230 if (planeindex >= r_waterstate.maxwaterplanes)
5231 return; // nothing we can do, out of planes
5233 // if this triangle does not fit any known plane rendered this frame, add one
5234 if (planeindex >= r_waterstate.numwaterplanes)
5236 // store the new plane
5237 r_waterstate.numwaterplanes++;
5239 // clear materialflags and pvs
5240 p->materialflags = 0;
5241 p->pvsvalid = false;
5243 // merge this surface's materialflags into the waterplane
5244 p->materialflags |= t->currentmaterialflags;
5245 // merge this surface's PVS into the waterplane
5246 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
5247 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
5248 && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
5250 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
5255 static void R_Water_ProcessPlanes(void)
5257 r_refdef_view_t originalview;
5258 r_refdef_view_t myview;
5260 r_waterstate_waterplane_t *p;
5262 originalview = r_refdef.view;
5264 // make sure enough textures are allocated
5265 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5267 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5269 if (!p->texture_refraction)
5270 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, NULL);
5271 if (!p->texture_refraction)
5275 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5277 if (!p->texture_reflection)
5278 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, NULL);
5279 if (!p->texture_reflection)
5285 r_refdef.view = originalview;
5286 r_refdef.view.showdebug = false;
5287 r_refdef.view.width = r_waterstate.waterwidth;
5288 r_refdef.view.height = r_waterstate.waterheight;
5289 r_refdef.view.useclipplane = true;
5290 myview = r_refdef.view;
5291 r_waterstate.renderingscene = true;
5292 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5294 // render the normal view scene and copy into texture
5295 // (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)
5296 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5298 r_refdef.view = myview;
5299 r_refdef.view.clipplane = p->plane;
5300 VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
5301 r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
5302 PlaneClassify(&r_refdef.view.clipplane);
5304 R_ResetViewRendering3D();
5305 R_ClearScreen(r_refdef.fogenabled);
5309 R_Mesh_CopyToTexture(R_GetTexture(p->texture_refraction), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5312 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5314 r_refdef.view = myview;
5315 // render reflected scene and copy into texture
5316 Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
5317 // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
5318 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
5319 r_refdef.view.clipplane = p->plane;
5320 // reverse the cullface settings for this render
5321 r_refdef.view.cullface_front = GL_FRONT;
5322 r_refdef.view.cullface_back = GL_BACK;
5323 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
5325 r_refdef.view.usecustompvs = true;
5327 memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5329 memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5332 R_ResetViewRendering3D();
5333 R_ClearScreen(r_refdef.fogenabled);
5337 R_Mesh_CopyToTexture(R_GetTexture(p->texture_reflection), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5340 r_waterstate.renderingscene = false;
5341 r_refdef.view = originalview;
5342 R_ResetViewRendering3D();
5343 R_ClearScreen(r_refdef.fogenabled);
5347 r_refdef.view = originalview;
5348 r_waterstate.renderingscene = false;
5349 Cvar_SetValueQuick(&r_water, 0);
5350 Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
5354 void R_Bloom_StartFrame(void)
5356 int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
5358 switch(vid.renderpath)
5360 case RENDERPATH_GL20:
5361 case RENDERPATH_CGGL:
5363 case RENDERPATH_GL13:
5364 case RENDERPATH_GL11:
5368 // set bloomwidth and bloomheight to the bloom resolution that will be
5369 // used (often less than the screen resolution for faster rendering)
5370 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
5371 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
5372 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
5373 r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
5374 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
5376 // calculate desired texture sizes
5377 if (vid.support.arb_texture_non_power_of_two)
5379 screentexturewidth = r_refdef.view.width;
5380 screentextureheight = r_refdef.view.height;
5381 bloomtexturewidth = r_bloomstate.bloomwidth;
5382 bloomtextureheight = r_bloomstate.bloomheight;
5386 for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
5387 for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
5388 for (bloomtexturewidth = 1;bloomtexturewidth < r_bloomstate.bloomwidth ;bloomtexturewidth *= 2);
5389 for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2);
5392 if ((r_hdr.integer || r_bloom.integer || (!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))) && ((r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512) || r_refdef.view.width > (int)vid.maxtexturesize_2d || r_refdef.view.height > (int)vid.maxtexturesize_2d))
5394 Cvar_SetValueQuick(&r_hdr, 0);
5395 Cvar_SetValueQuick(&r_bloom, 0);
5396 Cvar_SetValueQuick(&r_motionblur, 0);
5397 Cvar_SetValueQuick(&r_damageblur, 0);
5400 if (!(r_glsl_postprocess.integer || (!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) || (v_glslgamma.integer && !vid_gammatables_trivial)) && !r_bloom.integer && !r_hdr.integer && (R_Stereo_Active() || (r_motionblur.value <= 0 && r_damageblur.value <= 0)))
5401 screentexturewidth = screentextureheight = 0;
5402 if (!r_hdr.integer && !r_bloom.integer)
5403 bloomtexturewidth = bloomtextureheight = 0;
5405 // allocate textures as needed
5406 if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
5408 if (r_bloomstate.texture_screen)
5409 R_FreeTexture(r_bloomstate.texture_screen);
5410 r_bloomstate.texture_screen = NULL;
5411 r_bloomstate.screentexturewidth = screentexturewidth;
5412 r_bloomstate.screentextureheight = screentextureheight;
5413 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
5414 r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCENEAREST | TEXF_CLAMP, NULL);
5416 if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
5418 if (r_bloomstate.texture_bloom)
5419 R_FreeTexture(r_bloomstate.texture_bloom);
5420 r_bloomstate.texture_bloom = NULL;
5421 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
5422 r_bloomstate.bloomtextureheight = bloomtextureheight;
5423 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
5424 r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
5427 // when doing a reduced render (HDR) we want to use a smaller area
5428 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
5429 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
5430 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
5431 r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
5432 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
5434 // set up a texcoord array for the full resolution screen image
5435 // (we have to keep this around to copy back during final render)
5436 r_bloomstate.screentexcoord2f[0] = 0;
5437 r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height / (float)r_bloomstate.screentextureheight;
5438 r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width / (float)r_bloomstate.screentexturewidth;
5439 r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height / (float)r_bloomstate.screentextureheight;
5440 r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width / (float)r_bloomstate.screentexturewidth;
5441 r_bloomstate.screentexcoord2f[5] = 0;
5442 r_bloomstate.screentexcoord2f[6] = 0;
5443 r_bloomstate.screentexcoord2f[7] = 0;
5445 // set up a texcoord array for the reduced resolution bloom image
5446 // (which will be additive blended over the screen image)
5447 r_bloomstate.bloomtexcoord2f[0] = 0;
5448 r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5449 r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5450 r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5451 r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5452 r_bloomstate.bloomtexcoord2f[5] = 0;
5453 r_bloomstate.bloomtexcoord2f[6] = 0;
5454 r_bloomstate.bloomtexcoord2f[7] = 0;
5456 if (r_hdr.integer || r_bloom.integer)
5458 r_bloomstate.enabled = true;
5459 r_bloomstate.hdr = r_hdr.integer != 0;
5462 R_Viewport_InitOrtho(&r_bloomstate.viewport, &identitymatrix, r_refdef.view.x, vid.height - r_bloomstate.bloomheight - r_refdef.view.y, r_bloomstate.bloomwidth, r_bloomstate.bloomheight, 0, 0, 1, 1, -10, 100, NULL);
5465 void R_Bloom_CopyBloomTexture(float colorscale)
5467 r_refdef.stats.bloom++;
5469 // scale down screen texture to the bloom texture size
5471 R_SetViewport(&r_bloomstate.viewport);
5472 GL_BlendFunc(GL_ONE, GL_ZERO);
5473 GL_Color(colorscale, colorscale, colorscale, 1);
5474 // TODO: optimize with multitexture or GLSL
5475 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5476 R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5477 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5478 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5480 // we now have a bloom image in the framebuffer
5481 // copy it into the bloom image texture for later processing
5482 R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_bloom), 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
5483 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5486 void R_Bloom_CopyHDRTexture(void)
5488 R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_bloom), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5489 r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5492 void R_Bloom_MakeTexture(void)
5495 float xoffset, yoffset, r, brighten;
5497 r_refdef.stats.bloom++;
5499 R_ResetViewRendering2D();
5500 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5501 R_Mesh_ColorPointer(NULL, 0, 0);
5503 // we have a bloom image in the framebuffer
5505 R_SetViewport(&r_bloomstate.viewport);
5507 for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
5510 r = bound(0, r_bloom_colorexponent.value / x, 1);
5511 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5512 GL_Color(r, r, r, 1);
5513 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5514 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5515 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5516 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5518 // copy the vertically blurred bloom view to a texture
5519 GL_ActiveTexture(0);
5521 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5522 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5525 range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
5526 brighten = r_bloom_brighten.value;
5528 brighten *= r_hdr_range.value;
5529 brighten = sqrt(brighten);
5531 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
5532 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5533 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
5535 for (dir = 0;dir < 2;dir++)
5537 // blend on at multiple vertical offsets to achieve a vertical blur
5538 // TODO: do offset blends using GLSL
5539 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
5540 GL_BlendFunc(GL_ONE, GL_ZERO);
5541 for (x = -range;x <= range;x++)
5543 if (!dir){xoffset = 0;yoffset = x;}
5544 else {xoffset = x;yoffset = 0;}
5545 xoffset /= (float)r_bloomstate.bloomtexturewidth;
5546 yoffset /= (float)r_bloomstate.bloomtextureheight;
5547 // compute a texcoord array with the specified x and y offset
5548 r_bloomstate.offsettexcoord2f[0] = xoffset+0;
5549 r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5550 r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5551 r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5552 r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5553 r_bloomstate.offsettexcoord2f[5] = yoffset+0;
5554 r_bloomstate.offsettexcoord2f[6] = xoffset+0;
5555 r_bloomstate.offsettexcoord2f[7] = yoffset+0;
5556 // this r value looks like a 'dot' particle, fading sharply to
5557 // black at the edges
5558 // (probably not realistic but looks good enough)
5559 //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
5560 //r = brighten/(range*2+1);
5561 r = brighten / (range * 2 + 1);
5563 r *= (1 - x*x/(float)(range*range));
5564 GL_Color(r, r, r, 1);
5565 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5566 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5567 GL_BlendFunc(GL_ONE, GL_ONE);
5570 // copy the vertically blurred bloom view to a texture
5571 GL_ActiveTexture(0);
5573 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5574 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5577 // apply subtract last
5578 // (just like it would be in a GLSL shader)
5579 if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract)
5581 GL_BlendFunc(GL_ONE, GL_ZERO);
5582 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5583 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5584 GL_Color(1, 1, 1, 1);
5585 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5586 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5588 GL_BlendFunc(GL_ONE, GL_ONE);
5589 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
5590 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5591 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5592 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
5593 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5594 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5595 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
5597 // copy the darkened bloom view to a texture
5598 R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_bloom), 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);
5599 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5603 void R_HDR_RenderBloomTexture(void)
5605 int oldwidth, oldheight;
5606 float oldcolorscale;
5608 oldcolorscale = r_refdef.view.colorscale;
5609 oldwidth = r_refdef.view.width;
5610 oldheight = r_refdef.view.height;
5611 r_refdef.view.width = r_bloomstate.bloomwidth;
5612 r_refdef.view.height = r_bloomstate.bloomheight;
5614 // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer? it might improve SLI performance.
5615 // TODO: add exposure compensation features
5616 // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
5618 r_refdef.view.showdebug = false;
5619 r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
5621 R_ResetViewRendering3D();
5623 R_ClearScreen(r_refdef.fogenabled);
5624 if (r_timereport_active)
5625 R_TimeReport("HDRclear");
5628 if (r_timereport_active)
5629 R_TimeReport("visibility");
5631 // only do secondary renders with HDR if r_hdr is 2 or higher
5632 r_waterstate.numwaterplanes = 0;
5633 if (r_waterstate.enabled && r_hdr.integer >= 2)
5634 R_RenderWaterPlanes();
5636 r_refdef.view.showdebug = true;
5638 r_waterstate.numwaterplanes = 0;
5640 R_ResetViewRendering2D();
5642 R_Bloom_CopyHDRTexture();
5643 R_Bloom_MakeTexture();
5645 // restore the view settings
5646 r_refdef.view.width = oldwidth;
5647 r_refdef.view.height = oldheight;
5648 r_refdef.view.colorscale = oldcolorscale;
5649 r_frame++; // used only by R_GetCurrentTexture
5651 R_ResetViewRendering3D();
5653 R_ClearScreen(r_refdef.fogenabled);
5654 if (r_timereport_active)
5655 R_TimeReport("viewclear");
5658 static void R_BlendView(void)
5660 unsigned int permutation;
5661 float uservecs[4][4];
5663 switch (vid.renderpath)
5665 case RENDERPATH_GL20:
5666 case RENDERPATH_CGGL:
5668 (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
5669 | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
5670 | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
5671 | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
5672 | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
5674 if (r_bloomstate.texture_screen)
5676 // make sure the buffer is available
5677 if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
5679 R_ResetViewRendering2D();
5680 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5681 R_Mesh_ColorPointer(NULL, 0, 0);
5683 if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
5685 // declare variables
5687 static float avgspeed;
5689 speed = VectorLength(cl.movement_velocity);
5691 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
5692 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
5694 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
5695 speed = bound(0, speed, 1);
5696 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
5698 // calculate values into a standard alpha
5699 cl.motionbluralpha = 1 - exp(-
5701 (r_motionblur.value * speed / 80)
5703 (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
5706 max(0.0001, cl.time - cl.oldtime) // fps independent
5709 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
5710 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
5712 if (cl.motionbluralpha > 0)
5714 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5715 GL_Color(1, 1, 1, cl.motionbluralpha);
5716 R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5717 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5718 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5719 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5723 // copy view into the screen texture
5724 R_Mesh_CopyToTexture(R_GetTexture(r_bloomstate.texture_screen), 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5725 r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5727 else if (!r_bloomstate.texture_bloom)
5729 // we may still have to do view tint...
5730 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5732 // apply a color tint to the whole view
5733 R_ResetViewRendering2D();
5734 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5735 R_Mesh_ColorPointer(NULL, 0, 0);
5736 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5737 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5738 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5739 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5741 break; // no screen processing, no bloom, skip it
5744 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
5746 // render simple bloom effect
5747 // copy the screen and shrink it and darken it for the bloom process
5748 R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
5749 // make the bloom texture
5750 R_Bloom_MakeTexture();
5753 #if _MSC_VER >= 1400
5754 #define sscanf sscanf_s
5756 memset(uservecs, 0, sizeof(uservecs));
5757 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
5758 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
5759 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
5760 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
5762 R_ResetViewRendering2D();
5763 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5764 R_Mesh_ColorPointer(NULL, 0, 0);
5765 GL_Color(1, 1, 1, 1);
5766 GL_BlendFunc(GL_ONE, GL_ZERO);
5767 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5768 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5770 switch(vid.renderpath)
5772 case RENDERPATH_GL20:
5773 R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
5774 if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST , R_GetTexture(r_bloomstate.texture_screen));
5775 if (r_glsl_permutation->loc_Texture_Second >= 0) R_Mesh_TexBind(GL20TU_SECOND , R_GetTexture(r_bloomstate.texture_bloom ));
5776 if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, R_GetTexture(r_texture_gammaramps ));
5777 if (r_glsl_permutation->loc_ViewTintColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5778 if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime , cl.time);
5779 if (r_glsl_permutation->loc_PixelSize >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
5780 if (r_glsl_permutation->loc_UserVec1 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
5781 if (r_glsl_permutation->loc_UserVec2 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
5782 if (r_glsl_permutation->loc_UserVec3 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
5783 if (r_glsl_permutation->loc_UserVec4 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
5784 if (r_glsl_permutation->loc_Saturation >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation , r_glsl_saturation.value);
5786 case RENDERPATH_CGGL:
5788 R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
5789 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , R_GetTexture(r_bloomstate.texture_screen));CHECKCGERROR
5790 if (r_cg_permutation->fp_Texture_Second ) CG_BindTexture(r_cg_permutation->fp_Texture_Second , R_GetTexture(r_bloomstate.texture_bloom ));CHECKCGERROR
5791 if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, R_GetTexture(r_texture_gammaramps ));CHECKCGERROR
5792 if (r_cg_permutation->fp_ViewTintColor ) cgGLSetParameter4f( r_cg_permutation->fp_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);CHECKCGERROR
5793 if (r_cg_permutation->fp_ClientTime ) cgGLSetParameter1f( r_cg_permutation->fp_ClientTime , cl.time);CHECKCGERROR
5794 if (r_cg_permutation->fp_PixelSize ) cgGLSetParameter2f( r_cg_permutation->fp_PixelSize , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
5795 if (r_cg_permutation->fp_UserVec1 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);CHECKCGERROR
5796 if (r_cg_permutation->fp_UserVec2 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);CHECKCGERROR
5797 if (r_cg_permutation->fp_UserVec3 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);CHECKCGERROR
5798 if (r_cg_permutation->fp_UserVec4 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);CHECKCGERROR
5799 if (r_cg_permutation->fp_Saturation ) cgGLSetParameter1f( r_cg_permutation->fp_Saturation , r_glsl_saturation.value);CHECKCGERROR
5805 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5806 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5808 case RENDERPATH_GL13:
5809 case RENDERPATH_GL11:
5810 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5812 // apply a color tint to the whole view
5813 R_ResetViewRendering2D();
5814 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5815 R_Mesh_ColorPointer(NULL, 0, 0);
5816 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5817 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5818 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5819 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5825 matrix4x4_t r_waterscrollmatrix;
5827 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
5829 if (r_refdef.fog_density)
5831 r_refdef.fogcolor[0] = r_refdef.fog_red;
5832 r_refdef.fogcolor[1] = r_refdef.fog_green;
5833 r_refdef.fogcolor[2] = r_refdef.fog_blue;
5835 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
5836 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
5837 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
5838 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
5842 VectorCopy(r_refdef.fogcolor, fogvec);
5843 // color.rgb *= ContrastBoost * SceneBrightness;
5844 VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
5845 r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
5846 r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
5847 r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
5852 void R_UpdateVariables(void)
5856 r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
5858 r_refdef.farclip = r_farclip_base.value;
5859 if (r_refdef.scene.worldmodel)
5860 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
5861 r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
5863 if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
5864 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
5865 r_refdef.polygonfactor = 0;
5866 r_refdef.polygonoffset = 0;
5867 r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5868 r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5870 r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
5871 r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
5872 r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
5873 r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
5874 r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
5875 if (r_showsurfaces.integer)
5877 r_refdef.scene.rtworld = false;
5878 r_refdef.scene.rtworldshadows = false;
5879 r_refdef.scene.rtdlight = false;
5880 r_refdef.scene.rtdlightshadows = false;
5881 r_refdef.lightmapintensity = 0;
5884 if (gamemode == GAME_NEHAHRA)
5886 if (gl_fogenable.integer)
5888 r_refdef.oldgl_fogenable = true;
5889 r_refdef.fog_density = gl_fogdensity.value;
5890 r_refdef.fog_red = gl_fogred.value;
5891 r_refdef.fog_green = gl_foggreen.value;
5892 r_refdef.fog_blue = gl_fogblue.value;
5893 r_refdef.fog_alpha = 1;
5894 r_refdef.fog_start = 0;
5895 r_refdef.fog_end = gl_skyclip.value;
5896 r_refdef.fog_height = 1<<30;
5897 r_refdef.fog_fadedepth = 128;
5899 else if (r_refdef.oldgl_fogenable)
5901 r_refdef.oldgl_fogenable = false;
5902 r_refdef.fog_density = 0;
5903 r_refdef.fog_red = 0;
5904 r_refdef.fog_green = 0;
5905 r_refdef.fog_blue = 0;
5906 r_refdef.fog_alpha = 0;
5907 r_refdef.fog_start = 0;
5908 r_refdef.fog_end = 0;
5909 r_refdef.fog_height = 1<<30;
5910 r_refdef.fog_fadedepth = 128;
5914 r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
5915 r_refdef.fog_start = max(0, r_refdef.fog_start);
5916 r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
5918 // R_UpdateFogColor(); // why? R_RenderScene does it anyway
5920 if (r_refdef.fog_density && r_drawfog.integer)
5922 r_refdef.fogenabled = true;
5923 // this is the point where the fog reaches 0.9986 alpha, which we
5924 // consider a good enough cutoff point for the texture
5925 // (0.9986 * 256 == 255.6)
5926 if (r_fog_exp2.integer)
5927 r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
5929 r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
5930 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
5931 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
5932 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
5933 // fog color was already set
5934 // update the fog texture
5935 if (r_refdef.fogmasktable_start != r_refdef.fog_start || r_refdef.fogmasktable_alpha != r_refdef.fog_alpha || r_refdef.fogmasktable_density != r_refdef.fog_density || r_refdef.fogmasktable_range != r_refdef.fogrange)
5936 R_BuildFogTexture();
5939 r_refdef.fogenabled = false;
5941 switch(vid.renderpath)
5943 case RENDERPATH_GL20:
5944 case RENDERPATH_CGGL:
5945 if(v_glslgamma.integer && !vid_gammatables_trivial)
5947 if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
5949 // build GLSL gamma texture
5950 #define RAMPWIDTH 256
5951 unsigned short ramp[RAMPWIDTH * 3];
5952 unsigned char rampbgr[RAMPWIDTH][4];
5955 r_texture_gammaramps_serial = vid_gammatables_serial;
5957 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
5958 for(i = 0; i < RAMPWIDTH; ++i)
5960 rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5961 rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5962 rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
5965 if (r_texture_gammaramps)
5967 R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
5971 r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT | TEXF_ALLOWUPDATES, NULL);
5977 // remove GLSL gamma texture
5980 case RENDERPATH_GL13:
5981 case RENDERPATH_GL11:
5986 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
5987 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
5993 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
5994 if( scenetype != r_currentscenetype ) {
5995 // store the old scenetype
5996 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
5997 r_currentscenetype = scenetype;
5998 // move in the new scene
5999 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
6008 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
6010 // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
6011 if( scenetype == r_currentscenetype ) {
6012 return &r_refdef.scene;
6014 return &r_scenes_store[ scenetype ];
6023 void R_RenderView(void)
6025 if (r_timereport_active)
6026 R_TimeReport("start");
6027 r_frame++; // used only by R_GetCurrentTexture
6028 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
6030 if (!r_drawentities.integer)
6031 r_refdef.scene.numentities = 0;
6033 R_AnimCache_ClearCache();
6034 R_FrameData_NewFrame();
6036 if (r_refdef.view.isoverlay)
6038 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
6039 GL_Clear( GL_DEPTH_BUFFER_BIT );
6040 R_TimeReport("depthclear");
6042 r_refdef.view.showdebug = false;
6044 r_waterstate.enabled = false;
6045 r_waterstate.numwaterplanes = 0;
6053 if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer/* || !r_refdef.scene.worldmodel*/)
6054 return; //Host_Error ("R_RenderView: NULL worldmodel");
6056 r_refdef.view.colorscale = r_hdr_scenebrightness.value;
6058 // break apart the view matrix into vectors for various purposes
6059 // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
6060 // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
6061 Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
6062 VectorNegate(r_refdef.view.left, r_refdef.view.right);
6063 // make an inverted copy of the view matrix for tracking sprites
6064 Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
6066 R_Shadow_UpdateWorldLightSelection();
6068 R_Bloom_StartFrame();
6069 R_Water_StartFrame();
6072 if (r_timereport_active)
6073 R_TimeReport("viewsetup");
6075 R_ResetViewRendering3D();
6077 if (r_refdef.view.clear || r_refdef.fogenabled)
6079 R_ClearScreen(r_refdef.fogenabled);
6080 if (r_timereport_active)
6081 R_TimeReport("viewclear");
6083 r_refdef.view.clear = true;
6085 // this produces a bloom texture to be used in R_BlendView() later
6086 if (r_hdr.integer && r_bloomstate.bloomwidth)
6087 R_HDR_RenderBloomTexture();
6089 r_refdef.view.showdebug = true;
6092 if (r_timereport_active)
6093 R_TimeReport("visibility");
6095 r_waterstate.numwaterplanes = 0;
6096 if (r_waterstate.enabled)
6097 R_RenderWaterPlanes();
6100 r_waterstate.numwaterplanes = 0;
6103 if (r_timereport_active)
6104 R_TimeReport("blendview");
6106 GL_Scissor(0, 0, vid.width, vid.height);
6107 GL_ScissorTest(false);
6111 void R_RenderWaterPlanes(void)
6113 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
6115 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
6116 if (r_timereport_active)
6117 R_TimeReport("waterworld");
6120 // don't let sound skip if going slow
6121 if (r_refdef.scene.extraupdate)
6124 R_DrawModelsAddWaterPlanes();
6125 if (r_timereport_active)
6126 R_TimeReport("watermodels");
6128 if (r_waterstate.numwaterplanes)
6130 R_Water_ProcessPlanes();
6131 if (r_timereport_active)
6132 R_TimeReport("waterscenes");
6136 extern void R_DrawLightningBeams (void);
6137 extern void VM_CL_AddPolygonsToMeshQueue (void);
6138 extern void R_DrawPortals (void);
6139 extern cvar_t cl_locs_show;
6140 static void R_DrawLocs(void);
6141 static void R_DrawEntityBBoxes(void);
6142 static void R_DrawModelDecals(void);
6143 extern cvar_t cl_decals_newsystem;
6144 extern qboolean r_shadow_usingdeferredprepass;
6145 void R_RenderScene(void)
6147 r_refdef.stats.renders++;
6151 // don't let sound skip if going slow
6152 if (r_refdef.scene.extraupdate)
6155 R_MeshQueue_BeginScene();
6159 Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.scene.time) * 0.025 * r_waterscroll.value, sin(r_refdef.scene.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
6161 if (cl.csqc_vidvars.drawworld)
6163 // don't let sound skip if going slow
6164 if (r_refdef.scene.extraupdate)
6167 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
6169 r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
6170 if (r_timereport_active)
6171 R_TimeReport("worldsky");
6174 if (R_DrawBrushModelsSky() && r_timereport_active)
6175 R_TimeReport("bmodelsky");
6177 if (skyrendermasked && skyrenderlater)
6179 // we have to force off the water clipping plane while rendering sky
6183 if (r_timereport_active)
6184 R_TimeReport("sky");
6188 R_AnimCache_CacheVisibleEntities();
6189 if (r_timereport_active)
6190 R_TimeReport("animation");
6192 R_Shadow_PrepareLights();
6193 if (r_timereport_active)
6194 R_TimeReport("preparelights");
6196 if (r_shadow_usingdeferredprepass)
6197 R_Shadow_DrawPrepass();
6199 if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
6201 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
6202 if (r_timereport_active)
6203 R_TimeReport("worlddepth");
6205 if (r_depthfirst.integer >= 2)
6207 R_DrawModelsDepth();
6208 if (r_timereport_active)
6209 R_TimeReport("modeldepth");
6212 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
6214 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
6215 if (r_timereport_active)
6216 R_TimeReport("world");
6219 // don't let sound skip if going slow
6220 if (r_refdef.scene.extraupdate)
6224 if (r_timereport_active)
6225 R_TimeReport("models");
6227 // don't let sound skip if going slow
6228 if (r_refdef.scene.extraupdate)
6231 if (r_shadows.integer > 0 && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6233 R_DrawModelShadows();
6234 R_ResetViewRendering3D();
6235 // don't let sound skip if going slow
6236 if (r_refdef.scene.extraupdate)
6240 if (!r_shadow_usingdeferredprepass)
6242 R_Shadow_DrawLights();
6243 if (r_timereport_active)
6244 R_TimeReport("rtlights");
6247 // don't let sound skip if going slow
6248 if (r_refdef.scene.extraupdate)
6251 if (r_shadows.integer > 0 && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6253 R_DrawModelShadows();
6254 R_ResetViewRendering3D();
6255 // don't let sound skip if going slow
6256 if (r_refdef.scene.extraupdate)
6260 if (cl.csqc_vidvars.drawworld)
6262 if (cl_decals_newsystem.integer)
6264 R_DrawModelDecals();
6265 if (r_timereport_active)
6266 R_TimeReport("modeldecals");
6271 if (r_timereport_active)
6272 R_TimeReport("decals");
6276 if (r_timereport_active)
6277 R_TimeReport("particles");
6280 if (r_timereport_active)
6281 R_TimeReport("explosions");
6283 R_DrawLightningBeams();
6284 if (r_timereport_active)
6285 R_TimeReport("lightning");
6288 VM_CL_AddPolygonsToMeshQueue();
6290 if (r_refdef.view.showdebug)
6292 if (cl_locs_show.integer)
6295 if (r_timereport_active)
6296 R_TimeReport("showlocs");
6299 if (r_drawportals.integer)
6302 if (r_timereport_active)
6303 R_TimeReport("portals");
6306 if (r_showbboxes.value > 0)
6308 R_DrawEntityBBoxes();
6309 if (r_timereport_active)
6310 R_TimeReport("bboxes");
6314 R_MeshQueue_RenderTransparent();
6315 if (r_timereport_active)
6316 R_TimeReport("drawtrans");
6318 if (r_refdef.view.showdebug && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value != 0 || r_showcollisionbrushes.value > 0))
6320 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
6321 if (r_timereport_active)
6322 R_TimeReport("worlddebug");
6323 R_DrawModelsDebug();
6324 if (r_timereport_active)
6325 R_TimeReport("modeldebug");
6328 if (cl.csqc_vidvars.drawworld)
6330 R_Shadow_DrawCoronas();
6331 if (r_timereport_active)
6332 R_TimeReport("coronas");
6335 // don't let sound skip if going slow
6336 if (r_refdef.scene.extraupdate)
6339 R_ResetViewRendering2D();
6342 static const unsigned short bboxelements[36] =
6352 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
6355 float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
6357 RSurf_ActiveWorldEntity();
6359 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6360 GL_DepthMask(false);
6361 GL_DepthRange(0, 1);
6362 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6363 R_Mesh_ResetTextureState();
6365 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
6366 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
6367 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
6368 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
6369 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
6370 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
6371 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
6372 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
6373 R_FillColors(color4f, 8, cr, cg, cb, ca);
6374 if (r_refdef.fogenabled)
6376 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
6378 f1 = RSurf_FogVertex(v);
6380 c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
6381 c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
6382 c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
6385 R_Mesh_VertexPointer(vertex3f, 0, 0);
6386 R_Mesh_ColorPointer(color4f, 0, 0);
6387 R_Mesh_ResetTextureState();
6388 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6389 R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
6392 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6396 prvm_edict_t *edict;
6397 prvm_prog_t *prog_save = prog;
6399 // this function draws bounding boxes of server entities
6403 GL_CullFace(GL_NONE);
6404 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6408 for (i = 0;i < numsurfaces;i++)
6410 edict = PRVM_EDICT_NUM(surfacelist[i]);
6411 switch ((int)edict->fields.server->solid)
6413 case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
6414 case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
6415 case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
6416 case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
6417 case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
6418 default: Vector4Set(color, 0, 0, 0, 0.50);break;
6420 color[3] *= r_showbboxes.value;
6421 color[3] = bound(0, color[3], 1);
6422 GL_DepthTest(!r_showdisabledepthtest.integer);
6423 GL_CullFace(r_refdef.view.cullface_front);
6424 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
6430 static void R_DrawEntityBBoxes(void)
6433 prvm_edict_t *edict;
6435 prvm_prog_t *prog_save = prog;
6437 // this function draws bounding boxes of server entities
6443 for (i = 0;i < prog->num_edicts;i++)
6445 edict = PRVM_EDICT_NUM(i);
6446 if (edict->priv.server->free)
6448 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
6449 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
6451 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
6453 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
6454 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
6460 static const int nomodelelement3i[24] =
6472 static const unsigned short nomodelelement3s[24] =
6484 static const float nomodelvertex3f[6*3] =
6494 static const float nomodelcolor4f[6*4] =
6496 0.0f, 0.0f, 0.5f, 1.0f,
6497 0.0f, 0.0f, 0.5f, 1.0f,
6498 0.0f, 0.5f, 0.0f, 1.0f,
6499 0.0f, 0.5f, 0.0f, 1.0f,
6500 0.5f, 0.0f, 0.0f, 1.0f,
6501 0.5f, 0.0f, 0.0f, 1.0f
6504 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6510 RSurf_ActiveCustomEntity(&ent->matrix, &ent->inversematrix, ent->flags, ent->shadertime, ent->colormod[0], ent->colormod[1], ent->colormod[2], ent->alpha, 6, nomodelvertex3f, NULL, NULL, NULL, NULL, nomodelcolor4f, 8, nomodelelement3i, nomodelelement3s, false, false);
6512 // this is only called once per entity so numsurfaces is always 1, and
6513 // surfacelist is always {0}, so this code does not handle batches
6515 if (rsurface.ent_flags & RENDER_ADDITIVE)
6517 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
6518 GL_DepthMask(false);
6520 else if (rsurface.colormod[3] < 1)
6522 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6523 GL_DepthMask(false);
6527 GL_BlendFunc(GL_ONE, GL_ZERO);
6530 GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
6531 GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
6532 GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
6533 GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
6534 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6535 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
6536 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
6537 R_Mesh_ColorPointer(color4f, 0, 0);
6538 for (i = 0, c = color4f;i < 6;i++, c += 4)
6540 c[0] *= rsurface.colormod[0];
6541 c[1] *= rsurface.colormod[1];
6542 c[2] *= rsurface.colormod[2];
6543 c[3] *= rsurface.colormod[3];
6545 if (r_refdef.fogenabled)
6547 for (i = 0, c = color4f;i < 6;i++, c += 4)
6549 f1 = RSurf_FogVertex(rsurface.vertex3f + 3*i);
6551 c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
6552 c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
6553 c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
6556 R_Mesh_ResetTextureState();
6557 R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, nomodelelement3s, 0, 0);
6560 void R_DrawNoModel(entity_render_t *ent)
6563 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
6564 if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
6565 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
6567 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
6570 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
6572 vec3_t right1, right2, diff, normal;
6574 VectorSubtract (org2, org1, normal);
6576 // calculate 'right' vector for start
6577 VectorSubtract (r_refdef.view.origin, org1, diff);
6578 CrossProduct (normal, diff, right1);
6579 VectorNormalize (right1);
6581 // calculate 'right' vector for end
6582 VectorSubtract (r_refdef.view.origin, org2, diff);
6583 CrossProduct (normal, diff, right2);
6584 VectorNormalize (right2);
6586 vert[ 0] = org1[0] + width * right1[0];
6587 vert[ 1] = org1[1] + width * right1[1];
6588 vert[ 2] = org1[2] + width * right1[2];
6589 vert[ 3] = org1[0] - width * right1[0];
6590 vert[ 4] = org1[1] - width * right1[1];
6591 vert[ 5] = org1[2] - width * right1[2];
6592 vert[ 6] = org2[0] - width * right2[0];
6593 vert[ 7] = org2[1] - width * right2[1];
6594 vert[ 8] = org2[2] - width * right2[2];
6595 vert[ 9] = org2[0] + width * right2[0];
6596 vert[10] = org2[1] + width * right2[1];
6597 vert[11] = org2[2] + width * right2[2];
6600 void R_CalcSprite_Vertex3f(float *vertex3f, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2)
6602 vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
6603 vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
6604 vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
6605 vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
6606 vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
6607 vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
6608 vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
6609 vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
6610 vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
6611 vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
6612 vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
6613 vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
6616 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
6621 VectorSet(v, x, y, z);
6622 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
6623 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
6625 if (i == mesh->numvertices)
6627 if (mesh->numvertices < mesh->maxvertices)
6629 VectorCopy(v, vertex3f);
6630 mesh->numvertices++;
6632 return mesh->numvertices;
6638 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
6642 element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6643 element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6644 e = mesh->element3i + mesh->numtriangles * 3;
6645 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
6647 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
6648 if (mesh->numtriangles < mesh->maxtriangles)
6653 mesh->numtriangles++;
6655 element[1] = element[2];
6659 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
6663 element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6664 element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6665 e = mesh->element3i + mesh->numtriangles * 3;
6666 for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
6668 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
6669 if (mesh->numtriangles < mesh->maxtriangles)
6674 mesh->numtriangles++;
6676 element[1] = element[2];
6680 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
6681 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
6683 int planenum, planenum2;
6686 mplane_t *plane, *plane2;
6688 double temppoints[2][256*3];
6689 // figure out how large a bounding box we need to properly compute this brush
6691 for (w = 0;w < numplanes;w++)
6692 maxdist = max(maxdist, fabs(planes[w].dist));
6693 // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
6694 maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
6695 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
6699 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
6700 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
6702 if (planenum2 == planenum)
6704 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);
6707 if (tempnumpoints < 3)
6709 // generate elements forming a triangle fan for this polygon
6710 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
6714 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)
6716 texturelayer_t *layer;
6717 layer = t->currentlayers + t->currentnumlayers++;
6719 layer->depthmask = depthmask;
6720 layer->blendfunc1 = blendfunc1;
6721 layer->blendfunc2 = blendfunc2;
6722 layer->texture = texture;
6723 layer->texmatrix = *matrix;
6724 layer->color[0] = r;
6725 layer->color[1] = g;
6726 layer->color[2] = b;
6727 layer->color[3] = a;
6730 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
6733 index = parms[2] + r_refdef.scene.time * parms[3];
6734 index -= floor(index);
6738 case Q3WAVEFUNC_NONE:
6739 case Q3WAVEFUNC_NOISE:
6740 case Q3WAVEFUNC_COUNT:
6743 case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
6744 case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
6745 case Q3WAVEFUNC_SAWTOOTH: f = index;break;
6746 case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
6747 case Q3WAVEFUNC_TRIANGLE:
6749 f = index - floor(index);
6760 return (float)(parms[0] + parms[1] * f);
6763 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
6768 matrix4x4_t matrix, temp;
6769 switch(tcmod->tcmod)
6773 if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6774 matrix = r_waterscrollmatrix;
6776 matrix = identitymatrix;
6778 case Q3TCMOD_ENTITYTRANSLATE:
6779 // this is used in Q3 to allow the gamecode to control texcoord
6780 // scrolling on the entity, which is not supported in darkplaces yet.
6781 Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
6783 case Q3TCMOD_ROTATE:
6784 Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
6785 Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
6786 Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
6789 Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
6791 case Q3TCMOD_SCROLL:
6792 Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
6794 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
6795 w = (int) tcmod->parms[0];
6796 h = (int) tcmod->parms[1];
6797 f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
6799 idx = (int) floor(f * w * h);
6800 Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
6802 case Q3TCMOD_STRETCH:
6803 f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
6804 Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
6806 case Q3TCMOD_TRANSFORM:
6807 VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
6808 VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
6809 VectorSet(tcmat + 6, 0 , 0 , 1);
6810 VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
6811 Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
6813 case Q3TCMOD_TURBULENT:
6814 // this is handled in the RSurf_PrepareVertices function
6815 matrix = identitymatrix;
6819 Matrix4x4_Concat(texmatrix, &matrix, &temp);
6822 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
6824 int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
6825 char name[MAX_QPATH];
6826 skinframe_t *skinframe;
6827 unsigned char pixels[296*194];
6828 strlcpy(cache->name, skinname, sizeof(cache->name));
6829 dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
6830 if (developer_loading.integer)
6831 Con_Printf("loading %s\n", name);
6832 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
6833 if (!skinframe || !skinframe->base)
6836 fs_offset_t filesize;
6838 f = FS_LoadFile(name, tempmempool, true, &filesize);
6841 if (LoadPCX_QWSkin(f, filesize, pixels, 296, 194))
6842 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
6846 cache->skinframe = skinframe;
6849 texture_t *R_GetCurrentTexture(texture_t *t)
6852 const entity_render_t *ent = rsurface.entity;
6853 dp_model_t *model = ent->model;
6854 q3shaderinfo_layer_tcmod_t *tcmod;
6856 if (t->update_lastrenderframe == r_frame && t->update_lastrenderentity == (void *)ent)
6857 return t->currentframe;
6858 t->update_lastrenderframe = r_frame;
6859 t->update_lastrenderentity = (void *)ent;
6861 // switch to an alternate material if this is a q1bsp animated material
6863 texture_t *texture = t;
6864 int s = rsurface.ent_skinnum;
6865 if ((unsigned int)s >= (unsigned int)model->numskins)
6867 if (model->skinscenes)
6869 if (model->skinscenes[s].framecount > 1)
6870 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
6872 s = model->skinscenes[s].firstframe;
6875 t = t + s * model->num_surfaces;
6878 // use an alternate animation if the entity's frame is not 0,
6879 // and only if the texture has an alternate animation
6880 if (rsurface.ent_alttextures && t->anim_total[1])
6881 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
6883 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
6885 texture->currentframe = t;
6888 // update currentskinframe to be a qw skin or animation frame
6889 if (rsurface.ent_qwskin >= 0)
6891 i = rsurface.ent_qwskin;
6892 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
6894 r_qwskincache_size = cl.maxclients;
6896 Mem_Free(r_qwskincache);
6897 r_qwskincache = Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
6899 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
6900 R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
6901 t->currentskinframe = r_qwskincache[i].skinframe;
6902 if (t->currentskinframe == NULL)
6903 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6905 else if (t->numskinframes >= 2)
6906 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6907 if (t->backgroundnumskinframes >= 2)
6908 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
6910 t->currentmaterialflags = t->basematerialflags;
6911 t->currentalpha = rsurface.colormod[3];
6912 if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
6913 t->currentalpha *= r_wateralpha.value;
6914 if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
6915 t->currentalpha *= t->r_water_wateralpha;
6916 if(!r_waterstate.enabled || r_refdef.view.isoverlay)
6917 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
6918 if (!(rsurface.ent_flags & RENDER_LIGHT))
6919 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
6920 else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
6922 // pick a model lighting mode
6923 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
6924 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
6926 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
6928 if (rsurface.ent_flags & RENDER_ADDITIVE)
6929 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6930 else if (t->currentalpha < 1)
6931 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6932 if (rsurface.ent_flags & RENDER_DOUBLESIDED)
6933 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
6934 if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
6935 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
6936 if (t->backgroundnumskinframes)
6937 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
6938 if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
6940 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER))
6941 t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
6944 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER);
6945 if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
6946 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
6948 // there is no tcmod
6949 if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6951 t->currenttexmatrix = r_waterscrollmatrix;
6952 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
6954 else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
6956 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
6957 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
6960 for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6961 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
6962 for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6963 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
6965 t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
6966 if (t->currentskinframe->qpixels)
6967 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
6968 t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
6969 t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
6970 t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
6971 t->nmaptexture = t->currentskinframe->nmap;
6972 t->glosstexture = r_texture_black;
6973 t->glowtexture = t->currentskinframe->glow;
6974 t->fogtexture = t->currentskinframe->fog;
6975 if (t->backgroundnumskinframes)
6977 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
6978 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
6979 t->backgroundglosstexture = r_texture_black;
6980 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
6984 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
6985 t->backgroundnmaptexture = r_texture_blanknormalmap;
6986 t->backgroundglosstexture = r_texture_black;
6987 t->backgroundglowtexture = NULL;
6989 t->specularpower = r_shadow_glossexponent.value;
6990 // TODO: store reference values for these in the texture?
6991 t->specularscale = 0;
6992 if (r_shadow_gloss.integer > 0)
6994 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
6996 if (r_shadow_glossintensity.value > 0)
6998 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
6999 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
7000 t->specularscale = r_shadow_glossintensity.value;
7003 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
7005 t->glosstexture = r_texture_white;
7006 t->backgroundglosstexture = r_texture_white;
7007 t->specularscale = r_shadow_gloss2intensity.value;
7008 t->specularpower = r_shadow_gloss2exponent.value;
7011 t->specularscale *= t->specularscalemod;
7012 t->specularpower *= t->specularpowermod;
7014 // lightmaps mode looks bad with dlights using actual texturing, so turn
7015 // off the colormap and glossmap, but leave the normalmap on as it still
7016 // accurately represents the shading involved
7017 if (gl_lightmaps.integer)
7019 t->basetexture = r_texture_grey128;
7020 t->pantstexture = r_texture_black;
7021 t->shirttexture = r_texture_black;
7022 t->nmaptexture = r_texture_blanknormalmap;
7023 t->glosstexture = r_texture_black;
7024 t->glowtexture = NULL;
7025 t->fogtexture = NULL;
7026 t->backgroundbasetexture = NULL;
7027 t->backgroundnmaptexture = r_texture_blanknormalmap;
7028 t->backgroundglosstexture = r_texture_black;
7029 t->backgroundglowtexture = NULL;
7030 t->specularscale = 0;
7031 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
7034 Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
7035 VectorClear(t->dlightcolor);
7036 t->currentnumlayers = 0;
7037 if (t->currentmaterialflags & MATERIALFLAG_WALL)
7039 int blendfunc1, blendfunc2;
7041 if (t->currentmaterialflags & MATERIALFLAG_ADD)
7043 blendfunc1 = GL_SRC_ALPHA;
7044 blendfunc2 = GL_ONE;
7046 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
7048 blendfunc1 = GL_SRC_ALPHA;
7049 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
7051 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
7053 blendfunc1 = t->customblendfunc[0];
7054 blendfunc2 = t->customblendfunc[1];
7058 blendfunc1 = GL_ONE;
7059 blendfunc2 = GL_ZERO;
7061 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
7062 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
7064 // fullbright is not affected by r_refdef.lightmapintensity
7065 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, t->basetexture, &t->currenttexmatrix, t->lightmapcolor[0], t->lightmapcolor[1], t->lightmapcolor[2], t->lightmapcolor[3]);
7066 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7067 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * t->lightmapcolor[0], rsurface.colormap_pantscolor[1] * t->lightmapcolor[1], rsurface.colormap_pantscolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
7068 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7069 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * t->lightmapcolor[0], rsurface.colormap_shirtcolor[1] * t->lightmapcolor[1], rsurface.colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
7073 vec3_t ambientcolor;
7075 // set the color tint used for lights affecting this surface
7076 VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
7078 // q3bsp has no lightmap updates, so the lightstylevalue that
7079 // would normally be baked into the lightmap must be
7080 // applied to the color
7081 // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
7082 if (model->type == mod_brushq3)
7083 colorscale *= r_refdef.scene.rtlightstylevalue[0];
7084 colorscale *= r_refdef.lightmapintensity;
7085 VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
7086 VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
7087 // basic lit geometry
7088 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, t->basetexture, &t->currenttexmatrix, t->lightmapcolor[0], t->lightmapcolor[1], t->lightmapcolor[2], t->lightmapcolor[3]);
7089 // add pants/shirt if needed
7090 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7091 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * t->lightmapcolor[0], rsurface.colormap_pantscolor[1] * t->lightmapcolor[1], rsurface.colormap_pantscolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
7092 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7093 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * t->lightmapcolor[0], rsurface.colormap_shirtcolor[1] * t->lightmapcolor[1], rsurface.colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
7094 // now add ambient passes if needed
7095 if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
7097 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->basetexture, &t->currenttexmatrix, ambientcolor[0], ambientcolor[1], ambientcolor[2], t->lightmapcolor[3]);
7098 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7099 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * ambientcolor[0], rsurface.colormap_pantscolor[1] * ambientcolor[1], rsurface.colormap_pantscolor[2] * ambientcolor[2], t->lightmapcolor[3]);
7100 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7101 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * ambientcolor[0], rsurface.colormap_shirtcolor[1] * ambientcolor[1], rsurface.colormap_shirtcolor[2] * ambientcolor[2], t->lightmapcolor[3]);
7104 if (t->glowtexture != NULL && !gl_lightmaps.integer)
7105 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->glowtexture, &t->currenttexmatrix, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2], t->lightmapcolor[3]);
7106 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
7108 // if this is opaque use alpha blend which will darken the earlier
7111 // if this is an alpha blended material, all the earlier passes
7112 // were darkened by fog already, so we only need to add the fog
7113 // color ontop through the fog mask texture
7115 // if this is an additive blended material, all the earlier passes
7116 // were darkened by fog already, and we should not add fog color
7117 // (because the background was not darkened, there is no fog color
7118 // that was lost behind it).
7119 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_BLENDED) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->fogtexture, &t->currenttexmatrix, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], t->lightmapcolor[3]);
7123 return t->currentframe;
7126 rsurfacestate_t rsurface;
7128 void R_Mesh_ResizeArrays(int newvertices)
7131 if (rsurface.array_size >= newvertices)
7133 if (rsurface.array_modelvertex3f)
7134 Mem_Free(rsurface.array_modelvertex3f);
7135 rsurface.array_size = (newvertices + 1023) & ~1023;
7136 base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
7137 rsurface.array_modelvertex3f = base + rsurface.array_size * 0;
7138 rsurface.array_modelsvector3f = base + rsurface.array_size * 3;
7139 rsurface.array_modeltvector3f = base + rsurface.array_size * 6;
7140 rsurface.array_modelnormal3f = base + rsurface.array_size * 9;
7141 rsurface.array_deformedvertex3f = base + rsurface.array_size * 12;
7142 rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
7143 rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
7144 rsurface.array_deformednormal3f = base + rsurface.array_size * 21;
7145 rsurface.array_texcoord3f = base + rsurface.array_size * 24;
7146 rsurface.array_color4f = base + rsurface.array_size * 27;
7147 rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
7150 void RSurf_ActiveWorldEntity(void)
7152 dp_model_t *model = r_refdef.scene.worldmodel;
7153 //if (rsurface.entity == r_refdef.scene.worldentity)
7155 rsurface.entity = r_refdef.scene.worldentity;
7156 rsurface.skeleton = NULL;
7157 rsurface.ent_skinnum = 0;
7158 rsurface.ent_qwskin = -1;
7159 rsurface.ent_shadertime = 0;
7160 rsurface.ent_flags = r_refdef.scene.worldentity->flags;
7161 if (rsurface.array_size < model->surfmesh.num_vertices)
7162 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7163 rsurface.matrix = identitymatrix;
7164 rsurface.inversematrix = identitymatrix;
7165 rsurface.matrixscale = 1;
7166 rsurface.inversematrixscale = 1;
7167 R_EntityMatrix(&identitymatrix);
7168 VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
7169 Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
7170 rsurface.fograngerecip = r_refdef.fograngerecip;
7171 rsurface.fogheightfade = r_refdef.fogheightfade;
7172 rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
7173 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7174 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7175 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7176 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7177 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7178 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7179 VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
7180 rsurface.colormod[3] = 1;
7181 VectorSet(rsurface.glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value);
7182 memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7183 rsurface.frameblend[0].lerp = 1;
7184 rsurface.ent_alttextures = false;
7185 rsurface.basepolygonfactor = r_refdef.polygonfactor;
7186 rsurface.basepolygonoffset = r_refdef.polygonoffset;
7187 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
7188 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7189 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7190 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7191 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7192 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7193 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7194 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7195 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7196 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
7197 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7198 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7199 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
7200 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7201 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7202 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
7203 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7204 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7205 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
7206 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7207 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7208 rsurface.modelelement3i = model->surfmesh.data_element3i;
7209 rsurface.modelelement3s = model->surfmesh.data_element3s;
7210 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7211 rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7212 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7213 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7214 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7215 rsurface.modelsurfaces = model->data_surfaces;
7216 rsurface.generatedvertex = false;
7217 rsurface.vertex3f = rsurface.modelvertex3f;
7218 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7219 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7220 rsurface.svector3f = rsurface.modelsvector3f;
7221 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7222 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7223 rsurface.tvector3f = rsurface.modeltvector3f;
7224 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7225 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7226 rsurface.normal3f = rsurface.modelnormal3f;
7227 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7228 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7229 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7232 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
7234 dp_model_t *model = ent->model;
7235 //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
7237 rsurface.entity = (entity_render_t *)ent;
7238 rsurface.skeleton = ent->skeleton;
7239 rsurface.ent_skinnum = ent->skinnum;
7240 rsurface.ent_qwskin = (ent->entitynumber <= cl.maxclients && ent->entitynumber >= 1 && cls.protocol == PROTOCOL_QUAKEWORLD && cl.scores[ent->entitynumber - 1].qw_skin[0] && !strcmp(ent->model->name, "progs/player.mdl")) ? (ent->entitynumber - 1) : -1;
7241 rsurface.ent_shadertime = ent->shadertime;
7242 rsurface.ent_flags = ent->flags;
7243 if (rsurface.array_size < model->surfmesh.num_vertices)
7244 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7245 rsurface.matrix = ent->matrix;
7246 rsurface.inversematrix = ent->inversematrix;
7247 rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7248 rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7249 R_EntityMatrix(&rsurface.matrix);
7250 Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7251 Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7252 rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7253 rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7254 rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7255 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7256 VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
7257 VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
7258 VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
7259 VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
7260 VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
7261 VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
7262 rsurface.colormod[3] = ent->alpha;
7263 VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
7264 memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
7265 rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
7266 rsurface.basepolygonfactor = r_refdef.polygonfactor;
7267 rsurface.basepolygonoffset = r_refdef.polygonoffset;
7268 if (ent->model->brush.submodel && !prepass)
7270 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
7271 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
7273 if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
7275 if (ent->animcache_vertex3f && !r_framedata_failed)
7277 rsurface.modelvertex3f = ent->animcache_vertex3f;
7278 rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
7279 rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
7280 rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
7282 else if (wanttangents)
7284 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7285 rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7286 rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7287 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7288 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
7290 else if (wantnormals)
7292 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7293 rsurface.modelsvector3f = NULL;
7294 rsurface.modeltvector3f = NULL;
7295 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7296 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
7300 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7301 rsurface.modelsvector3f = NULL;
7302 rsurface.modeltvector3f = NULL;
7303 rsurface.modelnormal3f = NULL;
7304 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
7306 rsurface.modelvertex3f_bufferobject = 0;
7307 rsurface.modelvertex3f_bufferoffset = 0;
7308 rsurface.modelsvector3f_bufferobject = 0;
7309 rsurface.modelsvector3f_bufferoffset = 0;
7310 rsurface.modeltvector3f_bufferobject = 0;
7311 rsurface.modeltvector3f_bufferoffset = 0;
7312 rsurface.modelnormal3f_bufferobject = 0;
7313 rsurface.modelnormal3f_bufferoffset = 0;
7314 rsurface.generatedvertex = true;
7318 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
7319 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7320 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7321 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7322 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7323 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7324 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7325 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7326 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7327 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
7328 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7329 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7330 rsurface.generatedvertex = false;
7332 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
7333 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7334 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7335 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
7336 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7337 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7338 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
7339 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7340 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7341 rsurface.modelelement3i = model->surfmesh.data_element3i;
7342 rsurface.modelelement3s = model->surfmesh.data_element3s;
7343 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7344 rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7345 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7346 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7347 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7348 rsurface.modelsurfaces = model->data_surfaces;
7349 rsurface.vertex3f = rsurface.modelvertex3f;
7350 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7351 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7352 rsurface.svector3f = rsurface.modelsvector3f;
7353 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7354 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7355 rsurface.tvector3f = rsurface.modeltvector3f;
7356 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7357 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7358 rsurface.normal3f = rsurface.modelnormal3f;
7359 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7360 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7361 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7364 void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, int entflags, double shadertime, float r, float g, float b, float a, int numvertices, const float *vertex3f, const float *texcoord2f, const float *normal3f, const float *svector3f, const float *tvector3f, const float *color4f, int numtriangles, const int *element3i, const unsigned short *element3s, qboolean wantnormals, qboolean wanttangents)
7366 rsurface.entity = r_refdef.scene.worldentity;
7367 rsurface.skeleton = NULL;
7368 rsurface.ent_skinnum = 0;
7369 rsurface.ent_qwskin = -1;
7370 rsurface.ent_shadertime = shadertime;
7371 rsurface.ent_flags = entflags;
7372 rsurface.modelnum_vertices = numvertices;
7373 rsurface.modelnum_triangles = numtriangles;
7374 if (rsurface.array_size < rsurface.modelnum_vertices)
7375 R_Mesh_ResizeArrays(rsurface.modelnum_vertices);
7376 rsurface.matrix = *matrix;
7377 rsurface.inversematrix = *inversematrix;
7378 rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7379 rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7380 R_EntityMatrix(&rsurface.matrix);
7381 Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7382 Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7383 rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7384 rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7385 rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7386 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7387 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7388 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7389 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7390 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7391 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7392 Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
7393 VectorSet(rsurface.glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value);
7394 memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7395 rsurface.frameblend[0].lerp = 1;
7396 rsurface.ent_alttextures = false;
7397 rsurface.basepolygonfactor = r_refdef.polygonfactor;
7398 rsurface.basepolygonoffset = r_refdef.polygonoffset;
7401 rsurface.modelvertex3f = vertex3f;
7402 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
7403 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
7404 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7406 else if (wantnormals)
7408 rsurface.modelvertex3f = vertex3f;
7409 rsurface.modelsvector3f = NULL;
7410 rsurface.modeltvector3f = NULL;
7411 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7415 rsurface.modelvertex3f = vertex3f;
7416 rsurface.modelsvector3f = NULL;
7417 rsurface.modeltvector3f = NULL;
7418 rsurface.modelnormal3f = NULL;
7420 rsurface.modelvertex3f_bufferobject = 0;
7421 rsurface.modelvertex3f_bufferoffset = 0;
7422 rsurface.modelsvector3f_bufferobject = 0;
7423 rsurface.modelsvector3f_bufferoffset = 0;
7424 rsurface.modeltvector3f_bufferobject = 0;
7425 rsurface.modeltvector3f_bufferoffset = 0;
7426 rsurface.modelnormal3f_bufferobject = 0;
7427 rsurface.modelnormal3f_bufferoffset = 0;
7428 rsurface.generatedvertex = true;
7429 rsurface.modellightmapcolor4f = color4f;
7430 rsurface.modellightmapcolor4f_bufferobject = 0;
7431 rsurface.modellightmapcolor4f_bufferoffset = 0;
7432 rsurface.modeltexcoordtexture2f = texcoord2f;
7433 rsurface.modeltexcoordtexture2f_bufferobject = 0;
7434 rsurface.modeltexcoordtexture2f_bufferoffset = 0;
7435 rsurface.modeltexcoordlightmap2f = NULL;
7436 rsurface.modeltexcoordlightmap2f_bufferobject = 0;
7437 rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
7438 rsurface.modelelement3i = element3i;
7439 rsurface.modelelement3s = element3s;
7440 rsurface.modelelement3i_bufferobject = 0;
7441 rsurface.modelelement3s_bufferobject = 0;
7442 rsurface.modellightmapoffsets = NULL;
7443 rsurface.modelsurfaces = NULL;
7444 rsurface.vertex3f = rsurface.modelvertex3f;
7445 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7446 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7447 rsurface.svector3f = rsurface.modelsvector3f;
7448 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7449 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7450 rsurface.tvector3f = rsurface.modeltvector3f;
7451 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7452 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7453 rsurface.normal3f = rsurface.modelnormal3f;
7454 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7455 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7456 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7458 if (rsurface.modelnum_vertices && rsurface.modelelement3i)
7460 if ((wantnormals || wanttangents) && !normal3f)
7461 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7462 if (wanttangents && !svector3f)
7463 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 != 0);
7467 float RSurf_FogPoint(const float *v)
7469 // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7470 float FogPlaneViewDist = r_refdef.fogplaneviewdist;
7471 float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
7472 float FogHeightFade = r_refdef.fogheightfade;
7474 unsigned int fogmasktableindex;
7475 if (r_refdef.fogplaneviewabove)
7476 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7478 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7479 fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
7480 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7483 float RSurf_FogVertex(const float *v)
7485 // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7486 float FogPlaneViewDist = rsurface.fogplaneviewdist;
7487 float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
7488 float FogHeightFade = rsurface.fogheightfade;
7490 unsigned int fogmasktableindex;
7491 if (r_refdef.fogplaneviewabove)
7492 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7494 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7495 fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
7496 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7499 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
7500 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, const msurface_t **texturesurfacelist)
7503 int texturesurfaceindex;
7508 const float *v1, *in_tc;
7510 float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
7512 q3shaderinfo_deform_t *deform;
7513 // 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
7514 if (rsurface.generatedvertex)
7516 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
7517 generatenormals = true;
7518 for (i = 0;i < Q3MAXDEFORMS;i++)
7520 if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
7522 generatetangents = true;
7523 generatenormals = true;
7525 if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
7526 generatenormals = true;
7528 if (generatenormals && !rsurface.modelnormal3f)
7530 rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7531 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
7532 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
7533 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7535 if (generatetangents && !rsurface.modelsvector3f)
7537 rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7538 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
7539 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
7540 rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7541 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
7542 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
7543 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 != 0);
7546 rsurface.vertex3f = rsurface.modelvertex3f;
7547 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7548 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7549 rsurface.svector3f = rsurface.modelsvector3f;
7550 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7551 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7552 rsurface.tvector3f = rsurface.modeltvector3f;
7553 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7554 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7555 rsurface.normal3f = rsurface.modelnormal3f;
7556 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7557 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7558 // if vertices are deformed (sprite flares and things in maps, possibly
7559 // water waves, bulges and other deformations), generate them into
7560 // rsurface.deform* arrays from whatever the rsurface.* arrays point to
7561 // (may be static model data or generated data for an animated model, or
7562 // the previous deform pass)
7563 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
7565 switch (deform->deform)
7568 case Q3DEFORM_PROJECTIONSHADOW:
7569 case Q3DEFORM_TEXT0:
7570 case Q3DEFORM_TEXT1:
7571 case Q3DEFORM_TEXT2:
7572 case Q3DEFORM_TEXT3:
7573 case Q3DEFORM_TEXT4:
7574 case Q3DEFORM_TEXT5:
7575 case Q3DEFORM_TEXT6:
7576 case Q3DEFORM_TEXT7:
7579 case Q3DEFORM_AUTOSPRITE:
7580 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7581 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7582 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7583 VectorNormalize(newforward);
7584 VectorNormalize(newright);
7585 VectorNormalize(newup);
7586 // make deformed versions of only the model vertices used by the specified surfaces
7587 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7589 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7590 // a single autosprite surface can contain multiple sprites...
7591 for (j = 0;j < surface->num_vertices - 3;j += 4)
7593 VectorClear(center);
7594 for (i = 0;i < 4;i++)
7595 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7596 VectorScale(center, 0.25f, center);
7597 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, forward);
7598 VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
7599 VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
7600 for (i = 0;i < 4;i++)
7602 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
7603 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7606 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 != 0);
7607 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 != 0);
7609 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7610 rsurface.vertex3f_bufferobject = 0;
7611 rsurface.vertex3f_bufferoffset = 0;
7612 rsurface.svector3f = rsurface.array_deformedsvector3f;
7613 rsurface.svector3f_bufferobject = 0;
7614 rsurface.svector3f_bufferoffset = 0;
7615 rsurface.tvector3f = rsurface.array_deformedtvector3f;
7616 rsurface.tvector3f_bufferobject = 0;
7617 rsurface.tvector3f_bufferoffset = 0;
7618 rsurface.normal3f = rsurface.array_deformednormal3f;
7619 rsurface.normal3f_bufferobject = 0;
7620 rsurface.normal3f_bufferoffset = 0;
7622 case Q3DEFORM_AUTOSPRITE2:
7623 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7624 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7625 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7626 VectorNormalize(newforward);
7627 VectorNormalize(newright);
7628 VectorNormalize(newup);
7629 // make deformed versions of only the model vertices used by the specified surfaces
7630 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7632 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7633 const float *v1, *v2;
7643 memset(shortest, 0, sizeof(shortest));
7644 // a single autosprite surface can contain multiple sprites...
7645 for (j = 0;j < surface->num_vertices - 3;j += 4)
7647 VectorClear(center);
7648 for (i = 0;i < 4;i++)
7649 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7650 VectorScale(center, 0.25f, center);
7651 // find the two shortest edges, then use them to define the
7652 // axis vectors for rotating around the central axis
7653 for (i = 0;i < 6;i++)
7655 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
7656 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
7658 Debug_PolygonBegin(NULL, 0);
7659 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
7660 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);
7661 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
7664 l = VectorDistance2(v1, v2);
7665 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
7667 l += (1.0f / 1024.0f);
7668 if (shortest[0].length2 > l || i == 0)
7670 shortest[1] = shortest[0];
7671 shortest[0].length2 = l;
7672 shortest[0].v1 = v1;
7673 shortest[0].v2 = v2;
7675 else if (shortest[1].length2 > l || i == 1)
7677 shortest[1].length2 = l;
7678 shortest[1].v1 = v1;
7679 shortest[1].v2 = v2;
7682 VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
7683 VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
7685 Debug_PolygonBegin(NULL, 0);
7686 Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
7687 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);
7688 Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
7691 // this calculates the right vector from the shortest edge
7692 // and the up vector from the edge midpoints
7693 VectorSubtract(shortest[0].v1, shortest[0].v2, right);
7694 VectorNormalize(right);
7695 VectorSubtract(end, start, up);
7696 VectorNormalize(up);
7697 // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
7698 VectorSubtract(rsurface.localvieworigin, center, forward);
7699 //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
7700 VectorNegate(forward, forward);
7701 VectorReflect(forward, 0, up, forward);
7702 VectorNormalize(forward);
7703 CrossProduct(up, forward, newright);
7704 VectorNormalize(newright);
7706 Debug_PolygonBegin(NULL, 0);
7707 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);
7708 Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
7709 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
7713 Debug_PolygonBegin(NULL, 0);
7714 Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
7715 Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
7716 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
7719 // rotate the quad around the up axis vector, this is made
7720 // especially easy by the fact we know the quad is flat,
7721 // so we only have to subtract the center position and
7722 // measure distance along the right vector, and then
7723 // multiply that by the newright vector and add back the
7725 // we also need to subtract the old position to undo the
7726 // displacement from the center, which we do with a
7727 // DotProduct, the subtraction/addition of center is also
7728 // optimized into DotProducts here
7729 l = DotProduct(right, center);
7730 for (i = 0;i < 4;i++)
7732 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
7733 f = DotProduct(right, v1) - l;
7734 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7737 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 != 0);
7738 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 != 0);
7740 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7741 rsurface.vertex3f_bufferobject = 0;
7742 rsurface.vertex3f_bufferoffset = 0;
7743 rsurface.svector3f = rsurface.array_deformedsvector3f;
7744 rsurface.svector3f_bufferobject = 0;
7745 rsurface.svector3f_bufferoffset = 0;
7746 rsurface.tvector3f = rsurface.array_deformedtvector3f;
7747 rsurface.tvector3f_bufferobject = 0;
7748 rsurface.tvector3f_bufferoffset = 0;
7749 rsurface.normal3f = rsurface.array_deformednormal3f;
7750 rsurface.normal3f_bufferobject = 0;
7751 rsurface.normal3f_bufferoffset = 0;
7753 case Q3DEFORM_NORMAL:
7754 // deform the normals to make reflections wavey
7755 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7757 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7758 for (j = 0;j < surface->num_vertices;j++)
7761 float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3;
7762 VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
7763 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal);
7764 normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7765 normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7766 normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7767 VectorNormalize(normal);
7769 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 != 0);
7771 rsurface.svector3f = rsurface.array_deformedsvector3f;
7772 rsurface.svector3f_bufferobject = 0;
7773 rsurface.svector3f_bufferoffset = 0;
7774 rsurface.tvector3f = rsurface.array_deformedtvector3f;
7775 rsurface.tvector3f_bufferobject = 0;
7776 rsurface.tvector3f_bufferoffset = 0;
7777 rsurface.normal3f = rsurface.array_deformednormal3f;
7778 rsurface.normal3f_bufferobject = 0;
7779 rsurface.normal3f_bufferoffset = 0;
7782 // deform vertex array to make wavey water and flags and such
7783 waveparms[0] = deform->waveparms[0];
7784 waveparms[1] = deform->waveparms[1];
7785 waveparms[2] = deform->waveparms[2];
7786 waveparms[3] = deform->waveparms[3];
7787 // this is how a divisor of vertex influence on deformation
7788 animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
7789 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7790 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7792 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7793 for (j = 0;j < surface->num_vertices;j++)
7795 float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3;
7796 VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex);
7797 // if the wavefunc depends on time, evaluate it per-vertex
7800 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
7801 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7803 VectorMA(vertex, scale, (rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, vertex);
7806 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7807 rsurface.vertex3f_bufferobject = 0;
7808 rsurface.vertex3f_bufferoffset = 0;
7810 case Q3DEFORM_BULGE:
7811 // deform vertex array to make the surface have moving bulges
7812 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7814 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7815 for (j = 0;j < surface->num_vertices;j++)
7817 scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.scene.time * deform->parms[2])) * deform->parms[1];
7818 VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7821 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7822 rsurface.vertex3f_bufferobject = 0;
7823 rsurface.vertex3f_bufferoffset = 0;
7826 // deform vertex array
7827 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
7828 VectorScale(deform->parms, scale, waveparms);
7829 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7831 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7832 for (j = 0;j < surface->num_vertices;j++)
7833 VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7835 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7836 rsurface.vertex3f_bufferobject = 0;
7837 rsurface.vertex3f_bufferoffset = 0;
7841 // generate texcoords based on the chosen texcoord source
7842 switch(rsurface.texture->tcgen.tcgen)
7845 case Q3TCGEN_TEXTURE:
7846 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7847 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordtexture2f_bufferobject;
7848 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
7850 case Q3TCGEN_LIGHTMAP:
7851 rsurface.texcoordtexture2f = rsurface.modeltexcoordlightmap2f;
7852 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
7853 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
7855 case Q3TCGEN_VECTOR:
7856 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7858 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7859 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)
7861 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
7862 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
7865 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
7866 rsurface.texcoordtexture2f_bufferobject = 0;
7867 rsurface.texcoordtexture2f_bufferoffset = 0;
7869 case Q3TCGEN_ENVIRONMENT:
7870 // make environment reflections using a spheremap
7871 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7873 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7874 const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
7875 const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
7876 float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
7877 for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
7879 // identical to Q3A's method, but executed in worldspace so
7880 // carried models can be shiny too
7882 float viewer[3], d, reflected[3], worldreflected[3];
7884 VectorSubtract(rsurface.localvieworigin, vertex, viewer);
7885 // VectorNormalize(viewer);
7887 d = DotProduct(normal, viewer);
7889 reflected[0] = normal[0]*2*d - viewer[0];
7890 reflected[1] = normal[1]*2*d - viewer[1];
7891 reflected[2] = normal[2]*2*d - viewer[2];
7892 // note: this is proportinal to viewer, so we can normalize later
7894 Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
7895 VectorNormalize(worldreflected);
7897 // note: this sphere map only uses world x and z!
7898 // so positive and negative y will LOOK THE SAME.
7899 out_tc[0] = 0.5 + 0.5 * worldreflected[1];
7900 out_tc[1] = 0.5 - 0.5 * worldreflected[2];
7903 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
7904 rsurface.texcoordtexture2f_bufferobject = 0;
7905 rsurface.texcoordtexture2f_bufferoffset = 0;
7908 // the only tcmod that needs software vertex processing is turbulent, so
7909 // check for it here and apply the changes if needed
7910 // and we only support that as the first one
7911 // (handling a mixture of turbulent and other tcmods would be problematic
7912 // without punting it entirely to a software path)
7913 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
7915 amplitude = rsurface.texture->tcmods[0].parms[1];
7916 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
7917 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7919 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7920 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)
7922 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7923 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7926 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
7927 rsurface.texcoordtexture2f_bufferobject = 0;
7928 rsurface.texcoordtexture2f_bufferoffset = 0;
7930 rsurface.texcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
7931 rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
7932 rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
7933 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
7936 void RSurf_DrawBatch_Simple(int texturenumsurfaces, const msurface_t **texturesurfacelist)
7939 const msurface_t *surface = texturesurfacelist[0];
7940 const msurface_t *surface2;
7945 // TODO: lock all array ranges before render, rather than on each surface
7946 if (texturenumsurfaces == 1)
7948 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
7949 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
7951 else if (r_batchmode.integer == 2)
7953 #define MAXBATCHTRIANGLES 4096
7954 int batchtriangles = 0;
7955 static int batchelements[MAXBATCHTRIANGLES*3];
7956 for (i = 0;i < texturenumsurfaces;i = j)
7958 surface = texturesurfacelist[i];
7960 if (surface->num_triangles > MAXBATCHTRIANGLES)
7962 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
7965 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
7966 batchtriangles = surface->num_triangles;
7967 firstvertex = surface->num_firstvertex;
7968 endvertex = surface->num_firstvertex + surface->num_vertices;
7969 for (;j < texturenumsurfaces;j++)
7971 surface2 = texturesurfacelist[j];
7972 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
7974 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
7975 batchtriangles += surface2->num_triangles;
7976 firstvertex = min(firstvertex, surface2->num_firstvertex);
7977 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
7979 surface2 = texturesurfacelist[j-1];
7980 numvertices = endvertex - firstvertex;
7981 R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
7984 else if (r_batchmode.integer == 1)
7986 for (i = 0;i < texturenumsurfaces;i = j)
7988 surface = texturesurfacelist[i];
7989 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
7990 if (texturesurfacelist[j] != surface2)
7992 surface2 = texturesurfacelist[j-1];
7993 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
7994 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
7995 GL_LockArrays(surface->num_firstvertex, numvertices);
7996 R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8001 for (i = 0;i < texturenumsurfaces;i++)
8003 surface = texturesurfacelist[i];
8004 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8005 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8010 static void RSurf_BindLightmapForSurface(const msurface_t *surface)
8012 switch(vid.renderpath)
8014 case RENDERPATH_CGGL:
8016 if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , R_GetTexture(surface->lightmaptexture ));CHECKCGERROR
8017 if (r_cg_permutation->fp_Texture_Deluxemap) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap, R_GetTexture(surface->deluxemaptexture));CHECKCGERROR
8020 case RENDERPATH_GL20:
8021 if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , R_GetTexture(surface->lightmaptexture ));
8022 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP, R_GetTexture(surface->deluxemaptexture));
8024 case RENDERPATH_GL13:
8025 case RENDERPATH_GL11:
8026 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
8031 static void RSurf_BindReflectionForSurface(const msurface_t *surface)
8033 // pick the closest matching water plane and bind textures
8034 int planeindex, vertexindex;
8038 r_waterstate_waterplane_t *p, *bestp;
8041 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8044 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
8046 Matrix4x4_Transform(&rsurface.matrix, v, vert);
8047 d += fabs(PlaneDiff(vert, &p->plane));
8049 if (bestd > d || !bestp)
8055 switch(vid.renderpath)
8057 case RENDERPATH_CGGL:
8059 if (r_cg_permutation->fp_Texture_Refraction) CG_BindTexture(r_cg_permutation->fp_Texture_Refraction, bestp ? R_GetTexture(bestp->texture_refraction) : R_GetTexture(r_texture_black));CHECKCGERROR
8060 if (r_cg_permutation->fp_Texture_Reflection) CG_BindTexture(r_cg_permutation->fp_Texture_Reflection, bestp ? R_GetTexture(bestp->texture_reflection) : R_GetTexture(r_texture_black));CHECKCGERROR
8063 case RENDERPATH_GL20:
8064 if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION, bestp ? R_GetTexture(bestp->texture_refraction) : R_GetTexture(r_texture_black));
8065 if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION, bestp ? R_GetTexture(bestp->texture_reflection) : R_GetTexture(r_texture_black));
8067 case RENDERPATH_GL13:
8068 case RENDERPATH_GL11:
8073 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8076 const msurface_t *surface;
8077 if (r_waterstate.renderingscene)
8079 for (i = 0;i < texturenumsurfaces;i++)
8081 surface = texturesurfacelist[i];
8082 RSurf_BindLightmapForSurface(surface);
8083 RSurf_BindReflectionForSurface(surface);
8084 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8085 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8089 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8093 const msurface_t *surface = texturesurfacelist[0];
8094 const msurface_t *surface2;
8099 if (texturenumsurfaces == 1)
8101 RSurf_BindLightmapForSurface(surface);
8102 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8103 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8105 else if (r_batchmode.integer == 2)
8107 #define MAXBATCHTRIANGLES 4096
8108 int batchtriangles = 0;
8109 static int batchelements[MAXBATCHTRIANGLES*3];
8110 for (i = 0;i < texturenumsurfaces;i = j)
8112 surface = texturesurfacelist[i];
8113 RSurf_BindLightmapForSurface(surface);
8115 if (surface->num_triangles > MAXBATCHTRIANGLES)
8117 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8120 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
8121 batchtriangles = surface->num_triangles;
8122 firstvertex = surface->num_firstvertex;
8123 endvertex = surface->num_firstvertex + surface->num_vertices;
8124 for (;j < texturenumsurfaces;j++)
8126 surface2 = texturesurfacelist[j];
8127 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
8129 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
8130 batchtriangles += surface2->num_triangles;
8131 firstvertex = min(firstvertex, surface2->num_firstvertex);
8132 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
8134 surface2 = texturesurfacelist[j-1];
8135 numvertices = endvertex - firstvertex;
8136 R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
8139 else if (r_batchmode.integer == 1)
8142 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
8143 for (i = 0;i < texturenumsurfaces;i = j)
8145 surface = texturesurfacelist[i];
8146 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8147 if (texturesurfacelist[j] != surface2)
8149 Con_Printf(" %i", j - i);
8152 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
8154 for (i = 0;i < texturenumsurfaces;i = j)
8156 surface = texturesurfacelist[i];
8157 RSurf_BindLightmapForSurface(surface);
8158 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8159 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
8162 Con_Printf(" %i", j - i);
8164 surface2 = texturesurfacelist[j-1];
8165 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
8166 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
8167 GL_LockArrays(surface->num_firstvertex, numvertices);
8168 R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8176 for (i = 0;i < texturenumsurfaces;i++)
8178 surface = texturesurfacelist[i];
8179 RSurf_BindLightmapForSurface(surface);
8180 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8181 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8186 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8189 int texturesurfaceindex;
8190 if (r_showsurfaces.integer == 2)
8192 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8194 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8195 for (j = 0;j < surface->num_triangles;j++)
8197 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_refdef.view.colorscale;
8198 GL_Color(f, f, f, 1);
8199 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle + j, 1, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8205 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8207 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8208 int k = (int)(((size_t)surface) / sizeof(msurface_t));
8209 GL_Color((k & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, ((k >> 4) & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, ((k >> 8) & 15) * (1.0f / 16.0f) * r_refdef.view.colorscale, 1);
8210 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8211 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8216 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8218 int texturesurfaceindex;
8222 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8224 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8225 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)
8233 rsurface.lightmapcolor4f = rsurface.array_color4f;
8234 rsurface.lightmapcolor4f_bufferobject = 0;
8235 rsurface.lightmapcolor4f_bufferoffset = 0;
8238 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8240 int texturesurfaceindex;
8246 if (rsurface.lightmapcolor4f)
8248 // generate color arrays for the surfaces in this list
8249 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8251 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8252 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)
8254 f = RSurf_FogVertex(v);
8264 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8266 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8267 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)
8269 f = RSurf_FogVertex(v);
8277 rsurface.lightmapcolor4f = rsurface.array_color4f;
8278 rsurface.lightmapcolor4f_bufferobject = 0;
8279 rsurface.lightmapcolor4f_bufferoffset = 0;
8282 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8284 int texturesurfaceindex;
8290 if (!rsurface.lightmapcolor4f)
8292 // generate color arrays for the surfaces in this list
8293 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8295 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8296 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)
8298 f = RSurf_FogVertex(v);
8299 c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
8300 c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
8301 c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
8305 rsurface.lightmapcolor4f = rsurface.array_color4f;
8306 rsurface.lightmapcolor4f_bufferobject = 0;
8307 rsurface.lightmapcolor4f_bufferoffset = 0;
8310 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a)
8312 int texturesurfaceindex;
8316 if (!rsurface.lightmapcolor4f)
8318 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8320 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8321 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)
8329 rsurface.lightmapcolor4f = rsurface.array_color4f;
8330 rsurface.lightmapcolor4f_bufferobject = 0;
8331 rsurface.lightmapcolor4f_bufferoffset = 0;
8334 static void RSurf_DrawBatch_GL11_ApplyAmbient(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8336 int texturesurfaceindex;
8340 if (!rsurface.lightmapcolor4f)
8342 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8344 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8345 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)
8347 c2[0] = c[0] + r_refdef.scene.ambient;
8348 c2[1] = c[1] + r_refdef.scene.ambient;
8349 c2[2] = c[2] + r_refdef.scene.ambient;
8353 rsurface.lightmapcolor4f = rsurface.array_color4f;
8354 rsurface.lightmapcolor4f_bufferobject = 0;
8355 rsurface.lightmapcolor4f_bufferoffset = 0;
8358 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8361 rsurface.lightmapcolor4f = NULL;
8362 rsurface.lightmapcolor4f_bufferobject = 0;
8363 rsurface.lightmapcolor4f_bufferoffset = 0;
8364 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8365 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8366 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8367 GL_Color(r, g, b, a);
8368 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8371 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8373 // TODO: optimize applyfog && applycolor case
8374 // just apply fog if necessary, and tint the fog color array if necessary
8375 rsurface.lightmapcolor4f = NULL;
8376 rsurface.lightmapcolor4f_bufferobject = 0;
8377 rsurface.lightmapcolor4f_bufferoffset = 0;
8378 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8379 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8380 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8381 GL_Color(r, g, b, a);
8382 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8385 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8387 int texturesurfaceindex;
8391 if (texturesurfacelist[0]->lightmapinfo)
8393 // generate color arrays for the surfaces in this list
8394 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8396 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8397 for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
8399 if (surface->lightmapinfo->samples)
8401 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
8402 float scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
8403 VectorScale(lm, scale, c);
8404 if (surface->lightmapinfo->styles[1] != 255)
8406 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
8408 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
8409 VectorMA(c, scale, lm, c);
8410 if (surface->lightmapinfo->styles[2] != 255)
8413 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
8414 VectorMA(c, scale, lm, c);
8415 if (surface->lightmapinfo->styles[3] != 255)
8418 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
8419 VectorMA(c, scale, lm, c);
8429 rsurface.lightmapcolor4f = rsurface.array_color4f;
8430 rsurface.lightmapcolor4f_bufferobject = 0;
8431 rsurface.lightmapcolor4f_bufferoffset = 0;
8435 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8436 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8437 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8439 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8440 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8441 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8442 GL_Color(r, g, b, a);
8443 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8446 static void RSurf_DrawBatch_GL11_ApplyVertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float *r, float *g, float *b, float *a, qboolean *applycolor)
8448 int texturesurfaceindex;
8455 vec3_t ambientcolor;
8456 vec3_t diffusecolor;
8460 VectorCopy(rsurface.modellight_lightdir, lightdir);
8461 f = 0.5f * r_refdef.lightmapintensity;
8462 ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
8463 ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
8464 ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
8465 diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
8466 diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
8467 diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
8469 if (VectorLength2(diffusecolor) > 0 && rsurface.normal3f)
8471 // generate color arrays for the surfaces in this list
8472 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8474 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8475 int numverts = surface->num_vertices;
8476 v = rsurface.vertex3f + 3 * surface->num_firstvertex;
8477 n = rsurface.normal3f + 3 * surface->num_firstvertex;
8478 c = rsurface.array_color4f + 4 * surface->num_firstvertex;
8479 // q3-style directional shading
8480 for (i = 0;i < numverts;i++, v += 3, n += 3, c += 4)
8482 if ((f = DotProduct(n, lightdir)) > 0)
8483 VectorMA(ambientcolor, f, diffusecolor, c);
8485 VectorCopy(ambientcolor, c);
8493 rsurface.lightmapcolor4f = rsurface.array_color4f;
8494 rsurface.lightmapcolor4f_bufferobject = 0;
8495 rsurface.lightmapcolor4f_bufferoffset = 0;
8496 *applycolor = false;
8500 *r = ambientcolor[0];
8501 *g = ambientcolor[1];
8502 *b = ambientcolor[2];
8503 rsurface.lightmapcolor4f = NULL;
8504 rsurface.lightmapcolor4f_bufferobject = 0;
8505 rsurface.lightmapcolor4f_bufferoffset = 0;
8509 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8511 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &r, &g, &b, &a, &applycolor);
8512 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8513 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8514 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8515 GL_Color(r, g, b, a);
8516 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8519 void RSurf_SetupDepthAndCulling(void)
8521 // submodels are biased to avoid z-fighting with world surfaces that they
8522 // may be exactly overlapping (avoids z-fighting artifacts on certain
8523 // doors and things in Quake maps)
8524 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
8525 GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
8526 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
8527 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
8530 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8532 // transparent sky would be ridiculous
8533 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
8535 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8536 skyrenderlater = true;
8537 RSurf_SetupDepthAndCulling();
8539 // LordHavoc: HalfLife maps have freaky skypolys so don't use
8540 // skymasking on them, and Quake3 never did sky masking (unlike
8541 // software Quake and software Quake2), so disable the sky masking
8542 // in Quake3 maps as it causes problems with q3map2 sky tricks,
8543 // and skymasking also looks very bad when noclipping outside the
8544 // level, so don't use it then either.
8545 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
8547 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
8548 R_Mesh_ColorPointer(NULL, 0, 0);
8549 R_Mesh_ResetTextureState();
8550 if (skyrendermasked)
8552 R_SetupShader_DepthOrShadow();
8553 // depth-only (masking)
8554 GL_ColorMask(0,0,0,0);
8555 // just to make sure that braindead drivers don't draw
8556 // anything despite that colormask...
8557 GL_BlendFunc(GL_ZERO, GL_ONE);
8561 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8563 GL_BlendFunc(GL_ONE, GL_ZERO);
8565 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8566 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8567 if (skyrendermasked)
8568 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8570 R_Mesh_ResetTextureState();
8571 GL_Color(1, 1, 1, 1);
8574 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
8575 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
8576 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
8578 qboolean reflect = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)) && !prepass;
8579 qboolean refract = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) && !prepass;
8581 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
8584 if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8585 R_Mesh_ColorPointer(NULL, 0, 0);
8587 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8591 // render background
8592 GL_BlendFunc(GL_ONE, GL_ZERO);
8594 GL_AlphaTest(false);
8596 GL_Color(1, 1, 1, 1);
8597 R_Mesh_ColorPointer(NULL, 0, 0);
8599 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
8600 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8601 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8602 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8603 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8604 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8605 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8606 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8607 GL_LockArrays(0, 0);
8609 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8610 GL_DepthMask(false);
8611 if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8612 R_Mesh_ColorPointer(NULL, 0, 0);
8614 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8617 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, prepass ? RSURFPASS_DEFERREDGEOMETRY : RSURFPASS_BASE);
8619 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8620 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8621 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8622 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8623 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8625 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8629 GL_BlendFunc(GL_ONE, GL_ZERO);
8631 GL_AlphaTest(false);
8635 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8636 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
8637 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0 && !r_shadow_usingdeferredprepass);
8640 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
8642 if (refract || reflect)
8643 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8645 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8649 if (refract || reflect)
8650 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8652 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8654 GL_LockArrays(0, 0);
8657 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8659 // OpenGL 1.3 path - anything not completely ancient
8660 int texturesurfaceindex;
8661 qboolean applycolor;
8664 const texturelayer_t *layer;
8665 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8667 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8670 int layertexrgbscale;
8671 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8673 if (layerindex == 0)
8677 GL_AlphaTest(false);
8678 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8681 GL_DepthMask(layer->depthmask && writedepth);
8682 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8683 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
8685 layertexrgbscale = 4;
8686 VectorScale(layer->color, 0.25f, layercolor);
8688 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
8690 layertexrgbscale = 2;
8691 VectorScale(layer->color, 0.5f, layercolor);
8695 layertexrgbscale = 1;
8696 VectorScale(layer->color, 1.0f, layercolor);
8698 layercolor[3] = layer->color[3];
8699 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
8700 R_Mesh_ColorPointer(NULL, 0, 0);
8701 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8702 switch (layer->type)
8704 case TEXTURELAYERTYPE_LITTEXTURE:
8705 // single-pass lightmapped texture with 2x rgbscale
8706 //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8707 R_Mesh_TexMatrix(0, NULL);
8708 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8709 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8710 R_Mesh_TexBind(1, R_GetTexture(layer->texture));
8711 R_Mesh_TexMatrix(1, &layer->texmatrix);
8712 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8713 R_Mesh_TexCoordPointer(1, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8714 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8715 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8716 else if (rsurface.uselightmaptexture)
8717 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8719 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8721 case TEXTURELAYERTYPE_TEXTURE:
8722 // singletexture unlit texture with transparency support
8723 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8724 R_Mesh_TexMatrix(0, &layer->texmatrix);
8725 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8726 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8727 R_Mesh_TexBind(1, 0);
8728 R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8729 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8731 case TEXTURELAYERTYPE_FOG:
8732 // singletexture fogging
8735 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8736 R_Mesh_TexMatrix(0, &layer->texmatrix);
8737 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8738 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8742 R_Mesh_TexBind(0, 0);
8743 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8745 R_Mesh_TexBind(1, 0);
8746 R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8747 // generate a color array for the fog pass
8748 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8749 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8755 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8756 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)
8758 f = 1 - RSurf_FogVertex(v);
8759 c[0] = layercolor[0];
8760 c[1] = layercolor[1];
8761 c[2] = layercolor[2];
8762 c[3] = f * layercolor[3];
8765 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8768 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8770 GL_LockArrays(0, 0);
8773 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8775 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8776 GL_AlphaTest(false);
8780 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8782 // OpenGL 1.1 - crusty old voodoo path
8783 int texturesurfaceindex;
8786 const texturelayer_t *layer;
8787 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8789 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8791 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8793 if (layerindex == 0)
8797 GL_AlphaTest(false);
8798 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8801 GL_DepthMask(layer->depthmask && writedepth);
8802 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8803 R_Mesh_ColorPointer(NULL, 0, 0);
8804 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8805 switch (layer->type)
8807 case TEXTURELAYERTYPE_LITTEXTURE:
8808 if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
8810 // two-pass lit texture with 2x rgbscale
8811 // first the lightmap pass
8812 //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8813 R_Mesh_TexMatrix(0, NULL);
8814 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8815 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8816 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8817 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8818 else if (rsurface.uselightmaptexture)
8819 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8821 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8822 GL_LockArrays(0, 0);
8823 // then apply the texture to it
8824 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
8825 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8826 R_Mesh_TexMatrix(0, &layer->texmatrix);
8827 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8828 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8829 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);
8833 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
8834 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8835 R_Mesh_TexMatrix(0, &layer->texmatrix);
8836 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8837 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8838 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8839 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);
8841 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);
8844 case TEXTURELAYERTYPE_TEXTURE:
8845 // singletexture unlit texture with transparency support
8846 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8847 R_Mesh_TexMatrix(0, &layer->texmatrix);
8848 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8849 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8850 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);
8852 case TEXTURELAYERTYPE_FOG:
8853 // singletexture fogging
8856 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8857 R_Mesh_TexMatrix(0, &layer->texmatrix);
8858 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8859 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8863 R_Mesh_TexBind(0, 0);
8864 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8866 // generate a color array for the fog pass
8867 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8868 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8874 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8875 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)
8877 f = 1 - RSurf_FogVertex(v);
8878 c[0] = layer->color[0];
8879 c[1] = layer->color[1];
8880 c[2] = layer->color[2];
8881 c[3] = f * layer->color[3];
8884 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8887 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8889 GL_LockArrays(0, 0);
8892 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8894 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8895 GL_AlphaTest(false);
8899 static void R_DrawTextureSurfaceList_ShowSurfaces3(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8903 GL_AlphaTest(false);
8904 R_Mesh_ColorPointer(NULL, 0, 0);
8905 R_Mesh_ResetTextureState();
8906 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8908 if(rsurface.texture && rsurface.texture->currentskinframe)
8910 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
8911 c[3] *= rsurface.texture->currentalpha;
8921 if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
8923 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
8924 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
8925 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
8928 // brighten it up (as texture value 127 means "unlit")
8929 c[0] *= 2 * r_refdef.view.colorscale;
8930 c[1] *= 2 * r_refdef.view.colorscale;
8931 c[2] *= 2 * r_refdef.view.colorscale;
8933 if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
8934 c[3] *= r_wateralpha.value;
8936 if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
8938 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8939 GL_DepthMask(false);
8941 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
8943 GL_BlendFunc(GL_ONE, GL_ONE);
8944 GL_DepthMask(false);
8946 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8948 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
8949 GL_DepthMask(false);
8951 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
8953 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
8954 GL_DepthMask(false);
8958 GL_BlendFunc(GL_ONE, GL_ZERO);
8959 GL_DepthMask(writedepth);
8962 rsurface.lightmapcolor4f = NULL;
8964 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
8966 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8968 rsurface.lightmapcolor4f = NULL;
8969 rsurface.lightmapcolor4f_bufferobject = 0;
8970 rsurface.lightmapcolor4f_bufferoffset = 0;
8972 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8974 qboolean applycolor = true;
8977 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8979 r_refdef.lightmapintensity = 1;
8980 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &one, &one, &one, &one, &applycolor);
8981 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
8985 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8987 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8988 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8989 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8992 if(!rsurface.lightmapcolor4f)
8993 RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(texturenumsurfaces, texturesurfacelist);
8995 RSurf_DrawBatch_GL11_ApplyAmbient(texturenumsurfaces, texturesurfacelist);
8996 RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, c[0], c[1], c[2], c[3]);
8997 if(r_refdef.fogenabled)
8998 RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(texturenumsurfaces, texturesurfacelist);
9000 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
9001 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9004 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9007 RSurf_SetupDepthAndCulling();
9008 if (r_showsurfaces.integer == 3 && !prepass)
9010 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9013 switch (vid.renderpath)
9015 case RENDERPATH_GL20:
9016 case RENDERPATH_CGGL:
9017 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9019 case RENDERPATH_GL13:
9020 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9022 case RENDERPATH_GL11:
9023 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9029 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9032 RSurf_SetupDepthAndCulling();
9033 if (r_showsurfaces.integer == 3 && !prepass)
9035 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9038 switch (vid.renderpath)
9040 case RENDERPATH_GL20:
9041 case RENDERPATH_CGGL:
9042 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9044 case RENDERPATH_GL13:
9045 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9047 case RENDERPATH_GL11:
9048 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9054 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9057 int texturenumsurfaces, endsurface;
9059 const msurface_t *surface;
9060 const msurface_t *texturesurfacelist[256];
9062 // if the model is static it doesn't matter what value we give for
9063 // wantnormals and wanttangents, so this logic uses only rules applicable
9064 // to a model, knowing that they are meaningless otherwise
9065 if (ent == r_refdef.scene.worldentity)
9066 RSurf_ActiveWorldEntity();
9067 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9068 RSurf_ActiveModelEntity(ent, false, false, false);
9071 switch (vid.renderpath)
9073 case RENDERPATH_GL20:
9074 case RENDERPATH_CGGL:
9075 RSurf_ActiveModelEntity(ent, true, true, false);
9077 case RENDERPATH_GL13:
9078 case RENDERPATH_GL11:
9079 RSurf_ActiveModelEntity(ent, true, false, false);
9084 if (r_transparentdepthmasking.integer)
9086 qboolean setup = false;
9087 for (i = 0;i < numsurfaces;i = j)
9090 surface = rsurface.modelsurfaces + surfacelist[i];
9091 texture = surface->texture;
9092 rsurface.texture = R_GetCurrentTexture(texture);
9093 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9094 // scan ahead until we find a different texture
9095 endsurface = min(i + 1024, numsurfaces);
9096 texturenumsurfaces = 0;
9097 texturesurfacelist[texturenumsurfaces++] = surface;
9098 for (;j < endsurface;j++)
9100 surface = rsurface.modelsurfaces + surfacelist[j];
9101 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9103 texturesurfacelist[texturenumsurfaces++] = surface;
9105 if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
9107 // render the range of surfaces as depth
9111 GL_ColorMask(0,0,0,0);
9114 GL_BlendFunc(GL_ONE, GL_ZERO);
9116 GL_AlphaTest(false);
9117 R_Mesh_ColorPointer(NULL, 0, 0);
9118 R_Mesh_ResetTextureState();
9119 R_SetupShader_DepthOrShadow();
9121 RSurf_SetupDepthAndCulling();
9122 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9123 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9126 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
9129 for (i = 0;i < numsurfaces;i = j)
9132 surface = rsurface.modelsurfaces + surfacelist[i];
9133 texture = surface->texture;
9134 rsurface.texture = R_GetCurrentTexture(texture);
9135 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9136 // scan ahead until we find a different texture
9137 endsurface = min(i + 1024, numsurfaces);
9138 texturenumsurfaces = 0;
9139 texturesurfacelist[texturenumsurfaces++] = surface;
9140 for (;j < endsurface;j++)
9142 surface = rsurface.modelsurfaces + surfacelist[j];
9143 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9145 texturesurfacelist[texturenumsurfaces++] = surface;
9147 // render the range of surfaces
9148 if (ent == r_refdef.scene.worldentity)
9149 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9151 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9153 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
9154 GL_AlphaTest(false);
9157 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
9159 // transparent surfaces get pushed off into the transparent queue
9160 int surfacelistindex;
9161 const msurface_t *surface;
9162 vec3_t tempcenter, center;
9163 for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
9165 surface = texturesurfacelist[surfacelistindex];
9166 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
9167 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
9168 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
9169 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
9170 if (queueentity->transparent_offset) // transparent offset
9172 center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
9173 center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
9174 center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
9176 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
9180 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
9182 const entity_render_t *queueentity = r_refdef.scene.worldentity;
9186 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9188 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9190 RSurf_SetupDepthAndCulling();
9191 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9192 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9196 if (!rsurface.texture->currentnumlayers)
9198 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9199 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9201 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9203 else if (r_showsurfaces.integer && !r_refdef.view.showdebug && !prepass)
9205 RSurf_SetupDepthAndCulling();
9206 GL_AlphaTest(false);
9207 R_Mesh_ColorPointer(NULL, 0, 0);
9208 R_Mesh_ResetTextureState();
9209 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9210 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9212 GL_BlendFunc(GL_ONE, GL_ZERO);
9213 GL_Color(0, 0, 0, 1);
9214 GL_DepthTest(writedepth);
9215 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9217 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3 && !prepass)
9219 RSurf_SetupDepthAndCulling();
9220 GL_AlphaTest(false);
9221 R_Mesh_ColorPointer(NULL, 0, 0);
9222 R_Mesh_ResetTextureState();
9223 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9224 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9226 GL_BlendFunc(GL_ONE, GL_ZERO);
9228 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9230 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9231 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9232 else if (!rsurface.texture->currentnumlayers)
9234 else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9236 // in the deferred case, transparent surfaces were queued during prepass
9237 if (!r_shadow_usingdeferredprepass)
9238 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9242 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9243 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9248 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9252 // break the surface list down into batches by texture and use of lightmapping
9253 for (i = 0;i < numsurfaces;i = j)
9256 // texture is the base texture pointer, rsurface.texture is the
9257 // current frame/skin the texture is directing us to use (for example
9258 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9259 // use skin 1 instead)
9260 texture = surfacelist[i]->texture;
9261 rsurface.texture = R_GetCurrentTexture(texture);
9262 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9263 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9265 // if this texture is not the kind we want, skip ahead to the next one
9266 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9270 // simply scan ahead until we find a different texture or lightmap state
9271 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9273 // render the range of surfaces
9274 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
9278 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
9283 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9285 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9287 RSurf_SetupDepthAndCulling();
9288 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9289 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9293 if (!rsurface.texture->currentnumlayers)
9295 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9296 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9298 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9300 else if (r_showsurfaces.integer && !r_refdef.view.showdebug)
9302 RSurf_SetupDepthAndCulling();
9303 GL_AlphaTest(false);
9304 R_Mesh_ColorPointer(NULL, 0, 0);
9305 R_Mesh_ResetTextureState();
9306 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9307 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9309 GL_BlendFunc(GL_ONE, GL_ZERO);
9310 GL_Color(0, 0, 0, 1);
9311 GL_DepthTest(writedepth);
9312 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9314 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9316 RSurf_SetupDepthAndCulling();
9317 GL_AlphaTest(false);
9318 R_Mesh_ColorPointer(NULL, 0, 0);
9319 R_Mesh_ResetTextureState();
9320 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9321 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9323 GL_BlendFunc(GL_ONE, GL_ZERO);
9325 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9327 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9328 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9329 else if (!rsurface.texture->currentnumlayers)
9331 else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9333 // in the deferred case, transparent surfaces were queued during prepass
9334 if (!r_shadow_usingdeferredprepass)
9335 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9339 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9340 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9345 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9349 // break the surface list down into batches by texture and use of lightmapping
9350 for (i = 0;i < numsurfaces;i = j)
9353 // texture is the base texture pointer, rsurface.texture is the
9354 // current frame/skin the texture is directing us to use (for example
9355 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9356 // use skin 1 instead)
9357 texture = surfacelist[i]->texture;
9358 rsurface.texture = R_GetCurrentTexture(texture);
9359 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9360 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9362 // if this texture is not the kind we want, skip ahead to the next one
9363 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9367 // simply scan ahead until we find a different texture or lightmap state
9368 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9370 // render the range of surfaces
9371 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
9375 float locboxvertex3f[6*4*3] =
9377 1,0,1, 1,0,0, 1,1,0, 1,1,1,
9378 0,1,1, 0,1,0, 0,0,0, 0,0,1,
9379 1,1,1, 1,1,0, 0,1,0, 0,1,1,
9380 0,0,1, 0,0,0, 1,0,0, 1,0,1,
9381 0,0,1, 1,0,1, 1,1,1, 0,1,1,
9382 1,0,0, 0,0,0, 0,1,0, 1,1,0
9385 unsigned short locboxelements[6*2*3] =
9395 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9398 cl_locnode_t *loc = (cl_locnode_t *)ent;
9400 float vertex3f[6*4*3];
9402 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9403 GL_DepthMask(false);
9404 GL_DepthRange(0, 1);
9405 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
9407 GL_CullFace(GL_NONE);
9408 R_EntityMatrix(&identitymatrix);
9410 R_Mesh_VertexPointer(vertex3f, 0, 0);
9411 R_Mesh_ColorPointer(NULL, 0, 0);
9412 R_Mesh_ResetTextureState();
9413 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9416 GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9417 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9418 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9419 surfacelist[0] < 0 ? 0.5f : 0.125f);
9421 if (VectorCompare(loc->mins, loc->maxs))
9423 VectorSet(size, 2, 2, 2);
9424 VectorMA(loc->mins, -0.5f, size, mins);
9428 VectorCopy(loc->mins, mins);
9429 VectorSubtract(loc->maxs, loc->mins, size);
9432 for (i = 0;i < 6*4*3;)
9433 for (j = 0;j < 3;j++, i++)
9434 vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
9436 R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, locboxelements, 0, 0);
9439 void R_DrawLocs(void)
9442 cl_locnode_t *loc, *nearestloc;
9444 nearestloc = CL_Locs_FindNearest(cl.movement_origin);
9445 for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
9447 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
9448 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
9452 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
9454 if (decalsystem->decals)
9455 Mem_Free(decalsystem->decals);
9456 memset(decalsystem, 0, sizeof(*decalsystem));
9459 static void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, const float *v1, const float *v2, const float *t0, const float *t1, const float *t2, const float *c0, const float *c1, const float *c2, int triangleindex, int surfaceindex, int decalsequence)
9466 // expand or initialize the system
9467 if (decalsystem->maxdecals <= decalsystem->numdecals)
9469 decalsystem_t old = *decalsystem;
9470 qboolean useshortelements;
9471 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
9472 useshortelements = decalsystem->maxdecals * 3 <= 65536;
9473 decalsystem->decals = Mem_Alloc(cls.levelmempool, decalsystem->maxdecals * (sizeof(tridecal_t) + sizeof(float[3][3]) + sizeof(float[3][2]) + sizeof(float[3][4]) + sizeof(int[3]) + (useshortelements ? sizeof(unsigned short[3]) : 0)));
9474 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
9475 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
9476 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
9477 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
9478 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
9479 if (decalsystem->numdecals)
9480 memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
9482 Mem_Free(old.decals);
9483 for (i = 0;i < decalsystem->maxdecals*3;i++)
9484 decalsystem->element3i[i] = i;
9485 if (useshortelements)
9486 for (i = 0;i < decalsystem->maxdecals*3;i++)
9487 decalsystem->element3s[i] = i;
9490 // grab a decal and search for another free slot for the next one
9491 maxdecals = decalsystem->maxdecals;
9492 decals = decalsystem->decals;
9493 decal = decalsystem->decals + (i = decalsystem->freedecal++);
9494 for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
9496 decalsystem->freedecal = i;
9497 if (decalsystem->numdecals <= i)
9498 decalsystem->numdecals = i + 1;
9500 // initialize the decal
9502 decal->triangleindex = triangleindex;
9503 decal->surfaceindex = surfaceindex;
9504 decal->decalsequence = decalsequence;
9505 decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
9506 decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
9507 decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
9508 decal->color4ub[0][3] = 255;
9509 decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
9510 decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
9511 decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
9512 decal->color4ub[1][3] = 255;
9513 decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
9514 decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
9515 decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
9516 decal->color4ub[2][3] = 255;
9517 decal->vertex3f[0][0] = v0[0];
9518 decal->vertex3f[0][1] = v0[1];
9519 decal->vertex3f[0][2] = v0[2];
9520 decal->vertex3f[1][0] = v1[0];
9521 decal->vertex3f[1][1] = v1[1];
9522 decal->vertex3f[1][2] = v1[2];
9523 decal->vertex3f[2][0] = v2[0];
9524 decal->vertex3f[2][1] = v2[1];
9525 decal->vertex3f[2][2] = v2[2];
9526 decal->texcoord2f[0][0] = t0[0];
9527 decal->texcoord2f[0][1] = t0[1];
9528 decal->texcoord2f[1][0] = t1[0];
9529 decal->texcoord2f[1][1] = t1[1];
9530 decal->texcoord2f[2][0] = t2[0];
9531 decal->texcoord2f[2][1] = t2[1];
9534 extern cvar_t cl_decals_bias;
9535 extern cvar_t cl_decals_models;
9536 extern cvar_t cl_decals_newsystem_intensitymultiplier;
9537 static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence)
9539 matrix4x4_t projection;
9540 decalsystem_t *decalsystem;
9543 const float *vertex3f;
9544 const msurface_t *surface;
9545 const msurface_t *surfaces;
9546 const int *surfacelist;
9547 const texture_t *texture;
9551 int surfacelistindex;
9554 int decalsurfaceindex;
9559 float localorigin[3];
9560 float localnormal[3];
9571 float points[2][9][3];
9575 decalsystem = &ent->decalsystem;
9577 if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
9579 R_DecalSystem_Reset(&ent->decalsystem);
9583 if (!model->brush.data_nodes && !cl_decals_models.integer)
9585 if (decalsystem->model)
9586 R_DecalSystem_Reset(decalsystem);
9590 if (decalsystem->model != model)
9591 R_DecalSystem_Reset(decalsystem);
9592 decalsystem->model = model;
9594 RSurf_ActiveModelEntity(ent, false, false, false);
9596 Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
9597 Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
9598 VectorNormalize(localnormal);
9599 localsize = worldsize*rsurface.inversematrixscale;
9600 ilocalsize = 1.0f / localsize;
9601 localmins[0] = localorigin[0] - localsize;
9602 localmins[1] = localorigin[1] - localsize;
9603 localmins[2] = localorigin[2] - localsize;
9604 localmaxs[0] = localorigin[0] + localsize;
9605 localmaxs[1] = localorigin[1] + localsize;
9606 localmaxs[2] = localorigin[2] + localsize;
9608 //VectorCopy(localnormal, planes[4]);
9609 //VectorVectors(planes[4], planes[2], planes[0]);
9610 AnglesFromVectors(angles, localnormal, NULL, false);
9611 AngleVectors(angles, planes[0], planes[2], planes[4]);
9612 VectorNegate(planes[0], planes[1]);
9613 VectorNegate(planes[2], planes[3]);
9614 VectorNegate(planes[4], planes[5]);
9615 planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
9616 planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
9617 planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
9618 planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
9619 planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
9620 planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
9625 matrix4x4_t forwardprojection;
9626 Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
9627 Matrix4x4_Invert_Simple(&projection, &forwardprojection);
9632 float projectionvector[4][3];
9633 VectorScale(planes[0], ilocalsize, projectionvector[0]);
9634 VectorScale(planes[2], ilocalsize, projectionvector[1]);
9635 VectorScale(planes[4], ilocalsize, projectionvector[2]);
9636 projectionvector[0][0] = planes[0][0] * ilocalsize;
9637 projectionvector[0][1] = planes[1][0] * ilocalsize;
9638 projectionvector[0][2] = planes[2][0] * ilocalsize;
9639 projectionvector[1][0] = planes[0][1] * ilocalsize;
9640 projectionvector[1][1] = planes[1][1] * ilocalsize;
9641 projectionvector[1][2] = planes[2][1] * ilocalsize;
9642 projectionvector[2][0] = planes[0][2] * ilocalsize;
9643 projectionvector[2][1] = planes[1][2] * ilocalsize;
9644 projectionvector[2][2] = planes[2][2] * ilocalsize;
9645 projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
9646 projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
9647 projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
9648 Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
9652 dynamic = model->surfmesh.isanimated;
9653 vertex3f = rsurface.modelvertex3f;
9654 numsurfacelist = model->nummodelsurfaces;
9655 surfacelist = model->sortedmodelsurfaces;
9656 surfaces = model->data_surfaces;
9657 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
9659 surfaceindex = surfacelist[surfacelistindex];
9660 surface = surfaces + surfaceindex;
9661 // skip transparent surfaces
9662 texture = surface->texture;
9663 if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
9665 if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
9667 if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
9669 decalsurfaceindex = ent == r_refdef.scene.worldentity ? surfaceindex : -1;
9670 numvertices = surface->num_vertices;
9671 numtriangles = surface->num_triangles;
9672 for (triangleindex = 0, e = model->surfmesh.data_element3i + 3*surface->num_firsttriangle;triangleindex < numtriangles;triangleindex++, e += 3)
9674 for (cornerindex = 0;cornerindex < 3;cornerindex++)
9676 index = 3*e[cornerindex];
9677 VectorCopy(vertex3f + index, v[cornerindex]);
9680 //TriangleNormal(v[0], v[1], v[2], normal);
9681 //if (DotProduct(normal, localnormal) < 0.0f)
9683 // clip by each of the box planes formed from the projection matrix
9684 // if anything survives, we emit the decal
9685 numpoints = PolygonF_Clip(3 , v[0] , planes[0][0], planes[0][1], planes[0][2], planes[0][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
9688 numpoints = PolygonF_Clip(numpoints, points[1][0], planes[1][0], planes[1][1], planes[1][2], planes[1][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[0][0]);
9691 numpoints = PolygonF_Clip(numpoints, points[0][0], planes[2][0], planes[2][1], planes[2][2], planes[2][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
9694 numpoints = PolygonF_Clip(numpoints, points[1][0], planes[3][0], planes[3][1], planes[3][2], planes[3][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[0][0]);
9697 numpoints = PolygonF_Clip(numpoints, points[0][0], planes[4][0], planes[4][1], planes[4][2], planes[4][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
9700 numpoints = PolygonF_Clip(numpoints, points[1][0], planes[5][0], planes[5][1], planes[5][2], planes[5][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), v[0]);
9703 // some part of the triangle survived, so we have to accept it...
9706 // dynamic always uses the original triangle
9708 for (cornerindex = 0;cornerindex < 3;cornerindex++)
9710 index = 3*e[cornerindex];
9711 VectorCopy(vertex3f + index, v[cornerindex]);
9714 for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
9716 // convert vertex positions to texcoords
9717 Matrix4x4_Transform(&projection, v[cornerindex], temp);
9718 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
9719 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
9720 // calculate distance fade from the projection origin
9721 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
9722 f = bound(0.0f, f, 1.0f);
9723 c[cornerindex][0] = r * f;
9724 c[cornerindex][1] = g * f;
9725 c[cornerindex][2] = b * f;
9726 c[cornerindex][3] = 1.0f;
9727 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
9730 R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[1], v[2], tc[0], tc[1], tc[2], c[0], c[1], c[2], triangleindex+surface->num_firsttriangle, surfaceindex, decalsequence);
9732 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
9733 R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[cornerindex+1], v[cornerindex+2], tc[0], tc[cornerindex+1], tc[cornerindex+2], c[0], c[cornerindex+1], c[cornerindex+2], -1, surfaceindex, decalsequence);
9738 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
9739 static void R_DecalSystem_ApplySplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence)
9741 int renderentityindex;
9744 entity_render_t *ent;
9746 if (!cl_decals_newsystem.integer)
9749 worldmins[0] = worldorigin[0] - worldsize;
9750 worldmins[1] = worldorigin[1] - worldsize;
9751 worldmins[2] = worldorigin[2] - worldsize;
9752 worldmaxs[0] = worldorigin[0] + worldsize;
9753 worldmaxs[1] = worldorigin[1] + worldsize;
9754 worldmaxs[2] = worldorigin[2] + worldsize;
9756 R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9758 for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
9760 ent = r_refdef.scene.entities[renderentityindex];
9761 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
9764 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9768 typedef struct r_decalsystem_splatqueue_s
9777 r_decalsystem_splatqueue_t;
9779 int r_decalsystem_numqueued = 0;
9780 #define MAX_DECALSYSTEM_QUEUE 1024
9781 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
9783 void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize)
9785 r_decalsystem_splatqueue_t *queue;
9787 if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
9790 queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
9791 VectorCopy(worldorigin, queue->worldorigin);
9792 VectorCopy(worldnormal, queue->worldnormal);
9793 Vector4Set(queue->color, r, g, b, a);
9794 Vector4Set(queue->tcrange, s1, t1, s2, t2);
9795 queue->worldsize = worldsize;
9796 queue->decalsequence = cl.decalsequence++;
9799 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
9802 r_decalsystem_splatqueue_t *queue;
9804 for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
9805 R_DecalSystem_ApplySplatEntities(queue->worldorigin, queue->worldnormal, queue->color[0], queue->color[1], queue->color[2], queue->color[3], queue->tcrange[0], queue->tcrange[1], queue->tcrange[2], queue->tcrange[3], queue->worldsize, queue->decalsequence);
9806 r_decalsystem_numqueued = 0;
9809 extern cvar_t cl_decals_max;
9810 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
9813 decalsystem_t *decalsystem = &ent->decalsystem;
9820 if (!decalsystem->numdecals)
9823 if (r_showsurfaces.integer)
9826 if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9828 R_DecalSystem_Reset(decalsystem);
9832 killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
9833 lifetime = cl_decals_time.value + cl_decals_fadetime.value;
9835 if (decalsystem->lastupdatetime)
9836 frametime = (cl.time - decalsystem->lastupdatetime);
9839 decalsystem->lastupdatetime = cl.time;
9840 decal = decalsystem->decals;
9841 numdecals = decalsystem->numdecals;
9843 for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9845 if (decal->color4ub[0][3])
9847 decal->lived += frametime;
9848 if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
9850 memset(decal, 0, sizeof(*decal));
9851 if (decalsystem->freedecal > i)
9852 decalsystem->freedecal = i;
9856 decal = decalsystem->decals;
9857 while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
9860 // collapse the array by shuffling the tail decals into the gaps
9863 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
9864 decalsystem->freedecal++;
9865 if (decalsystem->freedecal == numdecals)
9867 decal[decalsystem->freedecal] = decal[--numdecals];
9870 decalsystem->numdecals = numdecals;
9874 // if there are no decals left, reset decalsystem
9875 R_DecalSystem_Reset(decalsystem);
9879 extern skinframe_t *decalskinframe;
9880 static void R_DrawModelDecals_Entity(entity_render_t *ent)
9883 decalsystem_t *decalsystem = &ent->decalsystem;
9893 const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
9896 numdecals = decalsystem->numdecals;
9900 if (r_showsurfaces.integer)
9903 if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9905 R_DecalSystem_Reset(decalsystem);
9909 // if the model is static it doesn't matter what value we give for
9910 // wantnormals and wanttangents, so this logic uses only rules applicable
9911 // to a model, knowing that they are meaningless otherwise
9912 if (ent == r_refdef.scene.worldentity)
9913 RSurf_ActiveWorldEntity();
9915 RSurf_ActiveModelEntity(ent, false, false, false);
9917 decalsystem->lastupdatetime = cl.time;
9918 decal = decalsystem->decals;
9920 fadedelay = cl_decals_time.value;
9921 faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
9923 // update vertex positions for animated models
9924 v3f = decalsystem->vertex3f;
9925 c4f = decalsystem->color4f;
9926 t2f = decalsystem->texcoord2f;
9927 for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9929 if (!decal->color4ub[0][3])
9932 if (surfacevisible && !surfacevisible[decal->surfaceindex])
9935 // update color values for fading decals
9936 if (decal->lived >= cl_decals_time.value)
9938 alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
9939 alpha *= (1.0f/255.0f);
9942 alpha = 1.0f/255.0f;
9944 c4f[ 0] = decal->color4ub[0][0] * alpha;
9945 c4f[ 1] = decal->color4ub[0][1] * alpha;
9946 c4f[ 2] = decal->color4ub[0][2] * alpha;
9948 c4f[ 4] = decal->color4ub[1][0] * alpha;
9949 c4f[ 5] = decal->color4ub[1][1] * alpha;
9950 c4f[ 6] = decal->color4ub[1][2] * alpha;
9952 c4f[ 8] = decal->color4ub[2][0] * alpha;
9953 c4f[ 9] = decal->color4ub[2][1] * alpha;
9954 c4f[10] = decal->color4ub[2][2] * alpha;
9957 t2f[0] = decal->texcoord2f[0][0];
9958 t2f[1] = decal->texcoord2f[0][1];
9959 t2f[2] = decal->texcoord2f[1][0];
9960 t2f[3] = decal->texcoord2f[1][1];
9961 t2f[4] = decal->texcoord2f[2][0];
9962 t2f[5] = decal->texcoord2f[2][1];
9964 // update vertex positions for animated models
9965 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnum_triangles)
9967 e = rsurface.modelelement3i + 3*decal->triangleindex;
9968 VectorCopy(rsurface.vertex3f + 3*e[0], v3f);
9969 VectorCopy(rsurface.vertex3f + 3*e[1], v3f + 3);
9970 VectorCopy(rsurface.vertex3f + 3*e[2], v3f + 6);
9974 VectorCopy(decal->vertex3f[0], v3f);
9975 VectorCopy(decal->vertex3f[1], v3f + 3);
9976 VectorCopy(decal->vertex3f[2], v3f + 6);
9987 r_refdef.stats.drawndecals += numtris;
9989 if (r_refdef.fogenabled)
9991 switch(vid.renderpath)
9993 case RENDERPATH_GL20:
9994 case RENDERPATH_CGGL:
9995 case RENDERPATH_GL13:
9996 case RENDERPATH_GL11:
9997 for (i = 0, v3f = decalsystem->vertex3f, c4f = decalsystem->color4f;i < numtris*3;i++, v3f += 3, c4f += 4)
9999 alpha = RSurf_FogVertex(v3f);
10008 // now render the decals all at once
10009 // (this assumes they all use one particle font texture!)
10010 RSurf_ActiveCustomEntity(&rsurface.matrix, &rsurface.inversematrix, rsurface.ent_flags, rsurface.ent_shadertime, 1, 1, 1, 1, numdecals*3, decalsystem->vertex3f, decalsystem->texcoord2f, NULL, NULL, NULL, decalsystem->color4f, numtris, decalsystem->element3i, decalsystem->element3s, false, false);
10011 R_Mesh_ResetTextureState();
10012 R_Mesh_VertexPointer(decalsystem->vertex3f, 0, 0);
10013 R_Mesh_TexCoordPointer(0, 2, decalsystem->texcoord2f, 0, 0);
10014 R_Mesh_ColorPointer(decalsystem->color4f, 0, 0);
10015 GL_DepthMask(false);
10016 GL_DepthRange(0, 1);
10017 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
10018 GL_DepthTest(true);
10019 GL_CullFace(GL_NONE);
10020 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
10021 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
10022 GL_LockArrays(0, numtris * 3);
10023 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, decalsystem->element3s, 0, 0);
10024 GL_LockArrays(0, 0);
10028 static void R_DrawModelDecals(void)
10032 // fade faster when there are too many decals
10033 numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10034 for (i = 0;i < r_refdef.scene.numentities;i++)
10035 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10037 R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
10038 for (i = 0;i < r_refdef.scene.numentities;i++)
10039 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10040 R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
10042 R_DecalSystem_ApplySplatEntitiesQueue();
10044 numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10045 for (i = 0;i < r_refdef.scene.numentities;i++)
10046 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10048 r_refdef.stats.totaldecals += numdecals;
10050 if (r_showsurfaces.integer)
10053 R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
10055 for (i = 0;i < r_refdef.scene.numentities;i++)
10057 if (!r_refdef.viewcache.entityvisible[i])
10059 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10060 R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
10064 void R_DrawDebugModel(void)
10066 entity_render_t *ent = rsurface.entity;
10067 int i, j, k, l, flagsmask;
10068 const int *elements;
10070 const msurface_t *surface;
10071 dp_model_t *model = ent->model;
10074 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
10076 R_Mesh_ColorPointer(NULL, 0, 0);
10077 R_Mesh_ResetTextureState();
10078 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10079 GL_DepthRange(0, 1);
10080 GL_DepthTest(!r_showdisabledepthtest.integer);
10081 GL_DepthMask(false);
10082 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10084 if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
10086 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
10087 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
10089 if (brush->colbrushf && brush->colbrushf->numtriangles)
10091 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
10092 GL_Color((i & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
10093 R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, 0);
10096 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
10098 if (surface->num_collisiontriangles)
10100 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
10101 GL_Color((i & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((i >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
10102 R_Mesh_Draw(0, surface->num_collisionvertices, 0, surface->num_collisiontriangles, surface->data_collisionelement3i, NULL, 0, 0);
10107 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
10109 if (r_showtris.integer || r_shownormals.integer)
10111 if (r_showdisabledepthtest.integer)
10113 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10114 GL_DepthMask(false);
10118 GL_BlendFunc(GL_ONE, GL_ZERO);
10119 GL_DepthMask(true);
10121 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
10123 if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
10125 rsurface.texture = R_GetCurrentTexture(surface->texture);
10126 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
10128 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
10129 if (r_showtris.value > 0)
10131 if (!rsurface.texture->currentlayers->depthmask)
10132 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
10133 else if (ent == r_refdef.scene.worldentity)
10134 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
10136 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
10137 elements = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
10138 R_Mesh_VertexPointer(rsurface.vertex3f, 0, 0);
10139 R_Mesh_ColorPointer(NULL, 0, 0);
10140 R_Mesh_TexCoordPointer(0, 0, NULL, 0, 0);
10141 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
10142 //R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, model->surfmesh.data_element3i, NULL, 0, 0);
10143 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
10144 qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
10147 if (r_shownormals.value < 0)
10149 qglBegin(GL_LINES);
10150 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10152 VectorCopy(rsurface.vertex3f + l * 3, v);
10153 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10154 qglVertex3f(v[0], v[1], v[2]);
10155 VectorMA(v, -r_shownormals.value, rsurface.svector3f + l * 3, v);
10156 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10157 qglVertex3f(v[0], v[1], v[2]);
10162 if (r_shownormals.value > 0)
10164 qglBegin(GL_LINES);
10165 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10167 VectorCopy(rsurface.vertex3f + l * 3, v);
10168 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10169 qglVertex3f(v[0], v[1], v[2]);
10170 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
10171 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10172 qglVertex3f(v[0], v[1], v[2]);
10176 qglBegin(GL_LINES);
10177 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10179 VectorCopy(rsurface.vertex3f + l * 3, v);
10180 GL_Color(0, r_refdef.view.colorscale, 0, 1);
10181 qglVertex3f(v[0], v[1], v[2]);
10182 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
10183 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10184 qglVertex3f(v[0], v[1], v[2]);
10188 qglBegin(GL_LINES);
10189 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10191 VectorCopy(rsurface.vertex3f + l * 3, v);
10192 GL_Color(0, 0, r_refdef.view.colorscale, 1);
10193 qglVertex3f(v[0], v[1], v[2]);
10194 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
10195 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10196 qglVertex3f(v[0], v[1], v[2]);
10203 rsurface.texture = NULL;
10207 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
10208 int r_maxsurfacelist = 0;
10209 const msurface_t **r_surfacelist = NULL;
10210 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10212 int i, j, endj, f, flagsmask;
10214 dp_model_t *model = r_refdef.scene.worldmodel;
10215 msurface_t *surfaces;
10216 unsigned char *update;
10217 int numsurfacelist = 0;
10221 if (r_maxsurfacelist < model->num_surfaces)
10223 r_maxsurfacelist = model->num_surfaces;
10225 Mem_Free((msurface_t**)r_surfacelist);
10226 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10229 RSurf_ActiveWorldEntity();
10231 surfaces = model->data_surfaces;
10232 update = model->brushq1.lightmapupdateflags;
10234 // update light styles on this submodel
10235 if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10237 model_brush_lightstyleinfo_t *style;
10238 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10240 if (style->value != r_refdef.scene.lightstylevalue[style->style])
10242 int *list = style->surfacelist;
10243 style->value = r_refdef.scene.lightstylevalue[style->style];
10244 for (j = 0;j < style->numsurfaces;j++)
10245 update[list[j]] = true;
10250 flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10254 R_DrawDebugModel();
10255 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10261 rsurface.uselightmaptexture = false;
10262 rsurface.texture = NULL;
10263 rsurface.rtlight = NULL;
10264 numsurfacelist = 0;
10265 // add visible surfaces to draw list
10266 for (i = 0;i < model->nummodelsurfaces;i++)
10268 j = model->sortedmodelsurfaces[i];
10269 if (r_refdef.viewcache.world_surfacevisible[j])
10270 r_surfacelist[numsurfacelist++] = surfaces + j;
10272 // update lightmaps if needed
10276 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10278 if (r_refdef.viewcache.world_surfacevisible[j])
10283 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
10289 int count = model->brushq3.num_mergedlightmaps;
10290 for (i = 0;i < count;i++)
10292 if (model->brushq3.data_deluxemaps[i])
10293 R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10294 if (model->brushq3.data_lightmaps[i])
10295 R_FlushTexture(model->brushq3.data_lightmaps[i]);
10299 // don't do anything if there were no surfaces
10300 if (!numsurfacelist)
10302 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10305 R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10306 GL_AlphaTest(false);
10308 // add to stats if desired
10309 if (r_speeds.integer && !skysurfaces && !depthonly)
10311 r_refdef.stats.world_surfaces += numsurfacelist;
10312 for (j = 0;j < numsurfacelist;j++)
10313 r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
10316 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10319 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10321 int i, j, endj, f, flagsmask;
10323 dp_model_t *model = ent->model;
10324 msurface_t *surfaces;
10325 unsigned char *update;
10326 int numsurfacelist = 0;
10330 if (r_maxsurfacelist < model->num_surfaces)
10332 r_maxsurfacelist = model->num_surfaces;
10334 Mem_Free((msurface_t **)r_surfacelist);
10335 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10338 // if the model is static it doesn't matter what value we give for
10339 // wantnormals and wanttangents, so this logic uses only rules applicable
10340 // to a model, knowing that they are meaningless otherwise
10341 if (ent == r_refdef.scene.worldentity)
10342 RSurf_ActiveWorldEntity();
10343 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
10344 RSurf_ActiveModelEntity(ent, false, false, false);
10346 RSurf_ActiveModelEntity(ent, true, true, true);
10347 else if (depthonly)
10348 RSurf_ActiveModelEntity(ent, false, false, false);
10351 switch (vid.renderpath)
10353 case RENDERPATH_GL20:
10354 case RENDERPATH_CGGL:
10355 RSurf_ActiveModelEntity(ent, true, true, false);
10357 case RENDERPATH_GL13:
10358 case RENDERPATH_GL11:
10359 RSurf_ActiveModelEntity(ent, true, false, false);
10364 surfaces = model->data_surfaces;
10365 update = model->brushq1.lightmapupdateflags;
10367 // update light styles
10368 if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10370 model_brush_lightstyleinfo_t *style;
10371 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10373 if (style->value != r_refdef.scene.lightstylevalue[style->style])
10375 int *list = style->surfacelist;
10376 style->value = r_refdef.scene.lightstylevalue[style->style];
10377 for (j = 0;j < style->numsurfaces;j++)
10378 update[list[j]] = true;
10383 flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10387 R_DrawDebugModel();
10388 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10394 rsurface.uselightmaptexture = false;
10395 rsurface.texture = NULL;
10396 rsurface.rtlight = NULL;
10397 numsurfacelist = 0;
10398 // add visible surfaces to draw list
10399 for (i = 0;i < model->nummodelsurfaces;i++)
10400 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
10401 // don't do anything if there were no surfaces
10402 if (!numsurfacelist)
10404 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10407 // update lightmaps if needed
10411 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10416 R_BuildLightMap(ent, surfaces + j);
10421 int count = model->brushq3.num_mergedlightmaps;
10422 for (i = 0;i < count;i++)
10424 if (model->brushq3.data_deluxemaps[i])
10425 R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10426 if (model->brushq3.data_lightmaps[i])
10427 R_FlushTexture(model->brushq3.data_lightmaps[i]);
10432 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10434 R_BuildLightMap(ent, surfaces + j);
10435 R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10436 GL_AlphaTest(false);
10438 // add to stats if desired
10439 if (r_speeds.integer && !skysurfaces && !depthonly)
10441 r_refdef.stats.entities_surfaces += numsurfacelist;
10442 for (j = 0;j < numsurfacelist;j++)
10443 r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
10446 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10449 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
10451 static texture_t texture;
10452 static msurface_t surface;
10453 const msurface_t *surfacelist = &surface;
10455 // fake enough texture and surface state to render this geometry
10457 texture.update_lastrenderframe = -1; // regenerate this texture
10458 texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
10459 texture.currentskinframe = skinframe;
10460 texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
10461 texture.specularscalemod = 1;
10462 texture.specularpowermod = 1;
10464 surface.texture = &texture;
10465 surface.num_triangles = numtriangles;
10466 surface.num_firsttriangle = firsttriangle;
10467 surface.num_vertices = numvertices;
10468 surface.num_firstvertex = firstvertex;
10471 rsurface.texture = R_GetCurrentTexture(surface.texture);
10472 rsurface.uselightmaptexture = false;
10473 R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
10476 void R_DrawCustomSurface_Texture(texture_t *texture, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
10478 static msurface_t surface;
10479 const msurface_t *surfacelist = &surface;
10481 // fake enough texture and surface state to render this geometry
10483 surface.texture = texture;
10484 surface.num_triangles = numtriangles;
10485 surface.num_firsttriangle = firsttriangle;
10486 surface.num_vertices = numvertices;
10487 surface.num_firstvertex = firstvertex;
10490 rsurface.texture = R_GetCurrentTexture(surface.texture);
10491 rsurface.uselightmaptexture = false;
10492 R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);