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)
10 This is normally rendered using Carmack's Reverse technique, in which
11 backfaces behind zbuffer (zfail) increment the stencil, and frontfaces behind
12 zbuffer (zfail) decrement the stencil, the result is a stencil value of zero
13 where shadows did not intersect the visible geometry, suitable as a stencil
14 mask for rendering lighting everywhere but shadow.
16 In our case to hopefully avoid the Creative Labs patent, we draw the backfaces
17 as decrement and the frontfaces as increment, and we redefine the DepthFunc to
18 GL_LESS (the patent uses GL_GEQUAL) which causes zfail when behind surfaces
19 and zpass when infront (the patent draws where zpass with a GL_GEQUAL test),
20 additionally we clear stencil to 128 to avoid the need for the unclamped
21 incr/decr extension (not related to patent).
24 This algorithm may be covered by Creative's patent (US Patent #6384822),
25 however that patent is quite specific about increment on backfaces and
26 decrement on frontfaces where zpass with GL_GEQUAL depth test, which is
27 opposite this implementation and partially opposite Carmack's Reverse paper
28 (which uses GL_LESS, but increments on backfaces and decrements on frontfaces).
32 Terminology: Stencil Light Volume (sometimes called Light Volumes)
33 Similar to a Stencil Shadow Volume, but inverted; rather than containing the
34 areas in shadow it contains the areas in light, this can only be built
35 quickly for certain limited cases (such as portal visibility from a point),
36 but is quite useful for some effects (sunlight coming from sky polygons is
37 one possible example, translucent occluders is another example).
41 Terminology: Optimized Stencil Shadow Volume
42 A Stencil Shadow Volume that has been processed sufficiently to ensure it has
43 no duplicate coverage of areas (no need to shadow an area twice), often this
44 greatly improves performance but is an operation too costly to use on moving
45 lights (however completely optimal Stencil Light Volumes can be constructed
50 Terminology: Per Pixel Lighting (sometimes abbreviated PPL)
51 Per pixel evaluation of lighting equations, at a bare minimum this involves
52 DOT3 shading of diffuse lighting (per pixel dotproduct of negated incidence
53 vector and surface normal, using a texture of the surface bumps, called a
54 NormalMap) if supported by hardware; in our case there is support for cards
55 which are incapable of DOT3, the quality is quite poor however. Additionally
56 it is desirable to have specular evaluation per pixel, per vertex
57 normalization of specular halfangle vectors causes noticable distortion but
58 is unavoidable on hardware without GL_ARB_fragment_program or
59 GL_ARB_fragment_shader.
63 Terminology: Normalization CubeMap
64 A cubemap containing normalized dot3-encoded (vectors of length 1 or less
65 encoded as RGB colors) for any possible direction, this technique allows per
66 pixel calculation of incidence vector for per pixel lighting purposes, which
67 would not otherwise be possible per pixel without GL_ARB_fragment_program or
68 GL_ARB_fragment_shader.
72 Terminology: 2D+1D Attenuation Texturing
73 A very crude approximation of light attenuation with distance which results
74 in cylindrical light shapes which fade vertically as a streak (some games
75 such as Doom3 allow this to be rotated to be less noticable in specific
76 cases), the technique is simply modulating lighting by two 2D textures (which
77 can be the same) on different axes of projection (XY and Z, typically), this
78 is the second best technique available without 3D Attenuation Texturing,
79 GL_ARB_fragment_program or GL_ARB_fragment_shader technology.
83 Terminology: 2D+1D Inverse Attenuation Texturing
84 A clever method described in papers on the Abducted engine, this has a squared
85 distance texture (bright on the outside, black in the middle), which is used
86 twice using GL_ADD blending, the result of this is used in an inverse modulate
87 (GL_ONE_MINUS_DST_ALPHA, GL_ZERO) to implement the equation
88 lighting*=(1-((X*X+Y*Y)+(Z*Z))) which is spherical (unlike 2D+1D attenuation
93 Terminology: 3D Attenuation Texturing
94 A slightly crude approximation of light attenuation with distance, its flaws
95 are limited radius and resolution (performance tradeoffs).
99 Terminology: 3D Attenuation-Normalization Texturing
100 A 3D Attenuation Texture merged with a Normalization CubeMap, by making the
101 vectors shorter the lighting becomes darker, a very effective optimization of
102 diffuse lighting if 3D Attenuation Textures are already used.
106 Terminology: Light Cubemap Filtering
107 A technique for modeling non-uniform light distribution according to
108 direction, for example a lantern may use a cubemap to describe the light
109 emission pattern of the cage around the lantern (as well as soot buildup
110 discoloring the light in certain areas), often also used for softened grate
111 shadows and light shining through a stained glass window (done crudely by
112 texturing the lighting with a cubemap), another good example would be a disco
113 light. This technique is used heavily in many games (Doom3 does not support
118 Terminology: Light Projection Filtering
119 A technique for modeling shadowing of light passing through translucent
120 surfaces, allowing stained glass windows and other effects to be done more
121 elegantly than possible with Light Cubemap Filtering by applying an occluder
122 texture to the lighting combined with a stencil light volume to limit the lit
123 area, this technique is used by Doom3 for spotlights and flashlights, among
124 other things, this can also be used more generally to render light passing
125 through multiple translucent occluders in a scene (using a light volume to
126 describe the area beyond the occluder, and thus mask off rendering of all
131 Terminology: Doom3 Lighting
132 A combination of Stencil Shadow Volume, Per Pixel Lighting, Normalization
133 CubeMap, 2D+1D Attenuation Texturing, and Light Projection Filtering, as
134 demonstrated by the game Doom3.
137 #include "quakedef.h"
138 #include "r_shadow.h"
139 #include "cl_collision.h"
143 extern void R_Shadow_EditLights_Init(void);
145 typedef enum r_shadow_rendermode_e
147 R_SHADOW_RENDERMODE_NONE,
148 R_SHADOW_RENDERMODE_ZPASS_STENCIL,
149 R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL,
150 R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE,
151 R_SHADOW_RENDERMODE_ZFAIL_STENCIL,
152 R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL,
153 R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE,
154 R_SHADOW_RENDERMODE_LIGHT_VERTEX,
155 R_SHADOW_RENDERMODE_LIGHT_DOT3,
156 R_SHADOW_RENDERMODE_LIGHT_GLSL,
157 R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
158 R_SHADOW_RENDERMODE_VISIBLELIGHTING,
160 r_shadow_rendermode_t;
162 r_shadow_rendermode_t r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
163 r_shadow_rendermode_t r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_NONE;
164 r_shadow_rendermode_t r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_NONE;
165 r_shadow_rendermode_t r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_NONE;
167 int maxshadowtriangles;
170 int maxshadowvertices;
171 float *shadowvertex3f;
184 int r_shadow_buffer_numleafpvsbytes;
185 unsigned char *r_shadow_buffer_visitingleafpvs;
186 unsigned char *r_shadow_buffer_leafpvs;
187 int *r_shadow_buffer_leaflist;
189 int r_shadow_buffer_numsurfacepvsbytes;
190 unsigned char *r_shadow_buffer_surfacepvs;
191 int *r_shadow_buffer_surfacelist;
193 int r_shadow_buffer_numshadowtrispvsbytes;
194 unsigned char *r_shadow_buffer_shadowtrispvs;
195 int r_shadow_buffer_numlighttrispvsbytes;
196 unsigned char *r_shadow_buffer_lighttrispvs;
198 rtexturepool_t *r_shadow_texturepool;
199 rtexture_t *r_shadow_attenuationgradienttexture;
200 rtexture_t *r_shadow_attenuation2dtexture;
201 rtexture_t *r_shadow_attenuation3dtexture;
202 rtexture_t *r_shadow_lightcorona;
204 // lights are reloaded when this changes
205 char r_shadow_mapname[MAX_QPATH];
207 // used only for light filters (cubemaps)
208 rtexturepool_t *r_shadow_filters_texturepool;
210 cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"};
211 cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
212 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
213 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
214 cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"};
215 cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};
216 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
217 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
218 cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
219 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
220 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
221 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
222 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
223 cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1", "use portal culling to exactly determine lit triangles when compiling world lights"};
224 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000", "how far to cast shadows"};
225 cvar_t r_shadow_frontsidecasting = {0, "r_shadow_frontsidecasting", "1", "whether to cast shadows from illuminated triangles (front side of model) or unlit triangles (back side of model)"};
226 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
227 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
228 cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
229 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
230 cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0", "enables rendering of full world lighting (whether loaded from the map, or a .rtlights file, or a .ent file, or a .lights file produced by hlight)"};
231 cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0", "brightness to render lightmaps when using full world lighting, try 0.5 for a tenebrae-like appearance"};
232 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
233 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
234 cvar_t r_shadow_realtime_world_compileshadow = {0, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"};
235 cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation"};
236 cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation"};
237 cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"};
238 cvar_t r_shadow_culltriangles = {0, "r_shadow_culltriangles", "1", "performs more expensive tests to remove unnecessary triangles of lit surfaces"};
239 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
240 cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"};
241 cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect r_glsl lighting)"};
242 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
243 cvar_t r_coronas_occlusionsizescale = {CVAR_SAVE, "r_coronas_occlusionsizescale", "0.1", "size of light source for corona occlusion checksm the proportion of hidden pixels controls corona intensity"};
244 cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
245 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
246 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
247 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
248 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
249 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
250 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
251 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
252 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
253 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
255 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
256 #define ATTENTABLESIZE 256
257 // 1D gradient, 2D circle and 3D sphere attenuation textures
258 #define ATTEN1DSIZE 32
259 #define ATTEN2DSIZE 64
260 #define ATTEN3DSIZE 32
262 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
263 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
264 static float r_shadow_attentable[ATTENTABLESIZE+1];
266 rtlight_t *r_shadow_compilingrtlight;
267 static memexpandablearray_t r_shadow_worldlightsarray;
268 dlight_t *r_shadow_selectedlight;
269 dlight_t r_shadow_bufferlight;
270 vec3_t r_editlights_cursorlocation;
272 extern int con_vislines;
274 typedef struct cubemapinfo_s
281 #define MAX_CUBEMAPS 256
282 static int numcubemaps;
283 static cubemapinfo_t cubemaps[MAX_CUBEMAPS];
285 void R_Shadow_UncompileWorldLights(void);
286 void R_Shadow_ClearWorldLights(void);
287 void R_Shadow_SaveWorldLights(void);
288 void R_Shadow_LoadWorldLights(void);
289 void R_Shadow_LoadLightsFile(void);
290 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
291 void R_Shadow_EditLights_Reload_f(void);
292 void R_Shadow_ValidateCvars(void);
293 static void R_Shadow_MakeTextures(void);
295 // VorteX: custom editor light sprites
296 #define EDLIGHTSPRSIZE 8
297 cachepic_t *r_editlights_sprcursor;
298 cachepic_t *r_editlights_sprlight;
299 cachepic_t *r_editlights_sprnoshadowlight;
300 cachepic_t *r_editlights_sprcubemaplight;
301 cachepic_t *r_editlights_sprcubemapnoshadowlight;
302 cachepic_t *r_editlights_sprselection;
304 void r_shadow_start(void)
306 // allocate vertex processing arrays
308 r_shadow_attenuationgradienttexture = NULL;
309 r_shadow_attenuation2dtexture = NULL;
310 r_shadow_attenuation3dtexture = NULL;
311 r_shadow_texturepool = NULL;
312 r_shadow_filters_texturepool = NULL;
313 R_Shadow_ValidateCvars();
314 R_Shadow_MakeTextures();
315 maxshadowtriangles = 0;
316 shadowelements = NULL;
317 maxshadowvertices = 0;
318 shadowvertex3f = NULL;
326 shadowmarklist = NULL;
328 r_shadow_buffer_numleafpvsbytes = 0;
329 r_shadow_buffer_visitingleafpvs = NULL;
330 r_shadow_buffer_leafpvs = NULL;
331 r_shadow_buffer_leaflist = NULL;
332 r_shadow_buffer_numsurfacepvsbytes = 0;
333 r_shadow_buffer_surfacepvs = NULL;
334 r_shadow_buffer_surfacelist = NULL;
335 r_shadow_buffer_numshadowtrispvsbytes = 0;
336 r_shadow_buffer_shadowtrispvs = NULL;
337 r_shadow_buffer_numlighttrispvsbytes = 0;
338 r_shadow_buffer_lighttrispvs = NULL;
341 void r_shadow_shutdown(void)
343 R_Shadow_UncompileWorldLights();
345 r_shadow_attenuationgradienttexture = NULL;
346 r_shadow_attenuation2dtexture = NULL;
347 r_shadow_attenuation3dtexture = NULL;
348 R_FreeTexturePool(&r_shadow_texturepool);
349 R_FreeTexturePool(&r_shadow_filters_texturepool);
350 maxshadowtriangles = 0;
352 Mem_Free(shadowelements);
353 shadowelements = NULL;
355 Mem_Free(shadowvertex3f);
356 shadowvertex3f = NULL;
359 Mem_Free(vertexupdate);
362 Mem_Free(vertexremap);
368 Mem_Free(shadowmark);
371 Mem_Free(shadowmarklist);
372 shadowmarklist = NULL;
374 r_shadow_buffer_numleafpvsbytes = 0;
375 if (r_shadow_buffer_visitingleafpvs)
376 Mem_Free(r_shadow_buffer_visitingleafpvs);
377 r_shadow_buffer_visitingleafpvs = NULL;
378 if (r_shadow_buffer_leafpvs)
379 Mem_Free(r_shadow_buffer_leafpvs);
380 r_shadow_buffer_leafpvs = NULL;
381 if (r_shadow_buffer_leaflist)
382 Mem_Free(r_shadow_buffer_leaflist);
383 r_shadow_buffer_leaflist = NULL;
384 r_shadow_buffer_numsurfacepvsbytes = 0;
385 if (r_shadow_buffer_surfacepvs)
386 Mem_Free(r_shadow_buffer_surfacepvs);
387 r_shadow_buffer_surfacepvs = NULL;
388 if (r_shadow_buffer_surfacelist)
389 Mem_Free(r_shadow_buffer_surfacelist);
390 r_shadow_buffer_surfacelist = NULL;
391 r_shadow_buffer_numshadowtrispvsbytes = 0;
392 if (r_shadow_buffer_shadowtrispvs)
393 Mem_Free(r_shadow_buffer_shadowtrispvs);
394 r_shadow_buffer_numlighttrispvsbytes = 0;
395 if (r_shadow_buffer_lighttrispvs)
396 Mem_Free(r_shadow_buffer_lighttrispvs);
399 void r_shadow_newmap(void)
401 if (cl.worldmodel && strncmp(cl.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
402 R_Shadow_EditLights_Reload_f();
405 void R_Shadow_Help_f(void)
408 "Documentation on r_shadow system:\n"
410 "r_shadow_bumpscale_basetexture : base texture as bumpmap with this scale\n"
411 "r_shadow_bumpscale_bumpmap : depth scale for bumpmap conversion\n"
412 "r_shadow_debuglight : render only this light number (-1 = all)\n"
413 "r_shadow_gloss 0/1/2 : no gloss, gloss textures only, force gloss\n"
414 "r_shadow_gloss2intensity : brightness of forced gloss\n"
415 "r_shadow_glossintensity : brightness of textured gloss\n"
416 "r_shadow_lightattenuationlinearscale : used to generate attenuation texture\n"
417 "r_shadow_lightattenuationdividebias : used to generate attenuation texture\n"
418 "r_shadow_lightintensityscale : scale rendering brightness of all lights\n"
419 "r_shadow_lightradiusscale : scale rendering radius of all lights\n"
420 "r_shadow_portallight : use portal visibility for static light precomputation\n"
421 "r_shadow_projectdistance : shadow volume projection distance\n"
422 "r_shadow_realtime_dlight : use high quality dynamic lights in normal mode\n"
423 "r_shadow_realtime_dlight_shadows : cast shadows from dlights\n"
424 "r_shadow_realtime_world : use high quality world lighting mode\n"
425 "r_shadow_realtime_world_lightmaps : use lightmaps in addition to lights\n"
426 "r_shadow_realtime_world_shadows : cast shadows from world lights\n"
427 "r_shadow_realtime_world_compile : compile surface/visibility information\n"
428 "r_shadow_realtime_world_compileshadow : compile shadow geometry\n"
429 "r_shadow_scissor : use scissor optimization\n"
430 "r_shadow_polygonfactor : nudge shadow volumes closer/further\n"
431 "r_shadow_polygonoffset : nudge shadow volumes closer/further\n"
432 "r_shadow_texture3d : use 3d attenuation texture (if hardware supports)\n"
433 "r_showlighting : useful for performance testing; bright = slow!\n"
434 "r_showshadowvolumes : useful for performance testing; bright = slow!\n"
436 "r_shadow_help : this help\n"
440 void R_Shadow_Init(void)
442 Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
443 Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
444 Cvar_RegisterVariable(&r_shadow_usenormalmap);
445 Cvar_RegisterVariable(&r_shadow_debuglight);
446 Cvar_RegisterVariable(&r_shadow_gloss);
447 Cvar_RegisterVariable(&r_shadow_gloss2intensity);
448 Cvar_RegisterVariable(&r_shadow_glossintensity);
449 Cvar_RegisterVariable(&r_shadow_glossexponent);
450 Cvar_RegisterVariable(&r_shadow_glossexact);
451 Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
452 Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
453 Cvar_RegisterVariable(&r_shadow_lightintensityscale);
454 Cvar_RegisterVariable(&r_shadow_lightradiusscale);
455 Cvar_RegisterVariable(&r_shadow_portallight);
456 Cvar_RegisterVariable(&r_shadow_projectdistance);
457 Cvar_RegisterVariable(&r_shadow_frontsidecasting);
458 Cvar_RegisterVariable(&r_shadow_realtime_dlight);
459 Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
460 Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
461 Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
462 Cvar_RegisterVariable(&r_shadow_realtime_world);
463 Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
464 Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
465 Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
466 Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
467 Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
468 Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
469 Cvar_RegisterVariable(&r_shadow_scissor);
470 Cvar_RegisterVariable(&r_shadow_culltriangles);
471 Cvar_RegisterVariable(&r_shadow_polygonfactor);
472 Cvar_RegisterVariable(&r_shadow_polygonoffset);
473 Cvar_RegisterVariable(&r_shadow_texture3d);
474 Cvar_RegisterVariable(&r_coronas);
475 Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
476 Cvar_RegisterVariable(&r_coronas_occlusionquery);
477 Cvar_RegisterVariable(&gl_flashblend);
478 Cvar_RegisterVariable(&gl_ext_separatestencil);
479 Cvar_RegisterVariable(&gl_ext_stenciltwoside);
480 if (gamemode == GAME_TENEBRAE)
482 Cvar_SetValue("r_shadow_gloss", 2);
483 Cvar_SetValue("r_shadow_bumpscale_basetexture", 4);
485 Cmd_AddCommand("r_shadow_help", R_Shadow_Help_f, "prints documentation on console commands and variables used by realtime lighting and shadowing system");
486 R_Shadow_EditLights_Init();
487 Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
488 maxshadowtriangles = 0;
489 shadowelements = NULL;
490 maxshadowvertices = 0;
491 shadowvertex3f = NULL;
499 shadowmarklist = NULL;
501 r_shadow_buffer_numleafpvsbytes = 0;
502 r_shadow_buffer_visitingleafpvs = NULL;
503 r_shadow_buffer_leafpvs = NULL;
504 r_shadow_buffer_leaflist = NULL;
505 r_shadow_buffer_numsurfacepvsbytes = 0;
506 r_shadow_buffer_surfacepvs = NULL;
507 r_shadow_buffer_surfacelist = NULL;
508 r_shadow_buffer_shadowtrispvs = NULL;
509 r_shadow_buffer_lighttrispvs = NULL;
510 R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap);
513 matrix4x4_t matrix_attenuationxyz =
516 {0.5, 0.0, 0.0, 0.5},
517 {0.0, 0.5, 0.0, 0.5},
518 {0.0, 0.0, 0.5, 0.5},
523 matrix4x4_t matrix_attenuationz =
526 {0.0, 0.0, 0.5, 0.5},
527 {0.0, 0.0, 0.0, 0.5},
528 {0.0, 0.0, 0.0, 0.5},
533 void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles)
535 // make sure shadowelements is big enough for this volume
536 if (maxshadowtriangles < numtriangles)
538 maxshadowtriangles = numtriangles;
540 Mem_Free(shadowelements);
541 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[24]));
543 // make sure shadowvertex3f is big enough for this volume
544 if (maxshadowvertices < numvertices)
546 maxshadowvertices = numvertices;
548 Mem_Free(shadowvertex3f);
549 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[6]));
553 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
555 int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
556 int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
557 int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
558 int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
559 if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
561 if (r_shadow_buffer_visitingleafpvs)
562 Mem_Free(r_shadow_buffer_visitingleafpvs);
563 if (r_shadow_buffer_leafpvs)
564 Mem_Free(r_shadow_buffer_leafpvs);
565 if (r_shadow_buffer_leaflist)
566 Mem_Free(r_shadow_buffer_leaflist);
567 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
568 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
569 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
570 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
572 if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
574 if (r_shadow_buffer_surfacepvs)
575 Mem_Free(r_shadow_buffer_surfacepvs);
576 if (r_shadow_buffer_surfacelist)
577 Mem_Free(r_shadow_buffer_surfacelist);
578 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
579 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
580 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
582 if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
584 if (r_shadow_buffer_shadowtrispvs)
585 Mem_Free(r_shadow_buffer_shadowtrispvs);
586 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
587 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
589 if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
591 if (r_shadow_buffer_lighttrispvs)
592 Mem_Free(r_shadow_buffer_lighttrispvs);
593 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
594 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
598 void R_Shadow_PrepareShadowMark(int numtris)
600 // make sure shadowmark is big enough for this volume
601 if (maxshadowmark < numtris)
603 maxshadowmark = numtris;
605 Mem_Free(shadowmark);
607 Mem_Free(shadowmarklist);
608 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
609 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
613 // if shadowmarkcount wrapped we clear the array and adjust accordingly
614 if (shadowmarkcount == 0)
617 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
622 static int R_Shadow_ConstructShadowVolume_ZFail(int innumvertices, int innumtris, const int *inelement3i, const int *inneighbor3i, const float *invertex3f, int *outnumvertices, int *outelement3i, float *outvertex3f, const float *projectorigin, const float *projectdirection, float projectdistance, int numshadowmarktris, const int *shadowmarktris)
625 int outtriangles = 0, outvertices = 0;
628 float ratio, direction[3], projectvector[3];
630 if (projectdirection)
631 VectorScale(projectdirection, projectdistance, projectvector);
633 VectorClear(projectvector);
635 // create the vertices
636 if (projectdirection)
638 for (i = 0;i < numshadowmarktris;i++)
640 element = inelement3i + shadowmarktris[i] * 3;
641 for (j = 0;j < 3;j++)
643 if (vertexupdate[element[j]] != vertexupdatenum)
645 vertexupdate[element[j]] = vertexupdatenum;
646 vertexremap[element[j]] = outvertices;
647 vertex = invertex3f + element[j] * 3;
648 // project one copy of the vertex according to projectvector
649 VectorCopy(vertex, outvertex3f);
650 VectorAdd(vertex, projectvector, (outvertex3f + 3));
659 for (i = 0;i < numshadowmarktris;i++)
661 element = inelement3i + shadowmarktris[i] * 3;
662 for (j = 0;j < 3;j++)
664 if (vertexupdate[element[j]] != vertexupdatenum)
666 vertexupdate[element[j]] = vertexupdatenum;
667 vertexremap[element[j]] = outvertices;
668 vertex = invertex3f + element[j] * 3;
669 // project one copy of the vertex to the sphere radius of the light
670 // (FIXME: would projecting it to the light box be better?)
671 VectorSubtract(vertex, projectorigin, direction);
672 ratio = projectdistance / VectorLength(direction);
673 VectorCopy(vertex, outvertex3f);
674 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
682 if (r_shadow_frontsidecasting.integer)
684 for (i = 0;i < numshadowmarktris;i++)
686 int remappedelement[3];
688 const int *neighbortriangle;
690 markindex = shadowmarktris[i] * 3;
691 element = inelement3i + markindex;
692 neighbortriangle = inneighbor3i + markindex;
693 // output the front and back triangles
694 outelement3i[0] = vertexremap[element[0]];
695 outelement3i[1] = vertexremap[element[1]];
696 outelement3i[2] = vertexremap[element[2]];
697 outelement3i[3] = vertexremap[element[2]] + 1;
698 outelement3i[4] = vertexremap[element[1]] + 1;
699 outelement3i[5] = vertexremap[element[0]] + 1;
703 // output the sides (facing outward from this triangle)
704 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
706 remappedelement[0] = vertexremap[element[0]];
707 remappedelement[1] = vertexremap[element[1]];
708 outelement3i[0] = remappedelement[1];
709 outelement3i[1] = remappedelement[0];
710 outelement3i[2] = remappedelement[0] + 1;
711 outelement3i[3] = remappedelement[1];
712 outelement3i[4] = remappedelement[0] + 1;
713 outelement3i[5] = remappedelement[1] + 1;
718 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
720 remappedelement[1] = vertexremap[element[1]];
721 remappedelement[2] = vertexremap[element[2]];
722 outelement3i[0] = remappedelement[2];
723 outelement3i[1] = remappedelement[1];
724 outelement3i[2] = remappedelement[1] + 1;
725 outelement3i[3] = remappedelement[2];
726 outelement3i[4] = remappedelement[1] + 1;
727 outelement3i[5] = remappedelement[2] + 1;
732 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
734 remappedelement[0] = vertexremap[element[0]];
735 remappedelement[2] = vertexremap[element[2]];
736 outelement3i[0] = remappedelement[0];
737 outelement3i[1] = remappedelement[2];
738 outelement3i[2] = remappedelement[2] + 1;
739 outelement3i[3] = remappedelement[0];
740 outelement3i[4] = remappedelement[2] + 1;
741 outelement3i[5] = remappedelement[0] + 1;
750 for (i = 0;i < numshadowmarktris;i++)
752 int remappedelement[3];
754 const int *neighbortriangle;
756 markindex = shadowmarktris[i] * 3;
757 element = inelement3i + markindex;
758 neighbortriangle = inneighbor3i + markindex;
759 // output the front and back triangles
760 outelement3i[0] = vertexremap[element[2]];
761 outelement3i[1] = vertexremap[element[1]];
762 outelement3i[2] = vertexremap[element[0]];
763 outelement3i[3] = vertexremap[element[0]] + 1;
764 outelement3i[4] = vertexremap[element[1]] + 1;
765 outelement3i[5] = vertexremap[element[2]] + 1;
769 // output the sides (facing outward from this triangle)
770 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
772 remappedelement[0] = vertexremap[element[0]];
773 remappedelement[1] = vertexremap[element[1]];
774 outelement3i[0] = remappedelement[0];
775 outelement3i[1] = remappedelement[1];
776 outelement3i[2] = remappedelement[1] + 1;
777 outelement3i[3] = remappedelement[0];
778 outelement3i[4] = remappedelement[1] + 1;
779 outelement3i[5] = remappedelement[0] + 1;
784 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
786 remappedelement[1] = vertexremap[element[1]];
787 remappedelement[2] = vertexremap[element[2]];
788 outelement3i[0] = remappedelement[1];
789 outelement3i[1] = remappedelement[2];
790 outelement3i[2] = remappedelement[2] + 1;
791 outelement3i[3] = remappedelement[1];
792 outelement3i[4] = remappedelement[2] + 1;
793 outelement3i[5] = remappedelement[1] + 1;
798 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
800 remappedelement[0] = vertexremap[element[0]];
801 remappedelement[2] = vertexremap[element[2]];
802 outelement3i[0] = remappedelement[2];
803 outelement3i[1] = remappedelement[0];
804 outelement3i[2] = remappedelement[0] + 1;
805 outelement3i[3] = remappedelement[2];
806 outelement3i[4] = remappedelement[0] + 1;
807 outelement3i[5] = remappedelement[2] + 1;
815 *outnumvertices = outvertices;
819 static int R_Shadow_ConstructShadowVolume_ZPass(int innumvertices, int innumtris, const int *inelement3i, const int *inneighbor3i, const float *invertex3f, int *outnumvertices, int *outelement3i, float *outvertex3f, const float *projectorigin, const float *projectdirection, float projectdistance, int numshadowmarktris, const int *shadowmarktris)
822 int outtriangles = 0, outvertices = 0;
825 float ratio, direction[3], projectvector[3];
828 if (projectdirection)
829 VectorScale(projectdirection, projectdistance, projectvector);
831 VectorClear(projectvector);
833 for (i = 0;i < numshadowmarktris;i++)
835 int remappedelement[3];
837 const int *neighbortriangle;
839 markindex = shadowmarktris[i] * 3;
840 neighbortriangle = inneighbor3i + markindex;
841 side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
842 side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
843 side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
844 if (side[0] + side[1] + side[2] == 0)
848 element = inelement3i + markindex;
850 // create the vertices
851 for (j = 0;j < 3;j++)
853 if (side[j] + side[j+1] == 0)
856 if (vertexupdate[k] != vertexupdatenum)
858 vertexupdate[k] = vertexupdatenum;
859 vertexremap[k] = outvertices;
860 vertex = invertex3f + k * 3;
861 VectorCopy(vertex, outvertex3f);
862 if (projectdirection)
864 // project one copy of the vertex according to projectvector
865 VectorAdd(vertex, projectvector, (outvertex3f + 3));
869 // project one copy of the vertex to the sphere radius of the light
870 // (FIXME: would projecting it to the light box be better?)
871 VectorSubtract(vertex, projectorigin, direction);
872 ratio = projectdistance / VectorLength(direction);
873 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
880 // output the sides (facing outward from this triangle)
883 remappedelement[0] = vertexremap[element[0]];
884 remappedelement[1] = vertexremap[element[1]];
885 outelement3i[0] = remappedelement[1];
886 outelement3i[1] = remappedelement[0];
887 outelement3i[2] = remappedelement[0] + 1;
888 outelement3i[3] = remappedelement[1];
889 outelement3i[4] = remappedelement[0] + 1;
890 outelement3i[5] = remappedelement[1] + 1;
897 remappedelement[1] = vertexremap[element[1]];
898 remappedelement[2] = vertexremap[element[2]];
899 outelement3i[0] = remappedelement[2];
900 outelement3i[1] = remappedelement[1];
901 outelement3i[2] = remappedelement[1] + 1;
902 outelement3i[3] = remappedelement[2];
903 outelement3i[4] = remappedelement[1] + 1;
904 outelement3i[5] = remappedelement[2] + 1;
911 remappedelement[0] = vertexremap[element[0]];
912 remappedelement[2] = vertexremap[element[2]];
913 outelement3i[0] = remappedelement[0];
914 outelement3i[1] = remappedelement[2];
915 outelement3i[2] = remappedelement[2] + 1;
916 outelement3i[3] = remappedelement[0];
917 outelement3i[4] = remappedelement[2] + 1;
918 outelement3i[5] = remappedelement[0] + 1;
925 *outnumvertices = outvertices;
929 void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const vec3_t projectorigin, const vec3_t projectdirection, const vec3_t lightmins, const vec3_t lightmaxs, const vec3_t surfacemins, const vec3_t surfacemaxs)
935 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
937 tend = firsttriangle + numtris;
938 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
940 // surface box entirely inside light box, no box cull
941 if (projectdirection)
943 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
945 TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal);
946 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
947 shadowmarklist[numshadowmark++] = t;
952 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
953 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
954 shadowmarklist[numshadowmark++] = t;
959 // surface box not entirely inside light box, cull each triangle
960 if (projectdirection)
962 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
964 v[0] = invertex3f + e[0] * 3;
965 v[1] = invertex3f + e[1] * 3;
966 v[2] = invertex3f + e[2] * 3;
967 TriangleNormal(v[0], v[1], v[2], normal);
968 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
969 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
970 shadowmarklist[numshadowmark++] = t;
975 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
977 v[0] = invertex3f + e[0] * 3;
978 v[1] = invertex3f + e[1] * 3;
979 v[2] = invertex3f + e[2] * 3;
980 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
981 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
982 shadowmarklist[numshadowmark++] = t;
988 qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
993 if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
995 // check if the shadow volume intersects the near plane
997 // a ray between the eye and light origin may intersect the caster,
998 // indicating that the shadow may touch the eye location, however we must
999 // test the near plane (a polygon), not merely the eye location, so it is
1000 // easiest to enlarge the caster bounding shape slightly for this.
1006 void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, const vec3_t projectdirection, float projectdistance, int nummarktris, const int *marktris, vec3_t trismins, vec3_t trismaxs)
1008 int i, tris, outverts;
1009 if (projectdistance < 0.1)
1011 Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
1014 if (!numverts || !nummarktris)
1016 // make sure shadowelements is big enough for this volume
1017 if (maxshadowtriangles < nummarktris || maxshadowvertices < numverts)
1018 R_Shadow_ResizeShadowArrays((numverts + 255) & ~255, (nummarktris + 255) & ~255);
1020 if (maxvertexupdate < numverts)
1022 maxvertexupdate = numverts;
1024 Mem_Free(vertexupdate);
1026 Mem_Free(vertexremap);
1027 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1028 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1029 vertexupdatenum = 0;
1032 if (vertexupdatenum == 0)
1034 vertexupdatenum = 1;
1035 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
1036 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
1039 for (i = 0;i < nummarktris;i++)
1040 shadowmark[marktris[i]] = shadowmarkcount;
1042 if (r_shadow_compilingrtlight)
1044 // if we're compiling an rtlight, capture the mesh
1045 //tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1046 //Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1047 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1048 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1052 // decide which type of shadow to generate and set stencil mode
1053 R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
1054 // generate the sides or a solid volume, depending on type
1055 if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
1056 tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1058 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1059 r_refdef.stats.lights_dynamicshadowtriangles += tris;
1060 r_refdef.stats.lights_shadowtriangles += tris;
1062 R_Mesh_VertexPointer(shadowvertex3f, 0, 0);
1063 GL_LockArrays(0, outverts);
1064 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
1066 // increment stencil if frontface is infront of depthbuffer
1067 GL_CullFace(r_refdef.view.cullface_front);
1068 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
1069 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1070 // decrement stencil if backface is infront of depthbuffer
1071 GL_CullFace(r_refdef.view.cullface_back);
1072 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
1074 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
1076 // decrement stencil if backface is behind depthbuffer
1077 GL_CullFace(r_refdef.view.cullface_front);
1078 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
1079 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1080 // increment stencil if frontface is behind depthbuffer
1081 GL_CullFace(r_refdef.view.cullface_back);
1082 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
1084 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1085 GL_LockArrays(0, 0);
1090 static void R_Shadow_MakeTextures_MakeCorona(void)
1094 unsigned char pixels[32][32][4];
1095 for (y = 0;y < 32;y++)
1097 dy = (y - 15.5f) * (1.0f / 16.0f);
1098 for (x = 0;x < 32;x++)
1100 dx = (x - 15.5f) * (1.0f / 16.0f);
1101 a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1102 a = bound(0, a, 255);
1103 pixels[y][x][0] = a;
1104 pixels[y][x][1] = a;
1105 pixels[y][x][2] = a;
1106 pixels[y][x][3] = 255;
1109 r_shadow_lightcorona = R_LoadTexture2D(r_shadow_texturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_FORCELINEAR, NULL);
1112 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1114 float dist = sqrt(x*x+y*y+z*z);
1115 float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1116 // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1117 return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1120 static void R_Shadow_MakeTextures(void)
1123 float intensity, dist;
1125 R_FreeTexturePool(&r_shadow_texturepool);
1126 r_shadow_texturepool = R_AllocTexturePool();
1127 r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1128 r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1129 data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1130 // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1131 for (x = 0;x <= ATTENTABLESIZE;x++)
1133 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1134 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1135 r_shadow_attentable[x] = bound(0, intensity, 1);
1137 // 1D gradient texture
1138 for (x = 0;x < ATTEN1DSIZE;x++)
1139 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1140 r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, NULL);
1141 // 2D circle texture
1142 for (y = 0;y < ATTEN2DSIZE;y++)
1143 for (x = 0;x < ATTEN2DSIZE;x++)
1144 data[y*ATTEN2DSIZE+x] = R_Shadow_MakeTextures_SamplePoint(((x + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375), ((y + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375), 0);
1145 r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, NULL);
1146 // 3D sphere texture
1147 if (r_shadow_texture3d.integer && gl_texture3d)
1149 for (z = 0;z < ATTEN3DSIZE;z++)
1150 for (y = 0;y < ATTEN3DSIZE;y++)
1151 for (x = 0;x < ATTEN3DSIZE;x++)
1152 data[(z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x] = R_Shadow_MakeTextures_SamplePoint(((x + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375), ((y + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375), ((z + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375));
1153 r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, NULL);
1156 r_shadow_attenuation3dtexture = NULL;
1159 R_Shadow_MakeTextures_MakeCorona();
1161 // Editor light sprites
1162 r_editlights_sprcursor = Draw_CachePic ("gfx/editlights/cursor");
1163 r_editlights_sprlight = Draw_CachePic ("gfx/editlights/light");
1164 r_editlights_sprnoshadowlight = Draw_CachePic ("gfx/editlights/noshadow");
1165 r_editlights_sprcubemaplight = Draw_CachePic ("gfx/editlights/cubemaplight");
1166 r_editlights_sprcubemapnoshadowlight = Draw_CachePic ("gfx/editlights/cubemapnoshadowlight");
1167 r_editlights_sprselection = Draw_CachePic ("gfx/editlights/selection");
1170 void R_Shadow_ValidateCvars(void)
1172 if (r_shadow_texture3d.integer && !gl_texture3d)
1173 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
1174 if (gl_ext_separatestencil.integer && !gl_support_separatestencil)
1175 Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
1176 if (gl_ext_stenciltwoside.integer && !gl_support_stenciltwoside)
1177 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
1180 void R_Shadow_RenderMode_Begin(void)
1182 R_Shadow_ValidateCvars();
1184 if (!r_shadow_attenuation2dtexture
1185 || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
1186 || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1187 || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1188 R_Shadow_MakeTextures();
1191 R_Mesh_ColorPointer(NULL, 0, 0);
1192 R_Mesh_ResetTextureState();
1193 GL_BlendFunc(GL_ONE, GL_ZERO);
1194 GL_DepthRange(0, 1);
1195 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1197 GL_DepthMask(false);
1198 GL_Color(0, 0, 0, 1);
1199 GL_Scissor(r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
1201 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1203 if (gl_ext_separatestencil.integer)
1205 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
1206 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
1208 else if (gl_ext_stenciltwoside.integer)
1210 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
1211 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
1215 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
1216 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
1219 if (r_glsl.integer && gl_support_fragment_shader)
1220 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1221 else if (gl_dot3arb && gl_texturecubemap && r_textureunits.integer >= 2 && gl_combine.integer && gl_stencil)
1222 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_DOT3;
1224 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
1227 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
1229 rsurface.rtlight = rtlight;
1232 void R_Shadow_RenderMode_Reset(void)
1235 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE || r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE)
1237 qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
1239 R_Mesh_ColorPointer(NULL, 0, 0);
1240 R_Mesh_ResetTextureState();
1241 GL_DepthRange(0, 1);
1243 GL_DepthMask(false);
1244 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1245 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1246 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
1247 qglStencilMask(~0);CHECKGLERROR
1248 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
1249 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
1250 GL_CullFace(r_refdef.view.cullface_back);
1251 GL_Color(1, 1, 1, 1);
1252 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
1253 GL_BlendFunc(GL_ONE, GL_ZERO);
1254 R_SetupGenericShader(false);
1257 void R_Shadow_ClearStencil(void)
1260 GL_Clear(GL_STENCIL_BUFFER_BIT);
1261 r_refdef.stats.lights_clears++;
1264 void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
1266 r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
1267 if (r_shadow_rendermode == mode)
1270 R_Shadow_RenderMode_Reset();
1271 GL_ColorMask(0, 0, 0, 0);
1272 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
1273 R_SetupDepthOrShadowShader();
1274 qglDepthFunc(GL_LESS);CHECKGLERROR
1275 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
1276 r_shadow_rendermode = mode;
1281 case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
1282 GL_CullFace(GL_NONE);
1283 qglStencilOpSeparate(r_refdef.view.cullface_front, GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
1284 qglStencilOpSeparate(r_refdef.view.cullface_back, GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
1286 case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
1287 GL_CullFace(GL_NONE);
1288 qglStencilOpSeparate(r_refdef.view.cullface_front, GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
1289 qglStencilOpSeparate(r_refdef.view.cullface_back, GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
1291 case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
1292 GL_CullFace(GL_NONE);
1293 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
1294 qglActiveStencilFaceEXT(r_refdef.view.cullface_front);CHECKGLERROR
1295 qglStencilMask(~0);CHECKGLERROR
1296 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
1297 qglActiveStencilFaceEXT(r_refdef.view.cullface_back);CHECKGLERROR
1298 qglStencilMask(~0);CHECKGLERROR
1299 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
1301 case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
1302 GL_CullFace(GL_NONE);
1303 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
1304 qglActiveStencilFaceEXT(r_refdef.view.cullface_front);CHECKGLERROR
1305 qglStencilMask(~0);CHECKGLERROR
1306 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
1307 qglActiveStencilFaceEXT(r_refdef.view.cullface_back);CHECKGLERROR
1308 qglStencilMask(~0);CHECKGLERROR
1309 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
1314 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent)
1317 R_Shadow_RenderMode_Reset();
1318 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1321 qglDepthFunc(GL_EQUAL);CHECKGLERROR
1325 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
1326 // only draw light where this geometry was already rendered AND the
1327 // stencil is 128 (values other than this mean shadow)
1328 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
1330 r_shadow_rendermode = r_shadow_lightingrendermode;
1331 // do global setup needed for the chosen lighting mode
1332 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
1334 R_Mesh_TexBindCubeMap(GL20TU_CUBE, R_GetTexture(rsurface.rtlight->currentcubemap)); // light filter
1335 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
1337 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_VERTEX)
1338 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
1339 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1342 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
1345 R_Shadow_RenderMode_Reset();
1346 GL_BlendFunc(GL_ONE, GL_ONE);
1347 GL_DepthRange(0, 1);
1348 GL_DepthTest(r_showshadowvolumes.integer < 2);
1349 GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
1350 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
1351 GL_CullFace(GL_NONE);
1352 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
1355 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
1358 R_Shadow_RenderMode_Reset();
1359 GL_BlendFunc(GL_ONE, GL_ONE);
1360 GL_DepthRange(0, 1);
1361 GL_DepthTest(r_showlighting.integer < 2);
1362 GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
1365 qglDepthFunc(GL_EQUAL);CHECKGLERROR
1369 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
1370 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
1372 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
1375 void R_Shadow_RenderMode_End(void)
1378 R_Shadow_RenderMode_Reset();
1379 R_Shadow_RenderMode_ActiveLight(NULL);
1381 GL_Scissor(r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
1382 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1385 int bboxedges[12][2] =
1404 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
1406 int i, ix1, iy1, ix2, iy2;
1407 float x1, y1, x2, y2;
1409 float vertex[20][3];
1418 if (!r_shadow_scissor.integer)
1421 // if view is inside the light box, just say yes it's visible
1422 if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs))
1424 GL_Scissor(r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
1428 x1 = y1 = x2 = y2 = 0;
1430 // transform all corners that are infront of the nearclip plane
1431 VectorNegate(r_refdef.view.frustum[4].normal, plane4f);
1432 plane4f[3] = r_refdef.view.frustum[4].dist;
1434 for (i = 0;i < 8;i++)
1436 Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1);
1437 dist[i] = DotProduct4(corner[i], plane4f);
1438 sign[i] = dist[i] > 0;
1441 VectorCopy(corner[i], vertex[numvertices]);
1445 // if some points are behind the nearclip, add clipped edge points to make
1446 // sure that the scissor boundary is complete
1447 if (numvertices > 0 && numvertices < 8)
1449 // add clipped edge points
1450 for (i = 0;i < 12;i++)
1452 j = bboxedges[i][0];
1453 k = bboxedges[i][1];
1454 if (sign[j] != sign[k])
1456 f = dist[j] / (dist[j] - dist[k]);
1457 VectorLerp(corner[j], f, corner[k], vertex[numvertices]);
1463 // if we have no points to check, the light is behind the view plane
1467 // if we have some points to transform, check what screen area is covered
1468 x1 = y1 = x2 = y2 = 0;
1470 //Con_Printf("%i vertices to transform...\n", numvertices);
1471 for (i = 0;i < numvertices;i++)
1473 VectorCopy(vertex[i], v);
1474 GL_TransformToScreen(v, v2);
1475 //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]);
1478 if (x1 > v2[0]) x1 = v2[0];
1479 if (x2 < v2[0]) x2 = v2[0];
1480 if (y1 > v2[1]) y1 = v2[1];
1481 if (y2 < v2[1]) y2 = v2[1];
1490 // now convert the scissor rectangle to integer screen coordinates
1491 ix1 = (int)(x1 - 1.0f);
1492 iy1 = (int)(y1 - 1.0f);
1493 ix2 = (int)(x2 + 1.0f);
1494 iy2 = (int)(y2 + 1.0f);
1495 //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
1497 // clamp it to the screen
1498 if (ix1 < r_refdef.view.x) ix1 = r_refdef.view.x;
1499 if (iy1 < r_refdef.view.y) iy1 = r_refdef.view.y;
1500 if (ix2 > r_refdef.view.x + r_refdef.view.width) ix2 = r_refdef.view.x + r_refdef.view.width;
1501 if (iy2 > r_refdef.view.y + r_refdef.view.height) iy2 = r_refdef.view.y + r_refdef.view.height;
1503 // if it is inside out, it's not visible
1504 if (ix2 <= ix1 || iy2 <= iy1)
1507 // the light area is visible, set up the scissor rectangle
1508 GL_Scissor(ix1, iy1, ix2 - ix1, iy2 - iy1);
1509 //qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1);CHECKGLERROR
1510 //qglEnable(GL_SCISSOR_TEST);CHECKGLERROR
1511 r_refdef.stats.lights_scissored++;
1515 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, int numtriangles, const int *element3i, const float *diffusecolor, const float *ambientcolor)
1517 float *vertex3f = rsurface.vertex3f + 3 * firstvertex;
1518 float *normal3f = rsurface.normal3f + 3 * firstvertex;
1519 float *color4f = rsurface.array_color4f + 4 * firstvertex;
1520 float dist, dot, distintensity, shadeintensity, v[3], n[3];
1521 if (r_textureunits.integer >= 3)
1523 if (VectorLength2(diffusecolor) > 0)
1525 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1527 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
1528 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
1529 if ((dot = DotProduct(n, v)) < 0)
1531 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
1532 VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
1535 VectorCopy(ambientcolor, color4f);
1536 if (r_refdef.fogenabled)
1539 f = FogPoint_Model(vertex3f);
1540 VectorScale(color4f, f, color4f);
1547 for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
1549 VectorCopy(ambientcolor, color4f);
1550 if (r_refdef.fogenabled)
1553 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
1554 f = FogPoint_Model(vertex3f);
1555 VectorScale(color4f, f, color4f);
1561 else if (r_textureunits.integer >= 2)
1563 if (VectorLength2(diffusecolor) > 0)
1565 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1567 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
1568 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
1570 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
1571 if ((dot = DotProduct(n, v)) < 0)
1573 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
1574 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
1575 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
1576 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
1580 color4f[0] = ambientcolor[0] * distintensity;
1581 color4f[1] = ambientcolor[1] * distintensity;
1582 color4f[2] = ambientcolor[2] * distintensity;
1584 if (r_refdef.fogenabled)
1587 f = FogPoint_Model(vertex3f);
1588 VectorScale(color4f, f, color4f);
1592 VectorClear(color4f);
1598 for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
1600 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
1601 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
1603 color4f[0] = ambientcolor[0] * distintensity;
1604 color4f[1] = ambientcolor[1] * distintensity;
1605 color4f[2] = ambientcolor[2] * distintensity;
1606 if (r_refdef.fogenabled)
1609 f = FogPoint_Model(vertex3f);
1610 VectorScale(color4f, f, color4f);
1614 VectorClear(color4f);
1621 if (VectorLength2(diffusecolor) > 0)
1623 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
1625 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
1626 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
1628 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
1629 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
1630 if ((dot = DotProduct(n, v)) < 0)
1632 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
1633 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
1634 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
1635 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
1639 color4f[0] = ambientcolor[0] * distintensity;
1640 color4f[1] = ambientcolor[1] * distintensity;
1641 color4f[2] = ambientcolor[2] * distintensity;
1643 if (r_refdef.fogenabled)
1646 f = FogPoint_Model(vertex3f);
1647 VectorScale(color4f, f, color4f);
1651 VectorClear(color4f);
1657 for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
1659 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
1660 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
1662 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
1663 color4f[0] = ambientcolor[0] * distintensity;
1664 color4f[1] = ambientcolor[1] * distintensity;
1665 color4f[2] = ambientcolor[2] * distintensity;
1666 if (r_refdef.fogenabled)
1669 f = FogPoint_Model(vertex3f);
1670 VectorScale(color4f, f, color4f);
1674 VectorClear(color4f);
1681 // TODO: use glTexGen instead of feeding vertices to texcoordpointer?
1683 static void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(int firstvertex, int numvertices, int numtriangles, const int *element3i)
1686 float *out3f = rsurface.array_texcoord3f + 3 * firstvertex;
1687 const float *vertex3f = rsurface.vertex3f + 3 * firstvertex;
1688 const float *svector3f = rsurface.svector3f + 3 * firstvertex;
1689 const float *tvector3f = rsurface.tvector3f + 3 * firstvertex;
1690 const float *normal3f = rsurface.normal3f + 3 * firstvertex;
1692 for (i = 0;i < numvertices;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
1694 VectorSubtract(rsurface.entitylightorigin, vertex3f, lightdir);
1695 // the cubemap normalizes this for us
1696 out3f[0] = DotProduct(svector3f, lightdir);
1697 out3f[1] = DotProduct(tvector3f, lightdir);
1698 out3f[2] = DotProduct(normal3f, lightdir);
1702 static void R_Shadow_GenTexCoords_Specular_NormalCubeMap(int firstvertex, int numvertices, int numtriangles, const int *element3i)
1705 float *out3f = rsurface.array_texcoord3f + 3 * firstvertex;
1706 const float *vertex3f = rsurface.vertex3f + 3 * firstvertex;
1707 const float *svector3f = rsurface.svector3f + 3 * firstvertex;
1708 const float *tvector3f = rsurface.tvector3f + 3 * firstvertex;
1709 const float *normal3f = rsurface.normal3f + 3 * firstvertex;
1710 float lightdir[3], eyedir[3], halfdir[3];
1711 for (i = 0;i < numvertices;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
1713 VectorSubtract(rsurface.entitylightorigin, vertex3f, lightdir);
1714 VectorNormalize(lightdir);
1715 VectorSubtract(rsurface.modelorg, vertex3f, eyedir);
1716 VectorNormalize(eyedir);
1717 VectorAdd(lightdir, eyedir, halfdir);
1718 // the cubemap normalizes this for us
1719 out3f[0] = DotProduct(svector3f, halfdir);
1720 out3f[1] = DotProduct(tvector3f, halfdir);
1721 out3f[2] = DotProduct(normal3f, halfdir);
1725 static void R_Shadow_RenderLighting_VisibleLighting(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
1727 // used to display how many times a surface is lit for level design purposes
1728 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
1731 static void R_Shadow_RenderLighting_Light_GLSL(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
1733 // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
1734 R_SetupSurfaceShader(lightcolorbase, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT);
1735 if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
1736 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
1738 R_Mesh_ColorPointer(NULL, 0, 0);
1739 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
1740 R_Mesh_TexMatrix(1, &rsurface.texture->currentbackgroundtexmatrix);
1741 R_Mesh_TexBind(GL20TU_NORMAL, R_GetTexture(rsurface.texture->currentskinframe->nmap));
1742 R_Mesh_TexBind(GL20TU_COLOR, R_GetTexture(rsurface.texture->basetexture));
1743 R_Mesh_TexBind(GL20TU_GLOSS, R_GetTexture(rsurface.texture->glosstexture));
1744 if (rsurface.texture->backgroundcurrentskinframe)
1746 R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->nmap));
1747 R_Mesh_TexBind(GL20TU_SECONDARY_COLOR, R_GetTexture(rsurface.texture->backgroundbasetexture));
1748 R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS, R_GetTexture(rsurface.texture->backgroundglosstexture));
1749 R_Mesh_TexBind(GL20TU_SECONDARY_GLOW, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->glow));
1751 //R_Mesh_TexBindCubeMap(GL20TU_CUBE, R_GetTexture(rsurface.rtlight->currentcubemap));
1752 R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
1753 if(rsurface.texture->colormapping)
1755 R_Mesh_TexBind(GL20TU_PANTS, R_GetTexture(rsurface.texture->currentskinframe->pants));
1756 R_Mesh_TexBind(GL20TU_SHIRT, R_GetTexture(rsurface.texture->currentskinframe->shirt));
1758 R_Mesh_TexBind(GL20TU_ATTENUATION, R_GetTexture(r_shadow_attenuationgradienttexture));
1759 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
1760 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
1761 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
1762 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
1763 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
1765 qglDepthFunc(GL_EQUAL);CHECKGLERROR
1767 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
1768 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
1770 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1774 static void R_Shadow_RenderLighting_Light_Dot3_Finalize(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, float r, float g, float b)
1776 // shared final code for all the dot3 layers
1778 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
1779 for (renders = 0;renders < 64 && (r > 0 || g > 0 || b > 0);renders++, r--, g--, b--)
1781 GL_Color(bound(0, r, 1), bound(0, g, 1), bound(0, b, 1), 1);
1782 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
1786 static void R_Shadow_RenderLighting_Light_Dot3_AmbientPass(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, rtexture_t *basetexture, float colorscale)
1789 // colorscale accounts for how much we multiply the brightness
1792 // mult is how many times the final pass of the lighting will be
1793 // performed to get more brightness than otherwise possible.
1795 // Limit mult to 64 for sanity sake.
1797 if (r_shadow_texture3d.integer && rsurface.rtlight->currentcubemap != r_texture_whitecube && r_textureunits.integer >= 4)
1799 // 3 3D combine path (Geforce3, Radeon 8500)
1800 memset(&m, 0, sizeof(m));
1801 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1802 m.pointer_texcoord3f[0] = rsurface.vertex3f;
1803 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
1804 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
1805 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
1806 m.tex[1] = R_GetTexture(basetexture);
1807 m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
1808 m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
1809 m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
1810 m.texmatrix[1] = rsurface.texture->currenttexmatrix;
1811 m.texcubemap[2] = R_GetTexture(rsurface.rtlight->currentcubemap);
1812 m.pointer_texcoord3f[2] = rsurface.vertex3f;
1813 m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
1814 m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
1815 m.texmatrix[2] = rsurface.entitytolight;
1816 GL_BlendFunc(GL_ONE, GL_ONE);
1818 else if (r_shadow_texture3d.integer && rsurface.rtlight->currentcubemap == r_texture_whitecube && r_textureunits.integer >= 2)
1820 // 2 3D combine path (Geforce3, original Radeon)
1821 memset(&m, 0, sizeof(m));
1822 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1823 m.pointer_texcoord3f[0] = rsurface.vertex3f;
1824 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
1825 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
1826 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
1827 m.tex[1] = R_GetTexture(basetexture);
1828 m.pointer_texcoord[1] = rsurface.texcoordtexture2f;
1829 m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject;
1830 m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset;
1831 m.texmatrix[1] = rsurface.texture->currenttexmatrix;
1832 GL_BlendFunc(GL_ONE, GL_ONE);
1834 else if (r_textureunits.integer >= 4 && rsurface.rtlight->currentcubemap != r_texture_whitecube)
1836 // 4 2D combine path (Geforce3, Radeon 8500)
1837 memset(&m, 0, sizeof(m));
1838 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1839 m.pointer_texcoord3f[0] = rsurface.vertex3f;
1840 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
1841 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
1842 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
1843 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1844 m.pointer_texcoord3f[1] = rsurface.vertex3f;
1845 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
1846 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
1847 m.texmatrix[1] = rsurface.entitytoattenuationz;
1848 m.tex[2] = R_GetTexture(basetexture);
1849 m.pointer_texcoord[2] = rsurface.texcoordtexture2f;
1850 m.pointer_texcoord_bufferobject[2] = rsurface.texcoordtexture2f_bufferobject;
1851 m.pointer_texcoord_bufferoffset[2] = rsurface.texcoordtexture2f_bufferoffset;
1852 m.texmatrix[2] = rsurface.texture->currenttexmatrix;
1853 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1855 m.texcubemap[3] = R_GetTexture(rsurface.rtlight->currentcubemap);
1856 m.pointer_texcoord3f[3] = rsurface.vertex3f;
1857 m.pointer_texcoord_bufferobject[3] = rsurface.vertex3f_bufferobject;
1858 m.pointer_texcoord_bufferoffset[3] = rsurface.vertex3f_bufferoffset;
1859 m.texmatrix[3] = rsurface.entitytolight;
1861 GL_BlendFunc(GL_ONE, GL_ONE);
1863 else if (r_textureunits.integer >= 3 && rsurface.rtlight->currentcubemap == r_texture_whitecube)
1865 // 3 2D combine path (Geforce3, original Radeon)
1866 memset(&m, 0, sizeof(m));
1867 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1868 m.pointer_texcoord3f[0] = rsurface.vertex3f;
1869 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
1870 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
1871 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
1872 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1873 m.pointer_texcoord3f[1] = rsurface.vertex3f;
1874 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
1875 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
1876 m.texmatrix[1] = rsurface.entitytoattenuationz;
1877 m.tex[2] = R_GetTexture(basetexture);
1878 m.pointer_texcoord[2] = rsurface.texcoordtexture2f;
1879 m.pointer_texcoord_bufferobject[2] = rsurface.texcoordtexture2f_bufferobject;
1880 m.pointer_texcoord_bufferoffset[2] = rsurface.texcoordtexture2f_bufferoffset;
1881 m.texmatrix[2] = rsurface.texture->currenttexmatrix;
1882 GL_BlendFunc(GL_ONE, GL_ONE);
1886 // 2/2/2 2D combine path (any dot3 card)
1887 memset(&m, 0, sizeof(m));
1888 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
1889 m.pointer_texcoord3f[0] = rsurface.vertex3f;
1890 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
1891 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
1892 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
1893 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
1894 m.pointer_texcoord3f[1] = rsurface.vertex3f;
1895 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
1896 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
1897 m.texmatrix[1] = rsurface.entitytoattenuationz;
1898 R_Mesh_TextureState(&m);
1899 GL_ColorMask(0,0,0,1);
1900 GL_BlendFunc(GL_ONE, GL_ZERO);
1901 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
1904 memset(&m, 0, sizeof(m));
1905 m.tex[0] = R_GetTexture(basetexture);
1906 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
1907 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
1908 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
1909 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
1910 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1912 m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
1913 m.pointer_texcoord3f[1] = rsurface.vertex3f;
1914 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
1915 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
1916 m.texmatrix[1] = rsurface.entitytolight;
1918 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1920 // this final code is shared
1921 R_Mesh_TextureState(&m);
1922 R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale);
1925 static void R_Shadow_RenderLighting_Light_Dot3_DiffusePass(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, rtexture_t *basetexture, rtexture_t *normalmaptexture, float colorscale)
1928 // colorscale accounts for how much we multiply the brightness
1931 // mult is how many times the final pass of the lighting will be
1932 // performed to get more brightness than otherwise possible.
1934 // Limit mult to 64 for sanity sake.
1936 // generate normalization cubemap texcoords
1937 R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(firstvertex, numvertices, numtriangles, element3i);
1938 if (r_shadow_texture3d.integer && r_textureunits.integer >= 4)
1940 // 3/2 3D combine path (Geforce3, Radeon 8500)
1941 memset(&m, 0, sizeof(m));
1942 m.tex[0] = R_GetTexture(normalmaptexture);
1943 m.texcombinergb[0] = GL_REPLACE;
1944 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
1945 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
1946 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
1947 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
1948 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
1949 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
1950 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
1951 m.pointer_texcoord_bufferobject[1] = 0;
1952 m.pointer_texcoord_bufferoffset[1] = 0;
1953 m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture);
1954 m.pointer_texcoord3f[2] = rsurface.vertex3f;
1955 m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
1956 m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
1957 m.texmatrix[2] = rsurface.entitytoattenuationxyz;
1958 R_Mesh_TextureState(&m);
1959 GL_ColorMask(0,0,0,1);
1960 GL_BlendFunc(GL_ONE, GL_ZERO);
1961 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
1964 memset(&m, 0, sizeof(m));
1965 m.tex[0] = R_GetTexture(basetexture);
1966 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
1967 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
1968 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
1969 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
1970 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
1972 m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
1973 m.pointer_texcoord3f[1] = rsurface.vertex3f;
1974 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
1975 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
1976 m.texmatrix[1] = rsurface.entitytolight;
1978 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
1980 else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap != r_texture_whitecube)
1982 // 1/2/2 3D combine path (original Radeon)
1983 memset(&m, 0, sizeof(m));
1984 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
1985 m.pointer_texcoord3f[0] = rsurface.vertex3f;
1986 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
1987 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
1988 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
1989 R_Mesh_TextureState(&m);
1990 GL_ColorMask(0,0,0,1);
1991 GL_BlendFunc(GL_ONE, GL_ZERO);
1992 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
1995 memset(&m, 0, sizeof(m));
1996 m.tex[0] = R_GetTexture(normalmaptexture);
1997 m.texcombinergb[0] = GL_REPLACE;
1998 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
1999 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2000 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2001 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2002 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
2003 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
2004 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
2005 m.pointer_texcoord_bufferobject[1] = 0;
2006 m.pointer_texcoord_bufferoffset[1] = 0;
2007 R_Mesh_TextureState(&m);
2008 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
2009 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2012 memset(&m, 0, sizeof(m));
2013 m.tex[0] = R_GetTexture(basetexture);
2014 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2015 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2016 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2017 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2018 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2020 m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
2021 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2022 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2023 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2024 m.texmatrix[1] = rsurface.entitytolight;
2026 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2028 else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap == r_texture_whitecube)
2030 // 2/2 3D combine path (original Radeon)
2031 memset(&m, 0, sizeof(m));
2032 m.tex[0] = R_GetTexture(normalmaptexture);
2033 m.texcombinergb[0] = GL_REPLACE;
2034 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2035 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2036 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2037 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2038 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
2039 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
2040 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
2041 m.pointer_texcoord_bufferobject[1] = 0;
2042 m.pointer_texcoord_bufferoffset[1] = 0;
2043 R_Mesh_TextureState(&m);
2044 GL_ColorMask(0,0,0,1);
2045 GL_BlendFunc(GL_ONE, GL_ZERO);
2046 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2049 memset(&m, 0, sizeof(m));
2050 m.tex[0] = R_GetTexture(basetexture);
2051 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2052 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2053 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2054 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2055 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
2056 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2057 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2058 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2059 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2060 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2062 else if (r_textureunits.integer >= 4)
2064 // 4/2 2D combine path (Geforce3, Radeon 8500)
2065 memset(&m, 0, sizeof(m));
2066 m.tex[0] = R_GetTexture(normalmaptexture);
2067 m.texcombinergb[0] = GL_REPLACE;
2068 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2069 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2070 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2071 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2072 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
2073 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
2074 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
2075 m.pointer_texcoord_bufferobject[1] = 0;
2076 m.pointer_texcoord_bufferoffset[1] = 0;
2077 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
2078 m.pointer_texcoord3f[2] = rsurface.vertex3f;
2079 m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
2080 m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
2081 m.texmatrix[2] = rsurface.entitytoattenuationxyz;
2082 m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture);
2083 m.pointer_texcoord3f[3] = rsurface.vertex3f;
2084 m.pointer_texcoord_bufferobject[3] = rsurface.vertex3f_bufferobject;
2085 m.pointer_texcoord_bufferoffset[3] = rsurface.vertex3f_bufferoffset;
2086 m.texmatrix[3] = rsurface.entitytoattenuationz;
2087 R_Mesh_TextureState(&m);
2088 GL_ColorMask(0,0,0,1);
2089 GL_BlendFunc(GL_ONE, GL_ZERO);
2090 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2093 memset(&m, 0, sizeof(m));
2094 m.tex[0] = R_GetTexture(basetexture);
2095 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2096 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2097 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2098 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2099 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2101 m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
2102 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2103 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2104 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2105 m.texmatrix[1] = rsurface.entitytolight;
2107 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2111 // 2/2/2 2D combine path (any dot3 card)
2112 memset(&m, 0, sizeof(m));
2113 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
2114 m.pointer_texcoord3f[0] = rsurface.vertex3f;
2115 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
2116 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
2117 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
2118 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2119 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2120 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
2121 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
2122 m.texmatrix[1] = rsurface.entitytoattenuationz;
2123 R_Mesh_TextureState(&m);
2124 GL_ColorMask(0,0,0,1);
2125 GL_BlendFunc(GL_ONE, GL_ZERO);
2126 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2129 memset(&m, 0, sizeof(m));
2130 m.tex[0] = R_GetTexture(normalmaptexture);
2131 m.texcombinergb[0] = GL_REPLACE;
2132 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2133 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2134 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2135 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2136 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
2137 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
2138 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
2139 m.pointer_texcoord_bufferobject[1] = 0;
2140 m.pointer_texcoord_bufferoffset[1] = 0;
2141 R_Mesh_TextureState(&m);
2142 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
2143 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2146 memset(&m, 0, sizeof(m));
2147 m.tex[0] = R_GetTexture(basetexture);
2148 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2149 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2150 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2151 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2152 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2154 m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
2155 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2156 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2157 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2158 m.texmatrix[1] = rsurface.entitytolight;
2160 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2162 // this final code is shared
2163 R_Mesh_TextureState(&m);
2164 R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale);
2167 static void R_Shadow_RenderLighting_Light_Dot3_SpecularPass(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, rtexture_t *glosstexture, rtexture_t *normalmaptexture, float colorscale)
2169 float glossexponent;
2171 // FIXME: detect blendsquare!
2172 //if (!gl_support_blendsquare)
2175 // generate normalization cubemap texcoords
2176 R_Shadow_GenTexCoords_Specular_NormalCubeMap(firstvertex, numvertices, numtriangles, element3i);
2177 if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap != r_texture_whitecube)
2179 // 2/0/0/1/2 3D combine blendsquare path
2180 memset(&m, 0, sizeof(m));
2181 m.tex[0] = R_GetTexture(normalmaptexture);
2182 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2183 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2184 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2185 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2186 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
2187 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
2188 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
2189 m.pointer_texcoord_bufferobject[1] = 0;
2190 m.pointer_texcoord_bufferoffset[1] = 0;
2191 R_Mesh_TextureState(&m);
2192 GL_ColorMask(0,0,0,1);
2193 // this squares the result
2194 GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
2195 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2197 // second and third pass
2198 R_Mesh_ResetTextureState();
2199 // square alpha in framebuffer a few times to make it shiny
2200 GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
2201 for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2)
2202 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2205 memset(&m, 0, sizeof(m));
2206 m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture);
2207 m.pointer_texcoord3f[0] = rsurface.vertex3f;
2208 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
2209 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
2210 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
2211 R_Mesh_TextureState(&m);
2212 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
2213 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2216 memset(&m, 0, sizeof(m));
2217 m.tex[0] = R_GetTexture(glosstexture);
2218 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2219 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2220 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2221 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2222 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2224 m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
2225 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2226 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2227 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2228 m.texmatrix[1] = rsurface.entitytolight;
2230 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2232 else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap == r_texture_whitecube /* && gl_support_blendsquare*/) // FIXME: detect blendsquare!
2234 // 2/0/0/2 3D combine blendsquare path
2235 memset(&m, 0, sizeof(m));
2236 m.tex[0] = R_GetTexture(normalmaptexture);
2237 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2238 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2239 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2240 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2241 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
2242 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
2243 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
2244 m.pointer_texcoord_bufferobject[1] = 0;
2245 m.pointer_texcoord_bufferoffset[1] = 0;
2246 R_Mesh_TextureState(&m);
2247 GL_ColorMask(0,0,0,1);
2248 // this squares the result
2249 GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
2250 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2252 // second and third pass
2253 R_Mesh_ResetTextureState();
2254 // square alpha in framebuffer a few times to make it shiny
2255 GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
2256 for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2)
2257 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2260 memset(&m, 0, sizeof(m));
2261 m.tex[0] = R_GetTexture(glosstexture);
2262 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2263 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2264 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2265 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2266 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
2267 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2268 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2269 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2270 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2271 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2275 // 2/0/0/2/2 2D combine blendsquare path
2276 memset(&m, 0, sizeof(m));
2277 m.tex[0] = R_GetTexture(normalmaptexture);
2278 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2279 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2280 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2281 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2282 m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube);
2283 m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
2284 m.pointer_texcoord3f[1] = rsurface.array_texcoord3f;
2285 m.pointer_texcoord_bufferobject[1] = 0;
2286 m.pointer_texcoord_bufferoffset[1] = 0;
2287 R_Mesh_TextureState(&m);
2288 GL_ColorMask(0,0,0,1);
2289 // this squares the result
2290 GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
2291 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2293 // second and third pass
2294 R_Mesh_ResetTextureState();
2295 // square alpha in framebuffer a few times to make it shiny
2296 GL_BlendFunc(GL_ZERO, GL_DST_ALPHA);
2297 for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2)
2298 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2301 memset(&m, 0, sizeof(m));
2302 m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture);
2303 m.pointer_texcoord3f[0] = rsurface.vertex3f;
2304 m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject;
2305 m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset;
2306 m.texmatrix[0] = rsurface.entitytoattenuationxyz;
2307 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2308 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2309 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2310 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2311 m.texmatrix[1] = rsurface.entitytoattenuationz;
2312 R_Mesh_TextureState(&m);
2313 GL_BlendFunc(GL_DST_ALPHA, GL_ZERO);
2314 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2317 memset(&m, 0, sizeof(m));
2318 m.tex[0] = R_GetTexture(glosstexture);
2319 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2320 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2321 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2322 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2323 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2325 m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap);
2326 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2327 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2328 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2329 m.texmatrix[1] = rsurface.entitytolight;
2331 GL_BlendFunc(GL_DST_ALPHA, GL_ONE);
2333 // this final code is shared
2334 R_Mesh_TextureState(&m);
2335 R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale);
2338 static void R_Shadow_RenderLighting_Light_Dot3(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
2340 // ARB path (any Geforce, any Radeon)
2341 qboolean doambient = ambientscale > 0;
2342 qboolean dodiffuse = diffusescale > 0;
2343 qboolean dospecular = specularscale > 0;
2344 if (!doambient && !dodiffuse && !dospecular)
2346 R_Mesh_ColorPointer(NULL, 0, 0);
2348 R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, basetexture, ambientscale * r_refdef.view.colorscale);
2350 R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, basetexture, normalmaptexture, diffusescale * r_refdef.view.colorscale);
2354 R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorpants, pantstexture, ambientscale * r_refdef.view.colorscale);
2356 R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorpants, pantstexture, normalmaptexture, diffusescale * r_refdef.view.colorscale);
2361 R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorshirt, shirttexture, ambientscale * r_refdef.view.colorscale);
2363 R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorshirt, shirttexture, normalmaptexture, diffusescale * r_refdef.view.colorscale);
2366 R_Shadow_RenderLighting_Light_Dot3_SpecularPass(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, glosstexture, normalmaptexture, specularscale * r_refdef.view.colorscale);
2369 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
2376 int newnumtriangles;
2380 int maxtriangles = 4096;
2381 int newelements[4096*3];
2382 R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, numtriangles, element3i, diffusecolor2, ambientcolor2);
2383 for (renders = 0;renders < 64;renders++)
2388 newnumtriangles = 0;
2390 // due to low fillrate on the cards this vertex lighting path is
2391 // designed for, we manually cull all triangles that do not
2392 // contain a lit vertex
2393 // this builds batches of triangles from multiple surfaces and
2394 // renders them at once
2395 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
2397 if (VectorLength2(rsurface.array_color4f + e[0] * 4) + VectorLength2(rsurface.array_color4f + e[1] * 4) + VectorLength2(rsurface.array_color4f + e[2] * 4) >= 0.01)
2399 if (newnumtriangles)
2401 newfirstvertex = min(newfirstvertex, e[0]);
2402 newlastvertex = max(newlastvertex, e[0]);
2406 newfirstvertex = e[0];
2407 newlastvertex = e[0];
2409 newfirstvertex = min(newfirstvertex, e[1]);
2410 newlastvertex = max(newlastvertex, e[1]);
2411 newfirstvertex = min(newfirstvertex, e[2]);
2412 newlastvertex = max(newlastvertex, e[2]);
2418 if (newnumtriangles >= maxtriangles)
2420 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2421 newnumtriangles = 0;
2427 if (newnumtriangles >= 1)
2429 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2432 // if we couldn't find any lit triangles, exit early
2435 // now reduce the intensity for the next overbright pass
2436 // we have to clamp to 0 here incase the drivers have improper
2437 // handling of negative colors
2438 // (some old drivers even have improper handling of >1 color)
2440 for (i = 0, c = rsurface.array_color4f + 4 * firstvertex;i < numvertices;i++, c += 4)
2442 if (c[0] > 1 || c[1] > 1 || c[2] > 1)
2444 c[0] = max(0, c[0] - 1);
2445 c[1] = max(0, c[1] - 1);
2446 c[2] = max(0, c[2] - 1);
2458 static void R_Shadow_RenderLighting_Light_Vertex(int firstvertex, int numvertices, int numtriangles, const int *element3i, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
2460 // OpenGL 1.1 path (anything)
2461 float ambientcolorbase[3], diffusecolorbase[3];
2462 float ambientcolorpants[3], diffusecolorpants[3];
2463 float ambientcolorshirt[3], diffusecolorshirt[3];
2465 VectorScale(lightcolorbase, ambientscale * 2 * r_refdef.view.colorscale, ambientcolorbase);
2466 VectorScale(lightcolorbase, diffusescale * 2 * r_refdef.view.colorscale, diffusecolorbase);
2467 VectorScale(lightcolorpants, ambientscale * 2 * r_refdef.view.colorscale, ambientcolorpants);
2468 VectorScale(lightcolorpants, diffusescale * 2 * r_refdef.view.colorscale, diffusecolorpants);
2469 VectorScale(lightcolorshirt, ambientscale * 2 * r_refdef.view.colorscale, ambientcolorshirt);
2470 VectorScale(lightcolorshirt, diffusescale * 2 * r_refdef.view.colorscale, diffusecolorshirt);
2471 memset(&m, 0, sizeof(m));
2472 m.tex[0] = R_GetTexture(basetexture);
2473 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2474 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2475 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2476 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2477 if (r_textureunits.integer >= 2)
2480 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2481 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2482 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2483 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2484 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2485 if (r_textureunits.integer >= 3)
2487 // Voodoo4 or Kyro (or Geforce3/Radeon with gl_combine off)
2488 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
2489 m.texmatrix[2] = rsurface.entitytoattenuationz;
2490 m.pointer_texcoord3f[2] = rsurface.vertex3f;
2491 m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
2492 m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
2495 R_Mesh_TextureState(&m);
2496 //R_Mesh_TexBind(0, R_GetTexture(basetexture));
2497 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorbase, ambientcolorbase);
2500 R_Mesh_TexBind(0, R_GetTexture(pantstexture));
2501 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorpants, ambientcolorpants);
2505 R_Mesh_TexBind(0, R_GetTexture(shirttexture));
2506 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorshirt, ambientcolorshirt);
2510 extern cvar_t gl_lightmaps;
2511 void R_Shadow_RenderLighting(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject)
2513 float ambientscale, diffusescale, specularscale;
2514 vec3_t lightcolorbase, lightcolorpants, lightcolorshirt;
2516 // calculate colors to render this texture with
2517 lightcolorbase[0] = rsurface.rtlight->currentcolor[0] * rsurface.texture->dlightcolor[0];
2518 lightcolorbase[1] = rsurface.rtlight->currentcolor[1] * rsurface.texture->dlightcolor[1];
2519 lightcolorbase[2] = rsurface.rtlight->currentcolor[2] * rsurface.texture->dlightcolor[2];
2520 ambientscale = rsurface.rtlight->ambientscale;
2521 diffusescale = rsurface.rtlight->diffusescale;
2522 specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
2523 if (!r_shadow_usenormalmap.integer)
2525 ambientscale += 1.0f * diffusescale;
2529 if ((ambientscale + diffusescale) * VectorLength2(lightcolorbase) + specularscale * VectorLength2(lightcolorbase) < (1.0f / 1048576.0f))
2531 RSurf_SetupDepthAndCulling();
2532 nmap = rsurface.texture->currentskinframe->nmap;
2533 if (gl_lightmaps.integer)
2534 nmap = r_texture_blanknormalmap;
2535 if (rsurface.texture->colormapping && !gl_lightmaps.integer)
2537 qboolean dopants = rsurface.texture->currentskinframe->pants != NULL && VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f);
2538 qboolean doshirt = rsurface.texture->currentskinframe->shirt != NULL && VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
2541 lightcolorpants[0] = lightcolorbase[0] * rsurface.colormap_pantscolor[0];
2542 lightcolorpants[1] = lightcolorbase[1] * rsurface.colormap_pantscolor[1];
2543 lightcolorpants[2] = lightcolorbase[2] * rsurface.colormap_pantscolor[2];
2546 VectorClear(lightcolorpants);
2549 lightcolorshirt[0] = lightcolorbase[0] * rsurface.colormap_shirtcolor[0];
2550 lightcolorshirt[1] = lightcolorbase[1] * rsurface.colormap_shirtcolor[1];
2551 lightcolorshirt[2] = lightcolorbase[2] * rsurface.colormap_shirtcolor[2];
2554 VectorClear(lightcolorshirt);
2555 switch (r_shadow_rendermode)
2557 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2558 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
2559 R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
2561 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2562 R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
2564 case R_SHADOW_RENDERMODE_LIGHT_DOT3:
2565 R_Shadow_RenderLighting_Light_Dot3(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
2567 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2568 R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i + firsttriangle * 3, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
2571 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2577 switch (r_shadow_rendermode)
2579 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2580 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
2581 R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
2583 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2584 R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
2586 case R_SHADOW_RENDERMODE_LIGHT_DOT3:
2587 R_Shadow_RenderLighting_Light_Dot3(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
2589 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2590 R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i + firsttriangle * 3, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
2593 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2599 void R_RTLight_Update(rtlight_t *rtlight, int isstatic, matrix4x4_t *matrix, vec3_t color, int style, const char *cubemapname, qboolean shadow, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags)
2601 matrix4x4_t tempmatrix = *matrix;
2602 Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
2604 // if this light has been compiled before, free the associated data
2605 R_RTLight_Uncompile(rtlight);
2607 // clear it completely to avoid any lingering data
2608 memset(rtlight, 0, sizeof(*rtlight));
2610 // copy the properties
2611 rtlight->matrix_lighttoworld = tempmatrix;
2612 Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
2613 Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
2614 rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
2615 VectorCopy(color, rtlight->color);
2616 rtlight->cubemapname[0] = 0;
2617 if (cubemapname && cubemapname[0])
2618 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
2619 rtlight->shadow = shadow;
2620 rtlight->corona = corona;
2621 rtlight->style = style;
2622 rtlight->isstatic = isstatic;
2623 rtlight->coronasizescale = coronasizescale;
2624 rtlight->ambientscale = ambientscale;
2625 rtlight->diffusescale = diffusescale;
2626 rtlight->specularscale = specularscale;
2627 rtlight->flags = flags;
2629 // compute derived data
2630 //rtlight->cullradius = rtlight->radius;
2631 //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
2632 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
2633 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
2634 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
2635 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
2636 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
2637 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
2640 // compiles rtlight geometry
2641 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
2642 void R_RTLight_Compile(rtlight_t *rtlight)
2645 int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
2646 int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
2647 entity_render_t *ent = r_refdef.scene.worldentity;
2648 dp_model_t *model = r_refdef.scene.worldmodel;
2649 unsigned char *data;
2652 // compile the light
2653 rtlight->compiled = true;
2654 rtlight->static_numleafs = 0;
2655 rtlight->static_numleafpvsbytes = 0;
2656 rtlight->static_leaflist = NULL;
2657 rtlight->static_leafpvs = NULL;
2658 rtlight->static_numsurfaces = 0;
2659 rtlight->static_surfacelist = NULL;
2660 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
2661 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
2662 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
2663 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
2664 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
2665 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
2667 if (model && model->GetLightInfo)
2669 // this variable must be set for the CompileShadowVolume code
2670 r_shadow_compilingrtlight = rtlight;
2671 R_Shadow_EnlargeLeafSurfaceTrisBuffer(model->brush.num_leafs, model->num_surfaces, model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles, model->surfmesh.num_triangles);
2672 model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces, r_shadow_buffer_shadowtrispvs, r_shadow_buffer_lighttrispvs, r_shadow_buffer_visitingleafpvs);
2673 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
2674 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
2675 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
2676 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
2677 rtlight->static_numsurfaces = numsurfaces;
2678 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
2679 rtlight->static_numleafs = numleafs;
2680 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
2681 rtlight->static_numleafpvsbytes = numleafpvsbytes;
2682 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
2683 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
2684 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
2685 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
2686 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
2687 if (rtlight->static_numsurfaces)
2688 memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
2689 if (rtlight->static_numleafs)
2690 memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
2691 if (rtlight->static_numleafpvsbytes)
2692 memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
2693 if (rtlight->static_numshadowtrispvsbytes)
2694 memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
2695 if (rtlight->static_numlighttrispvsbytes)
2696 memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
2697 if (model->CompileShadowVolume && rtlight->shadow)
2698 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
2699 // now we're done compiling the rtlight
2700 r_shadow_compilingrtlight = NULL;
2704 // use smallest available cullradius - box radius or light radius
2705 //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
2706 //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
2708 shadowzpasstris = 0;
2709 if (rtlight->static_meshchain_shadow_zpass)
2710 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
2711 shadowzpasstris += mesh->numtriangles;
2713 shadowzfailtris = 0;
2714 if (rtlight->static_meshchain_shadow_zfail)
2715 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
2716 shadowzfailtris += mesh->numtriangles;
2719 if (rtlight->static_numlighttrispvsbytes)
2720 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
2721 if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
2725 if (rtlight->static_numlighttrispvsbytes)
2726 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
2727 if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
2730 if (developer.integer >= 10)
2731 Con_Printf("static light built: %f %f %f : %f %f %f box, %i light triangles, %i shadow triangles, %i zpass/%i zfail compiled shadow volume triangles\n", rtlight->cullmins[0], rtlight->cullmins[1], rtlight->cullmins[2], rtlight->cullmaxs[0], rtlight->cullmaxs[1], rtlight->cullmaxs[2], lighttris, shadowtris, shadowzpasstris, shadowzfailtris);
2734 void R_RTLight_Uncompile(rtlight_t *rtlight)
2736 if (rtlight->compiled)
2738 if (rtlight->static_meshchain_shadow_zpass)
2739 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
2740 rtlight->static_meshchain_shadow_zpass = NULL;
2741 if (rtlight->static_meshchain_shadow_zfail)
2742 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
2743 rtlight->static_meshchain_shadow_zfail = NULL;
2744 // these allocations are grouped
2745 if (rtlight->static_surfacelist)
2746 Mem_Free(rtlight->static_surfacelist);
2747 rtlight->static_numleafs = 0;
2748 rtlight->static_numleafpvsbytes = 0;
2749 rtlight->static_leaflist = NULL;
2750 rtlight->static_leafpvs = NULL;
2751 rtlight->static_numsurfaces = 0;
2752 rtlight->static_surfacelist = NULL;
2753 rtlight->static_numshadowtrispvsbytes = 0;
2754 rtlight->static_shadowtrispvs = NULL;
2755 rtlight->static_numlighttrispvsbytes = 0;
2756 rtlight->static_lighttrispvs = NULL;
2757 rtlight->compiled = false;
2761 void R_Shadow_UncompileWorldLights(void)
2765 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2766 for (lightindex = 0;lightindex < range;lightindex++)
2768 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2771 R_RTLight_Uncompile(&light->rtlight);
2775 void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
2779 // reset the count of frustum planes
2780 // see rsurface.rtlight_frustumplanes definition for how much this array
2782 rsurface.rtlight_numfrustumplanes = 0;
2784 // haven't implemented a culling path for ortho rendering
2785 if (!r_refdef.view.useperspective)
2787 // check if the light is on screen and copy the 4 planes if it is
2788 for (i = 0;i < 4;i++)
2789 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
2792 for (i = 0;i < 4;i++)
2793 rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = r_refdef.view.frustum[i];
2798 // generate a deformed frustum that includes the light origin, this is
2799 // used to cull shadow casting surfaces that can not possibly cast a
2800 // shadow onto the visible light-receiving surfaces, which can be a
2803 // if the light origin is onscreen the result will be 4 planes exactly
2804 // if the light origin is offscreen on only one axis the result will
2805 // be exactly 5 planes (split-side case)
2806 // if the light origin is offscreen on two axes the result will be
2807 // exactly 4 planes (stretched corner case)
2808 for (i = 0;i < 4;i++)
2810 // quickly reject standard frustum planes that put the light
2811 // origin outside the frustum
2812 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
2815 rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = r_refdef.view.frustum[i];
2817 // if all the standard frustum planes were accepted, the light is onscreen
2818 // otherwise we need to generate some more planes below...
2819 if (rsurface.rtlight_numfrustumplanes < 4)
2821 // at least one of the stock frustum planes failed, so we need to
2822 // create one or two custom planes to enclose the light origin
2823 for (i = 0;i < 4;i++)
2825 // create a plane using the view origin and light origin, and a
2826 // single point from the frustum corner set
2827 TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
2828 VectorNormalize(plane.normal);
2829 plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
2830 // see if this plane is backwards and flip it if so
2831 for (j = 0;j < 4;j++)
2832 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
2836 VectorNegate(plane.normal, plane.normal);
2838 // flipped plane, test again to see if it is now valid
2839 for (j = 0;j < 4;j++)
2840 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
2842 // if the plane is still not valid, then it is dividing the
2843 // frustum and has to be rejected
2847 // we have created a valid plane, compute extra info
2848 PlaneClassify(&plane);
2850 rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane;
2852 // if we've found 5 frustum planes then we have constructed a
2853 // proper split-side case and do not need to keep searching for
2854 // planes to enclose the light origin
2855 if (rsurface.rtlight_numfrustumplanes == 5)
2863 for (i = 0;i < rsurface.rtlight_numfrustumplanes;i++)
2865 plane = rsurface.rtlight_frustumplanes[i];
2866 Con_Printf("light %p plane #%i %f %f %f : %f (%f %f %f %f %f)\n", rtlight, i, plane.normal[0], plane.normal[1], plane.normal[2], plane.dist, PlaneDiff(r_refdef.view.frustumcorner[0], &plane), PlaneDiff(r_refdef.view.frustumcorner[1], &plane), PlaneDiff(r_refdef.view.frustumcorner[2], &plane), PlaneDiff(r_refdef.view.frustumcorner[3], &plane), PlaneDiff(rtlight->shadoworigin, &plane));
2871 // now add the light-space box planes if the light box is rotated, as any
2872 // caster outside the oriented light box is irrelevant (even if it passed
2873 // the worldspace light box, which is axial)
2874 if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
2876 for (i = 0;i < 6;i++)
2880 v[i >> 1] = (i & 1) ? -1 : 1;
2881 Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
2882 VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
2883 plane.dist = VectorNormalizeLength(plane.normal);
2884 plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
2885 rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane;
2891 // add the world-space reduced box planes
2892 for (i = 0;i < 6;i++)
2894 VectorClear(plane.normal);
2895 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
2896 plane.dist = (i & 1) ? -rsurface.rtlight_cullmaxs[i >> 1] : rsurface.rtlight_cullmins[i >> 1];
2897 rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane;
2906 // reduce all plane distances to tightly fit the rtlight cull box, which
2908 VectorSet(points[0], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmins[2]);
2909 VectorSet(points[1], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmins[2]);
2910 VectorSet(points[2], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmins[2]);
2911 VectorSet(points[3], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmins[2]);
2912 VectorSet(points[4], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmaxs[2]);
2913 VectorSet(points[5], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmaxs[2]);
2914 VectorSet(points[6], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmaxs[2]);
2915 VectorSet(points[7], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmaxs[2]);
2916 oldnum = rsurface.rtlight_numfrustumplanes;
2917 rsurface.rtlight_numfrustumplanes = 0;
2918 for (j = 0;j < oldnum;j++)
2920 // find the nearest point on the box to this plane
2921 bestdist = DotProduct(rsurface.rtlight_frustumplanes[j].normal, points[0]);
2922 for (i = 1;i < 8;i++)
2924 dist = DotProduct(rsurface.rtlight_frustumplanes[j].normal, points[i]);
2925 if (bestdist > dist)
2928 Con_Printf("light %p %splane #%i %f %f %f : %f < %f\n", rtlight, rsurface.rtlight_frustumplanes[j].dist < bestdist + 0.03125 ? "^2" : "^1", j, rsurface.rtlight_frustumplanes[j].normal[0], rsurface.rtlight_frustumplanes[j].normal[1], rsurface.rtlight_frustumplanes[j].normal[2], rsurface.rtlight_frustumplanes[j].dist, bestdist);
2929 // if the nearest point is near or behind the plane, we want this
2930 // plane, otherwise the plane is useless as it won't cull anything
2931 if (rsurface.rtlight_frustumplanes[j].dist < bestdist + 0.03125)
2933 PlaneClassify(&rsurface.rtlight_frustumplanes[j]);
2934 rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = rsurface.rtlight_frustumplanes[j];
2941 void R_Shadow_DrawWorldShadow(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
2946 int surfacelistindex;
2947 msurface_t *surface;
2949 RSurf_ActiveWorldEntity();
2950 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
2953 zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
2954 R_Shadow_RenderMode_StencilShadowVolumes(zpass);
2955 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
2956 for (;mesh;mesh = mesh->next)
2958 r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
2959 R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
2960 GL_LockArrays(0, mesh->numverts);
2961 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
2963 // increment stencil if frontface is infront of depthbuffer
2964 GL_CullFace(r_refdef.view.cullface_back);
2965 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
2966 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
2967 // decrement stencil if backface is infront of depthbuffer
2968 GL_CullFace(r_refdef.view.cullface_front);
2969 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
2971 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
2973 // decrement stencil if backface is behind depthbuffer
2974 GL_CullFace(r_refdef.view.cullface_front);
2975 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
2976 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
2977 // increment stencil if frontface is behind depthbuffer
2978 GL_CullFace(r_refdef.view.cullface_back);
2979 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
2981 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
2982 GL_LockArrays(0, 0);
2986 else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh && r_shadow_culltriangles.integer)
2988 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
2989 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
2991 surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
2992 for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
2993 if (CHECKPVSBIT(trispvs, t))
2994 shadowmarklist[numshadowmark++] = t;
2996 R_Shadow_VolumeFromList(r_refdef.scene.worldmodel->brush.shadowmesh->numverts, r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles, r_refdef.scene.worldmodel->brush.shadowmesh->vertex3f, r_refdef.scene.worldmodel->brush.shadowmesh->element3i, r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius + r_refdef.scene.worldmodel->radius*2 + r_shadow_projectdistance.value, numshadowmark, shadowmarklist, r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
2998 else if (numsurfaces)
2999 r_refdef.scene.worldmodel->DrawShadowVolume(r_refdef.scene.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs);
3001 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3004 void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3006 vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3007 vec_t relativeshadowradius;
3008 RSurf_ActiveModelEntity(ent, false, false);
3009 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3010 relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3011 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3012 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3013 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3014 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3015 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3016 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3017 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3018 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3021 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3023 // set up properties for rendering light onto this entity
3024 RSurf_ActiveModelEntity(ent, true, true);
3025 GL_AlphaTest(false);
3026 Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3027 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3028 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3029 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3030 if (r_shadow_lightingrendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
3031 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3034 void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3036 if (!r_refdef.scene.worldmodel->DrawLight)
3039 // set up properties for rendering light onto this entity
3040 RSurf_ActiveWorldEntity();
3041 GL_AlphaTest(false);
3042 rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3043 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3044 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3045 VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3046 if (r_shadow_lightingrendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
3047 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3049 r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, trispvs);
3051 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3054 void R_Shadow_DrawEntityLight(entity_render_t *ent)
3056 dp_model_t *model = ent->model;
3057 if (!model->DrawLight)
3060 R_Shadow_SetupEntityLight(ent);
3062 model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3064 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3067 void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
3071 int numleafs, numsurfaces;
3072 int *leaflist, *surfacelist;
3073 unsigned char *leafpvs, *shadowtrispvs, *lighttrispvs;
3074 int numlightentities;
3075 int numlightentities_noselfshadow;
3076 int numshadowentities;
3077 int numshadowentities_noselfshadow;
3078 static entity_render_t *lightentities[MAX_EDICTS];
3079 static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3080 static entity_render_t *shadowentities[MAX_EDICTS];
3081 static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3083 // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3084 // skip lights that are basically invisible (color 0 0 0)
3085 if (VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f))
3088 // loading is done before visibility checks because loading should happen
3089 // all at once at the start of a level, not when it stalls gameplay.
3090 // (especially important to benchmarks)
3092 if (rtlight->isstatic && !rtlight->compiled && r_shadow_realtime_world_compile.integer)
3093 R_RTLight_Compile(rtlight);
3095 rtlight->currentcubemap = rtlight->cubemapname[0] ? R_Shadow_Cubemap(rtlight->cubemapname) : r_texture_whitecube;
3097 // look up the light style value at this time
3098 f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3099 VectorScale(rtlight->color, f, rtlight->currentcolor);
3101 if (rtlight->selected)
3103 f = 2 + sin(realtime * M_PI * 4.0);
3104 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3108 // if lightstyle is currently off, don't draw the light
3109 if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3112 // if the light box is offscreen, skip it
3113 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3116 VectorCopy(rtlight->cullmins, rsurface.rtlight_cullmins);
3117 VectorCopy(rtlight->cullmaxs, rsurface.rtlight_cullmaxs);
3119 if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3121 // compiled light, world available and can receive realtime lighting
3122 // retrieve leaf information
3123 numleafs = rtlight->static_numleafs;
3124 leaflist = rtlight->static_leaflist;
3125 leafpvs = rtlight->static_leafpvs;
3126 numsurfaces = rtlight->static_numsurfaces;
3127 surfacelist = rtlight->static_surfacelist;
3128 shadowtrispvs = rtlight->static_shadowtrispvs;
3129 lighttrispvs = rtlight->static_lighttrispvs;
3131 else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
3133 // dynamic light, world available and can receive realtime lighting
3134 // calculate lit surfaces and leafs
3135 R_Shadow_EnlargeLeafSurfaceTrisBuffer(r_refdef.scene.worldmodel->brush.num_leafs, r_refdef.scene.worldmodel->num_surfaces, r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles, r_refdef.scene.worldmodel->surfmesh.num_triangles);
3136 r_refdef.scene.worldmodel->GetLightInfo(r_refdef.scene.worldentity, rtlight->shadoworigin, rtlight->radius, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces, r_shadow_buffer_shadowtrispvs, r_shadow_buffer_lighttrispvs, r_shadow_buffer_visitingleafpvs);
3137 leaflist = r_shadow_buffer_leaflist;
3138 leafpvs = r_shadow_buffer_leafpvs;
3139 surfacelist = r_shadow_buffer_surfacelist;
3140 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
3141 lighttrispvs = r_shadow_buffer_lighttrispvs;
3142 // if the reduced leaf bounds are offscreen, skip it
3143 if (R_CullBox(rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs))
3154 shadowtrispvs = NULL;
3155 lighttrispvs = NULL;
3157 // check if light is illuminating any visible leafs
3160 for (i = 0;i < numleafs;i++)
3161 if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
3166 // set up a scissor rectangle for this light
3167 if (R_Shadow_ScissorForBBox(rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs))
3170 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3172 // make a list of lit entities and shadow casting entities
3173 numlightentities = 0;
3174 numlightentities_noselfshadow = 0;
3175 numshadowentities = 0;
3176 numshadowentities_noselfshadow = 0;
3177 // add dynamic entities that are lit by the light
3178 if (r_drawentities.integer)
3180 for (i = 0;i < r_refdef.scene.numentities;i++)
3183 entity_render_t *ent = r_refdef.scene.entities[i];
3185 if (!BoxesOverlap(ent->mins, ent->maxs, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs))
3187 // skip the object entirely if it is not within the valid
3188 // shadow-casting region (which includes the lit region)
3189 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rsurface.rtlight_numfrustumplanes, rsurface.rtlight_frustumplanes))
3191 if (!(model = ent->model))
3193 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
3195 // this entity wants to receive light, is visible, and is
3196 // inside the light box
3197 // TODO: check if the surfaces in the model can receive light
3198 // so now check if it's in a leaf seen by the light
3199 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingLeafPVS && !r_refdef.scene.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.scene.worldmodel, leafpvs, ent->mins, ent->maxs))
3201 if (ent->flags & RENDER_NOSELFSHADOW)
3202 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
3204 lightentities[numlightentities++] = ent;
3205 // since it is lit, it probably also casts a shadow...
3206 // about the VectorDistance2 - light emitting entities should not cast their own shadow
3207 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3208 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3210 // note: exterior models without the RENDER_NOSELFSHADOW
3211 // flag still create a RENDER_NOSELFSHADOW shadow but
3212 // are lit normally, this means that they are
3213 // self-shadowing but do not shadow other
3214 // RENDER_NOSELFSHADOW entities such as the gun
3215 // (very weird, but keeps the player shadow off the gun)
3216 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3217 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3219 shadowentities[numshadowentities++] = ent;
3222 else if (ent->flags & RENDER_SHADOW)
3224 // this entity is not receiving light, but may still need to
3226 // TODO: check if the surfaces in the model can cast shadow
3227 // now check if it is in a leaf seen by the light
3228 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingLeafPVS && !r_refdef.scene.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.scene.worldmodel, leafpvs, ent->mins, ent->maxs))
3230 // about the VectorDistance2 - light emitting entities should not cast their own shadow
3231 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3232 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3234 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3235 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3237 shadowentities[numshadowentities++] = ent;
3243 // return if there's nothing at all to light
3244 if (!numlightentities && !numsurfaces)
3247 // don't let sound skip if going slow
3248 if (r_refdef.scene.extraupdate)
3251 // make this the active rtlight for rendering purposes
3252 R_Shadow_RenderMode_ActiveLight(rtlight);
3253 // count this light in the r_speeds
3254 r_refdef.stats.lights++;
3256 if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
3258 // optionally draw visible shape of the shadow volumes
3259 // for performance analysis by level designers
3260 R_Shadow_RenderMode_VisibleShadowVolumes();
3262 R_Shadow_DrawWorldShadow(numsurfaces, surfacelist, shadowtrispvs);
3263 for (i = 0;i < numshadowentities;i++)
3264 R_Shadow_DrawEntityShadow(shadowentities[i]);
3265 for (i = 0;i < numshadowentities_noselfshadow;i++)
3266 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3269 if (gl_stencil && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
3271 // draw stencil shadow volumes to mask off pixels that are in shadow
3272 // so that they won't receive lighting
3273 R_Shadow_ClearStencil();
3275 R_Shadow_DrawWorldShadow(numsurfaces, surfacelist, shadowtrispvs);
3276 for (i = 0;i < numshadowentities;i++)
3277 R_Shadow_DrawEntityShadow(shadowentities[i]);
3278 if (numlightentities_noselfshadow)
3280 // draw lighting in the unmasked areas
3281 R_Shadow_RenderMode_Lighting(true, false);
3282 for (i = 0;i < numlightentities_noselfshadow;i++)
3283 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3285 // optionally draw the illuminated areas
3286 // for performance analysis by level designers
3287 if (r_showlighting.integer && r_refdef.view.showdebug)
3289 R_Shadow_RenderMode_VisibleLighting(!r_showdisabledepthtest.integer, false);
3290 for (i = 0;i < numlightentities_noselfshadow;i++)
3291 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3294 for (i = 0;i < numshadowentities_noselfshadow;i++)
3295 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3297 if (numsurfaces + numlightentities)
3299 // draw lighting in the unmasked areas
3300 R_Shadow_RenderMode_Lighting(true, false);
3302 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3303 for (i = 0;i < numlightentities;i++)
3304 R_Shadow_DrawEntityLight(lightentities[i]);
3306 // optionally draw the illuminated areas
3307 // for performance analysis by level designers
3308 if (r_showlighting.integer && r_refdef.view.showdebug)
3310 R_Shadow_RenderMode_VisibleLighting(!r_showdisabledepthtest.integer, false);
3312 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3313 for (i = 0;i < numlightentities;i++)
3314 R_Shadow_DrawEntityLight(lightentities[i]);
3320 if (numsurfaces + numlightentities)
3322 // draw lighting in the unmasked areas
3323 R_Shadow_RenderMode_Lighting(false, false);
3325 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3326 for (i = 0;i < numlightentities;i++)
3327 R_Shadow_DrawEntityLight(lightentities[i]);
3328 for (i = 0;i < numlightentities_noselfshadow;i++)
3329 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3331 // optionally draw the illuminated areas
3332 // for performance analysis by level designers
3333 if (r_showlighting.integer && r_refdef.view.showdebug)
3335 R_Shadow_RenderMode_VisibleLighting(false, false);
3337 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3338 for (i = 0;i < numlightentities;i++)
3339 R_Shadow_DrawEntityLight(lightentities[i]);
3340 for (i = 0;i < numlightentities_noselfshadow;i++)
3341 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3347 void R_Shadow_DrawLightSprites(void);
3348 void R_ShadowVolumeLighting(qboolean visible)
3356 if (r_editlights.integer)
3357 R_Shadow_DrawLightSprites();
3359 R_Shadow_RenderMode_Begin();
3361 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
3362 if (r_shadow_debuglight.integer >= 0)
3364 lightindex = r_shadow_debuglight.integer;
3365 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3366 if (light && (light->flags & flag))
3367 R_DrawRTLight(&light->rtlight, visible);
3371 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3372 for (lightindex = 0;lightindex < range;lightindex++)
3374 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3375 if (light && (light->flags & flag))
3376 R_DrawRTLight(&light->rtlight, visible);
3379 if (r_refdef.scene.rtdlight)
3380 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
3381 R_DrawRTLight(r_refdef.scene.lights[lnum], visible);
3383 R_Shadow_RenderMode_End();
3386 extern void R_SetupView(qboolean allowwaterclippingplane);
3387 extern cvar_t r_shadows;
3388 extern cvar_t r_shadows_throwdistance;
3389 void R_DrawModelShadows(void)
3392 float relativethrowdistance;
3393 entity_render_t *ent;
3394 vec3_t relativelightorigin;
3395 vec3_t relativelightdirection;
3396 vec3_t relativeshadowmins, relativeshadowmaxs;
3400 if (!r_drawentities.integer || !gl_stencil)
3404 GL_Scissor(r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
3406 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
3408 if (gl_ext_separatestencil.integer)
3410 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
3411 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
3413 else if (gl_ext_stenciltwoside.integer)
3415 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
3416 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
3420 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
3421 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
3424 R_Shadow_ClearStencil();
3426 for (i = 0;i < r_refdef.scene.numentities;i++)
3428 ent = r_refdef.scene.entities[i];
3429 // cast shadows from anything that is not a submodel of the map
3430 if (ent->model && ent->model->DrawShadowVolume != NULL && !ent->model->brush.submodel && (ent->flags & RENDER_SHADOW))
3432 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
3433 VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
3434 VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
3436 if(r_shadows.integer == 2)
3438 // 2: simpler mode, throw shadows always DOWN
3439 VectorSet(tmp, 0, 0, -1);
3440 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
3444 if(ent->entitynumber != 0)
3446 // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
3447 int entnum, entnum2, recursion;
3448 entnum = entnum2 = ent->entitynumber;
3449 for(recursion = 32; recursion > 0; --recursion)
3451 entnum2 = cl.entities[entnum].state_current.tagentity;
3452 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
3457 if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
3459 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
3460 // transform into modelspace of OUR entity
3461 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
3462 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
3465 VectorNegate(ent->modellight_lightdir, relativelightdirection);
3468 VectorNegate(ent->modellight_lightdir, relativelightdirection);
3471 VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
3472 RSurf_ActiveModelEntity(ent, false, false);
3473 ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3474 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3478 // not really the right mode, but this will disable any silly stencil features
3479 R_Shadow_RenderMode_VisibleLighting(true, true);
3481 // vertex coordinates for a quad that covers the screen exactly
3482 vertex3f[0] = 0;vertex3f[1] = 0;vertex3f[2] = 0;
3483 vertex3f[3] = 1;vertex3f[4] = 0;vertex3f[5] = 0;
3484 vertex3f[6] = 1;vertex3f[7] = 1;vertex3f[8] = 0;
3485 vertex3f[9] = 0;vertex3f[10] = 1;vertex3f[11] = 0;
3487 // set up ortho view for rendering this pass
3488 GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
3489 GL_Scissor(r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
3490 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
3491 GL_ScissorTest(true);
3492 R_Mesh_Matrix(&identitymatrix);
3493 R_Mesh_ResetTextureState();
3494 R_Mesh_VertexPointer(vertex3f, 0, 0);
3495 R_Mesh_ColorPointer(NULL, 0, 0);
3497 // set up a 50% darkening blend on shadowed areas
3498 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3499 GL_DepthRange(0, 1);
3500 GL_DepthTest(false);
3501 GL_DepthMask(false);
3502 GL_PolygonOffset(0, 0);CHECKGLERROR
3503 GL_Color(0, 0, 0, 0.5);
3504 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
3505 qglDepthFunc(GL_ALWAYS);CHECKGLERROR
3506 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
3507 qglStencilMask(~0);CHECKGLERROR
3508 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
3509 qglStencilFunc(GL_NOTEQUAL, 128, ~0);CHECKGLERROR
3511 // apply the blend to the shadowed areas
3512 R_Mesh_Draw(0, 4, 0, 2, NULL, polygonelements, 0, 0);
3514 // restoring the perspective view is done by R_RenderScene
3515 //R_SetupView(true);
3517 // restore other state to normal
3518 R_Shadow_RenderMode_End();
3521 void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
3524 vec3_t centerorigin;
3525 // if it's too close, skip it
3526 if (VectorLength(rtlight->color) < (1.0f / 256.0f))
3528 zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
3531 if (usequery && r_numqueries + 2 <= r_maxqueries)
3533 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
3534 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
3535 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
3538 // NOTE: we can't disable depth testing using R_DrawSprite's depthdisable argument, which calls GL_DepthTest, as that's broken in the ATI drivers
3539 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
3540 qglDepthFunc(GL_ALWAYS);
3541 R_DrawSprite(GL_ONE, GL_ZERO, r_shadow_lightcorona, NULL, false, false, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale, 1, 1, 1, 1);
3542 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
3543 qglDepthFunc(GL_LEQUAL);
3544 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
3545 R_DrawSprite(GL_ONE, GL_ZERO, r_shadow_lightcorona, NULL, false, false, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale, 1, 1, 1, 1);
3546 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
3549 rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
3552 void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
3555 GLint allpixels = 0, visiblepixels = 0;
3556 // now we have to check the query result
3557 if (rtlight->corona_queryindex_visiblepixels)
3560 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
3561 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
3563 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
3564 if (visiblepixels < 1 || allpixels < 1)
3566 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
3567 cscale *= rtlight->corona_visibility;
3571 // FIXME: these traces should scan all render entities instead of cl.world
3572 if (CL_Move(r_refdef.view.origin, vec3_origin, vec3_origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1)
3575 VectorScale(rtlight->color, cscale, color);
3576 if (VectorLength(color) > (1.0f / 256.0f))
3577 R_DrawSprite(GL_ONE, GL_ONE, r_shadow_lightcorona, NULL, true, false, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale, color[0], color[1], color[2], 1);
3580 void R_DrawCoronas(void)
3588 if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
3590 if (r_waterstate.renderingscene)
3592 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
3593 R_Mesh_Matrix(&identitymatrix);
3595 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3597 // check occlusion of coronas
3598 // use GL_ARB_occlusion_query if available
3599 // otherwise use raytraces
3601 usequery = gl_support_arb_occlusion_query && r_coronas_occlusionquery.integer;
3604 GL_ColorMask(0,0,0,0);
3605 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
3606 if (r_maxqueries < R_MAX_OCCLUSION_QUERIES)
3609 r_maxqueries = (range + r_refdef.scene.numlights) * 4;
3610 r_maxqueries = min(r_maxqueries, R_MAX_OCCLUSION_QUERIES);
3612 qglGenQueriesARB(r_maxqueries - i, r_queries + i);
3616 for (lightindex = 0;lightindex < range;lightindex++)
3618 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3621 rtlight = &light->rtlight;
3622 rtlight->corona_visibility = 0;
3623 rtlight->corona_queryindex_visiblepixels = 0;
3624 rtlight->corona_queryindex_allpixels = 0;
3625 if (!(rtlight->flags & flag))
3627 if (rtlight->corona <= 0)
3629 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
3631 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
3633 for (i = 0;i < r_refdef.scene.numlights;i++)
3635 rtlight = r_refdef.scene.lights[i];
3636 rtlight->corona_visibility = 0;
3637 rtlight->corona_queryindex_visiblepixels = 0;
3638 rtlight->corona_queryindex_allpixels = 0;
3639 if (!(rtlight->flags & flag))
3641 if (rtlight->corona <= 0)
3643 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
3646 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
3648 // now draw the coronas using the query data for intensity info
3649 for (lightindex = 0;lightindex < range;lightindex++)
3651 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3654 rtlight = &light->rtlight;
3655 if (rtlight->corona_visibility <= 0)
3657 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
3659 for (i = 0;i < r_refdef.scene.numlights;i++)
3661 rtlight = r_refdef.scene.lights[i];
3662 if (rtlight->corona_visibility <= 0)
3664 if (gl_flashblend.integer)
3665 R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
3667 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
3673 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
3674 typedef struct suffixinfo_s
3677 qboolean flipx, flipy, flipdiagonal;
3680 static suffixinfo_t suffix[3][6] =
3683 {"px", false, false, false},
3684 {"nx", false, false, false},
3685 {"py", false, false, false},
3686 {"ny", false, false, false},
3687 {"pz", false, false, false},
3688 {"nz", false, false, false}
3691 {"posx", false, false, false},
3692 {"negx", false, false, false},
3693 {"posy", false, false, false},
3694 {"negy", false, false, false},
3695 {"posz", false, false, false},
3696 {"negz", false, false, false}
3699 {"rt", true, false, true},
3700 {"lf", false, true, true},
3701 {"ft", true, true, false},
3702 {"bk", false, false, false},
3703 {"up", true, false, true},
3704 {"dn", true, false, true}
3708 static int componentorder[4] = {0, 1, 2, 3};
3710 rtexture_t *R_Shadow_LoadCubemap(const char *basename)
3712 int i, j, cubemapsize;
3713 unsigned char *cubemappixels, *image_buffer;
3714 rtexture_t *cubemaptexture;
3716 // must start 0 so the first loadimagepixels has no requested width/height
3718 cubemappixels = NULL;
3719 cubemaptexture = NULL;
3720 // keep trying different suffix groups (posx, px, rt) until one loads
3721 for (j = 0;j < 3 && !cubemappixels;j++)
3723 // load the 6 images in the suffix group
3724 for (i = 0;i < 6;i++)
3726 // generate an image name based on the base and and suffix
3727 dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
3729 if ((image_buffer = loadimagepixelsbgra(name, false, false)))
3731 // an image loaded, make sure width and height are equal
3732 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
3734 // if this is the first image to load successfully, allocate the cubemap memory
3735 if (!cubemappixels && image_width >= 1)
3737 cubemapsize = image_width;
3738 // note this clears to black, so unavailable sides are black
3739 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
3741 // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
3743 Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_buffer, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder);
3746 Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
3748 Mem_Free(image_buffer);
3752 // if a cubemap loaded, upload it
3755 if (developer_loading.integer)
3756 Con_Printf("loading cubemap \"%s\"\n", basename);
3758 if (!r_shadow_filters_texturepool)
3759 r_shadow_filters_texturepool = R_AllocTexturePool();
3760 cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, TEXF_PRECACHE | (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR, NULL);
3761 Mem_Free(cubemappixels);
3765 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
3766 if (developer_loading.integer)
3768 Con_Printf("(tried tried images ");
3769 for (j = 0;j < 3;j++)
3770 for (i = 0;i < 6;i++)
3771 Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
3772 Con_Print(" and was unable to find any of them).\n");
3775 return cubemaptexture;
3778 rtexture_t *R_Shadow_Cubemap(const char *basename)
3781 for (i = 0;i < numcubemaps;i++)
3782 if (!strcasecmp(cubemaps[i].basename, basename))
3783 return cubemaps[i].texture ? cubemaps[i].texture : r_texture_whitecube;
3784 if (i >= MAX_CUBEMAPS)
3785 return r_texture_whitecube;
3787 strlcpy(cubemaps[i].basename, basename, sizeof(cubemaps[i].basename));
3788 cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename);
3789 return cubemaps[i].texture;
3792 void R_Shadow_FreeCubemaps(void)
3795 for (i = 0;i < numcubemaps;i++)
3797 if (developer_loading.integer)
3798 Con_Printf("unloading cubemap \"%s\"\n", cubemaps[i].basename);
3799 if (cubemaps[i].texture)
3800 R_FreeTexture(cubemaps[i].texture);
3804 R_FreeTexturePool(&r_shadow_filters_texturepool);
3807 dlight_t *R_Shadow_NewWorldLight(void)
3809 return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
3812 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)
3815 // validate parameters
3816 if (style < 0 || style >= MAX_LIGHTSTYLES)
3818 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
3824 // copy to light properties
3825 VectorCopy(origin, light->origin);
3826 light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
3827 light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
3828 light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
3829 light->color[0] = max(color[0], 0);
3830 light->color[1] = max(color[1], 0);
3831 light->color[2] = max(color[2], 0);
3832 light->radius = max(radius, 0);
3833 light->style = style;
3834 light->shadow = shadowenable;
3835 light->corona = corona;
3836 strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
3837 light->coronasizescale = coronasizescale;
3838 light->ambientscale = ambientscale;
3839 light->diffusescale = diffusescale;
3840 light->specularscale = specularscale;
3841 light->flags = flags;
3843 // update renderable light data
3844 Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
3845 R_RTLight_Update(&light->rtlight, true, &matrix, light->color, light->style, light->cubemapname[0] ? light->cubemapname : NULL, light->shadow, light->corona, light->coronasizescale, light->ambientscale, light->diffusescale, light->specularscale, light->flags);
3848 void R_Shadow_FreeWorldLight(dlight_t *light)
3850 if (r_shadow_selectedlight == light)
3851 r_shadow_selectedlight = NULL;
3852 R_RTLight_Uncompile(&light->rtlight);
3853 Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
3856 void R_Shadow_ClearWorldLights(void)
3860 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3861 for (lightindex = 0;lightindex < range;lightindex++)
3863 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3865 R_Shadow_FreeWorldLight(light);
3867 r_shadow_selectedlight = NULL;
3868 R_Shadow_FreeCubemaps();
3871 void R_Shadow_SelectLight(dlight_t *light)
3873 if (r_shadow_selectedlight)
3874 r_shadow_selectedlight->selected = false;
3875 r_shadow_selectedlight = light;
3876 if (r_shadow_selectedlight)
3877 r_shadow_selectedlight->selected = true;
3880 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3882 // this is never batched (there can be only one)
3883 R_DrawSprite(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, r_editlights_sprcursor->tex, r_editlights_sprcursor->tex, false, false, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE, 1, 1, 1, 1);
3886 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3893 // this is never batched (due to the ent parameter changing every time)
3894 // so numsurfaces == 1 and surfacelist[0] == lightnumber
3895 const dlight_t *light = (dlight_t *)ent;
3898 VectorScale(light->color, intensity, spritecolor);
3899 if (VectorLength(spritecolor) < 0.1732f)
3900 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
3901 if (VectorLength(spritecolor) > 1.0f)
3902 VectorNormalize(spritecolor);
3904 // draw light sprite
3905 if (light->cubemapname[0] && !light->shadow)
3906 pic = r_editlights_sprcubemapnoshadowlight;
3907 else if (light->cubemapname[0])
3908 pic = r_editlights_sprcubemaplight;
3909 else if (!light->shadow)
3910 pic = r_editlights_sprnoshadowlight;
3912 pic = r_editlights_sprlight;
3913 R_DrawSprite(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, pic->tex, pic->tex, false, false, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s, spritecolor[0], spritecolor[1], spritecolor[2], 1);
3914 // draw selection sprite if light is selected
3915 if (light->selected)
3916 R_DrawSprite(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, r_editlights_sprselection->tex, r_editlights_sprselection->tex, false, false, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s, 1, 1, 1, 1);
3917 // VorteX todo: add normalmode/realtime mode light overlay sprites?
3920 void R_Shadow_DrawLightSprites(void)
3924 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3925 for (lightindex = 0;lightindex < range;lightindex++)
3927 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3929 R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
3931 R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
3934 void R_Shadow_SelectLightInView(void)
3936 float bestrating, rating, temp[3];
3940 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3943 for (lightindex = 0;lightindex < range;lightindex++)
3945 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3948 VectorSubtract(light->origin, r_refdef.view.origin, temp);
3949 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
3952 rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
3953 if (bestrating < rating && CL_Move(light->origin, vec3_origin, vec3_origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1.0f)
3955 bestrating = rating;
3960 R_Shadow_SelectLight(best);
3963 void R_Shadow_LoadWorldLights(void)
3965 int n, a, style, shadow, flags;
3966 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
3967 float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
3968 if (cl.worldmodel == NULL)
3970 Con_Print("No map loaded.\n");
3973 FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
3974 strlcat (name, ".rtlights", sizeof (name));
3975 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
3985 for (;COM_Parse(t, true) && strcmp(
3986 if (COM_Parse(t, true))
3988 if (com_token[0] == '!')
3991 origin[0] = atof(com_token+1);
3994 origin[0] = atof(com_token);
3999 while (*s && *s != '\n' && *s != '\r')
4005 // check for modifier flags
4012 #if _MSC_VER >= 1400
4013 #define sscanf sscanf_s
4015 cubemapname[sizeof(cubemapname)-1] = 0;
4016 #if MAX_QPATH != 128
4017 #error update this code if MAX_QPATH changes
4019 a = sscanf(t, "%f %f %f %f %f %f %f %d %127s %f %f %f %f %f %f %f %f %i", &origin[0], &origin[1], &origin[2], &radius, &color[0], &color[1], &color[2], &style, cubemapname
4020 #if _MSC_VER >= 1400
4021 , sizeof(cubemapname)
4023 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
4026 flags = LIGHTFLAG_REALTIMEMODE;
4034 coronasizescale = 0.25f;
4036 VectorClear(angles);
4039 if (a < 9 || !strcmp(cubemapname, "\"\""))
4041 // remove quotes on cubemapname
4042 if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
4045 namelen = strlen(cubemapname) - 2;
4046 memmove(cubemapname, cubemapname + 1, namelen);
4047 cubemapname[namelen] = '\0';
4051 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);
4054 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
4062 Con_Printf("invalid rtlights file \"%s\"\n", name);
4063 Mem_Free(lightsstring);
4067 void R_Shadow_SaveWorldLights(void)
4071 size_t bufchars, bufmaxchars;
4073 char name[MAX_QPATH];
4074 char line[MAX_INPUTLINE];
4075 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
4076 // I hate lines which are 3 times my screen size :( --blub
4079 if (cl.worldmodel == NULL)
4081 Con_Print("No map loaded.\n");
4084 FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
4085 strlcat (name, ".rtlights", sizeof (name));
4086 bufchars = bufmaxchars = 0;
4088 for (lightindex = 0;lightindex < range;lightindex++)
4090 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4093 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
4094 dpsnprintf(line, sizeof(line), "%s%f %f %f %f %f %f %f %d \"%s\" %f %f %f %f %f %f %f %f %i\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius, light->color[0], light->color[1], light->color[2], light->style, light->cubemapname, light->corona, light->angles[0], light->angles[1], light->angles[2], light->coronasizescale, light->ambientscale, light->diffusescale, light->specularscale, light->flags);
4095 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
4096 dpsnprintf(line, sizeof(line), "%s%f %f %f %f %f %f %f %d \"%s\" %f %f %f %f\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius, light->color[0], light->color[1], light->color[2], light->style, light->cubemapname, light->corona, light->angles[0], light->angles[1], light->angles[2]);
4098 dpsnprintf(line, sizeof(line), "%s%f %f %f %f %f %f %f %d\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius, light->color[0], light->color[1], light->color[2], light->style);
4099 if (bufchars + strlen(line) > bufmaxchars)
4101 bufmaxchars = bufchars + strlen(line) + 2048;
4103 buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
4107 memcpy(buf, oldbuf, bufchars);
4113 memcpy(buf + bufchars, line, strlen(line));
4114 bufchars += strlen(line);
4118 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
4123 void R_Shadow_LoadLightsFile(void)
4126 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
4127 float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
4128 if (cl.worldmodel == NULL)
4130 Con_Print("No map loaded.\n");
4133 FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
4134 strlcat (name, ".lights", sizeof (name));
4135 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
4143 while (*s && *s != '\n' && *s != '\r')
4149 a = sscanf(t, "%f %f %f %f %f %f %f %f %f %f %f %f %f %d", &origin[0], &origin[1], &origin[2], &falloff, &color[0], &color[1], &color[2], &subtract, &spotdir[0], &spotdir[1], &spotdir[2], &spotcone, &distbias, &style);
4153 Con_Printf("invalid lights file, found %d parameters on line %i, should be 14 parameters (origin[0] origin[1] origin[2] falloff light[0] light[1] light[2] subtract spotdir[0] spotdir[1] spotdir[2] spotcone distancebias style)\n", a, n + 1);
4156 radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
4157 radius = bound(15, radius, 4096);
4158 VectorScale(color, (2.0f / (8388608.0f)), color);
4159 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
4167 Con_Printf("invalid lights file \"%s\"\n", name);
4168 Mem_Free(lightsstring);
4172 // tyrlite/hmap2 light types in the delay field
4173 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
4175 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
4177 int entnum, style, islight, skin, pflags, effects, type, n;
4180 float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
4181 char key[256], value[MAX_INPUTLINE];
4183 if (cl.worldmodel == NULL)
4185 Con_Print("No map loaded.\n");
4188 // try to load a .ent file first
4189 FS_StripExtension (cl.worldmodel->name, key, sizeof (key));
4190 strlcat (key, ".ent", sizeof (key));
4191 data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
4192 // and if that is not found, fall back to the bsp file entity string
4194 data = cl.worldmodel->brush.entities;
4197 for (entnum = 0;COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{';entnum++)
4199 type = LIGHTTYPE_MINUSX;
4200 origin[0] = origin[1] = origin[2] = 0;
4201 originhack[0] = originhack[1] = originhack[2] = 0;
4202 angles[0] = angles[1] = angles[2] = 0;
4203 color[0] = color[1] = color[2] = 1;
4204 light[0] = light[1] = light[2] = 1;light[3] = 300;
4205 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
4215 if (!COM_ParseToken_Simple(&data, false, false))
4217 if (com_token[0] == '}')
4218 break; // end of entity
4219 if (com_token[0] == '_')
4220 strlcpy(key, com_token + 1, sizeof(key));
4222 strlcpy(key, com_token, sizeof(key));
4223 while (key[strlen(key)-1] == ' ') // remove trailing spaces
4224 key[strlen(key)-1] = 0;
4225 if (!COM_ParseToken_Simple(&data, false, false))
4227 strlcpy(value, com_token, sizeof(value));
4229 // now that we have the key pair worked out...
4230 if (!strcmp("light", key))
4232 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
4236 light[0] = vec[0] * (1.0f / 256.0f);
4237 light[1] = vec[0] * (1.0f / 256.0f);
4238 light[2] = vec[0] * (1.0f / 256.0f);
4244 light[0] = vec[0] * (1.0f / 255.0f);
4245 light[1] = vec[1] * (1.0f / 255.0f);
4246 light[2] = vec[2] * (1.0f / 255.0f);
4250 else if (!strcmp("delay", key))
4252 else if (!strcmp("origin", key))
4253 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
4254 else if (!strcmp("angle", key))
4255 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
4256 else if (!strcmp("angles", key))
4257 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
4258 else if (!strcmp("color", key))
4259 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
4260 else if (!strcmp("wait", key))
4261 fadescale = atof(value);
4262 else if (!strcmp("classname", key))
4264 if (!strncmp(value, "light", 5))
4267 if (!strcmp(value, "light_fluoro"))
4272 overridecolor[0] = 1;
4273 overridecolor[1] = 1;
4274 overridecolor[2] = 1;
4276 if (!strcmp(value, "light_fluorospark"))
4281 overridecolor[0] = 1;
4282 overridecolor[1] = 1;
4283 overridecolor[2] = 1;
4285 if (!strcmp(value, "light_globe"))
4290 overridecolor[0] = 1;
4291 overridecolor[1] = 0.8;
4292 overridecolor[2] = 0.4;
4294 if (!strcmp(value, "light_flame_large_yellow"))
4299 overridecolor[0] = 1;
4300 overridecolor[1] = 0.5;
4301 overridecolor[2] = 0.1;
4303 if (!strcmp(value, "light_flame_small_yellow"))
4308 overridecolor[0] = 1;
4309 overridecolor[1] = 0.5;
4310 overridecolor[2] = 0.1;
4312 if (!strcmp(value, "light_torch_small_white"))
4317 overridecolor[0] = 1;
4318 overridecolor[1] = 0.5;
4319 overridecolor[2] = 0.1;
4321 if (!strcmp(value, "light_torch_small_walltorch"))
4326 overridecolor[0] = 1;
4327 overridecolor[1] = 0.5;
4328 overridecolor[2] = 0.1;
4332 else if (!strcmp("style", key))
4333 style = atoi(value);
4334 else if (!strcmp("skin", key))
4335 skin = (int)atof(value);
4336 else if (!strcmp("pflags", key))
4337 pflags = (int)atof(value);
4338 else if (!strcmp("effects", key))
4339 effects = (int)atof(value);
4340 else if (cl.worldmodel->type == mod_brushq3)
4342 if (!strcmp("scale", key))
4343 lightscale = atof(value);
4344 if (!strcmp("fade", key))
4345 fadescale = atof(value);
4350 if (lightscale <= 0)
4354 if (color[0] == color[1] && color[0] == color[2])
4356 color[0] *= overridecolor[0];
4357 color[1] *= overridecolor[1];
4358 color[2] *= overridecolor[2];
4360 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
4361 color[0] = color[0] * light[0];
4362 color[1] = color[1] * light[1];
4363 color[2] = color[2] * light[2];
4366 case LIGHTTYPE_MINUSX:
4368 case LIGHTTYPE_RECIPX:
4370 VectorScale(color, (1.0f / 16.0f), color);
4372 case LIGHTTYPE_RECIPXX:
4374 VectorScale(color, (1.0f / 16.0f), color);
4377 case LIGHTTYPE_NONE:
4381 case LIGHTTYPE_MINUSXX:
4384 VectorAdd(origin, originhack, origin);
4386 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, (pflags & PFLAGS_CORONA) != 0, style, (pflags & PFLAGS_NOSHADOW) == 0, skin >= 16 ? va("cubemaps/%i", skin) : NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
4389 Mem_Free(entfiledata);
4393 void R_Shadow_SetCursorLocationForView(void)
4396 vec3_t dest, endpos;
4398 VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
4399 trace = CL_Move(r_refdef.view.origin, vec3_origin, vec3_origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
4400 if (trace.fraction < 1)
4402 dist = trace.fraction * r_editlights_cursordistance.value;
4403 push = r_editlights_cursorpushback.value;
4407 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
4408 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
4412 VectorClear( endpos );
4414 r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
4415 r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
4416 r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
4419 void R_Shadow_UpdateWorldLightSelection(void)
4421 if (r_editlights.integer)
4423 R_Shadow_SetCursorLocationForView();
4424 R_Shadow_SelectLightInView();
4427 R_Shadow_SelectLight(NULL);
4430 void R_Shadow_EditLights_Clear_f(void)
4432 R_Shadow_ClearWorldLights();
4435 void R_Shadow_EditLights_Reload_f(void)
4439 strlcpy(r_shadow_mapname, cl.worldmodel->name, sizeof(r_shadow_mapname));
4440 R_Shadow_ClearWorldLights();
4441 R_Shadow_LoadWorldLights();
4442 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
4444 R_Shadow_LoadLightsFile();
4445 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
4446 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
4450 void R_Shadow_EditLights_Save_f(void)
4454 R_Shadow_SaveWorldLights();
4457 void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
4459 R_Shadow_ClearWorldLights();
4460 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
4463 void R_Shadow_EditLights_ImportLightsFile_f(void)
4465 R_Shadow_ClearWorldLights();
4466 R_Shadow_LoadLightsFile();
4469 void R_Shadow_EditLights_Spawn_f(void)
4472 if (!r_editlights.integer)
4474 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
4477 if (Cmd_Argc() != 1)
4479 Con_Print("r_editlights_spawn does not take parameters\n");
4482 color[0] = color[1] = color[2] = 1;
4483 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
4486 void R_Shadow_EditLights_Edit_f(void)
4488 vec3_t origin, angles, color;
4489 vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
4490 int style, shadows, flags, normalmode, realtimemode;
4491 char cubemapname[MAX_INPUTLINE];
4492 if (!r_editlights.integer)
4494 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
4497 if (!r_shadow_selectedlight)
4499 Con_Print("No selected light.\n");
4502 VectorCopy(r_shadow_selectedlight->origin, origin);
4503 VectorCopy(r_shadow_selectedlight->angles, angles);
4504 VectorCopy(r_shadow_selectedlight->color, color);
4505 radius = r_shadow_selectedlight->radius;
4506 style = r_shadow_selectedlight->style;
4507 if (r_shadow_selectedlight->cubemapname)
4508 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
4511 shadows = r_shadow_selectedlight->shadow;
4512 corona = r_shadow_selectedlight->corona;
4513 coronasizescale = r_shadow_selectedlight->coronasizescale;
4514 ambientscale = r_shadow_selectedlight->ambientscale;
4515 diffusescale = r_shadow_selectedlight->diffusescale;
4516 specularscale = r_shadow_selectedlight->specularscale;
4517 flags = r_shadow_selectedlight->flags;
4518 normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
4519 realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
4520 if (!strcmp(Cmd_Argv(1), "origin"))
4522 if (Cmd_Argc() != 5)
4524 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
4527 origin[0] = atof(Cmd_Argv(2));
4528 origin[1] = atof(Cmd_Argv(3));
4529 origin[2] = atof(Cmd_Argv(4));
4531 else if (!strcmp(Cmd_Argv(1), "originx"))
4533 if (Cmd_Argc() != 3)
4535 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4538 origin[0] = atof(Cmd_Argv(2));
4540 else if (!strcmp(Cmd_Argv(1), "originy"))
4542 if (Cmd_Argc() != 3)
4544 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4547 origin[1] = atof(Cmd_Argv(2));
4549 else if (!strcmp(Cmd_Argv(1), "originz"))
4551 if (Cmd_Argc() != 3)
4553 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4556 origin[2] = atof(Cmd_Argv(2));
4558 else if (!strcmp(Cmd_Argv(1), "move"))
4560 if (Cmd_Argc() != 5)
4562 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
4565 origin[0] += atof(Cmd_Argv(2));
4566 origin[1] += atof(Cmd_Argv(3));
4567 origin[2] += atof(Cmd_Argv(4));
4569 else if (!strcmp(Cmd_Argv(1), "movex"))
4571 if (Cmd_Argc() != 3)
4573 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4576 origin[0] += atof(Cmd_Argv(2));
4578 else if (!strcmp(Cmd_Argv(1), "movey"))
4580 if (Cmd_Argc() != 3)
4582 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4585 origin[1] += atof(Cmd_Argv(2));
4587 else if (!strcmp(Cmd_Argv(1), "movez"))
4589 if (Cmd_Argc() != 3)
4591 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4594 origin[2] += atof(Cmd_Argv(2));
4596 else if (!strcmp(Cmd_Argv(1), "angles"))
4598 if (Cmd_Argc() != 5)
4600 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
4603 angles[0] = atof(Cmd_Argv(2));
4604 angles[1] = atof(Cmd_Argv(3));
4605 angles[2] = atof(Cmd_Argv(4));
4607 else if (!strcmp(Cmd_Argv(1), "anglesx"))
4609 if (Cmd_Argc() != 3)
4611 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4614 angles[0] = atof(Cmd_Argv(2));
4616 else if (!strcmp(Cmd_Argv(1), "anglesy"))
4618 if (Cmd_Argc() != 3)
4620 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4623 angles[1] = atof(Cmd_Argv(2));
4625 else if (!strcmp(Cmd_Argv(1), "anglesz"))
4627 if (Cmd_Argc() != 3)
4629 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4632 angles[2] = atof(Cmd_Argv(2));
4634 else if (!strcmp(Cmd_Argv(1), "color"))
4636 if (Cmd_Argc() != 5)
4638 Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
4641 color[0] = atof(Cmd_Argv(2));
4642 color[1] = atof(Cmd_Argv(3));
4643 color[2] = atof(Cmd_Argv(4));
4645 else if (!strcmp(Cmd_Argv(1), "radius"))
4647 if (Cmd_Argc() != 3)
4649 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4652 radius = atof(Cmd_Argv(2));
4654 else if (!strcmp(Cmd_Argv(1), "colorscale"))
4656 if (Cmd_Argc() == 3)
4658 double scale = atof(Cmd_Argv(2));
4665 if (Cmd_Argc() != 5)
4667 Con_Printf("usage: r_editlights_edit %s red green blue (OR grey instead of red green blue)\n", Cmd_Argv(1));
4670 color[0] *= atof(Cmd_Argv(2));
4671 color[1] *= atof(Cmd_Argv(3));
4672 color[2] *= atof(Cmd_Argv(4));
4675 else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
4677 if (Cmd_Argc() != 3)
4679 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4682 radius *= atof(Cmd_Argv(2));
4684 else if (!strcmp(Cmd_Argv(1), "style"))
4686 if (Cmd_Argc() != 3)
4688 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4691 style = atoi(Cmd_Argv(2));
4693 else if (!strcmp(Cmd_Argv(1), "cubemap"))
4697 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4700 if (Cmd_Argc() == 3)
4701 strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
4705 else if (!strcmp(Cmd_Argv(1), "shadows"))
4707 if (Cmd_Argc() != 3)
4709 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4712 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
4714 else if (!strcmp(Cmd_Argv(1), "corona"))
4716 if (Cmd_Argc() != 3)
4718 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4721 corona = atof(Cmd_Argv(2));
4723 else if (!strcmp(Cmd_Argv(1), "coronasize"))
4725 if (Cmd_Argc() != 3)
4727 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4730 coronasizescale = atof(Cmd_Argv(2));
4732 else if (!strcmp(Cmd_Argv(1), "ambient"))
4734 if (Cmd_Argc() != 3)
4736 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4739 ambientscale = atof(Cmd_Argv(2));
4741 else if (!strcmp(Cmd_Argv(1), "diffuse"))
4743 if (Cmd_Argc() != 3)
4745 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4748 diffusescale = atof(Cmd_Argv(2));
4750 else if (!strcmp(Cmd_Argv(1), "specular"))
4752 if (Cmd_Argc() != 3)
4754 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4757 specularscale = atof(Cmd_Argv(2));
4759 else if (!strcmp(Cmd_Argv(1), "normalmode"))
4761 if (Cmd_Argc() != 3)
4763 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4766 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
4768 else if (!strcmp(Cmd_Argv(1), "realtimemode"))
4770 if (Cmd_Argc() != 3)
4772 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
4775 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
4779 Con_Print("usage: r_editlights_edit [property] [value]\n");
4780 Con_Print("Selected light's properties:\n");
4781 Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
4782 Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
4783 Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
4784 Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius);
4785 Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona);
4786 Con_Printf("Style : %i\n", r_shadow_selectedlight->style);
4787 Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
4788 Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname);
4789 Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);
4790 Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale);
4791 Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale);
4792 Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale);
4793 Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
4794 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
4797 flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
4798 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
4801 void R_Shadow_EditLights_EditAll_f(void)
4807 if (!r_editlights.integer)
4809 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
4813 // EditLights doesn't seem to have a "remove" command or something so:
4814 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4815 for (lightindex = 0;lightindex < range;lightindex++)
4817 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4820 R_Shadow_SelectLight(light);
4821 R_Shadow_EditLights_Edit_f();
4825 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
4827 int lightnumber, lightcount;
4828 size_t lightindex, range;
4832 if (!r_editlights.integer)
4834 x = vid_conwidth.value - 240;
4836 DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
4839 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4840 for (lightindex = 0;lightindex < range;lightindex++)
4842 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4845 if (light == r_shadow_selectedlight)
4846 lightnumber = lightindex;
4849 dpsnprintf(temp, sizeof(temp), "Cursor origin: %.0f %.0f %.0f", r_editlights_cursorlocation[0], r_editlights_cursorlocation[1], r_editlights_cursorlocation[2]); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false);y += 8;
4850 dpsnprintf(temp, sizeof(temp), "Total lights : %i active (%i total)", lightcount, (int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray)); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false);y += 8;
4852 if (r_shadow_selectedlight == NULL)
4854 dpsnprintf(temp, sizeof(temp), "Light #%i properties:", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4855 dpsnprintf(temp, sizeof(temp), "Origin : %.0f %.0f %.0f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4856 dpsnprintf(temp, sizeof(temp), "Angles : %.0f %.0f %.0f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4857 dpsnprintf(temp, sizeof(temp), "Color : %.2f %.2f %.2f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4858 dpsnprintf(temp, sizeof(temp), "Radius : %.0f\n", r_shadow_selectedlight->radius);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4859 dpsnprintf(temp, sizeof(temp), "Corona : %.0f\n", r_shadow_selectedlight->corona);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4860 dpsnprintf(temp, sizeof(temp), "Style : %i\n", r_shadow_selectedlight->style);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4861 dpsnprintf(temp, sizeof(temp), "Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4862 dpsnprintf(temp, sizeof(temp), "Cubemap : %s\n", r_shadow_selectedlight->cubemapname);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4863 dpsnprintf(temp, sizeof(temp), "CoronaSize : %.2f\n", r_shadow_selectedlight->coronasizescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4864 dpsnprintf(temp, sizeof(temp), "Ambient : %.2f\n", r_shadow_selectedlight->ambientscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4865 dpsnprintf(temp, sizeof(temp), "Diffuse : %.2f\n", r_shadow_selectedlight->diffusescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4866 dpsnprintf(temp, sizeof(temp), "Specular : %.2f\n", r_shadow_selectedlight->specularscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4867 dpsnprintf(temp, sizeof(temp), "NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4868 dpsnprintf(temp, sizeof(temp), "RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
4871 void R_Shadow_EditLights_ToggleShadow_f(void)
4873 if (!r_editlights.integer)
4875 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
4878 if (!r_shadow_selectedlight)
4880 Con_Print("No selected light.\n");
4883 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, r_shadow_selectedlight->origin, r_shadow_selectedlight->angles, r_shadow_selectedlight->color, r_shadow_selectedlight->radius, r_shadow_selectedlight->corona, r_shadow_selectedlight->style, !r_shadow_selectedlight->shadow, r_shadow_selectedlight->cubemapname, r_shadow_selectedlight->coronasizescale, r_shadow_selectedlight->ambientscale, r_shadow_selectedlight->diffusescale, r_shadow_selectedlight->specularscale, r_shadow_selectedlight->flags);
4886 void R_Shadow_EditLights_ToggleCorona_f(void)
4888 if (!r_editlights.integer)
4890 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
4893 if (!r_shadow_selectedlight)
4895 Con_Print("No selected light.\n");
4898 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, r_shadow_selectedlight->origin, r_shadow_selectedlight->angles, r_shadow_selectedlight->color, r_shadow_selectedlight->radius, !r_shadow_selectedlight->corona, r_shadow_selectedlight->style, r_shadow_selectedlight->shadow, r_shadow_selectedlight->cubemapname, r_shadow_selectedlight->coronasizescale, r_shadow_selectedlight->ambientscale, r_shadow_selectedlight->diffusescale, r_shadow_selectedlight->specularscale, r_shadow_selectedlight->flags);
4901 void R_Shadow_EditLights_Remove_f(void)
4903 if (!r_editlights.integer)
4905 Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n");
4908 if (!r_shadow_selectedlight)
4910 Con_Print("No selected light.\n");
4913 R_Shadow_FreeWorldLight(r_shadow_selectedlight);
4914 r_shadow_selectedlight = NULL;
4917 void R_Shadow_EditLights_Help_f(void)
4920 "Documentation on r_editlights system:\n"
4922 "r_editlights : enable/disable editing mode\n"
4923 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
4924 "r_editlights_cursorpushback : push back cursor this far from surface\n"
4925 "r_editlights_cursorpushoff : push cursor off surface this far\n"
4926 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
4927 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
4929 "r_editlights_help : this help\n"
4930 "r_editlights_clear : remove all lights\n"
4931 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
4932 "r_editlights_save : save to .rtlights file\n"
4933 "r_editlights_spawn : create a light with default settings\n"
4934 "r_editlights_edit command : edit selected light - more documentation below\n"
4935 "r_editlights_remove : remove selected light\n"
4936 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
4937 "r_editlights_importlightentitiesfrommap : reload light entities\n"
4938 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
4940 "origin x y z : set light location\n"
4941 "originx x: set x component of light location\n"
4942 "originy y: set y component of light location\n"
4943 "originz z: set z component of light location\n"
4944 "move x y z : adjust light location\n"
4945 "movex x: adjust x component of light location\n"
4946 "movey y: adjust y component of light location\n"
4947 "movez z: adjust z component of light location\n"
4948 "angles x y z : set light angles\n"
4949 "anglesx x: set x component of light angles\n"
4950 "anglesy y: set y component of light angles\n"
4951 "anglesz z: set z component of light angles\n"
4952 "color r g b : set color of light (can be brighter than 1 1 1)\n"
4953 "radius radius : set radius (size) of light\n"
4954 "colorscale grey : multiply color of light (1 does nothing)\n"
4955 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
4956 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
4957 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
4958 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
4959 "cubemap basename : set filter cubemap of light (not yet supported)\n"
4960 "shadows 1/0 : turn on/off shadows\n"
4961 "corona n : set corona intensity\n"
4962 "coronasize n : set corona size (0-1)\n"
4963 "ambient n : set ambient intensity (0-1)\n"
4964 "diffuse n : set diffuse intensity (0-1)\n"
4965 "specular n : set specular intensity (0-1)\n"
4966 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
4967 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
4968 "<nothing> : print light properties to console\n"
4972 void R_Shadow_EditLights_CopyInfo_f(void)
4974 if (!r_editlights.integer)
4976 Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n");
4979 if (!r_shadow_selectedlight)
4981 Con_Print("No selected light.\n");
4984 VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
4985 VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
4986 r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
4987 r_shadow_bufferlight.style = r_shadow_selectedlight->style;
4988 if (r_shadow_selectedlight->cubemapname)
4989 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
4991 r_shadow_bufferlight.cubemapname[0] = 0;
4992 r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
4993 r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
4994 r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
4995 r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
4996 r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
4997 r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
4998 r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
5001 void R_Shadow_EditLights_PasteInfo_f(void)
5003 if (!r_editlights.integer)
5005 Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n");
5008 if (!r_shadow_selectedlight)
5010 Con_Print("No selected light.\n");
5013 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, r_shadow_selectedlight->origin, r_shadow_bufferlight.angles, r_shadow_bufferlight.color, r_shadow_bufferlight.radius, r_shadow_bufferlight.corona, r_shadow_bufferlight.style, r_shadow_bufferlight.shadow, r_shadow_bufferlight.cubemapname, r_shadow_bufferlight.coronasizescale, r_shadow_bufferlight.ambientscale, r_shadow_bufferlight.diffusescale, r_shadow_bufferlight.specularscale, r_shadow_bufferlight.flags);
5016 void R_Shadow_EditLights_Init(void)
5018 Cvar_RegisterVariable(&r_editlights);
5019 Cvar_RegisterVariable(&r_editlights_cursordistance);
5020 Cvar_RegisterVariable(&r_editlights_cursorpushback);
5021 Cvar_RegisterVariable(&r_editlights_cursorpushoff);
5022 Cvar_RegisterVariable(&r_editlights_cursorgrid);
5023 Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
5024 Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
5025 Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
5026 Cmd_AddCommand("r_editlights_reload", R_Shadow_EditLights_Reload_f, "reloads rtlights file (or imports from .lights file or .ent file or the map itself)");
5027 Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
5028 Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
5029 Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
5030 Cmd_AddCommand("r_editlights_editall", R_Shadow_EditLights_EditAll_f, "changes a property on ALL lights at once (tip: use radiusscale and colorscale to alter these properties)");
5031 Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
5032 Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
5033 Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
5034 Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
5035 Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
5036 Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
5037 Cmd_AddCommand("r_editlights_pasteinfo", R_Shadow_EditLights_PasteInfo_f, "apply the stored properties onto the selected light (making it exactly identical except for origin)");
5043 =============================================================================
5047 =============================================================================
5050 void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const vec3_t p, int dynamic)
5052 VectorClear(diffusecolor);
5053 VectorClear(diffusenormal);
5055 if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
5057 ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_refdef.scene.ambient * (2.0f / 128.0f);
5058 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
5061 VectorSet(ambientcolor, 1, 1, 1);
5068 for (i = 0;i < r_refdef.scene.numlights;i++)
5070 light = r_refdef.scene.lights[i];
5071 Matrix4x4_Transform(&light->matrix_worldtolight, p, v);
5072 f = 1 - VectorLength2(v);
5073 if (f > 0 && CL_Move(p, vec3_origin, vec3_origin, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1)
5074 VectorMA(ambientcolor, f, light->currentcolor, ambientcolor);