Disabled vsync when doing a timedemo.
[divverent/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 rendered using Carmack's Reverse technique, in which backfaces behind
11 zbuffer (zfail) increment the stencil, and frontfaces behind zbuffer (zfail)
12 decrement the stencil, the result is a stencil value of zero where shadows
13 did not intersect the visible geometry, suitable as a stencil mask for
14 rendering lighting everywhere but shadow.
15
16 In our case we use a biased stencil clear of 128 to avoid requiring the
17 stencil wrap extension (but probably should support it), and to address
18 Creative's patent on this sort of technology we also draw the frontfaces
19 first, and backfaces second (decrement, increment).
20
21 Patent warning:
22 This algorithm may be covered by Creative's patent (US Patent #6384822)
23 on Carmack's Reverse paper (which I have not read), however that patent
24 seems to be about drawing a stencil shadow from a model in an otherwise
25 unshadowed scene, where as realtime lighting technology draws light where
26 shadows do not lie.
27
28
29
30 Terminology: Stencil Light Volume (sometimes called Light Volumes)
31 Similar to a Stencil Shadow Volume, but inverted; rather than containing the
32 areas in shadow it contanis the areas in light, this can only be built
33 quickly for certain limited cases (such as portal visibility from a point),
34 but is quite useful for some effects (sunlight coming from sky polygons is
35 one possible example, translucent occluders is another example).
36
37
38
39 Terminology: Optimized Stencil Shadow Volume
40 A Stencil Shadow Volume that has been processed sufficiently to ensure it has
41 no duplicate coverage of areas (no need to shadow an area twice), often this
42 greatly improves performance but is an operation too costly to use on moving
43 lights (however completely optimal Stencil Light Volumes can be constructed
44 in some ideal cases).
45
46
47
48 Terminology: Per Pixel Lighting (sometimes abbreviated PPL)
49 Per pixel evaluation of lighting equations, at a bare minimum this involves
50 DOT3 shading of diffuse lighting (per pixel dotproduct of negated incidence
51 vector and surface normal, using a texture of the surface bumps, called a
52 NormalMap) if supported by hardware; in our case there is support for cards
53 which are incapable of DOT3, the quality is quite poor however.  Additionally
54 it is desirable to have specular evaluation per pixel, per vertex
55 normalization of specular halfangle vectors causes noticable distortion but
56 is unavoidable on hardware without GL_ARB_fragment_program.
57
58
59
60 Terminology: Normalization CubeMap
61 A cubemap containing normalized dot3-encoded (vectors of length 1 or less
62 encoded as RGB colors) for any possible direction, this technique allows per
63 pixel calculation of incidence vector for per pixel lighting purposes, which
64 would not otherwise be possible per pixel without GL_ARB_fragment_program.
65
66
67
68 Terminology: 2D Attenuation Texturing
69 A very crude approximation of light attenuation with distance which results
70 in cylindrical light shapes which fade vertically as a streak (some games
71 such as Doom3 allow this to be rotated to be less noticable in specific
72 cases), the technique is simply modulating lighting by two 2D textures (which
73 can be the same) on different axes of projection (XY and Z, typically), this
74 is the best technique available without 3D Attenuation Texturing or
75 GL_ARB_fragment_program technology.
76
77
78
79 Terminology: 3D Attenuation Texturing
80 A slightly crude approximation of light attenuation with distance, its flaws
81 are limited radius and resolution (performance tradeoffs).
82
83
84
85 Terminology: 3D Attenuation-Normalization Texturing
86 A 3D Attenuation Texture merged with a Normalization CubeMap, by making the
87 vectors shorter the lighting becomes darker, a very effective optimization of
88 diffuse lighting if 3D Attenuation Textures are already used.
89
90
91
92 Terminology: Light Cubemap Filtering
93 A technique for modeling non-uniform light distribution according to
94 direction, for example projecting a stained glass window image onto a wall,
95 this is done by texturing the lighting with a cubemap.
96
97
98
99 Terminology: Light Projection Filtering
100 A technique for modeling shadowing of light passing through translucent
101 surfaces, allowing stained glass windows and other effects to be done more
102 elegantly than possible with Light Cubemap Filtering by applying an occluder
103 texture to the lighting combined with a stencil light volume to limit the lit
104 area (this allows evaluating multiple translucent occluders in a scene).
105
106
107
108 Terminology: Doom3 Lighting
109 A combination of Stencil Shadow Volume, Per Pixel Lighting, Normalization
110 CubeMap, 2D Attenuation Texturing, and Light Filtering, as demonstrated by
111 the (currently upcoming) game Doom3.
112 */
113
114 #include "quakedef.h"
115 #include "r_shadow.h"
116 #include "cl_collision.h"
117 #include "portals.h"
118 #include "image.h"
119
120 extern void R_Shadow_EditLights_Init(void);
121
122 #define SHADOWSTAGE_NONE 0
123 #define SHADOWSTAGE_STENCIL 1
124 #define SHADOWSTAGE_LIGHT 2
125 #define SHADOWSTAGE_STENCILTWOSIDE 3
126
127 int r_shadowstage = SHADOWSTAGE_NONE;
128
129 mempool_t *r_shadow_mempool;
130
131 int maxshadowelements;
132 int *shadowelements;
133
134 int maxshadowmark;
135 int numshadowmark;
136 int *shadowmark;
137 int *shadowmarklist;
138 int shadowmarkcount;
139
140 int maxvertexupdate;
141 int *vertexupdate;
142 int *vertexremap;
143 int vertexupdatenum;
144
145 int r_shadow_buffer_numclusterpvsbytes;
146 qbyte *r_shadow_buffer_clusterpvs;
147 int *r_shadow_buffer_clusterlist;
148
149 int r_shadow_buffer_numsurfacepvsbytes;
150 qbyte *r_shadow_buffer_surfacepvs;
151 int *r_shadow_buffer_surfacelist;
152
153 rtexturepool_t *r_shadow_texturepool;
154 rtexture_t *r_shadow_normalcubetexture;
155 rtexture_t *r_shadow_attenuation2dtexture;
156 rtexture_t *r_shadow_attenuation3dtexture;
157 rtexture_t *r_shadow_blankbumptexture;
158 rtexture_t *r_shadow_blankglosstexture;
159 rtexture_t *r_shadow_blankwhitetexture;
160
161 // lights are reloaded when this changes
162 char r_shadow_mapname[MAX_QPATH];
163
164 // used only for light filters (cubemaps)
165 rtexturepool_t *r_shadow_filters_texturepool;
166
167 cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0"};
168 cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4"};
169 cvar_t r_shadow_cull = {0, "r_shadow_cull", "1"};
170 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1"};
171 cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1"};
172 cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.25"};
173 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1"};
174 cvar_t r_shadow_lightattenuationpower = {0, "r_shadow_lightattenuationpower", "0.5"};
175 cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "1"};
176 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1"};
177 cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1"};
178 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000"};
179 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1"};
180 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "0"};
181 cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0"};
182 cvar_t r_shadow_realtime_world_dlightshadows = {CVAR_SAVE, "r_shadow_realtime_world_dlightshadows", "1"};
183 cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0"};
184 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1"};
185 cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1"};
186 cvar_t r_shadow_shadow_polygonfactor = {0, "r_shadow_shadow_polygonfactor", "0"};
187 cvar_t r_shadow_shadow_polygonoffset = {0, "r_shadow_shadow_polygonoffset", "1"};
188 cvar_t r_shadow_singlepassvolumegeneration = {0, "r_shadow_singlepassvolumegeneration", "1"};
189 cvar_t r_shadow_staticworldlights = {0, "r_shadow_staticworldlights", "1"};
190 cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1"};
191 cvar_t r_shadow_visiblevolumes = {0, "r_shadow_visiblevolumes", "0"};
192 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1"};
193 cvar_t r_editlights = {0, "r_editlights", "0"};
194 cvar_t r_editlights_cursordistance = {0, "r_editlights_distance", "1024"};
195 cvar_t r_editlights_cursorpushback = {0, "r_editlights_pushback", "0"};
196 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_pushoff", "4"};
197 cvar_t r_editlights_cursorgrid = {0, "r_editlights_grid", "4"};
198 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "0.8"};
199 cvar_t r_editlights_rtlightssizescale = {CVAR_SAVE, "r_editlights_rtlightssizescale", "0.7"};
200 cvar_t r_editlights_rtlightscolorscale = {CVAR_SAVE, "r_editlights_rtlightscolorscale", "2"};
201
202 float r_shadow_attenpower, r_shadow_attenscale;
203
204 rtlight_t *r_shadow_compilingrtlight;
205 dlight_t *r_shadow_worldlightchain;
206 dlight_t *r_shadow_selectedlight;
207 dlight_t r_shadow_bufferlight;
208 vec3_t r_editlights_cursorlocation;
209
210 rtexture_t *lighttextures[5];
211
212 extern int con_vislines;
213
214 typedef struct cubemapinfo_s
215 {
216         char basename[64];
217         rtexture_t *texture;
218 }
219 cubemapinfo_t;
220
221 #define MAX_CUBEMAPS 256
222 static int numcubemaps;
223 static cubemapinfo_t cubemaps[MAX_CUBEMAPS];
224
225 GLhandleARB r_shadow_program_light_diffusegloss = 0;
226 GLhandleARB r_shadow_program_light_diffuse = 0;
227 GLhandleARB r_shadow_program_light_gloss = 0;
228
229 void R_Shadow_UncompileWorldLights(void);
230 void R_Shadow_ClearWorldLights(void);
231 void R_Shadow_SaveWorldLights(void);
232 void R_Shadow_LoadWorldLights(void);
233 void R_Shadow_LoadLightsFile(void);
234 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
235 void R_Shadow_EditLights_Reload_f(void);
236 void R_Shadow_ValidateCvars(void);
237 static void R_Shadow_MakeTextures(void);
238 void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, dlight_t *light);
239
240 // beginnings of GL_ARB_shaders support, not done yet
241 GLhandleARB GL_Backend_LoadProgram(const char *vertexshaderfilename, const char *fragmentshaderfilename)
242 {
243         return 0;
244 }
245
246 void GL_Backend_FreeProgram(GLhandleARB prog)
247 {
248 }
249
250 void r_shadow_start(void)
251 {
252         // allocate vertex processing arrays
253         numcubemaps = 0;
254         r_shadow_normalcubetexture = NULL;
255         r_shadow_attenuation2dtexture = NULL;
256         r_shadow_attenuation3dtexture = NULL;
257         r_shadow_blankbumptexture = NULL;
258         r_shadow_blankglosstexture = NULL;
259         r_shadow_blankwhitetexture = NULL;
260         r_shadow_texturepool = NULL;
261         r_shadow_filters_texturepool = NULL;
262         R_Shadow_ValidateCvars();
263         R_Shadow_MakeTextures();
264         maxshadowelements = 0;
265         shadowelements = NULL;
266         maxvertexupdate = 0;
267         vertexupdate = NULL;
268         vertexremap = NULL;
269         vertexupdatenum = 0;
270         maxshadowmark = 0;
271         numshadowmark = 0;
272         shadowmark = NULL;
273         shadowmarklist = NULL;
274         shadowmarkcount = 0;
275         r_shadow_buffer_numclusterpvsbytes = 0;
276         r_shadow_buffer_clusterpvs = NULL;
277         r_shadow_buffer_clusterlist = NULL;
278         r_shadow_buffer_numsurfacepvsbytes = 0;
279         r_shadow_buffer_surfacepvs = NULL;
280         r_shadow_buffer_surfacelist = NULL;
281         if (gl_support_fragment_shader)
282         {
283                 r_shadow_program_light_diffusegloss = GL_Backend_LoadProgram("glsl/diffusegloss.vert", "glsl/diffusegloss.frag");
284                 r_shadow_program_light_diffuse = GL_Backend_LoadProgram("glsl/diffuse.vert", "glsl/diffuse.frag");
285                 r_shadow_program_light_gloss = GL_Backend_LoadProgram("glsl/gloss.vert", "glsl/gloss.frag");
286         }
287 }
288
289 void r_shadow_shutdown(void)
290 {
291         R_Shadow_UncompileWorldLights();
292         GL_Backend_FreeProgram(r_shadow_program_light_diffusegloss);
293         r_shadow_program_light_diffusegloss = 0;
294         GL_Backend_FreeProgram(r_shadow_program_light_diffuse);
295         r_shadow_program_light_diffuse = 0;
296         GL_Backend_FreeProgram(r_shadow_program_light_gloss);
297         r_shadow_program_light_gloss = 0;
298         numcubemaps = 0;
299         r_shadow_normalcubetexture = NULL;
300         r_shadow_attenuation2dtexture = NULL;
301         r_shadow_attenuation3dtexture = NULL;
302         r_shadow_blankbumptexture = NULL;
303         r_shadow_blankglosstexture = NULL;
304         r_shadow_blankwhitetexture = NULL;
305         R_FreeTexturePool(&r_shadow_texturepool);
306         R_FreeTexturePool(&r_shadow_filters_texturepool);
307         maxshadowelements = 0;
308         if (shadowelements)
309                 Mem_Free(shadowelements);
310         shadowelements = NULL;
311         maxvertexupdate = 0;
312         if (vertexupdate)
313                 Mem_Free(vertexupdate);
314         vertexupdate = NULL;
315         if (vertexremap)
316                 Mem_Free(vertexremap);
317         vertexremap = NULL;
318         vertexupdatenum = 0;
319         maxshadowmark = 0;
320         numshadowmark = 0;
321         if (shadowmark)
322                 Mem_Free(shadowmark);
323         shadowmark = NULL;
324         if (shadowmarklist)
325                 Mem_Free(shadowmarklist);
326         shadowmarklist = NULL;
327         shadowmarkcount = 0;
328         r_shadow_buffer_numclusterpvsbytes = 0;
329         if (r_shadow_buffer_clusterpvs)
330                 Mem_Free(r_shadow_buffer_clusterpvs);
331         r_shadow_buffer_clusterpvs = NULL;
332         if (r_shadow_buffer_clusterlist)
333                 Mem_Free(r_shadow_buffer_clusterlist);
334         r_shadow_buffer_clusterlist = NULL;
335         r_shadow_buffer_numsurfacepvsbytes = 0;
336         if (r_shadow_buffer_surfacepvs)
337                 Mem_Free(r_shadow_buffer_surfacepvs);
338         r_shadow_buffer_surfacepvs = NULL;
339         if (r_shadow_buffer_surfacelist)
340                 Mem_Free(r_shadow_buffer_surfacelist);
341         r_shadow_buffer_surfacelist = NULL;
342 }
343
344 void r_shadow_newmap(void)
345 {
346 }
347
348 void R_Shadow_Help_f(void)
349 {
350         Con_Printf(
351 "Documentation on r_shadow system:\n"
352 "Settings:\n"
353 "r_shadow_bumpscale_basetexture : base texture as bumpmap with this scale\n"
354 "r_shadow_bumpscale_bumpmap : depth scale for bumpmap conversion\n"
355 "r_shadow_debuglight : render only this light number (-1 = all)\n"
356 "r_shadow_gloss 0/1/2 : no gloss, gloss textures only, force gloss\n"
357 "r_shadow_gloss2intensity : brightness of forced gloss\n"
358 "r_shadow_glossintensity : brightness of textured gloss\n"
359 "r_shadow_lightattenuationpower : used to generate attenuation texture\n"
360 "r_shadow_lightattenuationscale : used to generate attenuation texture\n"
361 "r_shadow_lightintensityscale : scale rendering brightness of all lights\n"
362 "r_shadow_portallight : use portal visibility for static light precomputation\n"
363 "r_shadow_projectdistance : shadow volume projection distance\n"
364 "r_shadow_realtime_dlight : use high quality dynamic lights in normal mode\n"
365 "r_shadow_realtime_dlight_shadows : cast shadows from dlights\n"
366 "r_shadow_realtime_world : use high quality world lighting mode\n"
367 "r_shadow_realtime_world_dlightshadows : cast shadows from dlights\n"
368 "r_shadow_realtime_world_lightmaps : use lightmaps in addition to lights\n"
369 "r_shadow_realtime_world_shadows : cast shadows from world lights\n"
370 "r_shadow_scissor : use scissor optimization\n"
371 "r_shadow_shadow_polygonfactor : nudge shadow volumes closer/further\n"
372 "r_shadow_shadow_polygonoffset : nudge shadow volumes closer/further\n"
373 "r_shadow_singlepassvolumegeneration : selects shadow volume algorithm\n"
374 "r_shadow_texture3d : use 3d attenuation texture (if hardware supports)\n"
375 "r_shadow_visiblevolumes : useful for performance testing; bright = slow!\n"
376 "Commands:\n"
377 "r_shadow_help : this help\n"
378         );
379 }
380
381 void R_Shadow_Init(void)
382 {
383         Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
384         Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
385         Cvar_RegisterVariable(&r_shadow_cull);
386         Cvar_RegisterVariable(&r_shadow_debuglight);
387         Cvar_RegisterVariable(&r_shadow_gloss);
388         Cvar_RegisterVariable(&r_shadow_gloss2intensity);
389         Cvar_RegisterVariable(&r_shadow_glossintensity);
390         Cvar_RegisterVariable(&r_shadow_lightattenuationpower);
391         Cvar_RegisterVariable(&r_shadow_lightattenuationscale);
392         Cvar_RegisterVariable(&r_shadow_lightintensityscale);
393         Cvar_RegisterVariable(&r_shadow_portallight);
394         Cvar_RegisterVariable(&r_shadow_projectdistance);
395         Cvar_RegisterVariable(&r_shadow_realtime_dlight);
396         Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
397         Cvar_RegisterVariable(&r_shadow_realtime_world);
398         Cvar_RegisterVariable(&r_shadow_realtime_world_dlightshadows);
399         Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
400         Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
401         Cvar_RegisterVariable(&r_shadow_scissor);
402         Cvar_RegisterVariable(&r_shadow_shadow_polygonfactor);
403         Cvar_RegisterVariable(&r_shadow_shadow_polygonoffset);
404         Cvar_RegisterVariable(&r_shadow_singlepassvolumegeneration);
405         Cvar_RegisterVariable(&r_shadow_staticworldlights);
406         Cvar_RegisterVariable(&r_shadow_texture3d);
407         Cvar_RegisterVariable(&r_shadow_visiblevolumes);
408         Cvar_RegisterVariable(&gl_ext_stenciltwoside);
409         if (gamemode == GAME_TENEBRAE)
410         {
411                 Cvar_SetValue("r_shadow_gloss", 2);
412                 Cvar_SetValue("r_shadow_bumpscale_basetexture", 4);
413         }
414         Cmd_AddCommand("r_shadow_help", R_Shadow_Help_f);
415         R_Shadow_EditLights_Init();
416         r_shadow_mempool = Mem_AllocPool("R_Shadow", 0, NULL);
417         r_shadow_worldlightchain = NULL;
418         maxshadowelements = 0;
419         shadowelements = NULL;
420         maxvertexupdate = 0;
421         vertexupdate = NULL;
422         vertexremap = NULL;
423         vertexupdatenum = 0;
424         maxshadowmark = 0;
425         numshadowmark = 0;
426         shadowmark = NULL;
427         shadowmarklist = NULL;
428         shadowmarkcount = 0;
429         r_shadow_buffer_numclusterpvsbytes = 0;
430         r_shadow_buffer_clusterpvs = NULL;
431         r_shadow_buffer_clusterlist = NULL;
432         r_shadow_buffer_numsurfacepvsbytes = 0;
433         r_shadow_buffer_surfacepvs = NULL;
434         r_shadow_buffer_surfacelist = NULL;
435         R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap);
436 }
437
438 matrix4x4_t matrix_attenuationxyz =
439 {
440         {
441                 {0.5, 0.0, 0.0, 0.5},
442                 {0.0, 0.5, 0.0, 0.5},
443                 {0.0, 0.0, 0.5, 0.5},
444                 {0.0, 0.0, 0.0, 1.0}
445         }
446 };
447
448 matrix4x4_t matrix_attenuationz =
449 {
450         {
451                 {0.0, 0.0, 0.5, 0.5},
452                 {0.0, 0.0, 0.0, 0.5},
453                 {0.0, 0.0, 0.0, 0.5},
454                 {0.0, 0.0, 0.0, 1.0}
455         }
456 };
457
458 int *R_Shadow_ResizeShadowElements(int numtris)
459 {
460         // make sure shadowelements is big enough for this volume
461         if (maxshadowelements < numtris * 24)
462         {
463                 maxshadowelements = numtris * 24;
464                 if (shadowelements)
465                         Mem_Free(shadowelements);
466                 shadowelements = Mem_Alloc(r_shadow_mempool, maxshadowelements * sizeof(int));
467         }
468         return shadowelements;
469 }
470
471 void R_Shadow_EnlargeClusterBuffer(int numclusters)
472 {
473         int numclusterpvsbytes = (((numclusters + 7) >> 3) + 255) & ~255;
474         if (r_shadow_buffer_numclusterpvsbytes < numclusterpvsbytes)
475         {
476                 if (r_shadow_buffer_clusterpvs)
477                         Mem_Free(r_shadow_buffer_clusterpvs);
478                 if (r_shadow_buffer_clusterlist)
479                         Mem_Free(r_shadow_buffer_clusterlist);
480                 r_shadow_buffer_numclusterpvsbytes = numclusterpvsbytes;
481                 r_shadow_buffer_clusterpvs = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numclusterpvsbytes);
482                 r_shadow_buffer_clusterlist = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numclusterpvsbytes * 8 * sizeof(*r_shadow_buffer_clusterlist));
483         }
484 }
485
486 void R_Shadow_EnlargeSurfaceBuffer(int numsurfaces)
487 {
488         int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
489         if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
490         {
491                 if (r_shadow_buffer_surfacepvs)
492                         Mem_Free(r_shadow_buffer_surfacepvs);
493                 if (r_shadow_buffer_surfacelist)
494                         Mem_Free(r_shadow_buffer_surfacelist);
495                 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
496                 r_shadow_buffer_surfacepvs = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes);
497                 r_shadow_buffer_surfacelist = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
498         }
499 }
500
501 void R_Shadow_PrepareShadowMark(int numtris)
502 {
503         // make sure shadowmark is big enough for this volume
504         if (maxshadowmark < numtris)
505         {
506                 maxshadowmark = numtris;
507                 if (shadowmark)
508                         Mem_Free(shadowmark);
509                 if (shadowmarklist)
510                         Mem_Free(shadowmarklist);
511                 shadowmark = Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmark));
512                 shadowmarklist = Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmarklist));
513                 shadowmarkcount = 0;
514         }
515         shadowmarkcount++;
516         // if shadowmarkcount wrapped we clear the array and adjust accordingly
517         if (shadowmarkcount == 0)
518         {
519                 shadowmarkcount = 1;
520                 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
521         }
522         numshadowmark = 0;
523 }
524
525 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)
526 {
527         int i, j, tris = 0, vr[3], t, outvertices = 0;
528         float f, temp[3];
529         const int *e, *n;
530         const float *v;
531
532         if (maxvertexupdate < innumvertices)
533         {
534                 maxvertexupdate = innumvertices;
535                 if (vertexupdate)
536                         Mem_Free(vertexupdate);
537                 if (vertexremap)
538                         Mem_Free(vertexremap);
539                 vertexupdate = Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int));
540                 vertexremap = Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int));
541                 vertexupdatenum = 0;
542         }
543         vertexupdatenum++;
544         if (vertexupdatenum == 0)
545         {
546                 vertexupdatenum = 1;
547                 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
548                 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
549         }
550         
551         for (i = 0;i < numshadowmarktris;i++)
552                 shadowmark[shadowmarktris[i]] = shadowmarkcount;
553
554         for (i = 0;i < numshadowmarktris;i++)
555         {
556                 t = shadowmarktris[i];
557                 e = inelement3i + t * 3;
558                 // make sure the vertices are created
559                 for (j = 0;j < 3;j++)
560                 {
561                         if (vertexupdate[e[j]] != vertexupdatenum)
562                         {
563                                 vertexupdate[e[j]] = vertexupdatenum;
564                                 vertexremap[e[j]] = outvertices;
565                                 v = invertex3f + e[j] * 3;
566                                 // project one copy of the vertex to the sphere radius of the light
567                                 // (FIXME: would projecting it to the light box be better?)
568                                 VectorSubtract(v, projectorigin, temp);
569                                 f = projectdistance / VectorLength(temp);
570                                 VectorCopy(v, outvertex3f);
571                                 VectorMA(projectorigin, f, temp, (outvertex3f + 3));
572                                 outvertex3f += 6;
573                                 outvertices += 2;
574                         }
575                 }
576         }
577
578         for (i = 0;i < numshadowmarktris;i++)
579         {
580                 t = shadowmarktris[i];
581                 e = inelement3i + t * 3;
582                 n = inneighbor3i + t * 3;
583                 // output the front and back triangles
584                 outelement3i[0] = vertexremap[e[0]];
585                 outelement3i[1] = vertexremap[e[1]];
586                 outelement3i[2] = vertexremap[e[2]];
587                 outelement3i[3] = vertexremap[e[2]] + 1;
588                 outelement3i[4] = vertexremap[e[1]] + 1;
589                 outelement3i[5] = vertexremap[e[0]] + 1;
590                 outelement3i += 6;
591                 tris += 2;
592                 // output the sides (facing outward from this triangle)
593                 if (shadowmark[n[0]] != shadowmarkcount)
594                 {
595                         vr[0] = vertexremap[e[0]];
596                         vr[1] = vertexremap[e[1]];
597                         outelement3i[0] = vr[1];
598                         outelement3i[1] = vr[0];
599                         outelement3i[2] = vr[0] + 1;
600                         outelement3i[3] = vr[1];
601                         outelement3i[4] = vr[0] + 1;
602                         outelement3i[5] = vr[1] + 1;
603                         outelement3i += 6;
604                         tris += 2;
605                 }
606                 if (shadowmark[n[1]] != shadowmarkcount)
607                 {
608                         vr[1] = vertexremap[e[1]];
609                         vr[2] = vertexremap[e[2]];
610                         outelement3i[0] = vr[2];
611                         outelement3i[1] = vr[1];
612                         outelement3i[2] = vr[1] + 1;
613                         outelement3i[3] = vr[2];
614                         outelement3i[4] = vr[1] + 1;
615                         outelement3i[5] = vr[2] + 1;
616                         outelement3i += 6;
617                         tris += 2;
618                 }
619                 if (shadowmark[n[2]] != shadowmarkcount)
620                 {
621                         vr[0] = vertexremap[e[0]];
622                         vr[2] = vertexremap[e[2]];
623                         outelement3i[0] = vr[0];
624                         outelement3i[1] = vr[2];
625                         outelement3i[2] = vr[2] + 1;
626                         outelement3i[3] = vr[0];
627                         outelement3i[4] = vr[2] + 1;
628                         outelement3i[5] = vr[0] + 1;
629                         outelement3i += 6;
630                         tris += 2;
631                 }
632         }
633         if (outnumvertices)
634                 *outnumvertices = outvertices;
635         return tris;
636 }
637
638 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)
639 {
640         int tris, outverts;
641         if (projectdistance < 0.1)
642         {
643                 Con_Printf("R_Shadow_Volume: projectdistance %f\n");
644                 return;
645         }
646         if (!numverts || !nummarktris)
647                 return;
648         // make sure shadowelements is big enough for this volume
649         if (maxshadowelements < nummarktris * 24)
650                 R_Shadow_ResizeShadowElements((nummarktris + 256) * 24);
651         tris = R_Shadow_ConstructShadowVolume(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, varray_vertex3f2, projectorigin, projectdistance, nummarktris, marktris);
652         R_Shadow_RenderVolume(outverts, tris, varray_vertex3f2, shadowelements);
653 }
654
655 void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const vec3_t projectorigin, vec3_t lightmins, vec3_t lightmaxs, vec3_t surfacemins, vec3_t surfacemaxs)
656 {
657         int t, tend;
658         const int *e;
659         const float *v[3];
660         if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
661                 return;
662         tend = firsttriangle + numtris;
663         if (surfacemins[0] >= lightmins[0] && surfacemaxs[0] <= lightmaxs[0]
664          && surfacemins[1] >= lightmins[1] && surfacemaxs[1] <= lightmaxs[1]
665          && surfacemins[2] >= lightmins[2] && surfacemaxs[2] <= lightmaxs[2])
666         {
667                 // surface box entirely inside light box, no box cull
668                 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
669                         if (PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
670                                 shadowmarklist[numshadowmark++] = t;
671         }
672         else
673         {
674                 // surface box not entirely inside light box, cull each triangle
675                 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
676                 {
677                         v[0] = invertex3f + e[0] * 3;
678                         v[1] = invertex3f + e[1] * 3;
679                         v[2] = invertex3f + e[2] * 3;
680                         if (PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
681                          && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0]))
682                          && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0]))
683                          && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1]))
684                          && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1]))
685                          && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2]))
686                          && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
687                                 shadowmarklist[numshadowmark++] = t;
688                 }
689         }
690 }
691
692 void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *vertex3f, const int *element3i)
693 {
694         rmeshstate_t m;
695         if (r_shadow_compilingrtlight)
696         {
697                 // if we're compiling an rtlight, capture the mesh
698                 Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_shadow, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, numtriangles, element3i);
699                 return;
700         }
701         memset(&m, 0, sizeof(m));
702         m.pointer_vertex = vertex3f;
703         R_Mesh_State(&m);
704         GL_LockArrays(0, numvertices);
705         if (r_shadowstage == SHADOWSTAGE_STENCIL)
706         {
707                 // increment stencil if backface is behind depthbuffer
708                 qglCullFace(GL_BACK); // quake is backwards, this culls front faces
709                 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
710                 R_Mesh_Draw(numvertices, numtriangles, element3i);
711                 c_rt_shadowmeshes++;
712                 c_rt_shadowtris += numtriangles;
713                 // decrement stencil if frontface is behind depthbuffer
714                 qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
715                 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
716         }
717         R_Mesh_Draw(numvertices, numtriangles, element3i);
718         c_rt_shadowmeshes++;
719         c_rt_shadowtris += numtriangles;
720         GL_LockArrays(0, 0);
721 }
722
723 static void R_Shadow_MakeTextures(void)
724 {
725         int x, y, z, d, side;
726         float v[3], s, t, intensity;
727         qbyte *data;
728         R_FreeTexturePool(&r_shadow_texturepool);
729         r_shadow_texturepool = R_AllocTexturePool();
730         r_shadow_attenpower = r_shadow_lightattenuationpower.value;
731         r_shadow_attenscale = r_shadow_lightattenuationscale.value;
732 #define NORMSIZE 64
733 #define ATTEN2DSIZE 64
734 #define ATTEN3DSIZE 32
735         data = Mem_Alloc(tempmempool, max(6*NORMSIZE*NORMSIZE*4, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4)));
736         data[0] = 128;
737         data[1] = 128;
738         data[2] = 255;
739         data[3] = 255;
740         r_shadow_blankbumptexture = R_LoadTexture2D(r_shadow_texturepool, "blankbump", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
741         data[0] = 255;
742         data[1] = 255;
743         data[2] = 255;
744         data[3] = 255;
745         r_shadow_blankglosstexture = R_LoadTexture2D(r_shadow_texturepool, "blankgloss", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
746         data[0] = 255;
747         data[1] = 255;
748         data[2] = 255;
749         data[3] = 255;
750         r_shadow_blankwhitetexture = R_LoadTexture2D(r_shadow_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
751         if (gl_texturecubemap)
752         {
753                 for (side = 0;side < 6;side++)
754                 {
755                         for (y = 0;y < NORMSIZE;y++)
756                         {
757                                 for (x = 0;x < NORMSIZE;x++)
758                                 {
759                                         s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
760                                         t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
761                                         switch(side)
762                                         {
763                                         case 0:
764                                                 v[0] = 1;
765                                                 v[1] = -t;
766                                                 v[2] = -s;
767                                                 break;
768                                         case 1:
769                                                 v[0] = -1;
770                                                 v[1] = -t;
771                                                 v[2] = s;
772                                                 break;
773                                         case 2:
774                                                 v[0] = s;
775                                                 v[1] = 1;
776                                                 v[2] = t;
777                                                 break;
778                                         case 3:
779                                                 v[0] = s;
780                                                 v[1] = -1;
781                                                 v[2] = -t;
782                                                 break;
783                                         case 4:
784                                                 v[0] = s;
785                                                 v[1] = -t;
786                                                 v[2] = 1;
787                                                 break;
788                                         case 5:
789                                                 v[0] = -s;
790                                                 v[1] = -t;
791                                                 v[2] = -1;
792                                                 break;
793                                         }
794                                         intensity = 127.0f / sqrt(DotProduct(v, v));
795                                         data[((side*NORMSIZE+y)*NORMSIZE+x)*4+0] = 128.0f + intensity * v[0];
796                                         data[((side*NORMSIZE+y)*NORMSIZE+x)*4+1] = 128.0f + intensity * v[1];
797                                         data[((side*NORMSIZE+y)*NORMSIZE+x)*4+2] = 128.0f + intensity * v[2];
798                                         data[((side*NORMSIZE+y)*NORMSIZE+x)*4+3] = 255;
799                                 }
800                         }
801                 }
802                 r_shadow_normalcubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
803         }
804         else
805                 r_shadow_normalcubetexture = NULL;
806         for (y = 0;y < ATTEN2DSIZE;y++)
807         {
808                 for (x = 0;x < ATTEN2DSIZE;x++)
809                 {
810                         v[0] = ((x + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375);
811                         v[1] = ((y + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375);
812                         v[2] = 0;
813                         intensity = 1.0f - sqrt(DotProduct(v, v));
814                         if (intensity > 0)
815                                 intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f;
816                         d = bound(0, intensity, 255);
817                         data[(y*ATTEN2DSIZE+x)*4+0] = d;
818                         data[(y*ATTEN2DSIZE+x)*4+1] = d;
819                         data[(y*ATTEN2DSIZE+x)*4+2] = d;
820                         data[(y*ATTEN2DSIZE+x)*4+3] = d;
821                 }
822         }
823         r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL);
824         if (r_shadow_texture3d.integer)
825         {
826                 for (z = 0;z < ATTEN3DSIZE;z++)
827                 {
828                         for (y = 0;y < ATTEN3DSIZE;y++)
829                         {
830                                 for (x = 0;x < ATTEN3DSIZE;x++)
831                                 {
832                                         v[0] = ((x + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375);
833                                         v[1] = ((y + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375);
834                                         v[2] = ((z + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375);
835                                         intensity = 1.0f - sqrt(DotProduct(v, v));
836                                         if (intensity > 0)
837                                                 intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f;
838                                         d = bound(0, intensity, 255);
839                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+0] = d;
840                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+1] = d;
841                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+2] = d;
842                                         data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+3] = d;
843                                 }
844                         }
845                 }
846                 r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL);
847         }
848         Mem_Free(data);
849 }
850
851 void R_Shadow_ValidateCvars(void)
852 {
853         if (r_shadow_texture3d.integer && !gl_texture3d)
854                 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
855         if (gl_ext_stenciltwoside.integer && !gl_support_stenciltwoside)
856                 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
857 }
858
859 void R_Shadow_Stage_Begin(void)
860 {
861         rmeshstate_t m;
862
863         R_Shadow_ValidateCvars();
864
865         if (!r_shadow_attenuation2dtexture
866          || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
867          || r_shadow_lightattenuationpower.value != r_shadow_attenpower
868          || r_shadow_lightattenuationscale.value != r_shadow_attenscale)
869                 R_Shadow_MakeTextures();
870
871         memset(&m, 0, sizeof(m));
872         GL_BlendFunc(GL_ONE, GL_ZERO);
873         GL_DepthMask(false);
874         GL_DepthTest(true);
875         R_Mesh_State(&m);
876         GL_Color(0, 0, 0, 1);
877         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
878         qglEnable(GL_CULL_FACE);
879         GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
880         r_shadowstage = SHADOWSTAGE_NONE;
881 }
882
883 void R_Shadow_Stage_ShadowVolumes(void)
884 {
885         rmeshstate_t m;
886         memset(&m, 0, sizeof(m));
887         R_Mesh_State(&m);
888         GL_Color(1, 1, 1, 1);
889         GL_ColorMask(0, 0, 0, 0);
890         GL_BlendFunc(GL_ONE, GL_ZERO);
891         GL_DepthMask(false);
892         GL_DepthTest(true);
893         qglPolygonOffset(r_shadow_shadow_polygonfactor.value, r_shadow_shadow_polygonoffset.value);
894         //if (r_shadow_shadow_polygonoffset.value != 0)
895         //{
896         //      qglPolygonOffset(r_shadow_shadow_polygonfactor.value, r_shadow_shadow_polygonoffset.value);
897         //      qglEnable(GL_POLYGON_OFFSET_FILL);
898         //}
899         //else
900         //      qglDisable(GL_POLYGON_OFFSET_FILL);
901         qglDepthFunc(GL_LESS);
902         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
903         qglEnable(GL_STENCIL_TEST);
904         qglStencilFunc(GL_ALWAYS, 128, ~0);
905         if (gl_ext_stenciltwoside.integer)
906         {
907                 r_shadowstage = SHADOWSTAGE_STENCILTWOSIDE;
908                 qglDisable(GL_CULL_FACE);
909                 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
910                 qglActiveStencilFaceEXT(GL_BACK); // quake is backwards, this is front faces
911                 qglStencilMask(~0);
912                 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
913                 qglActiveStencilFaceEXT(GL_FRONT); // quake is backwards, this is back faces
914                 qglStencilMask(~0);
915                 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
916         }
917         else
918         {
919                 r_shadowstage = SHADOWSTAGE_STENCIL;
920                 qglEnable(GL_CULL_FACE);
921                 qglStencilMask(~0);
922                 // this is changed by every shadow render so its value here is unimportant
923                 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
924         }
925         GL_Clear(GL_STENCIL_BUFFER_BIT);
926         c_rt_clears++;
927         // LordHavoc note: many shadow volumes reside entirely inside the world
928         // (that is to say they are entirely bounded by their lit surfaces),
929         // which can be optimized by handling things as an inverted light volume,
930         // with the shadow boundaries of the world being simulated by an altered
931         // (129) bias to stencil clearing on such lights
932         // FIXME: generate inverted light volumes for use as shadow volumes and
933         // optimize for them as noted above
934 }
935
936 void R_Shadow_Stage_Light(int shadowtest)
937 {
938         rmeshstate_t m;
939         memset(&m, 0, sizeof(m));
940         R_Mesh_State(&m);
941         GL_BlendFunc(GL_ONE, GL_ONE);
942         GL_DepthMask(false);
943         GL_DepthTest(true);
944         qglPolygonOffset(0, 0);
945         //qglDisable(GL_POLYGON_OFFSET_FILL);
946         GL_Color(1, 1, 1, 1);
947         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
948         qglDepthFunc(GL_EQUAL);
949         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
950         qglEnable(GL_CULL_FACE);
951         if (shadowtest)
952                 qglEnable(GL_STENCIL_TEST);
953         else
954                 qglDisable(GL_STENCIL_TEST);
955         if (gl_support_stenciltwoside)
956                 qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
957         qglStencilMask(~0);
958         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
959         // only draw light where this geometry was already rendered AND the
960         // stencil is 128 (values other than this mean shadow)
961         qglStencilFunc(GL_EQUAL, 128, ~0);
962         r_shadowstage = SHADOWSTAGE_LIGHT;
963         c_rt_lights++;
964 }
965
966 void R_Shadow_Stage_End(void)
967 {
968         rmeshstate_t m;
969         memset(&m, 0, sizeof(m));
970         R_Mesh_State(&m);
971         GL_BlendFunc(GL_ONE, GL_ZERO);
972         GL_DepthMask(true);
973         GL_DepthTest(true);
974         qglPolygonOffset(0, 0);
975         //qglDisable(GL_POLYGON_OFFSET_FILL);
976         GL_Color(1, 1, 1, 1);
977         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
978         GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
979         qglDepthFunc(GL_LEQUAL);
980         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
981         qglDisable(GL_STENCIL_TEST);
982         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
983         if (gl_support_stenciltwoside)
984                 qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
985         qglStencilMask(~0);
986         qglStencilFunc(GL_ALWAYS, 128, ~0);
987         r_shadowstage = SHADOWSTAGE_NONE;
988 }
989
990 int R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
991 {
992         int i, ix1, iy1, ix2, iy2;
993         float x1, y1, x2, y2, x, y, f;
994         vec3_t smins, smaxs;
995         vec4_t v, v2;
996         if (!r_shadow_scissor.integer)
997                 return false;
998         // if view is inside the box, just say yes it's visible
999         if (BoxesOverlap(r_vieworigin, r_vieworigin, mins, maxs))
1000         {
1001                 GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
1002                 return false;
1003         }
1004         for (i = 0;i < 3;i++)
1005         {
1006                 if (r_viewforward[i] >= 0)
1007                 {
1008                         v[i] = mins[i];
1009                         v2[i] = maxs[i];
1010                 }
1011                 else
1012                 {
1013                         v[i] = maxs[i];
1014                         v2[i] = mins[i];
1015                 }
1016         }
1017         f = DotProduct(r_viewforward, r_vieworigin) + 1;
1018         if (DotProduct(r_viewforward, v2) <= f)
1019         {
1020                 // entirely behind nearclip plane
1021                 return true;
1022         }
1023         if (DotProduct(r_viewforward, v) >= f)
1024         {
1025                 // entirely infront of nearclip plane
1026                 x1 = y1 = x2 = y2 = 0;
1027                 for (i = 0;i < 8;i++)
1028                 {
1029                         v[0] = (i & 1) ? mins[0] : maxs[0];
1030                         v[1] = (i & 2) ? mins[1] : maxs[1];
1031                         v[2] = (i & 4) ? mins[2] : maxs[2];
1032                         v[3] = 1.0f;
1033                         GL_TransformToScreen(v, v2);
1034                         //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]);
1035                         x = v2[0];
1036                         y = v2[1];
1037                         if (i)
1038                         {
1039                                 if (x1 > x) x1 = x;
1040                                 if (x2 < x) x2 = x;
1041                                 if (y1 > y) y1 = y;
1042                                 if (y2 < y) y2 = y;
1043                         }
1044                         else
1045                         {
1046                                 x1 = x2 = x;
1047                                 y1 = y2 = y;
1048                         }
1049                 }
1050         }
1051         else
1052         {
1053                 // clipped by nearclip plane
1054                 // this is nasty and crude...
1055                 // create viewspace bbox
1056                 for (i = 0;i < 8;i++)
1057                 {
1058                         v[0] = ((i & 1) ? mins[0] : maxs[0]) - r_vieworigin[0];
1059                         v[1] = ((i & 2) ? mins[1] : maxs[1]) - r_vieworigin[1];
1060                         v[2] = ((i & 4) ? mins[2] : maxs[2]) - r_vieworigin[2];
1061                         v2[0] = -DotProduct(v, r_viewleft);
1062                         v2[1] = DotProduct(v, r_viewup);
1063                         v2[2] = DotProduct(v, r_viewforward);
1064                         if (i)
1065                         {
1066                                 if (smins[0] > v2[0]) smins[0] = v2[0];
1067                                 if (smaxs[0] < v2[0]) smaxs[0] = v2[0];
1068                                 if (smins[1] > v2[1]) smins[1] = v2[1];
1069                                 if (smaxs[1] < v2[1]) smaxs[1] = v2[1];
1070                                 if (smins[2] > v2[2]) smins[2] = v2[2];
1071                                 if (smaxs[2] < v2[2]) smaxs[2] = v2[2];
1072                         }
1073                         else
1074                         {
1075                                 smins[0] = smaxs[0] = v2[0];
1076                                 smins[1] = smaxs[1] = v2[1];
1077                                 smins[2] = smaxs[2] = v2[2];
1078                         }
1079                 }
1080                 // now we have a bbox in viewspace
1081                 // clip it to the view plane
1082                 if (smins[2] < 1)
1083                         smins[2] = 1;
1084                 // return true if that culled the box
1085                 if (smins[2] >= smaxs[2])
1086                         return true;
1087                 // ok some of it is infront of the view, transform each corner back to
1088                 // worldspace and then to screenspace and make screen rect
1089                 // initialize these variables just to avoid compiler warnings
1090                 x1 = y1 = x2 = y2 = 0;
1091                 for (i = 0;i < 8;i++)
1092                 {
1093                         v2[0] = (i & 1) ? smins[0] : smaxs[0];
1094                         v2[1] = (i & 2) ? smins[1] : smaxs[1];
1095                         v2[2] = (i & 4) ? smins[2] : smaxs[2];
1096                         v[0] = v2[0] * -r_viewleft[0] + v2[1] * r_viewup[0] + v2[2] * r_viewforward[0] + r_vieworigin[0];
1097                         v[1] = v2[0] * -r_viewleft[1] + v2[1] * r_viewup[1] + v2[2] * r_viewforward[1] + r_vieworigin[1];
1098                         v[2] = v2[0] * -r_viewleft[2] + v2[1] * r_viewup[2] + v2[2] * r_viewforward[2] + r_vieworigin[2];
1099                         v[3] = 1.0f;
1100                         GL_TransformToScreen(v, v2);
1101                         //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]);
1102                         x = v2[0];
1103                         y = v2[1];
1104                         if (i)
1105                         {
1106                                 if (x1 > x) x1 = x;
1107                                 if (x2 < x) x2 = x;
1108                                 if (y1 > y) y1 = y;
1109                                 if (y2 < y) y2 = y;
1110                         }
1111                         else
1112                         {
1113                                 x1 = x2 = x;
1114                                 y1 = y2 = y;
1115                         }
1116                 }
1117                 /*
1118                 // this code doesn't handle boxes with any points behind view properly
1119                 x1 = 1000;x2 = -1000;
1120                 y1 = 1000;y2 = -1000;
1121                 for (i = 0;i < 8;i++)
1122                 {
1123                         v[0] = (i & 1) ? mins[0] : maxs[0];
1124                         v[1] = (i & 2) ? mins[1] : maxs[1];
1125                         v[2] = (i & 4) ? mins[2] : maxs[2];
1126                         v[3] = 1.0f;
1127                         GL_TransformToScreen(v, v2);
1128                         //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]);
1129                         if (v2[2] > 0)
1130                         {
1131                                 x = v2[0];
1132                                 y = v2[1];
1133
1134                                 if (x1 > x) x1 = x;
1135                                 if (x2 < x) x2 = x;
1136                                 if (y1 > y) y1 = y;
1137                                 if (y2 < y) y2 = y;
1138                         }
1139                 }
1140                 */
1141         }
1142         ix1 = x1 - 1.0f;
1143         iy1 = y1 - 1.0f;
1144         ix2 = x2 + 1.0f;
1145         iy2 = y2 + 1.0f;
1146         //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
1147         if (ix1 < r_view_x) ix1 = r_view_x;
1148         if (iy1 < r_view_y) iy1 = r_view_y;
1149         if (ix2 > r_view_x + r_view_width) ix2 = r_view_x + r_view_width;
1150         if (iy2 > r_view_y + r_view_height) iy2 = r_view_y + r_view_height;
1151         if (ix2 <= ix1 || iy2 <= iy1)
1152                 return true;
1153         // set up the scissor rectangle
1154         GL_Scissor(ix1, vid.realheight - iy2, ix2 - ix1, iy2 - iy1);
1155         //qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1);
1156         //qglEnable(GL_SCISSOR_TEST);
1157         c_rt_scissored++;
1158         return false;
1159 }
1160
1161 static void R_Shadow_VertexShadingWithXYZAttenuation(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m)
1162 {
1163         float *color4f = varray_color4f;
1164         float dist, dot, intensity, v[3], n[3];
1165         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1166         {
1167                 Matrix4x4_Transform(m, vertex3f, v);
1168                 if ((dist = DotProduct(v, v)) < 1)
1169                 {
1170                         Matrix4x4_Transform3x3(m, normal3f, n);
1171                         if ((dot = DotProduct(n, v)) > 0)
1172                         {
1173                                 dist = sqrt(dist);
1174                                 intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n));
1175                                 intensity *= pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale;
1176                                 VectorScale(lightcolor, intensity, color4f);
1177                                 color4f[3] = 1;
1178                         }
1179                         else
1180                         {
1181                                 VectorClear(color4f);
1182                                 color4f[3] = 1;
1183                         }
1184                 }
1185                 else
1186                 {
1187                         VectorClear(color4f);
1188                         color4f[3] = 1;
1189                 }
1190         }
1191 }
1192
1193 static void R_Shadow_VertexShadingWithZAttenuation(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m)
1194 {
1195         float *color4f = varray_color4f;
1196         float dist, dot, intensity, v[3], n[3];
1197         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1198         {
1199                 Matrix4x4_Transform(m, vertex3f, v);
1200                 if ((dist = fabs(v[2])) < 1)
1201                 {
1202                         Matrix4x4_Transform3x3(m, normal3f, n);
1203                         if ((dot = DotProduct(n, v)) > 0)
1204                         {
1205                                 intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n));
1206                                 intensity *= pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale;
1207                                 VectorScale(lightcolor, intensity, color4f);
1208                                 color4f[3] = 1;
1209                         }
1210                         else
1211                         {
1212                                 VectorClear(color4f);
1213                                 color4f[3] = 1;
1214                         }
1215                 }
1216                 else
1217                 {
1218                         VectorClear(color4f);
1219                         color4f[3] = 1;
1220                 }
1221         }
1222 }
1223
1224 static void R_Shadow_VertexShading(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m)
1225 {
1226         float *color4f = varray_color4f;
1227         float dot, intensity, v[3], n[3];
1228         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1229         {
1230                 Matrix4x4_Transform(m, vertex3f, v);
1231                 Matrix4x4_Transform3x3(m, normal3f, n);
1232                 if ((dot = DotProduct(n, v)) > 0)
1233                 {
1234                         intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n));
1235                         VectorScale(lightcolor, intensity, color4f);
1236                         color4f[3] = 1;
1237                 }
1238                 else
1239                 {
1240                         VectorClear(color4f);
1241                         color4f[3] = 1;
1242                 }
1243         }
1244 }
1245
1246 static void R_Shadow_VertexNoShadingWithXYZAttenuation(int numverts, const float *vertex3f, const float *lightcolor, const matrix4x4_t *m)
1247 {
1248         float *color4f = varray_color4f;
1249         float dist, intensity, v[3];
1250         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
1251         {
1252                 Matrix4x4_Transform(m, vertex3f, v);
1253                 if ((dist = DotProduct(v, v)) < 1)
1254                 {
1255                         dist = sqrt(dist);
1256                         intensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale;
1257                         VectorScale(lightcolor, intensity, color4f);
1258                         color4f[3] = 1;
1259                 }
1260                 else
1261                 {
1262                         VectorClear(color4f);
1263                         color4f[3] = 1;
1264                 }
1265         }
1266 }
1267
1268 static void R_Shadow_VertexNoShadingWithZAttenuation(int numverts, const float *vertex3f, const float *lightcolor, const matrix4x4_t *m)
1269 {
1270         float *color4f = varray_color4f;
1271         float dist, intensity, v[3];
1272         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
1273         {
1274                 Matrix4x4_Transform(m, vertex3f, v);
1275                 if ((dist = fabs(v[2])) < 1)
1276                 {
1277                         intensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale;
1278                         VectorScale(lightcolor, intensity, color4f);
1279                         color4f[3] = 1;
1280                 }
1281                 else
1282                 {
1283                         VectorClear(color4f);
1284                         color4f[3] = 1;
1285                 }
1286         }
1287 }
1288
1289 // TODO: use glTexGen instead of feeding vertices to texcoordpointer?
1290 #define USETEXMATRIX
1291
1292 #ifndef USETEXMATRIX
1293 // this should be done in a texture matrix or vertex program when possible, but here's code to do it manually
1294 // if hardware texcoord manipulation is not available (or not suitable, this would really benefit from 3DNow! or SSE
1295 static void R_Shadow_Transform_Vertex3f_TexCoord3f(float *tc3f, int numverts, const float *vertex3f, const matrix4x4_t *matrix)
1296 {
1297         do
1298         {
1299                 tc3f[0] = vertex3f[0] * matrix->m[0][0] + vertex3f[1] * matrix->m[0][1] + vertex3f[2] * matrix->m[0][2] + matrix->m[0][3];
1300                 tc3f[1] = vertex3f[0] * matrix->m[1][0] + vertex3f[1] * matrix->m[1][1] + vertex3f[2] * matrix->m[1][2] + matrix->m[1][3];
1301                 tc3f[2] = vertex3f[0] * matrix->m[2][0] + vertex3f[1] * matrix->m[2][1] + vertex3f[2] * matrix->m[2][2] + matrix->m[2][3];
1302                 vertex3f += 3;
1303                 tc3f += 3;
1304         }
1305         while (--numverts);
1306 }
1307
1308 static void R_Shadow_Transform_Vertex3f_TexCoord2f(float *tc2f, int numverts, const float *vertex3f, const matrix4x4_t *matrix)
1309 {
1310         do
1311         {
1312                 tc2f[0] = vertex3f[0] * matrix->m[0][0] + vertex3f[1] * matrix->m[0][1] + vertex3f[2] * matrix->m[0][2] + matrix->m[0][3];
1313                 tc2f[1] = vertex3f[0] * matrix->m[1][0] + vertex3f[1] * matrix->m[1][1] + vertex3f[2] * matrix->m[1][2] + matrix->m[1][3];
1314                 vertex3f += 3;
1315                 tc2f += 2;
1316         }
1317         while (--numverts);
1318 }
1319 #endif
1320
1321 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)
1322 {
1323         int i;
1324         float lightdir[3];
1325         for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
1326         {
1327                 VectorSubtract(vertex3f, relativelightorigin, lightdir);
1328                 // the cubemap normalizes this for us
1329                 out3f[0] = DotProduct(svector3f, lightdir);
1330                 out3f[1] = DotProduct(tvector3f, lightdir);
1331                 out3f[2] = DotProduct(normal3f, lightdir);
1332         }
1333 }
1334
1335 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)
1336 {
1337         int i;
1338         float lightdir[3], eyedir[3], halfdir[3];
1339         for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
1340         {
1341                 VectorSubtract(vertex3f, relativelightorigin, lightdir);
1342                 VectorNormalizeFast(lightdir);
1343                 VectorSubtract(vertex3f, relativeeyeorigin, eyedir);
1344                 VectorNormalizeFast(eyedir);
1345                 VectorAdd(lightdir, eyedir, halfdir);
1346                 // the cubemap normalizes this for us
1347                 out3f[0] = DotProduct(svector3f, halfdir);
1348                 out3f[1] = DotProduct(tvector3f, halfdir);
1349                 out3f[2] = DotProduct(normal3f, halfdir);
1350         }
1351 }
1352
1353 void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const float *texcoord2f, const float *relativelightorigin, const float *relativeeyeorigin, const float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *basetexture, rtexture_t *bumptexture, rtexture_t *glosstexture, rtexture_t *lightcubemap, vec_t ambientscale, vec_t diffusescale, vec_t specularscale)
1354 {
1355         int renders;
1356         float color[3], color2[3], colorscale;
1357         rmeshstate_t m;
1358         if (!bumptexture)
1359                 bumptexture = r_shadow_blankbumptexture;
1360         if (!glosstexture)
1361                 glosstexture = r_shadow_blankglosstexture;
1362         // FIXME: support EF_NODEPTHTEST
1363         GL_DepthMask(false);
1364         GL_DepthTest(true);
1365         if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil)
1366         {
1367                 if (ambientscale)
1368                 {
1369                         GL_Color(1,1,1,1);
1370                         colorscale = r_shadow_lightintensityscale.value * ambientscale;
1371                         // colorscale accounts for how much we multiply the brightness
1372                         // during combine.
1373                         //
1374                         // mult is how many times the final pass of the lighting will be
1375                         // performed to get more brightness than otherwise possible.
1376                         //
1377                         // Limit mult to 64 for sanity sake.
1378                         if (r_shadow_texture3d.integer && lightcubemap && r_textureunits.integer >= 4)
1379                         {
1380                                 // 3 3D combine path (Geforce3, Radeon 8500)
1381                                 memset(&m, 0, sizeof(m));
1382                                 m.pointer_vertex = vertex3f;
1383                                 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1384 #ifdef USETEXMATRIX
1385                                 m.pointer_texcoord3f[0] = vertex3f;
1386                                 m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1387 #else
1388                                 m.pointer_texcoord3f[0] = varray_texcoord3f[0];
1389                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1390 #endif
1391                                 m.tex[1] = R_GetTexture(basetexture);
1392                                 m.pointer_texcoord[1] = texcoord2f;
1393                                 m.texcubemap[2] = R_GetTexture(lightcubemap);
1394 #ifdef USETEXMATRIX
1395                                 m.pointer_texcoord3f[2] = vertex3f;
1396                                 m.texmatrix[2] = *matrix_modeltolight;
1397 #else
1398                                 m.pointer_texcoord3f[2] = varray_texcoord3f[2];
1399                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[2], numverts, vertex3f, matrix_modeltolight);
1400 #endif
1401                         }
1402                         else if (r_shadow_texture3d.integer && !lightcubemap && r_textureunits.integer >= 2)
1403                         {
1404                                 // 2 3D combine path (Geforce3, original Radeon)
1405                                 memset(&m, 0, sizeof(m));
1406                                 m.pointer_vertex = vertex3f;
1407                                 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1408 #ifdef USETEXMATRIX
1409                                 m.pointer_texcoord3f[0] = vertex3f;
1410                                 m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1411 #else
1412                                 m.pointer_texcoord3f[0] = varray_texcoord3f[0];
1413                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1414 #endif
1415                                 m.tex[1] = R_GetTexture(basetexture);
1416                                 m.pointer_texcoord[1] = texcoord2f;
1417                         }
1418                         else if (r_textureunits.integer >= 4 && lightcubemap)
1419                         {
1420                                 // 4 2D combine path (Geforce3, Radeon 8500)
1421                                 memset(&m, 0, sizeof(m));
1422                                 m.pointer_vertex = vertex3f;
1423                                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1424 #ifdef USETEXMATRIX
1425                                 m.pointer_texcoord3f[0] = vertex3f;
1426                                 m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1427 #else
1428                                 m.pointer_texcoord[0] = varray_texcoord2f[0];
1429                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1430 #endif
1431                                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1432 #ifdef USETEXMATRIX
1433                                 m.pointer_texcoord3f[1] = vertex3f;
1434                                 m.texmatrix[1] = *matrix_modeltoattenuationz;
1435 #else
1436                                 m.pointer_texcoord[1] = varray_texcoord2f[1];
1437                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz);
1438 #endif
1439                                 m.tex[2] = R_GetTexture(basetexture);
1440                                 m.pointer_texcoord[2] = texcoord2f;
1441                                 if (lightcubemap)
1442                                 {
1443                                         m.texcubemap[3] = R_GetTexture(lightcubemap);
1444 #ifdef USETEXMATRIX
1445                                         m.pointer_texcoord3f[3] = vertex3f;
1446                                         m.texmatrix[3] = *matrix_modeltolight;
1447 #else
1448                                         m.pointer_texcoord3f[3] = varray_texcoord3f[3];
1449                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[3], numverts, vertex3f, matrix_modeltolight);
1450 #endif
1451                                 }
1452                         }
1453                         else if (r_textureunits.integer >= 3 && !lightcubemap)
1454                         {
1455                                 // 3 2D combine path (Geforce3, original Radeon)
1456                                 memset(&m, 0, sizeof(m));
1457                                 m.pointer_vertex = vertex3f;
1458                                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1459 #ifdef USETEXMATRIX
1460                                 m.pointer_texcoord3f[0] = vertex3f;
1461                                 m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1462 #else
1463                                 m.pointer_texcoord[0] = varray_texcoord2f[0];
1464                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1465 #endif
1466                                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1467 #ifdef USETEXMATRIX
1468                                 m.pointer_texcoord3f[1] = vertex3f;
1469                                 m.texmatrix[1] = *matrix_modeltoattenuationz;
1470 #else
1471                                 m.pointer_texcoord[1] = varray_texcoord2f[1];
1472                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz);
1473 #endif
1474                                 m.tex[2] = R_GetTexture(basetexture);
1475                                 m.pointer_texcoord[2] = texcoord2f;
1476                         }
1477                         else
1478                         {
1479                                 // 2/2/2 2D combine path (any dot3 card)
1480                                 memset(&m, 0, sizeof(m));
1481                                 m.pointer_vertex = vertex3f;
1482                                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1483 #ifdef USETEXMATRIX
1484                                 m.pointer_texcoord3f[0] = vertex3f;
1485                                 m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1486 #else
1487                                 m.pointer_texcoord[0] = varray_texcoord2f[0];
1488                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1489 #endif
1490                                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1491 #ifdef USETEXMATRIX
1492                                 m.pointer_texcoord3f[1] = vertex3f;
1493                                 m.texmatrix[1] = *matrix_modeltoattenuationz;
1494 #else
1495                                 m.pointer_texcoord[1] = varray_texcoord2f[1];
1496                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz);
1497 #endif
1498                                 R_Mesh_State(&m);
1499                                 GL_ColorMask(0,0,0,1);
1500                                 GL_BlendFunc(GL_ONE, GL_ZERO);
1501                                 GL_LockArrays(0, numverts);
1502                                 R_Mesh_Draw(numverts, numtriangles, elements);
1503                                 GL_LockArrays(0, 0);
1504                                 c_rt_lightmeshes++;
1505                                 c_rt_lighttris += numtriangles;
1506         
1507                                 memset(&m, 0, sizeof(m));
1508                                 m.pointer_vertex = vertex3f;
1509                                 m.tex[0] = R_GetTexture(basetexture);
1510                                 m.pointer_texcoord[0] = texcoord2f;
1511                                 if (lightcubemap)
1512                                 {
1513                                         m.texcubemap[1] = R_GetTexture(lightcubemap);
1514 #ifdef USETEXMATRIX
1515                                         m.pointer_texcoord3f[1] = vertex3f;
1516                                         m.texmatrix[1] = *matrix_modeltolight;
1517 #else
1518                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1519                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
1520 #endif
1521                                 }
1522                         }
1523                         // this final code is shared
1524                         R_Mesh_State(&m);
1525                         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
1526                         GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1527                         VectorScale(lightcolor, colorscale, color2);
1528                         GL_LockArrays(0, numverts);
1529                         for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
1530                         {
1531                                 GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
1532                                 R_Mesh_Draw(numverts, numtriangles, elements);
1533                                 c_rt_lightmeshes++;
1534                                 c_rt_lighttris += numtriangles;
1535                         }
1536                         GL_LockArrays(0, 0);
1537                 }
1538                 if (diffusescale)
1539                 {
1540                         GL_Color(1,1,1,1);
1541                         colorscale = r_shadow_lightintensityscale.value * diffusescale;
1542                         // colorscale accounts for how much we multiply the brightness
1543                         // during combine.
1544                         //
1545                         // mult is how many times the final pass of the lighting will be
1546                         // performed to get more brightness than otherwise possible.
1547                         //
1548                         // Limit mult to 64 for sanity sake.
1549                         if (r_shadow_texture3d.integer && r_textureunits.integer >= 4)
1550                         {
1551                                 // 3/2 3D combine path (Geforce3, Radeon 8500)
1552                                 memset(&m, 0, sizeof(m));
1553                                 m.pointer_vertex = vertex3f;
1554                                 m.tex[0] = R_GetTexture(bumptexture);
1555                                 m.texcombinergb[0] = GL_REPLACE;
1556                                 m.pointer_texcoord[0] = texcoord2f;
1557                                 m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1558                                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1559                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1560                                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin);
1561                                 m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture);
1562 #ifdef USETEXMATRIX
1563                                 m.pointer_texcoord3f[2] = vertex3f;
1564                                 m.texmatrix[2] = *matrix_modeltoattenuationxyz;
1565 #else
1566                                 m.pointer_texcoord3f[2] = varray_texcoord3f[2];
1567                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[2], numverts, vertex3f, matrix_modeltoattenuationxyz);
1568 #endif
1569                                 R_Mesh_State(&m);
1570                                 GL_ColorMask(0,0,0,1);
1571                                 GL_BlendFunc(GL_ONE, GL_ZERO);
1572                                 GL_LockArrays(0, numverts);
1573                                 R_Mesh_Draw(numverts, numtriangles, elements);
1574                                 GL_LockArrays(0, 0);
1575                                 c_rt_lightmeshes++;
1576                                 c_rt_lighttris += numtriangles;
1577         
1578                                 memset(&m, 0, sizeof(m));
1579                                 m.pointer_vertex = vertex3f;
1580                                 m.tex[0] = R_GetTexture(basetexture);
1581                                 m.pointer_texcoord[0] = texcoord2f;
1582                                 if (lightcubemap)
1583                                 {
1584                                         m.texcubemap[1] = R_GetTexture(lightcubemap);
1585 #ifdef USETEXMATRIX
1586                                         m.pointer_texcoord3f[1] = vertex3f;
1587                                         m.texmatrix[1] = *matrix_modeltolight;
1588 #else
1589                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1590                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
1591 #endif
1592                                 }
1593                         }
1594                         else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap)
1595                         {
1596                                 // 1/2/2 3D combine path (original Radeon)
1597                                 memset(&m, 0, sizeof(m));
1598                                 m.pointer_vertex = vertex3f;
1599                                 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1600 #ifdef USETEXMATRIX
1601                                 m.pointer_texcoord3f[0] = vertex3f;
1602                                 m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1603 #else
1604                                 m.pointer_texcoord3f[0] = varray_texcoord3f[0];
1605                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1606 #endif
1607                                 R_Mesh_State(&m);
1608                                 GL_ColorMask(0,0,0,1);
1609                                 GL_BlendFunc(GL_ONE, GL_ZERO);
1610                                 GL_LockArrays(0, numverts);
1611                                 R_Mesh_Draw(numverts, numtriangles, elements);
1612                                 GL_LockArrays(0, 0);
1613                                 c_rt_lightmeshes++;
1614                                 c_rt_lighttris += numtriangles;
1615         
1616                                 memset(&m, 0, sizeof(m));
1617                                 m.pointer_vertex = vertex3f;
1618                                 m.tex[0] = R_GetTexture(bumptexture);
1619                                 m.texcombinergb[0] = GL_REPLACE;
1620                                 m.pointer_texcoord[0] = texcoord2f;
1621                                 m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1622                                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1623                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1624                                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin);
1625                                 R_Mesh_State(&m);
1626                                 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
1627                                 GL_LockArrays(0, numverts);
1628                                 R_Mesh_Draw(numverts, numtriangles, elements);
1629                                 GL_LockArrays(0, 0);
1630                                 c_rt_lightmeshes++;
1631                                 c_rt_lighttris += numtriangles;
1632         
1633                                 memset(&m, 0, sizeof(m));
1634                                 m.pointer_vertex = vertex3f;
1635                                 m.tex[0] = R_GetTexture(basetexture);
1636                                 m.pointer_texcoord[0] = texcoord2f;
1637                                 if (lightcubemap)
1638                                 {
1639                                         m.texcubemap[1] = R_GetTexture(lightcubemap);
1640 #ifdef USETEXMATRIX
1641                                         m.pointer_texcoord3f[1] = vertex3f;
1642                                         m.texmatrix[1] = *matrix_modeltolight;
1643 #else
1644                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1645                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
1646 #endif
1647                                 }
1648                         }
1649                         else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap)
1650                         {
1651                                 // 2/2 3D combine path (original Radeon)
1652                                 memset(&m, 0, sizeof(m));
1653                                 m.pointer_vertex = vertex3f;
1654                                 m.tex[0] = R_GetTexture(bumptexture);
1655                                 m.texcombinergb[0] = GL_REPLACE;
1656                                 m.pointer_texcoord[0] = texcoord2f;
1657                                 m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1658                                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1659                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1660                                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin);
1661                                 R_Mesh_State(&m);
1662                                 GL_ColorMask(0,0,0,1);
1663                                 GL_BlendFunc(GL_ONE, GL_ZERO);
1664                                 GL_LockArrays(0, numverts);
1665                                 R_Mesh_Draw(numverts, numtriangles, elements);
1666                                 GL_LockArrays(0, 0);
1667                                 c_rt_lightmeshes++;
1668                                 c_rt_lighttris += numtriangles;
1669         
1670                                 memset(&m, 0, sizeof(m));
1671                                 m.pointer_vertex = vertex3f;
1672                                 m.tex[0] = R_GetTexture(basetexture);
1673                                 m.pointer_texcoord[0] = texcoord2f;
1674                                 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
1675 #ifdef USETEXMATRIX
1676                                 m.pointer_texcoord3f[1] = vertex3f;
1677                                 m.texmatrix[1] = *matrix_modeltoattenuationxyz;
1678 #else
1679                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1680                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz);
1681 #endif
1682                         }
1683                         else if (r_textureunits.integer >= 4)
1684                         {
1685                                 // 4/2 2D combine path (Geforce3, Radeon 8500)
1686                                 memset(&m, 0, sizeof(m));
1687                                 m.pointer_vertex = vertex3f;
1688                                 m.tex[0] = R_GetTexture(bumptexture);
1689                                 m.texcombinergb[0] = GL_REPLACE;
1690                                 m.pointer_texcoord[0] = texcoord2f;
1691                                 m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1692                                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1693                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1694                                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin);
1695                                 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
1696 #ifdef USETEXMATRIX
1697                                 m.pointer_texcoord3f[2] = vertex3f;
1698                                 m.texmatrix[2] = *matrix_modeltoattenuationxyz;
1699 #else
1700                                 m.pointer_texcoord[2] = varray_texcoord2f[2];
1701                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2], numverts, vertex3f, matrix_modeltoattenuationxyz);
1702 #endif
1703                                 m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture);
1704 #ifdef USETEXMATRIX
1705                                 m.pointer_texcoord3f[3] = vertex3f;
1706                                 m.texmatrix[3] = *matrix_modeltoattenuationz;
1707 #else
1708                                 m.pointer_texcoord[3] = varray_texcoord2f[3];
1709                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[3], numverts, vertex3f, matrix_modeltoattenuationz);
1710 #endif
1711                                 R_Mesh_State(&m);
1712                                 GL_ColorMask(0,0,0,1);
1713                                 GL_BlendFunc(GL_ONE, GL_ZERO);
1714                                 GL_LockArrays(0, numverts);
1715                                 R_Mesh_Draw(numverts, numtriangles, elements);
1716                                 GL_LockArrays(0, 0);
1717                                 c_rt_lightmeshes++;
1718                                 c_rt_lighttris += numtriangles;
1719         
1720                                 memset(&m, 0, sizeof(m));
1721                                 m.pointer_vertex = vertex3f;
1722                                 m.tex[0] = R_GetTexture(basetexture);
1723                                 m.pointer_texcoord[0] = texcoord2f;
1724                                 if (lightcubemap)
1725                                 {
1726                                         m.texcubemap[1] = R_GetTexture(lightcubemap);
1727 #ifdef USETEXMATRIX
1728                                         m.pointer_texcoord3f[1] = vertex3f;
1729                                         m.texmatrix[1] = *matrix_modeltolight;
1730 #else
1731                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1732                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
1733 #endif
1734                                 }
1735                         }
1736                         else
1737                         {
1738                                 // 2/2/2 2D combine path (any dot3 card)
1739                                 memset(&m, 0, sizeof(m));
1740                                 m.pointer_vertex = vertex3f;
1741                                 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1742 #ifdef USETEXMATRIX
1743                                 m.pointer_texcoord3f[0] = vertex3f;
1744                                 m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1745 #else
1746                                 m.pointer_texcoord[0] = varray_texcoord2f[0];
1747                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1748 #endif
1749                                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1750 #ifdef USETEXMATRIX
1751                                 m.pointer_texcoord3f[1] = vertex3f;
1752                                 m.texmatrix[1] = *matrix_modeltoattenuationz;
1753 #else
1754                                 m.pointer_texcoord[1] = varray_texcoord2f[1];
1755                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz);
1756 #endif
1757                                 R_Mesh_State(&m);
1758                                 GL_ColorMask(0,0,0,1);
1759                                 GL_BlendFunc(GL_ONE, GL_ZERO);
1760                                 GL_LockArrays(0, numverts);
1761                                 R_Mesh_Draw(numverts, numtriangles, elements);
1762                                 GL_LockArrays(0, 0);
1763                                 c_rt_lightmeshes++;
1764                                 c_rt_lighttris += numtriangles;
1765         
1766                                 memset(&m, 0, sizeof(m));
1767                                 m.pointer_vertex = vertex3f;
1768                                 m.tex[0] = R_GetTexture(bumptexture);
1769                                 m.texcombinergb[0] = GL_REPLACE;
1770                                 m.pointer_texcoord[0] = texcoord2f;
1771                                 m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1772                                 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1773                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1774                                 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin);
1775                                 R_Mesh_State(&m);
1776                                 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
1777                                 GL_LockArrays(0, numverts);
1778                                 R_Mesh_Draw(numverts, numtriangles, elements);
1779                                 GL_LockArrays(0, 0);
1780                                 c_rt_lightmeshes++;
1781                                 c_rt_lighttris += numtriangles;
1782         
1783                                 memset(&m, 0, sizeof(m));
1784                                 m.pointer_vertex = vertex3f;
1785                                 m.tex[0] = R_GetTexture(basetexture);
1786                                 m.pointer_texcoord[0] = texcoord2f;
1787                                 if (lightcubemap)
1788                                 {
1789                                         m.texcubemap[1] = R_GetTexture(lightcubemap);
1790 #ifdef USETEXMATRIX
1791                                         m.pointer_texcoord3f[1] = vertex3f;
1792                                         m.texmatrix[1] = *matrix_modeltolight;
1793 #else
1794                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1795                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
1796 #endif
1797                                 }
1798                         }
1799                         // this final code is shared
1800                         R_Mesh_State(&m);
1801                         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
1802                         GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1803                         VectorScale(lightcolor, colorscale, color2);
1804                         GL_LockArrays(0, numverts);
1805                         for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
1806                         {
1807                                 GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
1808                                 R_Mesh_Draw(numverts, numtriangles, elements);
1809                                 c_rt_lightmeshes++;
1810                                 c_rt_lighttris += numtriangles;
1811                         }
1812                         GL_LockArrays(0, 0);
1813                 }
1814                 if (specularscale && (r_shadow_gloss.integer >= 2 || (r_shadow_gloss.integer >= 1 && glosstexture != r_shadow_blankglosstexture)))
1815                 {
1816                         // FIXME: detect blendsquare!
1817                         //if (gl_support_blendsquare)
1818                         {
1819                                 colorscale = r_shadow_lightintensityscale.value * r_shadow_glossintensity.value * specularscale;
1820                                 if (glosstexture == r_shadow_blankglosstexture)
1821                                         colorscale *= r_shadow_gloss2intensity.value;
1822                                 GL_Color(1,1,1,1);
1823                                 if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare!
1824                                 {
1825                                         // 2/0/0/1/2 3D combine blendsquare path
1826                                         memset(&m, 0, sizeof(m));
1827                                         m.pointer_vertex = vertex3f;
1828                                         m.tex[0] = R_GetTexture(bumptexture);
1829                                         m.pointer_texcoord[0] = texcoord2f;
1830                                         m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1831                                         m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1832                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1833                                         R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin);
1834                                         R_Mesh_State(&m);
1835                                         GL_ColorMask(0,0,0,1);
1836                                         // this squares the result
1837                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
1838                                         GL_LockArrays(0, numverts);
1839                                         R_Mesh_Draw(numverts, numtriangles, elements);
1840                                         GL_LockArrays(0, 0);
1841                                         c_rt_lightmeshes++;
1842                                         c_rt_lighttris += numtriangles;
1843                 
1844                                         memset(&m, 0, sizeof(m));
1845                                         m.pointer_vertex = vertex3f;
1846                                         R_Mesh_State(&m);
1847                                         GL_LockArrays(0, numverts);
1848                                         // square alpha in framebuffer a few times to make it shiny
1849                                         GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
1850                                         // these comments are a test run through this math for intensity 0.5
1851                                         // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
1852                                         // 0.25 * 0.25 = 0.0625 (this is another pass)
1853                                         // 0.0625 * 0.0625 = 0.00390625 (this is another pass)
1854                                         R_Mesh_Draw(numverts, numtriangles, elements);
1855                                         c_rt_lightmeshes++;
1856                                         c_rt_lighttris += numtriangles;
1857                                         R_Mesh_Draw(numverts, numtriangles, elements);
1858                                         c_rt_lightmeshes++;
1859                                         c_rt_lighttris += numtriangles;
1860                                         GL_LockArrays(0, 0);
1861                 
1862                                         memset(&m, 0, sizeof(m));
1863                                         m.pointer_vertex = vertex3f;
1864                                         m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1865 #ifdef USETEXMATRIX
1866                                         m.pointer_texcoord3f[0] = vertex3f;
1867                                         m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1868 #else
1869                                         m.pointer_texcoord3f[0] = varray_texcoord3f[0];
1870                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1871 #endif
1872                                         R_Mesh_State(&m);
1873                                         GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
1874                                         GL_LockArrays(0, numverts);
1875                                         R_Mesh_Draw(numverts, numtriangles, elements);
1876                                         GL_LockArrays(0, 0);
1877                                         c_rt_lightmeshes++;
1878                                         c_rt_lighttris += numtriangles;
1879                 
1880                                         memset(&m, 0, sizeof(m));
1881                                         m.pointer_vertex = vertex3f;
1882                                         m.tex[0] = R_GetTexture(glosstexture);
1883                                         m.pointer_texcoord[0] = texcoord2f;
1884                                         if (lightcubemap)
1885                                         {
1886                                                 m.texcubemap[1] = R_GetTexture(lightcubemap);
1887 #ifdef USETEXMATRIX
1888                                                 m.pointer_texcoord3f[1] = vertex3f;
1889                                                 m.texmatrix[1] = *matrix_modeltolight;
1890 #else
1891                                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1892                                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
1893 #endif
1894                                         }
1895                                 }
1896                                 else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare!
1897                                 {
1898                                         // 2/0/0/2 3D combine blendsquare path
1899                                         memset(&m, 0, sizeof(m));
1900                                         m.pointer_vertex = vertex3f;
1901                                         m.tex[0] = R_GetTexture(bumptexture);
1902                                         m.pointer_texcoord[0] = texcoord2f;
1903                                         m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1904                                         m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1905                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1906                                         R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin);
1907                                         R_Mesh_State(&m);
1908                                         GL_ColorMask(0,0,0,1);
1909                                         // this squares the result
1910                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
1911                                         GL_LockArrays(0, numverts);
1912                                         R_Mesh_Draw(numverts, numtriangles, elements);
1913                                         GL_LockArrays(0, 0);
1914                                         c_rt_lightmeshes++;
1915                                         c_rt_lighttris += numtriangles;
1916                 
1917                                         memset(&m, 0, sizeof(m));
1918                                         m.pointer_vertex = vertex3f;
1919                                         R_Mesh_State(&m);
1920                                         GL_LockArrays(0, numverts);
1921                                         // square alpha in framebuffer a few times to make it shiny
1922                                         GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
1923                                         // these comments are a test run through this math for intensity 0.5
1924                                         // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
1925                                         // 0.25 * 0.25 = 0.0625 (this is another pass)
1926                                         // 0.0625 * 0.0625 = 0.00390625 (this is another pass)
1927                                         R_Mesh_Draw(numverts, numtriangles, elements);
1928                                         c_rt_lightmeshes++;
1929                                         c_rt_lighttris += numtriangles;
1930                                         R_Mesh_Draw(numverts, numtriangles, elements);
1931                                         c_rt_lightmeshes++;
1932                                         c_rt_lighttris += numtriangles;
1933                                         GL_LockArrays(0, 0);
1934                 
1935                                         memset(&m, 0, sizeof(m));
1936                                         m.pointer_vertex = vertex3f;
1937                                         m.tex[0] = R_GetTexture(glosstexture);
1938                                         m.pointer_texcoord[0] = texcoord2f;
1939                                         m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
1940 #ifdef USETEXMATRIX
1941                                         m.pointer_texcoord3f[1] = vertex3f;
1942                                         m.texmatrix[1] = *matrix_modeltoattenuationxyz;
1943 #else
1944                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1945                                         R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz);
1946 #endif
1947                                 }
1948                                 else
1949                                 {
1950                                         // 2/0/0/2/2 2D combine blendsquare path
1951                                         memset(&m, 0, sizeof(m));
1952                                         m.pointer_vertex = vertex3f;
1953                                         m.tex[0] = R_GetTexture(bumptexture);
1954                                         m.pointer_texcoord[0] = texcoord2f;
1955                                         m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture);
1956                                         m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1957                                         m.pointer_texcoord3f[1] = varray_texcoord3f[1];
1958                                         R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin);
1959                                         R_Mesh_State(&m);
1960                                         GL_ColorMask(0,0,0,1);
1961                                         // this squares the result
1962                                         GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
1963                                         GL_LockArrays(0, numverts);
1964                                         R_Mesh_Draw(numverts, numtriangles, elements);
1965                                         GL_LockArrays(0, 0);
1966                                         c_rt_lightmeshes++;
1967                                         c_rt_lighttris += numtriangles;
1968                 
1969                                         memset(&m, 0, sizeof(m));
1970                                         m.pointer_vertex = vertex3f;
1971                                         R_Mesh_State(&m);
1972                                         GL_LockArrays(0, numverts);
1973                                         // square alpha in framebuffer a few times to make it shiny
1974                                         GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
1975                                         // these comments are a test run through this math for intensity 0.5
1976                                         // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier)
1977                                         // 0.25 * 0.25 = 0.0625 (this is another pass)
1978                                         // 0.0625 * 0.0625 = 0.00390625 (this is another pass)
1979                                         R_Mesh_Draw(numverts, numtriangles, elements);
1980                                         c_rt_lightmeshes++;
1981                                         c_rt_lighttris += numtriangles;
1982                                         R_Mesh_Draw(numverts, numtriangles, elements);
1983                                         c_rt_lightmeshes++;
1984                                         c_rt_lighttris += numtriangles;
1985                                         GL_LockArrays(0, 0);
1986                 
1987                                         memset(&m, 0, sizeof(m));
1988                                         m.pointer_vertex = vertex3f;
1989                                         m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1990 #ifdef USETEXMATRIX
1991                                         m.pointer_texcoord3f[0] = vertex3f;
1992                                         m.texmatrix[0] = *matrix_modeltoattenuationxyz;
1993 #else
1994                                         m.pointer_texcoord[0] = varray_texcoord2f[0];
1995                                         R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz);
1996 #endif
1997                                         m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1998 #ifdef USETEXMATRIX
1999                                         m.pointer_texcoord3f[1] = vertex3f;
2000                                         m.texmatrix[1] = *matrix_modeltoattenuationz;
2001 #else
2002                                         m.pointer_texcoord[1] = varray_texcoord2f[1];
2003                                         R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz);
2004 #endif
2005                                         R_Mesh_State(&m);
2006                                         GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
2007                                         GL_LockArrays(0, numverts);
2008                                         R_Mesh_Draw(numverts, numtriangles, elements);
2009                                         GL_LockArrays(0, 0);
2010                                         c_rt_lightmeshes++;
2011                                         c_rt_lighttris += numtriangles;
2012                 
2013                                         memset(&m, 0, sizeof(m));
2014                                         m.pointer_vertex = vertex3f;
2015                                         m.tex[0] = R_GetTexture(glosstexture);
2016                                         m.pointer_texcoord[0] = texcoord2f;
2017                                         if (lightcubemap)
2018                                         {
2019                                                 m.texcubemap[1] = R_GetTexture(lightcubemap);
2020 #ifdef USETEXMATRIX
2021                                                 m.pointer_texcoord3f[1] = vertex3f;
2022                                                 m.texmatrix[1] = *matrix_modeltolight;
2023 #else
2024                                                 m.pointer_texcoord3f[1] = varray_texcoord3f[1];
2025                                                 R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight);
2026 #endif
2027                                         }
2028                                 }
2029                                 R_Mesh_State(&m);
2030                                 GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0);
2031                                 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2032                                 VectorScale(lightcolor, colorscale, color2);
2033                                 GL_LockArrays(0, numverts);
2034                                 for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
2035                                 {
2036                                         GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
2037                                         R_Mesh_Draw(numverts, numtriangles, elements);
2038                                         c_rt_lightmeshes++;
2039                                         c_rt_lighttris += numtriangles;
2040                                 }
2041                                 GL_LockArrays(0, 0);
2042                         }
2043                 }
2044         }
2045         else
2046         {
2047                 if (ambientscale)
2048                 {
2049                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2050                         VectorScale(lightcolor, r_shadow_lightintensityscale.value * ambientscale, color2);
2051                         memset(&m, 0, sizeof(m));
2052                         m.pointer_vertex = vertex3f;
2053                         m.tex[0] = R_GetTexture(basetexture);
2054                         m.pointer_texcoord[0] = texcoord2f;
2055                         if (r_textureunits.integer >= 2)
2056                         {
2057                                 // voodoo2
2058                                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2059 #ifdef USETEXMATRIX
2060                                 m.pointer_texcoord3f[1] = vertex3f;
2061                                 m.texmatrix[1] = *matrix_modeltoattenuationxyz;
2062 #else
2063                                 m.pointer_texcoord[1] = varray_texcoord2f[1];
2064                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationxyz);
2065 #endif
2066                                 if (r_textureunits.integer >= 3)
2067                                 {
2068                                         // Geforce3/Radeon class but not using dot3
2069                                         m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
2070 #ifdef USETEXMATRIX
2071                                         m.pointer_texcoord3f[2] = vertex3f;
2072                                         m.texmatrix[2] = *matrix_modeltoattenuationz;
2073 #else
2074                                         m.pointer_texcoord[2] = varray_texcoord2f[2];
2075                                         R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2], numverts, vertex3f, matrix_modeltoattenuationz);
2076 #endif
2077                                 }
2078                         }
2079                         if (r_textureunits.integer >= 3)
2080                                 m.pointer_color = NULL;
2081                         else
2082                                 m.pointer_color = varray_color4f;
2083                         R_Mesh_State(&m);
2084                         for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
2085                         {
2086                                 color[0] = bound(0, color2[0], 1);
2087                                 color[1] = bound(0, color2[1], 1);
2088                                 color[2] = bound(0, color2[2], 1);
2089                                 if (r_textureunits.integer >= 3)
2090                                         GL_Color(color[0], color[1], color[2], 1);
2091                                 else if (r_textureunits.integer >= 2)
2092                                         R_Shadow_VertexNoShadingWithZAttenuation(numverts, vertex3f, color, matrix_modeltolight);
2093                                 else
2094                                         R_Shadow_VertexNoShadingWithXYZAttenuation(numverts, vertex3f, color, matrix_modeltolight);
2095                                 GL_LockArrays(0, numverts);
2096                                 R_Mesh_Draw(numverts, numtriangles, elements);
2097                                 GL_LockArrays(0, 0);
2098                                 c_rt_lightmeshes++;
2099                                 c_rt_lighttris += numtriangles;
2100                         }
2101                 }
2102                 if (diffusescale)
2103                 {
2104                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2105                         VectorScale(lightcolor, r_shadow_lightintensityscale.value * diffusescale, color2);
2106                         memset(&m, 0, sizeof(m));
2107                         m.pointer_vertex = vertex3f;
2108                         m.pointer_color = varray_color4f;
2109                         m.tex[0] = R_GetTexture(basetexture);
2110                         m.pointer_texcoord[0] = texcoord2f;
2111                         if (r_textureunits.integer >= 2)
2112                         {
2113                                 // voodoo2
2114                                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2115 #ifdef USETEXMATRIX
2116                                 m.pointer_texcoord3f[1] = vertex3f;
2117                                 m.texmatrix[1] = *matrix_modeltoattenuationxyz;
2118 #else
2119                                 m.pointer_texcoord[1] = varray_texcoord2f[1];
2120                                 R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationxyz);
2121 #endif
2122                                 if (r_textureunits.integer >= 3)
2123                                 {
2124                                         // Geforce3/Radeon class but not using dot3
2125                                         m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
2126 #ifdef USETEXMATRIX
2127                                         m.pointer_texcoord3f[2] = vertex3f;
2128                                         m.texmatrix[2] = *matrix_modeltoattenuationz;
2129 #else
2130                                         m.pointer_texcoord[2] = varray_texcoord2f[2];
2131                                         R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2], numverts, vertex3f, matrix_modeltoattenuationz);
2132 #endif
2133                                 }
2134                         }
2135                         R_Mesh_State(&m);
2136                         for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--)
2137                         {
2138                                 color[0] = bound(0, color2[0], 1);
2139                                 color[1] = bound(0, color2[1], 1);
2140                                 color[2] = bound(0, color2[2], 1);
2141                                 if (r_textureunits.integer >= 3)
2142                                         R_Shadow_VertexShading(numverts, vertex3f, normal3f, color, matrix_modeltolight);
2143                                 else if (r_textureunits.integer >= 2)
2144                                         R_Shadow_VertexShadingWithZAttenuation(numverts, vertex3f, normal3f, color, matrix_modeltolight);
2145                                 else
2146                                         R_Shadow_VertexShadingWithXYZAttenuation(numverts, vertex3f, normal3f, color, matrix_modeltolight);
2147                                 GL_LockArrays(0, numverts);
2148                                 R_Mesh_Draw(numverts, numtriangles, elements);
2149                                 GL_LockArrays(0, 0);
2150                                 c_rt_lightmeshes++;
2151                                 c_rt_lighttris += numtriangles;
2152                         }
2153                 }
2154         }
2155 }
2156
2157 void R_RTLight_UpdateFromDLight(rtlight_t *rtlight, const dlight_t *light, int isstatic)
2158 {
2159         int j, k;
2160         float scale;
2161         R_RTLight_Uncompile(rtlight);
2162         memset(rtlight, 0, sizeof(*rtlight));
2163
2164         VectorCopy(light->origin, rtlight->shadoworigin);
2165         VectorCopy(light->color, rtlight->color);
2166         rtlight->radius = light->radius;
2167         //rtlight->cullradius = rtlight->radius;
2168         //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
2169         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
2170         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
2171         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
2172         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
2173         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
2174         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
2175         rtlight->cubemapname[0] = 0;
2176         if (light->cubemapname[0])
2177                 strcpy(rtlight->cubemapname, light->cubemapname);
2178         else if (light->cubemapnum > 0)
2179                 sprintf(rtlight->cubemapname, "cubemaps/%i", light->cubemapnum);
2180         rtlight->shadow = light->shadow;
2181         rtlight->corona = light->corona;
2182         rtlight->style = light->style;
2183         rtlight->isstatic = isstatic;
2184         rtlight->coronasizescale = light->coronasizescale;
2185         rtlight->ambientscale = light->ambientscale;
2186         rtlight->diffusescale = light->diffusescale;
2187         rtlight->specularscale = light->specularscale;
2188         rtlight->flags = light->flags;
2189         Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &light->matrix);
2190         // ConcatScale won't work here because this needs to scale rotate and
2191         // translate, not just rotate
2192         scale = 1.0f / rtlight->radius;
2193         for (k = 0;k < 3;k++)
2194                 for (j = 0;j < 4;j++)
2195                         rtlight->matrix_worldtolight.m[k][j] *= scale;
2196         Matrix4x4_Concat(&rtlight->matrix_worldtoattenuationxyz, &matrix_attenuationxyz, &rtlight->matrix_worldtolight);
2197         Matrix4x4_Concat(&rtlight->matrix_worldtoattenuationz, &matrix_attenuationz, &rtlight->matrix_worldtolight);
2198
2199         rtlight->lightmap_cullradius = bound(0, rtlight->radius, 2048.0f);
2200         rtlight->lightmap_cullradius2 = rtlight->lightmap_cullradius * rtlight->lightmap_cullradius;
2201         VectorScale(rtlight->color, rtlight->radius * (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * 0.125f, rtlight->lightmap_light);
2202         rtlight->lightmap_subtract = 1.0f / rtlight->lightmap_cullradius2;
2203 }
2204
2205 // compiles rtlight geometry
2206 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
2207 void R_RTLight_Compile(rtlight_t *rtlight)
2208 {
2209         int shadowmeshes, shadowtris, lightmeshes, lighttris, numclusters, numsurfaces;
2210         entity_render_t *ent = &cl_entities[0].render;
2211         model_t *model = ent->model;
2212
2213         // compile the light
2214         rtlight->compiled = true;
2215         rtlight->static_numclusters = 0;
2216         rtlight->static_numclusterpvsbytes = 0;
2217         rtlight->static_clusterlist = NULL;
2218         rtlight->static_clusterpvs = NULL;
2219         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
2220         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
2221         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
2222         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
2223         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
2224         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
2225
2226         if (model && model->GetLightInfo)
2227         {
2228                 // this variable directs the DrawShadowVolume and DrawLight code to capture into the mesh chain instead of rendering
2229                 r_shadow_compilingrtlight = rtlight;
2230                 R_Shadow_EnlargeClusterBuffer(model->brush.num_pvsclusters);
2231                 R_Shadow_EnlargeSurfaceBuffer(model->nummodelsurfaces); 
2232                 model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_clusterlist, r_shadow_buffer_clusterpvs, &numclusters, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
2233                 if (numclusters)
2234                 {
2235                         rtlight->static_numclusters = numclusters;
2236                         rtlight->static_numclusterpvsbytes = (model->brush.num_pvsclusters + 7) >> 3;
2237                         rtlight->static_clusterlist = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusters * sizeof(*rtlight->static_clusterlist));
2238                         rtlight->static_clusterpvs = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusterpvsbytes);
2239                         memcpy(rtlight->static_clusterlist, r_shadow_buffer_clusterlist, rtlight->static_numclusters * sizeof(*rtlight->static_clusterlist));
2240                         memcpy(rtlight->static_clusterpvs, r_shadow_buffer_clusterpvs, rtlight->static_numclusterpvsbytes);
2241                 }
2242                 if (model->DrawShadowVolume && rtlight->shadow)
2243                 {
2244                         rtlight->static_meshchain_shadow = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768, 32768, NULL, NULL, NULL, false, false, true);
2245                         model->DrawShadowVolume(ent, rtlight->shadoworigin, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
2246                         rtlight->static_meshchain_shadow = Mod_ShadowMesh_Finish(r_shadow_mempool, rtlight->static_meshchain_shadow, false, false);
2247                 }
2248                 if (model->DrawLight)
2249                 {
2250                         rtlight->static_meshchain_light = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768, 32768, NULL, NULL, NULL, true, false, true);
2251                         model->DrawLight(ent, rtlight->shadoworigin, vec3_origin, rtlight->radius, vec3_origin, &r_identitymatrix, &r_identitymatrix, &r_identitymatrix, NULL, 0, 0, 0, numsurfaces, r_shadow_buffer_surfacelist);
2252                         rtlight->static_meshchain_light = Mod_ShadowMesh_Finish(r_shadow_mempool, rtlight->static_meshchain_light, true, false);
2253                 }
2254                 // switch back to rendering when DrawShadowVolume or DrawLight is called
2255                 r_shadow_compilingrtlight = NULL;
2256         }
2257
2258
2259         // use smallest available cullradius - box radius or light radius
2260         //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
2261         //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
2262
2263         shadowmeshes = 0;
2264         shadowtris = 0;
2265         if (rtlight->static_meshchain_shadow)
2266         {
2267                 shadowmesh_t *mesh;
2268                 for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next)
2269                 {
2270                         shadowmeshes++;
2271                         shadowtris += mesh->numtriangles;
2272                 }
2273         }
2274
2275         lightmeshes = 0;
2276         lighttris = 0;
2277         if (rtlight->static_meshchain_light)
2278         {
2279                 shadowmesh_t *mesh;
2280                 for (mesh = rtlight->static_meshchain_light;mesh;mesh = mesh->next)
2281                 {
2282                         lightmeshes++;
2283                         lighttris += mesh->numtriangles;
2284                 }
2285         }
2286
2287         Con_DPrintf("static light built: %f %f %f : %f %f %f box, %i shadow volume triangles (in %i meshes), %i light 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, lighttris, lightmeshes);
2288 }
2289
2290 void R_RTLight_Uncompile(rtlight_t *rtlight)
2291 {
2292         if (rtlight->compiled)
2293         {
2294                 if (rtlight->static_meshchain_shadow)
2295                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow);
2296                 rtlight->static_meshchain_shadow = NULL;
2297                 if (rtlight->static_meshchain_light)
2298                         Mod_ShadowMesh_Free(rtlight->static_meshchain_light);
2299                 rtlight->static_meshchain_light = NULL;
2300                 if (rtlight->static_clusterlist)
2301                         Mem_Free(rtlight->static_clusterlist);
2302                 rtlight->static_clusterlist = NULL;
2303                 if (rtlight->static_clusterpvs)
2304                         Mem_Free(rtlight->static_clusterpvs);
2305                 rtlight->static_clusterpvs = NULL;
2306                 rtlight->static_numclusters = 0;
2307                 rtlight->static_numclusterpvsbytes = 0;
2308                 rtlight->compiled = false;
2309         }
2310 }
2311
2312 void R_Shadow_UncompileWorldLights(void)
2313 {
2314         dlight_t *light;
2315         for (light = r_shadow_worldlightchain;light;light = light->next)
2316                 R_RTLight_Uncompile(&light->rtlight);
2317 }
2318
2319 void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes)
2320 {
2321         int i, shadow;
2322         entity_render_t *ent;
2323         float f;
2324         vec3_t relativelightorigin, relativeeyeorigin, lightcolor, lightcolor2;
2325         rtexture_t *cubemaptexture;
2326         matrix4x4_t matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz;
2327         int numclusters, numsurfaces;
2328         int *clusterlist, *surfacelist;
2329         qbyte *clusterpvs;
2330         vec3_t cullmins, cullmaxs;
2331         shadowmesh_t *mesh;
2332         rmeshstate_t m;
2333
2334         // loading is done before visibility checks because loading should happen
2335         // all at once at the start of a level, not when it stalls gameplay.
2336         // (especially important to benchmarks)
2337         if (rtlight->isstatic && !rtlight->compiled && r_shadow_staticworldlights.integer)
2338                 R_RTLight_Compile(rtlight);
2339         if (rtlight->cubemapname[0])
2340                 cubemaptexture = R_Shadow_Cubemap(rtlight->cubemapname);
2341         else
2342                 cubemaptexture = NULL;
2343
2344         cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
2345         cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
2346         cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
2347         cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
2348         cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
2349         cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
2350         if (rtlight->style >= 0 && d_lightstylevalue[rtlight->style] <= 0)
2351                 return;
2352         numclusters = 0;
2353         clusterlist = NULL;
2354         clusterpvs = NULL;
2355         numsurfaces = 0;
2356         surfacelist = NULL;
2357         if (rtlight->compiled && r_shadow_staticworldlights.integer)
2358         {
2359                 // compiled light, world available and can receive realtime lighting
2360                 // retrieve cluster information
2361                 numclusters = rtlight->static_numclusters;
2362                 clusterlist = rtlight->static_clusterlist;
2363                 clusterpvs = rtlight->static_clusterpvs;
2364                 VectorCopy(rtlight->cullmins, cullmins);
2365                 VectorCopy(rtlight->cullmaxs, cullmaxs);
2366         }
2367         else if (r_refdef.worldmodel && r_refdef.worldmodel->GetLightInfo)
2368         {
2369                 // dynamic light, world available and can receive realtime lighting
2370                 // if the light box is offscreen, skip it right away
2371                 if (R_CullBox(cullmins, cullmaxs))
2372                         return;
2373                 // calculate lit surfaces and clusters
2374                 R_Shadow_EnlargeClusterBuffer(r_refdef.worldmodel->brush.num_pvsclusters);
2375                 R_Shadow_EnlargeSurfaceBuffer(r_refdef.worldmodel->nummodelsurfaces); 
2376                 r_refdef.worldmodel->GetLightInfo(&cl_entities[0].render, rtlight->shadoworigin, rtlight->radius, cullmins, cullmaxs, r_shadow_buffer_clusterlist, r_shadow_buffer_clusterpvs, &numclusters, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
2377                 clusterlist = r_shadow_buffer_clusterlist;
2378                 clusterpvs = r_shadow_buffer_clusterpvs;
2379                 surfacelist = r_shadow_buffer_surfacelist;
2380         }
2381         // if the reduced cluster bounds are offscreen, skip it
2382         if (R_CullBox(cullmins, cullmaxs))
2383                 return;
2384         // check if light is illuminating any visible clusters
2385         if (numclusters)
2386         {
2387                 for (i = 0;i < numclusters;i++)
2388                         if (CHECKPVSBIT(r_pvsbits, clusterlist[i]))
2389                                 break;
2390                 if (i == numclusters)
2391                         return;
2392         }
2393         // set up a scissor rectangle for this light
2394         if (R_Shadow_ScissorForBBox(cullmins, cullmaxs))
2395                 return;
2396
2397         f = (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f);
2398         VectorScale(rtlight->color, f, lightcolor);
2399         /*
2400         if (rtlight->selected)
2401         {
2402                 f = 2 + sin(realtime * M_PI * 4.0);
2403                 VectorScale(lightcolor, f, lightcolor);
2404         }
2405         */
2406
2407         shadow = rtlight->shadow && (rtlight->isstatic ? r_rtworldshadows : r_rtdlightshadows);
2408
2409         if (shadow && (gl_stencil || visiblevolumes))
2410         {
2411                 if (!visiblevolumes)
2412                         R_Shadow_Stage_ShadowVolumes();
2413                 ent = &cl_entities[0].render;
2414                 if (r_shadow_staticworldlights.integer && rtlight->compiled)
2415                 {
2416                         memset(&m, 0, sizeof(m));
2417                         R_Mesh_Matrix(&ent->matrix);
2418                         for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next)
2419                         {
2420                                 m.pointer_vertex = mesh->vertex3f;
2421                                 R_Mesh_State(&m);
2422                                 GL_LockArrays(0, mesh->numverts);
2423                                 if (r_shadowstage == SHADOWSTAGE_STENCIL)
2424                                 {
2425                                         // decrement stencil if frontface is behind depthbuffer
2426                                         qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
2427                                         qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
2428                                         R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
2429                                         c_rtcached_shadowmeshes++;
2430                                         c_rtcached_shadowtris += mesh->numtriangles;
2431                                         // increment stencil if backface is behind depthbuffer
2432                                         qglCullFace(GL_BACK); // quake is backwards, this culls front faces
2433                                         qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
2434                                 }
2435                                 R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
2436                                 c_rtcached_shadowmeshes++;
2437                                 c_rtcached_shadowtris += mesh->numtriangles;
2438                                 GL_LockArrays(0, 0);
2439                         }
2440                 }
2441                 else if (numsurfaces)
2442                 {
2443                         Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin);
2444                         ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, numsurfaces, surfacelist);
2445                 }
2446                 if (r_drawentities.integer)
2447                 {
2448                         for (i = 0;i < r_refdef.numentities;i++)
2449                         {
2450                                 ent = r_refdef.entities[i];
2451                                 // rough checks
2452                                 if (r_shadow_cull.integer)
2453                                 {
2454                                         if (!BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs))
2455                                                 continue;
2456                                         if (r_refdef.worldmodel != NULL && r_refdef.worldmodel->brush.BoxTouchingPVS != NULL && !r_refdef.worldmodel->brush.BoxTouchingPVS(r_refdef.worldmodel, clusterpvs, ent->mins, ent->maxs))
2457                                                 continue;
2458                                 }
2459                                 if (!(ent->flags & RENDER_SHADOW) || !ent->model || !ent->model->DrawShadowVolume)
2460                                         continue;
2461                                 Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin);
2462                                 // light emitting entities should not cast their own shadow
2463                                 if (VectorLength2(relativelightorigin) < 0.1)
2464                                         continue;
2465                                 ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, ent->model->nummodelsurfaces, ent->model->surfacelist);
2466                         }
2467                 }
2468         }
2469
2470         if (!visiblevolumes)
2471         {
2472                 R_Shadow_Stage_Light(shadow && gl_stencil);
2473
2474                 ent = &cl_entities[0].render;
2475                 if (ent->model && ent->model->DrawLight && (ent->flags & RENDER_LIGHT))
2476                 {
2477                         lightcolor2[0] = lightcolor[0] * ent->colormod[0] * ent->alpha;
2478                         lightcolor2[1] = lightcolor[1] * ent->colormod[1] * ent->alpha;
2479                         lightcolor2[2] = lightcolor[2] * ent->colormod[2] * ent->alpha;
2480                         Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin);
2481                         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
2482                         Matrix4x4_Concat(&matrix_modeltolight, &rtlight->matrix_worldtolight, &ent->matrix);
2483                         Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &rtlight->matrix_worldtoattenuationxyz, &ent->matrix);
2484                         Matrix4x4_Concat(&matrix_modeltoattenuationz, &rtlight->matrix_worldtoattenuationz, &ent->matrix);
2485                         if (r_shadow_staticworldlights.integer && rtlight->compiled)
2486                         {
2487                                 R_Mesh_Matrix(&ent->matrix);
2488                                 for (mesh = rtlight->static_meshchain_light;mesh;mesh = mesh->next)
2489                                         R_Shadow_RenderLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoord2f, relativelightorigin, relativeeyeorigin, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, mesh->map_diffuse, mesh->map_normal, mesh->map_specular, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale);
2490                         }
2491                         else
2492                                 ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, rtlight->radius, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale, numsurfaces, surfacelist);
2493                 }
2494                 if (r_drawentities.integer)
2495                 {
2496                         for (i = 0;i < r_refdef.numentities;i++)
2497                         {
2498                                 ent = r_refdef.entities[i];
2499                                 // can't draw transparent entity lighting here because
2500                                 // transparent meshes are deferred for later
2501                                 if (ent->visframe == r_framecount && BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs) && ent->model && ent->model->DrawLight && (ent->flags & (RENDER_LIGHT | RENDER_TRANSPARENT)) == RENDER_LIGHT)
2502                                 {
2503                                         lightcolor2[0] = lightcolor[0] * ent->colormod[0] * ent->alpha;
2504                                         lightcolor2[1] = lightcolor[1] * ent->colormod[1] * ent->alpha;
2505                                         lightcolor2[2] = lightcolor[2] * ent->colormod[2] * ent->alpha;
2506                                         Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin);
2507                                         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
2508                                         Matrix4x4_Concat(&matrix_modeltolight, &rtlight->matrix_worldtolight, &ent->matrix);
2509                                         Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &rtlight->matrix_worldtoattenuationxyz, &ent->matrix);
2510                                         Matrix4x4_Concat(&matrix_modeltoattenuationz, &rtlight->matrix_worldtoattenuationz, &ent->matrix);
2511                                         ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, rtlight->radius, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale, ent->model->nummodelsurfaces, ent->model->surfacelist);
2512                                 }
2513                         }
2514                 }
2515         }
2516 }
2517
2518 void R_ShadowVolumeLighting(int visiblevolumes)
2519 {
2520         int lnum, flag;
2521         dlight_t *light;
2522         rmeshstate_t m;
2523
2524         if (r_refdef.worldmodel && strncmp(r_refdef.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
2525                 R_Shadow_EditLights_Reload_f();
2526
2527         if (visiblevolumes)
2528         {
2529                 memset(&m, 0, sizeof(m));
2530                 R_Mesh_State(&m);
2531
2532                 GL_BlendFunc(GL_ONE, GL_ONE);
2533                 GL_DepthMask(false);
2534                 GL_DepthTest(r_shadow_visiblevolumes.integer < 2);
2535                 qglDisable(GL_CULL_FACE);
2536                 GL_Color(0.0, 0.0125, 0.1, 1);
2537         }
2538         else
2539                 R_Shadow_Stage_Begin();
2540         flag = r_rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2541         if (r_shadow_debuglight.integer >= 0)
2542         {
2543                 for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next)
2544                         if (lnum == r_shadow_debuglight.integer && (light->flags & flag))
2545                                 R_DrawRTLight(&light->rtlight, visiblevolumes);
2546         }
2547         else
2548                 for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next)
2549                         if (light->flags & flag)
2550                                 R_DrawRTLight(&light->rtlight, visiblevolumes);
2551         if (r_rtdlight)
2552                 for (lnum = 0, light = r_dlight;lnum < r_numdlights;lnum++, light++)
2553                         R_DrawRTLight(&light->rtlight, visiblevolumes);
2554
2555         if (visiblevolumes)
2556         {
2557                 qglEnable(GL_CULL_FACE);
2558                 GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
2559         }
2560         else
2561                 R_Shadow_Stage_End();
2562 }
2563
2564 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
2565 typedef struct suffixinfo_s
2566 {
2567         char *suffix;
2568         qboolean flipx, flipy, flipdiagonal;
2569 }
2570 suffixinfo_t;
2571 static suffixinfo_t suffix[3][6] =
2572 {
2573         {
2574                 {"px",   false, false, false},
2575                 {"nx",   false, false, false},
2576                 {"py",   false, false, false},
2577                 {"ny",   false, false, false},
2578                 {"pz",   false, false, false},
2579                 {"nz",   false, false, false}
2580         },
2581         {
2582                 {"posx", false, false, false},
2583                 {"negx", false, false, false},
2584                 {"posy", false, false, false},
2585                 {"negy", false, false, false},
2586                 {"posz", false, false, false},
2587                 {"negz", false, false, false}
2588         },
2589         {
2590                 {"rt",    true, false,  true},
2591                 {"lf",   false,  true,  true},
2592                 {"ft",    true,  true, false},
2593                 {"bk",   false, false, false},
2594                 {"up",    true, false,  true},
2595                 {"dn",    true, false,  true}
2596         }
2597 };
2598
2599 static int componentorder[4] = {0, 1, 2, 3};
2600
2601 rtexture_t *R_Shadow_LoadCubemap(const char *basename)
2602 {
2603         int i, j, cubemapsize;
2604         qbyte *cubemappixels, *image_rgba;
2605         rtexture_t *cubemaptexture;
2606         char name[256];
2607         // must start 0 so the first loadimagepixels has no requested width/height
2608         cubemapsize = 0;
2609         cubemappixels = NULL;
2610         cubemaptexture = NULL;
2611         // keep trying different suffix groups (posx, px, rt) until one loads
2612         for (j = 0;j < 3 && !cubemappixels;j++)
2613         {
2614                 // load the 6 images in the suffix group
2615                 for (i = 0;i < 6;i++)
2616                 {
2617                         // generate an image name based on the base and and suffix
2618                         snprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
2619                         // load it
2620                         if ((image_rgba = loadimagepixels(name, false, cubemapsize, cubemapsize)))
2621                         {
2622                                 // an image loaded, make sure width and height are equal
2623                                 if (image_width == image_height)
2624                                 {
2625                                         // if this is the first image to load successfully, allocate the cubemap memory
2626                                         if (!cubemappixels && image_width >= 1)
2627                                         {
2628                                                 cubemapsize = image_width;
2629                                                 // note this clears to black, so unavailable sides are black
2630                                                 cubemappixels = Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
2631                                         }
2632                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
2633                                         if (cubemappixels)
2634                                                 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);
2635                                 }
2636                                 else
2637                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
2638                                 // free the image
2639                                 Mem_Free(image_rgba);
2640                         }
2641                 }
2642         }
2643         // if a cubemap loaded, upload it
2644         if (cubemappixels)
2645         {
2646                 if (!r_shadow_filters_texturepool)
2647                         r_shadow_filters_texturepool = R_AllocTexturePool();
2648                 cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
2649                 Mem_Free(cubemappixels);
2650         }
2651         else
2652         {
2653                 Con_Printf("Failed to load Cubemap \"%s\", tried ", basename);
2654                 for (j = 0;j < 3;j++)
2655                         for (i = 0;i < 6;i++)
2656                                 Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
2657                 Con_Print(" and was unable to find any of them.\n");
2658         }
2659         return cubemaptexture;
2660 }
2661
2662 rtexture_t *R_Shadow_Cubemap(const char *basename)
2663 {
2664         int i;
2665         for (i = 0;i < numcubemaps;i++)
2666                 if (!strcasecmp(cubemaps[i].basename, basename))
2667                         return cubemaps[i].texture;
2668         if (i >= MAX_CUBEMAPS)
2669                 return NULL;
2670         numcubemaps++;
2671         strcpy(cubemaps[i].basename, basename);
2672         cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename);
2673         return cubemaps[i].texture;
2674 }
2675
2676 void R_Shadow_FreeCubemaps(void)
2677 {
2678         numcubemaps = 0;
2679         R_FreeTexturePool(&r_shadow_filters_texturepool);
2680 }
2681
2682 dlight_t *R_Shadow_NewWorldLight(void)
2683 {
2684         dlight_t *light;
2685         light = Mem_Alloc(r_shadow_mempool, sizeof(dlight_t));
2686         light->next = r_shadow_worldlightchain;
2687         r_shadow_worldlightchain = light;
2688         return light;
2689 }
2690
2691 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)
2692 {
2693         VectorCopy(origin, light->origin);
2694         light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
2695         light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
2696         light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
2697         light->color[0] = max(color[0], 0);
2698         light->color[1] = max(color[1], 0);
2699         light->color[2] = max(color[2], 0);
2700         light->radius = max(radius, 0);
2701         light->style = style;
2702         if (light->style < 0 || light->style >= MAX_LIGHTSTYLES)
2703         {
2704                 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
2705                 light->style = 0;
2706         }
2707         light->shadow = shadowenable;
2708         light->corona = corona;
2709         if (!cubemapname)
2710                 cubemapname = "";
2711         strlcpy(light->cubemapname, cubemapname, strlen(light->cubemapname));
2712         light->coronasizescale = coronasizescale;
2713         light->ambientscale = ambientscale;
2714         light->diffusescale = diffusescale;
2715         light->specularscale = specularscale;
2716         light->flags = flags;
2717         Matrix4x4_CreateFromQuakeEntity(&light->matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], 1);
2718
2719         R_RTLight_UpdateFromDLight(&light->rtlight, light, true);
2720 }
2721
2722 void R_Shadow_FreeWorldLight(dlight_t *light)
2723 {
2724         dlight_t **lightpointer;
2725         R_RTLight_Uncompile(&light->rtlight);
2726         for (lightpointer = &r_shadow_worldlightchain;*lightpointer && *lightpointer != light;lightpointer = &(*lightpointer)->next);
2727         if (*lightpointer != light)
2728                 Sys_Error("R_Shadow_FreeWorldLight: light not linked into chain\n");
2729         *lightpointer = light->next;
2730         Mem_Free(light);
2731 }
2732
2733 void R_Shadow_ClearWorldLights(void)
2734 {
2735         while (r_shadow_worldlightchain)
2736                 R_Shadow_FreeWorldLight(r_shadow_worldlightchain);
2737         r_shadow_selectedlight = NULL;
2738         R_Shadow_FreeCubemaps();
2739 }
2740
2741 void R_Shadow_SelectLight(dlight_t *light)
2742 {
2743         if (r_shadow_selectedlight)
2744                 r_shadow_selectedlight->selected = false;
2745         r_shadow_selectedlight = light;
2746         if (r_shadow_selectedlight)
2747                 r_shadow_selectedlight->selected = true;
2748 }
2749
2750 void R_Shadow_DrawCursorCallback(const void *calldata1, int calldata2)
2751 {
2752         float scale = r_editlights_cursorgrid.value * 0.5f;
2753         R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[0], false, r_editlights_cursorlocation, r_viewright, r_viewup, scale, -scale, -scale, scale, 1, 1, 1, 0.5f);
2754 }
2755
2756 void R_Shadow_DrawLightSpriteCallback(const void *calldata1, int calldata2)
2757 {
2758         float intensity;
2759         const dlight_t *light;
2760         light = calldata1;
2761         intensity = 0.5;
2762         if (light->selected)
2763                 intensity = 0.75 + 0.25 * sin(realtime * M_PI * 4.0);
2764         if (!light->shadow)
2765                 intensity *= 0.5f;
2766         R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[calldata2], false, light->origin, r_viewright, r_viewup, 8, -8, -8, 8, intensity, intensity, intensity, 0.5);
2767 }
2768
2769 void R_Shadow_DrawLightSprites(void)
2770 {
2771         int i;
2772         cachepic_t *pic;
2773         dlight_t *light;
2774
2775         for (i = 0;i < 5;i++)
2776         {
2777                 lighttextures[i] = NULL;
2778                 if ((pic = Draw_CachePic(va("gfx/crosshair%i.tga", i + 1))))
2779                         lighttextures[i] = pic->tex;
2780         }
2781
2782         for (i = 0, light = r_shadow_worldlightchain;light;i++, light = light->next)
2783                 R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSpriteCallback, light, i % 5);
2784         R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursorCallback, NULL, 0);
2785 }
2786
2787 void R_Shadow_SelectLightInView(void)
2788 {
2789         float bestrating, rating, temp[3];
2790         dlight_t *best, *light;
2791         best = NULL;
2792         bestrating = 0;
2793         for (light = r_shadow_worldlightchain;light;light = light->next)
2794         {
2795                 VectorSubtract(light->origin, r_vieworigin, temp);
2796                 rating = (DotProduct(temp, r_viewforward) / sqrt(DotProduct(temp, temp)));
2797                 if (rating >= 0.95)
2798                 {
2799                         rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
2800                         if (bestrating < rating && CL_TraceLine(light->origin, r_vieworigin, NULL, NULL, true, NULL, SUPERCONTENTS_SOLID) == 1.0f)
2801                         {
2802                                 bestrating = rating;
2803                                 best = light;
2804                         }
2805                 }
2806         }
2807         R_Shadow_SelectLight(best);
2808 }
2809
2810 void R_Shadow_LoadWorldLights(void)
2811 {
2812         int n, a, style, shadow, flags;
2813         char name[MAX_QPATH], cubemapname[MAX_QPATH], *lightsstring, *s, *t;
2814         float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
2815         if (r_refdef.worldmodel == NULL)
2816         {
2817                 Con_Print("No map loaded.\n");
2818                 return;
2819         }
2820         FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
2821         strlcat (name, ".rtlights", sizeof (name));
2822         lightsstring = FS_LoadFile(name, tempmempool, false);
2823         if (lightsstring)
2824         {
2825                 s = lightsstring;
2826                 n = 0;
2827                 while (*s)
2828                 {
2829                         t = s;
2830                         /*
2831                         shadow = true;
2832                         for (;COM_Parse(t, true) && strcmp(
2833                         if (COM_Parse(t, true))
2834                         {
2835                                 if (com_token[0] == '!')
2836                                 {
2837                                         shadow = false;
2838                                         origin[0] = atof(com_token+1);
2839                                 }
2840                                 else
2841                                         origin[0] = atof(com_token);
2842                                 if (Com_Parse(t
2843                         }
2844                         */
2845                         t = s;
2846                         while (*s && *s != '\n')
2847                                 s++;
2848                         if (!*s)
2849                                 break;
2850                         *s = 0;
2851                         shadow = true;
2852                         // check for modifier flags
2853                         if (*t == '!')
2854                         {
2855                                 shadow = false;
2856                                 t++;
2857                         }
2858                         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);
2859                         if (a < 18)
2860                                 flags = LIGHTFLAG_REALTIMEMODE;
2861                         if (a < 17)
2862                                 specularscale = 1;
2863                         if (a < 16)
2864                                 diffusescale = 1;
2865                         if (a < 15)
2866                                 ambientscale = 0;
2867                         if (a < 14)
2868                                 coronasizescale = 0.25f;
2869                         if (a < 13)
2870                                 VectorClear(angles);
2871                         if (a < 10)
2872                                 corona = 0;
2873                         if (a < 9 || !strcmp(cubemapname, "\"\""))
2874                                 cubemapname[0] = 0;
2875                         *s = '\n';
2876                         if (a < 8)
2877                         {
2878                                 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);
2879                                 break;
2880                         }
2881                         VectorScale(color, r_editlights_rtlightscolorscale.value, color);
2882                         radius *= r_editlights_rtlightssizescale.value;
2883                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
2884                         s++;
2885                         n++;
2886                 }
2887                 if (*s)
2888                         Con_Printf("invalid rtlights file \"%s\"\n", name);
2889                 Mem_Free(lightsstring);
2890         }
2891 }
2892
2893 void R_Shadow_SaveWorldLights(void)
2894 {
2895         dlight_t *light;
2896         int bufchars, bufmaxchars;
2897         char *buf, *oldbuf;
2898         char name[MAX_QPATH];
2899         char line[1024];
2900         if (!r_shadow_worldlightchain)
2901                 return;
2902         if (r_refdef.worldmodel == NULL)
2903         {
2904                 Con_Print("No map loaded.\n");
2905                 return;
2906         }
2907         FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
2908         strlcat (name, ".rtlights", sizeof (name));
2909         bufchars = bufmaxchars = 0;
2910         buf = NULL;
2911         for (light = r_shadow_worldlightchain;light;light = light->next)
2912        &n