9417854f8e4a8660980876c5a57722eaeae73d97
[xonotic/darkplaces.git] / r_shadow.c
1
2 /*
3 Terminology: Stencil Shadow Volume (sometimes called Stencil Shadows)
4 An extrusion of the lit faces, beginning at the original geometry and ending
5 further from the light source than the original geometry (presumably at least
6 as far as the light's radius, if the light has a radius at all), capped at
7 both front and back to avoid any problems (extrusion from dark faces also
8 works but has a different set of problems)
9
10 This is normally rendered using Carmack's Reverse technique, in which
11 backfaces behind zbuffer (zfail) increment the stencil, and frontfaces behind
12 zbuffer (zfail) decrement the stencil, the result is a stencil value of zero
13 where shadows did not intersect the visible geometry, suitable as a stencil
14 mask for rendering lighting everywhere but shadow.
15
16 In our case to hopefully avoid the Creative Labs patent, we draw the backfaces
17 as decrement and the frontfaces as increment, and we redefine the DepthFunc to
18 GL_LESS (the patent uses GL_GEQUAL) which causes zfail when behind surfaces
19 and zpass when infront (the patent draws where zpass with a GL_GEQUAL test),
20 additionally we clear stencil to 128 to avoid the need for the unclamped
21 incr/decr extension (not related to patent).
22
23 Patent warning:
24 This algorithm may be covered by Creative's patent (US Patent #6384822),
25 however that patent is quite specific about increment on backfaces and
26 decrement on frontfaces where zpass with GL_GEQUAL depth test, which is
27 opposite this implementation and partially opposite Carmack's Reverse paper
28 (which uses GL_LESS, but increments on backfaces and decrements on frontfaces).
29
30
31
32 Terminology: Stencil Light Volume (sometimes called Light Volumes)
33 Similar to a Stencil Shadow Volume, but inverted; rather than containing the
34 areas in shadow it contains the areas in light, this can only be built
35 quickly for certain limited cases (such as portal visibility from a point),
36 but is quite useful for some effects (sunlight coming from sky polygons is
37 one possible example, translucent occluders is another example).
38
39
40
41 Terminology: Optimized Stencil Shadow Volume
42 A Stencil Shadow Volume that has been processed sufficiently to ensure it has
43 no duplicate coverage of areas (no need to shadow an area twice), often this
44 greatly improves performance but is an operation too costly to use on moving
45 lights (however completely optimal Stencil Light Volumes can be constructed
46 in some ideal cases).
47
48
49
50 Terminology: Per Pixel Lighting (sometimes abbreviated PPL)
51 Per pixel evaluation of lighting equations, at a bare minimum this involves
52 DOT3 shading of diffuse lighting (per pixel dotproduct of negated incidence
53 vector and surface normal, using a texture of the surface bumps, called a
54 NormalMap) if supported by hardware; in our case there is support for cards
55 which are incapable of DOT3, the quality is quite poor however.  Additionally
56 it is desirable to have specular evaluation per pixel, per vertex
57 normalization of specular halfangle vectors causes noticable distortion but
58 is unavoidable on hardware without GL_ARB_fragment_program or
59 GL_ARB_fragment_shader.
60
61
62
63 Terminology: Normalization CubeMap
64 A cubemap containing normalized dot3-encoded (vectors of length 1 or less
65 encoded as RGB colors) for any possible direction, this technique allows per
66 pixel calculation of incidence vector for per pixel lighting purposes, which
67 would not otherwise be possible per pixel without GL_ARB_fragment_program or
68 GL_ARB_fragment_shader.
69
70
71
72 Terminology: 2D+1D Attenuation Texturing
73 A very crude approximation of light attenuation with distance which results
74 in cylindrical light shapes which fade vertically as a streak (some games
75 such as Doom3 allow this to be rotated to be less noticable in specific
76 cases), the technique is simply modulating lighting by two 2D textures (which
77 can be the same) on different axes of projection (XY and Z, typically), this
78 is the second best technique available without 3D Attenuation Texturing,
79 GL_ARB_fragment_program or GL_ARB_fragment_shader technology.
80
81
82
83 Terminology: 2D+1D Inverse Attenuation Texturing
84 A clever method described in papers on the Abducted engine, this has a squared
85 distance texture (bright on the outside, black in the middle), which is used
86 twice using GL_ADD blending, the result of this is used in an inverse modulate
87 (GL_ONE_MINUS_DST_ALPHA, GL_ZERO) to implement the equation
88 lighting*=(1-((X*X+Y*Y)+(Z*Z))) which is spherical (unlike 2D+1D attenuation
89 texturing).
90
91
92
93 Terminology: 3D Attenuation Texturing
94 A slightly crude approximation of light attenuation with distance, its flaws
95 are limited radius and resolution (performance tradeoffs).
96
97
98
99 Terminology: 3D Attenuation-Normalization Texturing
100 A 3D Attenuation Texture merged with a Normalization CubeMap, by making the
101 vectors shorter the lighting becomes darker, a very effective optimization of
102 diffuse lighting if 3D Attenuation Textures are already used.
103
104
105
106 Terminology: Light Cubemap Filtering
107 A technique for modeling non-uniform light distribution according to
108 direction, for example a lantern may use a cubemap to describe the light
109 emission pattern of the cage around the lantern (as well as soot buildup
110 discoloring the light in certain areas), often also used for softened grate
111 shadows and light shining through a stained glass window (done crudely by
112 texturing the lighting with a cubemap), another good example would be a disco
113 light.  This technique is used heavily in many games (Doom3 does not support
114 this however).
115
116
117
118 Terminology: Light Projection Filtering
119 A technique for modeling shadowing of light passing through translucent
120 surfaces, allowing stained glass windows and other effects to be done more
121 elegantly than possible with Light Cubemap Filtering by applying an occluder
122 texture to the lighting combined with a stencil light volume to limit the lit
123 area, this technique is used by Doom3 for spotlights and flashlights, among
124 other things, this can also be used more generally to render light passing
125 through multiple translucent occluders in a scene (using a light volume to
126 describe the area beyond the occluder, and thus mask off rendering of all
127 other areas).
128
129
130
131 Terminology: Doom3 Lighting
132 A combination of Stencil Shadow Volume, Per Pixel Lighting, Normalization
133 CubeMap, 2D+1D Attenuation Texturing, and Light Projection Filtering, as
134 demonstrated by the game Doom3.
135 */
136
137 #include "quakedef.h"
138 #include "r_shadow.h"
139 #include "cl_collision.h"
140 #include "portals.h"
141 #include "image.h"
142
143 extern void R_Shadow_EditLights_Init(void);
144
145 typedef enum r_shadow_rendermode_e
146 {
147         R_SHADOW_RENDERMODE_NONE,
148         R_SHADOW_RENDERMODE_STENCIL,
149         R_SHADOW_RENDERMODE_STENCILTWOSIDE,
150         R_SHADOW_RENDERMODE_LIGHT_VERTEX,
151         R_SHADOW_RENDERMODE_LIGHT_DOT3,
152         R_SHADOW_RENDERMODE_LIGHT_GLSL,
153         R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
154         R_SHADOW_RENDERMODE_VISIBLELIGHTING,
155 }
156 r_shadow_rendermode_t;
157
158 r_shadow_rendermode_t r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
159 r_shadow_rendermode_t r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_NONE;
160 r_shadow_rendermode_t r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_NONE;
161
162 int maxshadowtriangles;
163 int *shadowelements;
164
165 int maxshadowvertices;
166 float *shadowvertex3f;
167
168 int maxshadowmark;
169 int numshadowmark;
170 int *shadowmark;
171 int *shadowmarklist;
172 int shadowmarkcount;
173
174 int maxvertexupdate;
175 int *vertexupdate;
176 int *vertexremap;
177 int vertexupdatenum;
178
179 int r_shadow_buffer_numleafpvsbytes;
180 unsigned char *r_shadow_buffer_leafpvs;
181 int *r_shadow_buffer_leaflist;
182
183 int r_shadow_buffer_numsurfacepvsbytes;
184 unsigned char *r_shadow_buffer_surfacepvs;
185 int *r_shadow_buffer_surfacelist;
186
187 rtexturepool_t *r_shadow_texturepool;
188 rtexture_t *r_shadow_attenuation2dtexture;
189 rtexture_t *r_shadow_attenuation3dtexture;
190
191 // lights are reloaded when this changes
192 char r_shadow_mapname[MAX_QPATH];
193
194 // used only for light filters (cubemaps)
195 rtexturepool_t *r_shadow_filters_texturepool;
196
197 cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"};
198 cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
199 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
200 cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"};
201 cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.25", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};
202 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
203 cvar_t r_shadow_lightattenuationpower = {0, "r_shadow_lightattenuationpower", "0.5", "changes attenuation texture generation (does not affect r_glsl lighting)"};
204 cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "1", "changes attenuation texture generation (does not affect r_glsl lighting)"};
205 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
206 cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1", "use portal culling to exactly determine lit triangles when compiling world lights"};
207 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000", "how far to cast shadows"};
208 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
209 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
210 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal culling optimizations on dynamic lights (slow!  you probably don't want this!)"};
211 cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0", "enables rendering of full world lighting (whether loaded from the map, or a .rtlights file, or a .ent file, or a .lights file produced by hlight)"};
212 cvar_t r_shadow_realtime_world_dlightshadows = {CVAR_SAVE, "r_shadow_realtime_world_dlightshadows", "1", "enables shadows from dynamic lights when using full world lighting"};
213 cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0", "brightness to render lightmaps when using full world lighting, try 0.5 for a tenebrae-like appearance"};
214 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
215 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
216 cvar_t r_shadow_realtime_world_compileshadow = {0, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"};
217 cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"};
218 cvar_t r_shadow_shadow_polygonfactor = {0, "r_shadow_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
219 cvar_t r_shadow_shadow_polygonoffset = {0, "r_shadow_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"};
220 cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect r_glsl lighting)"};
221 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
222 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
223 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
224 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
225 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
226 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
227 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
228
229 float r_shadow_attenpower, r_shadow_attenscale;
230
231 rtlight_t *r_shadow_compilingrtlight;
232 dlight_t *r_shadow_worldlightchain;
233 dlight_t *r_shadow_selectedlight;
234 dlight_t r_shadow_bufferlight;
235 vec3_t r_editlights_cursorlocation;
236
237 extern int con_vislines;
238
239 typedef struct cubemapinfo_s
240 {
241         char basename[64];
242         rtexture_t *texture;
243 }
244 cubemapinfo_t;
245
246 #define MAX_CUBEMAPS 256
247 static int numcubemaps;
248 static cubemapinfo_t cubemaps[MAX_CUBEMAPS];
249
250 void R_Shadow_UncompileWorldLights(void);
251 void R_Shadow_ClearWorldLights(void);
252 void R_Shadow_SaveWorldLights(void);
253 void R_Shadow_LoadWorldLights(void);
254 void R_Shadow_LoadLightsFile(void);
255 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
256 void R_Shadow_EditLights_Reload_f(void);
257 void R_Shadow_ValidateCvars(void);
258 static void R_Shadow_MakeTextures(void);
259 void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, dlight_t *light);
260
261 void r_shadow_start(void)
262 {
263         // allocate vertex processing arrays
264         numcubemaps = 0;
265         r_shadow_attenuation2dtexture = NULL;
266         r_shadow_attenuation3dtexture = NULL;
267         r_shadow_texturepool = NULL;
268         r_shadow_filters_texturepool = NULL;
269         R_Shadow_ValidateCvars();
270         R_Shadow_MakeTextures();
271         maxshadowtriangles = 0;
272         shadowelements = NULL;
273         maxshadowvertices = 0;
274         shadowvertex3f = NULL;
275         maxvertexupdate = 0;
276         vertexupdate = NULL;
277         vertexremap = NULL;
278         vertexupdatenum = 0;
279         maxshadowmark = 0;
280         numshadowmark = 0;
281         shadowmark = NULL;
282         shadowmarklist = NULL;
283         shadowmarkcount = 0;
284         r_shadow_buffer_numleafpvsbytes = 0;
285         r_shadow_buffer_leafpvs = NULL;
286         r_shadow_buffer_leaflist = NULL;
287         r_shadow_buffer_numsurfacepvsbytes = 0;
288         r_shadow_buffer_surfacepvs = NULL;
289         r_shadow_buffer_surfacelist = NULL;
290 }
291
292 void r_shadow_shutdown(void)
293 {
294         R_Shadow_UncompileWorldLights();
295         numcubemaps = 0;
296         r_shadow_attenuation2dtexture = NULL;
297         r_shadow_attenuation3dtexture = NULL;
298         R_FreeTexturePool(&r_shadow_texturepool);
299         R_FreeTexturePool(&r_shadow_filters_texturepool);
300         maxshadowtriangles = 0;
301         if (shadowelements)
302                 Mem_Free(shadowelements);
303         shadowelements = NULL;
304         if (shadowvertex3f)
305                 Mem_Free(shadowvertex3f);
306         shadowvertex3f = NULL;
307         maxvertexupdate = 0;
308         if (vertexupdate)
309                 Mem_Free(vertexupdate);
310         vertexupdate = NULL;
311         if (vertexremap)
312                 Mem_Free(vertexremap);
313         vertexremap = NULL;
314         vertexupdatenum = 0;
315         maxshadowmark = 0;
316         numshadowmark = 0;
317         if (shadowmark)
318                 Mem_Free(shadowmark);
319         shadowmark = NULL;
320         if (shadowmarklist)
321                 Mem_Free(shadowmarklist);
322         shadowmarklist = NULL;
323         shadowmarkcount = 0;
324         r_shadow_buffer_numleafpvsbytes = 0;
325         if (r_shadow_buffer_leafpvs)
326                 Mem_Free(r_shadow_buffer_leafpvs);
327         r_shadow_buffer_leafpvs = NULL;
328         if (r_shadow_buffer_leaflist)
329                 Mem_Free(r_shadow_buffer_leaflist);
330         r_shadow_buffer_leaflist = NULL;
331         r_shadow_buffer_numsurfacepvsbytes = 0;
332         if (r_shadow_buffer_surfacepvs)
333                 Mem_Free(r_shadow_buffer_surfacepvs);
334         r_shadow_buffer_surfacepvs = NULL;
335         if (r_shadow_buffer_surfacelist)
336                 Mem_Free(r_shadow_buffer_surfacelist);
337         r_shadow_buffer_surfacelist = NULL;
338 }
339
340 void r_shadow_newmap(void)
341 {
342 }
343
344 void R_Shadow_Help_f(void)
345 {
346         Con_Printf(
347 "Documentation on r_shadow system:\n"
348 "Settings:\n"
349 "r_shadow_bumpscale_basetexture : base texture as bumpmap with this scale\n"
350 "r_shadow_bumpscale_bumpmap : depth scale for bumpmap conversion\n"
351 "r_shadow_debuglight : render only this light number (-1 = all)\n"
352 "r_shadow_gloss 0/1/2 : no gloss, gloss textures only, force gloss\n"
353 "r_shadow_gloss2intensity : brightness of forced gloss\n"
354 "r_shadow_glossintensity : brightness of textured gloss\n"
355 "r_shadow_lightattenuationpower : used to generate attenuation texture\n"
356 "r_shadow_lightattenuationscale : used to generate attenuation texture\n"
357 "r_shadow_lightintensityscale : scale rendering brightness of all lights\n"
358 "r_shadow_portallight : use portal visibility for static light precomputation\n"
359 "r_shadow_projectdistance : shadow volume projection distance\n"
360 "r_shadow_realtime_dlight : use high quality dynamic lights in normal mode\n"
361 "r_shadow_realtime_dlight_shadows : cast shadows from dlights\n"
362 "r_shadow_realtime_dlight_portalculling : work hard to reduce graphics work\n"
363 "r_shadow_realtime_world : use high quality world lighting mode\n"
364 "r_shadow_realtime_world_dlightshadows : cast shadows from dlights\n"
365 "r_shadow_realtime_world_lightmaps : use lightmaps in addition to lights\n"
366 "r_shadow_realtime_world_shadows : cast shadows from world lights\n"
367 "r_shadow_realtime_world_compile : compile surface/visibility information\n"
368 "r_shadow_realtime_world_compileshadow : compile shadow geometry\n"
369 "r_shadow_scissor : use scissor optimization\n"
370 "r_shadow_shadow_polygonfactor : nudge shadow volumes closer/further\n"
371 "r_shadow_shadow_polygonoffset : nudge shadow volumes closer/further\n"
372 "r_shadow_texture3d : use 3d attenuation texture (if hardware supports)\n"
373 "r_showlighting : useful for performance testing; bright = slow!\n"
374 "r_showshadowvolumes : useful for performance testing; bright = slow!\n"
375 "Commands:\n"
376 "r_shadow_help : this help\n"
377         );
378 }
379
380 void R_Shadow_Init(void)
381 {
382         Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
383         Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
384         Cvar_RegisterVariable(&r_shadow_debuglight);
385         Cvar_RegisterVariable(&r_shadow_gloss);
386         Cvar_RegisterVariable(&r_shadow_gloss2intensity);
387         Cvar_RegisterVariable(&r_shadow_glossintensity);
388         Cvar_RegisterVariable(&r_shadow_lightattenuationpower);
389         Cvar_RegisterVariable(&r_shadow_lightattenuationscale);
390         Cvar_RegisterVariable(&r_shadow_lightintensityscale);
391         Cvar_RegisterVariable(&r_shadow_portallight);
392         Cvar_RegisterVariable(&r_shadow_projectdistance);
393         Cvar_RegisterVariable(&r_shadow_realtime_dlight);
394         Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
395         Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
396         Cvar_RegisterVariable(&r_shadow_realtime_world);
397         Cvar_RegisterVariable(&r_shadow_realtime_world_dlightshadows);
398         Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
399         Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
400         Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
401         Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
402         Cvar_RegisterVariable(&r_shadow_scissor);
403         Cvar_RegisterVariable(&r_shadow_shadow_polygonfactor);
404         Cvar_RegisterVariable(&r_shadow_shadow_polygonoffset);
405         Cvar_RegisterVariable(&r_shadow_texture3d);
406         Cvar_RegisterVariable(&gl_ext_stenciltwoside);
407         if (gamemode == GAME_TENEBRAE)
408         {
409                 Cvar_SetValue("r_shadow_gloss", 2);
410                 Cvar_SetValue("r_shadow_bumpscale_basetexture", 4);
411         }
412         Cmd_AddCommand("r_shadow_help", R_Shadow_Help_f, "prints documentation on console commands and variables used by realtime lighting and shadowing system");
413         R_Shadow_EditLights_Init();
414         r_shadow_worldlightchain = NULL;
415         maxshadowtriangles = 0;
416         shadowelements = NULL;
417         maxshadowvertices = 0;
418         shadowvertex3f = NULL;
419         maxvertexupdate = 0;
420         vertexupdate = NULL;
421         vertexremap = NULL;
422         vertexupdatenum = 0;
423         maxshadowmark = 0;
424         numshadowmark = 0;
425         shadowmark = NULL;
426         shadowmarklist = NULL;
427         shadowmarkcount = 0;
428         r_shadow_buffer_numleafpvsbytes = 0;
429         r_shadow_buffer_leafpvs = NULL;
430         r_shadow_buffer_leaflist = NULL;
431         r_shadow_buffer_numsurfacepvsbytes = 0;
432         r_shadow_buffer_surfacepvs = NULL;
433         r_shadow_buffer_surfacelist = NULL;
434         R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap);
435 }
436
437 matrix4x4_t matrix_attenuationxyz =
438 {
439         {
440                 {0.5, 0.0, 0.0, 0.5},
441                 {0.0, 0.5, 0.0, 0.5},
442                 {0.0, 0.0, 0.5, 0.5},
443                 {0.0, 0.0, 0.0, 1.0}
444         }
445 };
446
447 matrix4x4_t matrix_attenuationz =
448 {
449         {
450                 {0.0, 0.0, 0.5, 0.5},
451                 {0.0, 0.0, 0.0, 0.5},
452                 {0.0, 0.0, 0.0, 0.5},
453                 {0.0, 0.0, 0.0, 1.0}
454         }
455 };
456
457 void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles)
458 {
459         // make sure shadowelements is big enough for this volume
460         if (maxshadowtriangles < numtriangles)
461         {
462                 maxshadowtriangles = numtriangles;
463                 if (shadowelements)
464                         Mem_Free(shadowelements);
465                 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[24]));
466         }
467         // make sure shadowvertex3f is big enough for this volume
468         if (maxshadowvertices < numvertices)
469         {
470                 maxshadowvertices = numvertices;
471                 if (shadowvertex3f)
472                         Mem_Free(shadowvertex3f);
473                 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[6]));
474         }
475 }
476
477 static void R_Shadow_EnlargeLeafSurfaceBuffer(int numleafs, int numsurfaces)
478 {
479         int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
480         int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
481         if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
482         {
483                 if (r_shadow_buffer_leafpvs)
484                         Mem_Free(r_shadow_buffer_leafpvs);
485                 if (r_shadow_buffer_leaflist)
486                         Mem_Free(r_shadow_buffer_leaflist);
487                 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
488                 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
489                 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
490         }
491         if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
492         {
493                 if (r_shadow_buffer_surfacepvs)
494                         Mem_Free(r_shadow_buffer_surfacepvs);
495                 if (r_shadow_buffer_surfacelist)
496                         Mem_Free(r_shadow_buffer_surfacelist);
497                 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
498                 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
499                 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
500         }
501 }
502
503 void R_Shadow_PrepareShadowMark(int numtris)
504 {
505         // make sure shadowmark is big enough for this volume
506         if (maxshadowmark < numtris)
507         {
508                 maxshadowmark = numtris;
509                 if (shadowmark)
510                         Mem_Free(shadowmark);
511                 if (shadowmarklist)
512                         Mem_Free(shadowmarklist);
513                 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
514                 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
515                 shadowmarkcount = 0;
516         }
517         shadowmarkcount++;
518         // if shadowmarkcount wrapped we clear the array and adjust accordingly
519         if (shadowmarkcount == 0)
520         {
521                 shadowmarkcount = 1;
522                 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
523         }
524         numshadowmark = 0;
525 }
526
527 int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *inelement3i, const int *inneighbor3i, const float *invertex3f, int *outnumvertices, int *outelement3i, float *outvertex3f, const float *projectorigin, float projectdistance, int numshadowmarktris, const int *shadowmarktris)
528 {
529         int i, j;
530         int outtriangles = 0, outvertices = 0;
531         const int *element;
532         const float *vertex;
533
534         if (maxvertexupdate < innumvertices)
535         {
536                 maxvertexupdate = innumvertices;
537                 if (vertexupdate)
538                         Mem_Free(vertexupdate);
539                 if (vertexremap)
540                         Mem_Free(vertexremap);
541                 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
542                 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
543                 vertexupdatenum = 0;
544         }
545         vertexupdatenum++;
546         if (vertexupdatenum == 0)
547         {
548                 vertexupdatenum = 1;
549                 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
550                 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
551         }
552
553         for (i = 0;i < numshadowmarktris;i++)
554                 shadowmark[shadowmarktris[i]] = shadowmarkcount;
555
556         for (i = 0;i < numshadowmarktris;i++)
557         {
558                 element = inelement3i + shadowmarktris[i] * 3;
559                 // make sure the vertices are created
560                 for (j = 0;j < 3;j++)
561                 {
562                         if (vertexupdate[element[j]] != vertexupdatenum)
563                         {
564                                 float ratio, direction[3];
565                                 vertexupdate[element[j]] = vertexupdatenum;
566                                 vertexremap[element[j]] = outvertices;
567                                 vertex = invertex3f + element[j] * 3;
568                                 // project one copy of the vertex to the sphere radius of the light
569                                 // (FIXME: would projecting it to the light box be better?)
570                                 VectorSubtract(vertex, projectorigin, direction);
571                                 ratio = projectdistance / VectorLength(direction);
572                                 VectorCopy(vertex, outvertex3f);
573                                 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
574                                 outvertex3f += 6;
575                                 outvertices += 2;
576                         }
577                 }
578         }
579
580         for (i = 0;i < numshadowmarktris;i++)
581         {
582                 int remappedelement[3];
583                 int markindex;
584                 const int *neighbortriangle;
585
586                 markindex = shadowmarktris[i] * 3;
587                 element = inelement3i + markindex;
588                 neighbortriangle = inneighbor3i + markindex;
589                 // output the front and back triangles
590                 outelement3i[0] = vertexremap[element[0]];
591                 outelement3i[1] = vertexremap[element[1]];
592                 outelement3i[2] = vertexremap[element[2]];
593                 outelement3i[3] = vertexremap[element[2]] + 1;
594                 outelement3i[4] = vertexremap[element[1]] + 1;
595                 outelement3i[5] = vertexremap[element[0]] + 1;
596
597                 outelement3i += 6;
598                 outtriangles += 2;
599                 // output the sides (facing outward from this triangle)
600                 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
601                 {
602                         remappedelement[0] = vertexremap[element[0]];
603                         remappedelement[1] = vertexremap[element[1]];
604                         outelement3i[0] = remappedelement[1];
605                         outelement3i[1] = remappedelement[0];
606                         outelement3i[2] = remappedelement[0] + 1;
607                         outelement3i[3] = remappedelement[1];
608                         outelement3i[4] = remappedelement[0] + 1;
609                         outelement3i[5] = remappedelement[1] + 1;
610
611                         outelement3i += 6;
612                         outtriangles += 2;
613                 }
614                 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
615                 {
616                         remappedelement[1] = vertexremap[element[1]];
617                         remappedelement[2] = vertexremap[element[2]];
618                         outelement3i[0] = remappedelement[2];
619                         outelement3i[1] = remappedelement[1];
620                         outelement3i[2] = remappedelement[1] + 1;
621                         outelement3i[3] = remappedelement[2];
622                         outelement3i[4] = remappedelement[1] + 1;
623                         outelement3i[5] = remappedelement[2] + 1;
624
625                         outelement3i += 6;
626                         outtriangles += 2;
627                 }
628                 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
629                 {
630                         remappedelement[0] = vertexremap[element[0]];
631                         remappedelement[2] = vertexremap[element[2]];
632                         outelement3i[0] = remappedelement[0];
633                         outelement3i[1] = remappedelement[2];
634                         outelement3i[2] = remappedelement[2] + 1;
635                         outelement3i[3] = remappedelement[0];
636                         outelement3i[4] = remappedelement[2] + 1;
637                         outelement3i[5] = remappedelement[0] + 1;
638
639                         outelement3i += 6;
640                         outtriangles += 2;
641                 }
642         }
643         if (outnumvertices)
644                 *outnumvertices = outvertices;
645         return outtriangles;
646 }
647
648 void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, float projectdistance, int nummarktris, const int *marktris)
649 {
650         int tris, outverts;
651         if (projectdistance < 0.1)
652         {
653                 Con_Printf("R_Shadow_Volume: projectdistance %f\n");
654                 return;
655         }
656         if (!numverts || !nummarktris)
657                 return;
658         // make sure shadowelements is big enough for this volume
659         if (maxshadowtriangles < nummarktris || maxshadowvertices < numverts)
660                 R_Shadow_ResizeShadowArrays((numverts + 255) & ~255, (nummarktris + 255) & ~255);
661         tris = R_Shadow_ConstructShadowVolume(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdistance, nummarktris, marktris);
662         renderstats.lights_dynamicshadowtriangles += tris;
663         R_Shadow_RenderVolume(outverts, tris, shadowvertex3f, shadowelements);
664 }
665
666 void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const vec3_t projectorigin, const vec3_t lightmins, const vec3_t lightmaxs, const vec3_t surfacemins, const vec3_t surfacemaxs)
667 {
668         int t, tend;
669         const int *e;
670         const float *v[3];
671         if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
672                 return;
673         tend = firsttriangle + numtris;
674         if (surfacemins[0] >= lightmins[0] && surfacemaxs[0] <= lightmaxs[0]
675          && surfacemins[1] >= lightmins[1] && surfacemaxs[1] <= lightmaxs[1]
676          && surfacemins[2] >= lightmins[2] && surfacemaxs[2] <= lightmaxs[2])
677         {
678                 // surface box entirely inside light box, no box cull
679                 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
680                         if (PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
681                                 shadowmarklist[numshadowmark++] = t;
682         }
683         else
684         {
685                 // surface box not entirely inside light box, cull each triangle
686                 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
687                 {
688                         v[0] = invertex3f + e[0] * 3;
689                         v[1] = invertex3f + e[1] * 3;
690                         v[2] = invertex3f + e[2] * 3;
691                         if (PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
692                          && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0]))
693                          && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0]))
694                          && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1]))
695                          && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1]))
696                          && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2]))
697                          && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
698                                 shadowmarklist[numshadowmark++] = t;
699                 }
700         }
701 }
702
703 void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *vertex3f, const int *element3i)
704 {
705         rmeshstate_t m;
706         if (r_shadow_compilingrtlight)
707         {
708                 // if we're compiling an rtlight, capture the mesh
709                 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, numtriangles, element3i);
710                 return;
711         }
712         renderstats.lights_shadowtriangles += numtriangles;
713         memset(&m, 0, sizeof(m));
714         m.pointer_vertex = vertex3f;
715         R_Mesh_State(&m);
716         GL_LockArrays(0, numvertices);
717         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCIL)
718         {
719                 // decrement stencil if backface is behind depthbuffer
720                 qglCullFace(GL_BACK); // quake is backwards, this culls front faces
721                 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
722                 R_Mesh_Draw(0, numvertices, numtriangles, element3i);
723                 // increment stencil if frontface is behind depthbuffer
724                 qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
725                 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
726         }
727         R_Mesh_Draw(0, numvertices, numtriangles, element3i);
728         GL_LockArrays(0, 0);
729 }
730
731 static void R_Shadow_MakeTextures(void)
732 {
733         int x, y, z, d;
734         float v[3], intensity;
735         unsigned char *data;
736         R_FreeTexturePool(&r_shadow_texturepool);
737         r_shadow_texturepool = R_AllocTexturePool();
738         r_shadow_attenpower = r_shadow_lightattenuationpower.value;
739         r_shadow_attenscale = r_shadow_lightattenuationscale.value;
740 #define ATTEN2DSIZE 64
741 #define ATTEN3DSIZE 32
742         data = (unsigned char *)Mem_Alloc(tempmempool, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4));
743         for (y = 0;y < ATTEN2DSIZE;y++)
744         {
745                 for (x = 0;x < ATTEN2DSIZE;x++)
746                 {
747                         v[0] = ((x + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375);
748                         v[1] = ((y + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375);
749                         v[2] = 0;
750                         intensity = 1.0f - sqrt(DotProduct(v, v));
751                         if (intensity > 0)
752                                 intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f;
753                         d = bound(0, intensity, 255);
754                         data[(y*ATTEN2DSIZE+x)*4+0] = d;
755                         data[(y*ATTEN2DSIZE+x)*4+1] = d;
756                         data[(y*ATTEN2DSIZE+x)*4+2] = d;
757                         data[(y*ATTEN2DSIZE+x)*4+3] = d;
758                 }
759         }
760         r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL);
761         if (r_shadow_texture3d.integer)
762         {
763                 for (z = 0;z < ATTEN3DSIZE;z++)
764                 {
765                         for (y = 0;y < ATTEN3DSIZE;y++)
766                         {
767                                 for (x = 0;x < ATTEN3DSIZE;x++)
768                                 {
769                                         v[0] = ((x + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375);
770                                         v[1] = ((y + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375);
771                                         v[2] = ((z + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375);
772                                         intensity = 1.0f - sqrt(DotProduct(v, v));
773                                         if (intensity > 0)
774                                                 intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f;
775                                         d = bound(0, intensity, 255);
776                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+0] = d;
777                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+1] = d;
778                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+2] = d;
779                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+3] = d;
780                                 }
781                         }
782                 }
783                 r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL);
784         }
785         Mem_Free(data);
786 }
787
788 void R_Shadow_ValidateCvars(void)
789 {
790         if (r_shadow_texture3d.integer && !gl_texture3d)
791                 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
792         if (gl_ext_stenciltwoside.integer && !gl_support_stenciltwoside)
793                 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
794 }
795
796 // light currently being rendered
797 rtlight_t *r_shadow_rtlight;
798
799 // this is the location of the eye in entity space
800 vec3_t r_shadow_entityeyeorigin;
801 // this is the location of the light in entity space
802 vec3_t r_shadow_entitylightorigin;
803 // this transforms entity coordinates to light filter cubemap coordinates
804 // (also often used for other purposes)
805 matrix4x4_t r_shadow_entitytolight;
806 // based on entitytolight this transforms -1 to +1 to 0 to 1 for purposes
807 // of attenuation texturing in full 3D (Z result often ignored)
808 matrix4x4_t r_shadow_entitytoattenuationxyz;
809 // this transforms only the Z to S, and T is always 0.5
810 matrix4x4_t r_shadow_entitytoattenuationz;
811
812 void R_Shadow_RenderMode_Begin(void)
813 {
814         rmeshstate_t m;
815
816         R_Shadow_ValidateCvars();
817
818         if (!r_shadow_attenuation2dtexture
819          || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
820          || r_shadow_lightattenuationpower.value != r_shadow_attenpower
821          || r_shadow_lightattenuationscale.value != r_shadow_attenscale)
822                 R_Shadow_MakeTextures();
823
824         memset(&m, 0, sizeof(m));
825         R_Mesh_State(&m);
826         GL_BlendFunc(GL_ONE, GL_ZERO);
827         GL_DepthMask(false);
828         GL_DepthTest(true);
829         GL_Color(0, 0, 0, 1);
830         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
831         qglEnable(GL_CULL_FACE);
832         GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
833
834         r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
835
836         if (gl_ext_stenciltwoside.integer)
837                 r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCILTWOSIDE;
838         else
839                 r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCIL;
840
841         if (r_glsl.integer && gl_support_fragment_shader)
842                 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
843         else if (gl_dot3arb && gl_texturecubemap && r_textureunits.integer >= 2 && gl_combine.integer && gl_stencil)
844                 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_DOT3;
845         else
846                 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
847 }
848
849 void R_Shadow_RenderMode_ActiveLight(rtlight_t *rtlight)
850 {
851         r_shadow_rtlight = rtlight;
852 }
853
854 void R_Shadow_RenderMode_Reset(void)
855 {
856         rmeshstate_t m;
857         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
858         {
859                 qglUseProgramObjectARB(0);
860                 // HACK HACK HACK: work around for bug in NVIDIAI 6xxx drivers that causes GL_OUT_OF_MEMORY and/or software rendering
861                 qglBegin(GL_TRIANGLES);
862                 qglEnd();
863                 CHECKGLERROR
864         }
865         else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCILTWOSIDE)
866                 qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
867         memset(&m, 0, sizeof(m));
868         R_Mesh_State(&m);
869 }
870
871 void R_Shadow_RenderMode_StencilShadowVolumes(void)
872 {
873         R_Shadow_RenderMode_Reset();
874         GL_Color(1, 1, 1, 1);
875         GL_ColorMask(0, 0, 0, 0);
876         GL_BlendFunc(GL_ONE, GL_ZERO);
877         GL_DepthMask(false);
878         GL_DepthTest(true);
879         qglPolygonOffset(r_shadowpolygonfactor, r_shadowpolygonoffset);
880         qglDepthFunc(GL_LESS);
881         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
882         qglEnable(GL_STENCIL_TEST);
883         qglStencilFunc(GL_ALWAYS, 128, ~0);
884         r_shadow_rendermode = r_shadow_shadowingrendermode;
885         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCILTWOSIDE)
886         {
887                 qglDisable(GL_CULL_FACE);
888                 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
889                 qglActiveStencilFaceEXT(GL_BACK); // quake is backwards, this is front faces
890                 qglStencilMask(~0);
891                 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
892                 qglActiveStencilFaceEXT(GL_FRONT); // quake is backwards, this is back faces
893                 qglStencilMask(~0);
894                 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
895         }
896         else
897         {
898                 qglEnable(GL_CULL_FACE);
899                 qglStencilMask(~0);
900                 // this is changed by every shadow render so its value here is unimportant
901                 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
902         }
903         GL_Clear(GL_STENCIL_BUFFER_BIT);
904         renderstats.lights_clears++;
905 }
906
907 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent)
908 {
909         R_Shadow_RenderMode_Reset();
910         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
911         GL_DepthMask(false);
912         GL_DepthTest(true);
913         qglPolygonOffset(r_polygonfactor, r_polygonoffset);
914         //qglDisable(GL_POLYGON_OFFSET_FILL);
915         GL_Color(1, 1, 1, 1);
916         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
917         if (transparent)
918                 qglDepthFunc(GL_LEQUAL);
919         else
920                 qglDepthFunc(GL_EQUAL);
921         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
922         qglEnable(GL_CULL_FACE);
923         if (stenciltest)
924                 qglEnable(GL_STENCIL_TEST);
925         else
926                 qglDisable(GL_STENCIL_TEST);
927         qglStencilMask(~0);
928         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
929         // only draw light where this geometry was already rendered AND the
930         // stencil is 128 (values other than this mean shadow)
931         qglStencilFunc(GL_EQUAL, 128, ~0);
932         r_shadow_rendermode = r_shadow_lightingrendermode;
933         // do global setup needed for the chosen lighting mode
934         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
935         {
936                 R_Mesh_TexBind(0, R_GetTexture(r_texture_blanknormalmap)); // normal
937                 R_Mesh_TexBind(1, R_GetTexture(r_texture_white)); // diffuse
938                 R_Mesh_TexBind(2, R_GetTexture(r_texture_white)); // gloss
939                 R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap)); // light filter
940                 R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation)); // fog
941                 R_Mesh_TexBind(5, R_GetTexture(r_texture_white)); // pants
942                 R_Mesh_TexBind(6, R_GetTexture(r_texture_white)); // shirt
943                 //R_Mesh_TexMatrix(3, r_shadow_entitytolight); // light filter matrix
944                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
945                 GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
946                 CHECKGLERROR
947         }
948 }
949
950 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
951 {
952         R_Shadow_RenderMode_Reset();
953         GL_BlendFunc(GL_ONE, GL_ONE);
954         GL_DepthMask(false);
955         GL_DepthTest(!r_showdisabledepthtest.integer);
956         qglPolygonOffset(r_polygonfactor, r_polygonoffset);
957         GL_Color(0.0, 0.0125, 0.1, 1);
958         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
959         qglDepthFunc(GL_GEQUAL);
960         qglCullFace(GL_FRONT); // this culls back
961         qglDisable(GL_CULL_FACE);
962         qglDisable(GL_STENCIL_TEST);
963         r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
964 }
965
966 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
967 {
968         R_Shadow_RenderMode_Reset();
969         GL_BlendFunc(GL_ONE, GL_ONE);
970         GL_DepthMask(false);
971         GL_DepthTest(!r_showdisabledepthtest.integer);
972         qglPolygonOffset(r_polygonfactor, r_polygonoffset);
973         GL_Color(0.1, 0.0125, 0, 1);
974         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
975         if (transparent)
976                 qglDepthFunc(GL_LEQUAL);
977         else
978                 qglDepthFunc(GL_EQUAL);
979         qglCullFace(GL_FRONT); // this culls back
980         qglEnable(GL_CULL_FACE);
981         if (stenciltest)
982                 qglEnable(GL_STENCIL_TEST);
983         else
984                 qglDisable(GL_STENCIL_TEST);
985         r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
986 }
987
988 void R_Shadow_RenderMode_End(void)
989 {
990         R_Shadow_RenderMode_Reset();
991         R_Shadow_RenderMode_ActiveLight(NULL);
992         GL_BlendFunc(GL_ONE, GL_ZERO);
993         GL_DepthMask(true);
994         GL_DepthTest(true);
995         qglPolygonOffset(r_polygonfactor, r_polygonoffset);
996         //qglDisable(GL_POLYGON_OFFSET_FILL);
997         GL_Color(1, 1, 1, 1);
998         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
999         GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
1000         qglDepthFunc(GL_LEQUAL);
1001         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
1002         qglEnable(GL_CULL_FACE);
1003         qglDisable(GL_STENCIL_TEST);
1004         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
1005         if (gl_support_stenciltwoside)
1006                 qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
1007         qglStencilMask(~0);
1008         qglStencilFunc(GL_ALWAYS, 128, ~0);
1009         r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1010 }
1011
1012 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
1013 {
1014         int i, ix1, iy1, ix2, iy2;
1015         float x1, y1, x2, y2;
1016         vec4_t v, v2;
1017         rmesh_t mesh;
1018         mplane_t planes[11];
1019         float vertex3f[256*3];
1020
1021         // if view is inside the light box, just say yes it's visible
1022         if (BoxesOverlap(r_vieworigin, r_vieworigin, mins, maxs))
1023         {
1024                 GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
1025                 return false;
1026         }
1027
1028         // create a temporary brush describing the area the light can affect in worldspace
1029         VectorNegate(frustum[0].normal, planes[ 0].normal);planes[ 0].dist = -frustum[0].dist;
1030         VectorNegate(frustum[1].normal, planes[ 1].normal);planes[ 1].dist = -frustum[1].dist;
1031         VectorNegate(frustum[2].normal, planes[ 2].normal);planes[ 2].dist = -frustum[2].dist;
1032         VectorNegate(frustum[3].normal, planes[ 3].normal);planes[ 3].dist = -frustum[3].dist;
1033         VectorNegate(frustum[4].normal, planes[ 4].normal);planes[ 4].dist = -frustum[4].dist;
1034         VectorSet   (planes[ 5].normal,  1, 0, 0);         planes[ 5].dist =  maxs[0];
1035         VectorSet   (planes[ 6].normal, -1, 0, 0);         planes[ 6].dist = -mins[0];
1036         VectorSet   (planes[ 7].normal, 0,  1, 0);         planes[ 7].dist =  maxs[1];
1037         VectorSet   (planes[ 8].normal, 0, -1, 0);         planes[ 8].dist = -mins[1];
1038         VectorSet   (planes[ 9].normal, 0, 0,  1);         planes[ 9].dist =  maxs[2];
1039         VectorSet   (planes[10].normal, 0, 0, -1);         planes[10].dist = -mins[2];
1040
1041         // turn the brush into a mesh
1042         memset(&mesh, 0, sizeof(rmesh_t));
1043         mesh.maxvertices = 256;
1044         mesh.vertex3f = vertex3f;
1045         mesh.epsilon2 = (1.0f / (32.0f * 32.0f));
1046         R_Mesh_AddBrushMeshFromPlanes(&mesh, 11, planes);
1047
1048         // if that mesh is empty, the light is not visible at all
1049         if (!mesh.numvertices)
1050                 return true;
1051
1052         if (!r_shadow_scissor.integer)
1053                 return false;
1054
1055         // if that mesh is not empty, check what area of the screen it covers
1056         x1 = y1 = x2 = y2 = 0;
1057         v[3] = 1.0f;
1058         for (i = 0;i < mesh.numvertices;i++)
1059         {
1060                 VectorCopy(mesh.vertex3f + i * 3, v);
1061                 GL_TransformToScreen(v, v2);
1062                 //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]);
1063                 if (i)
1064                 {
1065                         if (x1 > v2[0]) x1 = v2[0];
1066                         if (x2 < v2[0]) x2 = v2[0];
1067                         if (y1 > v2[1]) y1 = v2[1];
1068                         if (y2 < v2[1]) y2 = v2[1];
1069                 }
1070                 else
1071                 {
1072                         x1 = x2 = v2[0];
1073                         y1 = y2 = v2[1];
1074                 }
1075         }
1076
1077         // now convert the scissor rectangle to integer screen coordinates
1078         ix1 = x1 - 1.0f;
1079         iy1 = y1 - 1.0f;
1080         ix2 = x2 + 1.0f;
1081         iy2 = y2 + 1.0f;
1082         //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
1083
1084         // clamp it to the screen
1085         if (ix1 < r_view_x) ix1 = r_view_x;
1086         if (iy1 < r_view_y) iy1 = r_view_y;
1087         if (ix2 > r_view_x + r_view_width) ix2 = r_view_x + r_view_width;
1088         if (iy2 > r_view_y + r_view_height) iy2 = r_view_y + r_view_height;
1089
1090         // if it is inside out, it's not visible
1091         if (ix2 <= ix1 || iy2 <= iy1)
1092                 return true;
1093
1094         // the light area is visible, set up the scissor rectangle
1095         GL_Scissor(ix1, vid.height - iy2, ix2 - ix1, iy2 - iy1);
1096         //qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1);
1097         //qglEnable(GL_SCISSOR_TEST);
1098         renderstats.lights_scissored++;
1099         return false;
1100 }
1101
1102 extern float *rsurface_vertex3f;
1103 extern float *rsurface_svector3f;
1104 extern float *rsurface_tvector3f;
1105 extern float *rsurface_normal3f;
1106 extern void RSurf_SetVertexPointer(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t modelorg, qboolean generatenormals, qboolean generatetangents);
1107
1108 static void R_Shadow_RenderSurfacesLighting_Light_Vertex_Shading(const msurface_t *surface, const float *diffusecolor, const float *ambientcolor)
1109 {
1110         int numverts = surface->num_vertices;
1111         float *vertex3f = rsurface_vertex3f + 3 * surface->num_firstvertex;
1112         float *normal3f = rsurface_normal3f + 3 * surface->num_firstvertex;
1113         float *color4f = rsurface_array_color4f + 4 * surface->num_firstvertex;
1114         float dist, dot, distintensity, shadeintensity, v[3], n[3];
1115         if (r_textureunits.integer >= 3)
1116         {
1117                 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1118                 {
1119                         Matrix4x4_Transform(&r_shadow_entitytolight, vertex3f, v);
1120                         Matrix4x4_Transform3x3(&r_shadow_entitytolight, normal3f, n);
1121                         if ((dot = DotProduct(n, v)) < 0)
1122                         {
1123                                 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
1124                                 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]);
1125                                 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]);
1126                                 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]);
1127                                 if (fogenabled)
1128                                 {
1129                                         float f = VERTEXFOGTABLE(VectorDistance(v, r_shadow_entityeyeorigin));
1130                                         VectorScale(color4f, f, color4f);
1131                                 }
1132                         }
1133                         else
1134                                 VectorClear(color4f);
1135                         color4f[3] = 1;
1136                 }
1137         }
1138         else if (r_textureunits.integer >= 2)
1139         {
1140                 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1141                 {
1142                         Matrix4x4_Transform(&r_shadow_entitytolight, vertex3f, v);
1143                         if ((dist = fabs(v[2])) < 1)
1144                         {
1145                                 distintensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale;
1146                                 Matrix4x4_Transform3x3(&r_shadow_entitytolight, normal3f, n);
1147                                 if ((dot = DotProduct(n, v)) < 0)
1148                                 {
1149                                         shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
1150                                         color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
1151                                         color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
1152                                         color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
1153                                 }
1154                                 else
1155                                 {
1156                                         color4f[0] = ambientcolor[0] * distintensity;
1157                                         color4f[1] = ambientcolor[1] * distintensity;
1158                                         color4f[2] = ambientcolor[2] * distintensity;
1159                                 }
1160                                 if (fogenabled)
1161                                 {
1162                                         float f = VERTEXFOGTABLE(VectorDistance(v, r_shadow_entityeyeorigin));
1163                                         VectorScale(color4f, f, color4f);
1164                                 }
1165                         }
1166                         else
1167                                 VectorClear(color4f);
1168                         color4f[3] = 1;
1169                 }
1170         }
1171         else
1172         {
1173                 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1174                 {
1175                         Matrix4x4_Transform(&r_shadow_entitytolight, vertex3f, v);
1176                         if ((dist = DotProduct(v, v)) < 1)
1177                         {
1178                                 dist = sqrt(dist);
1179                                 distintensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale;
1180                                 Matrix4x4_Transform3x3(&r_shadow_entitytolight, normal3f, n);
1181                                 if ((dot = DotProduct(n, v)) < 0)
1182                                 {
1183                                         shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
1184                                         color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
1185                                         color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
1186                                         color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
1187                                 }
1188                                 else
1189                                 {
1190                                         color4f[0] = ambientcolor[0] * distintensity;
1191                                         color4f[1] = ambientcolor[1] * distintensity;
1192                                         color4f[2] = ambientcolor[2] * distintensity;
1193                                 }
1194                                 if (fogenabled)
1195                                 {
1196                                         float f = VERTEXFOGTABLE(VectorDistance(v, r_shadow_entityeyeorigin));
1197                                         VectorScale(color4f, f, color4f);
1198                                 }
1199                         }
1200                         else
1201                                 VectorClear(color4f);
1202                         color4f[3] = 1;
1203                 }
1204         }
1205 }
1206
1207 // TODO: use glTexGen instead of feeding vertices to texcoordpointer?
1208
1209 static void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(float *out3f, int numverts, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const vec3_t relativelightorigin)
1210 {
1211         int i;
1212         float lightdir[3];
1213         for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
1214         {
1215                 VectorSubtract(relativelightorigin, vertex3f, lightdir);
1216                 // the cubemap normalizes this for us
1217                 out3f[0] = DotProduct(svector3f, lightdir);
1218                 out3f[1] = DotProduct(tvector3f, lightdir);
1219                 out3f[2] = DotProduct(normal3f, lightdir);
1220         }
1221 }
1222
1223 static void R_Shadow_GenTexCoords_Specular_NormalCubeMap(float *out3f, int numverts, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const vec3_t relativelightorigin, const vec3_t relativeeyeorigin)
1224 {
1225         int i;
1226         float lightdir[3], eyedir[3], halfdir[3];
1227         for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
1228         {
1229                 VectorSubtract(relativelightorigin, vertex3f, lightdir);
1230                 VectorNormalize(lightdir);
1231                 VectorSubtract(relativeeyeorigin, vertex3f, eyedir);
1232                 VectorNormalize(eyedir);
1233                 VectorAdd(lightdir, eyedir, halfdir);
1234                 // the cubemap normalizes this for us
1235                 out3f[0] = DotProduct(svector3f, halfdir);
1236                 out3f[1] = DotProduct(tvector3f, halfdir);
1237                 out3f[2] = DotProduct(normal3f, halfdir);
1238         }
1239 }
1240
1241 static void R_Shadow_RenderSurfacesLighting_VisibleLighting(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt)
1242 {
1243         // used to display how many times a surface is lit for level design purposes
1244         int surfacelistindex;
1245         rmeshstate_t m;
1246         GL_Color(0.1, 0.025, 0, 1);
1247         memset(&m, 0, sizeof(m));
1248         R_Mesh_State(&m);
1249         for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
1250         {
1251                 const msurface_t *surface = surfacelist[surfacelistindex];
1252                 RSurf_SetVertexPointer(ent, texture, surface, r_shadow_entityeyeorigin, false, false);
1253                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1254                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle);
1255                 GL_LockArrays(0, 0);
1256         }
1257 }
1258
1259 static void R_Shadow_RenderSurfacesLighting_Light_GLSL(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt)
1260 {
1261         // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
1262         int surfacelistindex;
1263         R_SetupSurfaceShader(ent, texture, r_shadow_entityeyeorigin, lightcolorbase, false);
1264         for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
1265         {
1266                 const msurface_t *surface = surfacelist[surfacelistindex];
1267                 const int *elements = surface->groupmesh->data_element3i + surface->num_firsttriangle * 3;
1268                 RSurf_SetVertexPointer(ent, texture, surface, r_shadow_entityeyeorigin, false, true);
1269                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1270                 R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f);
1271                 R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f);
1272                 R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f);
1273                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1274                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1275                 GL_LockArrays(0, 0);
1276         }
1277 }
1278
1279 static void R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t lightcolorbase, rtexture_t *basetexture, float colorscale)
1280 {
1281         int renders;
1282         float color2[3];
1283         rmeshstate_t m;
1284         const int *elements = surface->groupmesh->data_element3i + surface->num_firsttriangle * 3;
1285         GL_Color(1,1,1,1);
1286         // colorscale accounts for how much we multiply the brightness
1287         // during combine.
1288         //
1289         // mult is how many times the final pass of the lighting will be
1290         // performed to get more brightness than otherwise possible.
1291         //
1292         // Limit mult to 64 for sanity sake.
1293         if (r_shadow_texture3d.integer && r_shadow_rtlight->currentcubemap != r_texture_whitecube && r_textureunits.integer >= 4)
1294         {
1295                 // 3 3D combine path (Geforce3, Radeon 8500)
1296                 memset(&m, 0, sizeof(m));
1297                 m.pointer_vertex = rsurface_vertex3f;
1298                 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1299                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1300                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1301                 m.tex[1] = R_GetTexture(basetexture);
1302                 m.pointer_texcoord[1] = surface->groupmesh->data_texcoordtexture2f;
1303                 m.texmatrix[1] = texture->currenttexmatrix;
1304                 m.texcubemap[2] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1305                 m.pointer_texcoord3f[2] = rsurface_vertex3f;
1306                 m.texmatrix[2] = r_shadow_entitytolight;
1307                 GL_BlendFunc(GL_ONE, GL_ONE);
1308         }
1309         else if (r_shadow_texture3d.integer && r_shadow_rtlight->currentcubemap == r_texture_whitecube && r_textureunits.integer >= 2)
1310         {
1311                 // 2 3D combine path (Geforce3, original Radeon)
1312                 memset(&m, 0, sizeof(m));
1313                 m.pointer_vertex = rsurface_vertex3f;
1314                 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1315                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1316                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1317                 m.tex[1] = R_GetTexture(basetexture);
1318                 m.pointer_texcoord[1] = surface->groupmesh->data_texcoordtexture2f;
1319                 m.texmatrix[1] = texture->currenttexmatrix;
1320                 GL_BlendFunc(GL_ONE, GL_ONE);
1321         }
1322         else if (r_textureunits.integer >= 4 && r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1323         {
1324                 // 4 2D combine path (Geforce3, Radeon 8500)
1325                 memset(&m, 0, sizeof(m));
1326                 m.pointer_vertex = rsurface_vertex3f;
1327                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1328                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1329                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1330                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1331                 m.pointer_texcoord3f[1] = rsurface_vertex3f;
1332                 m.texmatrix[1] = r_shadow_entitytoattenuationz;
1333                 m.tex[2] = R_GetTexture(basetexture);
1334                 m.pointer_texcoord[2] = surface->groupmesh->data_texcoordtexture2f;
1335                 m.texmatrix[2] = texture->currenttexmatrix;
1336                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1337                 {
1338                         m.texcubemap[3] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1339                         m.pointer_texcoord3f[3] = rsurface_vertex3f;
1340                         m.texmatrix[3] = r_shadow_entitytolight;
1341                 }
1342                 GL_BlendFunc(GL_ONE, GL_ONE);
1343         }
1344         else if (r_textureunits.integer >= 3 && r_shadow_rtlight->currentcubemap == r_texture_whitecube)
1345         {
1346                 // 3 2D combine path (Geforce3, original Radeon)
1347                 memset(&m, 0, sizeof(m));
1348                 m.pointer_vertex = rsurface_vertex3f;
1349                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1350                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1351                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1352                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1353                 m.pointer_texcoord3f[1] = rsurface_vertex3f;
1354                 m.texmatrix[1] = r_shadow_entitytoattenuationz;
1355                 m.tex[2] = R_GetTexture(basetexture);
1356                 m.pointer_texcoord[2] = surface->groupmesh->data_texcoordtexture2f;
1357                 m.texmatrix[2] = texture->currenttexmatrix;
1358                 GL_BlendFunc(GL_ONE, GL_ONE);
1359         }
1360         else
1361         {
1362                 // 2/2/2 2D combine path (any dot3 card)
1363                 memset(&m, 0, sizeof(m));
1364                 m.pointer_vertex = rsurface_vertex3f;
1365                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1366                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1367                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1368                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1369                 m.pointer_texcoord3f[1] = rsurface_vertex3f;
1370                 m.texmatrix[1] = r_shadow_entitytoattenuationz;
1371                 R_Mesh_State(&m);
1372                 GL_ColorMask(0,0,0,1);
1373                 GL_BlendFunc(GL_ONE, GL_ZERO);
1374                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1375                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1376                 GL_LockArrays(0, 0);
1377
1378                 memset(&m, 0, sizeof(m));
1379                 m.pointer_vertex = rsurface_vertex3f;
1380                 m.tex[0] = R_GetTexture(basetexture);
1381                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1382                 m.texmatrix[0] = texture->currenttexmatrix;
1383                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1384                 {
1385                         m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1386                         m.pointer_texcoord3f[1] = rsurface_vertex3f;
1387                         m.texmatrix[1] = r_shadow_entitytolight;
1388                 }
1389                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1390         }
1391         // this final code is shared
1392         R_Mesh_State(&m);
1393         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
1394         VectorScale(lightcolorbase, colorscale, color2);
1395         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1396         for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
1397         {
1398                 GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
1399                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1400         }
1401         GL_LockArrays(0, 0);
1402 }
1403
1404 static void R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t lightcolorbase, rtexture_t *basetexture, rtexture_t *normalmaptexture, float colorscale)
1405 {
1406         int renders;
1407         float color2[3];
1408         rmeshstate_t m;
1409         const int *elements = surface->groupmesh->data_element3i + surface->num_firsttriangle * 3;
1410         GL_Color(1,1,1,1);
1411         // colorscale accounts for how much we multiply the brightness
1412         // during combine.
1413         //
1414         // mult is how many times the final pass of the lighting will be
1415         // performed to get more brightness than otherwise possible.
1416         //
1417         // Limit mult to 64 for sanity sake.
1418         if (r_shadow_texture3d.integer && r_textureunits.integer >= 4)
1419         {
1420                 // 3/2 3D combine path (Geforce3, Radeon 8500)
1421                 memset(&m, 0, sizeof(m));
1422                 m.pointer_vertex = rsurface_vertex3f;
1423                 m.tex[0] = R_GetTexture(normalmaptexture);
1424                 m.texcombinergb[0] = GL_REPLACE;
1425                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1426                 m.texmatrix[0] = texture->currenttexmatrix;
1427                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1428                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1429                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1430                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin);
1431                 m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture);
1432                 m.pointer_texcoord3f[2] = rsurface_vertex3f;
1433                 m.texmatrix[2] = r_shadow_entitytoattenuationxyz;
1434                 R_Mesh_State(&m);
1435                 GL_ColorMask(0,0,0,1);
1436                 GL_BlendFunc(GL_ONE, GL_ZERO);
1437                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1438                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1439                 GL_LockArrays(0, 0);
1440
1441                 memset(&m, 0, sizeof(m));
1442                 m.pointer_vertex = rsurface_vertex3f;
1443                 m.tex[0] = R_GetTexture(basetexture);
1444                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1445                 m.texmatrix[0] = texture->currenttexmatrix;
1446                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1447                 {
1448                         m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1449                         m.pointer_texcoord3f[1] = rsurface_vertex3f;
1450                         m.texmatrix[1] = r_shadow_entitytolight;
1451                 }
1452                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1453         }
1454         else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1455         {
1456                 // 1/2/2 3D combine path (original Radeon)
1457                 memset(&m, 0, sizeof(m));
1458                 m.pointer_vertex = rsurface_vertex3f;
1459                 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1460                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1461                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1462                 R_Mesh_State(&m);
1463                 GL_ColorMask(0,0,0,1);
1464                 GL_BlendFunc(GL_ONE, GL_ZERO);
1465                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1466                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1467                 GL_LockArrays(0, 0);
1468
1469                 memset(&m, 0, sizeof(m));
1470                 m.pointer_vertex = rsurface_vertex3f;
1471                 m.tex[0] = R_GetTexture(normalmaptexture);
1472                 m.texcombinergb[0] = GL_REPLACE;
1473                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1474                 m.texmatrix[0] = texture->currenttexmatrix;
1475                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1476                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1477                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1478                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin);
1479                 R_Mesh_State(&m);
1480                 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
1481                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1482                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1483                 GL_LockArrays(0, 0);
1484
1485                 memset(&m, 0, sizeof(m));
1486                 m.pointer_vertex = rsurface_vertex3f;
1487                 m.tex[0] = R_GetTexture(basetexture);
1488                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1489                 m.texmatrix[0] = texture->currenttexmatrix;
1490                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1491                 {
1492                         m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1493                         m.pointer_texcoord3f[1] = rsurface_vertex3f;
1494                         m.texmatrix[1] = r_shadow_entitytolight;
1495                 }
1496                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1497         }
1498         else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap == r_texture_whitecube)
1499         {
1500                 // 2/2 3D combine path (original Radeon)
1501                 memset(&m, 0, sizeof(m));
1502                 m.pointer_vertex = rsurface_vertex3f;
1503                 m.tex[0] = R_GetTexture(normalmaptexture);
1504                 m.texcombinergb[0] = GL_REPLACE;
1505                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1506                 m.texmatrix[0] = texture->currenttexmatrix;
1507                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1508                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1509                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1510                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin);
1511                 R_Mesh_State(&m);
1512                 GL_ColorMask(0,0,0,1);
1513                 GL_BlendFunc(GL_ONE, GL_ZERO);
1514                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1515                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1516                 GL_LockArrays(0, 0);
1517
1518                 memset(&m, 0, sizeof(m));
1519                 m.pointer_vertex = rsurface_vertex3f;
1520                 m.tex[0] = R_GetTexture(basetexture);
1521                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1522                 m.texmatrix[0] = texture->currenttexmatrix;
1523                 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
1524                 m.pointer_texcoord3f[1] = rsurface_vertex3f;
1525                 m.texmatrix[1] = r_shadow_entitytoattenuationxyz;
1526                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1527         }
1528         else if (r_textureunits.integer >= 4)
1529         {
1530                 // 4/2 2D combine path (Geforce3, Radeon 8500)
1531                 memset(&m, 0, sizeof(m));
1532                 m.pointer_vertex = rsurface_vertex3f;
1533                 m.tex[0] = R_GetTexture(normalmaptexture);
1534                 m.texcombinergb[0] = GL_REPLACE;
1535                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1536                 m.texmatrix[0] = texture->currenttexmatrix;
1537                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1538                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1539                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1540                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin);
1541                 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
1542                 m.pointer_texcoord3f[2] = rsurface_vertex3f;
1543                 m.texmatrix[2] = r_shadow_entitytoattenuationxyz;
1544                 m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture);
1545                 m.pointer_texcoord3f[3] = rsurface_vertex3f;
1546                 m.texmatrix[3] = r_shadow_entitytoattenuationz;
1547                 R_Mesh_State(&m);
1548                 GL_ColorMask(0,0,0,1);
1549                 GL_BlendFunc(GL_ONE, GL_ZERO);
1550                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1551                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1552                 GL_LockArrays(0, 0);
1553
1554                 memset(&m, 0, sizeof(m));
1555                 m.pointer_vertex = rsurface_vertex3f;
1556                 m.tex[0] = R_GetTexture(basetexture);
1557                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1558                 m.texmatrix[0] = texture->currenttexmatrix;
1559                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1560                 {
1561                         m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1562                         m.pointer_texcoord3f[1] = rsurface_vertex3f;
1563                         m.texmatrix[1] = r_shadow_entitytolight;
1564                 }
1565                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1566         }
1567         else
1568         {
1569                 // 2/2/2 2D combine path (any dot3 card)
1570                 memset(&m, 0, sizeof(m));
1571                 m.pointer_vertex = rsurface_vertex3f;
1572                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1573                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1574                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1575                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1576                 m.pointer_texcoord3f[1] = rsurface_vertex3f;
1577                 m.texmatrix[1] = r_shadow_entitytoattenuationz;
1578                 R_Mesh_State(&m);
1579                 GL_ColorMask(0,0,0,1);
1580                 GL_BlendFunc(GL_ONE, GL_ZERO);
1581                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1582                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1583                 GL_LockArrays(0, 0);
1584
1585                 memset(&m, 0, sizeof(m));
1586                 m.pointer_vertex = rsurface_vertex3f;
1587                 m.tex[0] = R_GetTexture(normalmaptexture);
1588                 m.texcombinergb[0] = GL_REPLACE;
1589                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1590                 m.texmatrix[0] = texture->currenttexmatrix;
1591                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1592                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1593                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1594                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin);
1595                 R_Mesh_State(&m);
1596                 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
1597                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1598                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1599                 GL_LockArrays(0, 0);
1600
1601                 memset(&m, 0, sizeof(m));
1602                 m.pointer_vertex = rsurface_vertex3f;
1603                 m.tex[0] = R_GetTexture(basetexture);
1604                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1605                 m.texmatrix[0] = texture->currenttexmatrix;
1606                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1607                 {
1608                         m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1609                         m.pointer_texcoord3f[1] = rsurface_vertex3f;
1610                         m.texmatrix[1] = r_shadow_entitytolight;
1611                 }
1612                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1613         }
1614         // this final code is shared
1615         R_Mesh_State(&m);
1616         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
1617         VectorScale(lightcolorbase, colorscale, color2);
1618         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1619         for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
1620         {
1621                 GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
1622                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1623         }
1624         GL_LockArrays(0, 0);
1625 }
1626
1627 static void R_Shadow_RenderSurfacesLighting_Light_Dot3_SpecularPass(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t lightcolorbase, rtexture_t *glosstexture, rtexture_t *normalmaptexture, float colorscale)
1628 {
1629         int renders;
1630         float color2[3];
1631         rmeshstate_t m;
1632         const int *elements = surface->groupmesh->data_element3i + surface->num_firsttriangle * 3;
1633         // FIXME: detect blendsquare!
1634         //if (!gl_support_blendsquare)
1635         //      return;
1636         GL_Color(1,1,1,1);
1637         if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap != r_texture_whitecube /* && gl_support_blendsquare*/) // FIXME: detect blendsquare!
1638         {
1639                 // 2/0/0/1/2 3D combine blendsquare path
1640                 memset(&m, 0, sizeof(m));
1641                 m.pointer_vertex = rsurface_vertex3f;
1642                 m.tex[0] = R_GetTexture(normalmaptexture);
1643                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1644                 m.texmatrix[0] = texture->currenttexmatrix;
1645                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1646                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1647                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1648                 R_Shadow_GenTexCoords_Specular_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin, r_shadow_entityeyeorigin);
1649                 R_Mesh_State(&m);
1650                 GL_ColorMask(0,0,0,1);
1651                 // this squares the result
1652                 GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
1653                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1654                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1655                 GL_LockArrays(0, 0);
1656
1657                 memset(&m, 0, sizeof(m));
1658                 m.pointer_vertex = rsurface_vertex3f;
1659                 R_Mesh_State(&m);
1660                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1661                 // square alpha in framebuffer a few times to make it shiny
1662                 GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
1663                 // these comments are a test run through this math for intensity 0.5
1664                 // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
1665                 // 0.25 * 0.25 = 0.0625 (this is another pass)
1666                 // 0.0625 * 0.0625 = 0.00390625 (this is another pass)
1667                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1668                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1669                 GL_LockArrays(0, 0);
1670
1671                 memset(&m, 0, sizeof(m));
1672                 m.pointer_vertex = rsurface_vertex3f;
1673                 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1674                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1675                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1676                 R_Mesh_State(&m);
1677                 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
1678                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1679                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1680                 GL_LockArrays(0, 0);
1681
1682                 memset(&m, 0, sizeof(m));
1683                 m.pointer_vertex = rsurface_vertex3f;
1684                 m.tex[0] = R_GetTexture(glosstexture);
1685                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1686                 m.texmatrix[0] = texture->currenttexmatrix;
1687                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1688                 {
1689                         m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1690                         m.pointer_texcoord3f[1] = rsurface_vertex3f;
1691                         m.texmatrix[1] = r_shadow_entitytolight;
1692                 }
1693                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1694         }
1695         else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap == r_texture_whitecube /* && gl_support_blendsquare*/) // FIXME: detect blendsquare!
1696         {
1697                 // 2/0/0/2 3D combine blendsquare path
1698                 memset(&m, 0, sizeof(m));
1699                 m.pointer_vertex = rsurface_vertex3f;
1700                 m.tex[0] = R_GetTexture(normalmaptexture);
1701                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1702                 m.texmatrix[0] = texture->currenttexmatrix;
1703                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1704                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1705                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1706                 R_Shadow_GenTexCoords_Specular_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin, r_shadow_entityeyeorigin);
1707                 R_Mesh_State(&m);
1708                 GL_ColorMask(0,0,0,1);
1709                 // this squares the result
1710                 GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
1711                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1712                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1713                 GL_LockArrays(0, 0);
1714
1715                 memset(&m, 0, sizeof(m));
1716                 m.pointer_vertex = rsurface_vertex3f;
1717                 R_Mesh_State(&m);
1718                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1719                 // square alpha in framebuffer a few times to make it shiny
1720                 GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
1721                 // these comments are a test run through this math for intensity 0.5
1722                 // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
1723                 // 0.25 * 0.25 = 0.0625 (this is another pass)
1724                 // 0.0625 * 0.0625 = 0.00390625 (this is another pass)
1725                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1726                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1727                 GL_LockArrays(0, 0);
1728
1729                 memset(&m, 0, sizeof(m));
1730                 m.pointer_vertex = rsurface_vertex3f;
1731                 m.tex[0] = R_GetTexture(glosstexture);
1732                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1733                 m.texmatrix[0] = texture->currenttexmatrix;
1734                 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
1735                 m.pointer_texcoord3f[1] = rsurface_vertex3f;
1736                 m.texmatrix[1] = r_shadow_entitytoattenuationxyz;
1737                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1738         }
1739         else
1740         {
1741                 // 2/0/0/2/2 2D combine blendsquare path
1742                 memset(&m, 0, sizeof(m));
1743                 m.pointer_vertex = rsurface_vertex3f;
1744                 m.tex[0] = R_GetTexture(normalmaptexture);
1745                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1746                 m.texmatrix[0] = texture->currenttexmatrix;
1747                 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1748                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1749                 m.pointer_texcoord3f[1] = rsurface_array_texcoord3f;
1750                 R_Shadow_GenTexCoords_Specular_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin, r_shadow_entityeyeorigin);
1751                 R_Mesh_State(&m);
1752                 GL_ColorMask(0,0,0,1);
1753                 // this squares the result
1754                 GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
1755                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1756                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1757                 GL_LockArrays(0, 0);
1758
1759                 memset(&m, 0, sizeof(m));
1760                 m.pointer_vertex = rsurface_vertex3f;
1761                 R_Mesh_State(&m);
1762                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1763                 // square alpha in framebuffer a few times to make it shiny
1764                 GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
1765                 // these comments are a test run through this math for intensity 0.5
1766                 // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
1767                 // 0.25 * 0.25 = 0.0625 (this is another pass)
1768                 // 0.0625 * 0.0625 = 0.00390625 (this is another pass)
1769                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1770                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1771                 GL_LockArrays(0, 0);
1772
1773                 memset(&m, 0, sizeof(m));
1774                 m.pointer_vertex = rsurface_vertex3f;
1775                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1776                 m.pointer_texcoord3f[0] = rsurface_vertex3f;
1777                 m.texmatrix[0] = r_shadow_entitytoattenuationxyz;
1778                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1779                 m.pointer_texcoord3f[1] = rsurface_vertex3f;
1780                 m.texmatrix[1] = r_shadow_entitytoattenuationz;
1781                 R_Mesh_State(&m);
1782                 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
1783                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1784                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1785                 GL_LockArrays(0, 0);
1786
1787                 memset(&m, 0, sizeof(m));
1788                 m.pointer_vertex = rsurface_vertex3f;
1789                 m.tex[0] = R_GetTexture(glosstexture);
1790                 m.pointer_texcoord[0] = surface->groupmesh->data_texcoordtexture2f;
1791                 m.texmatrix[0] = texture->currenttexmatrix;
1792                 if (r_shadow_rtlight->currentcubemap != r_texture_whitecube)
1793                 {
1794                         m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap);
1795                         m.pointer_texcoord3f[1] = rsurface_vertex3f;
1796                         m.texmatrix[1] = r_shadow_entitytolight;
1797                 }
1798                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1799         }
1800         R_Mesh_State(&m);
1801         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
1802         VectorScale(lightcolorbase, colorscale, color2);
1803         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1804         for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
1805         {
1806                 GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
1807                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1808         }
1809         GL_LockArrays(0, 0);
1810 }
1811
1812 static void R_Shadow_RenderSurfacesLighting_Light_Dot3(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt)
1813 {
1814         // ARB path (any Geforce, any Radeon)
1815         int surfacelistindex;
1816         qboolean doambient = r_shadow_rtlight->ambientscale > 0;
1817         qboolean dodiffuse = r_shadow_rtlight->diffusescale > 0;
1818         qboolean dospecular = specularscale > 0;
1819         if (!doambient && !dodiffuse && !dospecular)
1820                 return;
1821         for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
1822         {
1823                 const msurface_t *surface = surfacelist[surfacelistindex];
1824                 RSurf_SetVertexPointer(ent, texture, surface, r_shadow_entityeyeorigin, false, true);
1825                 if (doambient)
1826                         R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(ent, texture, surface, lightcolorbase, basetexture, r_shadow_rtlight->ambientscale);
1827                 if (dodiffuse)
1828                         R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(ent, texture, surface, lightcolorbase, basetexture, normalmaptexture, r_shadow_rtlight->diffusescale);
1829                 if (dopants)
1830                 {
1831                         if (doambient)
1832                                 R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(ent, texture, surface, lightcolorpants, pantstexture, r_shadow_rtlight->ambientscale);
1833                         if (dodiffuse)
1834                                 R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(ent, texture, surface, lightcolorpants, pantstexture, normalmaptexture, r_shadow_rtlight->diffusescale);
1835                 }
1836                 if (doshirt)
1837                 {
1838                         if (doambient)
1839                                 R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(ent, texture, surface, lightcolorshirt, shirttexture, r_shadow_rtlight->ambientscale);
1840                         if (dodiffuse)
1841                                 R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(ent, texture, surface, lightcolorshirt, shirttexture, normalmaptexture, r_shadow_rtlight->diffusescale);
1842                 }
1843                 if (dospecular)
1844                         R_Shadow_RenderSurfacesLighting_Light_Dot3_SpecularPass(ent, texture, surface, lightcolorbase, glosstexture, normalmaptexture, specularscale);
1845         }
1846 }
1847
1848 void R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(const msurface_t *surface, vec3_t diffusecolor2, vec3_t ambientcolor2)
1849 {
1850         int renders;
1851         const int *elements = surface->groupmesh->data_element3i + surface->num_firsttriangle * 3;
1852         R_Shadow_RenderSurfacesLighting_Light_Vertex_Shading(surface, diffusecolor2, ambientcolor2);
1853         for (renders = 0;renders < 64 && (ambientcolor2[0] > renders || ambientcolor2[1] > renders || ambientcolor2[2] > renders || diffusecolor2[0] > renders || diffusecolor2[1] > renders || diffusecolor2[2] > renders);renders++)
1854         {
1855                 int i;
1856                 float *c;
1857 #if 1
1858                 // due to low fillrate on the cards this vertex lighting path is
1859                 // designed for, we manually cull all triangles that do not
1860                 // contain a lit vertex
1861                 int draw;
1862                 const int *e;
1863                 int newnumtriangles;
1864                 int *newe;
1865                 int newelements[3072];
1866                 draw = false;
1867                 newnumtriangles = 0;
1868                 newe = newelements;
1869                 for (i = 0, e = elements;i < surface->num_triangles;i++, e += 3)
1870                 {
1871                         if (newnumtriangles >= 1024)
1872                         {
1873                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1874                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, newnumtriangles, newelements);
1875                                 GL_LockArrays(0, 0);
1876                                 newnumtriangles = 0;
1877                                 newe = newelements;
1878                         }
1879                         if (VectorLength2(rsurface_array_color4f + e[0] * 4) + VectorLength2(rsurface_array_color4f + e[1] * 4) + VectorLength2(rsurface_array_color4f + e[2] * 4) >= 0.01)
1880                         {
1881                                 newe[0] = e[0];
1882                                 newe[1] = e[1];
1883                                 newe[2] = e[2];
1884                                 newnumtriangles++;
1885                                 newe += 3;
1886                                 draw = true;
1887                         }
1888                 }
1889                 if (newnumtriangles >= 1)
1890                 {
1891                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1892                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, newnumtriangles, newelements);
1893                         GL_LockArrays(0, 0);
1894                         draw = true;
1895                 }
1896                 if (!draw)
1897                         break;
1898 #else
1899                 for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
1900                         if (VectorLength2(c))
1901                                 goto goodpass;
1902                 break;
1903 goodpass:
1904                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1905                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
1906                 GL_LockArrays(0, 0);
1907 #endif
1908                 // now reduce the intensity for the next overbright pass
1909                 for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
1910                 {
1911                         c[0] = max(0, c[0] - 1);
1912                         c[1] = max(0, c[1] - 1);
1913                         c[2] = max(0, c[2] - 1);
1914                 }
1915         }
1916 }
1917
1918 static void R_Shadow_RenderSurfacesLighting_Light_Vertex(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt)
1919 {
1920         int surfacelistindex;
1921         float ambientcolorbase[3], diffusecolorbase[3];
1922         float ambientcolorpants[3], diffusecolorpants[3];
1923         float ambientcolorshirt[3], diffusecolorshirt[3];
1924         rmeshstate_t m;
1925         VectorScale(lightcolorbase, r_shadow_rtlight->ambientscale * 2, ambientcolorbase);
1926         VectorScale(lightcolorbase, r_shadow_rtlight->diffusescale * 2, diffusecolorbase);
1927         VectorScale(lightcolorpants, r_shadow_rtlight->ambientscale * 2, ambientcolorpants);
1928         VectorScale(lightcolorpants, r_shadow_rtlight->diffusescale * 2, diffusecolorpants);
1929         VectorScale(lightcolorshirt, r_shadow_rtlight->ambientscale * 2, ambientcolorshirt);
1930         VectorScale(lightcolorshirt, r_shadow_rtlight->diffusescale * 2, diffusecolorshirt);
1931         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1932         memset(&m, 0, sizeof(m));
1933         m.tex[0] = R_GetTexture(basetexture);
1934         if (r_textureunits.integer >= 2)
1935         {
1936                 // voodoo2
1937                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1938                 m.texmatrix[1] = r_shadow_entitytoattenuationxyz;
1939                 if (r_textureunits.integer >= 3)
1940                 {
1941                         // Geforce3/Radeon class but not using dot3
1942                         m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
1943                         m.texmatrix[2] = r_shadow_entitytoattenuationz;
1944                 }
1945         }
1946         m.pointer_color = rsurface_array_color4f;
1947         R_Mesh_State(&m);
1948         for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
1949         {
1950                 const msurface_t *surface = surfacelist[surfacelistindex];
1951                 RSurf_SetVertexPointer(ent, texture, surface, r_shadow_entityeyeorigin, true, false);
1952                 // OpenGL 1.1 path (anything)
1953                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1954                 R_Mesh_TexMatrix(0, &texture->currenttexmatrix);
1955                 if (r_textureunits.integer >= 2)
1956                 {
1957                         // voodoo2 or TNT
1958                         R_Mesh_TexCoordPointer(1, 3, rsurface_vertex3f);
1959                         if (r_textureunits.integer >= 3)
1960                         {
1961                                 // Voodoo4 or Kyro (or Geforce3/Radeon with gl_combine off)
1962                                 R_Mesh_TexCoordPointer(2, 3, rsurface_vertex3f);
1963                         }
1964                 }
1965                 R_Mesh_TexBind(0, R_GetTexture(basetexture));
1966                 R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(surface, diffusecolorbase, ambientcolorbase);
1967                 if (dopants)
1968                 {
1969                         R_Mesh_TexBind(0, R_GetTexture(pantstexture));
1970                         R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(surface, diffusecolorpants, ambientcolorpants);
1971                 }
1972                 if (doshirt)
1973                 {
1974                         R_Mesh_TexBind(0, R_GetTexture(shirttexture));
1975                         R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(surface, diffusecolorshirt, ambientcolorshirt);
1976                 }
1977         }
1978 }
1979
1980 void R_Shadow_RenderSurfacesLighting(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist)
1981 {
1982         // FIXME: support MATERIALFLAG_NODEPTHTEST
1983         vec3_t lightcolorbase, lightcolorpants, lightcolorshirt;
1984         // calculate colors to render this texture with
1985         lightcolorbase[0] = r_shadow_rtlight->currentcolor[0] * ent->colormod[0] * texture->currentalpha;
1986         lightcolorbase[1] = r_shadow_rtlight->currentcolor[1] * ent->colormod[1] * texture->currentalpha;
1987         lightcolorbase[2] = r_shadow_rtlight->currentcolor[2] * ent->colormod[2] * texture->currentalpha;
1988         if ((r_shadow_rtlight->ambientscale + r_shadow_rtlight->diffusescale) * VectorLength2(lightcolorbase) + (r_shadow_rtlight->specularscale * texture->specularscale) * VectorLength2(lightcolorbase) < (1.0f / 1048576.0f))
1989                 return;
1990         if ((texture->textureflags & Q3TEXTUREFLAG_TWOSIDED) || (ent->flags & RENDER_NOCULLFACE))
1991                 qglDisable(GL_CULL_FACE);
1992         else
1993                 qglEnable(GL_CULL_FACE);
1994         if (texture->colormapping)
1995         {
1996                 qboolean dopants = texture->skin.pants != NULL && VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f);
1997                 qboolean doshirt = texture->skin.shirt != NULL && VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
1998                 if (dopants)
1999                 {
2000                         lightcolorpants[0] = lightcolorbase[0] * ent->colormap_pantscolor[0];
2001                         lightcolorpants[1] = lightcolorbase[1] * ent->colormap_pantscolor[1];
2002                         lightcolorpants[2] = lightcolorbase[2] * ent->colormap_pantscolor[2];
2003                 }
2004                 else
2005                         VectorClear(lightcolorpants);
2006                 if (doshirt)
2007                 {
2008                         lightcolorshirt[0] = lightcolorbase[0] * ent->colormap_shirtcolor[0];
2009                         lightcolorshirt[1] = lightcolorbase[1] * ent->colormap_shirtcolor[1];
2010                         lightcolorshirt[2] = lightcolorbase[2] * ent->colormap_shirtcolor[2];
2011                 }
2012                 else
2013                         VectorClear(lightcolorshirt);
2014                 switch (r_shadow_rendermode)
2015                 {
2016                 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2017                         R_Shadow_RenderSurfacesLighting_VisibleLighting(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt);
2018                         break;
2019                 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2020                         R_Shadow_RenderSurfacesLighting_Light_GLSL(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt);
2021                         break;
2022                 case R_SHADOW_RENDERMODE_LIGHT_DOT3:
2023                         R_Shadow_RenderSurfacesLighting_Light_Dot3(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt);
2024                         break;
2025                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2026                         R_Shadow_RenderSurfacesLighting_Light_Vertex(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt);
2027                         break;
2028                 default:
2029                         Con_Printf("R_Shadow_RenderSurfacesLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2030                         break;
2031                 }
2032         }
2033         else
2034         {
2035                 switch (r_shadow_rendermode)
2036                 {
2037                 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2038                         R_Shadow_RenderSurfacesLighting_VisibleLighting(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false);
2039                         break;
2040                 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2041                         R_Shadow_RenderSurfacesLighting_Light_GLSL(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false);
2042                         break;
2043                 case R_SHADOW_RENDERMODE_LIGHT_DOT3:
2044                         R_Shadow_RenderSurfacesLighting_Light_Dot3(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false);
2045                         break;
2046                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2047                         R_Shadow_RenderSurfacesLighting_Light_Vertex(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false);
2048                         break;
2049                 default:
2050                         Con_Printf("R_Shadow_RenderSurfacesLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2051                         break;
2052                 }
2053         }
2054 }
2055
2056 void R_RTLight_Update(dlight_t *light, int isstatic)
2057 {
2058         int j, k;
2059         float scale;
2060         rtlight_t *rtlight = &light->rtlight;
2061         R_RTLight_Uncompile(rtlight);
2062         memset(rtlight, 0, sizeof(*rtlight));
2063
2064         VectorCopy(light->origin, rtlight->shadoworigin);
2065         VectorCopy(light->color, rtlight->color);
2066         rtlight->radius = light->radius;
2067         //rtlight->cullradius = rtlight->radius;
2068         //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
2069         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
2070         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
2071         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
2072         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
2073         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
2074         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
2075         rtlight->cubemapname[0] = 0;
2076         if (light->cubemapname[0])
2077                 strcpy(rtlight->cubemapname, light->cubemapname);
2078         else if (light->cubemapnum > 0)
2079                 sprintf(rtlight->cubemapname, "cubemaps/%i", light->cubemapnum);
2080         rtlight->shadow = light->shadow;
2081         rtlight->corona = light->corona;
2082         rtlight->style = light->style;
2083         rtlight->isstatic = isstatic;
2084         rtlight->coronasizescale = light->coronasizescale;
2085         rtlight->ambientscale = light->ambientscale;
2086         rtlight->diffusescale = light->diffusescale;
2087         rtlight->specularscale = light->specularscale;
2088         rtlight->flags = light->flags;
2089         Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &light->matrix);
2090         // ConcatScale won't work here because this needs to scale rotate and
2091         // translate, not just rotate
2092         scale = 1.0f / rtlight->radius;
2093         for (k = 0;k < 3;k++)
2094                 for (j = 0;j < 4;j++)
2095                         rtlight->matrix_worldtolight.m[k][j] *= scale;
2096 }
2097
2098 // compiles rtlight geometry
2099 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
2100 void R_RTLight_Compile(rtlight_t *rtlight)
2101 {
2102         int shadowmeshes, shadowtris, numleafs, numleafpvsbytes, numsurfaces;
2103         entity_render_t *ent = r_refdef.worldentity;
2104         model_t *model = r_refdef.worldmodel;
2105         unsigned char *data;
2106
2107         // compile the light
2108         rtlight->compiled = true;
2109         rtlight->static_numleafs = 0;
2110         rtlight->static_numleafpvsbytes = 0;
2111         rtlight->static_leaflist = NULL;
2112         rtlight->static_leafpvs = NULL;
2113         rtlight->static_numsurfaces = 0;
2114         rtlight->static_surfacelist = NULL;
2115         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
2116         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
2117         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
2118         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
2119         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
2120         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
2121
2122         if (model && model->GetLightInfo)
2123         {
2124                 // this variable must be set for the CompileShadowVolume code
2125                 r_shadow_compilingrtlight = rtlight;
2126                 R_Shadow_EnlargeLeafSurfaceBuffer(model->brush.num_leafs, model->num_surfaces);
2127                 model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
2128                 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
2129                 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numleafs + numleafpvsbytes + sizeof(int) * numsurfaces);
2130                 rtlight->static_numleafs = numleafs;
2131                 rtlight->static_numleafpvsbytes = numleafpvsbytes;
2132                 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
2133                 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
2134                 rtlight->static_numsurfaces = numsurfaces;
2135                 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
2136                 if (numleafs)
2137                         memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
2138                 if (numleafpvsbytes)
2139                         memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
2140                 if (numsurfaces)
2141                         memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
2142                 if (model->CompileShadowVolume && rtlight->shadow)
2143                         model->CompileShadowVolume(ent, rtlight->shadoworigin, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
2144                 // now we're done compiling the rtlight
2145                 r_shadow_compilingrtlight = NULL;
2146         }
2147
2148
2149         // use smallest available cullradius - box radius or light radius
2150         //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
2151         //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
2152
2153         shadowmeshes = 0;
2154         shadowtris = 0;
2155         if (rtlight->static_meshchain_shadow)
2156         {
2157                 shadowmesh_t *mesh;
2158                 for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next)
2159                 {
2160                         shadowmeshes++;
2161                         shadowtris += mesh->numtriangles;
2162                 }
2163         }
2164
2165         if (developer.integer >= 10)
2166                 Con_Printf("static light built: %f %f %f : %f %f %f box, %i shadow volume triangles (in %i meshes)\n", rtlight->cullmins[0], rtlight->cullmins[1], rtlight->cullmins[2], rtlight->cullmaxs[0], rtlight->cullmaxs[1], rtlight->cullmaxs[2], shadowtris, shadowmeshes);
2167 }
2168
2169 void R_RTLight_Uncompile(rtlight_t *rtlight)
2170 {
2171         if (rtlight->compiled)
2172         {
2173                 if (rtlight->static_meshchain_shadow)
2174                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow);
2175                 rtlight->static_meshchain_shadow = NULL;
2176                 // these allocations are grouped
2177                 if (rtlight->static_leaflist)
2178                         Mem_Free(rtlight->static_leaflist);
2179                 rtlight->static_numleafs = 0;
2180                 rtlight->static_numleafpvsbytes = 0;
2181                 rtlight->static_leaflist = NULL;
2182                 rtlight->static_leafpvs = NULL;
2183                 rtlight->static_numsurfaces = 0;
2184                 rtlight->static_surfacelist = NULL;
2185                 rtlight->compiled = false;
2186         }
2187 }
2188
2189 void R_Shadow_UncompileWorldLights(void)
2190 {
2191         dlight_t *light;
2192         for (light = r_shadow_worldlightchain;light;light = light->next)
2193                 R_RTLight_Uncompile(&light->rtlight);
2194 }
2195
2196 void R_Shadow_DrawEntityShadow(entity_render_t *ent, int numsurfaces, int *surfacelist)
2197 {
2198         vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
2199         vec_t relativeshadowradius;
2200         if (ent == r_refdef.worldentity)
2201         {
2202                 if (r_shadow_rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
2203                 {
2204                         shadowmesh_t *mesh;
2205                         R_Mesh_Matrix(&ent->matrix);
2206                         for (mesh = r_shadow_rtlight->static_meshchain_shadow;mesh;mesh = mesh->next)
2207                         {
2208                                 renderstats.lights_shadowtriangles += mesh->numtriangles;
2209                                 R_Mesh_VertexPointer(mesh->vertex3f);
2210                                 GL_LockArrays(0, mesh->numverts);
2211                                 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCIL)
2212                                 {
2213                                         // decrement stencil if backface is behind depthbuffer
2214                                         qglCullFace(GL_BACK); // quake is backwards, this culls front faces
2215                                         qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
2216                                         R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i);
2217                                         // increment stencil if frontface is behind depthbuffer
2218                                         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
2219                                         qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
2220                                 }
2221                                 R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i);
2222                                 GL_LockArrays(0, 0);
2223                         }
2224                 }
2225                 else if (numsurfaces)
2226                 {
2227                         R_Mesh_Matrix(&ent->matrix);
2228                         ent->model->DrawShadowVolume(ent, r_shadow_rtlight->shadoworigin, r_shadow_rtlight->radius, numsurfaces, surfacelist, r_shadow_rtlight->cullmins, r_shadow_rtlight->cullmaxs);
2229                 }
2230         }
2231         else
2232         {
2233                 Matrix4x4_Transform(&ent->inversematrix, r_shadow_rtlight->shadoworigin, relativeshadoworigin);
2234                 relativeshadowradius = r_shadow_rtlight->radius / ent->scale;
2235                 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
2236                 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
2237                 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
2238                 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
2239                 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
2240                 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
2241                 R_Mesh_Matrix(&ent->matrix);
2242                 ent->model->DrawShadowVolume(ent, relativeshadoworigin, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->surfacelist, relativeshadowmins, relativeshadowmaxs);
2243         }
2244 }
2245
2246 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
2247 {
2248         // set up properties for rendering light onto this entity
2249         Matrix4x4_Concat(&r_shadow_entitytolight, &r_shadow_rtlight->matrix_worldtolight, &ent->matrix);
2250         Matrix4x4_Concat(&r_shadow_entitytoattenuationxyz, &matrix_attenuationxyz, &r_shadow_entitytolight);
2251         Matrix4x4_Concat(&r_shadow_entitytoattenuationz, &matrix_attenuationz, &r_shadow_entitytolight);
2252         Matrix4x4_Transform(&ent->inversematrix, r_shadow_rtlight->shadoworigin, r_shadow_entitylightorigin);
2253         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, r_shadow_entityeyeorigin);
2254         R_Mesh_Matrix(&ent->matrix);
2255 }
2256
2257 void R_Shadow_DrawEntityLight(entity_render_t *ent, int numsurfaces, int *surfacelist)
2258 {
2259         if (!ent->model->DrawLight)
2260                 return;
2261         R_Shadow_SetupEntityLight(ent);
2262         if (ent == r_refdef.worldentity)
2263                 ent->model->DrawLight(ent, numsurfaces, surfacelist);
2264         else
2265                 ent->model->DrawLight(ent, ent->model->nummodelsurfaces, ent->model->surfacelist);
2266 }
2267
2268 void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
2269 {
2270         int i, usestencil;
2271         float f;
2272         int numleafs, numsurfaces;
2273         int *leaflist, *surfacelist;
2274         unsigned char *leafpvs;
2275         int numlightentities;
2276         int numshadowentities;
2277         entity_render_t *lightentities[MAX_EDICTS];
2278         entity_render_t *shadowentities[MAX_EDICTS];
2279
2280         // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
2281         // skip lights that are basically invisible (color 0 0 0)
2282         if (VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f))
2283                 return;
2284
2285         // loading is done before visibility checks because loading should happen
2286         // all at once at the start of a level, not when it stalls gameplay.
2287         // (especially important to benchmarks)
2288         // compile light
2289         if (rtlight->isstatic && !rtlight->compiled && r_shadow_realtime_world_compile.integer)
2290                 R_RTLight_Compile(rtlight);
2291         // load cubemap
2292         rtlight->currentcubemap = rtlight->cubemapname[0] ? R_Shadow_Cubemap(rtlight->cubemapname) : r_texture_whitecube;
2293
2294         // look up the light style value at this time
2295         f = (rtlight->style >= 0 ? r_refdef.lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f) * r_shadow_lightintensityscale.value;
2296         VectorScale(rtlight->color, f, rtlight->currentcolor);
2297         /*
2298         if (rtlight->selected)
2299         {
2300                 f = 2 + sin(realtime * M_PI * 4.0);
2301                 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
2302         }
2303         */
2304
2305         // if lightstyle is currently off, don't draw the light
2306         if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
2307                 return;
2308
2309         // if the light box is offscreen, skip it
2310         if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
2311                 return;
2312
2313         if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
2314         {
2315                 // compiled light, world available and can receive realtime lighting
2316                 // retrieve leaf information
2317                 numleafs = rtlight->static_numleafs;
2318                 leaflist = rtlight->static_leaflist;
2319                 leafpvs = rtlight->static_leafpvs;
2320                 numsurfaces = rtlight->static_numsurfaces;
2321                 surfacelist = rtlight->static_surfacelist;
2322         }
2323         else if (r_refdef.worldmodel && r_refdef.worldmodel->GetLightInfo)
2324         {
2325                 // dynamic light, world available and can receive realtime lighting
2326                 // calculate lit surfaces and leafs
2327                 R_Shadow_EnlargeLeafSurfaceBuffer(r_refdef.worldmodel->brush.num_leafs, r_refdef.worldmodel->num_surfaces);
2328                 r_refdef.worldmodel->GetLightInfo(r_refdef.worldentity, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
2329                 leaflist = r_shadow_buffer_leaflist;
2330                 leafpvs = r_shadow_buffer_leafpvs;
2331                 surfacelist = r_shadow_buffer_surfacelist;
2332                 // if the reduced leaf bounds are offscreen, skip it
2333                 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
2334                         return;
2335         }
2336         else
2337         {
2338                 // no world
2339                 numleafs = 0;
2340                 leaflist = NULL;
2341                 leafpvs = NULL;
2342                 numsurfaces = 0;
2343                 surfacelist = NULL;
2344         }
2345         // check if light is illuminating any visible leafs
2346         if (numleafs)
2347         {
2348                 for (i = 0;i < numleafs;i++)
2349                         if (r_worldleafvisible[leaflist[i]])
2350                                 break;
2351                 if (i == numleafs)
2352                         return;
2353         }
2354         // set up a scissor rectangle for this light
2355         if (R_Shadow_ScissorForBBox(rtlight->cullmins, rtlight->cullmaxs))
2356                 return;
2357
2358         // make a list of lit entities and shadow casting entities
2359         numlightentities = 0;
2360         numshadowentities = 0;
2361         // don't count the world unless some surfaces are actually lit
2362         if (numsurfaces)
2363         {
2364                 lightentities[numlightentities++] = r_refdef.worldentity;
2365                 shadowentities[numshadowentities++] = r_refdef.worldentity;
2366         }
2367         // add dynamic entities that are lit by the light
2368         if (r_drawentities.integer)
2369         {
2370                 for (i = 0;i < r_refdef.numentities;i++)
2371                 {
2372                         entity_render_t *ent = r_refdef.entities[i];
2373                         if (BoxesOverlap(ent->mins, ent->maxs, rtlight->cullmins, rtlight->cullmaxs)
2374                          && ent->model
2375                          && !(ent->flags & RENDER_TRANSPARENT)
2376                          && (r_refdef.worldmodel == NULL || r_refdef.worldmodel->brush.BoxTouchingLeafPVS == NULL || r_refdef.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.worldmodel, leafpvs, ent->mins, ent->maxs)))
2377                         {
2378                                 // about the VectorDistance2 - light emitting entities should not cast their own shadow
2379                                 if ((ent->flags & RENDER_SHADOW) && ent->model->DrawShadowVolume && VectorDistance2(ent->origin, rtlight->shadoworigin) > 0.1)
2380                                         shadowentities[numshadowentities++] = ent;
2381                                 if (ent->visframe == r_framecount && (ent->flags & RENDER_LIGHT) && ent->model->DrawLight)
2382                                         lightentities[numlightentities++] = ent;
2383                         }
2384                 }
2385         }
2386
2387         // return if there's nothing at all to light
2388         if (!numlightentities)
2389                 return;
2390
2391         // don't let sound skip if going slow
2392         if (r_refdef.extraupdate)
2393                 S_ExtraUpdate ();
2394
2395         // make this the active rtlight for rendering purposes
2396         R_Shadow_RenderMode_ActiveLight(rtlight);
2397         // count this light in the r_speeds
2398         renderstats.lights++;
2399
2400         usestencil = false;
2401         if (numshadowentities && rtlight->shadow && (rtlight->isstatic ? r_rtworldshadows : r_rtdlightshadows))
2402         {
2403                 // draw stencil shadow volumes to mask off pixels that are in shadow
2404                 // so that they won't receive lighting
2405                 if (gl_stencil)
2406                 {
2407                         usestencil = true;
2408                         R_Shadow_RenderMode_StencilShadowVolumes();
2409                         for (i = 0;i < numshadowentities;i++)
2410                                 R_Shadow_DrawEntityShadow(shadowentities[i], numsurfaces, surfacelist);
2411                 }
2412
2413                 // optionally draw visible shape of the shadow volumes
2414                 // for performance analysis by level designers
2415                 if (r_showshadowvolumes.integer)
2416                 {
2417                         R_Shadow_RenderMode_VisibleShadowVolumes();
2418                         for (i = 0;i < numshadowentities;i++)
2419                                 R_Shadow_DrawEntityShadow(shadowentities[i], numsurfaces, surfacelist);
2420                 }
2421         }
2422
2423         if (numlightentities)
2424         {
2425                 // draw lighting in the unmasked areas
2426                 R_Shadow_RenderMode_Lighting(usestencil, false);
2427                 for (i = 0;i < numlightentities;i++)
2428                         R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist);
2429
2430                 // optionally draw the illuminated areas
2431                 // for performance analysis by level designers
2432                 if (r_showlighting.integer)
2433                 {
2434                         R_Shadow_RenderMode_VisibleLighting(usestencil && !r_showdisabledepthtest.integer, false);
2435                         for (i = 0;i < numlightentities;i++)
2436                                 R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist);
2437                 }
2438         }
2439 }
2440
2441 void R_ShadowVolumeLighting(qboolean visible)
2442 {
2443         int lnum, flag;
2444         dlight_t *light;
2445
2446         if (r_refdef.worldmodel && strncmp(r_refdef.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
2447                 R_Shadow_EditLights_Reload_f();
2448
2449         R_Shadow_RenderMode_Begin();
2450
2451         flag = r_rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2452         if (r_shadow_debuglight.integer >= 0)
2453         {
2454                 for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next)
2455                         if (lnum == r_shadow_debuglight.integer && (light->flags & flag))
2456                                 R_DrawRTLight(&light->rtlight, visible);
2457         }
2458         else
2459                 for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next)
2460                         if (light->flags & flag)
2461                                 R_DrawRTLight(&light->rtlight, visible);
2462         if (r_rtdlight)
2463                 for (lnum = 0;lnum < r_refdef.numlights;lnum++)
2464                         R_DrawRTLight(&r_refdef.lights[lnum]->rtlight, visible);
2465
2466         R_Shadow_RenderMode_End();
2467 }
2468
2469 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
2470 typedef struct suffixinfo_s
2471 {
2472         char *suffix;
2473         qboolean flipx, flipy, flipdiagonal;
2474 }
2475 suffixinfo_t;
2476 static suffixinfo_t suffix[3][6] =
2477 {
2478         {
2479                 {"px",   false, false, false},
2480                 {"nx",   false, false, false},
2481                 {"py",   false, false, false},
2482                 {"ny",   false, false, false},
2483                 {"pz",   false, false, false},
2484                 {"nz",   false, false, false}
2485         },
2486         {
2487                 {"posx", false, false, false},
2488                 {"negx", false, false, false},
2489                 {"posy", false, false, false},
2490                 {"negy", false, false, false},
2491                 {"posz", false, false, false},
2492                 {"negz", false, false, false}
2493         },
2494         {
2495                 {"rt",    true, false,  true},
2496                 {"lf",   false,  true,  true},
2497                 {"ft",    true,  true, false},
2498                 {"bk",   false, false, false},
2499                 {"up",    true, false,  true},
2500                 {"dn",    true, false,  true}
2501         }
2502 };
2503
2504 static int componentorder[4] = {0, 1, 2, 3};
2505
2506 rtexture_t *R_Shadow_LoadCubemap(const char *basename)
2507 {
2508         int i, j, cubemapsize;
2509         unsigned char *cubemappixels, *image_rgba;
2510         rtexture_t *cubemaptexture;
2511         char name[256];
2512         // must start 0 so the first loadimagepixels has no requested width/height
2513         cubemapsize = 0;
2514         cubemappixels = NULL;
2515         cubemaptexture = NULL;
2516         // keep trying different suffix groups (posx, px, rt) until one loads
2517         for (j = 0;j < 3 && !cubemappixels;j++)
2518         {
2519                 // load the 6 images in the suffix group
2520                 for (i = 0;i < 6;i++)
2521                 {
2522                         // generate an image name based on the base and and suffix
2523                         dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
2524                         // load it
2525                         if ((image_rgba = loadimagepixels(name, false, cubemapsize, cubemapsize)))
2526                         {
2527                                 // an image loaded, make sure width and height are equal
2528                                 if (image_width == image_height)
2529                                 {
2530                                         // if this is the first image to load successfully, allocate the cubemap memory
2531                                         if (!cubemappixels && image_width >= 1)
2532                                         {
2533                                                 cubemapsize = image_width;
2534                                                 // note this clears to black, so unavailable sides are black
2535                                                 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
2536                                         }
2537                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
2538                                         if (cubemappixels)
2539                                                 Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_rgba, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder);
2540                                 }
2541                                 else
2542                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
2543                                 // free the image
2544                                 Mem_Free(image_rgba);
2545                         }
2546                 }
2547         }
2548         // if a cubemap loaded, upload it
2549         if (cubemappixels)
2550         {
2551                 if (!r_shadow_filters_texturepool)
2552                         r_shadow_filters_texturepool = R_AllocTexturePool();
2553                 cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
2554                 Mem_Free(cubemappixels);
2555         }
2556         else
2557         {
2558                 Con_Printf("Failed to load Cubemap \"%s\", tried ", basename);
2559                 for (j = 0;j < 3;j++)
2560                         for (i = 0;i < 6;i++)
2561                                 Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
2562                 Con_Print(" and was unable to find any of them.\n");
2563         }
2564         return cubemaptexture;
2565 }
2566
2567 rtexture_t *R_Shadow_Cubemap(const char *basename)
2568 {
2569         int i;
2570         for (i = 0;i < numcubemaps;i++)
2571                 if (!strcasecmp(cubemaps[i].basename, basename))
2572                         return cubemaps[i].texture;
2573         if (i >= MAX_CUBEMAPS)
2574                 return r_texture_whitecube;
2575         numcubemaps++;
2576         strcpy(cubemaps[i].basename, basename);
2577         cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename);
2578         if (!cubemaps[i].texture)
2579                 cubemaps[i].texture = r_texture_whitecube;
2580         return cubemaps[i].texture;
2581 }
2582
2583 void R_Shadow_FreeCubemaps(void)
2584 {
2585         numcubemaps = 0;
2586         R_FreeTexturePool(&r_shadow_filters_texturepool);
2587 }
2588
2589 dlight_t *R_Shadow_NewWorldLight(void)
2590 {
2591         dlight_t *light;
2592         light = (dlight_t *)Mem_Alloc(r_main_mempool, sizeof(dlight_t));
2593         light->next = r_shadow_worldlightchain;
2594         r_shadow_worldlightchain = light;
2595         return light;
2596 }
2597
2598 void R_Shadow_UpdateWorldLight(dlight_t *light, vec3_t origin, vec3_t angles, vec3_t color, vec_t radius, vec_t corona, int style, int shadowenable, const char *cubemapname, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags)
2599 {
2600         VectorCopy(origin, light->origin);
2601         light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
2602         light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
2603         light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
2604         light->color[0] = max(color[0], 0);
2605         light->color[1] = max(color[1], 0);
2606         light->color[2] = max(color[2], 0);
2607         light->radius = max(radius, 0);
2608         light->style = style;
2609         if (light->style < 0 || light->style >= MAX_LIGHTSTYLES)
2610         {
2611                 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
2612                 light->style = 0;
2613         }
2614         light->shadow = shadowenable;
2615         light->corona = corona;
2616         if (!cubemapname)
2617                 cubemapname = "";
2618         strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
2619         light->coronasizescale = coronasizescale;
2620         light->ambientscale = ambientscale;
2621         light->diffusescale = diffusescale;
2622         light->specularscale = specularscale;
2623         light->flags = flags;
2624         Matrix4x4_CreateFromQuakeEntity(&light->matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], 1);
2625
2626         R_RTLight_Update(light, true);
2627 }
2628
2629 void R_Shadow_FreeWorldLight(dlight_t *light)
2630 {
2631         dlight_t **lightpointer;
2632         R_RTLight_Uncompile(&light->rtlight);
2633         for (lightpointer = &r_shadow_worldlightchain;*lightpointer && *lightpointer != light;lightpointer = &(*lightpointer)->next);
2634         if (*lightpointer != light)
2635                 Sys_Error("R_Shadow_FreeWorldLight: light not linked into chain");
2636         *lightpointer = light->next;
2637         Mem_Free(light);
2638 }
2639
2640 void R_Shadow_ClearWorldLights(void)
2641 {
2642         while (r_shadow_worldlightchain)
2643                 R_Shadow_FreeWorldLight(r_shadow_worldlightchain);
2644         r_shadow_selectedlight = NULL;
2645         R_Shadow_FreeCubemaps();
2646 }
2647
2648 void R_Shadow_SelectLight(dlight_t *light)
2649 {
2650         if (r_shadow_selectedlight)
2651                 r_shadow_selectedlight->selected = false;
2652         r_shadow_selectedlight = light;
2653         if (r_shadow_selectedlight)
2654                 r_shadow_selectedlight->selected = true;
2655 }
2656
2657 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight)
2658 {
2659         float scale = r_editlights_cursorgrid.value * 0.5f;
2660         R_DrawSprite(GL_SRC_ALPHA, GL_ONE, r_crosshairs[1]->tex, NULL, false, r_editlights_cursorlocation, r_viewright, r_viewup, scale, -scale, -scale, scale, 1, 1, 1, 0.5f);
2661 }
2662
2663 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight)
2664 {
2665         float intensity;
2666         const dlight_t *light = (dlight_t *)ent;
2667         intensity = 0.5;
2668         if (light->selected)
2669                 intensity = 0.75 + 0.25 * sin(realtime * M_PI * 4.0);
2670         if (!light->shadow)
2671                 intensity *= 0.5f;
2672         R_DrawSprite(GL_SRC_ALPHA, GL_ONE, r_crosshairs[surfacenumber]->tex, NULL, false, light->origin, r_viewright, r_viewup, 8, -8, -8, 8, intensity, intensity, intensity, 0.5);
2673 }
2674
2675 void R_Shadow_DrawLightSprites(void)
2676 {
2677         int i;
2678         dlight_t *light;
2679
2680         for (i = 0, light = r_shadow_worldlightchain;light;i++, light = light->next)
2681                 R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 1+(i % 5), &light->rtlight);
2682         R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
2683 }
2684
2685 void R_Shadow_SelectLightInView(void)
2686 {
2687         float bestrating, rating, temp[3];
2688         dlight_t *best, *light;
2689         best = NULL;
2690         bestrating = 0;
2691         for (light = r_shadow_worldlightchain;light;light = light->next)
2692         {
2693                 VectorSubtract(light->origin, r_vieworigin, temp);
2694                 rating = (DotProduct(temp, r_viewforward) / sqrt(DotProduct(temp, temp)));
2695                 if (rating >= 0.95)
2696                 {
2697                         rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
2698                         if (bestrating < rating && CL_TraceBox(light->origin, vec3_origin, vec3_origin, r_vieworigin, true, NULL, SUPERCONTENTS_SOLID, false).fraction == 1.0f)
2699                         {
2700                                 bestrating = rating;
2701                                 best = light;
2702                         }
2703                 }
2704         }
2705         R_Shadow_SelectLight(best);
2706 }
2707
2708 void R_Shadow_LoadWorldLights(void)
2709 {
2710         int n, a, style, shadow, flags;
2711         char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
2712         float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
2713         if (r_refdef.worldmodel == NULL)
2714         {
2715                 Con_Print("No map loaded.\n");
2716                 return;
2717         }
2718         FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
2719         strlcat (name, ".rtlights", sizeof (name));
2720         lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
2721         if (lightsstring)
2722         {
2723                 s = lightsstring;
2724                 n = 0;
2725                 while (*s)
2726                 {
2727                         t = s;
2728                         /*
2729                         shadow = true;
2730                         for (;COM_Parse(t, true) && strcmp(
2731                         if (COM_Parse(t, true))
2732                         {
2733                                 if (com_token[0] == '!')
2734                                 {
2735                                         shadow = false;
2736                                         origin[0] = atof(com_token+1);
2737                                 }
2738                                 else
2739                                         origin[0] = atof(com_token);
2740                                 if (Com_Parse(t
2741                         }
2742                         */
2743                         t = s;
2744                         while (*s && *s != '\n' && *s != '\r')
2745                                 s++;
2746                         if (!*s)
2747                                 break;
2748                         tempchar = *s;
2749                         shadow = true;
2750                         // check for modifier flags
2751                         if (*t == '!')
2752                         {
2753                                 shadow = false;
2754                                 t++;
2755                         }
2756                         *s = 0;
2757                         a = sscanf(t, "%f %f %f %f %f %f %f %d %s %f %f %f %f %f %f %f %f %i", &origin[0], &origin[1], &origin[2], &radius, &color[0], &color[1], &color[2], &style, cubemapname, &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
2758                         *s = tempchar;
2759                         if (a < 18)
2760                                 flags = LIGHTFLAG_REALTIMEMODE;
2761                         if (a < 17)
2762                                 specularscale = 1;
2763                         if (a < 16)
2764                                 diffusescale = 1;
2765                         if (a < 15)
2766                                 ambientscale = 0;
2767                         if (a < 14)
2768                                 coronasizescale = 0.25f;
2769                         if (a < 13)
2770                                 VectorClear(angles);
2771                         if (a < 10)
2772                                 corona = 0;
2773                         if (a < 9 || !strcmp(cubemapname, "\"\""))
2774                                 cubemapname[0] = 0;
2775                         // remove quotes on cubemapname
2776                         if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
2777                         {
2778                                 cubemapname[strlen(cubemapname)-1] = 0;
2779                                 strcpy(cubemapname, cubemapname + 1);
2780                         }
2781                         if (a < 8)
2782                         {
2783                                 Con_Printf("found %d parameters on line %i, should be 8 or more parameters (origin[0] origin[1] origin[2] radius color[0] color[1] color[2] style \"cubemapname\" corona angles[0] angles[1] angles[2] coronasizescale ambientscale diffusescale specularscale flags)\n", a, n + 1);
2784                                 break;
2785                         }
2786                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
2787                         if (*s == '\r')
2788                                 s++;
2789                         if (*s == '\n')
2790                                 s++;
2791                         n++;
2792                 }
2793                 if (*s)
2794                         Con_Printf("invalid rtlights file \"%s\"\n", name);
2795                 Mem_Free(lightsstring);
2796         }
2797 }
2798
2799 void R_Shadow_SaveWorldLights(void)
2800 {
2801         dlight_t *light;
2802         size_t bufchars, bufmaxchars;
2803         char *buf, *oldbuf;
2804         char name[MAX_QPATH];
2805         char line[MAX_INPUTLINE];
2806         if (!r_shadow_worldlightchain)
2807                 return;
2808         if (r_refdef.worldmodel == NULL)
2809         {
2810                 Con_Print("No map loaded.\n");
2811                 return;
2812         }
2813         FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
2814         strlcat (name, ".rtlights", sizeof (name));
2815         bufchars = bufmaxchars = 0;
2816         buf = NULL;
2817         for (light = r_shadow_worldlightchain;light;light = light->next)
2818         {
2819                 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
2820                         sprintf(line, "%s%f %f %f %f %f %f %f %d \"%s\" %f %f %f %f %f %f %f %f %i\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius, light->color[0], light->color[1], light->color[2], light->style, light->cubemapname, light->corona, light->angles[0], light->angles[1], light->angles[2], light->coronasizescale, light->ambientscale, light->diffusescale, light->specularscale, light->flags);
2821                 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
2822                         sprintf(line, "%s%f %f %f %f %f %f %f %d \"%s\" %f %f %f %f\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius, light->color[0], light->color[1], light->color[2], light->style, light->cubemapname, light->corona, light->angles[0], light->angles[1], light->angles[2]);
2823                 else
2824                         sprintf(line, "%s%f %f %f %f %f %f %f %d\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius, light->color[0], light->color[1], light->color[2], light->style);
2825                 if (bufchars + strlen(line) > bufmaxchars)
2826                 {
2827                         bufmaxchars = bufchars + strlen(line) + 2048;
2828                         oldbuf = buf;
2829                         buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
2830                         if (oldbuf)
2831                         {
2832                                 if (bufchars)
2833                                         memcpy(buf, oldbuf, bufchars);
2834                                 Mem_Free(oldbuf);
2835                         }
2836                 }
2837                 if (strlen(line))
2838                 {
2839                         memcpy(buf + bufchars, line, strlen(line));
2840                         bufchars += strlen(line);
2841                 }
2842         }
2843         if (bufchars)
2844                 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
2845         if (buf)
2846                 Mem_Free(buf);
2847 }
2848
2849 void R_Shadow_LoadLightsFile(void)
2850 {
2851         int n, a, style;
2852         char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
2853         float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
2854         if (r_refdef.worldmodel == NULL)
2855         {
2856                 Con_Print("No map loaded.\n");
2857                 return;
2858         }
2859         FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
2860         strlcat (name, ".lights", sizeof (name));
2861         lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
2862         if (lightsstring)
2863         {
2864                 s = lightsstring;
2865                 n = 0;
2866                 while (*s)
2867                 {
2868                         t = s;
2869                         while (*s && *s != '\n' && *s != '\r')
2870                                 s++;
2871                         if (!*s)
2872                                 break;
2873                         tempchar = *s;
2874                         *s = 0;
2875                         a = sscanf(t, "%f %f %f %f %f %f %f %f %f %f %f %f %f %d", &origin[0], &origin[1], &origin[2], &falloff, &color[0], &color[1], &color[2], &subtract, &spotdir[0], &spotdir[1], &spotdir[2], &spotcone, &distbias, &style);
2876                         *s = tempchar;
2877                         if (a < 14)
2878                         {
2879                                 Con_Printf("invalid lights file, found %d parameters on line %i, should be 14 parameters (origin[0] origin[1] origin[2] falloff light[0] light[1] light[2] subtract spotdir[0] spotdir[1] spotdir[2] spotcone distancebias style)\n", a, n + 1);
2880                                 break;
2881                         }
2882                         radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
2883                         radius = bound(15, radius, 4096);
2884                         VectorScale(color, (2.0f / (8388608.0f)), color);
2885                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
2886                         if (*s == '\r')
2887                                 s++;
2888                         if (*s == '\n')
2889                                 s++;
2890                         n++;
2891                 }
2892                 if (*s)
2893                         Con_Printf("invalid lights file \"%s\"\n", name);
2894                 Mem_Free(lightsstring);
2895         }
2896 }
2897
2898 // tyrlite/hmap2 light types in the delay field
2899 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
2900
2901 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
2902 {
2903         int entnum, style, islight, skin, pflags, effects, type, n;
2904         char *entfiledata;
2905         const char *data;
2906         float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
2907         char key[256], value[MAX_INPUTLINE];
2908
2909         if (r_refdef.worldmodel == NULL)
2910         {
2911                 Con_Print("No map loaded.\n");
2912                 return;
2913         }
2914         // try to load a .ent file first
2915         FS_StripExtension (r_refdef.worldmodel->name, key, sizeof (key));
2916         strlcat (key, ".ent", sizeof (key));
2917         data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
2918         // and if that is not found, fall back to the bsp file entity string
2919         if (!data)
2920                 data = r_refdef.worldmodel->brush.entities;
2921         if (!data)
2922                 return;
2923         for (entnum = 0;COM_ParseToken(&data, false) && com_token[0] == '{';entnum++)
2924         {
2925                 type = LIGHTTYPE_MINUSX;
2926                 origin[0] = origin[1] = origin[2] = 0;
2927                 originhack[0] = originhack[1] = originhack[2] = 0;
2928                 angles[0] = angles[1] = angles[2] = 0;
2929                 color[0] = color[1] = color[2] = 1;
2930                 light[0] = light[1] = light[2] = 1;light[3] = 300;
2931                 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
2932                 fadescale = 1;
2933                 lightscale = 1;
2934                 style = 0;
2935                 skin = 0;
2936                 pflags = 0;
2937                 effects = 0;
2938                 islight = false;
2939                 while (1)
2940                 {
2941                         if (!COM_ParseToken(&data, false))
2942                                 break; // error
2943                         if (com_token[0] == '}')
2944                                 break; // end of entity
2945                         if (com_token[0] == '_')
2946                                 strcpy(key, com_token + 1);
2947                         else
2948                                 strcpy(key, com_token);
2949                         while (key[strlen(key)-1] == ' ') // remove trailing spaces
2950                                 key[strlen(key)-1] = 0;
2951                         if (!COM_ParseToken(&data, false))
2952                                 break; // error
2953                         strcpy(value, com_token);
2954
2955                         // now that we have the key pair worked out...
2956                         if (!strcmp("light", key))
2957                         {
2958                                 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
2959                                 if (n == 1)
2960                                 {
2961                                         // quake
2962                                         light[0] = vec[0] * (1.0f / 256.0f);
2963                                         light[1] = vec[0] * (1.0f / 256.0f);
2964                                         light[2] = vec[0] * (1.0f / 256.0f);
2965                                         light[3] = vec[0];
2966                                 }
2967                                 else if (n == 4)
2968                                 {
2969                                         // halflife
2970                                         light[0] = vec[0] * (1.0f / 255.0f);
2971                                         light[1] = vec[1] * (1.0f / 255.0f);
2972                                         light[2] = vec[2] * (1.0f / 255.0f);
2973                                         light[3] = vec[3];
2974                                 }
2975                         }
2976                         else if (!strcmp("delay", key))
2977                                 type = atoi(value);
2978                         else if (!strcmp("origin", key))
2979                                 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
2980                         else if (!strcmp("angle", key))
2981                                 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
2982                         else if (!strcmp("angles", key))
2983                                 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
2984                         else if (!strcmp("color", key))
2985                                 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
2986                         else if (!strcmp("wait", key))
2987                                 fadescale = atof(value);
2988                         else if (!strcmp("classname", key))
2989                         {
2990                                 if (!strncmp(value, "light", 5))
2991                                 {
2992                                         islight = true;
2993                                         if (!strcmp(value, "light_fluoro"))
2994                                         {
2995                                                 originhack[0] = 0;
2996                                                 originhack[1] = 0;
2997                                                 originhack[2] = 0;
2998                                                 overridecolor[0] = 1;
2999                                                 overridecolor[1] = 1;
3000                                                 overridecolor[2] = 1;
3001                                         }
3002                                         if (!strcmp(value, "light_fluorospark"))
3003                                         {
3004                                                 originhack[0] = 0;
3005                                                 originhack[1] = 0;
3006                                                 originhack[2] = 0;
3007                                                 overridecolor[0] = 1;
3008                                                 overridecolor[1] = 1;
3009                                                 overridecolor[2] = 1;
3010                                         }
3011                                         if (!strcmp(value, "light_globe"))
3012                                         {
3013                                                 originhack[0] = 0;
3014                                                 originhack[1] = 0;
3015                                                 originhack[2] = 0;
3016                                                 overridecolor[0] = 1;
3017                                                 overridecolor[1] = 0.8;
3018                                                 overridecolor[2] = 0.4;
3019                                         }
3020                                         if (!strcmp(value, "light_flame_large_yellow"))
3021                                         {
3022                                                 originhack[0] = 0;
3023                                                 originhack[1] = 0;
3024                                                 originhack[2] = 0;
3025                                                 overridecolor[0] = 1;
3026                                                 overridecolor[1] = 0.5;
3027                                                 overridecolor[2] = 0.1;
3028                                         }
3029                                         if (!strcmp(value, "light_flame_small_yellow"))
3030                                         {
3031                                                 originhack[0] = 0;
3032                                                 originhack[1] = 0;
3033                                                 originhack[2] = 0;
3034                                                 overridecolor[0] = 1;
3035                                                 overridecolor[1] = 0.5;
3036                                                 overridecolor[2] = 0.1;
3037                                         }
3038                                         if (!strcmp(value, "light_torch_small_white"))
3039                                         {
3040                                                 originhack[0] = 0;
3041                                                 originhack[1] = 0;
3042                                                 originhack[2] = 0;
3043                                                 overridecolor[0] = 1;
3044                                                 overridecolor[1] = 0.5;
3045                                                 overridecolor[2] = 0.1;
3046                                         }
3047                                         if (!strcmp(value, "light_torch_small_walltorch"))
3048                                         {
3049                                                 originhack[0] = 0;
3050                                                 originhack[1] = 0;
3051                                                 originhack[2] = 0;
3052                                                 overridecolor[0] = 1;
3053                                                 overridecolor[1] = 0.5;
3054                                                 overridecolor[2] = 0.1;
3055                                         }
3056                                 }
3057                         }
3058                         else if (!strcmp("style", key))
3059                                 style = atoi(value);
3060                         else if (!strcmp("skin", key))
3061                                 skin = (int)atof(value);
3062                         else if (!strcmp("pflags", key))
3063                                 pflags = (int)atof(value);
3064                         else if (!strcmp("effects", key))
3065                                 effects = (int)atof(value);
3066                         else if (r_refdef.worldmodel->type == mod_brushq3)
3067                         {
3068                                 if (!strcmp("scale", key))
3069                                         lightscale = atof(value);
3070                                 if (!strcmp("fade", key))
3071                                         fadescale = atof(value);
3072                         }
3073                 }
3074                 if (!islight)
3075                         continue;
3076                 if (lightscale <= 0)
3077                         lightscale = 1;
3078                 if (fadescale <= 0)
3079                         fadescale = 1;
3080                 if (color[0] == color[1] && color[0] == color[2])
3081                 {
3082                         color[0] *= overridecolor[0];
3083                         color[1] *= overridecolor[1];
3084                         color[2] *= overridecolor[2];
3085                 }
3086                 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
3087                 color[0] = color[0] * light[0];
3088                 color[1] = color[1] * light[1];
3089                 color[2] = color[2] * light[2];
3090                 switch (type)
3091                 {
3092                 case LIGHTTYPE_MINUSX:
3093                         break;
3094                 case LIGHTTYPE_RECIPX:
3095                         radius *= 2;
3096                         VectorScale(color, (1.0f / 16.0f), color);
3097                         break;
3098                 case LIGHTTYPE_RECIPXX:
3099                         radius *= 2;
3100                         VectorScale(color, (1.0f / 16.0f), color);
3101                         break;
3102                 default:
3103                 case LIGHTTYPE_NONE:
3104                         break;
3105                 case LIGHTTYPE_SUN:
3106                         break;
3107                 case LIGHTTYPE_MINUSXX:
3108                         break;
3109                 }
3110                 VectorAdd(origin, originhack, origin);
3111                 if (radius >= 1)
3112                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, (pflags & PFLAGS_CORONA) != 0, style, (pflags & PFLAGS_NOSHADOW) == 0, skin >= 16 ? va("cubemaps/%i", skin) : NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
3113         }
3114         if (entfiledata)
3115                 Mem_Free(entfiledata);
3116 }
3117
3118
3119 void R_Shadow_SetCursorLocationForView(void)
3120 {
3121         vec_t dist, push;
3122         vec3_t dest, endpos;
3123         trace_t trace;
3124         VectorMA(r_vieworigin, r_editlights_cursordistance.value, r_viewforward, dest);
3125         trace = CL_TraceBox(r_vieworigin, vec3_origin, vec3_origin, dest, true, NULL, SUPERCONTENTS_SOLID, false);
3126         if (trace.fraction < 1)
3127         {
3128                 dist = trace.fraction * r_editlights_cursordistance.value;
3129                 push = r_editlights_cursorpushback.value;
3130                 if (push > dist)
3131                         push = dist;
3132                 push = -push;
3133                 VectorMA(trace.endpos, push, r_viewforward, endpos);
3134                 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
3135         }
3136         else
3137         {
3138                 VectorClear( endpos );
3139         }
3140         r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
3141         r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
3142         r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
3143 }
3144
3145 void R_Shadow_UpdateWorldLightSelection(void)
3146 {
3147         if (r_editlights.integer)
3148         {
3149                 R_Shadow_SetCursorLocationForView();
3150                 R_Shadow_SelectLightInView();
3151                 R_Shadow_DrawLightSprites();
3152         }
3153         else
3154                 R_Shadow_SelectLight(NULL);
3155 }
3156
3157 void R_Shadow_EditLights_Clear_f(void)
3158 {
3159         R_Shadow_ClearWorldLights();
3160 }
3161
3162 void R_Shadow_EditLights_Reload_f(void)
3163 {
3164         if (!r_refdef.worldmodel)
3165                 return;
3166         strlcpy(r_shadow_mapname, r_refdef.worldmodel->name, sizeof(r_shadow_mapname));
3167         R_Shadow_ClearWorldLights();
3168         R_Shadow_LoadWorldLights();
3169         if (r_shadow_worldlightchain == NULL)
3170         {
3171                 R_Shadow_LoadLightsFile();
3172                 if (r_shadow_worldlightchain == NULL)
3173                         R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
3174         }
3175 }
3176
3177 void R_Shadow_EditLights_Save_f(void)
3178 {
3179         if (!r_refdef.worldmodel)
3180                 return;
3181         R_Shadow_SaveWorldLights();
3182 }
3183
3184 void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
3185 {
3186         R_Shadow_ClearWorldLights();
3187         R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
3188 }
3189
3190 void R_Shadow_EditLights_ImportLightsFile_f(void)
3191 {
3192         R_Shadow_ClearWorldLights();
3193         R_Shadow_LoadLightsFile();
3194 }
3195
3196 void R_Shadow_EditLights_Spawn_f(void)
3197 {
3198         vec3_t color;
3199         if (!r_editlights.integer)
3200         {
3201                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
3202                 return;
3203         }
3204         if (Cmd_Argc() != 1)
3205         {
3206                 Con_Print("r_editlights_spawn does not take parameters\n");
3207                 return;
3208         }
3209         color[0] = color[1] = color[2] = 1;
3210         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
3211 }
3212
3213 void R_Shadow_EditLights_Edit_f(void)
3214 {
3215         vec3_t origin, angles, color;
3216         vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
3217         int style, shadows, flags, normalmode, realtimemode;
3218         char cubemapname[MAX_INPUTLINE];
3219         if (!r_editlights.integer)
3220         {
3221                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
3222                 return;
3223         }
3224         if (!r_shadow_selectedlight)
3225         {
3226                 Con_Print("No selected light.\n");
3227                 return;
3228         }
3229         VectorCopy(r_shadow_selectedlight->origin, origin);
3230         VectorCopy(r_shadow_selectedlight->angles, angles);
3231         VectorCopy(r_shadow_selectedlight->color, color);
3232         radius = r_shadow_selectedlight->radius;
3233         style = r_shadow_selectedlight->style;
3234         if (r_shadow_selectedlight->cubemapname)
3235                 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
3236         else
3237                 cubemapname[0] = 0;
3238         shadows = r_shadow_selectedlight->shadow;
3239         corona = r_shadow_selectedlight->corona;
3240         coronasizescale = r_shadow_selectedlight->coronasizescale;
3241         ambientscale = r_shadow_selectedlight->ambientscale;
3242         diffusescale = r_shadow_selectedlight->diffusescale;
3243         specularscale = r_shadow_selectedlight->specularscale;
3244         flags = r_shadow_selectedlight->flags;
3245         normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
3246         realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
3247         if (!strcmp(Cmd_Argv(1), "origin"))
3248         {
3249                 if (Cmd_Argc() != 5)
3250                 {
3251                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
3252                         return;
3253                 }
3254                 origin[0] = atof(Cmd_Argv(2));
3255                 origin[1] = atof(Cmd_Argv(3));
3256                 origin[2] = atof(Cmd_Argv(4));
3257         }
3258         else if (!strcmp(Cmd_Argv(1), "originx"))
3259         {
3260                 if (Cmd_Argc() != 3)
3261                 {
3262                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3263                         return;
3264                 }
3265                 origin[0] = atof(Cmd_Argv(2));
3266         }
3267         else if (!strcmp(Cmd_Argv(1), "originy"))
3268         {
3269                 if (Cmd_Argc() != 3)
3270                 {
3271                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3272                         return;
3273                 }
3274                 origin[1] = atof(Cmd_Argv(2));
3275         }
3276         else if (!strcmp(Cmd_Argv(1), "originz"))
3277         {
3278                 if (Cmd_Argc() != 3)
3279                 {
3280                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3281                         return;
3282                 }
3283                 origin[2] = atof(Cmd_Argv(2));
3284         }
3285         else if (!strcmp(Cmd_Argv(1), "move"))
3286         {
3287                 if (Cmd_Argc() != 5)
3288                 {
3289                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
3290                         return;
3291                 }
3292                 origin[0] += atof(Cmd_Argv(2));
3293                 origin[1] += atof(Cmd_Argv(3));
3294                 origin[2] += atof(Cmd_Argv(4));
3295         }
3296         else if (!strcmp(Cmd_Argv(1), "movex"))
3297         {
3298                 if (Cmd_Argc() != 3)
3299                 {
3300                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3301                         return;
3302                 }
3303                 origin[0] += atof(Cmd_Argv(2));
3304         }
3305         else if (!strcmp(Cmd_Argv(1), "movey"))
3306         {
3307                 if (Cmd_Argc() != 3)
3308                 {
3309                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3310                         return;
3311                 }
3312                 origin[1] += atof(Cmd_Argv(2));
3313         }
3314         else if (!strcmp(Cmd_Argv(1), "movez"))
3315         {
3316                 if (Cmd_Argc() != 3)
3317                 {
3318                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3319                         return;
3320                 }
3321                 origin[2] += atof(Cmd_Argv(2));
3322         }
3323         else if (!strcmp(Cmd_Argv(1), "angles"))
3324         {
3325                 if (Cmd_Argc() != 5)
3326                 {
3327                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
3328                         return;
3329                 }
3330                 angles[0] = atof(Cmd_Argv(2));
3331                 angles[1] = atof(Cmd_Argv(3));
3332                 angles[2] = atof(Cmd_Argv(4));
3333         }
3334         else if (!strcmp(Cmd_Argv(1), "anglesx"))
3335         {
3336                 if (Cmd_Argc() != 3)
3337                 {
3338                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3339                         return;
3340                 }
3341                 angles[0] = atof(Cmd_Argv(2));
3342         }
3343         else if (!strcmp(Cmd_Argv(1), "anglesy"))
3344         {
3345                 if (Cmd_Argc() != 3)
3346                 {
3347                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3348                         return;
3349                 }
3350                 angles[1] = atof(Cmd_Argv(2));
3351         }
3352         else if (!strcmp(Cmd_Argv(1), "anglesz"))
3353         {
3354                 if (Cmd_Argc() != 3)
3355                 {
3356                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3357                         return;
3358                 }
3359                 angles[2] = atof(Cmd_Argv(2));
3360         }
3361         else if (!strcmp(Cmd_Argv(1), "color"))
3362         {
3363                 if (Cmd_Argc() != 5)
3364                 {
3365                         Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
3366                         return;
3367                 }
3368                 color[0] = atof(Cmd_Argv(2));
3369                 color[1] = atof(Cmd_Argv(3));
3370                 color[2] = atof(Cmd_Argv(4));
3371         }
3372         else if (!strcmp(Cmd_Argv(1), "radius"))
3373         {
3374                 if (Cmd_Argc() != 3)
3375                 {
3376                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3377                         return;
3378                 }
3379                 radius = atof(Cmd_Argv(2));
3380         }
3381         else if (!strcmp(Cmd_Argv(1), "colorscale"))
3382         {
3383                 if (Cmd_Argc() == 3)
3384                 {
3385                         double scale = atof(Cmd_Argv(2));
3386                         color[0] *= scale;
3387                         color[1] *= scale;
3388                         color[2] *= scale;
3389                 }
3390                 else
3391                 {
3392                         if (Cmd_Argc() != 5)
3393                         {
3394                                 Con_Printf("usage: r_editlights_edit %s red green blue  (OR grey instead of red green blue)\n", Cmd_Argv(1));
3395                                 return;
3396                         }
3397                         color[0] *= atof(Cmd_Argv(2));
3398                         color[1] *= atof(Cmd_Argv(3));
3399                         color[2] *= atof(Cmd_Argv(4));
3400                 }
3401         }
3402         else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
3403         {
3404                 if (Cmd_Argc() != 3)
3405                 {
3406                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3407                         return;
3408                 }
3409                 radius *= atof(Cmd_Argv(2));
3410         }
3411         else if (!strcmp(Cmd_Argv(1), "style"))
3412         {
3413                 if (Cmd_Argc() != 3)
3414                 {
3415                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3416                         return;
3417                 }
3418                 style = atoi(Cmd_Argv(2));
3419         }
3420         else if (!strcmp(Cmd_Argv(1), "cubemap"))
3421         {
3422                 if (Cmd_Argc() > 3)
3423                 {
3424                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3425                         return;
3426                 }
3427                 if (Cmd_Argc() == 3)
3428                         strcpy(cubemapname, Cmd_Argv(2));
3429                 else
3430                         cubemapname[0] = 0;
3431         }
3432         else if (!strcmp(Cmd_Argv(1), "shadows"))
3433         {
3434                 if (Cmd_Argc() != 3)
3435                 {
3436                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3437                         return;
3438                 }
3439                 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
3440         }
3441         else if (!strcmp(Cmd_Argv(1), "corona"))
3442         {
3443                 if (Cmd_Argc() != 3)
3444                 {
3445                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3446                         return;
3447                 }
3448                 corona = atof(Cmd_Argv(2));
3449         }
3450         else if (!strcmp(Cmd_Argv(1), "coronasize"))
3451         {
3452                 if (Cmd_Argc() != 3)
3453                 {
3454                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3455                         return;
3456                 }
3457                 coronasizescale = atof(Cmd_Argv(2));
3458         }
3459         else if (!strcmp(Cmd_Argv(1), "ambient"))
3460         {
3461                 if (Cmd_Argc() != 3)
3462                 {
3463                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3464                         return;
3465                 }
3466                 ambientscale = atof(Cmd_Argv(2));
3467         }
3468         else if (!strcmp(Cmd_Argv(1), "diffuse"))
3469         {
3470                 if (Cmd_Argc() != 3)
3471                 {
3472                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3473                         return;
3474                 }
3475                 diffusescale = atof(Cmd_Argv(2));
3476         }
3477         else if (!strcmp(Cmd_Argv(1), "specular"))
3478         {
3479                 if (Cmd_Argc() != 3)
3480                 {
3481                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3482                         return;
3483                 }
3484                 specularscale = atof(Cmd_Argv(2));
3485         }
3486         else if (!strcmp(Cmd_Argv(1), "normalmode"))
3487         {
3488                 if (Cmd_Argc() != 3)
3489                 {
3490                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3491                         return;
3492                 }
3493                 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
3494         }
3495         else if (!strcmp(Cmd_Argv(1), "realtimemode"))
3496         {
3497                 if (Cmd_Argc() != 3)
3498                 {
3499                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
3500                         return;
3501                 }
3502                 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
3503         }
3504         else
3505         {
3506                 Con_Print("usage: r_editlights_edit [property] [value]\n");
3507                 Con_Print("Selected light's properties:\n");
3508                 Con_Printf("Origin       : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
3509                 Con_Printf("Angles       : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
3510                 Con_Printf("Color        : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
3511                 Con_Printf("Radius       : %f\n", r_shadow_selectedlight->radius);
3512                 Con_Printf("Corona       : %f\n", r_shadow_selectedlight->corona);
3513                 Con_Printf("Style        : %i\n", r_shadow_selectedlight->style);
3514                 Con_Printf("Shadows      : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
3515                 Con_Printf("Cubemap      : %s\n", r_shadow_selectedlight->cubemapname);
3516                 Con_Printf("CoronaSize   : %f\n", r_shadow_selectedlight->coronasizescale);
3517                 Con_Printf("Ambient      : %f\n", r_shadow_selectedlight->ambientscale);
3518                 Con_Printf("Diffuse      : %f\n", r_shadow_selectedlight->diffusescale);
3519                 Con_Printf("Specular     : %f\n", r_shadow_selectedlight->specularscale);
3520                 Con_Printf("NormalMode   : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
3521                 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
3522                 return;
3523         }
3524         flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
3525         R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
3526 }
3527
3528 void R_Shadow_EditLights_EditAll_f(void)
3529 {
3530         dlight_t *light;
3531
3532         if (!r_editlights.integer)
3533         {
3534                 Con_Print("Cannot edit lights when not in editing mode. Se