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 = cgGetError(), err2 = err;if (err){Con_Printf("%s:%i CG error %i: %s : %s\n", __FILE__, __LINE__, err, cgGetErrorString(err), cgGetLastErrorString(&err2));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:
5044 if (r_cg_permutation && r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR
5045 qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5048 case RENDERPATH_GL13:
5049 case RENDERPATH_GL11:
5050 qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5056 void R_ResetViewRendering2D(void)
5058 r_viewport_t viewport;
5061 // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
5062 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);
5063 R_SetViewport(&viewport);
5064 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
5065 GL_Color(1, 1, 1, 1);
5066 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5067 GL_BlendFunc(GL_ONE, GL_ZERO);
5068 GL_AlphaTest(false);
5069 GL_ScissorTest(false);
5070 GL_DepthMask(false);
5071 GL_DepthRange(0, 1);
5072 GL_DepthTest(false);
5073 R_EntityMatrix(&identitymatrix);
5074 R_Mesh_ResetTextureState();
5075 GL_PolygonOffset(0, 0);
5076 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5077 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5078 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5079 qglStencilMask(~0);CHECKGLERROR
5080 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5081 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5082 GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
5085 void R_ResetViewRendering3D(void)
5090 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5091 GL_Color(1, 1, 1, 1);
5092 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5093 GL_BlendFunc(GL_ONE, GL_ZERO);
5094 GL_AlphaTest(false);
5095 GL_ScissorTest(true);
5097 GL_DepthRange(0, 1);
5099 R_EntityMatrix(&identitymatrix);
5100 R_Mesh_ResetTextureState();
5101 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
5102 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5103 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
5104 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
5105 qglStencilMask(~0);CHECKGLERROR
5106 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
5107 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
5108 GL_CullFace(r_refdef.view.cullface_back);
5111 void R_RenderScene(void);
5112 void R_RenderWaterPlanes(void);
5114 static void R_Water_StartFrame(void)
5117 int waterwidth, waterheight, texturewidth, textureheight;
5118 r_waterstate_waterplane_t *p;
5120 if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
5123 switch(vid.renderpath)
5125 case RENDERPATH_GL20:
5126 case RENDERPATH_CGGL:
5128 case RENDERPATH_GL13:
5129 case RENDERPATH_GL11:
5133 // set waterwidth and waterheight to the water resolution that will be
5134 // used (often less than the screen resolution for faster rendering)
5135 waterwidth = (int)bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width);
5136 waterheight = (int)bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height);
5138 // calculate desired texture sizes
5139 // can't use water if the card does not support the texture size
5140 if (!r_water.integer || r_showsurfaces.integer)
5141 texturewidth = textureheight = waterwidth = waterheight = 0;
5142 else if (vid.support.arb_texture_non_power_of_two)
5144 texturewidth = waterwidth;
5145 textureheight = waterheight;
5149 for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
5150 for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
5153 // allocate textures as needed
5154 if (r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
5156 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5157 for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
5159 if (p->texture_refraction)
5160 R_FreeTexture(p->texture_refraction);
5161 p->texture_refraction = NULL;
5162 if (p->texture_reflection)
5163 R_FreeTexture(p->texture_reflection);
5164 p->texture_reflection = NULL;
5166 memset(&r_waterstate, 0, sizeof(r_waterstate));
5167 r_waterstate.texturewidth = texturewidth;
5168 r_waterstate.textureheight = textureheight;
5171 if (r_waterstate.texturewidth)
5173 r_waterstate.enabled = true;
5175 // when doing a reduced render (HDR) we want to use a smaller area
5176 r_waterstate.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
5177 r_waterstate.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
5179 // set up variables that will be used in shader setup
5180 r_waterstate.screenscale[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5181 r_waterstate.screenscale[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5182 r_waterstate.screencenter[0] = 0.5f * (float)r_waterstate.waterwidth / (float)r_waterstate.texturewidth;
5183 r_waterstate.screencenter[1] = 0.5f * (float)r_waterstate.waterheight / (float)r_waterstate.textureheight;
5186 r_waterstate.maxwaterplanes = MAX_WATERPLANES;
5187 r_waterstate.numwaterplanes = 0;
5190 void R_Water_AddWaterPlane(msurface_t *surface)
5192 int triangleindex, planeindex;
5198 r_waterstate_waterplane_t *p;
5199 texture_t *t = R_GetCurrentTexture(surface->texture);
5200 // just use the first triangle with a valid normal for any decisions
5201 VectorClear(normal);
5202 for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
5204 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
5205 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
5206 Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
5207 TriangleNormal(vert[0], vert[1], vert[2], normal);
5208 if (VectorLength2(normal) >= 0.001)
5212 VectorCopy(normal, plane.normal);
5213 VectorNormalize(plane.normal);
5214 plane.dist = DotProduct(vert[0], plane.normal);
5215 PlaneClassify(&plane);
5216 if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
5218 // skip backfaces (except if nocullface is set)
5219 if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
5221 VectorNegate(plane.normal, plane.normal);
5223 PlaneClassify(&plane);
5227 // find a matching plane if there is one
5228 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5229 if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
5231 if (planeindex >= r_waterstate.maxwaterplanes)
5232 return; // nothing we can do, out of planes
5234 // if this triangle does not fit any known plane rendered this frame, add one
5235 if (planeindex >= r_waterstate.numwaterplanes)
5237 // store the new plane
5238 r_waterstate.numwaterplanes++;
5240 // clear materialflags and pvs
5241 p->materialflags = 0;
5242 p->pvsvalid = false;
5244 // merge this surface's materialflags into the waterplane
5245 p->materialflags |= t->currentmaterialflags;
5246 // merge this surface's PVS into the waterplane
5247 VectorMAM(0.5f, surface->mins, 0.5f, surface->maxs, center);
5248 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
5249 && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
5251 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
5256 static void R_Water_ProcessPlanes(void)
5258 r_refdef_view_t originalview;
5259 r_refdef_view_t myview;
5261 r_waterstate_waterplane_t *p;
5263 originalview = r_refdef.view;
5265 // make sure enough textures are allocated
5266 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5268 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5270 if (!p->texture_refraction)
5271 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);
5272 if (!p->texture_refraction)
5276 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5278 if (!p->texture_reflection)
5279 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);
5280 if (!p->texture_reflection)
5286 r_refdef.view = originalview;
5287 r_refdef.view.showdebug = false;
5288 r_refdef.view.width = r_waterstate.waterwidth;
5289 r_refdef.view.height = r_waterstate.waterheight;
5290 r_refdef.view.useclipplane = true;
5291 myview = r_refdef.view;
5292 r_waterstate.renderingscene = true;
5293 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
5295 // render the normal view scene and copy into texture
5296 // (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)
5297 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5299 r_refdef.view = myview;
5300 r_refdef.view.clipplane = p->plane;
5301 VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
5302 r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
5303 PlaneClassify(&r_refdef.view.clipplane);
5305 R_ResetViewRendering3D();
5306 R_ClearScreen(r_refdef.fogenabled);
5310 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);
5313 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5315 r_refdef.view = myview;
5316 // render reflected scene and copy into texture
5317 Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
5318 // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
5319 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
5320 r_refdef.view.clipplane = p->plane;
5321 // reverse the cullface settings for this render
5322 r_refdef.view.cullface_front = GL_FRONT;
5323 r_refdef.view.cullface_back = GL_BACK;
5324 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
5326 r_refdef.view.usecustompvs = true;
5328 memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5330 memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5333 R_ResetViewRendering3D();
5334 R_ClearScreen(r_refdef.fogenabled);
5338 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);
5341 r_waterstate.renderingscene = false;
5342 r_refdef.view = originalview;
5343 R_ResetViewRendering3D();
5344 R_ClearScreen(r_refdef.fogenabled);
5348 r_refdef.view = originalview;
5349 r_waterstate.renderingscene = false;
5350 Cvar_SetValueQuick(&r_water, 0);
5351 Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
5355 void R_Bloom_StartFrame(void)
5357 int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
5359 switch(vid.renderpath)
5361 case RENDERPATH_GL20:
5362 case RENDERPATH_CGGL:
5364 case RENDERPATH_GL13:
5365 case RENDERPATH_GL11:
5369 // set bloomwidth and bloomheight to the bloom resolution that will be
5370 // used (often less than the screen resolution for faster rendering)
5371 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, vid.height);
5372 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * vid.height / vid.width;
5373 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, vid.height);
5374 r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, (int)vid.maxtexturesize_2d);
5375 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, (int)vid.maxtexturesize_2d);
5377 // calculate desired texture sizes
5378 if (vid.support.arb_texture_non_power_of_two)
5380 screentexturewidth = r_refdef.view.width;
5381 screentextureheight = r_refdef.view.height;
5382 bloomtexturewidth = r_bloomstate.bloomwidth;
5383 bloomtextureheight = r_bloomstate.bloomheight;
5387 for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
5388 for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
5389 for (bloomtexturewidth = 1;bloomtexturewidth < r_bloomstate.bloomwidth ;bloomtexturewidth *= 2);
5390 for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2);
5393 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))
5395 Cvar_SetValueQuick(&r_hdr, 0);
5396 Cvar_SetValueQuick(&r_bloom, 0);
5397 Cvar_SetValueQuick(&r_motionblur, 0);
5398 Cvar_SetValueQuick(&r_damageblur, 0);
5401 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)))
5402 screentexturewidth = screentextureheight = 0;
5403 if (!r_hdr.integer && !r_bloom.integer)
5404 bloomtexturewidth = bloomtextureheight = 0;
5406 // allocate textures as needed
5407 if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
5409 if (r_bloomstate.texture_screen)
5410 R_FreeTexture(r_bloomstate.texture_screen);
5411 r_bloomstate.texture_screen = NULL;
5412 r_bloomstate.screentexturewidth = screentexturewidth;
5413 r_bloomstate.screentextureheight = screentextureheight;
5414 if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
5415 r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCENEAREST | TEXF_CLAMP, NULL);
5417 if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
5419 if (r_bloomstate.texture_bloom)
5420 R_FreeTexture(r_bloomstate.texture_bloom);
5421 r_bloomstate.texture_bloom = NULL;
5422 r_bloomstate.bloomtexturewidth = bloomtexturewidth;
5423 r_bloomstate.bloomtextureheight = bloomtextureheight;
5424 if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
5425 r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
5428 // when doing a reduced render (HDR) we want to use a smaller area
5429 r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.height);
5430 r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_refdef.view.height / r_refdef.view.width;
5431 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_refdef.view.height);
5432 r_bloomstate.bloomwidth = bound(1, r_bloomstate.bloomwidth, r_bloomstate.bloomtexturewidth);
5433 r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_bloomstate.bloomtextureheight);
5435 // set up a texcoord array for the full resolution screen image
5436 // (we have to keep this around to copy back during final render)
5437 r_bloomstate.screentexcoord2f[0] = 0;
5438 r_bloomstate.screentexcoord2f[1] = (float)r_refdef.view.height / (float)r_bloomstate.screentextureheight;
5439 r_bloomstate.screentexcoord2f[2] = (float)r_refdef.view.width / (float)r_bloomstate.screentexturewidth;
5440 r_bloomstate.screentexcoord2f[3] = (float)r_refdef.view.height / (float)r_bloomstate.screentextureheight;
5441 r_bloomstate.screentexcoord2f[4] = (float)r_refdef.view.width / (float)r_bloomstate.screentexturewidth;
5442 r_bloomstate.screentexcoord2f[5] = 0;
5443 r_bloomstate.screentexcoord2f[6] = 0;
5444 r_bloomstate.screentexcoord2f[7] = 0;
5446 // set up a texcoord array for the reduced resolution bloom image
5447 // (which will be additive blended over the screen image)
5448 r_bloomstate.bloomtexcoord2f[0] = 0;
5449 r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5450 r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5451 r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5452 r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5453 r_bloomstate.bloomtexcoord2f[5] = 0;
5454 r_bloomstate.bloomtexcoord2f[6] = 0;
5455 r_bloomstate.bloomtexcoord2f[7] = 0;
5457 if (r_hdr.integer || r_bloom.integer)
5459 r_bloomstate.enabled = true;
5460 r_bloomstate.hdr = r_hdr.integer != 0;
5463 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);
5466 void R_Bloom_CopyBloomTexture(float colorscale)
5468 r_refdef.stats.bloom++;
5470 // scale down screen texture to the bloom texture size
5472 R_SetViewport(&r_bloomstate.viewport);
5473 GL_BlendFunc(GL_ONE, GL_ZERO);
5474 GL_Color(colorscale, colorscale, colorscale, 1);
5475 // TODO: optimize with multitexture or GLSL
5476 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5477 R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5478 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5479 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5481 // we now have a bloom image in the framebuffer
5482 // copy it into the bloom image texture for later processing
5483 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);
5484 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5487 void R_Bloom_CopyHDRTexture(void)
5489 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);
5490 r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5493 void R_Bloom_MakeTexture(void)
5496 float xoffset, yoffset, r, brighten;
5498 r_refdef.stats.bloom++;
5500 R_ResetViewRendering2D();
5501 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5502 R_Mesh_ColorPointer(NULL, 0, 0);
5504 // we have a bloom image in the framebuffer
5506 R_SetViewport(&r_bloomstate.viewport);
5508 for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
5511 r = bound(0, r_bloom_colorexponent.value / x, 1);
5512 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
5513 GL_Color(r, r, r, 1);
5514 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5515 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5516 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5517 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5519 // copy the vertically blurred bloom view to a texture
5520 GL_ActiveTexture(0);
5522 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5523 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5526 range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
5527 brighten = r_bloom_brighten.value;
5529 brighten *= r_hdr_range.value;
5530 brighten = sqrt(brighten);
5532 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
5533 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5534 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
5536 for (dir = 0;dir < 2;dir++)
5538 // blend on at multiple vertical offsets to achieve a vertical blur
5539 // TODO: do offset blends using GLSL
5540 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
5541 GL_BlendFunc(GL_ONE, GL_ZERO);
5542 for (x = -range;x <= range;x++)
5544 if (!dir){xoffset = 0;yoffset = x;}
5545 else {xoffset = x;yoffset = 0;}
5546 xoffset /= (float)r_bloomstate.bloomtexturewidth;
5547 yoffset /= (float)r_bloomstate.bloomtextureheight;
5548 // compute a texcoord array with the specified x and y offset
5549 r_bloomstate.offsettexcoord2f[0] = xoffset+0;
5550 r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5551 r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5552 r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
5553 r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
5554 r_bloomstate.offsettexcoord2f[5] = yoffset+0;
5555 r_bloomstate.offsettexcoord2f[6] = xoffset+0;
5556 r_bloomstate.offsettexcoord2f[7] = yoffset+0;
5557 // this r value looks like a 'dot' particle, fading sharply to
5558 // black at the edges
5559 // (probably not realistic but looks good enough)
5560 //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
5561 //r = brighten/(range*2+1);
5562 r = brighten / (range * 2 + 1);
5564 r *= (1 - x*x/(float)(range*range));
5565 GL_Color(r, r, r, 1);
5566 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5567 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5568 GL_BlendFunc(GL_ONE, GL_ONE);
5571 // copy the vertically blurred bloom view to a texture
5572 GL_ActiveTexture(0);
5574 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR
5575 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5578 // apply subtract last
5579 // (just like it would be in a GLSL shader)
5580 if (r_bloom_colorsubtract.value > 0 && vid.support.ext_blend_subtract)
5582 GL_BlendFunc(GL_ONE, GL_ZERO);
5583 R_SetupShader_Generic(r_bloomstate.texture_bloom, NULL, GL_MODULATE, 1);
5584 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5585 GL_Color(1, 1, 1, 1);
5586 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5587 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5589 GL_BlendFunc(GL_ONE, GL_ONE);
5590 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
5591 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5592 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5593 GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
5594 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5595 r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
5596 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
5598 // copy the darkened bloom view to a texture
5599 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);
5600 r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height;
5604 void R_HDR_RenderBloomTexture(void)
5606 int oldwidth, oldheight;
5607 float oldcolorscale;
5609 oldcolorscale = r_refdef.view.colorscale;
5610 oldwidth = r_refdef.view.width;
5611 oldheight = r_refdef.view.height;
5612 r_refdef.view.width = r_bloomstate.bloomwidth;
5613 r_refdef.view.height = r_bloomstate.bloomheight;
5615 // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer? it might improve SLI performance.
5616 // TODO: add exposure compensation features
5617 // TODO: add fp16 framebuffer support (using GL_EXT_framebuffer_object)
5619 r_refdef.view.showdebug = false;
5620 r_refdef.view.colorscale *= r_bloom_colorscale.value / bound(1, r_hdr_range.value, 16);
5622 R_ResetViewRendering3D();
5624 R_ClearScreen(r_refdef.fogenabled);
5625 if (r_timereport_active)
5626 R_TimeReport("HDRclear");
5629 if (r_timereport_active)
5630 R_TimeReport("visibility");
5632 // only do secondary renders with HDR if r_hdr is 2 or higher
5633 r_waterstate.numwaterplanes = 0;
5634 if (r_waterstate.enabled && r_hdr.integer >= 2)
5635 R_RenderWaterPlanes();
5637 r_refdef.view.showdebug = true;
5639 r_waterstate.numwaterplanes = 0;
5641 R_ResetViewRendering2D();
5643 R_Bloom_CopyHDRTexture();
5644 R_Bloom_MakeTexture();
5646 // restore the view settings
5647 r_refdef.view.width = oldwidth;
5648 r_refdef.view.height = oldheight;
5649 r_refdef.view.colorscale = oldcolorscale;
5650 r_frame++; // used only by R_GetCurrentTexture
5652 R_ResetViewRendering3D();
5654 R_ClearScreen(r_refdef.fogenabled);
5655 if (r_timereport_active)
5656 R_TimeReport("viewclear");
5659 static void R_BlendView(void)
5661 unsigned int permutation;
5662 float uservecs[4][4];
5664 switch (vid.renderpath)
5666 case RENDERPATH_GL20:
5667 case RENDERPATH_CGGL:
5669 (r_bloomstate.texture_bloom ? SHADERPERMUTATION_BLOOM : 0)
5670 | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
5671 | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
5672 | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
5673 | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
5675 if (r_bloomstate.texture_screen)
5677 // make sure the buffer is available
5678 if (r_bloom_blur.value < 1) { Cvar_SetValueQuick(&r_bloom_blur, 1); }
5680 R_ResetViewRendering2D();
5681 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5682 R_Mesh_ColorPointer(NULL, 0, 0);
5684 if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))
5686 // declare variables
5688 static float avgspeed;
5690 speed = VectorLength(cl.movement_velocity);
5692 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_vcoeff.value), 1);
5693 avgspeed = avgspeed * (1 - cl.motionbluralpha) + speed * cl.motionbluralpha;
5695 speed = (avgspeed - r_motionblur_vmin.value) / max(1, r_motionblur_vmax.value - r_motionblur_vmin.value);
5696 speed = bound(0, speed, 1);
5697 speed = speed * (1 - r_motionblur_bmin.value) + r_motionblur_bmin.value;
5699 // calculate values into a standard alpha
5700 cl.motionbluralpha = 1 - exp(-
5702 (r_motionblur.value * speed / 80)
5704 (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
5707 max(0.0001, cl.time - cl.oldtime) // fps independent
5710 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
5711 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
5713 if (cl.motionbluralpha > 0)
5715 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5716 GL_Color(1, 1, 1, cl.motionbluralpha);
5717 R_SetupShader_Generic(r_bloomstate.texture_screen, NULL, GL_MODULATE, 1);
5718 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5719 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5720 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5724 // copy view into the screen texture
5725 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);
5726 r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5728 else if (!r_bloomstate.texture_bloom)
5730 // we may still have to do view tint...
5731 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5733 // apply a color tint to the whole view
5734 R_ResetViewRendering2D();
5735 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5736 R_Mesh_ColorPointer(NULL, 0, 0);
5737 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5738 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5739 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5740 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5742 break; // no screen processing, no bloom, skip it
5745 if (r_bloomstate.texture_bloom && !r_bloomstate.hdr)
5747 // render simple bloom effect
5748 // copy the screen and shrink it and darken it for the bloom process
5749 R_Bloom_CopyBloomTexture(r_bloom_colorscale.value);
5750 // make the bloom texture
5751 R_Bloom_MakeTexture();
5754 #if _MSC_VER >= 1400
5755 #define sscanf sscanf_s
5757 memset(uservecs, 0, sizeof(uservecs));
5758 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
5759 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
5760 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
5761 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
5763 R_ResetViewRendering2D();
5764 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5765 R_Mesh_ColorPointer(NULL, 0, 0);
5766 GL_Color(1, 1, 1, 1);
5767 GL_BlendFunc(GL_ONE, GL_ZERO);
5768 R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
5769 R_Mesh_TexCoordPointer(1, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
5771 switch(vid.renderpath)
5773 case RENDERPATH_GL20:
5774 R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
5775 if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST , R_GetTexture(r_bloomstate.texture_screen));
5776 if (r_glsl_permutation->loc_Texture_Second >= 0) R_Mesh_TexBind(GL20TU_SECOND , R_GetTexture(r_bloomstate.texture_bloom ));
5777 if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, R_GetTexture(r_texture_gammaramps ));
5778 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]);
5779 if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime , cl.time);
5780 if (r_glsl_permutation->loc_PixelSize >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);
5781 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]);
5782 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]);
5783 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]);
5784 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]);
5785 if (r_glsl_permutation->loc_Saturation >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation , r_glsl_saturation.value);
5787 case RENDERPATH_CGGL:
5789 R_SetupShader_SetPermutationCG(SHADERMODE_POSTPROCESS, permutation);
5790 if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , R_GetTexture(r_bloomstate.texture_screen));CHECKCGERROR
5791 if (r_cg_permutation->fp_Texture_Second ) CG_BindTexture(r_cg_permutation->fp_Texture_Second , R_GetTexture(r_bloomstate.texture_bloom ));CHECKCGERROR
5792 if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, R_GetTexture(r_texture_gammaramps ));CHECKCGERROR
5793 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
5794 if (r_cg_permutation->fp_ClientTime ) cgGLSetParameter1f( r_cg_permutation->fp_ClientTime , cl.time);CHECKCGERROR
5795 if (r_cg_permutation->fp_PixelSize ) cgGLSetParameter2f( r_cg_permutation->fp_PixelSize , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR
5796 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
5797 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
5798 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
5799 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
5800 if (r_cg_permutation->fp_Saturation ) cgGLSetParameter1f( r_cg_permutation->fp_Saturation , r_glsl_saturation.value);CHECKCGERROR
5806 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5807 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
5809 case RENDERPATH_GL13:
5810 case RENDERPATH_GL11:
5811 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
5813 // apply a color tint to the whole view
5814 R_ResetViewRendering2D();
5815 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
5816 R_Mesh_ColorPointer(NULL, 0, 0);
5817 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5818 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5819 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
5820 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
5826 matrix4x4_t r_waterscrollmatrix;
5828 void R_UpdateFogColor(void) // needs to be called before HDR subrender too, as that changes colorscale!
5830 if (r_refdef.fog_density)
5832 r_refdef.fogcolor[0] = r_refdef.fog_red;
5833 r_refdef.fogcolor[1] = r_refdef.fog_green;
5834 r_refdef.fogcolor[2] = r_refdef.fog_blue;
5836 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
5837 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
5838 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
5839 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
5843 VectorCopy(r_refdef.fogcolor, fogvec);
5844 // color.rgb *= ContrastBoost * SceneBrightness;
5845 VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
5846 r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
5847 r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
5848 r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
5853 void R_UpdateVariables(void)
5857 r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
5859 r_refdef.farclip = r_farclip_base.value;
5860 if (r_refdef.scene.worldmodel)
5861 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
5862 r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
5864 if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
5865 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
5866 r_refdef.polygonfactor = 0;
5867 r_refdef.polygonoffset = 0;
5868 r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5869 r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
5871 r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
5872 r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
5873 r_refdef.scene.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
5874 r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
5875 r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
5876 if (r_showsurfaces.integer)
5878 r_refdef.scene.rtworld = false;
5879 r_refdef.scene.rtworldshadows = false;
5880 r_refdef.scene.rtdlight = false;
5881 r_refdef.scene.rtdlightshadows = false;
5882 r_refdef.lightmapintensity = 0;
5885 if (gamemode == GAME_NEHAHRA)
5887 if (gl_fogenable.integer)
5889 r_refdef.oldgl_fogenable = true;
5890 r_refdef.fog_density = gl_fogdensity.value;
5891 r_refdef.fog_red = gl_fogred.value;
5892 r_refdef.fog_green = gl_foggreen.value;
5893 r_refdef.fog_blue = gl_fogblue.value;
5894 r_refdef.fog_alpha = 1;
5895 r_refdef.fog_start = 0;
5896 r_refdef.fog_end = gl_skyclip.value;
5897 r_refdef.fog_height = 1<<30;
5898 r_refdef.fog_fadedepth = 128;
5900 else if (r_refdef.oldgl_fogenable)
5902 r_refdef.oldgl_fogenable = false;
5903 r_refdef.fog_density = 0;
5904 r_refdef.fog_red = 0;
5905 r_refdef.fog_green = 0;
5906 r_refdef.fog_blue = 0;
5907 r_refdef.fog_alpha = 0;
5908 r_refdef.fog_start = 0;
5909 r_refdef.fog_end = 0;
5910 r_refdef.fog_height = 1<<30;
5911 r_refdef.fog_fadedepth = 128;
5915 r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
5916 r_refdef.fog_start = max(0, r_refdef.fog_start);
5917 r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
5919 // R_UpdateFogColor(); // why? R_RenderScene does it anyway
5921 if (r_refdef.fog_density && r_drawfog.integer)
5923 r_refdef.fogenabled = true;
5924 // this is the point where the fog reaches 0.9986 alpha, which we
5925 // consider a good enough cutoff point for the texture
5926 // (0.9986 * 256 == 255.6)
5927 if (r_fog_exp2.integer)
5928 r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
5930 r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
5931 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
5932 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
5933 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
5934 // fog color was already set
5935 // update the fog texture
5936 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)
5937 R_BuildFogTexture();
5940 r_refdef.fogenabled = false;
5942 switch(vid.renderpath)
5944 case RENDERPATH_GL20:
5945 case RENDERPATH_CGGL:
5946 if(v_glslgamma.integer && !vid_gammatables_trivial)
5948 if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
5950 // build GLSL gamma texture
5951 #define RAMPWIDTH 256
5952 unsigned short ramp[RAMPWIDTH * 3];
5953 unsigned char rampbgr[RAMPWIDTH][4];
5956 r_texture_gammaramps_serial = vid_gammatables_serial;
5958 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
5959 for(i = 0; i < RAMPWIDTH; ++i)
5961 rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5962 rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
5963 rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
5966 if (r_texture_gammaramps)
5968 R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, RAMPWIDTH, 1);
5972 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);
5978 // remove GLSL gamma texture
5981 case RENDERPATH_GL13:
5982 case RENDERPATH_GL11:
5987 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
5988 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
5994 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
5995 if( scenetype != r_currentscenetype ) {
5996 // store the old scenetype
5997 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
5998 r_currentscenetype = scenetype;
5999 // move in the new scene
6000 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
6009 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
6011 // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
6012 if( scenetype == r_currentscenetype ) {
6013 return &r_refdef.scene;
6015 return &r_scenes_store[ scenetype ];
6024 void R_RenderView(void)
6026 if (r_timereport_active)
6027 R_TimeReport("start");
6028 r_frame++; // used only by R_GetCurrentTexture
6029 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
6031 if (!r_drawentities.integer)
6032 r_refdef.scene.numentities = 0;
6034 R_AnimCache_ClearCache();
6035 R_FrameData_NewFrame();
6037 if (r_refdef.view.isoverlay)
6039 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
6040 GL_Clear( GL_DEPTH_BUFFER_BIT );
6041 R_TimeReport("depthclear");
6043 r_refdef.view.showdebug = false;
6045 r_waterstate.enabled = false;
6046 r_waterstate.numwaterplanes = 0;
6054 if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer/* || !r_refdef.scene.worldmodel*/)
6055 return; //Host_Error ("R_RenderView: NULL worldmodel");
6057 r_refdef.view.colorscale = r_hdr_scenebrightness.value;
6059 // break apart the view matrix into vectors for various purposes
6060 // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
6061 // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
6062 Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
6063 VectorNegate(r_refdef.view.left, r_refdef.view.right);
6064 // make an inverted copy of the view matrix for tracking sprites
6065 Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
6067 R_Shadow_UpdateWorldLightSelection();
6069 R_Bloom_StartFrame();
6070 R_Water_StartFrame();
6073 if (r_timereport_active)
6074 R_TimeReport("viewsetup");
6076 R_ResetViewRendering3D();
6078 if (r_refdef.view.clear || r_refdef.fogenabled)
6080 R_ClearScreen(r_refdef.fogenabled);
6081 if (r_timereport_active)
6082 R_TimeReport("viewclear");
6084 r_refdef.view.clear = true;
6086 // this produces a bloom texture to be used in R_BlendView() later
6087 if (r_hdr.integer && r_bloomstate.bloomwidth)
6088 R_HDR_RenderBloomTexture();
6090 r_refdef.view.showdebug = true;
6093 if (r_timereport_active)
6094 R_TimeReport("visibility");
6096 r_waterstate.numwaterplanes = 0;
6097 if (r_waterstate.enabled)
6098 R_RenderWaterPlanes();
6101 r_waterstate.numwaterplanes = 0;
6104 if (r_timereport_active)
6105 R_TimeReport("blendview");
6107 GL_Scissor(0, 0, vid.width, vid.height);
6108 GL_ScissorTest(false);
6112 void R_RenderWaterPlanes(void)
6114 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
6116 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
6117 if (r_timereport_active)
6118 R_TimeReport("waterworld");
6121 // don't let sound skip if going slow
6122 if (r_refdef.scene.extraupdate)
6125 R_DrawModelsAddWaterPlanes();
6126 if (r_timereport_active)
6127 R_TimeReport("watermodels");
6129 if (r_waterstate.numwaterplanes)
6131 R_Water_ProcessPlanes();
6132 if (r_timereport_active)
6133 R_TimeReport("waterscenes");
6137 extern void R_DrawLightningBeams (void);
6138 extern void VM_CL_AddPolygonsToMeshQueue (void);
6139 extern void R_DrawPortals (void);
6140 extern cvar_t cl_locs_show;
6141 static void R_DrawLocs(void);
6142 static void R_DrawEntityBBoxes(void);
6143 static void R_DrawModelDecals(void);
6144 extern cvar_t cl_decals_newsystem;
6145 extern qboolean r_shadow_usingdeferredprepass;
6146 void R_RenderScene(void)
6148 r_refdef.stats.renders++;
6152 // don't let sound skip if going slow
6153 if (r_refdef.scene.extraupdate)
6156 R_MeshQueue_BeginScene();
6160 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);
6162 if (cl.csqc_vidvars.drawworld)
6164 // don't let sound skip if going slow
6165 if (r_refdef.scene.extraupdate)
6168 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
6170 r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
6171 if (r_timereport_active)
6172 R_TimeReport("worldsky");
6175 if (R_DrawBrushModelsSky() && r_timereport_active)
6176 R_TimeReport("bmodelsky");
6178 if (skyrendermasked && skyrenderlater)
6180 // we have to force off the water clipping plane while rendering sky
6184 if (r_timereport_active)
6185 R_TimeReport("sky");
6189 R_AnimCache_CacheVisibleEntities();
6190 if (r_timereport_active)
6191 R_TimeReport("animation");
6193 R_Shadow_PrepareLights();
6194 if (r_timereport_active)
6195 R_TimeReport("preparelights");
6197 if (r_shadow_usingdeferredprepass)
6198 R_Shadow_DrawPrepass();
6200 if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
6202 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
6203 if (r_timereport_active)
6204 R_TimeReport("worlddepth");
6206 if (r_depthfirst.integer >= 2)
6208 R_DrawModelsDepth();
6209 if (r_timereport_active)
6210 R_TimeReport("modeldepth");
6213 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
6215 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
6216 if (r_timereport_active)
6217 R_TimeReport("world");
6220 // don't let sound skip if going slow
6221 if (r_refdef.scene.extraupdate)
6225 if (r_timereport_active)
6226 R_TimeReport("models");
6228 // don't let sound skip if going slow
6229 if (r_refdef.scene.extraupdate)
6232 if (r_shadows.integer > 0 && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6234 R_DrawModelShadows();
6235 R_ResetViewRendering3D();
6236 // don't let sound skip if going slow
6237 if (r_refdef.scene.extraupdate)
6241 if (!r_shadow_usingdeferredprepass)
6243 R_Shadow_DrawLights();
6244 if (r_timereport_active)
6245 R_TimeReport("rtlights");
6248 // don't let sound skip if going slow
6249 if (r_refdef.scene.extraupdate)
6252 if (r_shadows.integer > 0 && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
6254 R_DrawModelShadows();
6255 R_ResetViewRendering3D();
6256 // don't let sound skip if going slow
6257 if (r_refdef.scene.extraupdate)
6261 if (cl.csqc_vidvars.drawworld)
6263 if (cl_decals_newsystem.integer)
6265 R_DrawModelDecals();
6266 if (r_timereport_active)
6267 R_TimeReport("modeldecals");
6272 if (r_timereport_active)
6273 R_TimeReport("decals");
6277 if (r_timereport_active)
6278 R_TimeReport("particles");
6281 if (r_timereport_active)
6282 R_TimeReport("explosions");
6284 R_DrawLightningBeams();
6285 if (r_timereport_active)
6286 R_TimeReport("lightning");
6289 VM_CL_AddPolygonsToMeshQueue();
6291 if (r_refdef.view.showdebug)
6293 if (cl_locs_show.integer)
6296 if (r_timereport_active)
6297 R_TimeReport("showlocs");
6300 if (r_drawportals.integer)
6303 if (r_timereport_active)
6304 R_TimeReport("portals");
6307 if (r_showbboxes.value > 0)
6309 R_DrawEntityBBoxes();
6310 if (r_timereport_active)
6311 R_TimeReport("bboxes");
6315 R_MeshQueue_RenderTransparent();
6316 if (r_timereport_active)
6317 R_TimeReport("drawtrans");
6319 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))
6321 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
6322 if (r_timereport_active)
6323 R_TimeReport("worlddebug");
6324 R_DrawModelsDebug();
6325 if (r_timereport_active)
6326 R_TimeReport("modeldebug");
6329 if (cl.csqc_vidvars.drawworld)
6331 R_Shadow_DrawCoronas();
6332 if (r_timereport_active)
6333 R_TimeReport("coronas");
6336 // don't let sound skip if going slow
6337 if (r_refdef.scene.extraupdate)
6340 R_ResetViewRendering2D();
6343 static const unsigned short bboxelements[36] =
6353 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
6356 float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
6358 RSurf_ActiveWorldEntity();
6360 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6361 GL_DepthMask(false);
6362 GL_DepthRange(0, 1);
6363 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
6364 R_Mesh_ResetTextureState();
6366 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
6367 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
6368 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
6369 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
6370 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
6371 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
6372 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
6373 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
6374 R_FillColors(color4f, 8, cr, cg, cb, ca);
6375 if (r_refdef.fogenabled)
6377 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
6379 f1 = RSurf_FogVertex(v);
6381 c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
6382 c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
6383 c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
6386 R_Mesh_VertexPointer(vertex3f, 0, 0);
6387 R_Mesh_ColorPointer(color4f, 0, 0);
6388 R_Mesh_ResetTextureState();
6389 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6390 R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
6393 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6397 prvm_edict_t *edict;
6398 prvm_prog_t *prog_save = prog;
6400 // this function draws bounding boxes of server entities
6404 GL_CullFace(GL_NONE);
6405 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6409 for (i = 0;i < numsurfaces;i++)
6411 edict = PRVM_EDICT_NUM(surfacelist[i]);
6412 switch ((int)edict->fields.server->solid)
6414 case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
6415 case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
6416 case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
6417 case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
6418 case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
6419 default: Vector4Set(color, 0, 0, 0, 0.50);break;
6421 color[3] *= r_showbboxes.value;
6422 color[3] = bound(0, color[3], 1);
6423 GL_DepthTest(!r_showdisabledepthtest.integer);
6424 GL_CullFace(r_refdef.view.cullface_front);
6425 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
6431 static void R_DrawEntityBBoxes(void)
6434 prvm_edict_t *edict;
6436 prvm_prog_t *prog_save = prog;
6438 // this function draws bounding boxes of server entities
6444 for (i = 0;i < prog->num_edicts;i++)
6446 edict = PRVM_EDICT_NUM(i);
6447 if (edict->priv.server->free)
6449 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
6450 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.tag_entity)->edict != 0)
6452 if(PRVM_EDICTFIELDVALUE(edict, prog->fieldoffsets.viewmodelforclient)->edict != 0)
6454 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
6455 R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
6461 static const int nomodelelement3i[24] =
6473 static const unsigned short nomodelelement3s[24] =
6485 static const float nomodelvertex3f[6*3] =
6495 static const float nomodelcolor4f[6*4] =
6497 0.0f, 0.0f, 0.5f, 1.0f,
6498 0.0f, 0.0f, 0.5f, 1.0f,
6499 0.0f, 0.5f, 0.0f, 1.0f,
6500 0.0f, 0.5f, 0.0f, 1.0f,
6501 0.5f, 0.0f, 0.0f, 1.0f,
6502 0.5f, 0.0f, 0.0f, 1.0f
6505 void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
6511 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);
6513 // this is only called once per entity so numsurfaces is always 1, and
6514 // surfacelist is always {0}, so this code does not handle batches
6516 if (rsurface.ent_flags & RENDER_ADDITIVE)
6518 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
6519 GL_DepthMask(false);
6521 else if (rsurface.colormod[3] < 1)
6523 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6524 GL_DepthMask(false);
6528 GL_BlendFunc(GL_ONE, GL_ZERO);
6531 GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
6532 GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
6533 GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
6534 GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
6535 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
6536 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
6537 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
6538 R_Mesh_ColorPointer(color4f, 0, 0);
6539 for (i = 0, c = color4f;i < 6;i++, c += 4)
6541 c[0] *= rsurface.colormod[0];
6542 c[1] *= rsurface.colormod[1];
6543 c[2] *= rsurface.colormod[2];
6544 c[3] *= rsurface.colormod[3];
6546 if (r_refdef.fogenabled)
6548 for (i = 0, c = color4f;i < 6;i++, c += 4)
6550 f1 = RSurf_FogVertex(rsurface.vertex3f + 3*i);
6552 c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
6553 c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
6554 c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
6557 R_Mesh_ResetTextureState();
6558 R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, nomodelelement3s, 0, 0);
6561 void R_DrawNoModel(entity_render_t *ent)
6564 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
6565 if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
6566 R_MeshQueue_AddTransparent(ent->flags & RENDER_NODEPTHTEST ? r_refdef.view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
6568 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
6571 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
6573 vec3_t right1, right2, diff, normal;
6575 VectorSubtract (org2, org1, normal);
6577 // calculate 'right' vector for start
6578 VectorSubtract (r_refdef.view.origin, org1, diff);
6579 CrossProduct (normal, diff, right1);
6580 VectorNormalize (right1);
6582 // calculate 'right' vector for end
6583 VectorSubtract (r_refdef.view.origin, org2, diff);
6584 CrossProduct (normal, diff, right2);
6585 VectorNormalize (right2);
6587 vert[ 0] = org1[0] + width * right1[0];
6588 vert[ 1] = org1[1] + width * right1[1];
6589 vert[ 2] = org1[2] + width * right1[2];
6590 vert[ 3] = org1[0] - width * right1[0];
6591 vert[ 4] = org1[1] - width * right1[1];
6592 vert[ 5] = org1[2] - width * right1[2];
6593 vert[ 6] = org2[0] - width * right2[0];
6594 vert[ 7] = org2[1] - width * right2[1];
6595 vert[ 8] = org2[2] - width * right2[2];
6596 vert[ 9] = org2[0] + width * right2[0];
6597 vert[10] = org2[1] + width * right2[1];
6598 vert[11] = org2[2] + width * right2[2];
6601 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)
6603 vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
6604 vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
6605 vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
6606 vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
6607 vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
6608 vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
6609 vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
6610 vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
6611 vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
6612 vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
6613 vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
6614 vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
6617 int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
6622 VectorSet(v, x, y, z);
6623 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
6624 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
6626 if (i == mesh->numvertices)
6628 if (mesh->numvertices < mesh->maxvertices)
6630 VectorCopy(v, vertex3f);
6631 mesh->numvertices++;
6633 return mesh->numvertices;
6639 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
6643 element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6644 element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
6645 e = mesh->element3i + mesh->numtriangles * 3;
6646 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
6648 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
6649 if (mesh->numtriangles < mesh->maxtriangles)
6654 mesh->numtriangles++;
6656 element[1] = element[2];
6660 void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
6664 element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6665 element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
6666 e = mesh->element3i + mesh->numtriangles * 3;
6667 for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
6669 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
6670 if (mesh->numtriangles < mesh->maxtriangles)
6675 mesh->numtriangles++;
6677 element[1] = element[2];
6681 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
6682 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
6684 int planenum, planenum2;
6687 mplane_t *plane, *plane2;
6689 double temppoints[2][256*3];
6690 // figure out how large a bounding box we need to properly compute this brush
6692 for (w = 0;w < numplanes;w++)
6693 maxdist = max(maxdist, fabs(planes[w].dist));
6694 // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
6695 maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
6696 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
6700 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
6701 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
6703 if (planenum2 == planenum)
6705 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);
6708 if (tempnumpoints < 3)
6710 // generate elements forming a triangle fan for this polygon
6711 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
6715 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)
6717 texturelayer_t *layer;
6718 layer = t->currentlayers + t->currentnumlayers++;
6720 layer->depthmask = depthmask;
6721 layer->blendfunc1 = blendfunc1;
6722 layer->blendfunc2 = blendfunc2;
6723 layer->texture = texture;
6724 layer->texmatrix = *matrix;
6725 layer->color[0] = r;
6726 layer->color[1] = g;
6727 layer->color[2] = b;
6728 layer->color[3] = a;
6731 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
6734 index = parms[2] + r_refdef.scene.time * parms[3];
6735 index -= floor(index);
6739 case Q3WAVEFUNC_NONE:
6740 case Q3WAVEFUNC_NOISE:
6741 case Q3WAVEFUNC_COUNT:
6744 case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
6745 case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
6746 case Q3WAVEFUNC_SAWTOOTH: f = index;break;
6747 case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
6748 case Q3WAVEFUNC_TRIANGLE:
6750 f = index - floor(index);
6761 return (float)(parms[0] + parms[1] * f);
6764 void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
6769 matrix4x4_t matrix, temp;
6770 switch(tcmod->tcmod)
6774 if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6775 matrix = r_waterscrollmatrix;
6777 matrix = identitymatrix;
6779 case Q3TCMOD_ENTITYTRANSLATE:
6780 // this is used in Q3 to allow the gamecode to control texcoord
6781 // scrolling on the entity, which is not supported in darkplaces yet.
6782 Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
6784 case Q3TCMOD_ROTATE:
6785 Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
6786 Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.scene.time, 0, 0, 1);
6787 Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
6790 Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
6792 case Q3TCMOD_SCROLL:
6793 Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.scene.time, tcmod->parms[1] * r_refdef.scene.time, 0);
6795 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
6796 w = (int) tcmod->parms[0];
6797 h = (int) tcmod->parms[1];
6798 f = r_refdef.scene.time / (tcmod->parms[2] * w * h);
6800 idx = (int) floor(f * w * h);
6801 Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
6803 case Q3TCMOD_STRETCH:
6804 f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
6805 Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
6807 case Q3TCMOD_TRANSFORM:
6808 VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
6809 VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
6810 VectorSet(tcmat + 6, 0 , 0 , 1);
6811 VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
6812 Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
6814 case Q3TCMOD_TURBULENT:
6815 // this is handled in the RSurf_PrepareVertices function
6816 matrix = identitymatrix;
6820 Matrix4x4_Concat(texmatrix, &matrix, &temp);
6823 void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
6825 int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS;
6826 char name[MAX_QPATH];
6827 skinframe_t *skinframe;
6828 unsigned char pixels[296*194];
6829 strlcpy(cache->name, skinname, sizeof(cache->name));
6830 dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
6831 if (developer_loading.integer)
6832 Con_Printf("loading %s\n", name);
6833 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
6834 if (!skinframe || !skinframe->base)
6837 fs_offset_t filesize;
6839 f = FS_LoadFile(name, tempmempool, true, &filesize);
6842 if (LoadPCX_QWSkin(f, filesize, pixels, 296, 194))
6843 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
6847 cache->skinframe = skinframe;
6850 texture_t *R_GetCurrentTexture(texture_t *t)
6853 const entity_render_t *ent = rsurface.entity;
6854 dp_model_t *model = ent->model;
6855 q3shaderinfo_layer_tcmod_t *tcmod;
6857 if (t->update_lastrenderframe == r_frame && t->update_lastrenderentity == (void *)ent)
6858 return t->currentframe;
6859 t->update_lastrenderframe = r_frame;
6860 t->update_lastrenderentity = (void *)ent;
6862 // switch to an alternate material if this is a q1bsp animated material
6864 texture_t *texture = t;
6865 int s = rsurface.ent_skinnum;
6866 if ((unsigned int)s >= (unsigned int)model->numskins)
6868 if (model->skinscenes)
6870 if (model->skinscenes[s].framecount > 1)
6871 s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.scene.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
6873 s = model->skinscenes[s].firstframe;
6876 t = t + s * model->num_surfaces;
6879 // use an alternate animation if the entity's frame is not 0,
6880 // and only if the texture has an alternate animation
6881 if (rsurface.ent_alttextures && t->anim_total[1])
6882 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[1]) : 0];
6884 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.scene.time * 5.0f) % t->anim_total[0]) : 0];
6886 texture->currentframe = t;
6889 // update currentskinframe to be a qw skin or animation frame
6890 if (rsurface.ent_qwskin >= 0)
6892 i = rsurface.ent_qwskin;
6893 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
6895 r_qwskincache_size = cl.maxclients;
6897 Mem_Free(r_qwskincache);
6898 r_qwskincache = Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
6900 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
6901 R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
6902 t->currentskinframe = r_qwskincache[i].skinframe;
6903 if (t->currentskinframe == NULL)
6904 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6906 else if (t->numskinframes >= 2)
6907 t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - rsurface.ent_shadertime)) % t->numskinframes];
6908 if (t->backgroundnumskinframes >= 2)
6909 t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - rsurface.ent_shadertime)) % t->backgroundnumskinframes];
6911 t->currentmaterialflags = t->basematerialflags;
6912 t->currentalpha = rsurface.colormod[3];
6913 if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
6914 t->currentalpha *= r_wateralpha.value;
6915 if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_waterstate.enabled && !r_refdef.view.isoverlay)
6916 t->currentalpha *= t->r_water_wateralpha;
6917 if(!r_waterstate.enabled || r_refdef.view.isoverlay)
6918 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
6919 if (!(rsurface.ent_flags & RENDER_LIGHT))
6920 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
6921 else if (rsurface.modeltexcoordlightmap2f == NULL && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
6923 // pick a model lighting mode
6924 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
6925 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
6927 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
6929 if (rsurface.ent_flags & RENDER_ADDITIVE)
6930 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6931 else if (t->currentalpha < 1)
6932 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
6933 if (rsurface.ent_flags & RENDER_DOUBLESIDED)
6934 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
6935 if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
6936 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
6937 if (t->backgroundnumskinframes)
6938 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
6939 if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
6941 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER))
6942 t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
6945 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER);
6946 if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
6947 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
6949 // there is no tcmod
6950 if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
6952 t->currenttexmatrix = r_waterscrollmatrix;
6953 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
6955 else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
6957 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
6958 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
6961 for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6962 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
6963 for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
6964 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
6966 t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
6967 if (t->currentskinframe->qpixels)
6968 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
6969 t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
6970 t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
6971 t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
6972 t->nmaptexture = t->currentskinframe->nmap;
6973 t->glosstexture = r_texture_black;
6974 t->glowtexture = t->currentskinframe->glow;
6975 t->fogtexture = t->currentskinframe->fog;
6976 if (t->backgroundnumskinframes)
6978 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
6979 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
6980 t->backgroundglosstexture = r_texture_black;
6981 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
6985 t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
6986 t->backgroundnmaptexture = r_texture_blanknormalmap;
6987 t->backgroundglosstexture = r_texture_black;
6988 t->backgroundglowtexture = NULL;
6990 t->specularpower = r_shadow_glossexponent.value;
6991 // TODO: store reference values for these in the texture?
6992 t->specularscale = 0;
6993 if (r_shadow_gloss.integer > 0)
6995 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
6997 if (r_shadow_glossintensity.value > 0)
6999 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
7000 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
7001 t->specularscale = r_shadow_glossintensity.value;
7004 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
7006 t->glosstexture = r_texture_white;
7007 t->backgroundglosstexture = r_texture_white;
7008 t->specularscale = r_shadow_gloss2intensity.value;
7009 t->specularpower = r_shadow_gloss2exponent.value;
7012 t->specularscale *= t->specularscalemod;
7013 t->specularpower *= t->specularpowermod;
7015 // lightmaps mode looks bad with dlights using actual texturing, so turn
7016 // off the colormap and glossmap, but leave the normalmap on as it still
7017 // accurately represents the shading involved
7018 if (gl_lightmaps.integer)
7020 t->basetexture = r_texture_grey128;
7021 t->pantstexture = r_texture_black;
7022 t->shirttexture = r_texture_black;
7023 t->nmaptexture = r_texture_blanknormalmap;
7024 t->glosstexture = r_texture_black;
7025 t->glowtexture = NULL;
7026 t->fogtexture = NULL;
7027 t->backgroundbasetexture = NULL;
7028 t->backgroundnmaptexture = r_texture_blanknormalmap;
7029 t->backgroundglosstexture = r_texture_black;
7030 t->backgroundglowtexture = NULL;
7031 t->specularscale = 0;
7032 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
7035 Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
7036 VectorClear(t->dlightcolor);
7037 t->currentnumlayers = 0;
7038 if (t->currentmaterialflags & MATERIALFLAG_WALL)
7040 int blendfunc1, blendfunc2;
7042 if (t->currentmaterialflags & MATERIALFLAG_ADD)
7044 blendfunc1 = GL_SRC_ALPHA;
7045 blendfunc2 = GL_ONE;
7047 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
7049 blendfunc1 = GL_SRC_ALPHA;
7050 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
7052 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
7054 blendfunc1 = t->customblendfunc[0];
7055 blendfunc2 = t->customblendfunc[1];
7059 blendfunc1 = GL_ONE;
7060 blendfunc2 = GL_ZERO;
7062 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
7063 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
7065 // fullbright is not affected by r_refdef.lightmapintensity
7066 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]);
7067 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7068 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]);
7069 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7070 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]);
7074 vec3_t ambientcolor;
7076 // set the color tint used for lights affecting this surface
7077 VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
7079 // q3bsp has no lightmap updates, so the lightstylevalue that
7080 // would normally be baked into the lightmap must be
7081 // applied to the color
7082 // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
7083 if (model->type == mod_brushq3)
7084 colorscale *= r_refdef.scene.rtlightstylevalue[0];
7085 colorscale *= r_refdef.lightmapintensity;
7086 VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
7087 VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
7088 // basic lit geometry
7089 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]);
7090 // add pants/shirt if needed
7091 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7092 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]);
7093 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7094 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]);
7095 // now add ambient passes if needed
7096 if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
7098 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]);
7099 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
7100 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]);
7101 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
7102 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]);
7105 if (t->glowtexture != NULL && !gl_lightmaps.integer)
7106 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]);
7107 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
7109 // if this is opaque use alpha blend which will darken the earlier
7112 // if this is an alpha blended material, all the earlier passes
7113 // were darkened by fog already, so we only need to add the fog
7114 // color ontop through the fog mask texture
7116 // if this is an additive blended material, all the earlier passes
7117 // were darkened by fog already, and we should not add fog color
7118 // (because the background was not darkened, there is no fog color
7119 // that was lost behind it).
7120 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]);
7124 return t->currentframe;
7127 rsurfacestate_t rsurface;
7129 void R_Mesh_ResizeArrays(int newvertices)
7132 if (rsurface.array_size >= newvertices)
7134 if (rsurface.array_modelvertex3f)
7135 Mem_Free(rsurface.array_modelvertex3f);
7136 rsurface.array_size = (newvertices + 1023) & ~1023;
7137 base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
7138 rsurface.array_modelvertex3f = base + rsurface.array_size * 0;
7139 rsurface.array_modelsvector3f = base + rsurface.array_size * 3;
7140 rsurface.array_modeltvector3f = base + rsurface.array_size * 6;
7141 rsurface.array_modelnormal3f = base + rsurface.array_size * 9;
7142 rsurface.array_deformedvertex3f = base + rsurface.array_size * 12;
7143 rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
7144 rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
7145 rsurface.array_deformednormal3f = base + rsurface.array_size * 21;
7146 rsurface.array_texcoord3f = base + rsurface.array_size * 24;
7147 rsurface.array_color4f = base + rsurface.array_size * 27;
7148 rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
7151 void RSurf_ActiveWorldEntity(void)
7153 dp_model_t *model = r_refdef.scene.worldmodel;
7154 //if (rsurface.entity == r_refdef.scene.worldentity)
7156 rsurface.entity = r_refdef.scene.worldentity;
7157 rsurface.skeleton = NULL;
7158 rsurface.ent_skinnum = 0;
7159 rsurface.ent_qwskin = -1;
7160 rsurface.ent_shadertime = 0;
7161 rsurface.ent_flags = r_refdef.scene.worldentity->flags;
7162 if (rsurface.array_size < model->surfmesh.num_vertices)
7163 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7164 rsurface.matrix = identitymatrix;
7165 rsurface.inversematrix = identitymatrix;
7166 rsurface.matrixscale = 1;
7167 rsurface.inversematrixscale = 1;
7168 R_EntityMatrix(&identitymatrix);
7169 VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
7170 Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
7171 rsurface.fograngerecip = r_refdef.fograngerecip;
7172 rsurface.fogheightfade = r_refdef.fogheightfade;
7173 rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
7174 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7175 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7176 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7177 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7178 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7179 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7180 VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
7181 rsurface.colormod[3] = 1;
7182 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);
7183 memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7184 rsurface.frameblend[0].lerp = 1;
7185 rsurface.ent_alttextures = false;
7186 rsurface.basepolygonfactor = r_refdef.polygonfactor;
7187 rsurface.basepolygonoffset = r_refdef.polygonoffset;
7188 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
7189 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7190 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7191 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7192 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7193 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7194 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7195 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7196 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7197 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
7198 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7199 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7200 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
7201 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7202 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7203 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
7204 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7205 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7206 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
7207 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7208 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7209 rsurface.modelelement3i = model->surfmesh.data_element3i;
7210 rsurface.modelelement3s = model->surfmesh.data_element3s;
7211 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7212 rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7213 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7214 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7215 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7216 rsurface.modelsurfaces = model->data_surfaces;
7217 rsurface.generatedvertex = false;
7218 rsurface.vertex3f = rsurface.modelvertex3f;
7219 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7220 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7221 rsurface.svector3f = rsurface.modelsvector3f;
7222 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7223 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7224 rsurface.tvector3f = rsurface.modeltvector3f;
7225 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7226 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7227 rsurface.normal3f = rsurface.modelnormal3f;
7228 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7229 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7230 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7233 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
7235 dp_model_t *model = ent->model;
7236 //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
7238 rsurface.entity = (entity_render_t *)ent;
7239 rsurface.skeleton = ent->skeleton;
7240 rsurface.ent_skinnum = ent->skinnum;
7241 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;
7242 rsurface.ent_shadertime = ent->shadertime;
7243 rsurface.ent_flags = ent->flags;
7244 if (rsurface.array_size < model->surfmesh.num_vertices)
7245 R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
7246 rsurface.matrix = ent->matrix;
7247 rsurface.inversematrix = ent->inversematrix;
7248 rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7249 rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7250 R_EntityMatrix(&rsurface.matrix);
7251 Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7252 Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7253 rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7254 rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7255 rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7256 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7257 VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
7258 VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
7259 VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
7260 VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
7261 VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
7262 VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
7263 rsurface.colormod[3] = ent->alpha;
7264 VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
7265 memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
7266 rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
7267 rsurface.basepolygonfactor = r_refdef.polygonfactor;
7268 rsurface.basepolygonoffset = r_refdef.polygonoffset;
7269 if (ent->model->brush.submodel && !prepass)
7271 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
7272 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
7274 if (model->surfmesh.isanimated && model->AnimateVertices && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].subframe != 0))
7276 if (ent->animcache_vertex3f && !r_framedata_failed)
7278 rsurface.modelvertex3f = ent->animcache_vertex3f;
7279 rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
7280 rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
7281 rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
7283 else if (wanttangents)
7285 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7286 rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7287 rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7288 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7289 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
7291 else if (wantnormals)
7293 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7294 rsurface.modelsvector3f = NULL;
7295 rsurface.modeltvector3f = NULL;
7296 rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7297 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
7301 rsurface.modelvertex3f = rsurface.array_modelvertex3f;
7302 rsurface.modelsvector3f = NULL;
7303 rsurface.modeltvector3f = NULL;
7304 rsurface.modelnormal3f = NULL;
7305 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.array_modelvertex3f, NULL, NULL, NULL);
7307 rsurface.modelvertex3f_bufferobject = 0;
7308 rsurface.modelvertex3f_bufferoffset = 0;
7309 rsurface.modelsvector3f_bufferobject = 0;
7310 rsurface.modelsvector3f_bufferoffset = 0;
7311 rsurface.modeltvector3f_bufferobject = 0;
7312 rsurface.modeltvector3f_bufferoffset = 0;
7313 rsurface.modelnormal3f_bufferobject = 0;
7314 rsurface.modelnormal3f_bufferoffset = 0;
7315 rsurface.generatedvertex = true;
7319 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
7320 rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
7321 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
7322 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
7323 rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
7324 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
7325 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
7326 rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
7327 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
7328 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
7329 rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
7330 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
7331 rsurface.generatedvertex = false;
7333 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
7334 rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
7335 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
7336 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
7337 rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
7338 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
7339 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
7340 rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
7341 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
7342 rsurface.modelelement3i = model->surfmesh.data_element3i;
7343 rsurface.modelelement3s = model->surfmesh.data_element3s;
7344 rsurface.modelelement3i_bufferobject = model->surfmesh.ebo3i;
7345 rsurface.modelelement3s_bufferobject = model->surfmesh.ebo3s;
7346 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
7347 rsurface.modelnum_vertices = model->surfmesh.num_vertices;
7348 rsurface.modelnum_triangles = model->surfmesh.num_triangles;
7349 rsurface.modelsurfaces = model->data_surfaces;
7350 rsurface.vertex3f = rsurface.modelvertex3f;
7351 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7352 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7353 rsurface.svector3f = rsurface.modelsvector3f;
7354 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7355 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7356 rsurface.tvector3f = rsurface.modeltvector3f;
7357 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7358 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7359 rsurface.normal3f = rsurface.modelnormal3f;
7360 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7361 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7362 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7365 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)
7367 rsurface.entity = r_refdef.scene.worldentity;
7368 rsurface.skeleton = NULL;
7369 rsurface.ent_skinnum = 0;
7370 rsurface.ent_qwskin = -1;
7371 rsurface.ent_shadertime = shadertime;
7372 rsurface.ent_flags = entflags;
7373 rsurface.modelnum_vertices = numvertices;
7374 rsurface.modelnum_triangles = numtriangles;
7375 if (rsurface.array_size < rsurface.modelnum_vertices)
7376 R_Mesh_ResizeArrays(rsurface.modelnum_vertices);
7377 rsurface.matrix = *matrix;
7378 rsurface.inversematrix = *inversematrix;
7379 rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
7380 rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
7381 R_EntityMatrix(&rsurface.matrix);
7382 Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
7383 Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
7384 rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
7385 rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
7386 rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
7387 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
7388 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
7389 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
7390 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
7391 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
7392 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
7393 Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
7394 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);
7395 memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
7396 rsurface.frameblend[0].lerp = 1;
7397 rsurface.ent_alttextures = false;
7398 rsurface.basepolygonfactor = r_refdef.polygonfactor;
7399 rsurface.basepolygonoffset = r_refdef.polygonoffset;
7402 rsurface.modelvertex3f = vertex3f;
7403 rsurface.modelsvector3f = svector3f ? svector3f : rsurface.array_modelsvector3f;
7404 rsurface.modeltvector3f = tvector3f ? tvector3f : rsurface.array_modeltvector3f;
7405 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7407 else if (wantnormals)
7409 rsurface.modelvertex3f = vertex3f;
7410 rsurface.modelsvector3f = NULL;
7411 rsurface.modeltvector3f = NULL;
7412 rsurface.modelnormal3f = normal3f ? normal3f : rsurface.array_modelnormal3f;
7416 rsurface.modelvertex3f = vertex3f;
7417 rsurface.modelsvector3f = NULL;
7418 rsurface.modeltvector3f = NULL;
7419 rsurface.modelnormal3f = NULL;
7421 rsurface.modelvertex3f_bufferobject = 0;
7422 rsurface.modelvertex3f_bufferoffset = 0;
7423 rsurface.modelsvector3f_bufferobject = 0;
7424 rsurface.modelsvector3f_bufferoffset = 0;
7425 rsurface.modeltvector3f_bufferobject = 0;
7426 rsurface.modeltvector3f_bufferoffset = 0;
7427 rsurface.modelnormal3f_bufferobject = 0;
7428 rsurface.modelnormal3f_bufferoffset = 0;
7429 rsurface.generatedvertex = true;
7430 rsurface.modellightmapcolor4f = color4f;
7431 rsurface.modellightmapcolor4f_bufferobject = 0;
7432 rsurface.modellightmapcolor4f_bufferoffset = 0;
7433 rsurface.modeltexcoordtexture2f = texcoord2f;
7434 rsurface.modeltexcoordtexture2f_bufferobject = 0;
7435 rsurface.modeltexcoordtexture2f_bufferoffset = 0;
7436 rsurface.modeltexcoordlightmap2f = NULL;
7437 rsurface.modeltexcoordlightmap2f_bufferobject = 0;
7438 rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
7439 rsurface.modelelement3i = element3i;
7440 rsurface.modelelement3s = element3s;
7441 rsurface.modelelement3i_bufferobject = 0;
7442 rsurface.modelelement3s_bufferobject = 0;
7443 rsurface.modellightmapoffsets = NULL;
7444 rsurface.modelsurfaces = NULL;
7445 rsurface.vertex3f = rsurface.modelvertex3f;
7446 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7447 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7448 rsurface.svector3f = rsurface.modelsvector3f;
7449 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7450 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7451 rsurface.tvector3f = rsurface.modeltvector3f;
7452 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7453 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7454 rsurface.normal3f = rsurface.modelnormal3f;
7455 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7456 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7457 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7459 if (rsurface.modelnum_vertices && rsurface.modelelement3i)
7461 if ((wantnormals || wanttangents) && !normal3f)
7462 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7463 if (wanttangents && !svector3f)
7464 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);
7468 float RSurf_FogPoint(const float *v)
7470 // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7471 float FogPlaneViewDist = r_refdef.fogplaneviewdist;
7472 float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
7473 float FogHeightFade = r_refdef.fogheightfade;
7475 unsigned int fogmasktableindex;
7476 if (r_refdef.fogplaneviewabove)
7477 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7479 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7480 fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
7481 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7484 float RSurf_FogVertex(const float *v)
7486 // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
7487 float FogPlaneViewDist = rsurface.fogplaneviewdist;
7488 float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
7489 float FogHeightFade = rsurface.fogheightfade;
7491 unsigned int fogmasktableindex;
7492 if (r_refdef.fogplaneviewabove)
7493 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
7495 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
7496 fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
7497 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
7500 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
7501 void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, const msurface_t **texturesurfacelist)
7504 int texturesurfaceindex;
7509 const float *v1, *in_tc;
7511 float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
7513 q3shaderinfo_deform_t *deform;
7514 // 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
7515 if (rsurface.generatedvertex)
7517 if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
7518 generatenormals = true;
7519 for (i = 0;i < Q3MAXDEFORMS;i++)
7521 if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
7523 generatetangents = true;
7524 generatenormals = true;
7526 if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
7527 generatenormals = true;
7529 if (generatenormals && !rsurface.modelnormal3f)
7531 rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
7532 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
7533 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
7534 Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
7536 if (generatetangents && !rsurface.modelsvector3f)
7538 rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
7539 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
7540 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
7541 rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
7542 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
7543 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
7544 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);
7547 rsurface.vertex3f = rsurface.modelvertex3f;
7548 rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
7549 rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
7550 rsurface.svector3f = rsurface.modelsvector3f;
7551 rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
7552 rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
7553 rsurface.tvector3f = rsurface.modeltvector3f;
7554 rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
7555 rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
7556 rsurface.normal3f = rsurface.modelnormal3f;
7557 rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
7558 rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
7559 // if vertices are deformed (sprite flares and things in maps, possibly
7560 // water waves, bulges and other deformations), generate them into
7561 // rsurface.deform* arrays from whatever the rsurface.* arrays point to
7562 // (may be static model data or generated data for an animated model, or
7563 // the previous deform pass)
7564 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
7566 switch (deform->deform)
7569 case Q3DEFORM_PROJECTIONSHADOW:
7570 case Q3DEFORM_TEXT0:
7571 case Q3DEFORM_TEXT1:
7572 case Q3DEFORM_TEXT2:
7573 case Q3DEFORM_TEXT3:
7574 case Q3DEFORM_TEXT4:
7575 case Q3DEFORM_TEXT5:
7576 case Q3DEFORM_TEXT6:
7577 case Q3DEFORM_TEXT7:
7580 case Q3DEFORM_AUTOSPRITE:
7581 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7582 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7583 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7584 VectorNormalize(newforward);
7585 VectorNormalize(newright);
7586 VectorNormalize(newup);
7587 // make deformed versions of only the model vertices used by the specified surfaces
7588 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7590 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7591 // a single autosprite surface can contain multiple sprites...
7592 for (j = 0;j < surface->num_vertices - 3;j += 4)
7594 VectorClear(center);
7595 for (i = 0;i < 4;i++)
7596 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7597 VectorScale(center, 0.25f, center);
7598 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, forward);
7599 VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
7600 VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
7601 for (i = 0;i < 4;i++)
7603 VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
7604 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7607 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);
7608 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);
7610 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7611 rsurface.vertex3f_bufferobject = 0;
7612 rsurface.vertex3f_bufferoffset = 0;
7613 rsurface.svector3f = rsurface.array_deformedsvector3f;
7614 rsurface.svector3f_bufferobject = 0;
7615 rsurface.svector3f_bufferoffset = 0;
7616 rsurface.tvector3f = rsurface.array_deformedtvector3f;
7617 rsurface.tvector3f_bufferobject = 0;
7618 rsurface.tvector3f_bufferoffset = 0;
7619 rsurface.normal3f = rsurface.array_deformednormal3f;
7620 rsurface.normal3f_bufferobject = 0;
7621 rsurface.normal3f_bufferoffset = 0;
7623 case Q3DEFORM_AUTOSPRITE2:
7624 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
7625 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
7626 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
7627 VectorNormalize(newforward);
7628 VectorNormalize(newright);
7629 VectorNormalize(newup);
7630 // make deformed versions of only the model vertices used by the specified surfaces
7631 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7633 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7634 const float *v1, *v2;
7644 memset(shortest, 0, sizeof(shortest));
7645 // a single autosprite surface can contain multiple sprites...
7646 for (j = 0;j < surface->num_vertices - 3;j += 4)
7648 VectorClear(center);
7649 for (i = 0;i < 4;i++)
7650 VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
7651 VectorScale(center, 0.25f, center);
7652 // find the two shortest edges, then use them to define the
7653 // axis vectors for rotating around the central axis
7654 for (i = 0;i < 6;i++)
7656 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
7657 v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
7659 Debug_PolygonBegin(NULL, 0);
7660 Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
7661 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);
7662 Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
7665 l = VectorDistance2(v1, v2);
7666 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
7668 l += (1.0f / 1024.0f);
7669 if (shortest[0].length2 > l || i == 0)
7671 shortest[1] = shortest[0];
7672 shortest[0].length2 = l;
7673 shortest[0].v1 = v1;
7674 shortest[0].v2 = v2;
7676 else if (shortest[1].length2 > l || i == 1)
7678 shortest[1].length2 = l;
7679 shortest[1].v1 = v1;
7680 shortest[1].v2 = v2;
7683 VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
7684 VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
7686 Debug_PolygonBegin(NULL, 0);
7687 Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
7688 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);
7689 Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
7692 // this calculates the right vector from the shortest edge
7693 // and the up vector from the edge midpoints
7694 VectorSubtract(shortest[0].v1, shortest[0].v2, right);
7695 VectorNormalize(right);
7696 VectorSubtract(end, start, up);
7697 VectorNormalize(up);
7698 // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
7699 VectorSubtract(rsurface.localvieworigin, center, forward);
7700 //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
7701 VectorNegate(forward, forward);
7702 VectorReflect(forward, 0, up, forward);
7703 VectorNormalize(forward);
7704 CrossProduct(up, forward, newright);
7705 VectorNormalize(newright);
7707 Debug_PolygonBegin(NULL, 0);
7708 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);
7709 Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
7710 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
7714 Debug_PolygonBegin(NULL, 0);
7715 Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
7716 Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
7717 Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
7720 // rotate the quad around the up axis vector, this is made
7721 // especially easy by the fact we know the quad is flat,
7722 // so we only have to subtract the center position and
7723 // measure distance along the right vector, and then
7724 // multiply that by the newright vector and add back the
7726 // we also need to subtract the old position to undo the
7727 // displacement from the center, which we do with a
7728 // DotProduct, the subtraction/addition of center is also
7729 // optimized into DotProducts here
7730 l = DotProduct(right, center);
7731 for (i = 0;i < 4;i++)
7733 v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
7734 f = DotProduct(right, v1) - l;
7735 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
7738 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);
7739 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);
7741 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7742 rsurface.vertex3f_bufferobject = 0;
7743 rsurface.vertex3f_bufferoffset = 0;
7744 rsurface.svector3f = rsurface.array_deformedsvector3f;
7745 rsurface.svector3f_bufferobject = 0;
7746 rsurface.svector3f_bufferoffset = 0;
7747 rsurface.tvector3f = rsurface.array_deformedtvector3f;
7748 rsurface.tvector3f_bufferobject = 0;
7749 rsurface.tvector3f_bufferoffset = 0;
7750 rsurface.normal3f = rsurface.array_deformednormal3f;
7751 rsurface.normal3f_bufferobject = 0;
7752 rsurface.normal3f_bufferoffset = 0;
7754 case Q3DEFORM_NORMAL:
7755 // deform the normals to make reflections wavey
7756 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7758 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7759 for (j = 0;j < surface->num_vertices;j++)
7762 float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3;
7763 VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
7764 VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal);
7765 normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7766 normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7767 normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.scene.time * deform->parms[1]);
7768 VectorNormalize(normal);
7770 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);
7772 rsurface.svector3f = rsurface.array_deformedsvector3f;
7773 rsurface.svector3f_bufferobject = 0;
7774 rsurface.svector3f_bufferoffset = 0;
7775 rsurface.tvector3f = rsurface.array_deformedtvector3f;
7776 rsurface.tvector3f_bufferobject = 0;
7777 rsurface.tvector3f_bufferoffset = 0;
7778 rsurface.normal3f = rsurface.array_deformednormal3f;
7779 rsurface.normal3f_bufferobject = 0;
7780 rsurface.normal3f_bufferoffset = 0;
7783 // deform vertex array to make wavey water and flags and such
7784 waveparms[0] = deform->waveparms[0];
7785 waveparms[1] = deform->waveparms[1];
7786 waveparms[2] = deform->waveparms[2];
7787 waveparms[3] = deform->waveparms[3];
7788 // this is how a divisor of vertex influence on deformation
7789 animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
7790 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7791 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7793 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7794 for (j = 0;j < surface->num_vertices;j++)
7796 float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3;
7797 VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex);
7798 // if the wavefunc depends on time, evaluate it per-vertex
7801 waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
7802 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
7804 VectorMA(vertex, scale, (rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, vertex);
7807 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7808 rsurface.vertex3f_bufferobject = 0;
7809 rsurface.vertex3f_bufferoffset = 0;
7811 case Q3DEFORM_BULGE:
7812 // deform vertex array to make the surface have moving bulges
7813 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7815 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7816 for (j = 0;j < surface->num_vertices;j++)
7818 scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.scene.time * deform->parms[2])) * deform->parms[1];
7819 VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7822 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7823 rsurface.vertex3f_bufferobject = 0;
7824 rsurface.vertex3f_bufferoffset = 0;
7827 // deform vertex array
7828 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
7829 VectorScale(deform->parms, scale, waveparms);
7830 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7832 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7833 for (j = 0;j < surface->num_vertices;j++)
7834 VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
7836 rsurface.vertex3f = rsurface.array_deformedvertex3f;
7837 rsurface.vertex3f_bufferobject = 0;
7838 rsurface.vertex3f_bufferoffset = 0;
7842 // generate texcoords based on the chosen texcoord source
7843 switch(rsurface.texture->tcgen.tcgen)
7846 case Q3TCGEN_TEXTURE:
7847 rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
7848 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordtexture2f_bufferobject;
7849 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
7851 case Q3TCGEN_LIGHTMAP:
7852 rsurface.texcoordtexture2f = rsurface.modeltexcoordlightmap2f;
7853 rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
7854 rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
7856 case Q3TCGEN_VECTOR:
7857 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7859 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7860 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)
7862 out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
7863 out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
7866 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
7867 rsurface.texcoordtexture2f_bufferobject = 0;
7868 rsurface.texcoordtexture2f_bufferoffset = 0;
7870 case Q3TCGEN_ENVIRONMENT:
7871 // make environment reflections using a spheremap
7872 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7874 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7875 const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
7876 const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
7877 float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
7878 for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
7880 // identical to Q3A's method, but executed in worldspace so
7881 // carried models can be shiny too
7883 float viewer[3], d, reflected[3], worldreflected[3];
7885 VectorSubtract(rsurface.localvieworigin, vertex, viewer);
7886 // VectorNormalize(viewer);
7888 d = DotProduct(normal, viewer);
7890 reflected[0] = normal[0]*2*d - viewer[0];
7891 reflected[1] = normal[1]*2*d - viewer[1];
7892 reflected[2] = normal[2]*2*d - viewer[2];
7893 // note: this is proportinal to viewer, so we can normalize later
7895 Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
7896 VectorNormalize(worldreflected);
7898 // note: this sphere map only uses world x and z!
7899 // so positive and negative y will LOOK THE SAME.
7900 out_tc[0] = 0.5 + 0.5 * worldreflected[1];
7901 out_tc[1] = 0.5 - 0.5 * worldreflected[2];
7904 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
7905 rsurface.texcoordtexture2f_bufferobject = 0;
7906 rsurface.texcoordtexture2f_bufferoffset = 0;
7909 // the only tcmod that needs software vertex processing is turbulent, so
7910 // check for it here and apply the changes if needed
7911 // and we only support that as the first one
7912 // (handling a mixture of turbulent and other tcmods would be problematic
7913 // without punting it entirely to a software path)
7914 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
7916 amplitude = rsurface.texture->tcmods[0].parms[1];
7917 animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.scene.time * rsurface.texture->tcmods[0].parms[3];
7918 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
7920 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
7921 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)
7923 out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7924 out_tc[1] = in_tc[1] + amplitude * sin(((v1[1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
7927 rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
7928 rsurface.texcoordtexture2f_bufferobject = 0;
7929 rsurface.texcoordtexture2f_bufferoffset = 0;
7931 rsurface.texcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
7932 rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
7933 rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
7934 R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
7937 void RSurf_DrawBatch_Simple(int texturenumsurfaces, const msurface_t **texturesurfacelist)
7940 const msurface_t *surface = texturesurfacelist[0];
7941 const msurface_t *surface2;
7946 // TODO: lock all array ranges before render, rather than on each surface
7947 if (texturenumsurfaces == 1)
7949 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
7950 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);
7952 else if (r_batchmode.integer == 2)
7954 #define MAXBATCHTRIANGLES 4096
7955 int batchtriangles = 0;
7956 static int batchelements[MAXBATCHTRIANGLES*3];
7957 for (i = 0;i < texturenumsurfaces;i = j)
7959 surface = texturesurfacelist[i];
7961 if (surface->num_triangles > MAXBATCHTRIANGLES)
7963 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);
7966 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
7967 batchtriangles = surface->num_triangles;
7968 firstvertex = surface->num_firstvertex;
7969 endvertex = surface->num_firstvertex + surface->num_vertices;
7970 for (;j < texturenumsurfaces;j++)
7972 surface2 = texturesurfacelist[j];
7973 if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
7975 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
7976 batchtriangles += surface2->num_triangles;
7977 firstvertex = min(firstvertex, surface2->num_firstvertex);
7978 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
7980 surface2 = texturesurfacelist[j-1];
7981 numvertices = endvertex - firstvertex;
7982 R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
7985 else if (r_batchmode.integer == 1)
7987 for (i = 0;i < texturenumsurfaces;i = j)
7989 surface = texturesurfacelist[i];
7990 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
7991 if (texturesurfacelist[j] != surface2)
7993 surface2 = texturesurfacelist[j-1];
7994 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
7995 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
7996 GL_LockArrays(surface->num_firstvertex, numvertices);
7997 R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8002 for (i = 0;i < texturenumsurfaces;i++)
8004 surface = texturesurfacelist[i];
8005 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8006 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);
8011 static void RSurf_BindLightmapForSurface(const msurface_t *surface)
8013 switch(vid.renderpath)
8015 case RENDERPATH_CGGL:
8017 if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , R_GetTexture(surface->lightmaptexture ));CHECKCGERROR
8018 if (r_cg_permutation->fp_Texture_Deluxemap) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap, R_GetTexture(surface->deluxemaptexture));CHECKCGERROR
8021 case RENDERPATH_GL20:
8022 if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , R_GetTexture(surface->lightmaptexture ));
8023 if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_DELUXEMAP, R_GetTexture(surface->deluxemaptexture));
8025 case RENDERPATH_GL13:
8026 case RENDERPATH_GL11:
8027 R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
8032 static void RSurf_BindReflectionForSurface(const msurface_t *surface)
8034 // pick the closest matching water plane and bind textures
8035 int planeindex, vertexindex;
8039 r_waterstate_waterplane_t *p, *bestp;
8042 for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
8045 for (vertexindex = 0, v = rsurface.modelvertex3f + surface->num_firstvertex * 3;vertexindex < surface->num_vertices;vertexindex++, v += 3)
8047 Matrix4x4_Transform(&rsurface.matrix, v, vert);
8048 d += fabs(PlaneDiff(vert, &p->plane));
8050 if (bestd > d || !bestp)
8056 switch(vid.renderpath)
8058 case RENDERPATH_CGGL:
8060 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
8061 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
8064 case RENDERPATH_GL20:
8065 if (r_glsl_permutation->loc_Texture_Refraction >= 0) R_Mesh_TexBind(GL20TU_REFRACTION, bestp ? R_GetTexture(bestp->texture_refraction) : R_GetTexture(r_texture_black));
8066 if (r_glsl_permutation->loc_Texture_Reflection >= 0) R_Mesh_TexBind(GL20TU_REFLECTION, bestp ? R_GetTexture(bestp->texture_reflection) : R_GetTexture(r_texture_black));
8068 case RENDERPATH_GL13:
8069 case RENDERPATH_GL11:
8074 static void RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8077 const msurface_t *surface;
8078 if (r_waterstate.renderingscene)
8080 for (i = 0;i < texturenumsurfaces;i++)
8082 surface = texturesurfacelist[i];
8083 RSurf_BindLightmapForSurface(surface);
8084 RSurf_BindReflectionForSurface(surface);
8085 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8086 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);
8090 static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8094 const msurface_t *surface = texturesurfacelist[0];
8095 const msurface_t *surface2;
8100 if (texturenumsurfaces == 1)
8102 RSurf_BindLightmapForSurface(surface);
8103 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8104 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);
8106 else if (r_batchmode.integer == 2)
8108 #define MAXBATCHTRIANGLES 4096
8109 int batchtriangles = 0;
8110 static int batchelements[MAXBATCHTRIANGLES*3];
8111 for (i = 0;i < texturenumsurfaces;i = j)
8113 surface = texturesurfacelist[i];
8114 RSurf_BindLightmapForSurface(surface);
8116 if (surface->num_triangles > MAXBATCHTRIANGLES)
8118 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);
8121 memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
8122 batchtriangles = surface->num_triangles;
8123 firstvertex = surface->num_firstvertex;
8124 endvertex = surface->num_firstvertex + surface->num_vertices;
8125 for (;j < texturenumsurfaces;j++)
8127 surface2 = texturesurfacelist[j];
8128 if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
8130 memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
8131 batchtriangles += surface2->num_triangles;
8132 firstvertex = min(firstvertex, surface2->num_firstvertex);
8133 endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
8135 surface2 = texturesurfacelist[j-1];
8136 numvertices = endvertex - firstvertex;
8137 R_Mesh_Draw(firstvertex, numvertices, 0, batchtriangles, batchelements, NULL, 0, 0);
8140 else if (r_batchmode.integer == 1)
8143 Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name);
8144 for (i = 0;i < texturenumsurfaces;i = j)
8146 surface = texturesurfacelist[i];
8147 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8148 if (texturesurfacelist[j] != surface2)
8150 Con_Printf(" %i", j - i);
8153 Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name);
8155 for (i = 0;i < texturenumsurfaces;i = j)
8157 surface = texturesurfacelist[i];
8158 RSurf_BindLightmapForSurface(surface);
8159 for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
8160 if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
8163 Con_Printf(" %i", j - i);
8165 surface2 = texturesurfacelist[j-1];
8166 numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
8167 numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
8168 GL_LockArrays(surface->num_firstvertex, numvertices);
8169 R_Mesh_Draw(surface->num_firstvertex, numvertices, surface->num_firsttriangle, numtriangles, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8177 for (i = 0;i < texturenumsurfaces;i++)
8179 surface = texturesurfacelist[i];
8180 RSurf_BindLightmapForSurface(surface);
8181 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8182 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);
8187 static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8190 int texturesurfaceindex;
8191 if (r_showsurfaces.integer == 2)
8193 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8195 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8196 for (j = 0;j < surface->num_triangles;j++)
8198 float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_refdef.view.colorscale;
8199 GL_Color(f, f, f, 1);
8200 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle + j, 1, rsurface.modelelement3i, rsurface.modelelement3s, rsurface.modelelement3i_bufferobject, rsurface.modelelement3s_bufferobject);
8206 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8208 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8209 int k = (int)(((size_t)surface) / sizeof(msurface_t));
8210 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);
8211 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
8212 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);
8217 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8219 int texturesurfaceindex;
8223 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8225 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8226 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)
8234 rsurface.lightmapcolor4f = rsurface.array_color4f;
8235 rsurface.lightmapcolor4f_bufferobject = 0;
8236 rsurface.lightmapcolor4f_bufferoffset = 0;
8239 static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8241 int texturesurfaceindex;
8247 if (rsurface.lightmapcolor4f)
8249 // generate color arrays for the surfaces in this list
8250 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8252 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8253 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)
8255 f = RSurf_FogVertex(v);
8265 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8267 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8268 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)
8270 f = RSurf_FogVertex(v);
8278 rsurface.lightmapcolor4f = rsurface.array_color4f;
8279 rsurface.lightmapcolor4f_bufferobject = 0;
8280 rsurface.lightmapcolor4f_bufferoffset = 0;
8283 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8285 int texturesurfaceindex;
8291 if (!rsurface.lightmapcolor4f)
8293 // generate color arrays for the surfaces in this list
8294 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8296 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8297 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)
8299 f = RSurf_FogVertex(v);
8300 c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
8301 c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
8302 c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
8306 rsurface.lightmapcolor4f = rsurface.array_color4f;
8307 rsurface.lightmapcolor4f_bufferobject = 0;
8308 rsurface.lightmapcolor4f_bufferoffset = 0;
8311 static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a)
8313 int texturesurfaceindex;
8317 if (!rsurface.lightmapcolor4f)
8319 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8321 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8322 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)
8330 rsurface.lightmapcolor4f = rsurface.array_color4f;
8331 rsurface.lightmapcolor4f_bufferobject = 0;
8332 rsurface.lightmapcolor4f_bufferoffset = 0;
8335 static void RSurf_DrawBatch_GL11_ApplyAmbient(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8337 int texturesurfaceindex;
8341 if (!rsurface.lightmapcolor4f)
8343 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8345 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8346 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)
8348 c2[0] = c[0] + r_refdef.scene.ambient;
8349 c2[1] = c[1] + r_refdef.scene.ambient;
8350 c2[2] = c[2] + r_refdef.scene.ambient;
8354 rsurface.lightmapcolor4f = rsurface.array_color4f;
8355 rsurface.lightmapcolor4f_bufferobject = 0;
8356 rsurface.lightmapcolor4f_bufferoffset = 0;
8359 static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8362 rsurface.lightmapcolor4f = NULL;
8363 rsurface.lightmapcolor4f_bufferobject = 0;
8364 rsurface.lightmapcolor4f_bufferoffset = 0;
8365 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8366 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8367 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8368 GL_Color(r, g, b, a);
8369 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8372 static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8374 // TODO: optimize applyfog && applycolor case
8375 // just apply fog if necessary, and tint the fog color array if necessary
8376 rsurface.lightmapcolor4f = NULL;
8377 rsurface.lightmapcolor4f_bufferobject = 0;
8378 rsurface.lightmapcolor4f_bufferoffset = 0;
8379 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8380 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8381 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8382 GL_Color(r, g, b, a);
8383 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8386 static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8388 int texturesurfaceindex;
8392 if (texturesurfacelist[0]->lightmapinfo)
8394 // generate color arrays for the surfaces in this list
8395 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8397 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8398 for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
8400 if (surface->lightmapinfo->samples)
8402 const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i];
8403 float scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
8404 VectorScale(lm, scale, c);
8405 if (surface->lightmapinfo->styles[1] != 255)
8407 int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
8409 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
8410 VectorMA(c, scale, lm, c);
8411 if (surface->lightmapinfo->styles[2] != 255)
8414 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
8415 VectorMA(c, scale, lm, c);
8416 if (surface->lightmapinfo->styles[3] != 255)
8419 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
8420 VectorMA(c, scale, lm, c);
8430 rsurface.lightmapcolor4f = rsurface.array_color4f;
8431 rsurface.lightmapcolor4f_bufferobject = 0;
8432 rsurface.lightmapcolor4f_bufferoffset = 0;
8436 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8437 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8438 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8440 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8441 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8442 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8443 GL_Color(r, g, b, a);
8444 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8447 static void RSurf_DrawBatch_GL11_ApplyVertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float *r, float *g, float *b, float *a, qboolean *applycolor)
8449 int texturesurfaceindex;
8456 vec3_t ambientcolor;
8457 vec3_t diffusecolor;
8461 VectorCopy(rsurface.modellight_lightdir, lightdir);
8462 f = 0.5f * r_refdef.lightmapintensity;
8463 ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
8464 ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
8465 ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
8466 diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
8467 diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
8468 diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
8470 if (VectorLength2(diffusecolor) > 0 && rsurface.normal3f)
8472 // generate color arrays for the surfaces in this list
8473 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8475 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8476 int numverts = surface->num_vertices;
8477 v = rsurface.vertex3f + 3 * surface->num_firstvertex;
8478 n = rsurface.normal3f + 3 * surface->num_firstvertex;
8479 c = rsurface.array_color4f + 4 * surface->num_firstvertex;
8480 // q3-style directional shading
8481 for (i = 0;i < numverts;i++, v += 3, n += 3, c += 4)
8483 if ((f = DotProduct(n, lightdir)) > 0)
8484 VectorMA(ambientcolor, f, diffusecolor, c);
8486 VectorCopy(ambientcolor, c);
8494 rsurface.lightmapcolor4f = rsurface.array_color4f;
8495 rsurface.lightmapcolor4f_bufferobject = 0;
8496 rsurface.lightmapcolor4f_bufferoffset = 0;
8497 *applycolor = false;
8501 *r = ambientcolor[0];
8502 *g = ambientcolor[1];
8503 *b = ambientcolor[2];
8504 rsurface.lightmapcolor4f = NULL;
8505 rsurface.lightmapcolor4f_bufferobject = 0;
8506 rsurface.lightmapcolor4f_bufferoffset = 0;
8510 static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, const msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
8512 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &r, &g, &b, &a, &applycolor);
8513 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
8514 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
8515 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
8516 GL_Color(r, g, b, a);
8517 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8520 void RSurf_SetupDepthAndCulling(void)
8522 // submodels are biased to avoid z-fighting with world surfaces that they
8523 // may be exactly overlapping (avoids z-fighting artifacts on certain
8524 // doors and things in Quake maps)
8525 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
8526 GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
8527 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
8528 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
8531 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
8533 // transparent sky would be ridiculous
8534 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
8536 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8537 skyrenderlater = true;
8538 RSurf_SetupDepthAndCulling();
8540 // LordHavoc: HalfLife maps have freaky skypolys so don't use
8541 // skymasking on them, and Quake3 never did sky masking (unlike
8542 // software Quake and software Quake2), so disable the sky masking
8543 // in Quake3 maps as it causes problems with q3map2 sky tricks,
8544 // and skymasking also looks very bad when noclipping outside the
8545 // level, so don't use it then either.
8546 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis)
8548 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
8549 R_Mesh_ColorPointer(NULL, 0, 0);
8550 R_Mesh_ResetTextureState();
8551 if (skyrendermasked)
8553 R_SetupShader_DepthOrShadow();
8554 // depth-only (masking)
8555 GL_ColorMask(0,0,0,0);
8556 // just to make sure that braindead drivers don't draw
8557 // anything despite that colormask...
8558 GL_BlendFunc(GL_ZERO, GL_ONE);
8562 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8564 GL_BlendFunc(GL_ONE, GL_ZERO);
8566 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8567 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8568 if (skyrendermasked)
8569 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
8571 R_Mesh_ResetTextureState();
8572 GL_Color(1, 1, 1, 1);
8575 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
8576 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
8577 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
8579 qboolean reflect = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)) && !prepass;
8580 qboolean refract = (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) && !prepass;
8582 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)))
8585 if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8586 R_Mesh_ColorPointer(NULL, 0, 0);
8588 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8592 // render background
8593 GL_BlendFunc(GL_ONE, GL_ZERO);
8595 GL_AlphaTest(false);
8597 GL_Color(1, 1, 1, 1);
8598 R_Mesh_ColorPointer(NULL, 0, 0);
8600 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND);
8601 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8602 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8603 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8604 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8605 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8606 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8607 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8608 GL_LockArrays(0, 0);
8610 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8611 GL_DepthMask(false);
8612 if ((rsurface.uselightmaptexture || (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
8613 R_Mesh_ColorPointer(NULL, 0, 0);
8615 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
8618 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, prepass ? RSURFPASS_DEFERREDGEOMETRY : RSURFPASS_BASE);
8620 RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist);
8621 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8622 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
8623 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
8624 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
8626 R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8630 GL_BlendFunc(GL_ONE, GL_ZERO);
8632 GL_AlphaTest(false);
8636 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
8637 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
8638 GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0 && !r_shadow_usingdeferredprepass);
8641 if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
8643 if (refract || reflect)
8644 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8646 RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist);
8650 if (refract || reflect)
8651 RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist);
8653 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8655 GL_LockArrays(0, 0);
8658 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8660 // OpenGL 1.3 path - anything not completely ancient
8661 int texturesurfaceindex;
8662 qboolean applycolor;
8665 const texturelayer_t *layer;
8666 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8668 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8671 int layertexrgbscale;
8672 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8674 if (layerindex == 0)
8678 GL_AlphaTest(false);
8679 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8682 GL_DepthMask(layer->depthmask && writedepth);
8683 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8684 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
8686 layertexrgbscale = 4;
8687 VectorScale(layer->color, 0.25f, layercolor);
8689 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
8691 layertexrgbscale = 2;
8692 VectorScale(layer->color, 0.5f, layercolor);
8696 layertexrgbscale = 1;
8697 VectorScale(layer->color, 1.0f, layercolor);
8699 layercolor[3] = layer->color[3];
8700 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
8701 R_Mesh_ColorPointer(NULL, 0, 0);
8702 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8703 switch (layer->type)
8705 case TEXTURELAYERTYPE_LITTEXTURE:
8706 // single-pass lightmapped texture with 2x rgbscale
8707 //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8708 R_Mesh_TexMatrix(0, NULL);
8709 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8710 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8711 R_Mesh_TexBind(1, R_GetTexture(layer->texture));
8712 R_Mesh_TexMatrix(1, &layer->texmatrix);
8713 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8714 R_Mesh_TexCoordPointer(1, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8715 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8716 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8717 else if (rsurface.uselightmaptexture)
8718 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8720 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8722 case TEXTURELAYERTYPE_TEXTURE:
8723 // singletexture unlit texture with transparency support
8724 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8725 R_Mesh_TexMatrix(0, &layer->texmatrix);
8726 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8727 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8728 R_Mesh_TexBind(1, 0);
8729 R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8730 RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
8732 case TEXTURELAYERTYPE_FOG:
8733 // singletexture fogging
8736 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8737 R_Mesh_TexMatrix(0, &layer->texmatrix);
8738 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
8739 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8743 R_Mesh_TexBind(0, 0);
8744 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8746 R_Mesh_TexBind(1, 0);
8747 R_Mesh_TexCoordPointer(1, 2, NULL, 0, 0);
8748 // generate a color array for the fog pass
8749 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8750 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8756 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8757 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)
8759 f = 1 - RSurf_FogVertex(v);
8760 c[0] = layercolor[0];
8761 c[1] = layercolor[1];
8762 c[2] = layercolor[2];
8763 c[3] = f * layercolor[3];
8766 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8769 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8771 GL_LockArrays(0, 0);
8774 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8776 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8777 GL_AlphaTest(false);
8781 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8783 // OpenGL 1.1 - crusty old voodoo path
8784 int texturesurfaceindex;
8787 const texturelayer_t *layer;
8788 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8790 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
8792 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8794 if (layerindex == 0)
8798 GL_AlphaTest(false);
8799 qglDepthFunc(GL_EQUAL);CHECKGLERROR
8802 GL_DepthMask(layer->depthmask && writedepth);
8803 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
8804 R_Mesh_ColorPointer(NULL, 0, 0);
8805 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
8806 switch (layer->type)
8808 case TEXTURELAYERTYPE_LITTEXTURE:
8809 if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
8811 // two-pass lit texture with 2x rgbscale
8812 // first the lightmap pass
8813 //R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
8814 R_Mesh_TexMatrix(0, NULL);
8815 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8816 R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset);
8817 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8818 RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8819 else if (rsurface.uselightmaptexture)
8820 RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8822 RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
8823 GL_LockArrays(0, 0);
8824 // then apply the texture to it
8825 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
8826 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8827 R_Mesh_TexMatrix(0, &layer->texmatrix);
8828 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8829 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8830 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);
8834 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
8835 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8836 R_Mesh_TexMatrix(0, &layer->texmatrix);
8837 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8838 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8839 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8840 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);
8842 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);
8845 case TEXTURELAYERTYPE_TEXTURE:
8846 // singletexture unlit texture with transparency support
8847 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8848 R_Mesh_TexMatrix(0, &layer->texmatrix);
8849 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8850 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8851 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);
8853 case TEXTURELAYERTYPE_FOG:
8854 // singletexture fogging
8857 R_Mesh_TexBind(0, R_GetTexture(layer->texture));
8858 R_Mesh_TexMatrix(0, &layer->texmatrix);
8859 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
8860 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
8864 R_Mesh_TexBind(0, 0);
8865 R_Mesh_TexCoordPointer(0, 2, NULL, 0, 0);
8867 // generate a color array for the fog pass
8868 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
8869 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
8875 const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
8876 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)
8878 f = 1 - RSurf_FogVertex(v);
8879 c[0] = layer->color[0];
8880 c[1] = layer->color[1];
8881 c[2] = layer->color[2];
8882 c[3] = f * layer->color[3];
8885 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
8888 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
8890 GL_LockArrays(0, 0);
8893 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8895 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
8896 GL_AlphaTest(false);
8900 static void R_DrawTextureSurfaceList_ShowSurfaces3(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
8904 GL_AlphaTest(false);
8905 R_Mesh_ColorPointer(NULL, 0, 0);
8906 R_Mesh_ResetTextureState();
8907 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
8909 if(rsurface.texture && rsurface.texture->currentskinframe)
8911 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
8912 c[3] *= rsurface.texture->currentalpha;
8922 if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
8924 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
8925 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
8926 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
8929 // brighten it up (as texture value 127 means "unlit")
8930 c[0] *= 2 * r_refdef.view.colorscale;
8931 c[1] *= 2 * r_refdef.view.colorscale;
8932 c[2] *= 2 * r_refdef.view.colorscale;
8934 if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
8935 c[3] *= r_wateralpha.value;
8937 if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
8939 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
8940 GL_DepthMask(false);
8942 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
8944 GL_BlendFunc(GL_ONE, GL_ONE);
8945 GL_DepthMask(false);
8947 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
8949 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
8950 GL_DepthMask(false);
8952 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
8954 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
8955 GL_DepthMask(false);
8959 GL_BlendFunc(GL_ONE, GL_ZERO);
8960 GL_DepthMask(writedepth);
8963 rsurface.lightmapcolor4f = NULL;
8965 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
8967 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8969 rsurface.lightmapcolor4f = NULL;
8970 rsurface.lightmapcolor4f_bufferobject = 0;
8971 rsurface.lightmapcolor4f_bufferoffset = 0;
8973 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
8975 qboolean applycolor = true;
8978 RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
8980 r_refdef.lightmapintensity = 1;
8981 RSurf_DrawBatch_GL11_ApplyVertexShade(texturenumsurfaces, texturesurfacelist, &one, &one, &one, &one, &applycolor);
8982 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
8986 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
8988 rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f;
8989 rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject;
8990 rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8993 if(!rsurface.lightmapcolor4f)
8994 RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(texturenumsurfaces, texturesurfacelist);
8996 RSurf_DrawBatch_GL11_ApplyAmbient(texturenumsurfaces, texturesurfacelist);
8997 RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, c[0], c[1], c[2], c[3]);
8998 if(r_refdef.fogenabled)
8999 RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(texturenumsurfaces, texturesurfacelist);
9001 R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset);
9002 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9005 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9008 RSurf_SetupDepthAndCulling();
9009 if (r_showsurfaces.integer == 3 && !prepass)
9011 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9014 switch (vid.renderpath)
9016 case RENDERPATH_GL20:
9017 case RENDERPATH_CGGL:
9018 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9020 case RENDERPATH_GL13:
9021 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9023 case RENDERPATH_GL11:
9024 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9030 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9033 RSurf_SetupDepthAndCulling();
9034 if (r_showsurfaces.integer == 3 && !prepass)
9036 R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth);
9039 switch (vid.renderpath)
9041 case RENDERPATH_GL20:
9042 case RENDERPATH_CGGL:
9043 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9045 case RENDERPATH_GL13:
9046 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
9048 case RENDERPATH_GL11:
9049 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
9055 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9058 int texturenumsurfaces, endsurface;
9060 const msurface_t *surface;
9061 const msurface_t *texturesurfacelist[256];
9063 // if the model is static it doesn't matter what value we give for
9064 // wantnormals and wanttangents, so this logic uses only rules applicable
9065 // to a model, knowing that they are meaningless otherwise
9066 if (ent == r_refdef.scene.worldentity)
9067 RSurf_ActiveWorldEntity();
9068 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9069 RSurf_ActiveModelEntity(ent, false, false, false);
9072 switch (vid.renderpath)
9074 case RENDERPATH_GL20:
9075 case RENDERPATH_CGGL:
9076 RSurf_ActiveModelEntity(ent, true, true, false);
9078 case RENDERPATH_GL13:
9079 case RENDERPATH_GL11:
9080 RSurf_ActiveModelEntity(ent, true, false, false);
9085 if (r_transparentdepthmasking.integer)
9087 qboolean setup = false;
9088 for (i = 0;i < numsurfaces;i = j)
9091 surface = rsurface.modelsurfaces + surfacelist[i];
9092 texture = surface->texture;
9093 rsurface.texture = R_GetCurrentTexture(texture);
9094 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9095 // scan ahead until we find a different texture
9096 endsurface = min(i + 1024, numsurfaces);
9097 texturenumsurfaces = 0;
9098 texturesurfacelist[texturenumsurfaces++] = surface;
9099 for (;j < endsurface;j++)
9101 surface = rsurface.modelsurfaces + surfacelist[j];
9102 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9104 texturesurfacelist[texturenumsurfaces++] = surface;
9106 if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
9108 // render the range of surfaces as depth
9112 GL_ColorMask(0,0,0,0);
9115 GL_BlendFunc(GL_ONE, GL_ZERO);
9117 GL_AlphaTest(false);
9118 R_Mesh_ColorPointer(NULL, 0, 0);
9119 R_Mesh_ResetTextureState();
9120 R_SetupShader_DepthOrShadow();
9122 RSurf_SetupDepthAndCulling();
9123 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9124 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9127 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
9130 for (i = 0;i < numsurfaces;i = j)
9133 surface = rsurface.modelsurfaces + surfacelist[i];
9134 texture = surface->texture;
9135 rsurface.texture = R_GetCurrentTexture(texture);
9136 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
9137 // scan ahead until we find a different texture
9138 endsurface = min(i + 1024, numsurfaces);
9139 texturenumsurfaces = 0;
9140 texturesurfacelist[texturenumsurfaces++] = surface;
9141 for (;j < endsurface;j++)
9143 surface = rsurface.modelsurfaces + surfacelist[j];
9144 if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL))
9146 texturesurfacelist[texturenumsurfaces++] = surface;
9148 // render the range of surfaces
9149 if (ent == r_refdef.scene.worldentity)
9150 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9152 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
9154 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
9155 GL_AlphaTest(false);
9158 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, const entity_render_t *queueentity)
9160 // transparent surfaces get pushed off into the transparent queue
9161 int surfacelistindex;
9162 const msurface_t *surface;
9163 vec3_t tempcenter, center;
9164 for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
9166 surface = texturesurfacelist[surfacelistindex];
9167 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
9168 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
9169 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
9170 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
9171 if (queueentity->transparent_offset) // transparent offset
9173 center[0] += r_refdef.view.forward[0]*queueentity->transparent_offset;
9174 center[1] += r_refdef.view.forward[1]*queueentity->transparent_offset;
9175 center[2] += r_refdef.view.forward[2]*queueentity->transparent_offset;
9177 R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_refdef.view.origin : center, R_DrawSurface_TransparentCallback, queueentity, surface - rsurface.modelsurfaces, rsurface.rtlight);
9181 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
9183 const entity_render_t *queueentity = r_refdef.scene.worldentity;
9187 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9189 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9191 RSurf_SetupDepthAndCulling();
9192 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9193 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9197 if (!rsurface.texture->currentnumlayers)
9199 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9200 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9202 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9204 else if (r_showsurfaces.integer && !r_refdef.view.showdebug && !prepass)
9206 RSurf_SetupDepthAndCulling();
9207 GL_AlphaTest(false);
9208 R_Mesh_ColorPointer(NULL, 0, 0);
9209 R_Mesh_ResetTextureState();
9210 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9211 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9213 GL_BlendFunc(GL_ONE, GL_ZERO);
9214 GL_Color(0, 0, 0, 1);
9215 GL_DepthTest(writedepth);
9216 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9218 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3 && !prepass)
9220 RSurf_SetupDepthAndCulling();
9221 GL_AlphaTest(false);
9222 R_Mesh_ColorPointer(NULL, 0, 0);
9223 R_Mesh_ResetTextureState();
9224 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9225 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9227 GL_BlendFunc(GL_ONE, GL_ZERO);
9229 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9231 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9232 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9233 else if (!rsurface.texture->currentnumlayers)
9235 else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9237 // in the deferred case, transparent surfaces were queued during prepass
9238 if (!r_shadow_usingdeferredprepass)
9239 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9243 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9244 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9249 void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9253 // break the surface list down into batches by texture and use of lightmapping
9254 for (i = 0;i < numsurfaces;i = j)
9257 // texture is the base texture pointer, rsurface.texture is the
9258 // current frame/skin the texture is directing us to use (for example
9259 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9260 // use skin 1 instead)
9261 texture = surfacelist[i]->texture;
9262 rsurface.texture = R_GetCurrentTexture(texture);
9263 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9264 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9266 // if this texture is not the kind we want, skip ahead to the next one
9267 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9271 // simply scan ahead until we find a different texture or lightmap state
9272 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9274 // render the range of surfaces
9275 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
9279 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, const entity_render_t *queueentity, qboolean prepass)
9284 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
9286 if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
9288 RSurf_SetupDepthAndCulling();
9289 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9290 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9294 if (!rsurface.texture->currentnumlayers)
9296 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9297 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9299 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
9301 else if (r_showsurfaces.integer && !r_refdef.view.showdebug)
9303 RSurf_SetupDepthAndCulling();
9304 GL_AlphaTest(false);
9305 R_Mesh_ColorPointer(NULL, 0, 0);
9306 R_Mesh_ResetTextureState();
9307 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9308 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9310 GL_BlendFunc(GL_ONE, GL_ZERO);
9311 GL_Color(0, 0, 0, 1);
9312 GL_DepthTest(writedepth);
9313 RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
9315 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
9317 RSurf_SetupDepthAndCulling();
9318 GL_AlphaTest(false);
9319 R_Mesh_ColorPointer(NULL, 0, 0);
9320 R_Mesh_ResetTextureState();
9321 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9322 RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
9324 GL_BlendFunc(GL_ONE, GL_ZERO);
9326 RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
9328 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)
9329 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
9330 else if (!rsurface.texture->currentnumlayers)
9332 else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))) && queueentity)
9334 // in the deferred case, transparent surfaces were queued during prepass
9335 if (!r_shadow_usingdeferredprepass)
9336 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist, queueentity);
9340 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
9341 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
9346 void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
9350 // break the surface list down into batches by texture and use of lightmapping
9351 for (i = 0;i < numsurfaces;i = j)
9354 // texture is the base texture pointer, rsurface.texture is the
9355 // current frame/skin the texture is directing us to use (for example
9356 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
9357 // use skin 1 instead)
9358 texture = surfacelist[i]->texture;
9359 rsurface.texture = R_GetCurrentTexture(texture);
9360 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL && !depthonly && !prepass;
9361 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
9363 // if this texture is not the kind we want, skip ahead to the next one
9364 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
9368 // simply scan ahead until we find a different texture or lightmap state
9369 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++)
9371 // render the range of surfaces
9372 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, ent, prepass);
9376 float locboxvertex3f[6*4*3] =
9378 1,0,1, 1,0,0, 1,1,0, 1,1,1,
9379 0,1,1, 0,1,0, 0,0,0, 0,0,1,
9380 1,1,1, 1,1,0, 0,1,0, 0,1,1,
9381 0,0,1, 0,0,0, 1,0,0, 1,0,1,
9382 0,0,1, 1,0,1, 1,1,1, 0,1,1,
9383 1,0,0, 0,0,0, 0,1,0, 1,1,0
9386 unsigned short locboxelements[6*2*3] =
9396 void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
9399 cl_locnode_t *loc = (cl_locnode_t *)ent;
9401 float vertex3f[6*4*3];
9403 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
9404 GL_DepthMask(false);
9405 GL_DepthRange(0, 1);
9406 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
9408 GL_CullFace(GL_NONE);
9409 R_EntityMatrix(&identitymatrix);
9411 R_Mesh_VertexPointer(vertex3f, 0, 0);
9412 R_Mesh_ColorPointer(NULL, 0, 0);
9413 R_Mesh_ResetTextureState();
9414 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
9417 GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9418 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9419 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
9420 surfacelist[0] < 0 ? 0.5f : 0.125f);
9422 if (VectorCompare(loc->mins, loc->maxs))
9424 VectorSet(size, 2, 2, 2);
9425 VectorMA(loc->mins, -0.5f, size, mins);
9429 VectorCopy(loc->mins, mins);
9430 VectorSubtract(loc->maxs, loc->mins, size);
9433 for (i = 0;i < 6*4*3;)
9434 for (j = 0;j < 3;j++, i++)
9435 vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
9437 R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, locboxelements, 0, 0);
9440 void R_DrawLocs(void)
9443 cl_locnode_t *loc, *nearestloc;
9445 nearestloc = CL_Locs_FindNearest(cl.movement_origin);
9446 for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
9448 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
9449 R_MeshQueue_AddTransparent(center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
9453 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
9455 if (decalsystem->decals)
9456 Mem_Free(decalsystem->decals);
9457 memset(decalsystem, 0, sizeof(*decalsystem));
9460 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)
9467 // expand or initialize the system
9468 if (decalsystem->maxdecals <= decalsystem->numdecals)
9470 decalsystem_t old = *decalsystem;
9471 qboolean useshortelements;
9472 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
9473 useshortelements = decalsystem->maxdecals * 3 <= 65536;
9474 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)));
9475 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
9476 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
9477 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
9478 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
9479 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
9480 if (decalsystem->numdecals)
9481 memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
9483 Mem_Free(old.decals);
9484 for (i = 0;i < decalsystem->maxdecals*3;i++)
9485 decalsystem->element3i[i] = i;
9486 if (useshortelements)
9487 for (i = 0;i < decalsystem->maxdecals*3;i++)
9488 decalsystem->element3s[i] = i;
9491 // grab a decal and search for another free slot for the next one
9492 maxdecals = decalsystem->maxdecals;
9493 decals = decalsystem->decals;
9494 decal = decalsystem->decals + (i = decalsystem->freedecal++);
9495 for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++)
9497 decalsystem->freedecal = i;
9498 if (decalsystem->numdecals <= i)
9499 decalsystem->numdecals = i + 1;
9501 // initialize the decal
9503 decal->triangleindex = triangleindex;
9504 decal->surfaceindex = surfaceindex;
9505 decal->decalsequence = decalsequence;
9506 decal->color4ub[0][0] = (unsigned char)(c0[0]*255.0f);
9507 decal->color4ub[0][1] = (unsigned char)(c0[1]*255.0f);
9508 decal->color4ub[0][2] = (unsigned char)(c0[2]*255.0f);
9509 decal->color4ub[0][3] = 255;
9510 decal->color4ub[1][0] = (unsigned char)(c1[0]*255.0f);
9511 decal->color4ub[1][1] = (unsigned char)(c1[1]*255.0f);
9512 decal->color4ub[1][2] = (unsigned char)(c1[2]*255.0f);
9513 decal->color4ub[1][3] = 255;
9514 decal->color4ub[2][0] = (unsigned char)(c2[0]*255.0f);
9515 decal->color4ub[2][1] = (unsigned char)(c2[1]*255.0f);
9516 decal->color4ub[2][2] = (unsigned char)(c2[2]*255.0f);
9517 decal->color4ub[2][3] = 255;
9518 decal->vertex3f[0][0] = v0[0];
9519 decal->vertex3f[0][1] = v0[1];
9520 decal->vertex3f[0][2] = v0[2];
9521 decal->vertex3f[1][0] = v1[0];
9522 decal->vertex3f[1][1] = v1[1];
9523 decal->vertex3f[1][2] = v1[2];
9524 decal->vertex3f[2][0] = v2[0];
9525 decal->vertex3f[2][1] = v2[1];
9526 decal->vertex3f[2][2] = v2[2];
9527 decal->texcoord2f[0][0] = t0[0];
9528 decal->texcoord2f[0][1] = t0[1];
9529 decal->texcoord2f[1][0] = t1[0];
9530 decal->texcoord2f[1][1] = t1[1];
9531 decal->texcoord2f[2][0] = t2[0];
9532 decal->texcoord2f[2][1] = t2[1];
9535 extern cvar_t cl_decals_bias;
9536 extern cvar_t cl_decals_models;
9537 extern cvar_t cl_decals_newsystem_intensitymultiplier;
9538 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)
9540 matrix4x4_t projection;
9541 decalsystem_t *decalsystem;
9544 const float *vertex3f;
9545 const msurface_t *surface;
9546 const msurface_t *surfaces;
9547 const int *surfacelist;
9548 const texture_t *texture;
9552 int surfacelistindex;
9555 int decalsurfaceindex;
9560 float localorigin[3];
9561 float localnormal[3];
9572 float points[2][9][3];
9576 decalsystem = &ent->decalsystem;
9578 if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
9580 R_DecalSystem_Reset(&ent->decalsystem);
9584 if (!model->brush.data_nodes && !cl_decals_models.integer)
9586 if (decalsystem->model)
9587 R_DecalSystem_Reset(decalsystem);
9591 if (decalsystem->model != model)
9592 R_DecalSystem_Reset(decalsystem);
9593 decalsystem->model = model;
9595 RSurf_ActiveModelEntity(ent, false, false, false);
9597 Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
9598 Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
9599 VectorNormalize(localnormal);
9600 localsize = worldsize*rsurface.inversematrixscale;
9601 ilocalsize = 1.0f / localsize;
9602 localmins[0] = localorigin[0] - localsize;
9603 localmins[1] = localorigin[1] - localsize;
9604 localmins[2] = localorigin[2] - localsize;
9605 localmaxs[0] = localorigin[0] + localsize;
9606 localmaxs[1] = localorigin[1] + localsize;
9607 localmaxs[2] = localorigin[2] + localsize;
9609 //VectorCopy(localnormal, planes[4]);
9610 //VectorVectors(planes[4], planes[2], planes[0]);
9611 AnglesFromVectors(angles, localnormal, NULL, false);
9612 AngleVectors(angles, planes[0], planes[2], planes[4]);
9613 VectorNegate(planes[0], planes[1]);
9614 VectorNegate(planes[2], planes[3]);
9615 VectorNegate(planes[4], planes[5]);
9616 planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
9617 planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
9618 planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
9619 planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
9620 planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
9621 planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
9626 matrix4x4_t forwardprojection;
9627 Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
9628 Matrix4x4_Invert_Simple(&projection, &forwardprojection);
9633 float projectionvector[4][3];
9634 VectorScale(planes[0], ilocalsize, projectionvector[0]);
9635 VectorScale(planes[2], ilocalsize, projectionvector[1]);
9636 VectorScale(planes[4], ilocalsize, projectionvector[2]);
9637 projectionvector[0][0] = planes[0][0] * ilocalsize;
9638 projectionvector[0][1] = planes[1][0] * ilocalsize;
9639 projectionvector[0][2] = planes[2][0] * ilocalsize;
9640 projectionvector[1][0] = planes[0][1] * ilocalsize;
9641 projectionvector[1][1] = planes[1][1] * ilocalsize;
9642 projectionvector[1][2] = planes[2][1] * ilocalsize;
9643 projectionvector[2][0] = planes[0][2] * ilocalsize;
9644 projectionvector[2][1] = planes[1][2] * ilocalsize;
9645 projectionvector[2][2] = planes[2][2] * ilocalsize;
9646 projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
9647 projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
9648 projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
9649 Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
9653 dynamic = model->surfmesh.isanimated;
9654 vertex3f = rsurface.modelvertex3f;
9655 numsurfacelist = model->nummodelsurfaces;
9656 surfacelist = model->sortedmodelsurfaces;
9657 surfaces = model->data_surfaces;
9658 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
9660 surfaceindex = surfacelist[surfacelistindex];
9661 surface = surfaces + surfaceindex;
9662 // skip transparent surfaces
9663 texture = surface->texture;
9664 if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
9666 if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
9668 if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
9670 decalsurfaceindex = ent == r_refdef.scene.worldentity ? surfaceindex : -1;
9671 numvertices = surface->num_vertices;
9672 numtriangles = surface->num_triangles;
9673 for (triangleindex = 0, e = model->surfmesh.data_element3i + 3*surface->num_firsttriangle;triangleindex < numtriangles;triangleindex++, e += 3)
9675 for (cornerindex = 0;cornerindex < 3;cornerindex++)
9677 index = 3*e[cornerindex];
9678 VectorCopy(vertex3f + index, v[cornerindex]);
9681 //TriangleNormal(v[0], v[1], v[2], normal);
9682 //if (DotProduct(normal, localnormal) < 0.0f)
9684 // clip by each of the box planes formed from the projection matrix
9685 // if anything survives, we emit the decal
9686 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]);
9689 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]);
9692 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]);
9695 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]);
9698 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]);
9701 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]);
9704 // some part of the triangle survived, so we have to accept it...
9707 // dynamic always uses the original triangle
9709 for (cornerindex = 0;cornerindex < 3;cornerindex++)
9711 index = 3*e[cornerindex];
9712 VectorCopy(vertex3f + index, v[cornerindex]);
9715 for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
9717 // convert vertex positions to texcoords
9718 Matrix4x4_Transform(&projection, v[cornerindex], temp);
9719 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
9720 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
9721 // calculate distance fade from the projection origin
9722 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
9723 f = bound(0.0f, f, 1.0f);
9724 c[cornerindex][0] = r * f;
9725 c[cornerindex][1] = g * f;
9726 c[cornerindex][2] = b * f;
9727 c[cornerindex][3] = 1.0f;
9728 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
9731 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);
9733 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
9734 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);
9739 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
9740 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)
9742 int renderentityindex;
9745 entity_render_t *ent;
9747 if (!cl_decals_newsystem.integer)
9750 worldmins[0] = worldorigin[0] - worldsize;
9751 worldmins[1] = worldorigin[1] - worldsize;
9752 worldmins[2] = worldorigin[2] - worldsize;
9753 worldmaxs[0] = worldorigin[0] + worldsize;
9754 worldmaxs[1] = worldorigin[1] + worldsize;
9755 worldmaxs[2] = worldorigin[2] + worldsize;
9757 R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9759 for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
9761 ent = r_refdef.scene.entities[renderentityindex];
9762 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
9765 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
9769 typedef struct r_decalsystem_splatqueue_s
9778 r_decalsystem_splatqueue_t;
9780 int r_decalsystem_numqueued = 0;
9781 #define MAX_DECALSYSTEM_QUEUE 1024
9782 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
9784 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)
9786 r_decalsystem_splatqueue_t *queue;
9788 if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
9791 queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
9792 VectorCopy(worldorigin, queue->worldorigin);
9793 VectorCopy(worldnormal, queue->worldnormal);
9794 Vector4Set(queue->color, r, g, b, a);
9795 Vector4Set(queue->tcrange, s1, t1, s2, t2);
9796 queue->worldsize = worldsize;
9797 queue->decalsequence = cl.decalsequence++;
9800 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
9803 r_decalsystem_splatqueue_t *queue;
9805 for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
9806 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);
9807 r_decalsystem_numqueued = 0;
9810 extern cvar_t cl_decals_max;
9811 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
9814 decalsystem_t *decalsystem = &ent->decalsystem;
9821 if (!decalsystem->numdecals)
9824 if (r_showsurfaces.integer)
9827 if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9829 R_DecalSystem_Reset(decalsystem);
9833 killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
9834 lifetime = cl_decals_time.value + cl_decals_fadetime.value;
9836 if (decalsystem->lastupdatetime)
9837 frametime = (cl.time - decalsystem->lastupdatetime);
9840 decalsystem->lastupdatetime = cl.time;
9841 decal = decalsystem->decals;
9842 numdecals = decalsystem->numdecals;
9844 for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9846 if (decal->color4ub[0][3])
9848 decal->lived += frametime;
9849 if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
9851 memset(decal, 0, sizeof(*decal));
9852 if (decalsystem->freedecal > i)
9853 decalsystem->freedecal = i;
9857 decal = decalsystem->decals;
9858 while (numdecals > 0 && !decal[numdecals-1].color4ub[0][3])
9861 // collapse the array by shuffling the tail decals into the gaps
9864 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4ub[0][3])
9865 decalsystem->freedecal++;
9866 if (decalsystem->freedecal == numdecals)
9868 decal[decalsystem->freedecal] = decal[--numdecals];
9871 decalsystem->numdecals = numdecals;
9875 // if there are no decals left, reset decalsystem
9876 R_DecalSystem_Reset(decalsystem);
9880 extern skinframe_t *decalskinframe;
9881 static void R_DrawModelDecals_Entity(entity_render_t *ent)
9884 decalsystem_t *decalsystem = &ent->decalsystem;
9894 const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
9897 numdecals = decalsystem->numdecals;
9901 if (r_showsurfaces.integer)
9904 if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
9906 R_DecalSystem_Reset(decalsystem);
9910 // if the model is static it doesn't matter what value we give for
9911 // wantnormals and wanttangents, so this logic uses only rules applicable
9912 // to a model, knowing that they are meaningless otherwise
9913 if (ent == r_refdef.scene.worldentity)
9914 RSurf_ActiveWorldEntity();
9916 RSurf_ActiveModelEntity(ent, false, false, false);
9918 decalsystem->lastupdatetime = cl.time;
9919 decal = decalsystem->decals;
9921 fadedelay = cl_decals_time.value;
9922 faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
9924 // update vertex positions for animated models
9925 v3f = decalsystem->vertex3f;
9926 c4f = decalsystem->color4f;
9927 t2f = decalsystem->texcoord2f;
9928 for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
9930 if (!decal->color4ub[0][3])
9933 if (surfacevisible && !surfacevisible[decal->surfaceindex])
9936 // update color values for fading decals
9937 if (decal->lived >= cl_decals_time.value)
9939 alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
9940 alpha *= (1.0f/255.0f);
9943 alpha = 1.0f/255.0f;
9945 c4f[ 0] = decal->color4ub[0][0] * alpha;
9946 c4f[ 1] = decal->color4ub[0][1] * alpha;
9947 c4f[ 2] = decal->color4ub[0][2] * alpha;
9949 c4f[ 4] = decal->color4ub[1][0] * alpha;
9950 c4f[ 5] = decal->color4ub[1][1] * alpha;
9951 c4f[ 6] = decal->color4ub[1][2] * alpha;
9953 c4f[ 8] = decal->color4ub[2][0] * alpha;
9954 c4f[ 9] = decal->color4ub[2][1] * alpha;
9955 c4f[10] = decal->color4ub[2][2] * alpha;
9958 t2f[0] = decal->texcoord2f[0][0];
9959 t2f[1] = decal->texcoord2f[0][1];
9960 t2f[2] = decal->texcoord2f[1][0];
9961 t2f[3] = decal->texcoord2f[1][1];
9962 t2f[4] = decal->texcoord2f[2][0];
9963 t2f[5] = decal->texcoord2f[2][1];
9965 // update vertex positions for animated models
9966 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnum_triangles)
9968 e = rsurface.modelelement3i + 3*decal->triangleindex;
9969 VectorCopy(rsurface.vertex3f + 3*e[0], v3f);
9970 VectorCopy(rsurface.vertex3f + 3*e[1], v3f + 3);
9971 VectorCopy(rsurface.vertex3f + 3*e[2], v3f + 6);
9975 VectorCopy(decal->vertex3f[0], v3f);
9976 VectorCopy(decal->vertex3f[1], v3f + 3);
9977 VectorCopy(decal->vertex3f[2], v3f + 6);
9988 r_refdef.stats.drawndecals += numtris;
9990 if (r_refdef.fogenabled)
9992 switch(vid.renderpath)
9994 case RENDERPATH_GL20:
9995 case RENDERPATH_CGGL:
9996 case RENDERPATH_GL13:
9997 case RENDERPATH_GL11:
9998 for (i = 0, v3f = decalsystem->vertex3f, c4f = decalsystem->color4f;i < numtris*3;i++, v3f += 3, c4f += 4)
10000 alpha = RSurf_FogVertex(v3f);
10009 // now render the decals all at once
10010 // (this assumes they all use one particle font texture!)
10011 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);
10012 R_Mesh_ResetTextureState();
10013 R_Mesh_VertexPointer(decalsystem->vertex3f, 0, 0);
10014 R_Mesh_TexCoordPointer(0, 2, decalsystem->texcoord2f, 0, 0);
10015 R_Mesh_ColorPointer(decalsystem->color4f, 0, 0);
10016 GL_DepthMask(false);
10017 GL_DepthRange(0, 1);
10018 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
10019 GL_DepthTest(true);
10020 GL_CullFace(GL_NONE);
10021 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
10022 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1);
10023 GL_LockArrays(0, numtris * 3);
10024 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, decalsystem->element3s, 0, 0);
10025 GL_LockArrays(0, 0);
10029 static void R_DrawModelDecals(void)
10033 // fade faster when there are too many decals
10034 numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10035 for (i = 0;i < r_refdef.scene.numentities;i++)
10036 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10038 R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
10039 for (i = 0;i < r_refdef.scene.numentities;i++)
10040 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10041 R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
10043 R_DecalSystem_ApplySplatEntitiesQueue();
10045 numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
10046 for (i = 0;i < r_refdef.scene.numentities;i++)
10047 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
10049 r_refdef.stats.totaldecals += numdecals;
10051 if (r_showsurfaces.integer)
10054 R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
10056 for (i = 0;i < r_refdef.scene.numentities;i++)
10058 if (!r_refdef.viewcache.entityvisible[i])
10060 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
10061 R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
10065 void R_DrawDebugModel(void)
10067 entity_render_t *ent = rsurface.entity;
10068 int i, j, k, l, flagsmask;
10069 const int *elements;
10071 const msurface_t *surface;
10072 dp_model_t *model = ent->model;
10075 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
10077 R_Mesh_ColorPointer(NULL, 0, 0);
10078 R_Mesh_ResetTextureState();
10079 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
10080 GL_DepthRange(0, 1);
10081 GL_DepthTest(!r_showdisabledepthtest.integer);
10082 GL_DepthMask(false);
10083 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10085 if (r_showcollisionbrushes.value > 0 && model->brush.num_brushes)
10087 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
10088 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
10090 if (brush->colbrushf && brush->colbrushf->numtriangles)
10092 R_Mesh_VertexPointer(brush->colbrushf->points->v, 0, 0);
10093 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);
10094 R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, 0);
10097 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
10099 if (surface->num_collisiontriangles)
10101 R_Mesh_VertexPointer(surface->data_collisionvertex3f, 0, 0);
10102 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);
10103 R_Mesh_Draw(0, surface->num_collisionvertices, 0, surface->num_collisiontriangles, surface->data_collisionelement3i, NULL, 0, 0);
10108 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
10110 if (r_showtris.integer || r_shownormals.integer)
10112 if (r_showdisabledepthtest.integer)
10114 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10115 GL_DepthMask(false);
10119 GL_BlendFunc(GL_ONE, GL_ZERO);
10120 GL_DepthMask(true);
10122 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
10124 if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
10126 rsurface.texture = R_GetCurrentTexture(surface->texture);
10127 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
10129 RSurf_PrepareVerticesForBatch(true, true, 1, &surface);
10130 if (r_showtris.value > 0)
10132 if (!rsurface.texture->currentlayers->depthmask)
10133 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
10134 else if (ent == r_refdef.scene.worldentity)
10135 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
10137 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
10138 elements = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);
10139 R_Mesh_VertexPointer(rsurface.vertex3f, 0, 0);
10140 R_Mesh_ColorPointer(NULL, 0, 0);
10141 R_Mesh_TexCoordPointer(0, 0, NULL, 0, 0);
10142 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
10143 //R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_firsttriangle, surface->num_triangles, model->surfmesh.data_element3i, NULL, 0, 0);
10144 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);
10145 qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
10148 if (r_shownormals.value < 0)
10150 qglBegin(GL_LINES);
10151 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10153 VectorCopy(rsurface.vertex3f + l * 3, v);
10154 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10155 qglVertex3f(v[0], v[1], v[2]);
10156 VectorMA(v, -r_shownormals.value, rsurface.svector3f + l * 3, v);
10157 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10158 qglVertex3f(v[0], v[1], v[2]);
10163 if (r_shownormals.value > 0)
10165 qglBegin(GL_LINES);
10166 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10168 VectorCopy(rsurface.vertex3f + l * 3, v);
10169 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
10170 qglVertex3f(v[0], v[1], v[2]);
10171 VectorMA(v, r_shownormals.value, rsurface.svector3f + l * 3, v);
10172 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10173 qglVertex3f(v[0], v[1], v[2]);
10177 qglBegin(GL_LINES);
10178 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10180 VectorCopy(rsurface.vertex3f + l * 3, v);
10181 GL_Color(0, r_refdef.view.colorscale, 0, 1);
10182 qglVertex3f(v[0], v[1], v[2]);
10183 VectorMA(v, r_shownormals.value, rsurface.tvector3f + l * 3, v);
10184 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10185 qglVertex3f(v[0], v[1], v[2]);
10189 qglBegin(GL_LINES);
10190 for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++)
10192 VectorCopy(rsurface.vertex3f + l * 3, v);
10193 GL_Color(0, 0, r_refdef.view.colorscale, 1);
10194 qglVertex3f(v[0], v[1], v[2]);
10195 VectorMA(v, r_shownormals.value, rsurface.normal3f + l * 3, v);
10196 GL_Color(r_refdef.view.colorscale, 1, 1, 1);
10197 qglVertex3f(v[0], v[1], v[2]);
10204 rsurface.texture = NULL;
10208 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
10209 int r_maxsurfacelist = 0;
10210 const msurface_t **r_surfacelist = NULL;
10211 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10213 int i, j, endj, f, flagsmask;
10215 dp_model_t *model = r_refdef.scene.worldmodel;
10216 msurface_t *surfaces;
10217 unsigned char *update;
10218 int numsurfacelist = 0;
10222 if (r_maxsurfacelist < model->num_surfaces)
10224 r_maxsurfacelist = model->num_surfaces;
10226 Mem_Free((msurface_t**)r_surfacelist);
10227 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10230 RSurf_ActiveWorldEntity();
10232 surfaces = model->data_surfaces;
10233 update = model->brushq1.lightmapupdateflags;
10235 // update light styles on this submodel
10236 if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10238 model_brush_lightstyleinfo_t *style;
10239 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10241 if (style->value != r_refdef.scene.lightstylevalue[style->style])
10243 int *list = style->surfacelist;
10244 style->value = r_refdef.scene.lightstylevalue[style->style];
10245 for (j = 0;j < style->numsurfaces;j++)
10246 update[list[j]] = true;
10251 flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10255 R_DrawDebugModel();
10256 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10262 rsurface.uselightmaptexture = false;
10263 rsurface.texture = NULL;
10264 rsurface.rtlight = NULL;
10265 numsurfacelist = 0;
10266 // add visible surfaces to draw list
10267 for (i = 0;i < model->nummodelsurfaces;i++)
10269 j = model->sortedmodelsurfaces[i];
10270 if (r_refdef.viewcache.world_surfacevisible[j])
10271 r_surfacelist[numsurfacelist++] = surfaces + j;
10273 // update lightmaps if needed
10277 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10279 if (r_refdef.viewcache.world_surfacevisible[j])
10284 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
10290 int count = model->brushq3.num_mergedlightmaps;
10291 for (i = 0;i < count;i++)
10293 if (model->brushq3.data_deluxemaps[i])
10294 R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10295 if (model->brushq3.data_lightmaps[i])
10296 R_FlushTexture(model->brushq3.data_lightmaps[i]);
10300 // don't do anything if there were no surfaces
10301 if (!numsurfacelist)
10303 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10306 R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10307 GL_AlphaTest(false);
10309 // add to stats if desired
10310 if (r_speeds.integer && !skysurfaces && !depthonly)
10312 r_refdef.stats.world_surfaces += numsurfacelist;
10313 for (j = 0;j < numsurfacelist;j++)
10314 r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
10317 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10320 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
10322 int i, j, endj, f, flagsmask;
10324 dp_model_t *model = ent->model;
10325 msurface_t *surfaces;
10326 unsigned char *update;
10327 int numsurfacelist = 0;
10331 if (r_maxsurfacelist < model->num_surfaces)
10333 r_maxsurfacelist = model->num_surfaces;
10335 Mem_Free((msurface_t **)r_surfacelist);
10336 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
10339 // if the model is static it doesn't matter what value we give for
10340 // wantnormals and wanttangents, so this logic uses only rules applicable
10341 // to a model, knowing that they are meaningless otherwise
10342 if (ent == r_refdef.scene.worldentity)
10343 RSurf_ActiveWorldEntity();
10344 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
10345 RSurf_ActiveModelEntity(ent, false, false, false);
10347 RSurf_ActiveModelEntity(ent, true, true, true);
10348 else if (depthonly)
10349 RSurf_ActiveModelEntity(ent, false, false, false);
10352 switch (vid.renderpath)
10354 case RENDERPATH_GL20:
10355 case RENDERPATH_CGGL:
10356 RSurf_ActiveModelEntity(ent, true, true, false);
10358 case RENDERPATH_GL13:
10359 case RENDERPATH_GL11:
10360 RSurf_ActiveModelEntity(ent, true, false, false);
10365 surfaces = model->data_surfaces;
10366 update = model->brushq1.lightmapupdateflags;
10368 // update light styles
10369 if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
10371 model_brush_lightstyleinfo_t *style;
10372 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
10374 if (style->value != r_refdef.scene.lightstylevalue[style->style])
10376 int *list = style->surfacelist;
10377 style->value = r_refdef.scene.lightstylevalue[style->style];
10378 for (j = 0;j < style->numsurfaces;j++)
10379 update[list[j]] = true;
10384 flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
10388 R_DrawDebugModel();
10389 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10395 rsurface.uselightmaptexture = false;
10396 rsurface.texture = NULL;
10397 rsurface.rtlight = NULL;
10398 numsurfacelist = 0;
10399 // add visible surfaces to draw list
10400 for (i = 0;i < model->nummodelsurfaces;i++)
10401 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
10402 // don't do anything if there were no surfaces
10403 if (!numsurfacelist)
10405 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10408 // update lightmaps if needed
10412 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10417 R_BuildLightMap(ent, surfaces + j);
10422 int count = model->brushq3.num_mergedlightmaps;
10423 for (i = 0;i < count;i++)
10425 if (model->brushq3.data_deluxemaps[i])
10426 R_FlushTexture(model->brushq3.data_deluxemaps[i]);
10427 if (model->brushq3.data_lightmaps[i])
10428 R_FlushTexture(model->brushq3.data_lightmaps[i]);
10433 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
10435 R_BuildLightMap(ent, surfaces + j);
10436 R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
10437 GL_AlphaTest(false);
10439 // add to stats if desired
10440 if (r_speeds.integer && !skysurfaces && !depthonly)
10442 r_refdef.stats.entities_surfaces += numsurfacelist;
10443 for (j = 0;j < numsurfacelist;j++)
10444 r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
10447 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10450 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
10452 static texture_t texture;
10453 static msurface_t surface;
10454 const msurface_t *surfacelist = &surface;
10456 // fake enough texture and surface state to render this geometry
10458 texture.update_lastrenderframe = -1; // regenerate this texture
10459 texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
10460 texture.currentskinframe = skinframe;
10461 texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
10462 texture.specularscalemod = 1;
10463 texture.specularpowermod = 1;
10465 surface.texture = &texture;
10466 surface.num_triangles = numtriangles;
10467 surface.num_firsttriangle = firsttriangle;
10468 surface.num_vertices = numvertices;
10469 surface.num_firstvertex = firstvertex;
10472 rsurface.texture = R_GetCurrentTexture(surface.texture);
10473 rsurface.uselightmaptexture = false;
10474 R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
10477 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)
10479 static msurface_t surface;
10480 const msurface_t *surfacelist = &surface;
10482 // fake enough texture and surface state to render this geometry
10484 surface.texture = texture;
10485 surface.num_triangles = numtriangles;
10486 surface.num_firsttriangle = firsttriangle;
10487 surface.num_vertices = numvertices;
10488 surface.num_firstvertex = firstvertex;
10491 rsurface.texture = R_GetCurrentTexture(surface.texture);
10492 rsurface.uselightmaptexture = false;
10493 R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);