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 #define R_SHADOW_SHADOWMAP_NUMCUBEMAPS 8
145 extern void R_Shadow_EditLights_Init(void);
147 typedef enum r_shadow_rendermode_e
149 R_SHADOW_RENDERMODE_NONE,
150 R_SHADOW_RENDERMODE_ZPASS_STENCIL,
151 R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL,
152 R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE,
153 R_SHADOW_RENDERMODE_ZFAIL_STENCIL,
154 R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL,
155 R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE,
156 R_SHADOW_RENDERMODE_LIGHT_VERTEX,
157 R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN,
158 R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN,
159 R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN,
160 R_SHADOW_RENDERMODE_LIGHT_GLSL,
161 R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
162 R_SHADOW_RENDERMODE_VISIBLELIGHTING,
163 R_SHADOW_RENDERMODE_SHADOWMAP2D,
164 R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE,
165 R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE,
167 r_shadow_rendermode_t;
169 typedef enum r_shadow_shadowmode_e
171 R_SHADOW_SHADOWMODE_STENCIL,
172 R_SHADOW_SHADOWMODE_SHADOWMAP2D,
173 R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE,
174 R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE
176 r_shadow_shadowmode_t;
178 r_shadow_rendermode_t r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
179 r_shadow_rendermode_t r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_NONE;
180 r_shadow_rendermode_t r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_NONE;
181 r_shadow_rendermode_t r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_NONE;
182 qboolean r_shadow_usingshadowmaprect;
183 qboolean r_shadow_usingshadowmap2d;
184 qboolean r_shadow_usingshadowmapcube;
185 int r_shadow_shadowmapside;
186 float r_shadow_shadowmap_texturescale[2];
187 float r_shadow_shadowmap_parameters[4];
189 int r_shadow_drawbuffer;
190 int r_shadow_readbuffer;
192 int r_shadow_cullface_front, r_shadow_cullface_back;
193 GLuint r_shadow_fborectangle;
194 GLuint r_shadow_fbocubeside[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
195 GLuint r_shadow_fbo2d;
196 r_shadow_shadowmode_t r_shadow_shadowmode;
197 int r_shadow_shadowmapfilterquality;
198 int r_shadow_shadowmaptexturetype;
199 int r_shadow_shadowmapdepthbits;
200 int r_shadow_shadowmapmaxsize;
201 qboolean r_shadow_shadowmapvsdct;
202 qboolean r_shadow_shadowmapsampler;
203 int r_shadow_shadowmappcf;
204 int r_shadow_shadowmapborder;
205 int r_shadow_lightscissor[4];
206 qboolean r_shadow_usingdeferredprepass;
208 int maxshadowtriangles;
211 int maxshadowvertices;
212 float *shadowvertex3f;
222 unsigned char *shadowsides;
223 int *shadowsideslist;
230 int r_shadow_buffer_numleafpvsbytes;
231 unsigned char *r_shadow_buffer_visitingleafpvs;
232 unsigned char *r_shadow_buffer_leafpvs;
233 int *r_shadow_buffer_leaflist;
235 int r_shadow_buffer_numsurfacepvsbytes;
236 unsigned char *r_shadow_buffer_surfacepvs;
237 int *r_shadow_buffer_surfacelist;
238 unsigned char *r_shadow_buffer_surfacesides;
240 int r_shadow_buffer_numshadowtrispvsbytes;
241 unsigned char *r_shadow_buffer_shadowtrispvs;
242 int r_shadow_buffer_numlighttrispvsbytes;
243 unsigned char *r_shadow_buffer_lighttrispvs;
245 rtexturepool_t *r_shadow_texturepool;
246 rtexture_t *r_shadow_attenuationgradienttexture;
247 rtexture_t *r_shadow_attenuation2dtexture;
248 rtexture_t *r_shadow_attenuation3dtexture;
249 skinframe_t *r_shadow_lightcorona;
250 rtexture_t *r_shadow_shadowmaprectangletexture;
251 rtexture_t *r_shadow_shadowmap2dtexture;
252 rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
253 rtexture_t *r_shadow_shadowmapvsdcttexture;
254 int r_shadow_shadowmapsize; // changes for each light based on distance
255 int r_shadow_shadowmaplod; // changes for each light based on distance
257 GLuint r_shadow_prepassgeometryfbo;
258 GLuint r_shadow_prepasslightingfbo;
259 int r_shadow_prepass_width;
260 int r_shadow_prepass_height;
261 rtexture_t *r_shadow_prepassgeometrydepthtexture;
262 rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
263 rtexture_t *r_shadow_prepasslightingdiffusetexture;
264 rtexture_t *r_shadow_prepasslightingspeculartexture;
266 // lights are reloaded when this changes
267 char r_shadow_mapname[MAX_QPATH];
269 // used only for light filters (cubemaps)
270 rtexturepool_t *r_shadow_filters_texturepool;
272 static const GLenum r_shadow_prepasslightingdrawbuffers[2] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
274 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"};
275 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"};
276 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
277 cvar_t r_shadow_deferred = {CVAR_SAVE, "r_shadow_deferred", "0", "uses image-based lighting instead of geometry-based lighting, the method used renders a depth image and a normalmap image, renders lights into separate diffuse and specular images, and then combines this into the normal rendering, requires r_shadow_shadowmapping"};
278 cvar_t r_shadow_deferred_8bitrange = {CVAR_SAVE, "r_shadow_deferred_8bitrange", "2", "dynamic range of image-based lighting when using 32bit color (does not apply to fp)"};
279 //cvar_t r_shadow_deferred_fp = {CVAR_SAVE, "r_shadow_deferred_fp", "0", "use 16bit (1) or 32bit (2) floating point for accumulation of image-based lighting"};
280 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
281 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)"};
282 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"};
283 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
284 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
285 cvar_t r_shadow_gloss2exponent = {0, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
286 cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
287 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
288 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
289 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
290 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
291 cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1", "use portal culling to exactly determine lit triangles when compiling world lights"};
292 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000", "how far to cast shadows"};
293 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)"};
294 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
295 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
296 cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
297 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
298 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)"};
299 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"};
300 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
301 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
302 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"};
303 cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation"};
304 cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation"};
305 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)"};
306 cvar_t r_shadow_shadowmapping = {CVAR_SAVE, "r_shadow_shadowmapping", "0", "enables use of shadowmapping (depth texture sampling) instead of stencil shadow volumes, requires gl_fbo 1"};
307 cvar_t r_shadow_shadowmapping_texturetype = {CVAR_SAVE, "r_shadow_shadowmapping_texturetype", "-1", "shadowmap texture types: -1 = auto-select, 0 = 2D, 1 = rectangle, 2 = cubemap"};
308 cvar_t r_shadow_shadowmapping_filterquality = {CVAR_SAVE, "r_shadow_shadowmapping_filterquality", "-1", "shadowmap filter modes: -1 = auto-select, 0 = no filtering, 1 = bilinear, 2 = bilinear 2x2 blur (fast), 3 = 3x3 blur (moderate), 4 = 4x4 blur (slow)"};
309 cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
310 cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
311 cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "shadowmap size limit"};
312 cvar_t r_shadow_shadowmapping_maxsize = {CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "shadowmap size limit"};
313 cvar_t r_shadow_shadowmapping_precision = {CVAR_SAVE, "r_shadow_shadowmapping_precision", "1", "makes shadowmaps have a maximum resolution of this number of pixels per light source radius unit such that, for example, at precision 0.5 a light with radius 200 will have a maximum resolution of 100 pixels"};
314 //cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
315 //cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
316 cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
317 cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
318 cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
319 cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
320 cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
321 cvar_t r_shadow_culltriangles = {0, "r_shadow_culltriangles", "1", "performs more expensive tests to remove unnecessary triangles of lit surfaces"};
322 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
323 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)"};
324 cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect OpenGL 2.0 render path)"};
325 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
326 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"};
327 cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
328 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
329 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
330 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
331 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
332 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
333 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
334 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
335 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
336 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
338 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
339 #define ATTENTABLESIZE 256
340 // 1D gradient, 2D circle and 3D sphere attenuation textures
341 #define ATTEN1DSIZE 32
342 #define ATTEN2DSIZE 64
343 #define ATTEN3DSIZE 32
345 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
346 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
347 static float r_shadow_attentable[ATTENTABLESIZE+1];
349 rtlight_t *r_shadow_compilingrtlight;
350 static memexpandablearray_t r_shadow_worldlightsarray;
351 dlight_t *r_shadow_selectedlight;
352 dlight_t r_shadow_bufferlight;
353 vec3_t r_editlights_cursorlocation;
355 extern int con_vislines;
357 typedef struct cubemapinfo_s
364 static int numcubemaps;
365 static cubemapinfo_t cubemaps[MAX_CUBEMAPS];
367 void R_Shadow_UncompileWorldLights(void);
368 void R_Shadow_ClearWorldLights(void);
369 void R_Shadow_SaveWorldLights(void);
370 void R_Shadow_LoadWorldLights(void);
371 void R_Shadow_LoadLightsFile(void);
372 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
373 void R_Shadow_EditLights_Reload_f(void);
374 void R_Shadow_ValidateCvars(void);
375 static void R_Shadow_MakeTextures(void);
377 #define EDLIGHTSPRSIZE 8
378 skinframe_t *r_editlights_sprcursor;
379 skinframe_t *r_editlights_sprlight;
380 skinframe_t *r_editlights_sprnoshadowlight;
381 skinframe_t *r_editlights_sprcubemaplight;
382 skinframe_t *r_editlights_sprcubemapnoshadowlight;
383 skinframe_t *r_editlights_sprselection;
385 void R_Shadow_SetShadowMode(void)
387 r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
388 r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0;
389 r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
390 r_shadow_shadowmaptexturetype = r_shadow_shadowmapping_texturetype.integer;
391 r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
392 r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
393 r_shadow_shadowmaplod = -1;
394 r_shadow_shadowmapsize = 0;
395 r_shadow_shadowmapsampler = false;
396 r_shadow_shadowmappcf = 0;
397 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
398 switch(vid.renderpath)
400 case RENDERPATH_GL20:
401 if ((r_shadow_shadowmapping.integer || r_shadow_deferred.integer) && vid.support.ext_framebuffer_object)
403 if(r_shadow_shadowmapfilterquality < 0)
405 if(strstr(gl_vendor, "NVIDIA"))
407 r_shadow_shadowmapsampler = vid.support.arb_shadow;
408 r_shadow_shadowmappcf = 1;
410 else if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
411 r_shadow_shadowmappcf = 1;
412 else if(strstr(gl_vendor, "ATI"))
413 r_shadow_shadowmappcf = 1;
415 r_shadow_shadowmapsampler = vid.support.arb_shadow;
419 switch (r_shadow_shadowmapfilterquality)
422 r_shadow_shadowmapsampler = vid.support.arb_shadow;
425 r_shadow_shadowmapsampler = vid.support.arb_shadow;
426 r_shadow_shadowmappcf = 1;
429 r_shadow_shadowmappcf = 1;
432 r_shadow_shadowmappcf = 2;
436 switch (r_shadow_shadowmaptexturetype)
439 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
442 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE;
445 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE;
448 if((vid.support.amd_texture_texture4 || vid.support.arb_texture_gather) && r_shadow_shadowmappcf && !r_shadow_shadowmapsampler)
449 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
450 else if(vid.support.arb_texture_rectangle)
451 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE;
453 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
458 case RENDERPATH_GL13:
460 case RENDERPATH_GL11:
465 void R_Shadow_FreeShadowMaps(void)
469 R_Shadow_SetShadowMode();
471 if (!vid.support.ext_framebuffer_object || !vid.support.arb_fragment_shader)
476 if (r_shadow_fborectangle)
477 qglDeleteFramebuffersEXT(1, &r_shadow_fborectangle);CHECKGLERROR
478 r_shadow_fborectangle = 0;
481 qglDeleteFramebuffersEXT(1, &r_shadow_fbo2d);CHECKGLERROR
483 for (i = 0;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
484 if (r_shadow_fbocubeside[i])
485 qglDeleteFramebuffersEXT(1, &r_shadow_fbocubeside[i]);CHECKGLERROR
486 memset(r_shadow_fbocubeside, 0, sizeof(r_shadow_fbocubeside));
488 if (r_shadow_shadowmaprectangletexture)
489 R_FreeTexture(r_shadow_shadowmaprectangletexture);
490 r_shadow_shadowmaprectangletexture = NULL;
492 if (r_shadow_shadowmap2dtexture)
493 R_FreeTexture(r_shadow_shadowmap2dtexture);
494 r_shadow_shadowmap2dtexture = NULL;
496 for (i = 0;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
497 if (r_shadow_shadowmapcubetexture[i])
498 R_FreeTexture(r_shadow_shadowmapcubetexture[i]);
499 memset(r_shadow_shadowmapcubetexture, 0, sizeof(r_shadow_shadowmapcubetexture));
501 if (r_shadow_shadowmapvsdcttexture)
502 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
503 r_shadow_shadowmapvsdcttexture = NULL;
508 void r_shadow_start(void)
510 // allocate vertex processing arrays
512 r_shadow_attenuationgradienttexture = NULL;
513 r_shadow_attenuation2dtexture = NULL;
514 r_shadow_attenuation3dtexture = NULL;
515 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
516 r_shadow_shadowmaprectangletexture = NULL;
517 r_shadow_shadowmap2dtexture = NULL;
518 memset(r_shadow_shadowmapcubetexture, 0, sizeof(r_shadow_shadowmapcubetexture));
519 r_shadow_shadowmapvsdcttexture = NULL;
520 r_shadow_shadowmapmaxsize = 0;
521 r_shadow_shadowmapsize = 0;
522 r_shadow_shadowmaplod = 0;
523 r_shadow_shadowmapfilterquality = -1;
524 r_shadow_shadowmaptexturetype = -1;
525 r_shadow_shadowmapdepthbits = 0;
526 r_shadow_shadowmapvsdct = false;
527 r_shadow_shadowmapsampler = false;
528 r_shadow_shadowmappcf = 0;
529 r_shadow_fborectangle = 0;
531 memset(r_shadow_fbocubeside, 0, sizeof(r_shadow_fbocubeside));
533 R_Shadow_FreeShadowMaps();
535 r_shadow_texturepool = NULL;
536 r_shadow_filters_texturepool = NULL;
537 R_Shadow_ValidateCvars();
538 R_Shadow_MakeTextures();
539 maxshadowtriangles = 0;
540 shadowelements = NULL;
541 maxshadowvertices = 0;
542 shadowvertex3f = NULL;
550 shadowmarklist = NULL;
555 shadowsideslist = NULL;
556 r_shadow_buffer_numleafpvsbytes = 0;
557 r_shadow_buffer_visitingleafpvs = NULL;
558 r_shadow_buffer_leafpvs = NULL;
559 r_shadow_buffer_leaflist = NULL;
560 r_shadow_buffer_numsurfacepvsbytes = 0;
561 r_shadow_buffer_surfacepvs = NULL;
562 r_shadow_buffer_surfacelist = NULL;
563 r_shadow_buffer_surfacesides = NULL;
564 r_shadow_buffer_numshadowtrispvsbytes = 0;
565 r_shadow_buffer_shadowtrispvs = NULL;
566 r_shadow_buffer_numlighttrispvsbytes = 0;
567 r_shadow_buffer_lighttrispvs = NULL;
569 r_shadow_usingdeferredprepass = false;
570 r_shadow_prepass_width = r_shadow_prepass_height = 0;
573 static void R_Shadow_FreeDeferred(void);
574 void r_shadow_shutdown(void)
577 R_Shadow_UncompileWorldLights();
579 R_Shadow_FreeShadowMaps();
581 r_shadow_usingdeferredprepass = false;
582 if (r_shadow_prepass_width)
583 R_Shadow_FreeDeferred();
584 r_shadow_prepass_width = r_shadow_prepass_height = 0;
588 r_shadow_attenuationgradienttexture = NULL;
589 r_shadow_attenuation2dtexture = NULL;
590 r_shadow_attenuation3dtexture = NULL;
591 R_FreeTexturePool(&r_shadow_texturepool);
592 R_FreeTexturePool(&r_shadow_filters_texturepool);
593 maxshadowtriangles = 0;
595 Mem_Free(shadowelements);
596 shadowelements = NULL;
598 Mem_Free(shadowvertex3f);
599 shadowvertex3f = NULL;
602 Mem_Free(vertexupdate);
605 Mem_Free(vertexremap);
611 Mem_Free(shadowmark);
614 Mem_Free(shadowmarklist);
615 shadowmarklist = NULL;
620 Mem_Free(shadowsides);
623 Mem_Free(shadowsideslist);
624 shadowsideslist = NULL;
625 r_shadow_buffer_numleafpvsbytes = 0;
626 if (r_shadow_buffer_visitingleafpvs)
627 Mem_Free(r_shadow_buffer_visitingleafpvs);
628 r_shadow_buffer_visitingleafpvs = NULL;
629 if (r_shadow_buffer_leafpvs)
630 Mem_Free(r_shadow_buffer_leafpvs);
631 r_shadow_buffer_leafpvs = NULL;
632 if (r_shadow_buffer_leaflist)
633 Mem_Free(r_shadow_buffer_leaflist);
634 r_shadow_buffer_leaflist = NULL;
635 r_shadow_buffer_numsurfacepvsbytes = 0;
636 if (r_shadow_buffer_surfacepvs)
637 Mem_Free(r_shadow_buffer_surfacepvs);
638 r_shadow_buffer_surfacepvs = NULL;
639 if (r_shadow_buffer_surfacelist)
640 Mem_Free(r_shadow_buffer_surfacelist);
641 r_shadow_buffer_surfacelist = NULL;
642 if (r_shadow_buffer_surfacesides)
643 Mem_Free(r_shadow_buffer_surfacesides);
644 r_shadow_buffer_surfacesides = NULL;
645 r_shadow_buffer_numshadowtrispvsbytes = 0;
646 if (r_shadow_buffer_shadowtrispvs)
647 Mem_Free(r_shadow_buffer_shadowtrispvs);
648 r_shadow_buffer_numlighttrispvsbytes = 0;
649 if (r_shadow_buffer_lighttrispvs)
650 Mem_Free(r_shadow_buffer_lighttrispvs);
653 void r_shadow_newmap(void)
655 if (r_shadow_lightcorona) R_SkinFrame_MarkUsed(r_shadow_lightcorona);
656 if (r_editlights_sprcursor) R_SkinFrame_MarkUsed(r_editlights_sprcursor);
657 if (r_editlights_sprlight) R_SkinFrame_MarkUsed(r_editlights_sprlight);
658 if (r_editlights_sprnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
659 if (r_editlights_sprcubemaplight) R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
660 if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
661 if (r_editlights_sprselection) R_SkinFrame_MarkUsed(r_editlights_sprselection);
662 if (cl.worldmodel && strncmp(cl.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
663 R_Shadow_EditLights_Reload_f();
666 void R_Shadow_Init(void)
668 Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
669 Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
670 Cvar_RegisterVariable(&r_shadow_usenormalmap);
671 Cvar_RegisterVariable(&r_shadow_debuglight);
672 Cvar_RegisterVariable(&r_shadow_deferred);
673 Cvar_RegisterVariable(&r_shadow_deferred_8bitrange);
674 // Cvar_RegisterVariable(&r_shadow_deferred_fp);
675 Cvar_RegisterVariable(&r_shadow_gloss);
676 Cvar_RegisterVariable(&r_shadow_gloss2intensity);
677 Cvar_RegisterVariable(&r_shadow_glossintensity);
678 Cvar_RegisterVariable(&r_shadow_glossexponent);
679 Cvar_RegisterVariable(&r_shadow_gloss2exponent);
680 Cvar_RegisterVariable(&r_shadow_glossexact);
681 Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
682 Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
683 Cvar_RegisterVariable(&r_shadow_lightintensityscale);
684 Cvar_RegisterVariable(&r_shadow_lightradiusscale);
685 Cvar_RegisterVariable(&r_shadow_portallight);
686 Cvar_RegisterVariable(&r_shadow_projectdistance);
687 Cvar_RegisterVariable(&r_shadow_frontsidecasting);
688 Cvar_RegisterVariable(&r_shadow_realtime_dlight);
689 Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
690 Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
691 Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
692 Cvar_RegisterVariable(&r_shadow_realtime_world);
693 Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
694 Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
695 Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
696 Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
697 Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
698 Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
699 Cvar_RegisterVariable(&r_shadow_scissor);
700 Cvar_RegisterVariable(&r_shadow_shadowmapping);
701 Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
702 Cvar_RegisterVariable(&r_shadow_shadowmapping_texturetype);
703 Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
704 Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
705 Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
706 Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
707 Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
708 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
709 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
710 Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
711 Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
712 Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
713 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
714 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
715 Cvar_RegisterVariable(&r_shadow_culltriangles);
716 Cvar_RegisterVariable(&r_shadow_polygonfactor);
717 Cvar_RegisterVariable(&r_shadow_polygonoffset);
718 Cvar_RegisterVariable(&r_shadow_texture3d);
719 Cvar_RegisterVariable(&r_coronas);
720 Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
721 Cvar_RegisterVariable(&r_coronas_occlusionquery);
722 Cvar_RegisterVariable(&gl_flashblend);
723 Cvar_RegisterVariable(&gl_ext_separatestencil);
724 Cvar_RegisterVariable(&gl_ext_stenciltwoside);
725 if (gamemode == GAME_TENEBRAE)
727 Cvar_SetValue("r_shadow_gloss", 2);
728 Cvar_SetValue("r_shadow_bumpscale_basetexture", 4);
730 R_Shadow_EditLights_Init();
731 Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
732 maxshadowtriangles = 0;
733 shadowelements = NULL;
734 maxshadowvertices = 0;
735 shadowvertex3f = NULL;
743 shadowmarklist = NULL;
748 shadowsideslist = NULL;
749 r_shadow_buffer_numleafpvsbytes = 0;
750 r_shadow_buffer_visitingleafpvs = NULL;
751 r_shadow_buffer_leafpvs = NULL;
752 r_shadow_buffer_leaflist = NULL;
753 r_shadow_buffer_numsurfacepvsbytes = 0;
754 r_shadow_buffer_surfacepvs = NULL;
755 r_shadow_buffer_surfacelist = NULL;
756 r_shadow_buffer_surfacesides = NULL;
757 r_shadow_buffer_shadowtrispvs = NULL;
758 r_shadow_buffer_lighttrispvs = NULL;
759 R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap);
762 matrix4x4_t matrix_attenuationxyz =
765 {0.5, 0.0, 0.0, 0.5},
766 {0.0, 0.5, 0.0, 0.5},
767 {0.0, 0.0, 0.5, 0.5},
772 matrix4x4_t matrix_attenuationz =
775 {0.0, 0.0, 0.5, 0.5},
776 {0.0, 0.0, 0.0, 0.5},
777 {0.0, 0.0, 0.0, 0.5},
782 void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
784 numvertices = ((numvertices + 255) & ~255) * vertscale;
785 numtriangles = ((numtriangles + 255) & ~255) * triscale;
786 // make sure shadowelements is big enough for this volume
787 if (maxshadowtriangles < numtriangles)
789 maxshadowtriangles = numtriangles;
791 Mem_Free(shadowelements);
792 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
794 // make sure shadowvertex3f is big enough for this volume
795 if (maxshadowvertices < numvertices)
797 maxshadowvertices = numvertices;
799 Mem_Free(shadowvertex3f);
800 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
804 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
806 int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
807 int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
808 int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
809 int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
810 if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
812 if (r_shadow_buffer_visitingleafpvs)
813 Mem_Free(r_shadow_buffer_visitingleafpvs);
814 if (r_shadow_buffer_leafpvs)
815 Mem_Free(r_shadow_buffer_leafpvs);
816 if (r_shadow_buffer_leaflist)
817 Mem_Free(r_shadow_buffer_leaflist);
818 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
819 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
820 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
821 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
823 if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
825 if (r_shadow_buffer_surfacepvs)
826 Mem_Free(r_shadow_buffer_surfacepvs);
827 if (r_shadow_buffer_surfacelist)
828 Mem_Free(r_shadow_buffer_surfacelist);
829 if (r_shadow_buffer_surfacesides)
830 Mem_Free(r_shadow_buffer_surfacesides);
831 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
832 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
833 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
834 r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
836 if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
838 if (r_shadow_buffer_shadowtrispvs)
839 Mem_Free(r_shadow_buffer_shadowtrispvs);
840 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
841 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
843 if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
845 if (r_shadow_buffer_lighttrispvs)
846 Mem_Free(r_shadow_buffer_lighttrispvs);
847 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
848 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
852 void R_Shadow_PrepareShadowMark(int numtris)
854 // make sure shadowmark is big enough for this volume
855 if (maxshadowmark < numtris)
857 maxshadowmark = numtris;
859 Mem_Free(shadowmark);
861 Mem_Free(shadowmarklist);
862 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
863 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
867 // if shadowmarkcount wrapped we clear the array and adjust accordingly
868 if (shadowmarkcount == 0)
871 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
876 void R_Shadow_PrepareShadowSides(int numtris)
878 if (maxshadowsides < numtris)
880 maxshadowsides = numtris;
882 Mem_Free(shadowsides);
884 Mem_Free(shadowsideslist);
885 shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
886 shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
891 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)
894 int outtriangles = 0, outvertices = 0;
897 float ratio, direction[3], projectvector[3];
899 if (projectdirection)
900 VectorScale(projectdirection, projectdistance, projectvector);
902 VectorClear(projectvector);
904 // create the vertices
905 if (projectdirection)
907 for (i = 0;i < numshadowmarktris;i++)
909 element = inelement3i + shadowmarktris[i] * 3;
910 for (j = 0;j < 3;j++)
912 if (vertexupdate[element[j]] != vertexupdatenum)
914 vertexupdate[element[j]] = vertexupdatenum;
915 vertexremap[element[j]] = outvertices;
916 vertex = invertex3f + element[j] * 3;
917 // project one copy of the vertex according to projectvector
918 VectorCopy(vertex, outvertex3f);
919 VectorAdd(vertex, projectvector, (outvertex3f + 3));
928 for (i = 0;i < numshadowmarktris;i++)
930 element = inelement3i + shadowmarktris[i] * 3;
931 for (j = 0;j < 3;j++)
933 if (vertexupdate[element[j]] != vertexupdatenum)
935 vertexupdate[element[j]] = vertexupdatenum;
936 vertexremap[element[j]] = outvertices;
937 vertex = invertex3f + element[j] * 3;
938 // project one copy of the vertex to the sphere radius of the light
939 // (FIXME: would projecting it to the light box be better?)
940 VectorSubtract(vertex, projectorigin, direction);
941 ratio = projectdistance / VectorLength(direction);
942 VectorCopy(vertex, outvertex3f);
943 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
951 if (r_shadow_frontsidecasting.integer)
953 for (i = 0;i < numshadowmarktris;i++)
955 int remappedelement[3];
957 const int *neighbortriangle;
959 markindex = shadowmarktris[i] * 3;
960 element = inelement3i + markindex;
961 neighbortriangle = inneighbor3i + markindex;
962 // output the front and back triangles
963 outelement3i[0] = vertexremap[element[0]];
964 outelement3i[1] = vertexremap[element[1]];
965 outelement3i[2] = vertexremap[element[2]];
966 outelement3i[3] = vertexremap[element[2]] + 1;
967 outelement3i[4] = vertexremap[element[1]] + 1;
968 outelement3i[5] = vertexremap[element[0]] + 1;
972 // output the sides (facing outward from this triangle)
973 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
975 remappedelement[0] = vertexremap[element[0]];
976 remappedelement[1] = vertexremap[element[1]];
977 outelement3i[0] = remappedelement[1];
978 outelement3i[1] = remappedelement[0];
979 outelement3i[2] = remappedelement[0] + 1;
980 outelement3i[3] = remappedelement[1];
981 outelement3i[4] = remappedelement[0] + 1;
982 outelement3i[5] = remappedelement[1] + 1;
987 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
989 remappedelement[1] = vertexremap[element[1]];
990 remappedelement[2] = vertexremap[element[2]];
991 outelement3i[0] = remappedelement[2];
992 outelement3i[1] = remappedelement[1];
993 outelement3i[2] = remappedelement[1] + 1;
994 outelement3i[3] = remappedelement[2];
995 outelement3i[4] = remappedelement[1] + 1;
996 outelement3i[5] = remappedelement[2] + 1;
1001 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1003 remappedelement[0] = vertexremap[element[0]];
1004 remappedelement[2] = vertexremap[element[2]];
1005 outelement3i[0] = remappedelement[0];
1006 outelement3i[1] = remappedelement[2];
1007 outelement3i[2] = remappedelement[2] + 1;
1008 outelement3i[3] = remappedelement[0];
1009 outelement3i[4] = remappedelement[2] + 1;
1010 outelement3i[5] = remappedelement[0] + 1;
1019 for (i = 0;i < numshadowmarktris;i++)
1021 int remappedelement[3];
1023 const int *neighbortriangle;
1025 markindex = shadowmarktris[i] * 3;
1026 element = inelement3i + markindex;
1027 neighbortriangle = inneighbor3i + markindex;
1028 // output the front and back triangles
1029 outelement3i[0] = vertexremap[element[2]];
1030 outelement3i[1] = vertexremap[element[1]];
1031 outelement3i[2] = vertexremap[element[0]];
1032 outelement3i[3] = vertexremap[element[0]] + 1;
1033 outelement3i[4] = vertexremap[element[1]] + 1;
1034 outelement3i[5] = vertexremap[element[2]] + 1;
1038 // output the sides (facing outward from this triangle)
1039 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1041 remappedelement[0] = vertexremap[element[0]];
1042 remappedelement[1] = vertexremap[element[1]];
1043 outelement3i[0] = remappedelement[0];
1044 outelement3i[1] = remappedelement[1];
1045 outelement3i[2] = remappedelement[1] + 1;
1046 outelement3i[3] = remappedelement[0];
1047 outelement3i[4] = remappedelement[1] + 1;
1048 outelement3i[5] = remappedelement[0] + 1;
1053 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1055 remappedelement[1] = vertexremap[element[1]];
1056 remappedelement[2] = vertexremap[element[2]];
1057 outelement3i[0] = remappedelement[1];
1058 outelement3i[1] = remappedelement[2];
1059 outelement3i[2] = remappedelement[2] + 1;
1060 outelement3i[3] = remappedelement[1];
1061 outelement3i[4] = remappedelement[2] + 1;
1062 outelement3i[5] = remappedelement[1] + 1;
1067 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1069 remappedelement[0] = vertexremap[element[0]];
1070 remappedelement[2] = vertexremap[element[2]];
1071 outelement3i[0] = remappedelement[2];
1072 outelement3i[1] = remappedelement[0];
1073 outelement3i[2] = remappedelement[0] + 1;
1074 outelement3i[3] = remappedelement[2];
1075 outelement3i[4] = remappedelement[0] + 1;
1076 outelement3i[5] = remappedelement[2] + 1;
1084 *outnumvertices = outvertices;
1085 return outtriangles;
1088 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)
1091 int outtriangles = 0, outvertices = 0;
1093 const float *vertex;
1094 float ratio, direction[3], projectvector[3];
1097 if (projectdirection)
1098 VectorScale(projectdirection, projectdistance, projectvector);
1100 VectorClear(projectvector);
1102 for (i = 0;i < numshadowmarktris;i++)
1104 int remappedelement[3];
1106 const int *neighbortriangle;
1108 markindex = shadowmarktris[i] * 3;
1109 neighbortriangle = inneighbor3i + markindex;
1110 side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
1111 side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
1112 side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
1113 if (side[0] + side[1] + side[2] == 0)
1117 element = inelement3i + markindex;
1119 // create the vertices
1120 for (j = 0;j < 3;j++)
1122 if (side[j] + side[j+1] == 0)
1125 if (vertexupdate[k] != vertexupdatenum)
1127 vertexupdate[k] = vertexupdatenum;
1128 vertexremap[k] = outvertices;
1129 vertex = invertex3f + k * 3;
1130 VectorCopy(vertex, outvertex3f);
1131 if (projectdirection)
1133 // project one copy of the vertex according to projectvector
1134 VectorAdd(vertex, projectvector, (outvertex3f + 3));
1138 // project one copy of the vertex to the sphere radius of the light
1139 // (FIXME: would projecting it to the light box be better?)
1140 VectorSubtract(vertex, projectorigin, direction);
1141 ratio = projectdistance / VectorLength(direction);
1142 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
1149 // output the sides (facing outward from this triangle)
1152 remappedelement[0] = vertexremap[element[0]];
1153 remappedelement[1] = vertexremap[element[1]];
1154 outelement3i[0] = remappedelement[1];
1155 outelement3i[1] = remappedelement[0];
1156 outelement3i[2] = remappedelement[0] + 1;
1157 outelement3i[3] = remappedelement[1];
1158 outelement3i[4] = remappedelement[0] + 1;
1159 outelement3i[5] = remappedelement[1] + 1;
1166 remappedelement[1] = vertexremap[element[1]];
1167 remappedelement[2] = vertexremap[element[2]];
1168 outelement3i[0] = remappedelement[2];
1169 outelement3i[1] = remappedelement[1];
1170 outelement3i[2] = remappedelement[1] + 1;
1171 outelement3i[3] = remappedelement[2];
1172 outelement3i[4] = remappedelement[1] + 1;
1173 outelement3i[5] = remappedelement[2] + 1;
1180 remappedelement[0] = vertexremap[element[0]];
1181 remappedelement[2] = vertexremap[element[2]];
1182 outelement3i[0] = remappedelement[0];
1183 outelement3i[1] = remappedelement[2];
1184 outelement3i[2] = remappedelement[2] + 1;
1185 outelement3i[3] = remappedelement[0];
1186 outelement3i[4] = remappedelement[2] + 1;
1187 outelement3i[5] = remappedelement[0] + 1;
1194 *outnumvertices = outvertices;
1195 return outtriangles;
1198 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)
1204 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1206 tend = firsttriangle + numtris;
1207 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1209 // surface box entirely inside light box, no box cull
1210 if (projectdirection)
1212 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1214 TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal);
1215 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1216 shadowmarklist[numshadowmark++] = t;
1221 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1222 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
1223 shadowmarklist[numshadowmark++] = t;
1228 // surface box not entirely inside light box, cull each triangle
1229 if (projectdirection)
1231 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1233 v[0] = invertex3f + e[0] * 3;
1234 v[1] = invertex3f + e[1] * 3;
1235 v[2] = invertex3f + e[2] * 3;
1236 TriangleNormal(v[0], v[1], v[2], normal);
1237 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1238 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1239 shadowmarklist[numshadowmark++] = t;
1244 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1246 v[0] = invertex3f + e[0] * 3;
1247 v[1] = invertex3f + e[1] * 3;
1248 v[2] = invertex3f + e[2] * 3;
1249 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1250 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1251 shadowmarklist[numshadowmark++] = t;
1257 qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
1262 if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
1264 // check if the shadow volume intersects the near plane
1266 // a ray between the eye and light origin may intersect the caster,
1267 // indicating that the shadow may touch the eye location, however we must
1268 // test the near plane (a polygon), not merely the eye location, so it is
1269 // easiest to enlarge the caster bounding shape slightly for this.
1275 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)
1277 int i, tris, outverts;
1278 if (projectdistance < 0.1)
1280 Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
1283 if (!numverts || !nummarktris)
1285 // make sure shadowelements is big enough for this volume
1286 if (maxshadowtriangles < nummarktris*8 || maxshadowvertices < numverts*2)
1287 R_Shadow_ResizeShadowArrays(numverts, nummarktris, 2, 8);
1289 if (maxvertexupdate < numverts)
1291 maxvertexupdate = numverts;
1293 Mem_Free(vertexupdate);
1295 Mem_Free(vertexremap);
1296 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1297 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1298 vertexupdatenum = 0;
1301 if (vertexupdatenum == 0)
1303 vertexupdatenum = 1;
1304 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
1305 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
1308 for (i = 0;i < nummarktris;i++)
1309 shadowmark[marktris[i]] = shadowmarkcount;
1311 if (r_shadow_compilingrtlight)
1313 // if we're compiling an rtlight, capture the mesh
1314 //tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1315 //Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1316 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1317 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1319 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
1321 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1322 R_Mesh_VertexPointer(shadowvertex3f, 0, 0);
1323 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1327 // decide which type of shadow to generate and set stencil mode
1328 R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
1329 // generate the sides or a solid volume, depending on type
1330 if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
1331 tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1333 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1334 r_refdef.stats.lights_dynamicshadowtriangles += tris;
1335 r_refdef.stats.lights_shadowtriangles += tris;
1337 R_Mesh_VertexPointer(shadowvertex3f, 0, 0);
1338 GL_LockArrays(0, outverts);
1339 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
1341 // increment stencil if frontface is infront of depthbuffer
1342 GL_CullFace(r_refdef.view.cullface_front);
1343 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
1344 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1345 // decrement stencil if backface is infront of depthbuffer
1346 GL_CullFace(r_refdef.view.cullface_back);
1347 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
1349 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
1351 // decrement stencil if backface is behind depthbuffer
1352 GL_CullFace(r_refdef.view.cullface_front);
1353 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
1354 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1355 // increment stencil if frontface is behind depthbuffer
1356 GL_CullFace(r_refdef.view.cullface_back);
1357 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
1359 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1360 GL_LockArrays(0, 0);
1365 int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
1367 // p1, p2, p3 are in the cubemap's local coordinate system
1368 // bias = border/(size - border)
1371 float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1372 dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
1373 dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
1374 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1376 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1377 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1378 | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1379 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1381 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1382 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1383 | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1385 dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1386 dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
1387 dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
1388 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1390 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1391 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1392 | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1393 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1395 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1396 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1397 | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1399 dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1400 dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
1401 dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
1402 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1404 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1405 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1406 | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1407 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1409 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1410 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1411 | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1416 int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
1418 vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
1419 float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
1422 VectorSubtract(maxs, mins, radius);
1423 VectorScale(radius, 0.5f, radius);
1424 VectorAdd(mins, radius, center);
1425 Matrix4x4_Transform(worldtolight, center, lightcenter);
1426 Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
1427 VectorSubtract(lightcenter, lightradius, pmin);
1428 VectorAdd(lightcenter, lightradius, pmax);
1430 dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1431 dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
1432 if(ap1 > bias*an1 && ap2 > bias*an2)
1434 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1435 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1436 if(an1 > bias*ap1 && an2 > bias*ap2)
1438 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1439 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1441 dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1442 dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
1443 if(ap1 > bias*an1 && ap2 > bias*an2)
1445 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1446 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1447 if(an1 > bias*ap1 && an2 > bias*ap2)
1449 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1450 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1452 dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1453 dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
1454 if(ap1 > bias*an1 && ap2 > bias*an2)
1456 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1457 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1458 if(an1 > bias*ap1 && an2 > bias*ap2)
1460 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1461 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1466 #define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
1468 int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
1470 // p is in the cubemap's local coordinate system
1471 // bias = border/(size - border)
1472 float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
1473 float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
1474 float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
1476 if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
1477 if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
1478 if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
1479 if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
1480 if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
1481 if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
1485 int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
1489 int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
1490 float scale = (size - 2*border)/size, len;
1491 float bias = border / (float)(size - border), dp, dn, ap, an;
1492 // check if cone enclosing side would cross frustum plane
1493 scale = 2 / (scale*scale + 2);
1494 for (i = 0;i < 5;i++)
1496 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) > -0.03125)
1498 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
1499 len = scale*VectorLength2(n);
1500 if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
1501 if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
1502 if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
1504 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
1506 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
1507 len = scale*VectorLength(n);
1508 if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
1509 if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
1510 if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
1512 // this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
1513 // check if frustum corners/origin cross plane sides
1514 for (i = 0;i < 5;i++)
1516 Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
1517 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn),
1518 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1519 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1520 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn),
1521 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1522 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1523 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn),
1524 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1525 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1527 return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
1530 int R_Shadow_ChooseSidesFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const matrix4x4_t *worldtolight, const vec3_t projectorigin, const vec3_t projectdirection, const vec3_t lightmins, const vec3_t lightmaxs, const vec3_t surfacemins, const vec3_t surfacemaxs, int *totals)
1538 int mask, surfacemask = 0;
1539 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1541 bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
1542 tend = firsttriangle + numtris;
1543 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1545 // surface box entirely inside light box, no box cull
1546 if (projectdirection)
1548 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1550 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1551 TriangleNormal(v[0], v[1], v[2], normal);
1552 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1554 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1555 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1556 surfacemask |= mask;
1559 totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
1560 shadowsides[numshadowsides] = mask;
1561 shadowsideslist[numshadowsides++] = t;
1568 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1570 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1571 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
1573 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1574 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1575 surfacemask |= mask;
1578 totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
1579 shadowsides[numshadowsides] = mask;
1580 shadowsideslist[numshadowsides++] = t;
1588 // surface box not entirely inside light box, cull each triangle
1589 if (projectdirection)
1591 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1593 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1594 TriangleNormal(v[0], v[1], v[2], normal);
1595 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1596 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1598 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1599 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1600 surfacemask |= mask;
1603 totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
1604 shadowsides[numshadowsides] = mask;
1605 shadowsideslist[numshadowsides++] = t;
1612 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1614 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1615 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1616 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1618 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1619 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1620 surfacemask |= mask;
1623 totals[0] += mask&1, totals[1] += (mask>>1)&1, totals[2] += (mask>>2)&1, totals[3] += (mask>>3)&1, totals[4] += (mask>>4)&1, totals[5] += mask>>5;
1624 shadowsides[numshadowsides] = mask;
1625 shadowsideslist[numshadowsides++] = t;
1634 void R_Shadow_ShadowMapFromList(int numverts, int numtris, const float *vertex3f, const int *elements, int numsidetris, const int *sidetotals, const unsigned char *sides, const int *sidetris)
1636 int i, j, outtriangles = 0;
1637 int *outelement3i[6];
1638 if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
1640 outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
1641 // make sure shadowelements is big enough for this mesh
1642 if (maxshadowtriangles < outtriangles)
1643 R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
1645 // compute the offset and size of the separate index lists for each cubemap side
1647 for (i = 0;i < 6;i++)
1649 outelement3i[i] = shadowelements + outtriangles * 3;
1650 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
1651 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
1652 outtriangles += sidetotals[i];
1655 // gather up the (sparse) triangles into separate index lists for each cubemap side
1656 for (i = 0;i < numsidetris;i++)
1658 const int *element = elements + sidetris[i] * 3;
1659 for (j = 0;j < 6;j++)
1661 if (sides[i] & (1 << j))
1663 outelement3i[j][0] = element[0];
1664 outelement3i[j][1] = element[1];
1665 outelement3i[j][2] = element[2];
1666 outelement3i[j] += 3;
1671 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, outtriangles, shadowelements);
1674 static void R_Shadow_MakeTextures_MakeCorona(void)
1678 unsigned char pixels[32][32][4];
1679 for (y = 0;y < 32;y++)
1681 dy = (y - 15.5f) * (1.0f / 16.0f);
1682 for (x = 0;x < 32;x++)
1684 dx = (x - 15.5f) * (1.0f / 16.0f);
1685 a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1686 a = bound(0, a, 255);
1687 pixels[y][x][0] = a;
1688 pixels[y][x][1] = a;
1689 pixels[y][x][2] = a;
1690 pixels[y][x][3] = 255;
1693 r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_PRECACHE | TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32);
1696 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1698 float dist = sqrt(x*x+y*y+z*z);
1699 float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1700 // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1701 return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1704 static void R_Shadow_MakeTextures(void)
1707 float intensity, dist;
1709 R_Shadow_FreeShadowMaps();
1710 R_FreeTexturePool(&r_shadow_texturepool);
1711 r_shadow_texturepool = R_AllocTexturePool();
1712 r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1713 r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1714 data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1715 // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1716 for (x = 0;x <= ATTENTABLESIZE;x++)
1718 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1719 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1720 r_shadow_attentable[x] = bound(0, intensity, 1);
1722 // 1D gradient texture
1723 for (x = 0;x < ATTEN1DSIZE;x++)
1724 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1725 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);
1726 // 2D circle texture
1727 for (y = 0;y < ATTEN2DSIZE;y++)
1728 for (x = 0;x < ATTEN2DSIZE;x++)
1729 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);
1730 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);
1731 // 3D sphere texture
1732 if (r_shadow_texture3d.integer && vid.support.ext_texture_3d)
1734 for (z = 0;z < ATTEN3DSIZE;z++)
1735 for (y = 0;y < ATTEN3DSIZE;y++)
1736 for (x = 0;x < ATTEN3DSIZE;x++)
1737 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));
1738 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);
1741 r_shadow_attenuation3dtexture = NULL;
1744 R_Shadow_MakeTextures_MakeCorona();
1746 // Editor light sprites
1747 r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1764 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1765 r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1782 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1783 r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1800 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1801 r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1818 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1819 r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1836 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1837 r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
1854 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1857 void R_Shadow_ValidateCvars(void)
1859 if (r_shadow_texture3d.integer && !vid.support.ext_texture_3d)
1860 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
1861 if (gl_ext_separatestencil.integer && !vid.support.ati_separate_stencil)
1862 Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
1863 if (gl_ext_stenciltwoside.integer && !vid.support.ext_stencil_two_side)
1864 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
1867 void R_Shadow_RenderMode_Begin(void)
1873 R_Shadow_ValidateCvars();
1875 if (!r_shadow_attenuation2dtexture
1876 || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
1877 || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1878 || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1879 R_Shadow_MakeTextures();
1882 R_Mesh_ColorPointer(NULL, 0, 0);
1883 R_Mesh_ResetTextureState();
1884 GL_BlendFunc(GL_ONE, GL_ZERO);
1885 GL_DepthRange(0, 1);
1886 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1888 GL_DepthMask(false);
1889 GL_Color(0, 0, 0, 1);
1890 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
1892 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1894 if (gl_ext_separatestencil.integer && vid.support.ati_separate_stencil)
1896 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
1897 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
1899 else if (gl_ext_stenciltwoside.integer && vid.support.ext_stencil_two_side)
1901 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
1902 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
1906 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
1907 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
1910 switch(vid.renderpath)
1912 case RENDERPATH_GL20:
1913 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1915 case RENDERPATH_GL13:
1916 case RENDERPATH_GL11:
1917 if (r_textureunits.integer >= 2 && vid.texunits >= 2 && r_shadow_texture3d.integer && r_shadow_attenuation3dtexture)
1918 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN;
1919 else if (r_textureunits.integer >= 3 && vid.texunits >= 3)
1920 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN;
1921 else if (r_textureunits.integer >= 2 && vid.texunits >= 2)
1922 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN;
1924 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
1930 qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
1931 qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
1932 r_shadow_drawbuffer = drawbuffer;
1933 r_shadow_readbuffer = readbuffer;
1935 r_shadow_cullface_front = r_refdef.view.cullface_front;
1936 r_shadow_cullface_back = r_refdef.view.cullface_back;
1939 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
1941 rsurface.rtlight = rtlight;
1944 void R_Shadow_RenderMode_Reset(void)
1947 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE || r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE)
1949 qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
1951 if (vid.support.ext_framebuffer_object)
1953 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
1956 qglDrawBuffer(r_shadow_drawbuffer);CHECKGLERROR
1957 qglReadBuffer(r_shadow_readbuffer);CHECKGLERROR
1959 R_SetViewport(&r_refdef.view.viewport);
1960 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
1961 R_Mesh_ColorPointer(NULL, 0, 0);
1962 R_Mesh_ResetTextureState();
1963 GL_DepthRange(0, 1);
1965 GL_DepthMask(false);
1966 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1967 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1968 qglDisable(GL_STENCIL_TEST);CHECKGLERROR
1969 qglStencilMask(~0);CHECKGLERROR
1970 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
1971 qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
1972 r_refdef.view.cullface_front = r_shadow_cullface_front;
1973 r_refdef.view.cullface_back = r_shadow_cullface_back;
1974 GL_CullFace(r_refdef.view.cullface_back);
1975 GL_Color(1, 1, 1, 1);
1976 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
1977 GL_BlendFunc(GL_ONE, GL_ZERO);
1978 R_SetupGenericShader(false);
1979 r_shadow_usingshadowmaprect = false;
1980 r_shadow_usingshadowmapcube = false;
1981 r_shadow_usingshadowmap2d = false;
1985 void R_Shadow_ClearStencil(void)
1988 GL_Clear(GL_STENCIL_BUFFER_BIT);
1989 r_refdef.stats.lights_clears++;
1992 void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
1994 r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
1995 if (r_shadow_rendermode == mode)
1998 R_Shadow_RenderMode_Reset();
1999 GL_ColorMask(0, 0, 0, 0);
2000 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2001 R_SetupDepthOrShadowShader();
2002 qglDepthFunc(GL_LESS);CHECKGLERROR
2003 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2004 r_shadow_rendermode = mode;
2009 case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
2010 GL_CullFace(GL_NONE);
2011 qglStencilOpSeparate(r_refdef.view.cullface_front, GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
2012 qglStencilOpSeparate(r_refdef.view.cullface_back, GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
2014 case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
2015 GL_CullFace(GL_NONE);
2016 qglStencilOpSeparate(r_refdef.view.cullface_front, GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
2017 qglStencilOpSeparate(r_refdef.view.cullface_back, GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
2019 case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
2020 GL_CullFace(GL_NONE);
2021 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2022 qglActiveStencilFaceEXT(r_refdef.view.cullface_front);CHECKGLERROR
2023 qglStencilMask(~0);CHECKGLERROR
2024 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
2025 qglActiveStencilFaceEXT(r_refdef.view.cullface_back);CHECKGLERROR
2026 qglStencilMask(~0);CHECKGLERROR
2027 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
2029 case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
2030 GL_CullFace(GL_NONE);
2031 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2032 qglActiveStencilFaceEXT(r_refdef.view.cullface_front);CHECKGLERROR
2033 qglStencilMask(~0);CHECKGLERROR
2034 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
2035 qglActiveStencilFaceEXT(r_refdef.view.cullface_back);CHECKGLERROR
2036 qglStencilMask(~0);CHECKGLERROR
2037 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
2042 static void R_Shadow_MakeVSDCT(void)
2044 // maps to a 2x3 texture rectangle with normalized coordinates
2049 // stores abs(dir.xy), offset.xy/2.5
2050 unsigned char data[4*6] =
2052 255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
2053 255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
2054 0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
2055 0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
2056 0, 0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
2057 0, 0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
2059 r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_ALWAYSPRECACHE | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, NULL);
2062 void R_Shadow_RenderMode_ShadowMap(int side, qboolean clear, int size)
2066 float nearclip, farclip, bias;
2067 r_viewport_t viewport;
2070 maxsize = r_shadow_shadowmapmaxsize;
2071 nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
2073 bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
2074 r_shadow_shadowmap_parameters[2] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
2075 r_shadow_shadowmap_parameters[3] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
2076 r_shadow_shadowmapside = side;
2077 r_shadow_shadowmapsize = size;
2078 if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
2080 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2081 r_shadow_shadowmap_parameters[1] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2082 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2083 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
2085 // complex unrolled cube approach (more flexible)
2086 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2087 R_Shadow_MakeVSDCT();
2088 if (!r_shadow_shadowmap2dtexture)
2091 int w = maxsize*2, h = vid.support.arb_texture_non_power_of_two ? maxsize*3 : maxsize*4;
2092 r_shadow_shadowmap2dtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", w, h, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2093 qglGenFramebuffersEXT(1, &r_shadow_fbo2d);CHECKGLERROR
2094 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fbo2d);CHECKGLERROR
2095 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, R_GetTexture(r_shadow_shadowmap2dtexture), 0);CHECKGLERROR
2096 // render depth into the fbo, do not render color at all
2097 qglDrawBuffer(GL_NONE);CHECKGLERROR
2098 qglReadBuffer(GL_NONE);CHECKGLERROR
2099 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2100 if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2102 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2103 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2104 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2109 if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d;
2110 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
2111 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
2112 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2114 else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE)
2116 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2117 r_shadow_shadowmap_parameters[1] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2118 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2119 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE) goto init_done;
2121 // complex unrolled cube approach (more flexible)
2122 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2123 R_Shadow_MakeVSDCT();
2124 if (!r_shadow_shadowmaprectangletexture)
2127 r_shadow_shadowmaprectangletexture = R_LoadTextureShadowMapRectangle(r_shadow_texturepool, "shadowmap", maxsize*2, maxsize*3, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2128 qglGenFramebuffersEXT(1, &r_shadow_fborectangle);CHECKGLERROR
2129 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fborectangle);CHECKGLERROR
2130 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_shadowmaprectangletexture), 0);CHECKGLERROR
2131 // render depth into the fbo, do not render color at all
2132 qglDrawBuffer(GL_NONE);CHECKGLERROR
2133 qglReadBuffer(GL_NONE);CHECKGLERROR
2134 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2135 if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2137 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2138 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2139 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2144 if(r_shadow_shadowmaprectangletexture) fbo = r_shadow_fborectangle;
2145 r_shadow_shadowmap_texturescale[0] = 1.0f;
2146 r_shadow_shadowmap_texturescale[1] = 1.0f;
2147 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE;
2149 else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
2151 r_shadow_shadowmap_parameters[0] = 1.0f;
2152 r_shadow_shadowmap_parameters[1] = 1.0f;
2153 R_Viewport_InitCubeSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, nearclip, farclip, NULL);
2154 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE) goto init_done;
2156 // simple cube approach
2157 if (!r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod])
2160 r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod] = R_LoadTextureShadowMapCube(r_shadow_texturepool, "shadowmapcube", size, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2161 qglGenFramebuffersEXT(1, &r_shadow_fbocubeside[r_shadow_shadowmaplod]);CHECKGLERROR
2162 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fbocubeside[r_shadow_shadowmaplod]);CHECKGLERROR
2163 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + side, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);CHECKGLERROR
2164 // render depth into the fbo, do not render color at all
2165 qglDrawBuffer(GL_NONE);CHECKGLERROR
2166 qglReadBuffer(GL_NONE);CHECKGLERROR
2167 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2168 if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2170 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2171 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2172 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2177 if (r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]) fbo = r_shadow_fbocubeside[r_shadow_shadowmaplod];
2178 r_shadow_shadowmap_texturescale[0] = 0.0f;
2179 r_shadow_shadowmap_texturescale[1] = 0.0f;
2180 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE;
2183 R_Shadow_RenderMode_Reset();
2186 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);CHECKGLERROR
2187 R_SetupDepthOrShadowShader();
2191 R_SetupShowDepthShader();
2192 qglClearColor(1,1,1,1);CHECKGLERROR
2195 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2202 R_SetViewport(&viewport);
2203 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2204 if(r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE)
2206 int flipped = (side&1)^(side>>2);
2207 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2208 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2209 GL_CullFace(r_refdef.view.cullface_back);
2211 else if(r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE)
2213 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + side, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);CHECKGLERROR
2216 qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
2220 void R_Shadow_RenderMode_SetShadowMapTexture(void)
2222 if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
2224 r_shadow_usingshadowmap2d = true;
2225 R_Mesh_TexBind(GL20TU_SHADOWMAP2D, R_GetTexture(r_shadow_shadowmap2dtexture));
2228 else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE)
2230 r_shadow_usingshadowmaprect = true;
2231 R_Mesh_TexBindAll(GL20TU_SHADOWMAPRECT, 0, 0, 0, R_GetTexture(r_shadow_shadowmaprectangletexture));
2234 else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
2236 r_shadow_usingshadowmapcube = true;
2237 R_Mesh_TexBindAll(GL20TU_SHADOWMAPCUBE, 0, 0, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);
2241 if (r_shadow_shadowmapvsdct && (r_shadow_usingshadowmap2d || r_shadow_usingshadowmaprect))
2243 R_Mesh_TexBindAll(GL20TU_CUBEPROJECTION, 0, 0, R_GetTexture(r_shadow_shadowmapvsdcttexture), 0);
2248 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2252 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2253 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2254 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2255 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2258 R_Shadow_RenderMode_Reset();
2259 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2262 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2266 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2267 // only draw light where this geometry was already rendered AND the
2268 // stencil is 128 (values other than this mean shadow)
2269 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2271 r_shadow_rendermode = r_shadow_lightingrendermode;
2272 // do global setup needed for the chosen lighting mode
2273 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2275 R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0); // light filter
2276 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2279 R_Shadow_RenderMode_SetShadowMapTexture();
2281 R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
2285 static const unsigned short bboxelements[36] =
2295 static const float bboxpoints[8][3] =
2307 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2310 float vertex3f[8*3];
2311 const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2313 R_Shadow_RenderMode_Reset();
2314 r_shadow_rendermode = r_shadow_lightingrendermode;
2315 // do global setup needed for the chosen lighting mode
2316 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2318 R_Mesh_Matrix(&identitymatrix);
2319 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2322 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2323 // only draw light where this geometry was already rendered AND the
2324 // stencil is 128 (values other than this mean shadow)
2325 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2327 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
2328 R_Mesh_TexBindAll(GL20TU_SCREENDEPTH, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrydepthtexture));
2329 R_Mesh_TexBindAll(GL20TU_SCREENNORMALMAP, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture));
2330 R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0); // light filter
2332 R_Shadow_RenderMode_SetShadowMapTexture();
2333 R_SetupDeferredLightShader(rsurface.rtlight);
2334 //R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
2335 R_Mesh_TexBind(GL20TU_ATTENUATION, R_GetTexture(r_shadow_attenuationgradienttexture));
2337 for (i = 0;i < 8;i++)
2338 Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2340 //qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
2341 R_Mesh_VertexPointer(vertex3f, 0, 0);
2342 R_Mesh_ColorPointer(NULL, 0, 0);
2343 GL_ColorMask(1,1,1,1);
2344 //GL_Color(0.25f,0.05f,0.02f,1.0f);
2345 //R_SetupGenericShader(false);
2346 GL_DepthMask(false);
2347 GL_DepthRange(0, 1);
2348 GL_PolygonOffset(0, 0);
2350 qglDepthFunc(GL_GREATER);CHECKGLERROR
2351 GL_CullFace(r_refdef.view.cullface_back);
2352 //GL_AlphaTest(false);
2353 //qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2354 R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
2358 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2361 R_Shadow_RenderMode_Reset();
2362 GL_BlendFunc(GL_ONE, GL_ONE);
2363 GL_DepthRange(0, 1);
2364 GL_DepthTest(r_showshadowvolumes.integer < 2);
2365 GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2366 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2367 GL_CullFace(GL_NONE);
2368 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2371 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2374 R_Shadow_RenderMode_Reset();
2375 GL_BlendFunc(GL_ONE, GL_ONE);
2376 GL_DepthRange(0, 1);
2377 GL_DepthTest(r_showlighting.integer < 2);
2378 GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2381 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2385 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2386 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2388 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2391 void R_Shadow_RenderMode_End(void)
2394 R_Shadow_RenderMode_Reset();
2395 R_Shadow_RenderMode_ActiveLight(NULL);
2397 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2398 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2401 int bboxedges[12][2] =
2420 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2422 int i, ix1, iy1, ix2, iy2;
2423 float x1, y1, x2, y2;
2425 float vertex[20][3];
2434 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2435 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2436 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2437 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2439 if (!r_shadow_scissor.integer)
2442 // if view is inside the light box, just say yes it's visible
2443 if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs))
2446 x1 = y1 = x2 = y2 = 0;
2448 // transform all corners that are infront of the nearclip plane
2449 VectorNegate(r_refdef.view.frustum[4].normal, plane4f);
2450 plane4f[3] = r_refdef.view.frustum[4].dist;
2452 for (i = 0;i < 8;i++)
2454 Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1);
2455 dist[i] = DotProduct4(corner[i], plane4f);
2456 sign[i] = dist[i] > 0;
2459 VectorCopy(corner[i], vertex[numvertices]);
2463 // if some points are behind the nearclip, add clipped edge points to make
2464 // sure that the scissor boundary is complete
2465 if (numvertices > 0 && numvertices < 8)
2467 // add clipped edge points
2468 for (i = 0;i < 12;i++)
2470 j = bboxedges[i][0];
2471 k = bboxedges[i][1];
2472 if (sign[j] != sign[k])
2474 f = dist[j] / (dist[j] - dist[k]);
2475 VectorLerp(corner[j], f, corner[k], vertex[numvertices]);
2481 // if we have no points to check, the light is behind the view plane
2485 // if we have some points to transform, check what screen area is covered
2486 x1 = y1 = x2 = y2 = 0;
2488 //Con_Printf("%i vertices to transform...\n", numvertices);
2489 for (i = 0;i < numvertices;i++)
2491 VectorCopy(vertex[i], v);
2492 R_Viewport_TransformToScreen(&r_refdef.view.viewport, v, v2);
2493 //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]);
2496 if (x1 > v2[0]) x1 = v2[0];
2497 if (x2 < v2[0]) x2 = v2[0];
2498 if (y1 > v2[1]) y1 = v2[1];
2499 if (y2 < v2[1]) y2 = v2[1];
2508 // now convert the scissor rectangle to integer screen coordinates
2509 ix1 = (int)(x1 - 1.0f);
2510 iy1 = vid.height - (int)(y2 - 1.0f);
2511 ix2 = (int)(x2 + 1.0f);
2512 iy2 = vid.height - (int)(y1 + 1.0f);
2513 //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
2515 // clamp it to the screen
2516 if (ix1 < r_refdef.view.viewport.x) ix1 = r_refdef.view.viewport.x;
2517 if (iy1 < r_refdef.view.viewport.y) iy1 = r_refdef.view.viewport.y;
2518 if (ix2 > r_refdef.view.viewport.x + r_refdef.view.viewport.width) ix2 = r_refdef.view.viewport.x + r_refdef.view.viewport.width;
2519 if (iy2 > r_refdef.view.viewport.y + r_refdef.view.viewport.height) iy2 = r_refdef.view.viewport.y + r_refdef.view.viewport.height;
2521 // if it is inside out, it's not visible
2522 if (ix2 <= ix1 || iy2 <= iy1)
2525 // the light area is visible, set up the scissor rectangle
2526 r_shadow_lightscissor[0] = ix1;
2527 r_shadow_lightscissor[1] = iy1;
2528 r_shadow_lightscissor[2] = ix2 - ix1;
2529 r_shadow_lightscissor[3] = iy2 - iy1;
2531 r_refdef.stats.lights_scissored++;
2535 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, int numtriangles, const int *element3i, const float *diffusecolor, const float *ambientcolor)
2537 const float *vertex3f = rsurface.vertex3f + 3 * firstvertex;
2538 const float *normal3f = rsurface.normal3f + 3 * firstvertex;
2539 float *color4f = rsurface.array_color4f + 4 * firstvertex;
2540 float dist, dot, distintensity, shadeintensity, v[3], n[3];
2541 switch (r_shadow_rendermode)
2543 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2544 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2545 if (VectorLength2(diffusecolor) > 0)
2547 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2549 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2550 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2551 if ((dot = DotProduct(n, v)) < 0)
2553 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2554 VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
2557 VectorCopy(ambientcolor, color4f);
2558 if (r_refdef.fogenabled)
2561 f = RSurf_FogVertex(vertex3f);
2562 VectorScale(color4f, f, color4f);
2569 for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2571 VectorCopy(ambientcolor, color4f);
2572 if (r_refdef.fogenabled)
2575 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2576 f = RSurf_FogVertex(vertex3f);
2577 VectorScale(color4f, f, color4f);
2583 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2584 if (VectorLength2(diffusecolor) > 0)
2586 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2588 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2589 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2591 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2592 if ((dot = DotProduct(n, v)) < 0)
2594 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2595 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
2596 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
2597 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
2601 color4f[0] = ambientcolor[0] * distintensity;
2602 color4f[1] = ambientcolor[1] * distintensity;
2603 color4f[2] = ambientcolor[2] * distintensity;
2605 if (r_refdef.fogenabled)
2608 f = RSurf_FogVertex(vertex3f);
2609 VectorScale(color4f, f, color4f);
2613 VectorClear(color4f);
2619 for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2621 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2622 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2624 color4f[0] = ambientcolor[0] * distintensity;
2625 color4f[1] = ambientcolor[1] * distintensity;
2626 color4f[2] = ambientcolor[2] * distintensity;
2627 if (r_refdef.fogenabled)
2630 f = RSurf_FogVertex(vertex3f);
2631 VectorScale(color4f, f, color4f);
2635 VectorClear(color4f);
2640 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2641 if (VectorLength2(diffusecolor) > 0)
2643 for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2645 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2646 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2648 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
2649 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2650 if ((dot = DotProduct(n, v)) < 0)
2652 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2653 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
2654 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
2655 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
2659 color4f[0] = ambientcolor[0] * distintensity;
2660 color4f[1] = ambientcolor[1] * distintensity;
2661 color4f[2] = ambientcolor[2] * distintensity;
2663 if (r_refdef.fogenabled)
2666 f = RSurf_FogVertex(vertex3f);
2667 VectorScale(color4f, f, color4f);
2671 VectorClear(color4f);
2677 for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2679 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2680 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2682 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
2683 color4f[0] = ambientcolor[0] * distintensity;
2684 color4f[1] = ambientcolor[1] * distintensity;
2685 color4f[2] = ambientcolor[2] * distintensity;
2686 if (r_refdef.fogenabled)
2689 f = RSurf_FogVertex(vertex3f);
2690 VectorScale(color4f, f, color4f);
2694 VectorClear(color4f);
2704 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)
2706 // used to display how many times a surface is lit for level design purposes
2707 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2710 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 lightcolor, float ambientscale, float diffusescale, float specularscale)
2712 // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
2713 R_SetupSurfaceShader(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT);
2714 if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
2715 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
2717 R_Mesh_ColorPointer(NULL, 0, 0);
2718 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
2719 R_Mesh_TexMatrix(1, &rsurface.texture->currentbackgroundtexmatrix);
2720 R_Mesh_TexBind(GL20TU_NORMAL, R_GetTexture(rsurface.texture->currentskinframe->nmap));
2721 R_Mesh_TexBind(GL20TU_COLOR, R_GetTexture(rsurface.texture->basetexture));
2722 R_Mesh_TexBind(GL20TU_GLOSS, R_GetTexture(rsurface.texture->glosstexture));
2723 if (rsurface.texture->backgroundcurrentskinframe)
2725 R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->nmap));
2726 R_Mesh_TexBind(GL20TU_SECONDARY_COLOR, R_GetTexture(rsurface.texture->backgroundbasetexture));
2727 R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS, R_GetTexture(rsurface.texture->backgroundglosstexture));
2728 R_Mesh_TexBind(GL20TU_SECONDARY_GLOW, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->glow));
2730 //R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0);
2731 R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
2732 if(rsurface.texture->colormapping)
2734 R_Mesh_TexBind(GL20TU_PANTS, R_GetTexture(rsurface.texture->currentskinframe->pants));
2735 R_Mesh_TexBind(GL20TU_SHIRT, R_GetTexture(rsurface.texture->currentskinframe->shirt));
2737 R_Mesh_TexBind(GL20TU_ATTENUATION, R_GetTexture(r_shadow_attenuationgradienttexture));
2738 R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
2739 R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
2740 R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
2741 R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
2742 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
2744 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2746 R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2747 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
2749 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2753 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
2760 int newnumtriangles;
2764 int maxtriangles = 4096;
2765 static int newelements[4096*3];
2766 R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, numtriangles, element3i, diffusecolor2, ambientcolor2);
2767 for (renders = 0;renders < 64;renders++)
2772 newnumtriangles = 0;
2774 // due to low fillrate on the cards this vertex lighting path is
2775 // designed for, we manually cull all triangles that do not
2776 // contain a lit vertex
2777 // this builds batches of triangles from multiple surfaces and
2778 // renders them at once
2779 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
2781 if (VectorLength2(rsurface.array_color4f + e[0] * 4) + VectorLength2(rsurface.array_color4f + e[1] * 4) + VectorLength2(rsurface.array_color4f + e[2] * 4) >= 0.01)
2783 if (newnumtriangles)
2785 newfirstvertex = min(newfirstvertex, e[0]);
2786 newlastvertex = max(newlastvertex, e[0]);
2790 newfirstvertex = e[0];
2791 newlastvertex = e[0];
2793 newfirstvertex = min(newfirstvertex, e[1]);
2794 newlastvertex = max(newlastvertex, e[1]);
2795 newfirstvertex = min(newfirstvertex, e[2]);
2796 newlastvertex = max(newlastvertex, e[2]);
2802 if (newnumtriangles >= maxtriangles)
2804 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2805 newnumtriangles = 0;
2811 if (newnumtriangles >= 1)
2813 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2816 // if we couldn't find any lit triangles, exit early
2819 // now reduce the intensity for the next overbright pass
2820 // we have to clamp to 0 here incase the drivers have improper
2821 // handling of negative colors
2822 // (some old drivers even have improper handling of >1 color)
2824 for (i = 0, c = rsurface.array_color4f + 4 * firstvertex;i < numvertices;i++, c += 4)
2826 if (c[0] > 1 || c[1] > 1 || c[2] > 1)
2828 c[0] = max(0, c[0] - 1);
2829 c[1] = max(0, c[1] - 1);
2830 c[2] = max(0, c[2] - 1);
2842 static void R_Shadow_RenderLighting_Light_Vertex(int firstvertex, int numvertices, int numtriangles, const int *element3i, const vec3_t lightcolor, float ambientscale, float diffusescale)
2844 // OpenGL 1.1 path (anything)
2845 float ambientcolorbase[3], diffusecolorbase[3];
2846 float ambientcolorpants[3], diffusecolorpants[3];
2847 float ambientcolorshirt[3], diffusecolorshirt[3];
2848 const float *surfacecolor = rsurface.texture->dlightcolor;
2849 const float *surfacepants = rsurface.colormap_pantscolor;
2850 const float *surfaceshirt = rsurface.colormap_shirtcolor;
2851 rtexture_t *basetexture = rsurface.texture->basetexture;
2852 rtexture_t *pantstexture = rsurface.texture->currentskinframe->pants;
2853 rtexture_t *shirttexture = rsurface.texture->currentskinframe->shirt;
2854 qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
2855 qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
2857 ambientscale *= 2 * r_refdef.view.colorscale;
2858 diffusescale *= 2 * r_refdef.view.colorscale;
2859 ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
2860 diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
2861 ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
2862 diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
2863 ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
2864 diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
2865 switch(r_shadow_rendermode)
2867 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2868 memset(&m, 0, sizeof(m));
2869 m.tex[0] = R_GetTexture(basetexture);
2870 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2871 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2872 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2873 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2874 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
2875 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2876 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2877 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2878 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2879 R_Mesh_TextureState(&m);
2881 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2882 memset(&m, 0, sizeof(m));
2883 m.tex[0] = R_GetTexture(basetexture);
2884 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2885 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2886 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2887 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2888 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2889 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2890 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2891 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2892 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2893 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
2894 m.texmatrix[2] = rsurface.entitytoattenuationz;
2895 m.pointer_texcoord3f[2] = rsurface.vertex3f;
2896 m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
2897 m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
2898 R_Mesh_TextureState(&m);
2900 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2901 memset(&m, 0, sizeof(m));
2902 m.tex[0] = R_GetTexture(basetexture);
2903 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2904 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2905 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2906 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2907 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2908 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2909 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2910 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2911 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2912 R_Mesh_TextureState(&m);
2914 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2915 memset(&m, 0, sizeof(m));
2916 m.tex[0] = R_GetTexture(basetexture);
2917 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2918 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2919 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2920 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2921 R_Mesh_TextureState(&m);
2926 //R_Mesh_TexBind(0, R_GetTexture(basetexture));
2927 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorbase, ambientcolorbase);
2930 R_Mesh_TexBind(0, R_GetTexture(pantstexture));
2931 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorpants, ambientcolorpants);
2935 R_Mesh_TexBind(0, R_GetTexture(shirttexture));
2936 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorshirt, ambientcolorshirt);
2940 extern cvar_t gl_lightmaps;
2941 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)
2943 float ambientscale, diffusescale, specularscale;
2945 float lightcolor[3];
2946 VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
2947 ambientscale = rsurface.rtlight->ambientscale;
2948 diffusescale = rsurface.rtlight->diffusescale;
2949 specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
2950 if (!r_shadow_usenormalmap.integer)
2952 ambientscale += 1.0f * diffusescale;
2956 if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
2958 negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
2961 VectorNegate(lightcolor, lightcolor);
2962 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
2964 RSurf_SetupDepthAndCulling();
2965 switch (r_shadow_rendermode)
2967 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2968 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
2969 R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2971 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2972 R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolor, ambientscale, diffusescale, specularscale);
2974 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2975 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2976 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2977 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2978 R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i + firsttriangle * 3, lightcolor, ambientscale, diffusescale);
2981 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2985 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
2988 void R_RTLight_Update(rtlight_t *rtlight, int isstatic, matrix4x4_t *matrix, vec3_t color, int style, const char *cubemapname, int shadow, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags)
2990 matrix4x4_t tempmatrix = *matrix;
2991 Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
2993 // if this light has been compiled before, free the associated data
2994 R_RTLight_Uncompile(rtlight);
2996 // clear it completely to avoid any lingering data
2997 memset(rtlight, 0, sizeof(*rtlight));
2999 // copy the properties
3000 rtlight->matrix_lighttoworld = tempmatrix;
3001 Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3002 Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3003 rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3004 VectorCopy(color, rtlight->color);
3005 rtlight->cubemapname[0] = 0;
3006 if (cubemapname && cubemapname[0])
3007 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3008 rtlight->shadow = shadow;
3009 rtlight->corona = corona;
3010 rtlight->style = style;
3011 rtlight->isstatic = isstatic;
3012 rtlight->coronasizescale = coronasizescale;
3013 rtlight->ambientscale = ambientscale;
3014 rtlight->diffusescale = diffusescale;
3015 rtlight->specularscale = specularscale;
3016 rtlight->flags = flags;
3018 // compute derived data
3019 //rtlight->cullradius = rtlight->radius;
3020 //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3021 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3022 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3023 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3024 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3025 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3026 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3029 // compiles rtlight geometry
3030 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3031 void R_RTLight_Compile(rtlight_t *rtlight)
3034 int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3035 int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3036 entity_render_t *ent = r_refdef.scene.worldentity;
3037 dp_model_t *model = r_refdef.scene.worldmodel;
3038 unsigned char *data;
3041 // compile the light
3042 rtlight->compiled = true;
3043 rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3044 rtlight->static_numleafs = 0;
3045 rtlight->static_numleafpvsbytes = 0;
3046 rtlight->static_leaflist = NULL;
3047 rtlight->static_leafpvs = NULL;
3048 rtlight->static_numsurfaces = 0;
3049 rtlight->static_surfacelist = NULL;
3050 rtlight->static_shadowmap_receivers = 0x3F;
3051 rtlight->static_shadowmap_casters = 0x3F;
3052 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3053 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3054 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3055 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3056 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3057 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3059 if (model && model->GetLightInfo)
3061 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3062 r_shadow_compilingrtlight = rtlight;
3063 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, 0, NULL);
3064 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3065 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3066 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3067 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3068 rtlight->static_numsurfaces = numsurfaces;
3069 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3070 rtlight->static_numleafs = numleafs;
3071 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3072 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3073 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3074 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3075 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3076 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3077 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3078 if (rtlight->static_numsurfaces)
3079 memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3080 if (rtlight->static_numleafs)
3081 memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3082 if (rtlight->static_numleafpvsbytes)
3083 memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3084 if (rtlight->static_numshadowtrispvsbytes)
3085 memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3086 if (rtlight->static_numlighttrispvsbytes)
3087 memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3088 switch (rtlight->shadowmode)
3090 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3091 case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE:
3092 case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE:
3093 if (model->CompileShadowMap && rtlight->shadow)
3094 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3097 if (model->CompileShadowVolume && rtlight->shadow)
3098 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3101 // now we're done compiling the rtlight
3102 r_shadow_compilingrtlight = NULL;
3106 // use smallest available cullradius - box radius or light radius
3107 //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3108 //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3110 shadowzpasstris = 0;
3111 if (rtlight->static_meshchain_shadow_zpass)
3112 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3113 shadowzpasstris += mesh->numtriangles;
3115 shadowzfailtris = 0;
3116 if (rtlight->static_meshchain_shadow_zfail)
3117 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3118 shadowzfailtris += mesh->numtriangles;
3121 if (rtlight->static_numlighttrispvsbytes)
3122 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3123 if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3127 if (rtlight->static_numlighttrispvsbytes)
3128 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3129 if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3132 if (developer.integer >= 10)
3133 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);
3136 void R_RTLight_Uncompile(rtlight_t *rtlight)
3138 if (rtlight->compiled)
3140 if (rtlight->static_meshchain_shadow_zpass)
3141 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3142 rtlight->static_meshchain_shadow_zpass = NULL;
3143 if (rtlight->static_meshchain_shadow_zfail)
3144 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3145 rtlight->static_meshchain_shadow_zfail = NULL;
3146 if (rtlight->static_meshchain_shadow_shadowmap)
3147 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3148 rtlight->static_meshchain_shadow_shadowmap = NULL;
3149 // these allocations are grouped
3150 if (rtlight->static_surfacelist)
3151 Mem_Free(rtlight->static_surfacelist);
3152 rtlight->static_numleafs = 0;
3153 rtlight->static_numleafpvsbytes = 0;
3154 rtlight->static_leaflist = NULL;
3155 rtlight->static_leafpvs = NULL;
3156 rtlight->static_numsurfaces = 0;
3157 rtlight->static_surfacelist = NULL;
3158 rtlight->static_numshadowtrispvsbytes = 0;
3159 rtlight->static_shadowtrispvs = NULL;
3160 rtlight->static_numlighttrispvsbytes = 0;
3161 rtlight->static_lighttrispvs = NULL;
3162 rtlight->compiled = false;
3166 void R_Shadow_UncompileWorldLights(void)
3170 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3171 for (lightindex = 0;lightindex < range;lightindex++)
3173 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3176 R_RTLight_Uncompile(&light->rtlight);
3180 void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3184 // reset the count of frustum planes
3185 // see rtlight->cached_frustumplanes definition for how much this array
3187 rtlight->cached_numfrustumplanes = 0;
3189 // haven't implemented a culling path for ortho rendering
3190 if (!r_refdef.view.useperspective)
3192 // check if the light is on screen and copy the 4 planes if it is
3193 for (i = 0;i < 4;i++)
3194 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3197 for (i = 0;i < 4;i++)
3198 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3203 // generate a deformed frustum that includes the light origin, this is
3204 // used to cull shadow casting surfaces that can not possibly cast a
3205 // shadow onto the visible light-receiving surfaces, which can be a
3208 // if the light origin is onscreen the result will be 4 planes exactly
3209 // if the light origin is offscreen on only one axis the result will
3210 // be exactly 5 planes (split-side case)
3211 // if the light origin is offscreen on two axes the result will be
3212 // exactly 4 planes (stretched corner case)
3213 for (i = 0;i < 4;i++)
3215 // quickly reject standard frustum planes that put the light
3216 // origin outside the frustum
3217 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3220 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3222 // if all the standard frustum planes were accepted, the light is onscreen
3223 // otherwise we need to generate some more planes below...
3224 if (rtlight->cached_numfrustumplanes < 4)
3226 // at least one of the stock frustum planes failed, so we need to
3227 // create one or two custom planes to enclose the light origin
3228 for (i = 0;i < 4;i++)
3230 // create a plane using the view origin and light origin, and a
3231 // single point from the frustum corner set
3232 TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3233 VectorNormalize(plane.normal);
3234 plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3235 // see if this plane is backwards and flip it if so
3236 for (j = 0;j < 4;j++)
3237 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3241 VectorNegate(plane.normal, plane.normal);
3243 // flipped plane, test again to see if it is now valid
3244 for (j = 0;j < 4;j++)
3245 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3247 // if the plane is still not valid, then it is dividing the
3248 // frustum and has to be rejected
3252 // we have created a valid plane, compute extra info
3253 PlaneClassify(&plane);
3255 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3257 // if we've found 5 frustum planes then we have constructed a
3258 // proper split-side case and do not need to keep searching for
3259 // planes to enclose the light origin
3260 if (rtlight->cached_numfrustumplanes == 5)
3268 for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3270 plane = rtlight->cached_frustumplanes[i];
3271 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));
3276 // now add the light-space box planes if the light box is rotated, as any
3277 // caster outside the oriented light box is irrelevant (even if it passed
3278 // the worldspace light box, which is axial)
3279 if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3281 for (i = 0;i < 6;i++)
3285 v[i >> 1] = (i & 1) ? -1 : 1;
3286 Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3287 VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3288 plane.dist = VectorNormalizeLength(plane.normal);
3289 plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3290 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3296 // add the world-space reduced box planes
3297 for (i = 0;i < 6;i++)
3299 VectorClear(plane.normal);
3300 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3301 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3302 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3311 // reduce all plane distances to tightly fit the rtlight cull box, which
3313 VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3314 VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3315 VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3316 VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3317 VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3318 VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3319 VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3320 VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3321 oldnum = rtlight->cached_numfrustumplanes;
3322 rtlight->cached_numfrustumplanes = 0;
3323 for (j = 0;j < oldnum;j++)
3325 // find the nearest point on the box to this plane
3326 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3327 for (i = 1;i < 8;i++)
3329 dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3330 if (bestdist > dist)
3333 Con_Printf("light %p %splane #%i %f %f %f : %f < %f\n", rtlight, rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125 ? "^2" : "^1", j, rtlight->cached_frustumplanes[j].normal[0], rtlight->cached_frustumplanes[j].normal[1], rtlight->cached_frustumplanes[j].normal[2], rtlight->cached_frustumplanes[j].dist, bestdist);
3334 // if the nearest point is near or behind the plane, we want this
3335 // plane, otherwise the plane is useless as it won't cull anything
3336 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3338 PlaneClassify(&rtlight->cached_frustumplanes[j]);
3339 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3346 void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3350 RSurf_ActiveWorldEntity();
3352 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3355 GL_CullFace(GL_NONE);
3356 mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3357 for (;mesh;mesh = mesh->next)
3359 if (!mesh->sidetotals[r_shadow_shadowmapside])
3361 r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3362 R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
3363 R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3367 else if (r_refdef.scene.worldentity->model)
3368 r_refdef.scene.worldmodel->DrawShadowMap(r_shadow_shadowmapside, r_refdef.scene.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, surfacesides, rsurface.rtlight->cached_cullmins, rsurface.rtlight->cached_cullmaxs);
3370 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3373 void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3375 qboolean zpass = false;
3378 int surfacelistindex;
3379 msurface_t *surface;
3381 RSurf_ActiveWorldEntity();
3383 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3386 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3388 zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3389 R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3391 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3392 for (;mesh;mesh = mesh->next)
3394 r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3395 R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
3396 GL_LockArrays(0, mesh->numverts);
3397 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3399 // increment stencil if frontface is infront of depthbuffer
3400 GL_CullFace(r_refdef.view.cullface_back);
3401 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
3402 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3403 // decrement stencil if backface is infront of depthbuffer
3404 GL_CullFace(r_refdef.view.cullface_front);
3405 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
3407 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3409 // decrement stencil if backface is behind depthbuffer
3410 GL_CullFace(r_refdef.view.cullface_front);
3411 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
3412 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3413 // increment stencil if frontface is behind depthbuffer
3414 GL_CullFace(r_refdef.view.cullface_back);
3415 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
3417 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3418 GL_LockArrays(0, 0);
3422 else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh && r_shadow_culltriangles.integer)
3424 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3425 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3427 surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3428 for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3429 if (CHECKPVSBIT(trispvs, t))
3430 shadowmarklist[numshadowmark++] = t;
3432 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);
3434 else if (numsurfaces)
3435 r_refdef.scene.worldmodel->DrawShadowVolume(r_refdef.scene.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, rsurface.rtlight->cached_cullmins, rsurface.rtlight->cached_cullmaxs);
3437 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3440 void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3442 vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3443 vec_t relativeshadowradius;
3444 RSurf_ActiveModelEntity(ent, false, false, false);
3445 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3446 relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3447 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3448 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3449 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3450 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3451 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3452 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3453 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D)
3455 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3458 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3459 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3462 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3464 // set up properties for rendering light onto this entity
3465 RSurf_ActiveModelEntity(ent, true, true, false);
3466 GL_AlphaTest(false);
3467 Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3468 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3469 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3470 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3471 switch(r_shadow_lightingrendermode)
3473 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3474 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3481 void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3483 if (!r_refdef.scene.worldmodel->DrawLight)
3486 // set up properties for rendering light onto this entity
3487 RSurf_ActiveWorldEntity();
3488 GL_AlphaTest(false);
3489 rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3490 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3491 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3492 VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3493 switch(r_shadow_lightingrendermode)
3495 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3496 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3502 r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, trispvs);
3504 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3507 void R_Shadow_DrawEntityLight(entity_render_t *ent)
3509 dp_model_t *model = ent->model;
3510 if (!model->DrawLight)
3513 R_Shadow_SetupEntityLight(ent);
3515 model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3517 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3520 void R_Shadow_PrepareLight(rtlight_t *rtlight)
3524 int numleafs, numsurfaces;
3525 int *leaflist, *surfacelist;
3526 unsigned char *leafpvs, *shadowtrispvs, *lighttrispvs, *surfacesides;
3527 int numlightentities;
3528 int numlightentities_noselfshadow;
3529 int numshadowentities;
3530 int numshadowentities_noselfshadow;
3531 static entity_render_t *lightentities[MAX_EDICTS];
3532 static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3533 static entity_render_t *shadowentities[MAX_EDICTS];
3534 static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3536 rtlight->draw = false;
3538 // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3539 // skip lights that are basically invisible (color 0 0 0)
3540 if (VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f))
3543 // loading is done before visibility checks because loading should happen
3544 // all at once at the start of a level, not when it stalls gameplay.
3545 // (especially important to benchmarks)
3547 if (rtlight->isstatic && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
3549 if (rtlight->compiled)
3550 R_RTLight_Uncompile(rtlight);
3551 R_RTLight_Compile(rtlight);
3555 rtlight->currentcubemap = rtlight->cubemapname[0] ? R_Shadow_Cubemap(rtlight->cubemapname) : r_texture_whitecube;
3557 // look up the light style value at this time
3558 f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3559 VectorScale(rtlight->color, f, rtlight->currentcolor);
3561 if (rtlight->selected)
3563 f = 2 + sin(realtime * M_PI * 4.0);
3564 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3568 // if lightstyle is currently off, don't draw the light
3569 if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3572 // if the light box is offscreen, skip it
3573 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3576 VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
3577 VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
3579 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3581 if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3583 // compiled light, world available and can receive realtime lighting
3584 // retrieve leaf information
3585 numleafs = rtlight->static_numleafs;
3586 leaflist = rtlight->static_leaflist;
3587 leafpvs = rtlight->static_leafpvs;
3588 numsurfaces = rtlight->static_numsurfaces;
3589 surfacelist = rtlight->static_surfacelist;
3590 surfacesides = NULL;
3591 shadowtrispvs = rtlight->static_shadowtrispvs;
3592 lighttrispvs = rtlight->static_lighttrispvs;
3594 else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
3596 // dynamic light, world available and can receive realtime lighting
3597 // calculate lit surfaces and leafs
3598 r_refdef.scene.worldmodel->GetLightInfo(r_refdef.scene.worldentity, rtlight->shadoworigin, rtlight->radius, rtlight->cached_cullmins, rtlight->cached_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, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes);
3599 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3600 leaflist = r_shadow_buffer_leaflist;
3601 leafpvs = r_shadow_buffer_leafpvs;
3602 surfacelist = r_shadow_buffer_surfacelist;
3603 surfacesides = r_shadow_buffer_surfacesides;
3604 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
3605 lighttrispvs = r_shadow_buffer_lighttrispvs;
3606 // if the reduced leaf bounds are offscreen, skip it
3607 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3618 surfacesides = NULL;
3619 shadowtrispvs = NULL;
3620 lighttrispvs = NULL;
3622 // check if light is illuminating any visible leafs
3625 for (i = 0;i < numleafs;i++)
3626 if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
3632 // make a list of lit entities and shadow casting entities
3633 numlightentities = 0;
3634 numlightentities_noselfshadow = 0;
3635 numshadowentities = 0;
3636 numshadowentities_noselfshadow = 0;
3638 // add dynamic entities that are lit by the light
3639 for (i = 0;i < r_refdef.scene.numentities;i++)
3642 entity_render_t *ent = r_refdef.scene.entities[i];
3644 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3646 // skip the object entirely if it is not within the valid
3647 // shadow-casting region (which includes the lit region)
3648 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
3650 if (!(model = ent->model))
3652 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
3654 // this entity wants to receive light, is visible, and is
3655 // inside the light box
3656 // TODO: check if the surfaces in the model can receive light
3657 // so now check if it's in a leaf seen by the light
3658 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))
3660 if (ent->flags & RENDER_NOSELFSHADOW)
3661 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
3663 lightentities[numlightentities++] = ent;
3664 // since it is lit, it probably also casts a shadow...
3665 // about the VectorDistance2 - light emitting entities should not cast their own shadow
3666 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3667 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3669 // note: exterior models without the RENDER_NOSELFSHADOW
3670 // flag still create a RENDER_NOSELFSHADOW shadow but
3671 // are lit normally, this means that they are
3672 // self-shadowing but do not shadow other
3673 // RENDER_NOSELFSHADOW entities such as the gun
3674 // (very weird, but keeps the player shadow off the gun)
3675 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3676 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3678 shadowentities[numshadowentities++] = ent;
3681 else if (ent->flags & RENDER_SHADOW)
3683 // this entity is not receiving light, but may still need to
3685 // TODO: check if the surfaces in the model can cast shadow
3686 // now check if it is in a leaf seen by the light
3687 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))
3689 // about the VectorDistance2 - light emitting entities should not cast their own shadow
3690 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3691 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3693 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3694 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3696 shadowentities[numshadowentities++] = ent;
3701 // return if there's nothing at all to light
3702 if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
3705 // count this light in the r_speeds
3706 r_refdef.stats.lights++;
3708 // flag it as worth drawing later
3709 rtlight->draw = true;
3711 // cache all the animated entities that cast a shadow but are not visible
3712 for (i = 0;i < numshadowentities;i++)
3713 if (!shadowentities[i]->animcache_vertex3f)
3714 R_AnimCache_GetEntity(shadowentities[i], false, false);
3715 for (i = 0;i < numshadowentities_noselfshadow;i++)
3716 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
3717 R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
3719 // allocate some temporary memory for rendering this light later in the frame
3720 // reusable buffers need to be copied, static data can be used as-is
3721 rtlight->cached_numlightentities = numlightentities;
3722 rtlight->cached_numlightentities_noselfshadow = numlightentities_noselfshadow;
3723 rtlight->cached_numshadowentities = numshadowentities;
3724 rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
3725 rtlight->cached_numsurfaces = numsurfaces;
3726 rtlight->cached_lightentities = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
3727 rtlight->cached_lightentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
3728 rtlight->cached_shadowentities = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
3729 rtlight->cached_shadowentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
3730 if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
3732 rtlight->cached_shadowtrispvs = (unsigned char *)R_FrameData_Store(r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles, shadowtrispvs);
3733 rtlight->cached_lighttrispvs = (unsigned char *)R_FrameData_Store(r_refdef.scene.worldmodel->surfmesh.num_triangles, lighttrispvs);
3734 rtlight->cached_surfacelist = (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
3738 // compiled light data
3739 rtlight->cached_shadowtrispvs = shadowtrispvs;
3740 rtlight->cached_lighttrispvs = lighttrispvs;
3741 rtlight->cached_surfacelist = surfacelist;
3745 void R_Shadow_DrawLight(rtlight_t *rtlight)
3749 unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
3750 int numlightentities;
3751 int numlightentities_noselfshadow;
3752 int numshadowentities;
3753 int numshadowentities_noselfshadow;
3754 entity_render_t **lightentities;
3755 entity_render_t **lightentities_noselfshadow;
3756 entity_render_t **shadowentities;
3757 entity_render_t **shadowentities_noselfshadow;
3759 static unsigned char entitysides[MAX_EDICTS];
3760 static unsigned char entitysides_noselfshadow[MAX_EDICTS];
3761 vec3_t nearestpoint;
3763 qboolean castshadows;
3766 // check if we cached this light this frame (meaning it is worth drawing)
3770 // if R_FrameData_Store ran out of space we skip anything dependent on it
3771 if (r_framedata_failed)
3774 numlightentities = rtlight->cached_numlightentities;
3775 numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
3776 numshadowentities = rtlight->cached_numshadowentities;
3777 numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
3778 numsurfaces = rtlight->cached_numsurfaces;
3779 lightentities = rtlight->cached_lightentities;
3780 lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
3781 shadowentities = rtlight->cached_shadowentities;
3782 shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
3783 shadowtrispvs = rtlight->cached_shadowtrispvs;
3784 lighttrispvs = rtlight->cached_lighttrispvs;
3785 surfacelist = rtlight->cached_surfacelist;
3787 // set up a scissor rectangle for this light
3788 if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3791 // don't let sound skip if going slow
3792 if (r_refdef.scene.extraupdate)
3795 // make this the active rtlight for rendering purposes
3796 R_Shadow_RenderMode_ActiveLight(rtlight);
3798 if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
3800 // optionally draw visible shape of the shadow volumes
3801 // for performance analysis by level designers
3802 R_Shadow_RenderMode_VisibleShadowVolumes();
3804 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
3805 for (i = 0;i < numshadowentities;i++)
3806 R_Shadow_DrawEntityShadow(shadowentities[i]);
3807 for (i = 0;i < numshadowentities_noselfshadow;i++)
3808 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3809 R_Shadow_RenderMode_VisibleLighting(false, false);
3812 if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
3814 // optionally draw the illuminated areas
3815 // for performance analysis by level designers
3816 R_Shadow_RenderMode_VisibleLighting(false, false);
3818 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3819 for (i = 0;i < numlightentities;i++)
3820 R_Shadow_DrawEntityLight(lightentities[i]);
3821 for (i = 0;i < numlightentities_noselfshadow;i++)
3822 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3825 castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
3827 nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
3828 nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
3829 nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
3830 distance = VectorDistance(nearestpoint, r_refdef.view.origin);
3832 lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
3833 //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
3834 lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
3836 if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE))
3842 int receivermask = 0;
3843 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
3844 Matrix4x4_Abs(&radiustolight);
3846 r_shadow_shadowmaplod = 0;
3847 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
3848 if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
3849 r_shadow_shadowmaplod = i;
3851 if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
3852 size = max(1, r_shadow_shadowmapmaxsize >> r_shadow_shadowmaplod);
3854 size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
3856 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
3858 surfacesides = NULL;
3861 if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3863 castermask = rtlight->static_shadowmap_casters;
3864 receivermask = rtlight->static_shadowmap_receivers;
3868 surfacesides = r_shadow_buffer_surfacesides;
3869 for(i = 0;i < numsurfaces;i++)
3871 msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
3872 surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3873 castermask |= surfacesides[i];
3874 receivermask |= surfacesides[i];
3878 if (receivermask < 0x3F)
3880 for (i = 0;i < numlightentities;i++)
3881 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3882 if (receivermask < 0x3F)
3883 for(i = 0; i < numlightentities_noselfshadow;i++)
3884 receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3887 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
3891 for (i = 0;i < numshadowentities;i++)
3892 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
3893 for (i = 0;i < numshadowentities_noselfshadow;i++)
3894 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
3897 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
3899 // render shadow casters into 6 sided depth texture
3900 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
3902 R_Shadow_RenderMode_ShadowMap(side, true, size);
3903 if (! (castermask & (1 << side))) continue;
3905 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
3906 for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
3907 R_Shadow_DrawEntityShadow(shadowentities[i]);
3910 if (numlightentities_noselfshadow)
3912 // render lighting using the depth texture as shadowmap
3913 // draw lighting in the unmasked areas
3914 R_Shadow_RenderMode_Lighting(false, false, true);
3915 for (i = 0;i < numlightentities_noselfshadow;i++)
3916 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3919 // render shadow casters into 6 sided depth texture
3920 if (numshadowentities_noselfshadow)
3922 for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
3924 R_Shadow_RenderMode_ShadowMap(side, false, size);
3925 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
3926 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3930 // render lighting using the depth texture as shadowmap
3931 // draw lighting in the unmasked areas
3932 R_Shadow_RenderMode_Lighting(false, false, true);
3933 // draw lighting in the unmasked areas
3935 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3936 for (i = 0;i < numlightentities;i++)
3937 R_Shadow_DrawEntityLight(lightentities[i]);
3939 else if (castshadows && vid.stencil)
3941 // draw stencil shadow volumes to mask off pixels that are in shadow
3942 // so that they won't receive lighting
3943 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
3944 R_Shadow_ClearStencil();
3947 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
3948 for (i = 0;i < numshadowentities;i++)
3949 R_Shadow_DrawEntityShadow(shadowentities[i]);
3951 // draw lighting in the unmasked areas
3952 R_Shadow_RenderMode_Lighting(true, false, false);
3953 for (i = 0;i < numlightentities_noselfshadow;i++)
3954 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3956 for (i = 0;i < numshadowentities_noselfshadow;i++)
3957 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3959 // draw lighting in the unmasked areas
3960 R_Shadow_RenderMode_Lighting(true, false, false);
3962 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3963 for (i = 0;i < numlightentities;i++)
3964 R_Shadow_DrawEntityLight(lightentities[i]);
3968 // draw lighting in the unmasked areas
3969 R_Shadow_RenderMode_Lighting(false, false, false);
3971 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3972 for (i = 0;i < numlightentities;i++)
3973 R_Shadow_DrawEntityLight(lightentities[i]);
3974 for (i = 0;i < numlightentities_noselfshadow;i++)
3975 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3978 if (r_shadow_usingdeferredprepass)
3980 // when rendering deferred lighting, we simply rasterize the box
3981 if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE))
3982 R_Shadow_RenderMode_DrawDeferredLight(false, true);
3983 else if (castshadows && vid.stencil)
3984 R_Shadow_RenderMode_DrawDeferredLight(true, false);
3986 R_Shadow_RenderMode_DrawDeferredLight(false, false);
3990 static void R_Shadow_FreeDeferred(void)
3992 if (r_shadow_prepassgeometryfbo)
3993 qglDeleteFramebuffersEXT(1, &r_shadow_prepassgeometryfbo);CHECKGLERROR
3994 r_shadow_prepassgeometryfbo = 0;
3996 if (r_shadow_prepasslightingfbo)
3997 qglDeleteFramebuffersEXT(1, &r_shadow_prepasslightingfbo);CHECKGLERROR
3998 r_shadow_prepasslightingfbo = 0;
4000 if (r_shadow_prepassgeometrydepthtexture)
4001 R_FreeTexture(r_shadow_prepassgeometrydepthtexture);
4002 r_shadow_prepassgeometrydepthtexture = NULL;
4004 if (r_shadow_prepassgeometrynormalmaptexture)
4005 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4006 r_shadow_prepassgeometrynormalmaptexture = NULL;
4008 if (r_shadow_prepasslightingdiffusetexture)
4009 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4010 r_shadow_prepasslightingdiffusetexture = NULL;
4012 if (r_shadow_prepasslightingspeculartexture)
4013 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4014 r_shadow_prepasslightingspeculartexture = NULL;
4017 void R_Shadow_DrawPrepass(void)
4025 entity_render_t *ent;
4027 GL_AlphaTest(false);
4028 R_Mesh_ColorPointer(NULL, 0, 0);
4029 R_Mesh_ResetTextureState();
4031 GL_ColorMask(1,1,1,1);
4032 GL_BlendFunc(GL_ONE, GL_ZERO);
4035 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepassgeometryfbo);CHECKGLERROR
4036 qglClearColor(0.5f,0.5f,0.5f,1.0f);CHECKGLERROR
4037 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);CHECKGLERROR
4039 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4040 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4041 if (r_timereport_active)
4042 R_TimeReport("prepassgeometry");
4044 for (i = 0;i < r_refdef.scene.numentities;i++)
4046 if (!r_refdef.viewcache.entityvisible[i])
4048 ent = r_refdef.scene.entities[i];
4049 if (ent->model && ent->model->DrawPrepass != NULL)
4050 ent->model->DrawPrepass(ent);
4053 GL_DepthMask(false);
4054 GL_ColorMask(1,1,1,1);
4057 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
4058 qglClearColor(0.0f,0.0f,0.0f,0.0f);CHECKGLERROR
4059 GL_Clear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
4060 if (r_refdef.fogenabled)
4061 qglClearColor(r_refdef.fogcolor[0],r_refdef.fogcolor[1],r_refdef.fogcolor[2],0);CHECKGLERROR
4063 R_Shadow_RenderMode_Begin();
4065 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4066 if (r_shadow_debuglight.integer >= 0)
4068 lightindex = r_shadow_debuglight.integer;
4069 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4070 if (light && (light->flags & flag))
4071 R_Shadow_DrawLight(&light->rtlight);
4075 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4076 for (lightindex = 0;lightindex < range;lightindex++)
4078 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4079 if (light && (light->flags & flag))
4080 R_Shadow_DrawLight(&light->rtlight);
4083 if (r_refdef.scene.rtdlight)
4084 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4085 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4087 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
4088 if (r_refdef.fogenabled)
4089 qglClearColor(r_refdef.fogcolor[0],r_refdef.fogcolor[1],r_refdef.fogcolor[2],0);CHECKGLERROR
4091 R_Shadow_RenderMode_End();
4093 if (r_timereport_active)
4094 R_TimeReport("prepasslights");
4097 void R_Shadow_DrawLightSprites(void);
4098 void R_Shadow_PrepareLights(void)
4108 if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4109 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
4110 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0) ||
4111 r_shadow_shadowmaptexturetype != r_shadow_shadowmapping_texturetype.integer ||
4112 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4113 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4114 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4115 R_Shadow_FreeShadowMaps();
4117 switch (vid.renderpath)
4119 case RENDERPATH_GL20:
4120 if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || !vid.support.arb_texture_rectangle || vid.maxdrawbuffers < 2)
4122 r_shadow_usingdeferredprepass = false;
4123 if (r_shadow_prepass_width)
4124 R_Shadow_FreeDeferred();
4125 r_shadow_prepass_width = r_shadow_prepass_height = 0;
4129 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4131 R_Shadow_FreeDeferred();
4133 r_shadow_usingdeferredprepass = true;
4134 r_shadow_prepass_width = vid.width;
4135 r_shadow_prepass_height = vid.height;
4136 r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMapRectangle(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false);
4137 r_shadow_prepassgeometrynormalmaptexture = R_LoadTextureRectangle(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, NULL);
4138 r_shadow_prepasslightingdiffusetexture = R_LoadTextureRectangle(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, NULL);
4139 r_shadow_prepasslightingspeculartexture = R_LoadTextureRectangle(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, NULL);
4141 // set up the geometry pass fbo (depth + normalmap)
4142 qglGenFramebuffersEXT(1, &r_shadow_prepassgeometryfbo);CHECKGLERROR
4143 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepassgeometryfbo);CHECKGLERROR
4144 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrydepthtexture), 0);CHECKGLERROR
4145 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture), 0);CHECKGLERROR
4146 // render depth into one texture and normalmap into the other
4147 qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
4148 qglReadBuffer(GL_NONE);CHECKGLERROR
4149 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4150 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4152 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4153 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4154 r_shadow_usingdeferredprepass = false;
4157 // set up the lighting pass fbo (diffuse + specular)
4158 qglGenFramebuffersEXT(1, &r_shadow_prepasslightingfbo);CHECKGLERROR
4159 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
4160 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrydepthtexture), 0);CHECKGLERROR
4161 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepasslightingdiffusetexture), 0);CHECKGLERROR
4162 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepasslightingspeculartexture), 0);CHECKGLERROR
4163 // render diffuse into one texture and specular into another,
4164 // with depth and normalmap bound as textures,
4165 // with depth bound as attachment as well
4166 qglDrawBuffersARB(2, r_shadow_prepasslightingdrawbuffers);CHECKGLERROR
4167 qglReadBuffer(GL_NONE);CHECKGLERROR
4168 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4169 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4171 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4172 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4173 r_shadow_usingdeferredprepass = false;
4177 case RENDERPATH_GL13:
4178 case RENDERPATH_GL11:
4179 r_shadow_usingdeferredprepass = false;
4183 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);
4185 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4186 if (r_shadow_debuglight.integer >= 0)
4188 lightindex = r_shadow_debuglight.integer;
4189 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4190 if (light && (light->flags & flag))
4191 R_Shadow_PrepareLight(&light->rtlight);
4195 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4196 for (lightindex = 0;lightindex < range;lightindex++)
4198 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4199 if (light && (light->flags & flag))
4200 R_Shadow_PrepareLight(&light->rtlight);
4203 if (r_refdef.scene.rtdlight)
4205 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4206 R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4208 else if(gl_flashblend.integer)
4210 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4212 rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4213 f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4214 VectorScale(rtlight->color, f, rtlight->currentcolor);
4218 if (r_editlights.integer)
4219 R_Shadow_DrawLightSprites();
4222 void R_Shadow_DrawLights(void)
4230 R_Shadow_RenderMode_Begin();
4232 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4233 if (r_shadow_debuglight.integer >= 0)
4235 lightindex = r_shadow_debuglight.integer;
4236 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4237 if (light && (light->flags & flag))
4238 R_Shadow_DrawLight(&light->rtlight);
4242 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4243 for (lightindex = 0;lightindex < range;lightindex++)
4245 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4246 if (light && (light->flags & flag))
4247 R_Shadow_DrawLight(&light->rtlight);
4250 if (r_refdef.scene.rtdlight)
4251 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4252 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4254 R_Shadow_RenderMode_End();
4257 extern const float r_screenvertex3f[12];
4258 extern void R_SetupView(qboolean allowwaterclippingplane);
4259 extern void R_ResetViewRendering3D(void);
4260 extern void R_ResetViewRendering2D(void);
4261 extern cvar_t r_shadows;
4262 extern cvar_t r_shadows_darken;
4263 extern cvar_t r_shadows_drawafterrtlighting;
4264 extern cvar_t r_shadows_castfrombmodels;
4265 extern cvar_t r_shadows_throwdistance;
4266 extern cvar_t r_shadows_throwdirection;
4267 void R_DrawModelShadows(void)
4270 float relativethrowdistance;
4271 entity_render_t *ent;
4272 vec3_t relativelightorigin;
4273 vec3_t relativelightdirection;
4274 vec3_t relativeshadowmins, relativeshadowmaxs;
4275 vec3_t tmp, shadowdir;
4277 if (!r_refdef.scene.numentities || !vid.stencil)
4281 R_ResetViewRendering3D();
4282 //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
4283 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4284 R_Shadow_RenderMode_Begin();
4285 R_Shadow_RenderMode_ActiveLight(NULL);
4286 r_shadow_lightscissor[0] = r_refdef.view.x;
4287 r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
4288 r_shadow_lightscissor[2] = r_refdef.view.width;
4289 r_shadow_lightscissor[3] = r_refdef.view.height;
4290 R_Shadow_RenderMode_StencilShadowVolumes(false);
4293 if (r_shadows.integer == 2)
4295 Math_atov(r_shadows_throwdirection.string, shadowdir);
4296 VectorNormalize(shadowdir);
4299 R_Shadow_ClearStencil();
4301 for (i = 0;i < r_refdef.scene.numentities;i++)
4303 ent = r_refdef.scene.entities[i];
4305 // cast shadows from anything of the map (submodels are optional)
4306 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4308 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4309 VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
4310 VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
4311 if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
4312 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4315 if(ent->entitynumber != 0)
4317 // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
4318 int entnum, entnum2, recursion;
4319 entnum = entnum2 = ent->entitynumber;
4320 for(recursion = 32; recursion > 0; --recursion)
4322 entnum2 = cl.entities[entnum].state_current.tagentity;
4323 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
4328 if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
4330 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
4331 // transform into modelspace of OUR entity
4332 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
4333 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
4336 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4339 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4342 VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
4343 RSurf_ActiveModelEntity(ent, false, false, false);
4344 ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
4345 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4349 // not really the right mode, but this will disable any silly stencil features
4350 R_Shadow_RenderMode_End();
4352 // set up ortho view for rendering this pass
4353 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4354 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4355 //GL_ScissorTest(true);
4356 //R_Mesh_Matrix(&identitymatrix);
4357 //R_Mesh_ResetTextureState();
4358 R_ResetViewRendering2D();
4359 R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
4360 R_Mesh_ColorPointer(NULL, 0, 0);
4361 R_SetupGenericShader(false);
4363 // set up a darkening blend on shadowed areas
4364 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
4365 //GL_DepthRange(0, 1);
4366 //GL_DepthTest(false);
4367 //GL_DepthMask(false);
4368 //GL_PolygonOffset(0, 0);CHECKGLERROR
4369 GL_Color(0, 0, 0, r_shadows_darken.value);
4370 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4371 //qglDepthFunc(GL_ALWAYS);CHECKGLERROR
4372 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
4373 qglStencilMask(~0);CHECKGLERROR
4374 qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
4375 qglStencilFunc(GL_NOTEQUAL, 128, ~0);CHECKGLERROR
4377 // apply the blend to the shadowed areas
4378 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4380 // restore the viewport
4381 R_SetViewport(&r_refdef.view.viewport);
4383 // restore other state to normal
4384 //R_Shadow_RenderMode_End();
4387 void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
4390 vec3_t centerorigin;
4392 // if it's too close, skip it
4393 if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
4395 zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
4398 if (usequery && r_numqueries + 2 <= r_maxqueries)
4400 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
4401 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
4402 // we count potential samples in the middle of the screen, we count actual samples at the light location, this allows counting potential samples of off-screen lights
4403 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
4406 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use qglDepthFunc instead
4407 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
4408 qglDepthFunc(GL_ALWAYS);
4409 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4410 R_Mesh_VertexPointer(vertex3f, 0, 0);
4411 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4412 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
4413 qglDepthFunc(GL_LEQUAL);
4414 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
4415 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4416 R_Mesh_VertexPointer(vertex3f, 0, 0);
4417 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4418 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
4421 rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
4424 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
4426 void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
4429 GLint allpixels = 0, visiblepixels = 0;
4430 // now we have to check the query result
4431 if (rtlight->corona_queryindex_visiblepixels)
4434 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
4435 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
4437 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
4438 if (visiblepixels < 1 || allpixels < 1)
4440 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
4441 cscale *= rtlight->corona_visibility;
4445 // FIXME: these traces should scan all render entities instead of cl.world
4446 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1)
4449 VectorScale(rtlight->currentcolor, cscale, color);
4450 if (VectorLength(color) > (1.0f / 256.0f))
4453 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
4456 VectorNegate(color, color);
4457 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
4459 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4460 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, RENDER_NODEPTHTEST, 0, color[0], color[1], color[2], 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4461 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4463 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
4467 void R_Shadow_DrawCoronas(void)
4475 if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
4477 if (r_waterstate.renderingscene)
4479 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4480 R_Mesh_Matrix(&identitymatrix);
4482 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4484 // check occlusion of coronas
4485 // use GL_ARB_occlusion_query if available
4486 // otherwise use raytraces
4488 usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
4491 GL_ColorMask(0,0,0,0);
4492 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
4493 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
4496 r_maxqueries = (range + r_refdef.scene.numlights) * 4;
4497 r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
4499 qglGenQueriesARB(r_maxqueries - i, r_queries + i);
4502 RSurf_ActiveWorldEntity();
4503 GL_BlendFunc(GL_ONE, GL_ZERO);
4504 GL_CullFace(GL_NONE);
4505 GL_DepthMask(false);
4506 GL_DepthRange(0, 1);
4507 GL_PolygonOffset(0, 0);
4509 R_Mesh_ColorPointer(NULL, 0, 0);
4510 R_Mesh_ResetTextureState();
4511 R_SetupGenericShader(false);
4513 for (lightindex = 0;lightindex < range;lightindex++)
4515 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4518 rtlight = &light->rtlight;
4519 rtlight->corona_visibility = 0;
4520 rtlight->corona_queryindex_visiblepixels = 0;
4521 rtlight->corona_queryindex_allpixels = 0;
4522 if (!(rtlight->flags & flag))
4524 if (rtlight->corona <= 0)
4526 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
4528 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
4530 for (i = 0;i < r_refdef.scene.numlights;i++)
4532 rtlight = r_refdef.scene.lights[i];
4533 rtlight->corona_visibility = 0;
4534 rtlight->corona_queryindex_visiblepixels = 0;
4535 rtlight->corona_queryindex_allpixels = 0;
4536 if (!(rtlight->flags & flag))
4538 if (rtlight->corona <= 0)
4540 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
4543 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4545 // now draw the coronas using the query data for intensity info
4546 for (lightindex = 0;lightindex < range;lightindex++)
4548 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4551 rtlight = &light->rtlight;
4552 if (rtlight->corona_visibility <= 0)
4554 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
4556 for (i = 0;i < r_refdef.scene.numlights;i++)
4558 rtlight = r_refdef.scene.lights[i];
4559 if (rtlight->corona_visibility <= 0)
4561 if (gl_flashblend.integer)
4562 R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
4564 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
4570 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
4571 typedef struct suffixinfo_s
4574 qboolean flipx, flipy, flipdiagonal;
4577 static suffixinfo_t suffix[3][6] =
4580 {"px", false, false, false},
4581 {"nx", false, false, false},
4582 {"py", false, false, false},
4583 {"ny", false, false, false},
4584 {"pz", false, false, false},
4585 {"nz", false, false, false}
4588 {"posx", false, false, false},
4589 {"negx", false, false, false},
4590 {"posy", false, false, false},
4591 {"negy", false, false, false},
4592 {"posz", false, false, false},
4593 {"negz", false, false, false}
4596 {"rt", true, false, true},
4597 {"lf", false, true, true},
4598 {"ft", true, true, false},
4599 {"bk", false, false, false},
4600 {"up", true, false, true},
4601 {"dn", true, false, true}
4605 static int componentorder[4] = {0, 1, 2, 3};
4607 rtexture_t *R_Shadow_LoadCubemap(const char *basename)
4609 int i, j, cubemapsize;
4610 unsigned char *cubemappixels, *image_buffer;
4611 rtexture_t *cubemaptexture;
4613 // must start 0 so the first loadimagepixels has no requested width/height
4615 cubemappixels = NULL;
4616 cubemaptexture = NULL;
4617 // keep trying different suffix groups (posx, px, rt) until one loads
4618 for (j = 0;j < 3 && !cubemappixels;j++)
4620 // load the 6 images in the suffix group
4621 for (i = 0;i < 6;i++)
4623 // generate an image name based on the base and and suffix
4624 dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
4626 if ((image_buffer = loadimagepixelsbgra(name, false, false)))
4628 // an image loaded, make sure width and height are equal
4629 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
4631 // if this is the first image to load successfully, allocate the cubemap memory
4632 if (!cubemappixels && image_width >= 1)
4634 cubemapsize = image_width;
4635 // note this clears to black, so unavailable sides are black
4636 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
4638 // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
4640 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);
4643 Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
4645 Mem_Free(image_buffer);
4649 // if a cubemap loaded, upload it
4652 if (developer_loading.integer)
4653 Con_Printf("loading cubemap \"%s\"\n", basename);
4655 if (!r_shadow_filters_texturepool)
4656 r_shadow_filters_texturepool = R_AllocTexturePool();
4657 cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, TEXF_PRECACHE | (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR, NULL);
4658 Mem_Free(cubemappixels);
4662 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
4663 if (developer_loading.integer)
4665 Con_Printf("(tried tried images ");
4666 for (j = 0;j < 3;j++)
4667 for (i = 0;i < 6;i++)
4668 Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
4669 Con_Print(" and was unable to find any of them).\n");
4672 return cubemaptexture;
4675 rtexture_t *R_Shadow_Cubemap(const char *basename)
4678 for (i = 0;i < numcubemaps;i++)
4679 if (!strcasecmp(cubemaps[i].basename, basename))
4680 return cubemaps[i].texture ? cubemaps[i].texture : r_texture_whitecube;
4681 if (i >= MAX_CUBEMAPS)
4682 return r_texture_whitecube;
4684 strlcpy(cubemaps[i].basename, basename, sizeof(cubemaps[i].basename));
4685 cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename);
4686 return cubemaps[i].texture;
4689 void R_Shadow_FreeCubemaps(void)
4692 for (i = 0;i < numcubemaps;i++)
4694 if (developer_loading.integer)
4695 Con_Printf("unloading cubemap \"%s\"\n", cubemaps[i].basename);
4696 if (cubemaps[i].texture)
4697 R_FreeTexture(cubemaps[i].texture);
4701 R_FreeTexturePool(&r_shadow_filters_texturepool);
4704 dlight_t *R_Shadow_NewWorldLight(void)
4706 return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
4709 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)
4712 // validate parameters
4713 if (style < 0 || style >= MAX_LIGHTSTYLES)
4715 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
4721 // copy to light properties
4722 VectorCopy(origin, light->origin);
4723 light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
4724 light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
4725 light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
4727 light->color[0] = max(color[0], 0);
4728 light->color[1] = max(color[1], 0);
4729 light->color[2] = max(color[2], 0);
4731 light->color[0] = color[0];
4732 light->color[1] = color[1];
4733 light->color[2] = color[2];
4734 light->radius = max(radius, 0);
4735 light->style = style;
4736 light->shadow = shadowenable;
4737 light->corona = corona;
4738 strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
4739 light->coronasizescale = coronasizescale;
4740 light->ambientscale = ambientscale;
4741 light->diffusescale = diffusescale;
4742 light->specularscale = specularscale;
4743 light->flags = flags;
4745 // update renderable light data
4746 Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
4747 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);
4750 void R_Shadow_FreeWorldLight(dlight_t *light)
4752 if (r_shadow_selectedlight == light)
4753 r_shadow_selectedlight = NULL;
4754 R_RTLight_Uncompile(&light->rtlight);
4755 Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
4758 void R_Shadow_ClearWorldLights(void)
4762 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4763 for (lightindex = 0;lightindex < range;lightindex++)
4765 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4767 R_Shadow_FreeWorldLight(light);
4769 r_shadow_selectedlight = NULL;
4770 R_Shadow_FreeCubemaps();
4773 void R_Shadow_SelectLight(dlight_t *light)
4775 if (r_shadow_selectedlight)
4776 r_shadow_selectedlight->selected = false;
4777 r_shadow_selectedlight = light;
4778 if (r_shadow_selectedlight)
4779 r_shadow_selectedlight->selected = true;
4782 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
4784 // this is never batched (there can be only one)
4786 R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
4787 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4788 R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4791 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
4796 skinframe_t *skinframe;
4799 // this is never batched (due to the ent parameter changing every time)
4800 // so numsurfaces == 1 and surfacelist[0] == lightnumber
4801 const dlight_t *light = (dlight_t *)ent;
4804 R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
4807 VectorScale(light->color, intensity, spritecolor);
4808 if (VectorLength(spritecolor) < 0.1732f)
4809 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
4810 if (VectorLength(spritecolor) > 1.0f)
4811 VectorNormalize(spritecolor);
4813 // draw light sprite
4814 if (light->cubemapname[0] && !light->shadow)
4815 skinframe = r_editlights_sprcubemapnoshadowlight;
4816 else if (light->cubemapname[0])
4817 skinframe = r_editlights_sprcubemaplight;
4818 else if (!light->shadow)
4819 skinframe = r_editlights_sprnoshadowlight;
4821 skinframe = r_editlights_sprlight;
4823 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, spritecolor[0], spritecolor[1], spritecolor[2], 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4824 R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4826 // draw selection sprite if light is selected
4827 if (light->selected)
4829 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4830 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4831 // VorteX todo: add normalmode/realtime mode light overlay sprites?
4835 void R_Shadow_DrawLightSprites(void)
4839 size_t 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);
4844 R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
4846 R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
4849 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
4854 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
4855 if (lightindex >= range)
4857 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4860 rtlight = &light->rtlight;
4861 //if (!(rtlight->flags & flag))
4863 VectorCopy(rtlight->shadoworigin, origin);
4864 *radius = rtlight->radius;
4865 VectorCopy(rtlight->color, color);
4869 void R_Shadow_SelectLightInView(void)
4871 float bestrating, rating, temp[3];
4875 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4878 for (lightindex = 0;lightindex < range;lightindex++)
4880 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4883 VectorSubtract(light->origin, r_refdef.view.origin, temp);
4884 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
4887 rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
4888 if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1.0f)
4890 bestrating = rating;
4895 R_Shadow_SelectLight(best);
4898 void R_Shadow_LoadWorldLights(void)
4900 int n, a, style, shadow, flags;
4901 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
4902 float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
4903 if (cl.worldmodel == NULL)
4905 Con_Print("No map loaded.\n");
4908 FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
4909 strlcat (name, ".rtlights", sizeof (name));
4910 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
4920 for (;COM_Parse(t, true) && strcmp(
4921 if (COM_Parse(t, true))
4923 if (com_token[0] == '!')
4926 origin[0] = atof(com_token+1);
4929 origin[0] = atof(com_token);
4934 while (*s && *s != '\n' && *s != '\r')
4940 // check for modifier flags
4947 #if _MSC_VER >= 1400
4948 #define sscanf sscanf_s
4950 cubemapname[sizeof(cubemapname)-1] = 0;
4951 #if MAX_QPATH != 128
4952 #error update this code if MAX_QPATH changes
4954 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
4955 #if _MSC_VER >= 1400
4956 , sizeof(cubemapname)
4958 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
4961 flags = LIGHTFLAG_REALTIMEMODE;
4969 coronasizescale = 0.25f;
4971 VectorClear(angles);
4974 if (a < 9 || !strcmp(cubemapname, "\"\""))
4976 // remove quotes on cubemapname
4977 if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
4980 namelen = strlen(cubemapname) - 2;
4981 memmove(cubemapname, cubemapname + 1, namelen);
4982 cubemapname[namelen] = '\0';
4986 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);
4989 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
4997 Con_Printf("invalid rtlights file \"%s\"\n", name);
4998 Mem_Free(lightsstring);
5002 void R_Shadow_SaveWorldLights(void)
5006 size_t bufchars, bufmaxchars;
5008 char name[MAX_QPATH];
5009 char line[MAX_INPUTLINE];
5010 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5011 // I hate lines which are 3 times my screen size :( --blub
5014 if (cl.worldmodel == NULL)
5016 Con_Print("No map loaded.\n");
5019 FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
5020 strlcat (name, ".rtlights", sizeof (name));
5021 bufchars = bufmaxchars = 0;
5023 for (lightindex = 0;lightindex < range;lightindex++)
5025 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5028 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5029 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);
5030 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5031 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]);
5033 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);
5034 if (bufchars + strlen(line) > bufmaxchars)
5036 bufmaxchars = bufchars + strlen(line) + 2048;
5038 buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5042 memcpy(buf, oldbuf, bufchars);
5048 memcpy(buf + bufchars, line, strlen(line));
5049 bufchars += strlen(line);
5053 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5058 void R_Shadow_LoadLightsFile(void)
5061 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5062 float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5063 if (cl.worldmodel == NULL)
5065 Con_Print("No map loaded.\n");
5068 FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
5069 strlcat (name, ".lights", sizeof (name));
5070 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5078 while (*s && *s != '\n' && *s != '\r')
5084 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);
5088 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);
5091 radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5092 radius = bound(15, radius, 4096);
5093 VectorScale(color, (2.0f / (8388608.0f)), color);
5094 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5102 Con_Printf("invalid lights file \"%s\"\n", name);
5103 Mem_Free(lightsstring);
5107 // tyrlite/hmap2 light types in the delay field
5108 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5110 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5112 int entnum, style, islight, skin, pflags, effects, type, n;
5115 float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5116 char key[256], value[MAX_INPUTLINE];
5118 if (cl.worldmodel == NULL)
5120 Con_Print("No map loaded.\n");
5123 // try to load a .ent file first
5124 FS_StripExtension (cl.worldmodel->name, key, sizeof (key));
5125 strlcat (key, ".ent", sizeof (key));
5126 data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5127 // and if that is not found, fall back to the bsp file entity string
5129 data = cl.worldmodel->brush.entities;
5132 for (entnum = 0;COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{';entnum++)
5134 type = LIGHTTYPE_MINUSX;
5135 origin[0] = origin[1] = origin[2] = 0;
5136 originhack[0] = originhack[1] = originhack[2] = 0;
5137 angles[0] = angles[1] = angles[2] = 0;
5138 color[0] = color[1] = color[2] = 1;
5139 light[0] = light[1] = light[2] = 1;light[3] = 300;
5140 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5150 if (!COM_ParseToken_Simple(&data, false, false))
5152 if (com_token[0] == '}')
5153 break; // end of entity
5154 if (com_token[0] == '_')
5155 strlcpy(key, com_token + 1, sizeof(key));
5157 strlcpy(key, com_token, sizeof(key));
5158 while (key[strlen(key)-1] == ' ') // remove trailing spaces
5159 key[strlen(key)-1] = 0;
5160 if (!COM_ParseToken_Simple(&data, false, false))
5162 strlcpy(value, com_token, sizeof(value));
5164 // now that we have the key pair worked out...
5165 if (!strcmp("light", key))
5167 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5171 light[0] = vec[0] * (1.0f / 256.0f);
5172 light[1] = vec[0] * (1.0f / 256.0f);
5173 light[2] = vec[0] * (1.0f / 256.0f);
5179 light[0] = vec[0] * (1.0f / 255.0f);
5180 light[1] = vec[1] * (1.0f / 255.0f);
5181 light[2] = vec[2] * (1.0f / 255.0f);
5185 else if (!strcmp("delay", key))
5187 else if (!strcmp("origin", key))
5188 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5189 else if (!strcmp("angle", key))
5190 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5191 else if (!strcmp("angles", key))
5192 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5193 else if (!strcmp("color", key))
5194 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5195 else if (!strcmp("wait", key))
5196 fadescale = atof(value);
5197 else if (!strcmp("classname", key))
5199 if (!strncmp(value, "light", 5))
5202 if (!strcmp(value, "light_fluoro"))
5207 overridecolor[0] = 1;
5208 overridecolor[1] = 1;
5209 overridecolor[2] = 1;
5211 if (!strcmp(value, "light_fluorospark"))
5216 overridecolor[0] = 1;
5217 overridecolor[1] = 1;
5218 overridecolor[2] = 1;
5220 if (!strcmp(value, "light_globe"))
5225 overridecolor[0] = 1;
5226 overridecolor[1] = 0.8;
5227 overridecolor[2] = 0.4;
5229 if (!strcmp(value, "light_flame_large_yellow"))
5234 overridecolor[0] = 1;
5235 overridecolor[1] = 0.5;
5236 overridecolor[2] = 0.1;
5238 if (!strcmp(value, "light_flame_small_yellow"))
5243 overridecolor[0] = 1;
5244 overridecolor[1] = 0.5;
5245 overridecolor[2] = 0.1;
5247 if (!strcmp(value, "light_torch_small_white"))
5252 overridecolor[0] = 1;
5253 overridecolor[1] = 0.5;
5254 overridecolor[2] = 0.1;
5256 if (!strcmp(value, "light_torch_small_walltorch"))
5261 overridecolor[0] = 1;
5262 overridecolor[1] = 0.5;
5263 overridecolor[2] = 0.1;
5267 else if (!strcmp("style", key))
5268 style = atoi(value);
5269 else if (!strcmp("skin", key))
5270 skin = (int)atof(value);
5271 else if (!strcmp("pflags", key))
5272 pflags = (int)atof(value);
5273 else if (!strcmp("effects", key))
5274 effects = (int)atof(value);
5275 else if (cl.worldmodel->type == mod_brushq3)
5277 if (!strcmp("scale", key))
5278 lightscale = atof(value);
5279 if (!strcmp("fade", key))
5280 fadescale = atof(value);
5285 if (lightscale <= 0)
5289 if (color[0] == color[1] && color[0] == color[2])
5291 color[0] *= overridecolor[0];
5292 color[1] *= overridecolor[1];
5293 color[2] *= overridecolor[2];
5295 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
5296 color[0] = color[0] * light[0];
5297 color[1] = color[1] * light[1];
5298 color[2] = color[2] * light[2];
5301 case LIGHTTYPE_MINUSX:
5303 case LIGHTTYPE_RECIPX:
5305 VectorScale(color, (1.0f / 16.0f), color);
5307 case LIGHTTYPE_RECIPXX:
5309 VectorScale(color, (1.0f / 16.0f), color);
5312 case LIGHTTYPE_NONE:
5316 case LIGHTTYPE_MINUSXX:
5319 VectorAdd(origin, originhack, origin);
5321 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);
5324 Mem_Free(entfiledata);
5328 void R_Shadow_SetCursorLocationForView(void)
5331 vec3_t dest, endpos;
5333 VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
5334 trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
5335 if (trace.fraction < 1)
5337 dist = trace.fraction * r_editlights_cursordistance.value;
5338 push = r_editlights_cursorpushback.value;
5342 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
5343 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
5347 VectorClear( endpos );
5349 r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5350 r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5351 r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5354 void R_Shadow_UpdateWorldLightSelection(void)
5356 if (r_editlights.integer)
5358 R_Shadow_SetCursorLocationForView();
5359 R_Shadow_SelectLightInView();
5362 R_Shadow_SelectLight(NULL);
5365 void R_Shadow_EditLights_Clear_f(void)
5367 R_Shadow_ClearWorldLights();
5370 void R_Shadow_EditLights_Reload_f(void)
5374 strlcpy(r_shadow_mapname, cl.worldmodel->name, sizeof(r_shadow_mapname));
5375 R_Shadow_ClearWorldLights();
5376 R_Shadow_LoadWorldLights();
5377 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5379 R_Shadow_LoadLightsFile();
5380 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5381 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5385 void R_Shadow_EditLights_Save_f(void)
5389 R_Shadow_SaveWorldLights();
5392 void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
5394 R_Shadow_ClearWorldLights();
5395 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5398 void R_Shadow_EditLights_ImportLightsFile_f(void)
5400 R_Shadow_ClearWorldLights();
5401 R_Shadow_LoadLightsFile();
5404 void R_Shadow_EditLights_Spawn_f(void)
5407 if (!r_editlights.integer)
5409 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
5412 if (Cmd_Argc() != 1)
5414 Con_Print("r_editlights_spawn does not take parameters\n");
5417 color[0] = color[1] = color[2] = 1;
5418 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5421 void R_Shadow_EditLights_Edit_f(void)
5423 vec3_t origin, angles, color;
5424 vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
5425 int style, shadows, flags, normalmode, realtimemode;
5426 char cubemapname[MAX_INPUTLINE];
5427 if (!r_editlights.integer)
5429 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
5432 if (!r_shadow_selectedlight)
5434 Con_Print("No selected light.\n");
5437 VectorCopy(r_shadow_selectedlight->origin, origin);
5438 VectorCopy(r_shadow_selectedlight->angles, angles);
5439 VectorCopy(r_shadow_selectedlight->color, color);
5440 radius = r_shadow_selectedlight->radius;
5441 style = r_shadow_selectedlight->style;
5442 if (r_shadow_selectedlight->cubemapname)
5443 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
5446 shadows = r_shadow_selectedlight->shadow;
5447 corona = r_shadow_selectedlight->corona;
5448 coronasizescale = r_shadow_selectedlight->coronasizescale;
5449 ambientscale = r_shadow_selectedlight->ambientscale;
5450 diffusescale = r_shadow_selectedlight->diffusescale;
5451 specularscale = r_shadow_selectedlight->specularscale;
5452 flags = r_shadow_selectedlight->flags;
5453 normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
5454 realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
5455 if (!strcmp(Cmd_Argv(1), "origin"))
5457 if (Cmd_Argc() != 5)
5459 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5462 origin[0] = atof(Cmd_Argv(2));
5463 origin[1] = atof(Cmd_Argv(3));
5464 origin[2] = atof(Cmd_Argv(4));
5466 else if (!strcmp(Cmd_Argv(1), "originx"))
5468 if (Cmd_Argc() != 3)
5470 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5473 origin[0] = atof(Cmd_Argv(2));
5475 else if (!strcmp(Cmd_Argv(1), "originy"))
5477 if (Cmd_Argc() != 3)
5479 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5482 origin[1] = atof(Cmd_Argv(2));
5484 else if (!strcmp(Cmd_Argv(1), "originz"))
5486 if (Cmd_Argc() != 3)
5488 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5491 origin[2] = atof(Cmd_Argv(2));
5493 else if (!strcmp(Cmd_Argv(1), "move"))
5495 if (Cmd_Argc() != 5)
5497 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5500 origin[0] += atof(Cmd_Argv(2));
5501 origin[1] += atof(Cmd_Argv(3));
5502 origin[2] += atof(Cmd_Argv(4));
5504 else if (!strcmp(Cmd_Argv(1), "movex"))
5506 if (Cmd_Argc() != 3)
5508 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5511 origin[0] += atof(Cmd_Argv(2));
5513 else if (!strcmp(Cmd_Argv(1), "movey"))
5515 if (Cmd_Argc() != 3)
5517 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5520 origin[1] += atof(Cmd_Argv(2));
5522 else if (!strcmp(Cmd_Argv(1), "movez"))
5524 if (Cmd_Argc() != 3)
5526 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5529 origin[2] += atof(Cmd_Argv(2));
5531 else if (!strcmp(Cmd_Argv(1), "angles"))
5533 if (Cmd_Argc() != 5)
5535 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5538 angles[0] = atof(Cmd_Argv(2));
5539 angles[1] = atof(Cmd_Argv(3));
5540 angles[2] = atof(Cmd_Argv(4));
5542 else if (!strcmp(Cmd_Argv(1), "anglesx"))
5544 if (Cmd_Argc() != 3)
5546 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5549 angles[0] = atof(Cmd_Argv(2));
5551 else if (!strcmp(Cmd_Argv(1), "anglesy"))
5553 if (Cmd_Argc() != 3)
5555 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5558 angles[1] = atof(Cmd_Argv(2));
5560 else if (!strcmp(Cmd_Argv(1), "anglesz"))
5562 if (Cmd_Argc() != 3)
5564 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5567 angles[2] = atof(Cmd_Argv(2));
5569 else if (!strcmp(Cmd_Argv(1), "color"))
5571 if (Cmd_Argc() != 5)
5573 Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
5576 color[0] = atof(Cmd_Argv(2));
5577 color[1] = atof(Cmd_Argv(3));
5578 color[2] = atof(Cmd_Argv(4));
5580 else if (!strcmp(Cmd_Argv(1), "radius"))
5582 if (Cmd_Argc() != 3)
5584 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5587 radius = atof(Cmd_Argv(2));
5589 else if (!strcmp(Cmd_Argv(1), "colorscale"))
5591 if (Cmd_Argc() == 3)
5593 double scale = atof(Cmd_Argv(2));
5600 if (Cmd_Argc() != 5)
5602 Con_Printf("usage: r_editlights_edit %s red green blue (OR grey instead of red green blue)\n", Cmd_Argv(1));
5605 color[0] *= atof(Cmd_Argv(2));
5606 color[1] *= atof(Cmd_Argv(3));
5607 color[2] *= atof(Cmd_Argv(4));
5610 else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
5612 if (Cmd_Argc() != 3)
5614 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5617 radius *= atof(Cmd_Argv(2));
5619 else if (!strcmp(Cmd_Argv(1), "style"))
5621 if (Cmd_Argc() != 3)
5623 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5626 style = atoi(Cmd_Argv(2));
5628 else if (!strcmp(Cmd_Argv(1), "cubemap"))
5632 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5635 if (Cmd_Argc() == 3)
5636 strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
5640 else if (!strcmp(Cmd_Argv(1), "shadows"))
5642 if (Cmd_Argc() != 3)
5644 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5647 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5649 else if (!strcmp(Cmd_Argv(1), "corona"))
5651 if (Cmd_Argc() != 3)
5653 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5656 corona = atof(Cmd_Argv(2));
5658 else if (!strcmp(Cmd_Argv(1), "coronasize"))
5660 if (Cmd_Argc() != 3)
5662 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5665 coronasizescale = atof(Cmd_Argv(2));
5667 else if (!strcmp(Cmd_Argv(1), "ambient"))
5669 if (Cmd_Argc() != 3)
5671 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5674 ambientscale = atof(Cmd_Argv(2));
5676 else if (!strcmp(Cmd_Argv(1), "diffuse"))
5678 if (Cmd_Argc() != 3)
5680 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5683 diffusescale = atof(Cmd_Argv(2));
5685 else if (!strcmp(Cmd_Argv(1), "specular"))
5687 if (Cmd_Argc() != 3)
5689 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5692 specularscale = atof(Cmd_Argv(2));
5694 else if (!strcmp(Cmd_Argv(1), "normalmode"))
5696 if (Cmd_Argc() != 3)
5698 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5701 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5703 else if (!strcmp(Cmd_Argv(1), "realtimemode"))
5705 if (Cmd_Argc() != 3)
5707 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5710 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5714 Con_Print("usage: r_editlights_edit [property] [value]\n");
5715 Con_Print("Selected light's properties:\n");
5716 Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
5717 Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
5718 Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
5719 Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius);
5720 Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona);
5721 Con_Printf("Style : %i\n", r_shadow_selectedlight->style);
5722 Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
5723 Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname);
5724 Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);
5725 Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale);
5726 Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale);
5727 Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale);
5728 Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
5729 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
5732 flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
5733 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5736 void R_Shadow_EditLights_EditAll_f(void)
5742 if (!r_editlights.integer)
5744 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
5748 // EditLights doesn't seem to have a "remove" command or something so:
5749 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5750 for (lightindex = 0;lightindex < range;lightindex++)
5752 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5755 R_Shadow_SelectLight(light);
5756 R_Shadow_EditLights_Edit_f();
5760 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
5762 int lightnumber, lightcount;
5763 size_t lightindex, range;
5767 if (!r_editlights.integer)
5769 x = vid_conwidth.value - 240;
5771 DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
5774 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5775 for (lightindex = 0;lightindex < range;lightindex++)
5777 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5780 if (light == r_shadow_selectedlight)
5781 lightnumber = lightindex;
5784 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;
5785 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;
5787 if (r_shadow_selectedlight == NULL)
5789 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;
5790 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;
5791 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;
5792 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;
5793 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;
5794 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;
5795 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;
5796 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;
5797 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;
5798 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;
5799 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;
5800 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;
5801 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;
5802 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;
5803 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;
5806 void R_Shadow_EditLights_ToggleShadow_f(void)
5808 if (!r_editlights.integer)
5810 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
5813 if (!r_shadow_selectedlight)
5815 Con_Print("No selected light.\n");
5818 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);
5821 void R_Shadow_EditLights_ToggleCorona_f(void)
5823 if (!r_editlights.integer)
5825 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
5828 if (!r_shadow_selectedlight)
5830 Con_Print("No selected light.\n");
5833 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);
5836 void R_Shadow_EditLights_Remove_f(void)
5838 if (!r_editlights.integer)
5840 Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n");
5843 if (!r_shadow_selectedlight)
5845 Con_Print("No selected light.\n");
5848 R_Shadow_FreeWorldLight(r_shadow_selectedlight);
5849 r_shadow_selectedlight = NULL;
5852 void R_Shadow_EditLights_Help_f(void)
5855 "Documentation on r_editlights system:\n"
5857 "r_editlights : enable/disable editing mode\n"
5858 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
5859 "r_editlights_cursorpushback : push back cursor this far from surface\n"
5860 "r_editlights_cursorpushoff : push cursor off surface this far\n"
5861 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
5862 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
5864 "r_editlights_help : this help\n"
5865 "r_editlights_clear : remove all lights\n"
5866 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
5867 "r_editlights_save : save to .rtlights file\n"
5868 "r_editlights_spawn : create a light with default settings\n"
5869 "r_editlights_edit command : edit selected light - more documentation below\n"
5870 "r_editlights_remove : remove selected light\n"
5871 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
5872 "r_editlights_importlightentitiesfrommap : reload light entities\n"
5873 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
5875 "origin x y z : set light location\n"
5876 "originx x: set x component of light location\n"
5877 "originy y: set y component of light location\n"
5878 "originz z: set z component of light location\n"
5879 "move x y z : adjust light location\n"
5880 "movex x: adjust x component of light location\n"
5881 "movey y: adjust y component of light location\n"
5882 "movez z: adjust z component of light location\n"
5883 "angles x y z : set light angles\n"
5884 "anglesx x: set x component of light angles\n"
5885 "anglesy y: set y component of light angles\n"
5886 "anglesz z: set z component of light angles\n"
5887 "color r g b : set color of light (can be brighter than 1 1 1)\n"
5888 "radius radius : set radius (size) of light\n"
5889 "colorscale grey : multiply color of light (1 does nothing)\n"
5890 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
5891 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
5892 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
5893 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
5894 "cubemap basename : set filter cubemap of light (not yet supported)\n"
5895 "shadows 1/0 : turn on/off shadows\n"
5896 "corona n : set corona intensity\n"
5897 "coronasize n : set corona size (0-1)\n"
5898 "ambient n : set ambient intensity (0-1)\n"
5899 "diffuse n : set diffuse intensity (0-1)\n"
5900 "specular n : set specular intensity (0-1)\n"
5901 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
5902 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
5903 "<nothing> : print light properties to console\n"
5907 void R_Shadow_EditLights_CopyInfo_f(void)
5909 if (!r_editlights.integer)
5911 Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n");
5914 if (!r_shadow_selectedlight)
5916 Con_Print("No selected light.\n");
5919 VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
5920 VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
5921 r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
5922 r_shadow_bufferlight.style = r_shadow_selectedlight->style;
5923 if (r_shadow_selectedlight->cubemapname)
5924 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
5926 r_shadow_bufferlight.cubemapname[0] = 0;
5927 r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
5928 r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
5929 r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
5930 r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
5931 r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
5932 r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
5933 r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
5936 void R_Shadow_EditLights_PasteInfo_f(void)
5938 if (!r_editlights.integer)
5940 Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n");
5943 if (!r_shadow_selectedlight)
5945 Con_Print("No selected light.\n");
5948 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);
5951 void R_Shadow_EditLights_Init(void)
5953 Cvar_RegisterVariable(&r_editlights);
5954 Cvar_RegisterVariable(&r_editlights_cursordistance);
5955 Cvar_RegisterVariable(&r_editlights_cursorpushback);
5956 Cvar_RegisterVariable(&r_editlights_cursorpushoff);
5957 Cvar_RegisterVariable(&r_editlights_cursorgrid);
5958 Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
5959 Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
5960 Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
5961 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)");
5962 Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
5963 Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
5964 Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
5965 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)");
5966 Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
5967 Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
5968 Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
5969 Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
5970 Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
5971 Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
5972 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)");
5978 =============================================================================
5982 =============================================================================
5985 void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const vec3_t p, int dynamic)
5987 VectorClear(diffusecolor);
5988 VectorClear(diffusenormal);
5990 if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
5992 ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_refdef.scene.ambient;
5993 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
5996 VectorSet(ambientcolor, 1, 1, 1);
6003 for (i = 0;i < r_refdef.scene.numlights;i++)
6005 light = r_refdef.scene.lights[i];
6006 Matrix4x4_Transform(&light->matrix_worldtolight, p, v);
6007 f = 1 - VectorLength2(v);
6008 if (f > 0 && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1)
6009 VectorMA(ambientcolor, f, light->currentcolor, ambientcolor);