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"
142 #include "dpsoftrast.h"
146 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
149 extern void R_Shadow_EditLights_Init(void);
151 typedef enum r_shadow_rendermode_e
153 R_SHADOW_RENDERMODE_NONE,
154 R_SHADOW_RENDERMODE_ZPASS_STENCIL,
155 R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL,
156 R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE,
157 R_SHADOW_RENDERMODE_ZFAIL_STENCIL,
158 R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL,
159 R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE,
160 R_SHADOW_RENDERMODE_LIGHT_VERTEX,
161 R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN,
162 R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN,
163 R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN,
164 R_SHADOW_RENDERMODE_LIGHT_GLSL,
165 R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
166 R_SHADOW_RENDERMODE_VISIBLELIGHTING,
167 R_SHADOW_RENDERMODE_SHADOWMAP2D
169 r_shadow_rendermode_t;
171 typedef enum r_shadow_shadowmode_e
173 R_SHADOW_SHADOWMODE_STENCIL,
174 R_SHADOW_SHADOWMODE_SHADOWMAP2D
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_usingshadowmap2d;
183 qboolean r_shadow_usingshadowmaportho;
184 int r_shadow_shadowmapside;
185 float r_shadow_shadowmap_texturescale[2];
186 float r_shadow_shadowmap_parameters[4];
188 int r_shadow_drawbuffer;
189 int r_shadow_readbuffer;
191 int r_shadow_cullface_front, r_shadow_cullface_back;
192 GLuint r_shadow_fbo2d;
193 r_shadow_shadowmode_t r_shadow_shadowmode;
194 int r_shadow_shadowmapfilterquality;
195 int r_shadow_shadowmapdepthbits;
196 int r_shadow_shadowmapmaxsize;
197 qboolean r_shadow_shadowmapvsdct;
198 qboolean r_shadow_shadowmapsampler;
199 int r_shadow_shadowmappcf;
200 int r_shadow_shadowmapborder;
201 matrix4x4_t r_shadow_shadowmapmatrix;
202 int r_shadow_lightscissor[4];
203 qboolean r_shadow_usingdeferredprepass;
205 int maxshadowtriangles;
208 int maxshadowvertices;
209 float *shadowvertex3f;
219 unsigned char *shadowsides;
220 int *shadowsideslist;
227 int r_shadow_buffer_numleafpvsbytes;
228 unsigned char *r_shadow_buffer_visitingleafpvs;
229 unsigned char *r_shadow_buffer_leafpvs;
230 int *r_shadow_buffer_leaflist;
232 int r_shadow_buffer_numsurfacepvsbytes;
233 unsigned char *r_shadow_buffer_surfacepvs;
234 int *r_shadow_buffer_surfacelist;
235 unsigned char *r_shadow_buffer_surfacesides;
237 int r_shadow_buffer_numshadowtrispvsbytes;
238 unsigned char *r_shadow_buffer_shadowtrispvs;
239 int r_shadow_buffer_numlighttrispvsbytes;
240 unsigned char *r_shadow_buffer_lighttrispvs;
242 rtexturepool_t *r_shadow_texturepool;
243 rtexture_t *r_shadow_attenuationgradienttexture;
244 rtexture_t *r_shadow_attenuation2dtexture;
245 rtexture_t *r_shadow_attenuation3dtexture;
246 skinframe_t *r_shadow_lightcorona;
247 rtexture_t *r_shadow_shadowmap2dtexture;
248 rtexture_t *r_shadow_shadowmap2dcolortexture;
249 rtexture_t *r_shadow_shadowmapvsdcttexture;
250 int r_shadow_shadowmapsize; // changes for each light based on distance
251 int r_shadow_shadowmaplod; // changes for each light based on distance
253 GLuint r_shadow_prepassgeometryfbo;
254 GLuint r_shadow_prepasslightingdiffusespecularfbo;
255 GLuint r_shadow_prepasslightingdiffusefbo;
256 int r_shadow_prepass_width;
257 int r_shadow_prepass_height;
258 rtexture_t *r_shadow_prepassgeometrydepthtexture;
259 rtexture_t *r_shadow_prepassgeometrydepthcolortexture;
260 rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
261 rtexture_t *r_shadow_prepasslightingdiffusetexture;
262 rtexture_t *r_shadow_prepasslightingspeculartexture;
264 // lights are reloaded when this changes
265 char r_shadow_mapname[MAX_QPATH];
267 // used only for light filters (cubemaps)
268 rtexturepool_t *r_shadow_filters_texturepool;
270 static const GLenum r_shadow_prepasslightingdrawbuffers[2] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
272 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"};
273 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"};
274 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
275 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"};
276 cvar_t r_shadow_deferred_8bitrange = {CVAR_SAVE, "r_shadow_deferred_8bitrange", "4", "dynamic range of image-based lighting when using 32bit color (does not apply to fp)"};
277 //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"};
278 cvar_t r_shadow_usebihculling = {0, "r_shadow_usebihculling", "1", "use BIH (Bounding Interval Hierarchy) for culling lit surfaces instead of BSP (Binary Space Partitioning)"};
279 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
280 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)"};
281 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"};
282 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
283 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
284 cvar_t r_shadow_gloss2exponent = {0, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
285 cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
286 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
287 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
288 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
289 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
290 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "0", "how far to cast shadows"};
291 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)"};
292 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
293 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
294 cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
295 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
296 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)"};
297 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"};
298 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
299 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
300 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"};
301 cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation (slower than compileportalculling but more exact)"};
302 cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};
303 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)"};
304 cvar_t r_shadow_shadowmapping = {CVAR_SAVE, "r_shadow_shadowmapping", "1", "enables use of shadowmapping (depth texture sampling) instead of stencil shadow volumes, requires gl_fbo 1"};
305 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)"};
306 cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
307 cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
308 cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "shadowmap size limit"};
309 cvar_t r_shadow_shadowmapping_maxsize = {CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "shadowmap size limit"};
310 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"};
311 //cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
312 //cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
313 cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
314 cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
315 cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
316 cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
317 cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
318 cvar_t r_shadow_sortsurfaces = {0, "r_shadow_sortsurfaces", "1", "improve performance by sorting illuminated surfaces by texture"};
319 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
320 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)"};
321 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)"};
322 cvar_t r_shadow_bouncegrid = {CVAR_SAVE, "r_shadow_bouncegrid", "0", "perform particle tracing for indirect lighting (Global Illumination / radiosity) using a 3D texture covering the scene, only active on levels with realtime lights active (r_shadow_realtime_world is usually required for these)"};
323 cvar_t r_shadow_bouncegrid_bounceanglediffuse = {CVAR_SAVE, "r_shadow_bouncegrid_bounceanglediffuse", "0", "use random bounce direction rather than true reflection, makes some corner areas dark"};
324 cvar_t r_shadow_bouncegrid_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_directionalshading", "0", "use diffuse shading rather than ambient, 3D texture becomes 4x as many pixels to hold the additional data"};
325 cvar_t r_shadow_bouncegrid_dlightparticlemultiplier = {CVAR_SAVE, "r_shadow_bouncegrid_dlightparticlemultiplier", "0", "if set to a high value like 16 this can make dlights look great, but 0 is recommended for performance reasons"};
326 cvar_t r_shadow_bouncegrid_hitmodels = {CVAR_SAVE, "r_shadow_bouncegrid_hitmodels", "0", "enables hitting character model geometry (SLOW)"};
327 cvar_t r_shadow_bouncegrid_intensity = {CVAR_SAVE, "r_shadow_bouncegrid_intensity", "4", "overall brightness of bouncegrid texture"};
328 cvar_t r_shadow_bouncegrid_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_lightradiusscale", "10", "particles stop at this fraction of light radius (can be more than 1)"};
329 cvar_t r_shadow_bouncegrid_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_maxbounce", "5", "maximum number of bounces for a particle (minimum is 1)"};
330 cvar_t r_shadow_bouncegrid_particlebounceintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particlebounceintensity", "4", "amount of energy carried over after each bounce, this is a multiplier of texture color and the result is clamped to 1 or less, to prevent adding energy on each bounce"};
331 cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "2", "brightness of particles contributing to bouncegrid texture"};
332 cvar_t r_shadow_bouncegrid_photons = {CVAR_SAVE, "r_shadow_bouncegrid_photons", "2000", "total photons to shoot per update, divided proportionately between lights"};
333 cvar_t r_shadow_bouncegrid_spacingx = {CVAR_SAVE, "r_shadow_bouncegrid_spacingx", "64", "unit size of bouncegrid pixel on X axis"};
334 cvar_t r_shadow_bouncegrid_spacingy = {CVAR_SAVE, "r_shadow_bouncegrid_spacingy", "64", "unit size of bouncegrid pixel on Y axis"};
335 cvar_t r_shadow_bouncegrid_spacingz = {CVAR_SAVE, "r_shadow_bouncegrid_spacingz", "64", "unit size of bouncegrid pixel on Z axis"};
336 cvar_t r_shadow_bouncegrid_static = {CVAR_SAVE, "r_shadow_bouncegrid_static", "1", "use static radiosity solution (high quality) rather than dynamic (splotchy)"};
337 cvar_t r_shadow_bouncegrid_static_photons = {CVAR_SAVE, "r_shadow_bouncegrid_static_photons", "25000", "photons value to use when in static mode"};
338 cvar_t r_shadow_bouncegrid_static_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when in static mode"};
339 cvar_t r_shadow_bouncegrid_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_stablerandom", "1", "make particle distribution consistent from frame to frame"};
340 cvar_t r_shadow_bouncegrid_updateinterval = {CVAR_SAVE, "r_shadow_bouncegrid_updateinterval", "0", "update bouncegrid texture once per this many seconds, useful values are 0, 0.05, or 1000000"};
341 cvar_t r_shadow_bouncegrid_x = {CVAR_SAVE, "r_shadow_bouncegrid_x", "64", "maximum texture size of bouncegrid on X axis"};
342 cvar_t r_shadow_bouncegrid_y = {CVAR_SAVE, "r_shadow_bouncegrid_y", "64", "maximum texture size of bouncegrid on Y axis"};
343 cvar_t r_shadow_bouncegrid_z = {CVAR_SAVE, "r_shadow_bouncegrid_z", "32", "maximum texture size of bouncegrid on Z axis"};
344 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
345 cvar_t r_coronas_occlusionsizescale = {CVAR_SAVE, "r_coronas_occlusionsizescale", "0.1", "size of light source for corona occlusion checksum the proportion of hidden pixels controls corona intensity"};
346 cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
347 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
348 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
349 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
350 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
351 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
352 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
353 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
354 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
355 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
357 typedef struct r_shadow_bouncegrid_settings_s
360 qboolean bounceanglediffuse;
361 qboolean directionalshading;
362 float dlightparticlemultiplier;
364 float lightradiusscale;
366 float particlebounceintensity;
367 float particleintensity;
372 r_shadow_bouncegrid_settings_t;
374 r_shadow_bouncegrid_settings_t r_shadow_bouncegridsettings;
375 rtexture_t *r_shadow_bouncegridtexture;
376 matrix4x4_t r_shadow_bouncegridmatrix;
377 vec_t r_shadow_bouncegridintensity;
378 qboolean r_shadow_bouncegriddirectional;
379 static double r_shadow_bouncegridtime;
380 static int r_shadow_bouncegridresolution[3];
381 static int r_shadow_bouncegridnumpixels;
382 static unsigned char *r_shadow_bouncegridpixels;
383 static float *r_shadow_bouncegridhighpixels;
385 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
386 #define ATTENTABLESIZE 256
387 // 1D gradient, 2D circle and 3D sphere attenuation textures
388 #define ATTEN1DSIZE 32
389 #define ATTEN2DSIZE 64
390 #define ATTEN3DSIZE 32
392 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
393 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
394 static float r_shadow_attentable[ATTENTABLESIZE+1];
396 rtlight_t *r_shadow_compilingrtlight;
397 static memexpandablearray_t r_shadow_worldlightsarray;
398 dlight_t *r_shadow_selectedlight;
399 dlight_t r_shadow_bufferlight;
400 vec3_t r_editlights_cursorlocation;
401 qboolean r_editlights_lockcursor;
403 extern int con_vislines;
405 void R_Shadow_UncompileWorldLights(void);
406 void R_Shadow_ClearWorldLights(void);
407 void R_Shadow_SaveWorldLights(void);
408 void R_Shadow_LoadWorldLights(void);
409 void R_Shadow_LoadLightsFile(void);
410 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
411 void R_Shadow_EditLights_Reload_f(void);
412 void R_Shadow_ValidateCvars(void);
413 static void R_Shadow_MakeTextures(void);
415 #define EDLIGHTSPRSIZE 8
416 skinframe_t *r_editlights_sprcursor;
417 skinframe_t *r_editlights_sprlight;
418 skinframe_t *r_editlights_sprnoshadowlight;
419 skinframe_t *r_editlights_sprcubemaplight;
420 skinframe_t *r_editlights_sprcubemapnoshadowlight;
421 skinframe_t *r_editlights_sprselection;
423 void R_Shadow_SetShadowMode(void)
425 r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
426 r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20;
427 r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
428 r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
429 r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
430 r_shadow_shadowmaplod = -1;
431 r_shadow_shadowmapsize = 0;
432 r_shadow_shadowmapsampler = false;
433 r_shadow_shadowmappcf = 0;
434 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
435 if ((r_shadow_shadowmapping.integer || r_shadow_deferred.integer) && vid.support.ext_framebuffer_object)
437 switch(vid.renderpath)
439 case RENDERPATH_GL20:
440 if(r_shadow_shadowmapfilterquality < 0)
442 if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
443 r_shadow_shadowmappcf = 1;
444 else if(strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD"))
446 r_shadow_shadowmapsampler = vid.support.arb_shadow;
447 r_shadow_shadowmappcf = 1;
449 else if(strstr(gl_vendor, "ATI"))
450 r_shadow_shadowmappcf = 1;
452 r_shadow_shadowmapsampler = vid.support.arb_shadow;
456 switch (r_shadow_shadowmapfilterquality)
459 r_shadow_shadowmapsampler = vid.support.arb_shadow;
462 r_shadow_shadowmapsampler = vid.support.arb_shadow;
463 r_shadow_shadowmappcf = 1;
466 r_shadow_shadowmappcf = 1;
469 r_shadow_shadowmappcf = 2;
473 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
475 case RENDERPATH_D3D9:
476 case RENDERPATH_D3D10:
477 case RENDERPATH_D3D11:
478 case RENDERPATH_SOFT:
479 r_shadow_shadowmapsampler = false;
480 r_shadow_shadowmappcf = 1;
481 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
483 case RENDERPATH_GL13:
485 case RENDERPATH_GL11:
487 case RENDERPATH_GLES2:
493 qboolean R_Shadow_ShadowMappingEnabled(void)
495 switch (r_shadow_shadowmode)
497 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
504 void R_Shadow_FreeShadowMaps(void)
506 R_Shadow_SetShadowMode();
508 R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d);
512 if (r_shadow_shadowmap2dtexture)
513 R_FreeTexture(r_shadow_shadowmap2dtexture);
514 r_shadow_shadowmap2dtexture = NULL;
516 if (r_shadow_shadowmap2dcolortexture)
517 R_FreeTexture(r_shadow_shadowmap2dcolortexture);
518 r_shadow_shadowmap2dcolortexture = NULL;
520 if (r_shadow_shadowmapvsdcttexture)
521 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
522 r_shadow_shadowmapvsdcttexture = NULL;
525 void r_shadow_start(void)
527 // allocate vertex processing arrays
528 r_shadow_bouncegridpixels = NULL;
529 r_shadow_bouncegridhighpixels = NULL;
530 r_shadow_bouncegridnumpixels = 0;
531 r_shadow_bouncegridtexture = NULL;
532 r_shadow_bouncegriddirectional = false;
533 r_shadow_attenuationgradienttexture = NULL;
534 r_shadow_attenuation2dtexture = NULL;
535 r_shadow_attenuation3dtexture = NULL;
536 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
537 r_shadow_shadowmap2dtexture = NULL;
538 r_shadow_shadowmap2dcolortexture = NULL;
539 r_shadow_shadowmapvsdcttexture = NULL;
540 r_shadow_shadowmapmaxsize = 0;
541 r_shadow_shadowmapsize = 0;
542 r_shadow_shadowmaplod = 0;
543 r_shadow_shadowmapfilterquality = -1;
544 r_shadow_shadowmapdepthbits = 0;
545 r_shadow_shadowmapvsdct = false;
546 r_shadow_shadowmapsampler = false;
547 r_shadow_shadowmappcf = 0;
550 R_Shadow_FreeShadowMaps();
552 r_shadow_texturepool = NULL;
553 r_shadow_filters_texturepool = NULL;
554 R_Shadow_ValidateCvars();
555 R_Shadow_MakeTextures();
556 maxshadowtriangles = 0;
557 shadowelements = NULL;
558 maxshadowvertices = 0;
559 shadowvertex3f = NULL;
567 shadowmarklist = NULL;
572 shadowsideslist = NULL;
573 r_shadow_buffer_numleafpvsbytes = 0;
574 r_shadow_buffer_visitingleafpvs = NULL;
575 r_shadow_buffer_leafpvs = NULL;
576 r_shadow_buffer_leaflist = NULL;
577 r_shadow_buffer_numsurfacepvsbytes = 0;
578 r_shadow_buffer_surfacepvs = NULL;
579 r_shadow_buffer_surfacelist = NULL;
580 r_shadow_buffer_surfacesides = NULL;
581 r_shadow_buffer_numshadowtrispvsbytes = 0;
582 r_shadow_buffer_shadowtrispvs = NULL;
583 r_shadow_buffer_numlighttrispvsbytes = 0;
584 r_shadow_buffer_lighttrispvs = NULL;
586 r_shadow_usingdeferredprepass = false;
587 r_shadow_prepass_width = r_shadow_prepass_height = 0;
590 static void R_Shadow_FreeDeferred(void);
591 void r_shadow_shutdown(void)
594 R_Shadow_UncompileWorldLights();
596 R_Shadow_FreeShadowMaps();
598 r_shadow_usingdeferredprepass = false;
599 if (r_shadow_prepass_width)
600 R_Shadow_FreeDeferred();
601 r_shadow_prepass_width = r_shadow_prepass_height = 0;
604 r_shadow_bouncegridtexture = NULL;
605 r_shadow_bouncegridpixels = NULL;
606 r_shadow_bouncegridhighpixels = NULL;
607 r_shadow_bouncegridnumpixels = 0;
608 r_shadow_bouncegriddirectional = false;
609 r_shadow_attenuationgradienttexture = NULL;
610 r_shadow_attenuation2dtexture = NULL;
611 r_shadow_attenuation3dtexture = NULL;
612 R_FreeTexturePool(&r_shadow_texturepool);
613 R_FreeTexturePool(&r_shadow_filters_texturepool);
614 maxshadowtriangles = 0;
616 Mem_Free(shadowelements);
617 shadowelements = NULL;
619 Mem_Free(shadowvertex3f);
620 shadowvertex3f = NULL;
623 Mem_Free(vertexupdate);
626 Mem_Free(vertexremap);
632 Mem_Free(shadowmark);
635 Mem_Free(shadowmarklist);
636 shadowmarklist = NULL;
641 Mem_Free(shadowsides);
644 Mem_Free(shadowsideslist);
645 shadowsideslist = NULL;
646 r_shadow_buffer_numleafpvsbytes = 0;
647 if (r_shadow_buffer_visitingleafpvs)
648 Mem_Free(r_shadow_buffer_visitingleafpvs);
649 r_shadow_buffer_visitingleafpvs = NULL;
650 if (r_shadow_buffer_leafpvs)
651 Mem_Free(r_shadow_buffer_leafpvs);
652 r_shadow_buffer_leafpvs = NULL;
653 if (r_shadow_buffer_leaflist)
654 Mem_Free(r_shadow_buffer_leaflist);
655 r_shadow_buffer_leaflist = NULL;
656 r_shadow_buffer_numsurfacepvsbytes = 0;
657 if (r_shadow_buffer_surfacepvs)
658 Mem_Free(r_shadow_buffer_surfacepvs);
659 r_shadow_buffer_surfacepvs = NULL;
660 if (r_shadow_buffer_surfacelist)
661 Mem_Free(r_shadow_buffer_surfacelist);
662 r_shadow_buffer_surfacelist = NULL;
663 if (r_shadow_buffer_surfacesides)
664 Mem_Free(r_shadow_buffer_surfacesides);
665 r_shadow_buffer_surfacesides = NULL;
666 r_shadow_buffer_numshadowtrispvsbytes = 0;
667 if (r_shadow_buffer_shadowtrispvs)
668 Mem_Free(r_shadow_buffer_shadowtrispvs);
669 r_shadow_buffer_numlighttrispvsbytes = 0;
670 if (r_shadow_buffer_lighttrispvs)
671 Mem_Free(r_shadow_buffer_lighttrispvs);
674 void r_shadow_newmap(void)
676 if (r_shadow_bouncegridtexture) R_FreeTexture(r_shadow_bouncegridtexture);r_shadow_bouncegridtexture = NULL;
677 if (r_shadow_lightcorona) R_SkinFrame_MarkUsed(r_shadow_lightcorona);
678 if (r_editlights_sprcursor) R_SkinFrame_MarkUsed(r_editlights_sprcursor);
679 if (r_editlights_sprlight) R_SkinFrame_MarkUsed(r_editlights_sprlight);
680 if (r_editlights_sprnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
681 if (r_editlights_sprcubemaplight) R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
682 if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
683 if (r_editlights_sprselection) R_SkinFrame_MarkUsed(r_editlights_sprselection);
684 if (strncmp(cl.worldname, r_shadow_mapname, sizeof(r_shadow_mapname)))
685 R_Shadow_EditLights_Reload_f();
688 void R_Shadow_Init(void)
690 Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
691 Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
692 Cvar_RegisterVariable(&r_shadow_usebihculling);
693 Cvar_RegisterVariable(&r_shadow_usenormalmap);
694 Cvar_RegisterVariable(&r_shadow_debuglight);
695 Cvar_RegisterVariable(&r_shadow_deferred);
696 Cvar_RegisterVariable(&r_shadow_deferred_8bitrange);
697 // Cvar_RegisterVariable(&r_shadow_deferred_fp);
698 Cvar_RegisterVariable(&r_shadow_gloss);
699 Cvar_RegisterVariable(&r_shadow_gloss2intensity);
700 Cvar_RegisterVariable(&r_shadow_glossintensity);
701 Cvar_RegisterVariable(&r_shadow_glossexponent);
702 Cvar_RegisterVariable(&r_shadow_gloss2exponent);
703 Cvar_RegisterVariable(&r_shadow_glossexact);
704 Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
705 Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
706 Cvar_RegisterVariable(&r_shadow_lightintensityscale);
707 Cvar_RegisterVariable(&r_shadow_lightradiusscale);
708 Cvar_RegisterVariable(&r_shadow_projectdistance);
709 Cvar_RegisterVariable(&r_shadow_frontsidecasting);
710 Cvar_RegisterVariable(&r_shadow_realtime_dlight);
711 Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
712 Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
713 Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
714 Cvar_RegisterVariable(&r_shadow_realtime_world);
715 Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
716 Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
717 Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
718 Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
719 Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
720 Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
721 Cvar_RegisterVariable(&r_shadow_scissor);
722 Cvar_RegisterVariable(&r_shadow_shadowmapping);
723 Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
724 Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
725 Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
726 Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
727 Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
728 Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
729 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
730 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
731 Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
732 Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
733 Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
734 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
735 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
736 Cvar_RegisterVariable(&r_shadow_sortsurfaces);
737 Cvar_RegisterVariable(&r_shadow_polygonfactor);
738 Cvar_RegisterVariable(&r_shadow_polygonoffset);
739 Cvar_RegisterVariable(&r_shadow_texture3d);
740 Cvar_RegisterVariable(&r_shadow_bouncegrid);
741 Cvar_RegisterVariable(&r_shadow_bouncegrid_bounceanglediffuse);
742 Cvar_RegisterVariable(&r_shadow_bouncegrid_directionalshading);
743 Cvar_RegisterVariable(&r_shadow_bouncegrid_dlightparticlemultiplier);
744 Cvar_RegisterVariable(&r_shadow_bouncegrid_hitmodels);
745 Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
746 Cvar_RegisterVariable(&r_shadow_bouncegrid_lightradiusscale);
747 Cvar_RegisterVariable(&r_shadow_bouncegrid_maxbounce);
748 Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
749 Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
750 Cvar_RegisterVariable(&r_shadow_bouncegrid_photons);
751 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingx);
752 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingy);
753 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingz);
754 Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
755 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_photons);
756 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
757 Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom);
758 Cvar_RegisterVariable(&r_shadow_bouncegrid_updateinterval);
759 Cvar_RegisterVariable(&r_shadow_bouncegrid_x);
760 Cvar_RegisterVariable(&r_shadow_bouncegrid_y);
761 Cvar_RegisterVariable(&r_shadow_bouncegrid_z);
762 Cvar_RegisterVariable(&r_coronas);
763 Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
764 Cvar_RegisterVariable(&r_coronas_occlusionquery);
765 Cvar_RegisterVariable(&gl_flashblend);
766 Cvar_RegisterVariable(&gl_ext_separatestencil);
767 Cvar_RegisterVariable(&gl_ext_stenciltwoside);
768 R_Shadow_EditLights_Init();
769 Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
770 maxshadowtriangles = 0;
771 shadowelements = NULL;
772 maxshadowvertices = 0;
773 shadowvertex3f = NULL;
781 shadowmarklist = NULL;
786 shadowsideslist = NULL;
787 r_shadow_buffer_numleafpvsbytes = 0;
788 r_shadow_buffer_visitingleafpvs = NULL;
789 r_shadow_buffer_leafpvs = NULL;
790 r_shadow_buffer_leaflist = NULL;
791 r_shadow_buffer_numsurfacepvsbytes = 0;
792 r_shadow_buffer_surfacepvs = NULL;
793 r_shadow_buffer_surfacelist = NULL;
794 r_shadow_buffer_surfacesides = NULL;
795 r_shadow_buffer_shadowtrispvs = NULL;
796 r_shadow_buffer_lighttrispvs = NULL;
797 R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
800 matrix4x4_t matrix_attenuationxyz =
803 {0.5, 0.0, 0.0, 0.5},
804 {0.0, 0.5, 0.0, 0.5},
805 {0.0, 0.0, 0.5, 0.5},
810 matrix4x4_t matrix_attenuationz =
813 {0.0, 0.0, 0.5, 0.5},
814 {0.0, 0.0, 0.0, 0.5},
815 {0.0, 0.0, 0.0, 0.5},
820 void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
822 numvertices = ((numvertices + 255) & ~255) * vertscale;
823 numtriangles = ((numtriangles + 255) & ~255) * triscale;
824 // make sure shadowelements is big enough for this volume
825 if (maxshadowtriangles < numtriangles)
827 maxshadowtriangles = numtriangles;
829 Mem_Free(shadowelements);
830 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
832 // make sure shadowvertex3f is big enough for this volume
833 if (maxshadowvertices < numvertices)
835 maxshadowvertices = numvertices;
837 Mem_Free(shadowvertex3f);
838 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
842 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
844 int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
845 int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
846 int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
847 int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
848 if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
850 if (r_shadow_buffer_visitingleafpvs)
851 Mem_Free(r_shadow_buffer_visitingleafpvs);
852 if (r_shadow_buffer_leafpvs)
853 Mem_Free(r_shadow_buffer_leafpvs);
854 if (r_shadow_buffer_leaflist)
855 Mem_Free(r_shadow_buffer_leaflist);
856 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
857 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
858 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
859 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
861 if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
863 if (r_shadow_buffer_surfacepvs)
864 Mem_Free(r_shadow_buffer_surfacepvs);
865 if (r_shadow_buffer_surfacelist)
866 Mem_Free(r_shadow_buffer_surfacelist);
867 if (r_shadow_buffer_surfacesides)
868 Mem_Free(r_shadow_buffer_surfacesides);
869 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
870 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
871 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
872 r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
874 if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
876 if (r_shadow_buffer_shadowtrispvs)
877 Mem_Free(r_shadow_buffer_shadowtrispvs);
878 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
879 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
881 if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
883 if (r_shadow_buffer_lighttrispvs)
884 Mem_Free(r_shadow_buffer_lighttrispvs);
885 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
886 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
890 void R_Shadow_PrepareShadowMark(int numtris)
892 // make sure shadowmark is big enough for this volume
893 if (maxshadowmark < numtris)
895 maxshadowmark = numtris;
897 Mem_Free(shadowmark);
899 Mem_Free(shadowmarklist);
900 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
901 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
905 // if shadowmarkcount wrapped we clear the array and adjust accordingly
906 if (shadowmarkcount == 0)
909 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
914 void R_Shadow_PrepareShadowSides(int numtris)
916 if (maxshadowsides < numtris)
918 maxshadowsides = numtris;
920 Mem_Free(shadowsides);
922 Mem_Free(shadowsideslist);
923 shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
924 shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
929 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)
932 int outtriangles = 0, outvertices = 0;
935 float ratio, direction[3], projectvector[3];
937 if (projectdirection)
938 VectorScale(projectdirection, projectdistance, projectvector);
940 VectorClear(projectvector);
942 // create the vertices
943 if (projectdirection)
945 for (i = 0;i < numshadowmarktris;i++)
947 element = inelement3i + shadowmarktris[i] * 3;
948 for (j = 0;j < 3;j++)
950 if (vertexupdate[element[j]] != vertexupdatenum)
952 vertexupdate[element[j]] = vertexupdatenum;
953 vertexremap[element[j]] = outvertices;
954 vertex = invertex3f + element[j] * 3;
955 // project one copy of the vertex according to projectvector
956 VectorCopy(vertex, outvertex3f);
957 VectorAdd(vertex, projectvector, (outvertex3f + 3));
966 for (i = 0;i < numshadowmarktris;i++)
968 element = inelement3i + shadowmarktris[i] * 3;
969 for (j = 0;j < 3;j++)
971 if (vertexupdate[element[j]] != vertexupdatenum)
973 vertexupdate[element[j]] = vertexupdatenum;
974 vertexremap[element[j]] = outvertices;
975 vertex = invertex3f + element[j] * 3;
976 // project one copy of the vertex to the sphere radius of the light
977 // (FIXME: would projecting it to the light box be better?)
978 VectorSubtract(vertex, projectorigin, direction);
979 ratio = projectdistance / VectorLength(direction);
980 VectorCopy(vertex, outvertex3f);
981 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
989 if (r_shadow_frontsidecasting.integer)
991 for (i = 0;i < numshadowmarktris;i++)
993 int remappedelement[3];
995 const int *neighbortriangle;
997 markindex = shadowmarktris[i] * 3;
998 element = inelement3i + markindex;
999 neighbortriangle = inneighbor3i + markindex;
1000 // output the front and back triangles
1001 outelement3i[0] = vertexremap[element[0]];
1002 outelement3i[1] = vertexremap[element[1]];
1003 outelement3i[2] = vertexremap[element[2]];
1004 outelement3i[3] = vertexremap[element[2]] + 1;
1005 outelement3i[4] = vertexremap[element[1]] + 1;
1006 outelement3i[5] = vertexremap[element[0]] + 1;
1010 // output the sides (facing outward from this triangle)
1011 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1013 remappedelement[0] = vertexremap[element[0]];
1014 remappedelement[1] = vertexremap[element[1]];
1015 outelement3i[0] = remappedelement[1];
1016 outelement3i[1] = remappedelement[0];
1017 outelement3i[2] = remappedelement[0] + 1;
1018 outelement3i[3] = remappedelement[1];
1019 outelement3i[4] = remappedelement[0] + 1;
1020 outelement3i[5] = remappedelement[1] + 1;
1025 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1027 remappedelement[1] = vertexremap[element[1]];
1028 remappedelement[2] = vertexremap[element[2]];
1029 outelement3i[0] = remappedelement[2];
1030 outelement3i[1] = remappedelement[1];
1031 outelement3i[2] = remappedelement[1] + 1;
1032 outelement3i[3] = remappedelement[2];
1033 outelement3i[4] = remappedelement[1] + 1;
1034 outelement3i[5] = remappedelement[2] + 1;
1039 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1041 remappedelement[0] = vertexremap[element[0]];
1042 remappedelement[2] = vertexremap[element[2]];
1043 outelement3i[0] = remappedelement[0];
1044 outelement3i[1] = remappedelement[2];
1045 outelement3i[2] = remappedelement[2] + 1;
1046 outelement3i[3] = remappedelement[0];
1047 outelement3i[4] = remappedelement[2] + 1;
1048 outelement3i[5] = remappedelement[0] + 1;
1057 for (i = 0;i < numshadowmarktris;i++)
1059 int remappedelement[3];
1061 const int *neighbortriangle;
1063 markindex = shadowmarktris[i] * 3;
1064 element = inelement3i + markindex;
1065 neighbortriangle = inneighbor3i + markindex;
1066 // output the front and back triangles
1067 outelement3i[0] = vertexremap[element[2]];
1068 outelement3i[1] = vertexremap[element[1]];
1069 outelement3i[2] = vertexremap[element[0]];
1070 outelement3i[3] = vertexremap[element[0]] + 1;
1071 outelement3i[4] = vertexremap[element[1]] + 1;
1072 outelement3i[5] = vertexremap[element[2]] + 1;
1076 // output the sides (facing outward from this triangle)
1077 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1079 remappedelement[0] = vertexremap[element[0]];
1080 remappedelement[1] = vertexremap[element[1]];
1081 outelement3i[0] = remappedelement[0];
1082 outelement3i[1] = remappedelement[1];
1083 outelement3i[2] = remappedelement[1] + 1;
1084 outelement3i[3] = remappedelement[0];
1085 outelement3i[4] = remappedelement[1] + 1;
1086 outelement3i[5] = remappedelement[0] + 1;
1091 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1093 remappedelement[1] = vertexremap[element[1]];
1094 remappedelement[2] = vertexremap[element[2]];
1095 outelement3i[0] = remappedelement[1];
1096 outelement3i[1] = remappedelement[2];
1097 outelement3i[2] = remappedelement[2] + 1;
1098 outelement3i[3] = remappedelement[1];
1099 outelement3i[4] = remappedelement[2] + 1;
1100 outelement3i[5] = remappedelement[1] + 1;
1105 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1107 remappedelement[0] = vertexremap[element[0]];
1108 remappedelement[2] = vertexremap[element[2]];
1109 outelement3i[0] = remappedelement[2];
1110 outelement3i[1] = remappedelement[0];
1111 outelement3i[2] = remappedelement[0] + 1;
1112 outelement3i[3] = remappedelement[2];
1113 outelement3i[4] = remappedelement[0] + 1;
1114 outelement3i[5] = remappedelement[2] + 1;
1122 *outnumvertices = outvertices;
1123 return outtriangles;
1126 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)
1129 int outtriangles = 0, outvertices = 0;
1131 const float *vertex;
1132 float ratio, direction[3], projectvector[3];
1135 if (projectdirection)
1136 VectorScale(projectdirection, projectdistance, projectvector);
1138 VectorClear(projectvector);
1140 for (i = 0;i < numshadowmarktris;i++)
1142 int remappedelement[3];
1144 const int *neighbortriangle;
1146 markindex = shadowmarktris[i] * 3;
1147 neighbortriangle = inneighbor3i + markindex;
1148 side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
1149 side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
1150 side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
1151 if (side[0] + side[1] + side[2] == 0)
1155 element = inelement3i + markindex;
1157 // create the vertices
1158 for (j = 0;j < 3;j++)
1160 if (side[j] + side[j+1] == 0)
1163 if (vertexupdate[k] != vertexupdatenum)
1165 vertexupdate[k] = vertexupdatenum;
1166 vertexremap[k] = outvertices;
1167 vertex = invertex3f + k * 3;
1168 VectorCopy(vertex, outvertex3f);
1169 if (projectdirection)
1171 // project one copy of the vertex according to projectvector
1172 VectorAdd(vertex, projectvector, (outvertex3f + 3));
1176 // project one copy of the vertex to the sphere radius of the light
1177 // (FIXME: would projecting it to the light box be better?)
1178 VectorSubtract(vertex, projectorigin, direction);
1179 ratio = projectdistance / VectorLength(direction);
1180 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
1187 // output the sides (facing outward from this triangle)
1190 remappedelement[0] = vertexremap[element[0]];
1191 remappedelement[1] = vertexremap[element[1]];
1192 outelement3i[0] = remappedelement[1];
1193 outelement3i[1] = remappedelement[0];
1194 outelement3i[2] = remappedelement[0] + 1;
1195 outelement3i[3] = remappedelement[1];
1196 outelement3i[4] = remappedelement[0] + 1;
1197 outelement3i[5] = remappedelement[1] + 1;
1204 remappedelement[1] = vertexremap[element[1]];
1205 remappedelement[2] = vertexremap[element[2]];
1206 outelement3i[0] = remappedelement[2];
1207 outelement3i[1] = remappedelement[1];
1208 outelement3i[2] = remappedelement[1] + 1;
1209 outelement3i[3] = remappedelement[2];
1210 outelement3i[4] = remappedelement[1] + 1;
1211 outelement3i[5] = remappedelement[2] + 1;
1218 remappedelement[0] = vertexremap[element[0]];
1219 remappedelement[2] = vertexremap[element[2]];
1220 outelement3i[0] = remappedelement[0];
1221 outelement3i[1] = remappedelement[2];
1222 outelement3i[2] = remappedelement[2] + 1;
1223 outelement3i[3] = remappedelement[0];
1224 outelement3i[4] = remappedelement[2] + 1;
1225 outelement3i[5] = remappedelement[0] + 1;
1232 *outnumvertices = outvertices;
1233 return outtriangles;
1236 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)
1242 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1244 tend = firsttriangle + numtris;
1245 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1247 // surface box entirely inside light box, no box cull
1248 if (projectdirection)
1250 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1252 TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal);
1253 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1254 shadowmarklist[numshadowmark++] = t;
1259 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1260 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
1261 shadowmarklist[numshadowmark++] = t;
1266 // surface box not entirely inside light box, cull each triangle
1267 if (projectdirection)
1269 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1271 v[0] = invertex3f + e[0] * 3;
1272 v[1] = invertex3f + e[1] * 3;
1273 v[2] = invertex3f + e[2] * 3;
1274 TriangleNormal(v[0], v[1], v[2], normal);
1275 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1276 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1277 shadowmarklist[numshadowmark++] = t;
1282 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1284 v[0] = invertex3f + e[0] * 3;
1285 v[1] = invertex3f + e[1] * 3;
1286 v[2] = invertex3f + e[2] * 3;
1287 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1288 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1289 shadowmarklist[numshadowmark++] = t;
1295 qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
1300 if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
1302 // check if the shadow volume intersects the near plane
1304 // a ray between the eye and light origin may intersect the caster,
1305 // indicating that the shadow may touch the eye location, however we must
1306 // test the near plane (a polygon), not merely the eye location, so it is
1307 // easiest to enlarge the caster bounding shape slightly for this.
1313 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)
1315 int i, tris, outverts;
1316 if (projectdistance < 0.1)
1318 Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
1321 if (!numverts || !nummarktris)
1323 // make sure shadowelements is big enough for this volume
1324 if (maxshadowtriangles < nummarktris*8 || maxshadowvertices < numverts*2)
1325 R_Shadow_ResizeShadowArrays(numverts, nummarktris, 2, 8);
1327 if (maxvertexupdate < numverts)
1329 maxvertexupdate = numverts;
1331 Mem_Free(vertexupdate);
1333 Mem_Free(vertexremap);
1334 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1335 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1336 vertexupdatenum = 0;
1339 if (vertexupdatenum == 0)
1341 vertexupdatenum = 1;
1342 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
1343 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
1346 for (i = 0;i < nummarktris;i++)
1347 shadowmark[marktris[i]] = shadowmarkcount;
1349 if (r_shadow_compilingrtlight)
1351 // if we're compiling an rtlight, capture the mesh
1352 //tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1353 //Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1354 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1355 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1357 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
1359 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1360 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1361 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1365 // decide which type of shadow to generate and set stencil mode
1366 R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
1367 // generate the sides or a solid volume, depending on type
1368 if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
1369 tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1371 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1372 r_refdef.stats.lights_dynamicshadowtriangles += tris;
1373 r_refdef.stats.lights_shadowtriangles += tris;
1374 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
1376 // increment stencil if frontface is infront of depthbuffer
1377 GL_CullFace(r_refdef.view.cullface_front);
1378 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
1379 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1380 // decrement stencil if backface is infront of depthbuffer
1381 GL_CullFace(r_refdef.view.cullface_back);
1382 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
1384 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
1386 // decrement stencil if backface is behind depthbuffer
1387 GL_CullFace(r_refdef.view.cullface_front);
1388 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
1389 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1390 // increment stencil if frontface is behind depthbuffer
1391 GL_CullFace(r_refdef.view.cullface_back);
1392 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
1394 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1395 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1399 int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
1401 // p1, p2, p3 are in the cubemap's local coordinate system
1402 // bias = border/(size - border)
1405 float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1406 dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
1407 dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
1408 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1410 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1411 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1412 | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1413 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1415 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1416 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1417 | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1419 dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1420 dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
1421 dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
1422 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1424 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1425 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1426 | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1427 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1429 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1430 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1431 | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1433 dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1434 dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
1435 dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
1436 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1438 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1439 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1440 | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1441 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1443 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1444 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1445 | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1450 int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
1452 vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
1453 float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
1456 VectorSubtract(maxs, mins, radius);
1457 VectorScale(radius, 0.5f, radius);
1458 VectorAdd(mins, radius, center);
1459 Matrix4x4_Transform(worldtolight, center, lightcenter);
1460 Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
1461 VectorSubtract(lightcenter, lightradius, pmin);
1462 VectorAdd(lightcenter, lightradius, pmax);
1464 dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1465 dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
1466 if(ap1 > bias*an1 && ap2 > bias*an2)
1468 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1469 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1470 if(an1 > bias*ap1 && an2 > bias*ap2)
1472 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1473 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1475 dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1476 dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
1477 if(ap1 > bias*an1 && ap2 > bias*an2)
1479 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1480 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1481 if(an1 > bias*ap1 && an2 > bias*ap2)
1483 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1484 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1486 dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1487 dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
1488 if(ap1 > bias*an1 && ap2 > bias*an2)
1490 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1491 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1492 if(an1 > bias*ap1 && an2 > bias*ap2)
1494 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1495 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1500 #define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
1502 int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
1504 // p is in the cubemap's local coordinate system
1505 // bias = border/(size - border)
1506 float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
1507 float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
1508 float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
1510 if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
1511 if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
1512 if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
1513 if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
1514 if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
1515 if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
1519 int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
1523 int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
1524 float scale = (size - 2*border)/size, len;
1525 float bias = border / (float)(size - border), dp, dn, ap, an;
1526 // check if cone enclosing side would cross frustum plane
1527 scale = 2 / (scale*scale + 2);
1528 for (i = 0;i < 5;i++)
1530 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) > -0.03125)
1532 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
1533 len = scale*VectorLength2(n);
1534 if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
1535 if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
1536 if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
1538 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
1540 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
1541 len = scale*VectorLength(n);
1542 if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
1543 if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
1544 if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
1546 // this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
1547 // check if frustum corners/origin cross plane sides
1549 // infinite version, assumes frustum corners merely give direction and extend to infinite distance
1550 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.origin, p);
1551 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1552 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1553 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1554 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1555 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1556 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1557 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1558 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1559 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1560 for (i = 0;i < 4;i++)
1562 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.frustumcorner[i], n);
1563 VectorSubtract(n, p, n);
1564 dp = n[0] + n[1], dn = n[0] - n[1], ap = fabs(dp), an = fabs(dn);
1565 if(ap > 0) masks[0] |= dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2);
1566 if(an > 0) masks[1] |= dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2);
1567 dp = n[1] + n[2], dn = n[1] - n[2], ap = fabs(dp), an = fabs(dn);
1568 if(ap > 0) masks[2] |= dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4);
1569 if(an > 0) masks[3] |= dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4);
1570 dp = n[2] + n[0], dn = n[2] - n[0], ap = fabs(dp), an = fabs(dn);
1571 if(ap > 0) masks[4] |= dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0);
1572 if(an > 0) masks[5] |= dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0);
1575 // finite version, assumes corners are a finite distance from origin dependent on far plane
1576 for (i = 0;i < 5;i++)
1578 Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
1579 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1580 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1581 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1582 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1583 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1584 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1585 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1586 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1587 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1590 return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
1593 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)
1601 int mask, surfacemask = 0;
1602 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1604 bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
1605 tend = firsttriangle + numtris;
1606 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1608 // surface box entirely inside light box, no box cull
1609 if (projectdirection)
1611 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1613 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1614 TriangleNormal(v[0], v[1], v[2], normal);
1615 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1617 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1618 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1619 surfacemask |= mask;
1622 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;
1623 shadowsides[numshadowsides] = mask;
1624 shadowsideslist[numshadowsides++] = t;
1631 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1633 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1634 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
1636 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1637 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1638 surfacemask |= mask;
1641 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;
1642 shadowsides[numshadowsides] = mask;
1643 shadowsideslist[numshadowsides++] = t;
1651 // surface box not entirely inside light box, cull each triangle
1652 if (projectdirection)
1654 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1656 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1657 TriangleNormal(v[0], v[1], v[2], normal);
1658 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1659 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1661 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1662 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1663 surfacemask |= mask;
1666 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;
1667 shadowsides[numshadowsides] = mask;
1668 shadowsideslist[numshadowsides++] = t;
1675 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1677 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1678 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1679 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1681 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1682 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1683 surfacemask |= mask;
1686 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;
1687 shadowsides[numshadowsides] = mask;
1688 shadowsideslist[numshadowsides++] = t;
1697 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)
1699 int i, j, outtriangles = 0;
1700 int *outelement3i[6];
1701 if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
1703 outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
1704 // make sure shadowelements is big enough for this mesh
1705 if (maxshadowtriangles < outtriangles)
1706 R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
1708 // compute the offset and size of the separate index lists for each cubemap side
1710 for (i = 0;i < 6;i++)
1712 outelement3i[i] = shadowelements + outtriangles * 3;
1713 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
1714 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
1715 outtriangles += sidetotals[i];
1718 // gather up the (sparse) triangles into separate index lists for each cubemap side
1719 for (i = 0;i < numsidetris;i++)
1721 const int *element = elements + sidetris[i] * 3;
1722 for (j = 0;j < 6;j++)
1724 if (sides[i] & (1 << j))
1726 outelement3i[j][0] = element[0];
1727 outelement3i[j][1] = element[1];
1728 outelement3i[j][2] = element[2];
1729 outelement3i[j] += 3;
1734 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, outtriangles, shadowelements);
1737 static void R_Shadow_MakeTextures_MakeCorona(void)
1741 unsigned char pixels[32][32][4];
1742 for (y = 0;y < 32;y++)
1744 dy = (y - 15.5f) * (1.0f / 16.0f);
1745 for (x = 0;x < 32;x++)
1747 dx = (x - 15.5f) * (1.0f / 16.0f);
1748 a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1749 a = bound(0, a, 255);
1750 pixels[y][x][0] = a;
1751 pixels[y][x][1] = a;
1752 pixels[y][x][2] = a;
1753 pixels[y][x][3] = 255;
1756 r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32);
1759 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1761 float dist = sqrt(x*x+y*y+z*z);
1762 float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1763 // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1764 return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1767 static void R_Shadow_MakeTextures(void)
1770 float intensity, dist;
1772 R_Shadow_FreeShadowMaps();
1773 R_FreeTexturePool(&r_shadow_texturepool);
1774 r_shadow_texturepool = R_AllocTexturePool();
1775 r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1776 r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1777 data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1778 // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1779 for (x = 0;x <= ATTENTABLESIZE;x++)
1781 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1782 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1783 r_shadow_attentable[x] = bound(0, intensity, 1);
1785 // 1D gradient texture
1786 for (x = 0;x < ATTEN1DSIZE;x++)
1787 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1788 r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1789 // 2D circle texture
1790 for (y = 0;y < ATTEN2DSIZE;y++)
1791 for (x = 0;x < ATTEN2DSIZE;x++)
1792 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);
1793 r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1794 // 3D sphere texture
1795 if (r_shadow_texture3d.integer && vid.support.ext_texture_3d)
1797 for (z = 0;z < ATTEN3DSIZE;z++)
1798 for (y = 0;y < ATTEN3DSIZE;y++)
1799 for (x = 0;x < ATTEN3DSIZE;x++)
1800 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));
1801 r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1804 r_shadow_attenuation3dtexture = NULL;
1807 R_Shadow_MakeTextures_MakeCorona();
1809 // Editor light sprites
1810 r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1827 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1828 r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1845 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1846 r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1863 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1864 r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1881 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1882 r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1899 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1900 r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
1917 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1920 void R_Shadow_ValidateCvars(void)
1922 if (r_shadow_texture3d.integer && !vid.support.ext_texture_3d)
1923 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
1924 if (gl_ext_separatestencil.integer && !vid.support.ati_separate_stencil)
1925 Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
1926 if (gl_ext_stenciltwoside.integer && !vid.support.ext_stencil_two_side)
1927 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
1930 void R_Shadow_RenderMode_Begin(void)
1936 R_Shadow_ValidateCvars();
1938 if (!r_shadow_attenuation2dtexture
1939 || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
1940 || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1941 || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1942 R_Shadow_MakeTextures();
1945 R_Mesh_ResetTextureState();
1946 GL_BlendFunc(GL_ONE, GL_ZERO);
1947 GL_DepthRange(0, 1);
1948 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1950 GL_DepthMask(false);
1951 GL_Color(0, 0, 0, 1);
1952 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
1954 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1956 if (gl_ext_separatestencil.integer && vid.support.ati_separate_stencil)
1958 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
1959 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
1961 else if (gl_ext_stenciltwoside.integer && vid.support.ext_stencil_two_side)
1963 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
1964 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
1968 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
1969 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
1972 switch(vid.renderpath)
1974 case RENDERPATH_GL20:
1975 case RENDERPATH_D3D9:
1976 case RENDERPATH_D3D10:
1977 case RENDERPATH_D3D11:
1978 case RENDERPATH_SOFT:
1979 case RENDERPATH_GLES2:
1980 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1982 case RENDERPATH_GL13:
1983 case RENDERPATH_GL11:
1984 if (r_textureunits.integer >= 2 && vid.texunits >= 2 && r_shadow_texture3d.integer && r_shadow_attenuation3dtexture)
1985 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN;
1986 else if (r_textureunits.integer >= 3 && vid.texunits >= 3)
1987 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN;
1988 else if (r_textureunits.integer >= 2 && vid.texunits >= 2)
1989 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN;
1991 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
1997 qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
1998 qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
1999 r_shadow_drawbuffer = drawbuffer;
2000 r_shadow_readbuffer = readbuffer;
2002 r_shadow_cullface_front = r_refdef.view.cullface_front;
2003 r_shadow_cullface_back = r_refdef.view.cullface_back;
2006 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
2008 rsurface.rtlight = rtlight;
2011 void R_Shadow_RenderMode_Reset(void)
2013 R_Mesh_ResetRenderTargets();
2014 R_SetViewport(&r_refdef.view.viewport);
2015 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
2016 R_Mesh_ResetTextureState();
2017 GL_DepthRange(0, 1);
2019 GL_DepthMask(false);
2020 GL_DepthFunc(GL_LEQUAL);
2021 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
2022 r_refdef.view.cullface_front = r_shadow_cullface_front;
2023 r_refdef.view.cullface_back = r_shadow_cullface_back;
2024 GL_CullFace(r_refdef.view.cullface_back);
2025 GL_Color(1, 1, 1, 1);
2026 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
2027 GL_BlendFunc(GL_ONE, GL_ZERO);
2028 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
2029 r_shadow_usingshadowmap2d = false;
2030 r_shadow_usingshadowmaportho = false;
2031 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2034 void R_Shadow_ClearStencil(void)
2036 GL_Clear(GL_STENCIL_BUFFER_BIT, NULL, 1.0f, 128);
2037 r_refdef.stats.lights_clears++;
2040 void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
2042 r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
2043 if (r_shadow_rendermode == mode)
2045 R_Shadow_RenderMode_Reset();
2046 GL_DepthFunc(GL_LESS);
2047 GL_ColorMask(0, 0, 0, 0);
2048 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2049 GL_CullFace(GL_NONE);
2050 R_SetupShader_DepthOrShadow();
2051 r_shadow_rendermode = mode;
2056 case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
2057 case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
2058 R_SetStencilSeparate(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, GL_ALWAYS, 128, 255);
2060 case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
2061 case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
2062 R_SetStencilSeparate(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, GL_ALWAYS, 128, 255);
2067 static void R_Shadow_MakeVSDCT(void)
2069 // maps to a 2x3 texture rectangle with normalized coordinates
2074 // stores abs(dir.xy), offset.xy/2.5
2075 unsigned char data[4*6] =
2077 255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
2078 255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
2079 0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
2080 0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
2081 0, 0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
2082 0, 0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
2084 r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2087 static void R_Shadow_MakeShadowMap(int side, int size)
2089 switch (r_shadow_shadowmode)
2091 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
2092 if (r_shadow_shadowmap2dtexture) return;
2093 r_shadow_shadowmap2dtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2094 r_shadow_shadowmap2dcolortexture = NULL;
2095 switch(vid.renderpath)
2098 case RENDERPATH_D3D9:
2099 r_shadow_shadowmap2dcolortexture = R_LoadTexture2D(r_shadow_texturepool, "shadowmaprendertarget", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), NULL, TEXTYPE_BGRA, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2100 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
2104 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, NULL, NULL, NULL, NULL);
2112 // render depth into the fbo, do not render color at all
2113 // validate the fbo now
2117 qglDrawBuffer(GL_NONE);CHECKGLERROR
2118 qglReadBuffer(GL_NONE);CHECKGLERROR
2119 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2120 if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2122 Con_Printf("R_Shadow_MakeShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2123 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2124 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2129 void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size)
2131 float nearclip, farclip, bias;
2132 r_viewport_t viewport;
2135 float clearcolor[4];
2136 nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
2138 bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
2139 r_shadow_shadowmap_parameters[1] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
2140 r_shadow_shadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
2141 r_shadow_shadowmapside = side;
2142 r_shadow_shadowmapsize = size;
2144 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2145 r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2146 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2147 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
2149 // complex unrolled cube approach (more flexible)
2150 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2151 R_Shadow_MakeVSDCT();
2152 if (!r_shadow_shadowmap2dtexture)
2153 R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize);
2154 if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d;
2155 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
2156 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
2157 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2159 R_Mesh_ResetTextureState();
2160 R_Mesh_ResetRenderTargets();
2161 R_Shadow_RenderMode_Reset();
2164 R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
2165 R_SetupShader_DepthOrShadow();
2168 R_SetupShader_ShowDepth();
2169 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2174 R_SetViewport(&viewport);
2175 flipped = (side & 1) ^ (side >> 2);
2176 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2177 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2178 switch(vid.renderpath)
2180 case RENDERPATH_GL11:
2181 case RENDERPATH_GL13:
2182 case RENDERPATH_GL20:
2183 case RENDERPATH_SOFT:
2184 case RENDERPATH_GLES2:
2185 GL_CullFace(r_refdef.view.cullface_back);
2186 // OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once
2187 if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask
2189 // get tightest scissor rectangle that encloses all viewports in the clear mask
2190 int x1 = clear & 0x15 ? 0 : size;
2191 int x2 = clear & 0x2A ? 2 * size : size;
2192 int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size);
2193 int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size);
2194 GL_Scissor(x1, y1, x2 - x1, y2 - y1);
2195 GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
2197 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2199 case RENDERPATH_D3D9:
2200 case RENDERPATH_D3D10:
2201 case RENDERPATH_D3D11:
2202 Vector4Set(clearcolor, 1,1,1,1);
2203 // completely different meaning than in OpenGL path
2204 r_shadow_shadowmap_parameters[1] = 0;
2205 r_shadow_shadowmap_parameters[3] = -bias;
2206 // we invert the cull mode because we flip the projection matrix
2207 // NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided...
2208 GL_CullFace(r_refdef.view.cullface_front);
2209 // D3D considers it an error to use a scissor larger than the viewport... clear just this view
2210 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2211 if (r_shadow_shadowmapsampler)
2213 GL_ColorMask(0,0,0,0);
2215 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
2219 GL_ColorMask(1,1,1,1);
2221 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
2227 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2229 R_Mesh_ResetTextureState();
2230 R_Mesh_ResetRenderTargets();
2233 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2234 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2235 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2236 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2238 R_Shadow_RenderMode_Reset();
2239 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2241 GL_DepthFunc(GL_EQUAL);
2242 // do global setup needed for the chosen lighting mode
2243 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2244 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2245 r_shadow_usingshadowmap2d = shadowmapping;
2246 r_shadow_rendermode = r_shadow_lightingrendermode;
2247 // only draw light where this geometry was already rendered AND the
2248 // stencil is 128 (values other than this mean shadow)
2250 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2252 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2255 static const unsigned short bboxelements[36] =
2265 static const float bboxpoints[8][3] =
2277 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2280 float vertex3f[8*3];
2281 const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2282 // do global setup needed for the chosen lighting mode
2283 R_Shadow_RenderMode_Reset();
2284 r_shadow_rendermode = r_shadow_lightingrendermode;
2285 R_EntityMatrix(&identitymatrix);
2286 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2287 // only draw light where this geometry was already rendered AND the
2288 // stencil is 128 (values other than this mean shadow)
2289 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2290 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
2292 r_shadow_usingshadowmap2d = shadowmapping;
2294 // render the lighting
2295 R_SetupShader_DeferredLight(rsurface.rtlight);
2296 for (i = 0;i < 8;i++)
2297 Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2298 GL_ColorMask(1,1,1,1);
2299 GL_DepthMask(false);
2300 GL_DepthRange(0, 1);
2301 GL_PolygonOffset(0, 0);
2303 GL_DepthFunc(GL_GREATER);
2304 GL_CullFace(r_refdef.view.cullface_back);
2305 R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL);
2306 R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
2309 static void R_Shadow_UpdateBounceGridTexture(void)
2311 #define MAXBOUNCEGRIDPARTICLESPERLIGHT 1048576
2313 int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2315 int hitsupercontentsmask;
2324 //trace_t cliptrace2;
2325 //trace_t cliptrace3;
2326 unsigned char *pixel;
2327 unsigned char *pixels;
2330 unsigned int lightindex;
2332 unsigned int range1;
2333 unsigned int range2;
2334 unsigned int seed = (unsigned int)(realtime * 1000.0f);
2336 vec3_t baseshotcolor;
2349 vec_t lightintensity;
2350 vec_t photonscaling;
2351 vec_t photonresidual;
2353 float texlerp[2][3];
2354 float splatcolor[16];
2355 float pixelweight[8];
2362 r_shadow_bouncegrid_settings_t settings;
2363 qboolean enable = r_shadow_bouncegrid.integer != 0 && r_refdef.scene.worldmodel;
2364 qboolean allowdirectionalshading = false;
2365 switch(vid.renderpath)
2367 case RENDERPATH_GL20:
2368 allowdirectionalshading = true;
2369 if (!vid.support.ext_texture_3d)
2372 case RENDERPATH_GLES2:
2373 // for performance reasons, do not use directional shading on GLES devices
2374 if (!vid.support.ext_texture_3d)
2377 // these renderpaths do not currently have the code to display the bouncegrid, so disable it on them...
2378 case RENDERPATH_GL11:
2379 case RENDERPATH_GL13:
2380 case RENDERPATH_SOFT:
2381 case RENDERPATH_D3D9:
2382 case RENDERPATH_D3D10:
2383 case RENDERPATH_D3D11:
2387 r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value;
2391 if (r_shadow_bouncegridtexture)
2393 R_FreeTexture(r_shadow_bouncegridtexture);
2394 r_shadow_bouncegridtexture = NULL;
2396 if (r_shadow_bouncegridpixels)
2397 Mem_Free(r_shadow_bouncegridpixels);
2398 r_shadow_bouncegridpixels = NULL;
2399 if (r_shadow_bouncegridhighpixels)
2400 Mem_Free(r_shadow_bouncegridhighpixels);
2401 r_shadow_bouncegridhighpixels = NULL;
2402 r_shadow_bouncegridnumpixels = 0;
2403 r_shadow_bouncegriddirectional = false;
2407 // build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
2408 settings.staticmode = r_shadow_bouncegrid_static.integer != 0;
2409 settings.bounceanglediffuse = r_shadow_bouncegrid_bounceanglediffuse.integer != 0;
2410 settings.directionalshading = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_directionalshading.integer != 0) && allowdirectionalshading;
2411 settings.dlightparticlemultiplier = r_shadow_bouncegrid_dlightparticlemultiplier.value;
2412 settings.hitmodels = r_shadow_bouncegrid_hitmodels.integer != 0;
2413 settings.lightradiusscale = r_shadow_bouncegrid_lightradiusscale.value;
2414 settings.maxbounce = r_shadow_bouncegrid_maxbounce.integer;
2415 settings.particlebounceintensity = r_shadow_bouncegrid_particlebounceintensity.value;
2416 settings.particleintensity = r_shadow_bouncegrid_particleintensity.value;
2417 settings.photons = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_photons.integer : r_shadow_bouncegrid_photons.integer;
2418 settings.spacing[0] = r_shadow_bouncegrid_spacingx.value;
2419 settings.spacing[1] = r_shadow_bouncegrid_spacingy.value;
2420 settings.spacing[2] = r_shadow_bouncegrid_spacingz.value;
2421 settings.stablerandom = r_shadow_bouncegrid_stablerandom.integer;
2423 // bound the values for sanity
2424 settings.photons = bound(1, settings.photons, 1048576);
2425 settings.lightradiusscale = bound(0.0001f, settings.lightradiusscale, 1024.0f);
2426 settings.maxbounce = bound(1, settings.maxbounce, 16);
2427 settings.spacing[0] = bound(1, settings.spacing[0], 512);
2428 settings.spacing[1] = bound(1, settings.spacing[1], 512);
2429 settings.spacing[2] = bound(1, settings.spacing[2], 512);
2431 // get the spacing values
2432 spacing[0] = settings.spacing[0];
2433 spacing[1] = settings.spacing[1];
2434 spacing[2] = settings.spacing[2];
2435 ispacing[0] = 1.0f / spacing[0];
2436 ispacing[1] = 1.0f / spacing[1];
2437 ispacing[2] = 1.0f / spacing[2];
2439 // calculate texture size enclosing entire world bounds at the spacing
2440 VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
2441 VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
2442 VectorSubtract(maxs, mins, size);
2443 // now we can calculate the resolution we want
2444 c[0] = (int)floor(size[0] / spacing[0] + 0.5f);
2445 c[1] = (int)floor(size[1] / spacing[1] + 0.5f);
2446 c[2] = (int)floor(size[2] / spacing[2] + 0.5f);
2447 // figure out the exact texture size (honoring power of 2 if required)
2448 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2449 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2450 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2451 if (vid.support.arb_texture_non_power_of_two)
2453 resolution[0] = c[0];
2454 resolution[1] = c[1];
2455 resolution[2] = c[2];
2459 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2460 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2461 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2463 size[0] = spacing[0] * resolution[0];
2464 size[1] = spacing[1] * resolution[1];
2465 size[2] = spacing[2] * resolution[2];
2467 // if dynamic we may or may not want to use the world bounds
2468 // if the dynamic size is smaller than the world bounds, use it instead
2469 if (!settings.staticmode && (r_shadow_bouncegrid_x.integer < resolution[0] || r_shadow_bouncegrid_y.integer < resolution[1] || r_shadow_bouncegrid_z.integer < resolution[2]))
2471 // we know the resolution we want
2472 c[0] = r_shadow_bouncegrid_x.integer;
2473 c[1] = r_shadow_bouncegrid_y.integer;
2474 c[2] = r_shadow_bouncegrid_z.integer;
2475 // now we can calculate the texture size (power of 2 if required)
2476 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2477 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2478 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2479 if (vid.support.arb_texture_non_power_of_two)
2481 resolution[0] = c[0];
2482 resolution[1] = c[1];
2483 resolution[2] = c[2];
2487 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2488 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2489 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2491 size[0] = spacing[0] * resolution[0];
2492 size[1] = spacing[1] * resolution[1];
2493 size[2] = spacing[2] * resolution[2];
2494 // center the rendering on the view
2495 mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0];
2496 mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1];
2497 mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2];
2500 // recalculate the maxs in case the resolution was not satisfactory
2501 VectorAdd(mins, size, maxs);
2503 // if all the settings seem identical to the previous update, return
2504 if (r_shadow_bouncegridtexture && (settings.staticmode || realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value) && !memcmp(&r_shadow_bouncegridsettings, &settings, sizeof(settings)))
2507 // store the new settings
2508 r_shadow_bouncegridsettings = settings;
2510 // we're going to update the bouncegrid, update the matrix...
2511 memset(m, 0, sizeof(m));
2512 m[0] = 1.0f / size[0];
2513 m[3] = -mins[0] * m[0];
2514 m[5] = 1.0f / size[1];
2515 m[7] = -mins[1] * m[5];
2516 m[10] = 1.0f / size[2];
2517 m[11] = -mins[2] * m[10];
2519 if (settings.directionalshading)
2524 Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegridmatrix, m);
2525 numpixels = resolution[0]*resolution[1]*resolution[2];
2526 if (settings.directionalshading)
2528 r_shadow_bouncegriddirectional = settings.directionalshading;
2529 // reallocate pixels for this update if needed...
2530 if (r_shadow_bouncegridnumpixels != numpixels || !r_shadow_bouncegridpixels || !r_shadow_bouncegridhighpixels)
2532 if (r_shadow_bouncegridtexture)
2534 R_FreeTexture(r_shadow_bouncegridtexture);
2535 r_shadow_bouncegridtexture = NULL;
2537 r_shadow_bouncegridpixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridpixels, numpixels * sizeof(unsigned char[4]));
2538 r_shadow_bouncegridhighpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(float[4]));
2540 r_shadow_bouncegridnumpixels = numpixels;
2541 pixels = r_shadow_bouncegridpixels;
2542 highpixels = r_shadow_bouncegridhighpixels;
2543 if (settings.directionalshading)
2544 memset(pixels, 128, numpixels * sizeof(unsigned char[4]));
2546 memset(pixels, 0, numpixels * sizeof(unsigned char[4]));
2547 memset(highpixels, 0, numpixels * sizeof(float[4]));
2548 // figure out what we want to interact with
2549 if (settings.hitmodels)
2550 hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_LIQUIDSMASK;
2552 hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK;
2553 maxbounce = settings.maxbounce;
2554 // clear variables that produce warnings otherwise
2555 memset(splatcolor, 0, sizeof(splatcolor));
2556 // iterate world rtlights
2557 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2558 range1 = settings.staticmode ? 0 : r_refdef.scene.numlights;
2559 range2 = range + range1;
2561 for (lightindex = 0;lightindex < range2;lightindex++)
2563 if (settings.staticmode)
2565 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2566 if (!light || !(light->flags & flag))
2568 rtlight = &light->rtlight;
2569 // when static, we skip styled lights because they tend to change...
2570 if (rtlight->style > 0)
2572 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) * (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1), lightcolor);
2576 if (lightindex < range)
2578 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2579 rtlight = &light->rtlight;
2582 rtlight = r_refdef.scene.lights[lightindex - range];
2583 // draw only visible lights (major speedup)
2586 VectorScale(rtlight->currentcolor, rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale, lightcolor);
2588 if (!VectorLength2(lightcolor))
2590 // shoot particles from this light
2591 // use a calculation for the number of particles that will not
2592 // vary with lightstyle, otherwise we get randomized particle
2593 // distribution, the seeded random is only consistent for a
2594 // consistent number of particles on this light...
2595 radius = rtlight->radius * settings.lightradiusscale;
2596 s = rtlight->radius;
2597 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2598 if (lightindex >= range)
2599 lightintensity *= settings.dlightparticlemultiplier;
2600 photoncount += max(0.0f, lightintensity * s * s);
2602 photonscaling = (float)settings.photons / max(1, photoncount);
2603 photonresidual = 0.0f;
2604 for (lightindex = 0;lightindex < range2;lightindex++)
2606 if (settings.staticmode)
2608 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2609 if (!light || !(light->flags & flag))
2611 rtlight = &light->rtlight;
2612 // when static, we skip styled lights because they tend to change...
2613 if (rtlight->style > 0)
2615 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) * (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1), lightcolor);
2619 if (lightindex < range)
2621 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2622 rtlight = &light->rtlight;
2625 rtlight = r_refdef.scene.lights[lightindex - range];
2626 // draw only visible lights (major speedup)
2629 VectorScale(rtlight->currentcolor, rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale, lightcolor);
2631 if (!VectorLength2(lightcolor))
2633 // shoot particles from this light
2634 // use a calculation for the number of particles that will not
2635 // vary with lightstyle, otherwise we get randomized particle
2636 // distribution, the seeded random is only consistent for a
2637 // consistent number of particles on this light...
2638 radius = rtlight->radius * settings.lightradiusscale;
2639 s = rtlight->radius;
2640 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2641 if (lightindex >= range)
2642 lightintensity *= settings.dlightparticlemultiplier;
2643 photonresidual += lightintensity * s * s * photonscaling;
2644 shootparticles = (int)bound(0, photonresidual, MAXBOUNCEGRIDPARTICLESPERLIGHT);
2645 if (!shootparticles)
2647 photonresidual -= shootparticles;
2648 s = settings.particleintensity / shootparticles;
2649 VectorScale(lightcolor, s, baseshotcolor);
2650 if (VectorLength2(baseshotcolor) == 0.0f)
2652 r_refdef.stats.bouncegrid_lights++;
2653 r_refdef.stats.bouncegrid_particles += shootparticles;
2654 for (shotparticles = 0;shotparticles < shootparticles;shotparticles++)
2656 if (settings.stablerandom > 0)
2657 seed = lightindex * 11937 + shotparticles;
2658 VectorCopy(baseshotcolor, shotcolor);
2659 VectorCopy(rtlight->shadoworigin, clipstart);
2660 if (settings.stablerandom < 0)
2661 VectorRandom(clipend);
2663 VectorCheeseRandom(clipend);
2664 VectorMA(clipstart, radius, clipend, clipend);
2665 for (bouncecount = 0;;bouncecount++)
2667 r_refdef.stats.bouncegrid_traces++;
2668 //r_refdef.scene.worldmodel->TraceLineAgainstSurfaces(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace, clipstart, clipend, hitsupercontentsmask);
2669 //r_refdef.scene.worldmodel->TraceLine(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace2, clipstart, clipend, hitsupercontentsmask);
2670 if (settings.staticmode)
2671 Collision_ClipLineToWorld(&cliptrace, cl.worldmodel, clipstart, clipend, hitsupercontentsmask, true);
2673 cliptrace = CL_TraceLine(clipstart, clipend, settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS, NULL, hitsupercontentsmask, true, false, NULL, true, true);
2674 if (cliptrace.fraction >= 1.0f)
2676 r_refdef.stats.bouncegrid_hits++;
2677 if (bouncecount > 0)
2679 r_refdef.stats.bouncegrid_splats++;
2680 // figure out which texture pixel this is in
2681 texlerp[1][0] = ((cliptrace.endpos[0] - mins[0]) * ispacing[0]);
2682 texlerp[1][1] = ((cliptrace.endpos[1] - mins[1]) * ispacing[1]);
2683 texlerp[1][2] = ((cliptrace.endpos[2] - mins[2]) * ispacing[2]);
2684 tex[0] = (int)floor(texlerp[1][0]);
2685 tex[1] = (int)floor(texlerp[1][1]);
2686 tex[2] = (int)floor(texlerp[1][2]);
2687 if (tex[0] >= 1 && tex[1] >= 1 && tex[2] >= 1 && tex[0] < resolution[0] - 2 && tex[1] < resolution[1] - 2 && tex[2] < resolution[2] - 2)
2689 // it is within bounds... do the real work now
2690 // calculate first order spherical harmonics values (average, slopeX, slopeY, slopeZ)
2691 if (settings.directionalshading)
2693 VectorSubtract(clipstart, cliptrace.endpos, clipdiff);
2694 VectorNormalize(clipdiff);
2695 splatcolor[ 0] = shotcolor[0] * clipdiff[2];
2696 splatcolor[ 1] = shotcolor[0] * clipdiff[1];
2697 splatcolor[ 2] = shotcolor[0] * clipdiff[0];
2698 splatcolor[ 3] = shotcolor[0];
2699 splatcolor[ 4] = shotcolor[1] * clipdiff[2];
2700 splatcolor[ 5] = shotcolor[1] * clipdiff[1];
2701 splatcolor[ 6] = shotcolor[1] * clipdiff[0];
2702 splatcolor[ 7] = shotcolor[1];
2703 splatcolor[ 8] = shotcolor[2] * clipdiff[2];
2704 splatcolor[ 9] = shotcolor[2] * clipdiff[1];
2705 splatcolor[10] = shotcolor[2] * clipdiff[0];
2706 splatcolor[11] = shotcolor[2];
2707 w = VectorLength(shotcolor);
2708 splatcolor[12] = clipdiff[2] * w;
2709 splatcolor[13] = clipdiff[1] * w;
2710 splatcolor[14] = clipdiff[0] * w;
2711 splatcolor[15] = 1.0f;
2715 splatcolor[ 0] = shotcolor[2];
2716 splatcolor[ 1] = shotcolor[1];
2717 splatcolor[ 2] = shotcolor[0];
2718 splatcolor[ 3] = 1.0f;
2720 // calculate the lerp factors
2721 texlerp[1][0] -= tex[0];
2722 texlerp[1][1] -= tex[1];
2723 texlerp[1][2] -= tex[2];
2724 texlerp[0][0] = 1.0f - texlerp[1][0];
2725 texlerp[0][1] = 1.0f - texlerp[1][1];
2726 texlerp[0][2] = 1.0f - texlerp[1][2];
2727 // calculate individual pixel indexes and weights
2728 pixelindex[0] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[0] = (texlerp[0][0]*texlerp[0][1]*texlerp[0][2]);
2729 pixelindex[1] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[1] = (texlerp[1][0]*texlerp[0][1]*texlerp[0][2]);
2730 pixelindex[2] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[2] = (texlerp[0][0]*texlerp[1][1]*texlerp[0][2]);
2731 pixelindex[3] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0]+1);pixelweight[3] = (texlerp[1][0]*texlerp[1][1]*texlerp[0][2]);
2732 pixelindex[4] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[4] = (texlerp[0][0]*texlerp[0][1]*texlerp[1][2]);
2733 pixelindex[5] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[5] = (texlerp[1][0]*texlerp[0][1]*texlerp[1][2]);
2734 pixelindex[6] = (((tex[2]+1)*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[6] = (texlerp[0][0]*texlerp[1][1]*texlerp[1][2]);
2735 pixelindex[7] = (((tex[2]+1)*resolution[1]+tex[1]+1)*resolution[0]+tex[0]+1);pixelweight[7] = (texlerp[1][0]*texlerp[1][1]*texlerp[1][2]);
2736 // update the 8 pixels...
2737 for (corner = 0;corner < 8;corner++)
2739 // calculate address for first set of coefficients
2740 w = pixelweight[corner];
2741 pixel = pixels + 4 * pixelindex[corner];
2742 highpixel = highpixels + 4 * pixelindex[corner];
2743 // add to the high precision pixel color
2744 highpixel[0] += (splatcolor[ 0]*w);
2745 highpixel[1] += (splatcolor[ 1]*w);
2746 highpixel[2] += (splatcolor[ 2]*w);
2747 highpixel[3] += (splatcolor[ 3]*w);
2748 // flag the low precision pixel as needing to be updated
2750 if (settings.directionalshading)
2752 // advance to second set of coefficients
2754 highpixel += numpixels;
2755 // add to the high precision pixel color
2756 highpixel[0] += (splatcolor[ 4]*w);
2757 highpixel[1] += (splatcolor[ 5]*w);
2758 highpixel[2] += (splatcolor[ 6]*w);
2759 highpixel[3] += (splatcolor[ 7]*w);
2760 // flag the low precision pixel as needing to be updated
2762 // advance to third set of coefficients
2764 highpixel += numpixels;
2765 // add to the high precision pixel color
2766 highpixel[0] += (splatcolor[ 8]*w);
2767 highpixel[1] += (splatcolor[ 9]*w);
2768 highpixel[2] += (splatcolor[10]*w);
2769 highpixel[3] += (splatcolor[11]*w);
2770 // flag the low precision pixel as needing to be updated
2772 // advance to fourth set of coefficients
2774 highpixel += numpixels;
2775 // add to the high precision pixel color
2776 highpixel[0] += (splatcolor[12]*w);
2777 highpixel[1] += (splatcolor[13]*w);
2778 highpixel[2] += (splatcolor[14]*w);
2779 highpixel[3] += (splatcolor[15]*w);
2780 // flag the low precision pixel as needing to be updated
2786 if (bouncecount >= maxbounce)
2788 // scale down shot color by bounce intensity and texture color (or 50% if no texture reported)
2789 // also clamp the resulting color to never add energy, even if the user requests extreme values
2790 if (cliptrace.hittexture && cliptrace.hittexture->currentskinframe)
2791 VectorCopy(cliptrace.hittexture->currentskinframe->avgcolor, surfcolor);
2793 VectorSet(surfcolor, 0.5f, 0.5f, 0.5f);
2794 VectorScale(surfcolor, settings.particlebounceintensity, surfcolor);
2795 surfcolor[0] = min(surfcolor[0], 1.0f);
2796 surfcolor[1] = min(surfcolor[1], 1.0f);
2797 surfcolor[2] = min(surfcolor[2], 1.0f);
2798 VectorMultiply(shotcolor, surfcolor, shotcolor);
2799 if (VectorLength2(baseshotcolor) == 0.0f)
2801 r_refdef.stats.bouncegrid_bounces++;
2802 if (settings.bounceanglediffuse)
2804 // random direction, primarily along plane normal
2805 s = VectorDistance(cliptrace.endpos, clipend);
2806 if (settings.stablerandom < 0)
2807 VectorRandom(clipend);
2809 VectorCheeseRandom(clipend);
2810 VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend);
2811 VectorNormalize(clipend);
2812 VectorScale(clipend, s, clipend);
2816 // reflect the remaining portion of the line across plane normal
2817 VectorSubtract(clipend, cliptrace.endpos, clipdiff);
2818 VectorReflect(clipdiff, 1.0, cliptrace.plane.normal, clipend);
2820 // calculate the new line start and end
2821 VectorCopy(cliptrace.endpos, clipstart);
2822 VectorAdd(clipstart, clipend, clipend);
2826 // generate pixels array from highpixels array
2827 // skip first and last columns, rows, and layers as these are blank
2828 // the pixel[3] value was written above, so we can use it to detect only pixels that need to be calculated
2829 for (d = 0;d < 4;d++)
2831 for (z = 1;z < resolution[2]-1;z++)
2833 for (y = 1;y < resolution[1]-1;y++)
2835 for (x = 1, pixelindex[0] = ((d*resolution[2]+z)*resolution[1]+y)*resolution[0]+x, pixel = pixels + 4*pixelindex[0], highpixel = highpixels + 4*pixelindex[0];x < resolution[0]-1;x++, pixel += 4, highpixel += 4)
2837 // only convert pixels that were hit by photons
2838 if (pixel[3] == 255)
2840 // normalize the bentnormal...
2841 if (settings.directionalshading)
2844 VectorNormalize(highpixel);
2845 c[0] = (int)(highpixel[0]*128.0f+128.0f);
2846 c[1] = (int)(highpixel[1]*128.0f+128.0f);
2847 c[2] = (int)(highpixel[2]*128.0f+128.0f);
2848 c[3] = (int)(highpixel[3]*128.0f+128.0f);
2852 c[0] = (int)(highpixel[0]*256.0f);
2853 c[1] = (int)(highpixel[1]*256.0f);
2854 c[2] = (int)(highpixel[2]*256.0f);
2855 c[3] = (int)(highpixel[3]*256.0f);
2857 pixel[0] = (unsigned char)bound(0, c[0], 255);
2858 pixel[1] = (unsigned char)bound(0, c[1], 255);
2859 pixel[2] = (unsigned char)bound(0, c[2], 255);
2860 pixel[3] = (unsigned char)bound(0, c[3], 255);
2865 if (!settings.directionalshading)
2868 if (r_shadow_bouncegridtexture && r_shadow_bouncegridresolution[0] == resolution[0] && r_shadow_bouncegridresolution[1] == resolution[1] && r_shadow_bouncegridresolution[2] == resolution[2])
2869 R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]*(settings.directionalshading ? 4 : 1));
2872 VectorCopy(resolution, r_shadow_bouncegridresolution);
2873 if (r_shadow_bouncegridtexture)
2874 R_FreeTexture(r_shadow_bouncegridtexture);
2875 r_shadow_bouncegridtexture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2]*(settings.directionalshading ? 4 : 1), pixels, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
2877 r_shadow_bouncegridtime = realtime;
2880 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2882 R_Shadow_RenderMode_Reset();
2883 GL_BlendFunc(GL_ONE, GL_ONE);
2884 GL_DepthRange(0, 1);
2885 GL_DepthTest(r_showshadowvolumes.integer < 2);
2886 GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2887 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2888 GL_CullFace(GL_NONE);
2889 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2892 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2894 R_Shadow_RenderMode_Reset();
2895 GL_BlendFunc(GL_ONE, GL_ONE);
2896 GL_DepthRange(0, 1);
2897 GL_DepthTest(r_showlighting.integer < 2);
2898 GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2900 GL_DepthFunc(GL_EQUAL);
2901 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2902 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2905 void R_Shadow_RenderMode_End(void)
2907 R_Shadow_RenderMode_Reset();
2908 R_Shadow_RenderMode_ActiveLight(NULL);
2910 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2911 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2914 int bboxedges[12][2] =
2933 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2935 if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass)
2937 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2938 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2939 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2940 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2943 if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor))
2944 return true; // invisible
2945 if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x
2946 || r_shadow_lightscissor[1] != r_refdef.view.viewport.y
2947 || r_shadow_lightscissor[2] != r_refdef.view.viewport.width
2948 || r_shadow_lightscissor[3] != r_refdef.view.viewport.height)
2949 r_refdef.stats.lights_scissored++;
2953 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, const float *diffusecolor, const float *ambientcolor)
2956 const float *vertex3f;
2957 const float *normal3f;
2959 float dist, dot, distintensity, shadeintensity, v[3], n[3];
2960 switch (r_shadow_rendermode)
2962 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2963 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2964 if (VectorLength2(diffusecolor) > 0)
2966 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
2968 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2969 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2970 if ((dot = DotProduct(n, v)) < 0)
2972 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2973 VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
2976 VectorCopy(ambientcolor, color4f);
2977 if (r_refdef.fogenabled)
2980 f = RSurf_FogVertex(vertex3f);
2981 VectorScale(color4f, f, color4f);
2988 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
2990 VectorCopy(ambientcolor, color4f);
2991 if (r_refdef.fogenabled)
2994 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2995 f = RSurf_FogVertex(vertex3f);
2996 VectorScale(color4f + 4*i, f, color4f);
3002 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3003 if (VectorLength2(diffusecolor) > 0)
3005 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
3007 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3008 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3010 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3011 if ((dot = DotProduct(n, v)) < 0)
3013 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3014 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3015 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3016 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3020 color4f[0] = ambientcolor[0] * distintensity;
3021 color4f[1] = ambientcolor[1] * distintensity;
3022 color4f[2] = ambientcolor[2] * distintensity;
3024 if (r_refdef.fogenabled)
3027 f = RSurf_FogVertex(vertex3f);
3028 VectorScale(color4f, f, color4f);
3032 VectorClear(color4f);
3038 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3040 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3041 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3043 color4f[0] = ambientcolor[0] * distintensity;
3044 color4f[1] = ambientcolor[1] * distintensity;
3045 color4f[2] = ambientcolor[2] * distintensity;
3046 if (r_refdef.fogenabled)
3049 f = RSurf_FogVertex(vertex3f);
3050 VectorScale(color4f, f, color4f);
3054 VectorClear(color4f);
3059 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3060 if (VectorLength2(diffusecolor) > 0)
3062 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, normal3f = rsurface.batchnormal3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
3064 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3065 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3067 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3068 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3069 if ((dot = DotProduct(n, v)) < 0)
3071 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3072 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3073 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3074 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3078 color4f[0] = ambientcolor[0] * distintensity;
3079 color4f[1] = ambientcolor[1] * distintensity;
3080 color4f[2] = ambientcolor[2] * distintensity;
3082 if (r_refdef.fogenabled)
3085 f = RSurf_FogVertex(vertex3f);
3086 VectorScale(color4f, f, color4f);
3090 VectorClear(color4f);
3096 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3098 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3099 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3101 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3102 color4f[0] = ambientcolor[0] * distintensity;
3103 color4f[1] = ambientcolor[1] * distintensity;
3104 color4f[2] = ambientcolor[2] * distintensity;
3105 if (r_refdef.fogenabled)
3108 f = RSurf_FogVertex(vertex3f);
3109 VectorScale(color4f, f, color4f);
3113 VectorClear(color4f);
3123 static void R_Shadow_RenderLighting_VisibleLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3125 // used to display how many times a surface is lit for level design purposes
3126 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3127 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
3131 static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale, float specularscale)
3133 // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
3134 R_SetupShader_Surface(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL);
3135 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3136 GL_DepthFunc(GL_EQUAL);
3138 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3139 GL_DepthFunc(GL_LEQUAL);
3142 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
3149 int newnumtriangles;
3153 int maxtriangles = 4096;
3154 static int newelements[4096*3];
3155 R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, diffusecolor2, ambientcolor2);
3156 for (renders = 0;renders < 4;renders++)
3161 newnumtriangles = 0;
3163 // due to low fillrate on the cards this vertex lighting path is
3164 // designed for, we manually cull all triangles that do not
3165 // contain a lit vertex
3166 // this builds batches of triangles from multiple surfaces and
3167 // renders them at once
3168 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
3170 if (VectorLength2(rsurface.passcolor4f + e[0] * 4) + VectorLength2(rsurface.passcolor4f + e[1] * 4) + VectorLength2(rsurface.passcolor4f + e[2] * 4) >= 0.01)
3172 if (newnumtriangles)
3174 newfirstvertex = min(newfirstvertex, e[0]);
3175 newlastvertex = max(newlastvertex, e[0]);
3179 newfirstvertex = e[0];
3180 newlastvertex = e[0];
3182 newfirstvertex = min(newfirstvertex, e[1]);
3183 newlastvertex = max(newlastvertex, e[1]);
3184 newfirstvertex = min(newfirstvertex, e[2]);
3185 newlastvertex = max(newlastvertex, e[2]);
3191 if (newnumtriangles >= maxtriangles)
3193 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3194 newnumtriangles = 0;
3200 if (newnumtriangles >= 1)
3202 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3205 // if we couldn't find any lit triangles, exit early
3208 // now reduce the intensity for the next overbright pass
3209 // we have to clamp to 0 here incase the drivers have improper
3210 // handling of negative colors
3211 // (some old drivers even have improper handling of >1 color)
3213 for (i = 0, c = rsurface.passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4)
3215 if (c[0] > 1 || c[1] > 1 || c[2] > 1)
3217 c[0] = max(0, c[0] - 1);
3218 c[1] = max(0, c[1] - 1);
3219 c[2] = max(0, c[2] - 1);
3231 static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale)
3233 // OpenGL 1.1 path (anything)
3234 float ambientcolorbase[3], diffusecolorbase[3];
3235 float ambientcolorpants[3], diffusecolorpants[3];
3236 float ambientcolorshirt[3], diffusecolorshirt[3];
3237 const float *surfacecolor = rsurface.texture->dlightcolor;
3238 const float *surfacepants = rsurface.colormap_pantscolor;
3239 const float *surfaceshirt = rsurface.colormap_shirtcolor;
3240 rtexture_t *basetexture = rsurface.texture->basetexture;
3241 rtexture_t *pantstexture = rsurface.texture->pantstexture;
3242 rtexture_t *shirttexture = rsurface.texture->shirttexture;
3243 qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
3244 qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
3245 ambientscale *= 2 * r_refdef.view.colorscale;
3246 diffusescale *= 2 * r_refdef.view.colorscale;
3247 ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
3248 diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
3249 ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
3250 diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
3251 ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
3252 diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
3253 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3254 rsurface.passcolor4f = (float *)R_FrameData_Alloc((rsurface.batchfirstvertex + rsurface.batchnumvertices) * sizeof(float[4]));
3255 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3256 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
3257 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
3258 R_Mesh_TexBind(0, basetexture);
3259 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
3260 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
3261 switch(r_shadow_rendermode)
3263 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3264 R_Mesh_TexBind(1, r_shadow_attenuation3dtexture);
3265 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3266 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3267 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3269 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3270 R_Mesh_TexBind(2, r_shadow_attenuation2dtexture);
3271 R_Mesh_TexMatrix(2, &rsurface.entitytoattenuationz);
3272 R_Mesh_TexCombine(2, GL_MODULATE, GL_MODULATE, 1, 1);
3273 R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3275 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3276 R_Mesh_TexBind(1, r_shadow_attenuation2dtexture);
3277 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3278 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3279 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3281 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3286 //R_Mesh_TexBind(0, basetexture);
3287 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorbase, ambientcolorbase);
3290 R_Mesh_TexBind(0, pantstexture);
3291 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorpants, ambientcolorpants);
3295 R_Mesh_TexBind(0, shirttexture);
3296 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorshirt, ambientcolorshirt);
3300 extern cvar_t gl_lightmaps;
3301 void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3303 float ambientscale, diffusescale, specularscale;
3305 float lightcolor[3];
3306 VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
3307 ambientscale = rsurface.rtlight->ambientscale;
3308 diffusescale = rsurface.rtlight->diffusescale;
3309 specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
3310 if (!r_shadow_usenormalmap.integer)
3312 ambientscale += 1.0f * diffusescale;
3316 if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
3318 negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
3321 VectorNegate(lightcolor, lightcolor);
3322 switch(vid.renderpath)
3324 case RENDERPATH_GL11:
3325 case RENDERPATH_GL13:
3326 case RENDERPATH_GL20:
3327 case RENDERPATH_GLES2:
3328 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
3330 case RENDERPATH_D3D9:
3332 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
3335 case RENDERPATH_D3D10:
3336 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3338 case RENDERPATH_D3D11:
3339 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3341 case RENDERPATH_SOFT:
3342 DPSOFTRAST_BlendSubtract(true);
3346 RSurf_SetupDepthAndCulling();
3347 switch (r_shadow_rendermode)
3349 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
3350 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
3351 R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
3353 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3354 R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale, specularscale);
3356 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3357 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3358 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3359 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3360 R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale);
3363 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
3368 switch(vid.renderpath)
3370 case RENDERPATH_GL11:
3371 case RENDERPATH_GL13:
3372 case RENDERPATH_GL20:
3373 case RENDERPATH_GLES2:
3374 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3376 case RENDERPATH_D3D9:
3378 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
3381 case RENDERPATH_D3D10:
3382 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3384 case RENDERPATH_D3D11:
3385 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3387 case RENDERPATH_SOFT:
3388 DPSOFTRAST_BlendSubtract(false);
3394 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)
3396 matrix4x4_t tempmatrix = *matrix;
3397 Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
3399 // if this light has been compiled before, free the associated data
3400 R_RTLight_Uncompile(rtlight);
3402 // clear it completely to avoid any lingering data
3403 memset(rtlight, 0, sizeof(*rtlight));
3405 // copy the properties
3406 rtlight->matrix_lighttoworld = tempmatrix;
3407 Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3408 Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3409 rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3410 VectorCopy(color, rtlight->color);
3411 rtlight->cubemapname[0] = 0;
3412 if (cubemapname && cubemapname[0])
3413 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3414 rtlight->shadow = shadow;
3415 rtlight->corona = corona;
3416 rtlight->style = style;
3417 rtlight->isstatic = isstatic;
3418 rtlight->coronasizescale = coronasizescale;
3419 rtlight->ambientscale = ambientscale;
3420 rtlight->diffusescale = diffusescale;
3421 rtlight->specularscale = specularscale;
3422 rtlight->flags = flags;
3424 // compute derived data
3425 //rtlight->cullradius = rtlight->radius;
3426 //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3427 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3428 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3429 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3430 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3431 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3432 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3435 // compiles rtlight geometry
3436 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3437 void R_RTLight_Compile(rtlight_t *rtlight)
3440 int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3441 int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3442 entity_render_t *ent = r_refdef.scene.worldentity;
3443 dp_model_t *model = r_refdef.scene.worldmodel;
3444 unsigned char *data;
3447 // compile the light
3448 rtlight->compiled = true;
3449 rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3450 rtlight->static_numleafs = 0;
3451 rtlight->static_numleafpvsbytes = 0;
3452 rtlight->static_leaflist = NULL;
3453 rtlight->static_leafpvs = NULL;
3454 rtlight->static_numsurfaces = 0;
3455 rtlight->static_surfacelist = NULL;
3456 rtlight->static_shadowmap_receivers = 0x3F;
3457 rtlight->static_shadowmap_casters = 0x3F;
3458 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3459 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3460 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3461 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3462 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3463 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3465 if (model && model->GetLightInfo)
3467 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3468 r_shadow_compilingrtlight = rtlight;
3469 R_FrameData_SetMark();
3470 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);
3471 R_FrameData_ReturnToMark();
3472 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3473 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3474 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3475 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3476 rtlight->static_numsurfaces = numsurfaces;
3477 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3478 rtlight->static_numleafs = numleafs;
3479 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3480 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3481 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3482 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3483 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3484 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3485 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3486 if (rtlight->static_numsurfaces)
3487 memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3488 if (rtlight->static_numleafs)
3489 memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3490 if (rtlight->static_numleafpvsbytes)
3491 memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3492 if (rtlight->static_numshadowtrispvsbytes)
3493 memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3494 if (rtlight->static_numlighttrispvsbytes)
3495 memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3496 R_FrameData_SetMark();
3497 switch (rtlight->shadowmode)
3499 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3500 if (model->CompileShadowMap && rtlight->shadow)
3501 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3504 if (model->CompileShadowVolume && rtlight->shadow)
3505 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3508 R_FrameData_ReturnToMark();
3509 // now we're done compiling the rtlight
3510 r_shadow_compilingrtlight = NULL;
3514 // use smallest available cullradius - box radius or light radius
3515 //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3516 //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3518 shadowzpasstris = 0;
3519 if (rtlight->static_meshchain_shadow_zpass)
3520 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3521 shadowzpasstris += mesh->numtriangles;
3523 shadowzfailtris = 0;
3524 if (rtlight->static_meshchain_shadow_zfail)
3525 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3526 shadowzfailtris += mesh->numtriangles;
3529 if (rtlight->static_numlighttrispvsbytes)
3530 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3531 if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3535 if (rtlight->static_numlighttrispvsbytes)
3536 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3537 if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3540 if (developer_extra.integer)
3541 Con_DPrintf("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);
3544 void R_RTLight_Uncompile(rtlight_t *rtlight)
3546 if (rtlight->compiled)
3548 if (rtlight->static_meshchain_shadow_zpass)
3549 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3550 rtlight->static_meshchain_shadow_zpass = NULL;
3551 if (rtlight->static_meshchain_shadow_zfail)
3552 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3553 rtlight->static_meshchain_shadow_zfail = NULL;
3554 if (rtlight->static_meshchain_shadow_shadowmap)
3555 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3556 rtlight->static_meshchain_shadow_shadowmap = NULL;
3557 // these allocations are grouped
3558 if (rtlight->static_surfacelist)
3559 Mem_Free(rtlight->static_surfacelist);
3560 rtlight->static_numleafs = 0;
3561 rtlight->static_numleafpvsbytes = 0;
3562 rtlight->static_leaflist = NULL;
3563 rtlight->static_leafpvs = NULL;
3564 rtlight->static_numsurfaces = 0;
3565 rtlight->static_surfacelist = NULL;
3566 rtlight->static_numshadowtrispvsbytes = 0;
3567 rtlight->static_shadowtrispvs = NULL;
3568 rtlight->static_numlighttrispvsbytes = 0;
3569 rtlight->static_lighttrispvs = NULL;
3570 rtlight->compiled = false;
3574 void R_Shadow_UncompileWorldLights(void)
3578 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3579 for (lightindex = 0;lightindex < range;lightindex++)
3581 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3584 R_RTLight_Uncompile(&light->rtlight);
3588 void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3592 // reset the count of frustum planes
3593 // see rtlight->cached_frustumplanes definition for how much this array
3595 rtlight->cached_numfrustumplanes = 0;
3597 // haven't implemented a culling path for ortho rendering
3598 if (!r_refdef.view.useperspective)
3600 // check if the light is on screen and copy the 4 planes if it is
3601 for (i = 0;i < 4;i++)
3602 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3605 for (i = 0;i < 4;i++)
3606 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3611 // generate a deformed frustum that includes the light origin, this is
3612 // used to cull shadow casting surfaces that can not possibly cast a
3613 // shadow onto the visible light-receiving surfaces, which can be a
3616 // if the light origin is onscreen the result will be 4 planes exactly
3617 // if the light origin is offscreen on only one axis the result will
3618 // be exactly 5 planes (split-side case)
3619 // if the light origin is offscreen on two axes the result will be
3620 // exactly 4 planes (stretched corner case)
3621 for (i = 0;i < 4;i++)
3623 // quickly reject standard frustum planes that put the light
3624 // origin outside the frustum
3625 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3628 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3630 // if all the standard frustum planes were accepted, the light is onscreen
3631 // otherwise we need to generate some more planes below...
3632 if (rtlight->cached_numfrustumplanes < 4)
3634 // at least one of the stock frustum planes failed, so we need to
3635 // create one or two custom planes to enclose the light origin
3636 for (i = 0;i < 4;i++)
3638 // create a plane using the view origin and light origin, and a
3639 // single point from the frustum corner set
3640 TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3641 VectorNormalize(plane.normal);
3642 plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3643 // see if this plane is backwards and flip it if so
3644 for (j = 0;j < 4;j++)
3645 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3649 VectorNegate(plane.normal, plane.normal);
3651 // flipped plane, test again to see if it is now valid
3652 for (j = 0;j < 4;j++)
3653 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3655 // if the plane is still not valid, then it is dividing the
3656 // frustum and has to be rejected
3660 // we have created a valid plane, compute extra info
3661 PlaneClassify(&plane);
3663 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3665 // if we've found 5 frustum planes then we have constructed a
3666 // proper split-side case and do not need to keep searching for
3667 // planes to enclose the light origin
3668 if (rtlight->cached_numfrustumplanes == 5)
3676 for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3678 plane = rtlight->cached_frustumplanes[i];
3679 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));
3684 // now add the light-space box planes if the light box is rotated, as any
3685 // caster outside the oriented light box is irrelevant (even if it passed
3686 // the worldspace light box, which is axial)
3687 if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3689 for (i = 0;i < 6;i++)
3693 v[i >> 1] = (i & 1) ? -1 : 1;
3694 Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3695 VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3696 plane.dist = VectorNormalizeLength(plane.normal);
3697 plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3698 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3704 // add the world-space reduced box planes
3705 for (i = 0;i < 6;i++)
3707 VectorClear(plane.normal);
3708 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3709 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3710 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3719 // reduce all plane distances to tightly fit the rtlight cull box, which
3721 VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3722 VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3723 VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3724 VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3725 VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3726 VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3727 VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3728 VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3729 oldnum = rtlight->cached_numfrustumplanes;
3730 rtlight->cached_numfrustumplanes = 0;
3731 for (j = 0;j < oldnum;j++)
3733 // find the nearest point on the box to this plane
3734 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3735 for (i = 1;i < 8;i++)
3737 dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3738 if (bestdist > dist)
3741 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);
3742 // if the nearest point is near or behind the plane, we want this
3743 // plane, otherwise the plane is useless as it won't cull anything
3744 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3746 PlaneClassify(&rtlight->cached_frustumplanes[j]);
3747 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3754 void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3758 RSurf_ActiveWorldEntity();
3760 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3763 GL_CullFace(GL_NONE);
3764 mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3765 for (;mesh;mesh = mesh->next)
3767 if (!mesh->sidetotals[r_shadow_shadowmapside])
3769 r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3770 if (mesh->vertex3fbuffer)
3771 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3773 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3774 R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
3778 else if (r_refdef.scene.worldentity->model)
3779 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);
3781 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3784 void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3786 qboolean zpass = false;
3789 int surfacelistindex;
3790 msurface_t *surface;
3792 // if triangle neighbors are disabled, shadowvolumes are disabled
3793 if (r_refdef.scene.worldmodel->brush.shadowmesh ? !r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i : !r_refdef.scene.worldmodel->surfmesh.data_neighbor3i)
3796 RSurf_ActiveWorldEntity();
3798 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3801 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3803 zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3804 R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3806 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3807 for (;mesh;mesh = mesh->next)
3809 r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3810 if (mesh->vertex3fbuffer)
3811 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3813 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3814 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3816 // increment stencil if frontface is infront of depthbuffer
3817 GL_CullFace(r_refdef.view.cullface_back);
3818 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
3819 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
3820 // decrement stencil if backface is infront of depthbuffer
3821 GL_CullFace(r_refdef.view.cullface_front);
3822 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
3824 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3826 // decrement stencil if backface is behind depthbuffer
3827 GL_CullFace(r_refdef.view.cullface_front);
3828 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
3829 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
3830 // increment stencil if frontface is behind depthbuffer
3831 GL_CullFace(r_refdef.view.cullface_back);
3832 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
3834 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3i_indexbuffer, mesh->element3i_bufferoffset, mesh->element3s, mesh->element3s_indexbuffer, mesh->element3s_bufferoffset);
3838 else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh)
3840 // use the shadow trispvs calculated earlier by GetLightInfo to cull world triangles on this dynamic light
3841 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3842 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3844 surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3845 for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3846 if (CHECKPVSBIT(trispvs, t))
3847 shadowmarklist[numshadowmark++] = t;
3849 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);
3851 else if (numsurfaces)
3853 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);
3856 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3859 void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3861 vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3862 vec_t relativeshadowradius;
3863 RSurf_ActiveModelEntity(ent, false, false, false);
3864 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3865 // we need to re-init the shader for each entity because the matrix changed
3866 relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3867 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3868 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3869 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3870 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3871 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3872 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3873 switch (r_shadow_rendermode)
3875 case R_SHADOW_RENDERMODE_SHADOWMAP2D:
3876 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3879 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3882 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3885 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3887 // set up properties for rendering light onto this entity
3888 RSurf_ActiveModelEntity(ent, true, true, false);
3889 Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3890 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3891 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3892 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3895 void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *lighttrispvs)
3897 if (!r_refdef.scene.worldmodel->DrawLight)
3900 // set up properties for rendering light onto this entity
3901 RSurf_ActiveWorldEntity();
3902 rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3903 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3904 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3905 VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3907 r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
3909 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3912 void R_Shadow_DrawEntityLight(entity_render_t *ent)
3914 dp_model_t *model = ent->model;
3915 if (!model->DrawLight)
3918 R_Shadow_SetupEntityLight(ent);
3920 model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3922 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3925 void R_Shadow_PrepareLight(rtlight_t *rtlight)
3929 int numleafs, numsurfaces;
3930 int *leaflist, *surfacelist;
3931 unsigned char *leafpvs;
3932 unsigned char *shadowtrispvs;
3933 unsigned char *lighttrispvs;
3934 //unsigned char *surfacesides;
3935 int numlightentities;
3936 int numlightentities_noselfshadow;
3937 int numshadowentities;
3938 int numshadowentities_noselfshadow;
3939 static entity_render_t *lightentities[MAX_EDICTS];
3940 static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3941 static entity_render_t *shadowentities[MAX_EDICTS];
3942 static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3945 rtlight->draw = false;
3947 // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3948 // skip lights that are basically invisible (color 0 0 0)
3949 nolight = VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f);
3951 // loading is done before visibility checks because loading should happen
3952 // all at once at the start of a level, not when it stalls gameplay.
3953 // (especially important to benchmarks)
3955 if (rtlight->isstatic && !nolight && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
3957 if (rtlight->compiled)
3958 R_RTLight_Uncompile(rtlight);
3959 R_RTLight_Compile(rtlight);
3963 rtlight->currentcubemap = rtlight->cubemapname[0] ? R_GetCubemap(rtlight->cubemapname) : r_texture_whitecube;
3965 // look up the light style value at this time
3966 f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3967 VectorScale(rtlight->color, f, rtlight->currentcolor);
3969 if (rtlight->selected)
3971 f = 2 + sin(realtime * M_PI * 4.0);
3972 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3976 // if lightstyle is currently off, don't draw the light
3977 if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3980 // skip processing on corona-only lights
3984 // if the light box is offscreen, skip it
3985 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3988 VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
3989 VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
3991 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3993 if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3995 // compiled light, world available and can receive realtime lighting
3996 // retrieve leaf information
3997 numleafs = rtlight->static_numleafs;
3998 leaflist = rtlight->static_leaflist;
3999 leafpvs = rtlight->static_leafpvs;
4000 numsurfaces = rtlight->static_numsurfaces;
4001 surfacelist = rtlight->static_surfacelist;
4002 //surfacesides = NULL;
4003 shadowtrispvs = rtlight->static_shadowtrispvs;
4004 lighttrispvs = rtlight->static_lighttrispvs;
4006 else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
4008 // dynamic light, world available and can receive realtime lighting
4009 // calculate lit surfaces and leafs
4010 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);
4011 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
4012 leaflist = r_shadow_buffer_leaflist;
4013 leafpvs = r_shadow_buffer_leafpvs;
4014 surfacelist = r_shadow_buffer_surfacelist;
4015 //surfacesides = r_shadow_buffer_surfacesides;
4016 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
4017 lighttrispvs = r_shadow_buffer_lighttrispvs;
4018 // if the reduced leaf bounds are offscreen, skip it
4019 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4030 //surfacesides = NULL;
4031 shadowtrispvs = NULL;
4032 lighttrispvs = NULL;
4034 // check if light is illuminating any visible leafs
4037 for (i = 0;i < numleafs;i++)
4038 if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
4044 // make a list of lit entities and shadow casting entities
4045 numlightentities = 0;
4046 numlightentities_noselfshadow = 0;
4047 numshadowentities = 0;
4048 numshadowentities_noselfshadow = 0;
4050 // add dynamic entities that are lit by the light
4051 for (i = 0;i < r_refdef.scene.numentities;i++)
4054 entity_render_t *ent = r_refdef.scene.entities[i];
4056 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4058 // skip the object entirely if it is not within the valid
4059 // shadow-casting region (which includes the lit region)
4060 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
4062 if (!(model = ent->model))
4064 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
4066 // this entity wants to receive light, is visible, and is
4067 // inside the light box
4068 // TODO: check if the surfaces in the model can receive light
4069 // so now check if it's in a leaf seen by the light
4070 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))
4072 if (ent->flags & RENDER_NOSELFSHADOW)
4073 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
4075 lightentities[numlightentities++] = ent;
4076 // since it is lit, it probably also casts a shadow...
4077 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4078 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4079 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4081 // note: exterior models without the RENDER_NOSELFSHADOW
4082 // flag still create a RENDER_NOSELFSHADOW shadow but
4083 // are lit normally, this means that they are
4084 // self-shadowing but do not shadow other
4085 // RENDER_NOSELFSHADOW entities such as the gun
4086 // (very weird, but keeps the player shadow off the gun)
4087 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4088 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4090 shadowentities[numshadowentities++] = ent;
4093 else if (ent->flags & RENDER_SHADOW)
4095 // this entity is not receiving light, but may still need to
4097 // TODO: check if the surfaces in the model can cast shadow
4098 // now check if it is in a leaf seen by the light
4099 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))
4101 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4102 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4103 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4105 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4106 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4108 shadowentities[numshadowentities++] = ent;
4113 // return if there's nothing at all to light
4114 if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
4117 // count this light in the r_speeds
4118 r_refdef.stats.lights++;
4120 // flag it as worth drawing later
4121 rtlight->draw = true;
4123 // cache all the animated entities that cast a shadow but are not visible
4124 for (i = 0;i < numshadowentities;i++)
4125 if (!shadowentities[i]->animcache_vertex3f)
4126 R_AnimCache_GetEntity(shadowentities[i], false, false);
4127 for (i = 0;i < numshadowentities_noselfshadow;i++)
4128 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
4129 R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
4131 // allocate some temporary memory for rendering this light later in the frame
4132 // reusable buffers need to be copied, static data can be used as-is
4133 rtlight->cached_numlightentities = numlightentities;
4134 rtlight->cached_numlightentities_noselfshadow = numlightentities_noselfshadow;
4135 rtlight->cached_numshadowentities = numshadowentities;
4136 rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
4137 rtlight->cached_numsurfaces = numsurfaces;
4138 rtlight->cached_lightentities = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
4139 rtlight->cached_lightentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
4140 rtlight->cached_shadowentities = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
4141 rtlight->cached_shadowentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
4142 if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
4144 int numshadowtrispvsbytes = (((r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles) + 7) >> 3);
4145 int numlighttrispvsbytes = ((r_refdef.scene.worldmodel->surfmesh.num_triangles + 7) >> 3);
4146 rtlight->cached_shadowtrispvs = (unsigned char *)R_FrameData_Store(numshadowtrispvsbytes, shadowtrispvs);
4147 rtlight->cached_lighttrispvs = (unsigned char *)R_FrameData_Store(numlighttrispvsbytes, lighttrispvs);
4148 rtlight->cached_surfacelist = (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
4152 // compiled light data
4153 rtlight->cached_shadowtrispvs = shadowtrispvs;
4154 rtlight->cached_lighttrispvs = lighttrispvs;
4155 rtlight->cached_surfacelist = surfacelist;
4159 void R_Shadow_DrawLight(rtlight_t *rtlight)
4163 unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
4164 int numlightentities;
4165 int numlightentities_noselfshadow;
4166 int numshadowentities;
4167 int numshadowentities_noselfshadow;
4168 entity_render_t **lightentities;
4169 entity_render_t **lightentities_noselfshadow;
4170 entity_render_t **shadowentities;
4171 entity_render_t **shadowentities_noselfshadow;
4173 static unsigned char entitysides[MAX_EDICTS];
4174 static unsigned char entitysides_noselfshadow[MAX_EDICTS];
4175 vec3_t nearestpoint;
4177 qboolean castshadows;
4180 // check if we cached this light this frame (meaning it is worth drawing)
4184 numlightentities = rtlight->cached_numlightentities;
4185 numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
4186 numshadowentities = rtlight->cached_numshadowentities;
4187 numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
4188 numsurfaces = rtlight->cached_numsurfaces;
4189 lightentities = rtlight->cached_lightentities;
4190 lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
4191 shadowentities = rtlight->cached_shadowentities;
4192 shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
4193 shadowtrispvs = rtlight->cached_shadowtrispvs;
4194 lighttrispvs = rtlight->cached_lighttrispvs;
4195 surfacelist = rtlight->cached_surfacelist;
4197 // set up a scissor rectangle for this light
4198 if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4201 // don't let sound skip if going slow
4202 if (r_refdef.scene.extraupdate)
4205 // make this the active rtlight for rendering purposes
4206 R_Shadow_RenderMode_ActiveLight(rtlight);
4208 if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
4210 // optionally draw visible shape of the shadow volumes
4211 // for performance analysis by level designers
4212 R_Shadow_RenderMode_VisibleShadowVolumes();
4214 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4215 for (i = 0;i < numshadowentities;i++)
4216 R_Shadow_DrawEntityShadow(shadowentities[i]);
4217 for (i = 0;i < numshadowentities_noselfshadow;i++)
4218 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4219 R_Shadow_RenderMode_VisibleLighting(false, false);
4222 if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
4224 // optionally draw the illuminated areas
4225 // for performance analysis by level designers
4226 R_Shadow_RenderMode_VisibleLighting(false, false);
4228 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4229 for (i = 0;i < numlightentities;i++)
4230 R_Shadow_DrawEntityLight(lightentities[i]);
4231 for (i = 0;i < numlightentities_noselfshadow;i++)
4232 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4235 castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
4237 nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
4238 nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
4239 nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
4240 distance = VectorDistance(nearestpoint, r_refdef.view.origin);
4242 lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
4243 //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
4244 lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
4246 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4252 int receivermask = 0;
4253 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
4254 Matrix4x4_Abs(&radiustolight);
4256 r_shadow_shadowmaplod = 0;
4257 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
4258 if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
4259 r_shadow_shadowmaplod = i;
4261 size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
4263 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
4265 surfacesides = NULL;
4268 if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
4270 castermask = rtlight->static_shadowmap_casters;
4271 receivermask = rtlight->static_shadowmap_receivers;
4275 surfacesides = r_shadow_buffer_surfacesides;
4276 for(i = 0;i < numsurfaces;i++)
4278 msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
4279 surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4280 castermask |= surfacesides[i];
4281 receivermask |= surfacesides[i];
4285 if (receivermask < 0x3F)
4287 for (i = 0;i < numlightentities;i++)
4288 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4289 if (receivermask < 0x3F)
4290 for(i = 0; i < numlightentities_noselfshadow;i++)
4291 receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4294 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
4298 for (i = 0;i < numshadowentities;i++)
4299 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4300 for (i = 0;i < numshadowentities_noselfshadow;i++)
4301 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4304 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
4306 // render shadow casters into 6 sided depth texture
4307 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
4309 R_Shadow_RenderMode_ShadowMap(side, receivermask, size);
4310 if (! (castermask & (1 << side))) continue;
4312 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
4313 for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
4314 R_Shadow_DrawEntityShadow(shadowentities[i]);
4317 if (numlightentities_noselfshadow)
4319 // render lighting using the depth texture as shadowmap
4320 // draw lighting in the unmasked areas
4321 R_Shadow_RenderMode_Lighting(false, false, true);
4322 for (i = 0;i < numlightentities_noselfshadow;i++)
4323 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4326 // render shadow casters into 6 sided depth texture
4327 if (numshadowentities_noselfshadow)
4329 for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
4331 R_Shadow_RenderMode_ShadowMap(side, 0, size);
4332 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
4333 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4337 // render lighting using the depth texture as shadowmap
4338 // draw lighting in the unmasked areas
4339 R_Shadow_RenderMode_Lighting(false, false, true);
4340 // draw lighting in the unmasked areas
4342 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4343 for (i = 0;i < numlightentities;i++)
4344 R_Shadow_DrawEntityLight(lightentities[i]);
4346 else if (castshadows && vid.stencil)
4348 // draw stencil shadow volumes to mask off pixels that are in shadow
4349 // so that they won't receive lighting
4350 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
4351 R_Shadow_ClearStencil();
4354 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4355 for (i = 0;i < numshadowentities;i++)
4356 R_Shadow_DrawEntityShadow(shadowentities[i]);
4358 // draw lighting in the unmasked areas
4359 R_Shadow_RenderMode_Lighting(true, false, false);
4360 for (i = 0;i < numlightentities_noselfshadow;i++)
4361 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4363 for (i = 0;i < numshadowentities_noselfshadow;i++)
4364 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4366 // draw lighting in the unmasked areas
4367 R_Shadow_RenderMode_Lighting(true, false, false);
4369 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4370 for (i = 0;i < numlightentities;i++)
4371 R_Shadow_DrawEntityLight(lightentities[i]);
4375 // draw lighting in the unmasked areas
4376 R_Shadow_RenderMode_Lighting(false, false, false);
4378 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4379 for (i = 0;i < numlightentities;i++)
4380 R_Shadow_DrawEntityLight(lightentities[i]);
4381 for (i = 0;i < numlightentities_noselfshadow;i++)
4382 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4385 if (r_shadow_usingdeferredprepass)
4387 // when rendering deferred lighting, we simply rasterize the box
4388 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4389 R_Shadow_RenderMode_DrawDeferredLight(false, true);
4390 else if (castshadows && vid.stencil)
4391 R_Shadow_RenderMode_DrawDeferredLight(true, false);
4393 R_Shadow_RenderMode_DrawDeferredLight(false, false);
4397 static void R_Shadow_FreeDeferred(void)
4399 R_Mesh_DestroyFramebufferObject(r_shadow_prepassgeometryfbo);
4400 r_shadow_prepassgeometryfbo = 0;
4402 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusespecularfbo);
4403 r_shadow_prepasslightingdiffusespecularfbo = 0;
4405 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusefbo);
4406 r_shadow_prepasslightingdiffusefbo = 0;
4408 if (r_shadow_prepassgeometrydepthtexture)
4409 R_FreeTexture(r_shadow_prepassgeometrydepthtexture);
4410 r_shadow_prepassgeometrydepthtexture = NULL;
4412 if (r_shadow_prepassgeometrydepthcolortexture)
4413 R_FreeTexture(r_shadow_prepassgeometrydepthcolortexture);
4414 r_shadow_prepassgeometrydepthcolortexture = NULL;
4416 if (r_shadow_prepassgeometrynormalmaptexture)
4417 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4418 r_shadow_prepassgeometrynormalmaptexture = NULL;
4420 if (r_shadow_prepasslightingdiffusetexture)
4421 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4422 r_shadow_prepasslightingdiffusetexture = NULL;
4424 if (r_shadow_prepasslightingspeculartexture)
4425 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4426 r_shadow_prepasslightingspeculartexture = NULL;
4429 void R_Shadow_DrawPrepass(void)
4437 entity_render_t *ent;
4438 float clearcolor[4];
4440 R_Mesh_ResetTextureState();
4442 GL_ColorMask(1,1,1,1);
4443 GL_BlendFunc(GL_ONE, GL_ZERO);
4446 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
4447 Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f);
4448 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4449 if (r_timereport_active)
4450 R_TimeReport("prepasscleargeom");
4452 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4453 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4454 if (r_timereport_active)
4455 R_TimeReport("prepassworld");
4457 for (i = 0;i < r_refdef.scene.numentities;i++)
4459 if (!r_refdef.viewcache.entityvisible[i])
4461 ent = r_refdef.scene.entities[i];
4462 if (ent->model && ent->model->DrawPrepass != NULL)
4463 ent->model->DrawPrepass(ent);
4466 if (r_timereport_active)
4467 R_TimeReport("prepassmodels");
4469 GL_DepthMask(false);
4470 GL_ColorMask(1,1,1,1);
4473 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4474 Vector4Set(clearcolor, 0, 0, 0, 0);
4475 GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
4476 if (r_timereport_active)
4477 R_TimeReport("prepassclearlit");
4479 R_Shadow_RenderMode_Begin();
4481 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4482 if (r_shadow_debuglight.integer >= 0)
4484 lightindex = r_shadow_debuglight.integer;
4485 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4486 if (light && (light->flags & flag) && light->rtlight.draw)
4487 R_Shadow_DrawLight(&light->rtlight);
4491 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4492 for (lightindex = 0;lightindex < range;lightindex++)
4494 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4495 if (light && (light->flags & flag) && light->rtlight.draw)
4496 R_Shadow_DrawLight(&light->rtlight);
4499 if (r_refdef.scene.rtdlight)
4500 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4501 if (r_refdef.scene.lights[lnum]->draw)
4502 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4504 R_Mesh_ResetRenderTargets();
4506 R_Shadow_RenderMode_End();
4508 if (r_timereport_active)
4509 R_TimeReport("prepasslights");
4512 void R_Shadow_DrawLightSprites(void);
4513 void R_Shadow_PrepareLights(void)
4523 if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4524 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
4525 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20) ||
4526 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4527 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4528 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4529 R_Shadow_FreeShadowMaps();
4531 r_shadow_usingshadowmaportho = false;
4533 switch (vid.renderpath)
4535 case RENDERPATH_GL20:
4536 case RENDERPATH_D3D9:
4537 case RENDERPATH_D3D10:
4538 case RENDERPATH_D3D11:
4539 case RENDERPATH_SOFT:
4540 case RENDERPATH_GLES2:
4541 if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || vid.maxdrawbuffers < 2)
4543 r_shadow_usingdeferredprepass = false;
4544 if (r_shadow_prepass_width)
4545 R_Shadow_FreeDeferred();
4546 r_shadow_prepass_width = r_shadow_prepass_height = 0;
4550 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4552 R_Shadow_FreeDeferred();
4554 r_shadow_usingdeferredprepass = true;
4555 r_shadow_prepass_width = vid.width;
4556 r_shadow_prepass_height = vid.height;
4557 r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false);
4558 switch (vid.renderpath)
4560 case RENDERPATH_D3D9:
4561 r_shadow_prepassgeometrydepthcolortexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrydepthcolormap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4566 r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4567 r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4568 r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4570 // set up the geometry pass fbo (depth + normalmap)
4571 r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4572 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
4573 // render depth into one texture and normalmap into the other
4574 if (qglDrawBuffersARB)
4576 qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
4577 qglReadBuffer(GL_NONE);CHECKGLERROR
4578 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4579 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4581 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4582 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4583 r_shadow_usingdeferredprepass = false;
4587 // set up the lighting pass fbo (diffuse + specular)
4588 r_shadow_prepasslightingdiffusespecularfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4589 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4590 // render diffuse into one texture and specular into another,
4591 // with depth and normalmap bound as textures,
4592 // with depth bound as attachment as well
4593 if (qglDrawBuffersARB)
4595 qglDrawBuffersARB(2, r_shadow_prepasslightingdrawbuffers);CHECKGLERROR
4596 qglReadBuffer(GL_NONE);CHECKGLERROR
4597 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4598 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4600 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4601 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4602 r_shadow_usingdeferredprepass = false;
4606 // set up the lighting pass fbo (diffuse)
4607 r_shadow_prepasslightingdiffusefbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4608 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4609 // render diffuse into one texture,
4610 // with depth and normalmap bound as textures,
4611 // with depth bound as attachment as well
4612 if (qglDrawBuffersARB)
4614 qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
4615 qglReadBuffer(GL_NONE);CHECKGLERROR
4616 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4617 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4619 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4620 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4621 r_shadow_usingdeferredprepass = false;
4626 case RENDERPATH_GL13:
4627 case RENDERPATH_GL11:
4628 r_shadow_usingdeferredprepass = false;
4632 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);
4634 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4635 if (r_shadow_debuglight.integer >= 0)
4637 lightindex = r_shadow_debuglight.integer;
4638 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4639 if (light && (light->flags & flag))
4640 R_Shadow_PrepareLight(&light->rtlight);
4644 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4645 for (lightindex = 0;lightindex < range;lightindex++)
4647 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4648 if (light && (light->flags & flag))
4649 R_Shadow_PrepareLight(&light->rtlight);
4652 if (r_refdef.scene.rtdlight)
4654 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4655 R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4657 else if(gl_flashblend.integer)
4659 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4661 rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4662 f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4663 VectorScale(rtlight->color, f, rtlight->currentcolor);
4667 if (r_editlights.integer)
4668 R_Shadow_DrawLightSprites();
4670 R_Shadow_UpdateBounceGridTexture();
4673 void R_Shadow_DrawLights(void)
4681 R_Shadow_RenderMode_Begin();
4683 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4684 if (r_shadow_debuglight.integer >= 0)
4686 lightindex = r_shadow_debuglight.integer;
4687 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4688 if (light && (light->flags & flag))
4689 R_Shadow_DrawLight(&light->rtlight);
4693 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4694 for (lightindex = 0;lightindex < range;lightindex++)
4696 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4697 if (light && (light->flags & flag))
4698 R_Shadow_DrawLight(&light->rtlight);
4701 if (r_refdef.scene.rtdlight)
4702 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4703 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4705 R_Shadow_RenderMode_End();
4708 extern const float r_screenvertex3f[12];
4709 extern void R_SetupView(qboolean allowwaterclippingplane);
4710 extern void R_ResetViewRendering3D(void);
4711 extern void R_ResetViewRendering2D(void);
4712 extern cvar_t r_shadows;
4713 extern cvar_t r_shadows_darken;
4714 extern cvar_t r_shadows_drawafterrtlighting;
4715 extern cvar_t r_shadows_castfrombmodels;
4716 extern cvar_t r_shadows_throwdistance;
4717 extern cvar_t r_shadows_throwdirection;
4718 extern cvar_t r_shadows_focus;
4719 extern cvar_t r_shadows_shadowmapscale;
4721 void R_Shadow_PrepareModelShadows(void)
4724 float scale, size, radius, dot1, dot2;
4725 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus, shadowmins, shadowmaxs;
4726 entity_render_t *ent;
4728 if (!r_refdef.scene.numentities)
4731 switch (r_shadow_shadowmode)
4733 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4734 if (r_shadows.integer >= 2)
4737 case R_SHADOW_SHADOWMODE_STENCIL:
4738 for (i = 0;i < r_refdef.scene.numentities;i++)
4740 ent = r_refdef.scene.entities[i];
4741 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4742 R_AnimCache_GetEntity(ent, false, false);
4749 size = 2*r_shadow_shadowmapmaxsize;
4750 scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
4751 radius = 0.5f * size / scale;
4753 Math_atov(r_shadows_throwdirection.string, shadowdir);
4754 VectorNormalize(shadowdir);
4755 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4756 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4757 if (fabs(dot1) <= fabs(dot2))
4758 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4760 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4761 VectorNormalize(shadowforward);
4762 CrossProduct(shadowdir, shadowforward, shadowright);
4763 Math_atov(r_shadows_focus.string, shadowfocus);
4764 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4765 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4766 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4767 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4768 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4770 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4772 shadowmins[0] = shadoworigin[0] - r_shadows_throwdistance.value * fabs(shadowdir[0]) - radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4773 shadowmins[1] = shadoworigin[1] - r_shadows_throwdistance.value * fabs(shadowdir[1]) - radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4774 shadowmins[2] = shadoworigin[2] - r_shadows_throwdistance.value * fabs(shadowdir[2]) - radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4775 shadowmaxs[0] = shadoworigin[0] + r_shadows_throwdistance.value * fabs(shadowdir[0]) + radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4776 shadowmaxs[1] = shadoworigin[1] + r_shadows_throwdistance.value * fabs(shadowdir[1]) + radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4777 shadowmaxs[2] = shadoworigin[2] + r_shadows_throwdistance.value * fabs(shadowdir[2]) + radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4779 for (i = 0;i < r_refdef.scene.numentities;i++)
4781 ent = r_refdef.scene.entities[i];
4782 if (!BoxesOverlap(ent->mins, ent->maxs, shadowmins, shadowmaxs))
4784 // cast shadows from anything of the map (submodels are optional)
4785 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4786 R_AnimCache_GetEntity(ent, false, false);
4790 void R_DrawModelShadowMaps(void)
4793 float relativethrowdistance, scale, size, radius, nearclip, farclip, bias, dot1, dot2;
4794 entity_render_t *ent;
4795 vec3_t relativelightorigin;
4796 vec3_t relativelightdirection, relativeforward, relativeright;
4797 vec3_t relativeshadowmins, relativeshadowmaxs;
4798 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus;
4800 matrix4x4_t shadowmatrix, cameramatrix, mvpmatrix, invmvpmatrix, scalematrix, texmatrix;
4801 r_viewport_t viewport;
4803 float clearcolor[4];
4805 if (!r_refdef.scene.numentities)
4808 switch (r_shadow_shadowmode)
4810 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4816 R_ResetViewRendering3D();
4817 R_Shadow_RenderMode_Begin();
4818 R_Shadow_RenderMode_ActiveLight(NULL);
4820 switch (r_shadow_shadowmode)
4822 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4823 if (!r_shadow_shadowmap2dtexture)
4824 R_Shadow_MakeShadowMap(0, r_shadow_shadowmapmaxsize);
4825 fbo = r_shadow_fbo2d;
4826 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
4827 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
4828 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
4834 size = 2*r_shadow_shadowmapmaxsize;
4835 scale = (r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value) / size;
4836 radius = 0.5f / scale;
4837 nearclip = -r_shadows_throwdistance.value;
4838 farclip = r_shadows_throwdistance.value;
4839 bias = r_shadow_shadowmapping_bias.value * r_shadow_shadowmapping_nearclip.value / (2 * r_shadows_throwdistance.value) * (1024.0f / size);
4841 r_shadow_shadowmap_parameters[0] = size;
4842 r_shadow_shadowmap_parameters[1] = size;
4843 r_shadow_shadowmap_parameters[2] = 1.0;
4844 r_shadow_shadowmap_parameters[3] = bound(0.0f, 1.0f - r_shadows_darken.value, 1.0f);
4846 Math_atov(r_shadows_throwdirection.string, shadowdir);
4847 VectorNormalize(shadowdir);
4848 Math_atov(r_shadows_focus.string, shadowfocus);
4849 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4850 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4851 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4852 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4853 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4854 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4855 if (fabs(dot1) <= fabs(dot2))
4856 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4858 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4859 VectorNormalize(shadowforward);
4860 VectorM(scale, shadowforward, &m[0]);
4861 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4863 m[3] = fabs(dot1) * 0.5f - DotProduct(shadoworigin, &m[0]);
4864 CrossProduct(shadowdir, shadowforward, shadowright);
4865 VectorM(scale, shadowright, &m[4]);
4866 m[7] = 0.5f - DotProduct(shadoworigin, &m[4]);
4867 VectorM(1.0f / (farclip - nearclip), shadowdir, &m[8]);
4868 m[11] = 0.5f - DotProduct(shadoworigin, &m[8]);
4869 Matrix4x4_FromArray12FloatD3D(&shadowmatrix, m);
4870 Matrix4x4_Invert_Full(&cameramatrix, &shadowmatrix);
4871 R_Viewport_InitOrtho(&viewport, &cameramatrix, 0, 0, size, size, 0, 0, 1, 1, 0, -1, NULL);
4873 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4875 R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
4876 R_SetupShader_DepthOrShadow();
4877 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
4880 R_SetViewport(&viewport);
4881 GL_Scissor(viewport.x, viewport.y, min(viewport.width + r_shadow_shadowmapborder, 2*r_shadow_shadowmapmaxsize), viewport.height + r_shadow_shadowmapborder);
4882 Vector4Set(clearcolor, 1,1,1,1);
4883 // in D3D9 we have to render to a color texture shadowmap
4884 // in GL we render directly to a depth texture only
4885 if (r_shadow_shadowmap2dtexture)
4886 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4888 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4889 // render into a slightly restricted region so that the borders of the
4890 // shadowmap area fade away, rather than streaking across everything
4891 // outside the usable area
4892 GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder);
4896 R_Mesh_ResetRenderTargets();
4897 R_SetupShader_ShowDepth();
4898 GL_ColorMask(1,1,1,1);
4899 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4902 for (i = 0;i < r_refdef.scene.numentities;i++)
4904 ent = r_refdef.scene.entities[i];
4906 // cast shadows from anything of the map (submodels are optional)
4907 if (ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4909 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4910 Matrix4x4_Transform(&ent->inversematrix, shadoworigin, relativelightorigin);
4911 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4912 Matrix4x4_Transform3x3(&ent->inversematrix, shadowforward, relativeforward);
4913 Matrix4x4_Transform3x3(&ent->inversematrix, shadowright, relativeright);
4914 relativeshadowmins[0] = relativelightorigin[0] - r_shadows_throwdistance.value * fabs(relativelightdirection[0]) - radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4915 relativeshadowmins[1] = relativelightorigin[1] - r_shadows_throwdistance.value * fabs(relativelightdirection[1]) - radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4916 relativeshadowmins[2] = relativelightorigin[2] - r_shadows_throwdistance.value * fabs(relativelightdirection[2]) - radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4917 relativeshadowmaxs[0] = relativelightorigin[0] + r_shadows_throwdistance.value * fabs(relativelightdirection[0]) + radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4918 relativeshadowmaxs[1] = relativelightorigin[1] + r_shadows_throwdistance.value * fabs(relativelightdirection[1]) + radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4919 relativeshadowmaxs[2] = relativelightorigin[2] + r_shadows_throwdistance.value * fabs(relativelightdirection[2]) + radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4920 RSurf_ActiveModelEntity(ent, false, false, false);
4921 ent->model->DrawShadowMap(0, ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
4922 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4929 unsigned char *rawpixels = Z_Malloc(viewport.width*viewport.height*4);
4931 qglReadPixels(viewport.x, viewport.y, viewport.width, viewport.height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, rawpixels);
4933 Image_WriteTGABGRA("r_shadows_2.tga", viewport.width, viewport.height, rawpixels);
4934 Cvar_SetValueQuick(&r_test, 0);
4939 R_Shadow_RenderMode_End();
4941 Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
4942 Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
4943 Matrix4x4_CreateScale3(&scalematrix, size, -size, 1);
4944 Matrix4x4_AdjustOrigin(&scalematrix, 0, size, -0.5f * bias);
4945 Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix);
4946 Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix);
4948 switch (vid.renderpath)
4950 case RENDERPATH_GL11:
4951 case RENDERPATH_GL13:
4952 case RENDERPATH_GL20:
4953 case RENDERPATH_SOFT:
4954 case RENDERPATH_GLES2:
4956 case RENDERPATH_D3D9:
4957 case RENDERPATH_D3D10:
4958 case RENDERPATH_D3D11:
4959 #ifdef OPENGL_ORIENTATION
4960 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4961 r_shadow_shadowmapmatrix.m[0][1] *= -1.0f;
4962 r_shadow_shadowmapmatrix.m[0][2] *= -1.0f;
4963 r_shadow_shadowmapmatrix.m[0][3] *= -1.0f;
4965 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4966 r_shadow_shadowmapmatrix.m[1][0] *= -1.0f;
4967 r_shadow_shadowmapmatrix.m[2][0] *= -1.0f;
4968 r_shadow_shadowmapmatrix.m[3][0] *= -1.0f;
4973 r_shadow_usingshadowmaportho = true;
4974 switch (r_shadow_shadowmode)
4976 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4977 r_shadow_usingshadowmap2d = true;
4984 void R_DrawModelShadows(void)
4987 float relativethrowdistance;
4988 entity_render_t *ent;
4989 vec3_t relativelightorigin;
4990 vec3_t relativelightdirection;
4991 vec3_t relativeshadowmins, relativeshadowmaxs;
4992 vec3_t tmp, shadowdir;
4994 if (!r_refdef.scene.numentities || !vid.stencil || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL && r_shadows.integer != 1))
4997 R_ResetViewRendering3D();
4998 //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
4999 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
5000 R_Shadow_RenderMode_Begin();
5001 R_Shadow_RenderMode_ActiveLight(NULL);
5002 r_shadow_lightscissor[0] = r_refdef.view.x;
5003 r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
5004 r_shadow_lightscissor[2] = r_refdef.view.width;
5005 r_shadow_lightscissor[3] = r_refdef.view.height;
5006 R_Shadow_RenderMode_StencilShadowVolumes(false);
5009 if (r_shadows.integer == 2)
5011 Math_atov(r_shadows_throwdirection.string, shadowdir);
5012 VectorNormalize(shadowdir);
5015 R_Shadow_ClearStencil();
5017 for (i = 0;i < r_refdef.scene.numentities;i++)
5019 ent = r_refdef.scene.entities[i];
5021 // cast shadows from anything of the map (submodels are optional)
5022 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
5024 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
5025 VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
5026 VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
5027 if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
5028 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
5031 if(ent->entitynumber != 0)
5033 if(ent->entitynumber >= MAX_EDICTS) // csqc entity
5035 // FIXME handle this
5036 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5040 // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
5041 int entnum, entnum2, recursion;
5042 entnum = entnum2 = ent->entitynumber;
5043 for(recursion = 32; recursion > 0; --recursion)
5045 entnum2 = cl.entities[entnum].state_current.tagentity;
5046 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
5051 if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
5053 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
5054 // transform into modelspace of OUR entity
5055 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
5056 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
5059 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5063 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5066 VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
5067 RSurf_ActiveModelEntity(ent, false, false, false);
5068 ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
5069 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
5073 // not really the right mode, but this will disable any silly stencil features
5074 R_Shadow_RenderMode_End();
5076 // set up ortho view for rendering this pass
5077 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
5078 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5079 //GL_ScissorTest(true);
5080 //R_EntityMatrix(&identitymatrix);
5081 //R_Mesh_ResetTextureState();
5082 R_ResetViewRendering2D();
5084 // set up a darkening blend on shadowed areas
5085 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5086 //GL_DepthRange(0, 1);
5087 //GL_DepthTest(false);
5088 //GL_DepthMask(false);
5089 //GL_PolygonOffset(0, 0);CHECKGLERROR
5090 GL_Color(0, 0, 0, r_shadows_darken.value);
5091 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5092 //GL_DepthFunc(GL_ALWAYS);
5093 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_NOTEQUAL, 128, 255);
5095 // apply the blend to the shadowed areas
5096 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
5097 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5098 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5100 // restore the viewport
5101 R_SetViewport(&r_refdef.view.viewport);
5103 // restore other state to normal
5104 //R_Shadow_RenderMode_End();
5107 void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
5110 vec3_t centerorigin;
5112 // if it's too close, skip it
5113 if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
5115 zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
5118 if (usequery && r_numqueries + 2 <= r_maxqueries)
5120 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
5121 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
5122 // 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
5123 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
5125 switch(vid.renderpath)
5127 case RENDERPATH_GL20:
5128 case RENDERPATH_GL13:
5129 case RENDERPATH_GL11:
5130 case RENDERPATH_GLES2:
5132 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead
5133 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
5134 GL_DepthFunc(GL_ALWAYS);
5135 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5136 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5137 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5138 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5139 GL_DepthFunc(GL_LEQUAL);
5140 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
5141 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5142 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5143 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5144 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5147 case RENDERPATH_D3D9:
5148 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5150 case RENDERPATH_D3D10:
5151 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5153 case RENDERPATH_D3D11:
5154 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5156 case RENDERPATH_SOFT:
5157 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5161 rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
5164 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
5166 void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
5169 GLint allpixels = 0, visiblepixels = 0;
5170 // now we have to check the query result
5171 if (rtlight->corona_queryindex_visiblepixels)
5173 switch(vid.renderpath)
5175 case RENDERPATH_GL20:
5176 case RENDERPATH_GL13:
5177 case RENDERPATH_GL11:
5178 case RENDERPATH_GLES2:
5180 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
5181 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
5184 case RENDERPATH_D3D9:
5185 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5187 case RENDERPATH_D3D10:
5188 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5190 case RENDERPATH_D3D11:
5191 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5193 case RENDERPATH_SOFT:
5194 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5197 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
5198 if (visiblepixels < 1 || allpixels < 1)
5200 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
5201 cscale *= rtlight->corona_visibility;
5205 // FIXME: these traces should scan all render entities instead of cl.world
5206 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
5209 VectorScale(rtlight->currentcolor, cscale, color);
5210 if (VectorLength(color) > (1.0f / 256.0f))
5213 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
5216 VectorNegate(color, color);
5217 switch(vid.renderpath)
5219 case RENDERPATH_GL11:
5220 case RENDERPATH_GL13:
5221 case RENDERPATH_GL20:
5222 case RENDERPATH_GLES2:
5223 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
5225 case RENDERPATH_D3D9:
5227 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
5230 case RENDERPATH_D3D10:
5231 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5233 case RENDERPATH_D3D11:
5234 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5236 case RENDERPATH_SOFT:
5237 DPSOFTRAST_BlendSubtract(true);
5241 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5242 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);
5243 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5246 switch(vid.renderpath)
5248 case RENDERPATH_GL11:
5249 case RENDERPATH_GL13:
5250 case RENDERPATH_GL20:
5251 case RENDERPATH_GLES2:
5252 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
5254 case RENDERPATH_D3D9:
5256 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
5259 case RENDERPATH_D3D10:
5260 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5262 case RENDERPATH_D3D11:
5263 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5265 case RENDERPATH_SOFT:
5266 DPSOFTRAST_BlendSubtract(false);
5273 void R_Shadow_DrawCoronas(void)
5276 qboolean usequery = false;
5281 if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
5283 if (r_waterstate.renderingscene)
5285 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
5286 R_EntityMatrix(&identitymatrix);
5288 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5290 // check occlusion of coronas
5291 // use GL_ARB_occlusion_query if available
5292 // otherwise use raytraces
5294 switch (vid.renderpath)
5296 case RENDERPATH_GL11:
5297 case RENDERPATH_GL13:
5298 case RENDERPATH_GL20:
5299 case RENDERPATH_GLES2:
5300 usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
5303 GL_ColorMask(0,0,0,0);
5304 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
5305 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
5308 r_maxqueries = (range + r_refdef.scene.numlights) * 4;
5309 r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
5311 qglGenQueriesARB(r_maxqueries - i, r_queries + i);
5314 RSurf_ActiveWorldEntity();
5315 GL_BlendFunc(GL_ONE, GL_ZERO);
5316 GL_CullFace(GL_NONE);
5317 GL_DepthMask(false);
5318 GL_DepthRange(0, 1);
5319 GL_PolygonOffset(0, 0);
5321 R_Mesh_ResetTextureState();
5322 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1);
5325 case RENDERPATH_D3D9:
5327 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5329 case RENDERPATH_D3D10:
5330 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5332 case RENDERPATH_D3D11:
5333 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5335 case RENDERPATH_SOFT:
5337 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5340 for (lightindex = 0;lightindex < range;lightindex++)
5342 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5345 rtlight = &light->rtlight;
5346 rtlight->corona_visibility = 0;
5347 rtlight->corona_queryindex_visiblepixels = 0;
5348 rtlight->corona_queryindex_allpixels = 0;
5349 if (!(rtlight->flags & flag))
5351 if (rtlight->corona <= 0)
5353 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
5355 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5357 for (i = 0;i < r_refdef.scene.numlights;i++)
5359 rtlight = r_refdef.scene.lights[i];
5360 rtlight->corona_visibility = 0;
5361 rtlight->corona_queryindex_visiblepixels = 0;
5362 rtlight->corona_queryindex_allpixels = 0;
5363 if (!(rtlight->flags & flag))
5365 if (rtlight->corona <= 0)
5367 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5370 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5372 // now draw the coronas using the query data for intensity info
5373 for (lightindex = 0;lightindex < range;lightindex++)
5375 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5378 rtlight = &light->rtlight;
5379 if (rtlight->corona_visibility <= 0)
5381 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5383 for (i = 0;i < r_refdef.scene.numlights;i++)
5385 rtlight = r_refdef.scene.lights[i];
5386 if (rtlight->corona_visibility <= 0)
5388 if (gl_flashblend.integer)
5389 R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
5391 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5397 dlight_t *R_Shadow_NewWorldLight(void)
5399 return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
5402 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)
5405 // validate parameters
5406 if (style < 0 || style >= MAX_LIGHTSTYLES)
5408 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
5414 // copy to light properties
5415 VectorCopy(origin, light->origin);
5416 light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
5417 light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
5418 light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
5420 light->color[0] = max(color[0], 0);
5421 light->color[1] = max(color[1], 0);
5422 light->color[2] = max(color[2], 0);
5424 light->color[0] = color[0];
5425 light->color[1] = color[1];
5426 light->color[2] = color[2];
5427 light->radius = max(radius, 0);
5428 light->style = style;
5429 light->shadow = shadowenable;
5430 light->corona = corona;
5431 strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
5432 light->coronasizescale = coronasizescale;
5433 light->ambientscale = ambientscale;
5434 light->diffusescale = diffusescale;
5435 light->specularscale = specularscale;
5436 light->flags = flags;
5438 // update renderable light data
5439 Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
5440 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);
5443 void R_Shadow_FreeWorldLight(dlight_t *light)
5445 if (r_shadow_selectedlight == light)
5446 r_shadow_selectedlight = NULL;
5447 R_RTLight_Uncompile(&light->rtlight);
5448 Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
5451 void R_Shadow_ClearWorldLights(void)
5455 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5456 for (lightindex = 0;lightindex < range;lightindex++)
5458 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5460 R_Shadow_FreeWorldLight(light);
5462 r_shadow_selectedlight = NULL;
5465 void R_Shadow_SelectLight(dlight_t *light)
5467 if (r_shadow_selectedlight)
5468 r_shadow_selectedlight->selected = false;
5469 r_shadow_selectedlight = light;
5470 if (r_shadow_selectedlight)
5471 r_shadow_selectedlight->selected = true;
5474 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5476 // this is never batched (there can be only one)
5478 R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
5479 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5480 R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5483 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5488 skinframe_t *skinframe;
5491 // this is never batched (due to the ent parameter changing every time)
5492 // so numsurfaces == 1 and surfacelist[0] == lightnumber
5493 const dlight_t *light = (dlight_t *)ent;
5496 R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
5499 VectorScale(light->color, intensity, spritecolor);
5500 if (VectorLength(spritecolor) < 0.1732f)
5501 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
5502 if (VectorLength(spritecolor) > 1.0f)
5503 VectorNormalize(spritecolor);
5505 // draw light sprite
5506 if (light->cubemapname[0] && !light->shadow)
5507 skinframe = r_editlights_sprcubemapnoshadowlight;
5508 else if (light->cubemapname[0])
5509 skinframe = r_editlights_sprcubemaplight;
5510 else if (!light->shadow)
5511 skinframe = r_editlights_sprnoshadowlight;
5513 skinframe = r_editlights_sprlight;
5515 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);
5516 R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5518 // draw selection sprite if light is selected
5519 if (light->selected)
5521 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5522 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5523 // VorteX todo: add normalmode/realtime mode light overlay sprites?
5527 void R_Shadow_DrawLightSprites(void)
5531 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5532 for (lightindex = 0;lightindex < range;lightindex++)
5534 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5536 R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
5538 if (!r_editlights_lockcursor)
5539 R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
5542 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
5547 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
5548 if (lightindex >= range)
5550 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5553 rtlight = &light->rtlight;
5554 //if (!(rtlight->flags & flag))
5556 VectorCopy(rtlight->shadoworigin, origin);
5557 *radius = rtlight->radius;
5558 VectorCopy(rtlight->color, color);
5562 void R_Shadow_SelectLightInView(void)
5564 float bestrating, rating, temp[3];
5568 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5572 if (r_editlights_lockcursor)
5574 for (lightindex = 0;lightindex < range;lightindex++)
5576 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5579 VectorSubtract(light->origin, r_refdef.view.origin, temp);
5580 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
5583 rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
5584 if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1.0f)
5586 bestrating = rating;
5591 R_Shadow_SelectLight(best);
5594 void R_Shadow_LoadWorldLights(void)
5596 int n, a, style, shadow, flags;
5597 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
5598 float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
5599 if (cl.worldmodel == NULL)
5601 Con_Print("No map loaded.\n");
5604 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5605 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5615 for (;COM_Parse(t, true) && strcmp(
5616 if (COM_Parse(t, true))
5618 if (com_token[0] == '!')
5621 origin[0] = atof(com_token+1);
5624 origin[0] = atof(com_token);
5629 while (*s && *s != '\n' && *s != '\r')
5635 // check for modifier flags
5642 #if _MSC_VER >= 1400
5643 #define sscanf sscanf_s
5645 cubemapname[sizeof(cubemapname)-1] = 0;
5646 #if MAX_QPATH != 128
5647 #error update this code if MAX_QPATH changes
5649 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
5650 #if _MSC_VER >= 1400
5651 , sizeof(cubemapname)
5653 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
5656 flags = LIGHTFLAG_REALTIMEMODE;
5664 coronasizescale = 0.25f;
5666 VectorClear(angles);
5669 if (a < 9 || !strcmp(cubemapname, "\"\""))
5671 // remove quotes on cubemapname
5672 if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
5675 namelen = strlen(cubemapname) - 2;
5676 memmove(cubemapname, cubemapname + 1, namelen);
5677 cubemapname[namelen] = '\0';
5681 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);
5684 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5692 Con_Printf("invalid rtlights file \"%s\"\n", name);
5693 Mem_Free(lightsstring);
5697 void R_Shadow_SaveWorldLights(void)
5701 size_t bufchars, bufmaxchars;
5703 char name[MAX_QPATH];
5704 char line[MAX_INPUTLINE];
5705 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5706 // I hate lines which are 3 times my screen size :( --blub
5709 if (cl.worldmodel == NULL)
5711 Con_Print("No map loaded.\n");
5714 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5715 bufchars = bufmaxchars = 0;
5717 for (lightindex = 0;lightindex < range;lightindex++)
5719 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5722 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5723 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);
5724 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5725 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]);
5727 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);
5728 if (bufchars + strlen(line) > bufmaxchars)
5730 bufmaxchars = bufchars + strlen(line) + 2048;
5732 buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5736 memcpy(buf, oldbuf, bufchars);
5742 memcpy(buf + bufchars, line, strlen(line));
5743 bufchars += strlen(line);
5747 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5752 void R_Shadow_LoadLightsFile(void)
5755 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5756 float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5757 if (cl.worldmodel == NULL)
5759 Con_Print("No map loaded.\n");
5762 dpsnprintf(name, sizeof(name), "%s.lights", cl.worldnamenoextension);
5763 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5771 while (*s && *s != '\n' && *s != '\r')
5777 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);
5781 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);
5784 radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5785 radius = bound(15, radius, 4096);
5786 VectorScale(color, (2.0f / (8388608.0f)), color);
5787 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5795 Con_Printf("invalid lights file \"%s\"\n", name);
5796 Mem_Free(lightsstring);
5800 // tyrlite/hmap2 light types in the delay field
5801 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5803 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5815 float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5816 char key[256], value[MAX_INPUTLINE];
5818 if (cl.worldmodel == NULL)
5820 Con_Print("No map loaded.\n");
5823 // try to load a .ent file first
5824 dpsnprintf(key, sizeof(key), "%s.ent", cl.worldnamenoextension);
5825 data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5826 // and if that is not found, fall back to the bsp file entity string
5828 data = cl.worldmodel->brush.entities;
5831 for (entnum = 0;COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{';entnum++)
5833 type = LIGHTTYPE_MINUSX;
5834 origin[0] = origin[1] = origin[2] = 0;
5835 originhack[0] = originhack[1] = originhack[2] = 0;
5836 angles[0] = angles[1] = angles[2] = 0;
5837 color[0] = color[1] = color[2] = 1;
5838 light[0] = light[1] = light[2] = 1;light[3] = 300;
5839 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5849 if (!COM_ParseToken_Simple(&data, false, false))
5851 if (com_token[0] == '}')
5852 break; // end of entity
5853 if (com_token[0] == '_')
5854 strlcpy(key, com_token + 1, sizeof(key));
5856 strlcpy(key, com_token, sizeof(key));
5857 while (key[strlen(key)-1] == ' ') // remove trailing spaces
5858 key[strlen(key)-1] = 0;
5859 if (!COM_ParseToken_Simple(&data, false, false))
5861 strlcpy(value, com_token, sizeof(value));
5863 // now that we have the key pair worked out...
5864 if (!strcmp("light", key))
5866 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5870 light[0] = vec[0] * (1.0f / 256.0f);
5871 light[1] = vec[0] * (1.0f / 256.0f);
5872 light[2] = vec[0] * (1.0f / 256.0f);
5878 light[0] = vec[0] * (1.0f / 255.0f);
5879 light[1] = vec[1] * (1.0f / 255.0f);
5880 light[2] = vec[2] * (1.0f / 255.0f);
5884 else if (!strcmp("delay", key))
5886 else if (!strcmp("origin", key))
5887 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5888 else if (!strcmp("angle", key))
5889 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5890 else if (!strcmp("angles", key))
5891 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5892 else if (!strcmp("color", key))
5893 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5894 else if (!strcmp("wait", key))
5895 fadescale = atof(value);
5896 else if (!strcmp("classname", key))
5898 if (!strncmp(value, "light", 5))
5901 if (!strcmp(value, "light_fluoro"))
5906 overridecolor[0] = 1;
5907 overridecolor[1] = 1;
5908 overridecolor[2] = 1;
5910 if (!strcmp(value, "light_fluorospark"))
5915 overridecolor[0] = 1;
5916 overridecolor[1] = 1;
5917 overridecolor[2] = 1;
5919 if (!strcmp(value, "light_globe"))
5924 overridecolor[0] = 1;
5925 overridecolor[1] = 0.8;
5926 overridecolor[2] = 0.4;
5928 if (!strcmp(value, "light_flame_large_yellow"))
5933 overridecolor[0] = 1;
5934 overridecolor[1] = 0.5;
5935 overridecolor[2] = 0.1;
5937 if (!strcmp(value, "light_flame_small_yellow"))
5942 overridecolor[0] = 1;
5943 overridecolor[1] = 0.5;
5944 overridecolor[2] = 0.1;
5946 if (!strcmp(value, "light_torch_small_white"))
5951 overridecolor[0] = 1;
5952 overridecolor[1] = 0.5;
5953 overridecolor[2] = 0.1;
5955 if (!strcmp(value, "light_torch_small_walltorch"))
5960 overridecolor[0] = 1;
5961 overridecolor[1] = 0.5;
5962 overridecolor[2] = 0.1;
5966 else if (!strcmp("style", key))
5967 style = atoi(value);
5968 else if (!strcmp("skin", key))
5969 skin = (int)atof(value);
5970 else if (!strcmp("pflags", key))
5971 pflags = (int)atof(value);
5972 //else if (!strcmp("effects", key))
5973 // effects = (int)atof(value);
5974 else if (cl.worldmodel->type == mod_brushq3)
5976 if (!strcmp("scale", key))
5977 lightscale = atof(value);
5978 if (!strcmp("fade", key))
5979 fadescale = atof(value);
5984 if (lightscale <= 0)
5988 if (color[0] == color[1] && color[0] == color[2])
5990 color[0] *= overridecolor[0];
5991 color[1] *= overridecolor[1];
5992 color[2] *= overridecolor[2];
5994 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
5995 color[0] = color[0] * light[0];
5996 color[1] = color[1] * light[1];
5997 color[2] = color[2] * light[2];
6000 case LIGHTTYPE_MINUSX:
6002 case LIGHTTYPE_RECIPX:
6004 VectorScale(color, (1.0f / 16.0f), color);
6006 case LIGHTTYPE_RECIPXX:
6008 VectorScale(color, (1.0f / 16.0f), color);
6011 case LIGHTTYPE_NONE:
6015 case LIGHTTYPE_MINUSXX:
6018 VectorAdd(origin, originhack, origin);
6020 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);
6023 Mem_Free(entfiledata);
6027 void R_Shadow_SetCursorLocationForView(void)
6030 vec3_t dest, endpos;
6032 VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
6033 trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true);
6034 if (trace.fraction < 1)
6036 dist = trace.fraction * r_editlights_cursordistance.value;
6037 push = r_editlights_cursorpushback.value;
6041 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
6042 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
6046 VectorClear( endpos );
6048 r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6049 r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6050 r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6053 void R_Shadow_UpdateWorldLightSelection(void)
6055 if (r_editlights.integer)
6057 R_Shadow_SetCursorLocationForView();
6058 R_Shadow_SelectLightInView();
6061 R_Shadow_SelectLight(NULL);
6064 void R_Shadow_EditLights_Clear_f(void)
6066 R_Shadow_ClearWorldLights();
6069 void R_Shadow_EditLights_Reload_f(void)
6073 strlcpy(r_shadow_mapname, cl.worldname, sizeof(r_shadow_mapname));
6074 R_Shadow_ClearWorldLights();
6075 R_Shadow_LoadWorldLights();
6076 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
6078 R_Shadow_LoadLightsFile();
6079 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
6080 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
6084 void R_Shadow_EditLights_Save_f(void)
6088 R_Shadow_SaveWorldLights();
6091 void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
6093 R_Shadow_ClearWorldLights();
6094 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
6097 void R_Shadow_EditLights_ImportLightsFile_f(void)
6099 R_Shadow_ClearWorldLights();
6100 R_Shadow_LoadLightsFile();
6103 void R_Shadow_EditLights_Spawn_f(void)
6106 if (!r_editlights.integer)
6108 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6111 if (Cmd_Argc() != 1)
6113 Con_Print("r_editlights_spawn does not take parameters\n");
6116 color[0] = color[1] = color[2] = 1;
6117 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
6120 void R_Shadow_EditLights_Edit_f(void)
6122 vec3_t origin, angles, color;
6123 vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
6124 int style, shadows, flags, normalmode, realtimemode;
6125 char cubemapname[MAX_INPUTLINE];
6126 if (!r_editlights.integer)
6128 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6131 if (!r_shadow_selectedlight)
6133 Con_Print("No selected light.\n");
6136 VectorCopy(r_shadow_selectedlight->origin, origin);
6137 VectorCopy(r_shadow_selectedlight->angles, angles);
6138 VectorCopy(r_shadow_selectedlight->color, color);
6139 radius = r_shadow_selectedlight->radius;
6140 style = r_shadow_selectedlight->style;
6141 if (r_shadow_selectedlight->cubemapname)
6142 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
6145 shadows = r_shadow_selectedlight->shadow;
6146 corona = r_shadow_selectedlight->corona;
6147 coronasizescale = r_shadow_selectedlight->coronasizescale;
6148 ambientscale = r_shadow_selectedlight->ambientscale;
6149 diffusescale = r_shadow_selectedlight->diffusescale;
6150 specularscale = r_shadow_selectedlight->specularscale;
6151 flags = r_shadow_selectedlight->flags;
6152 normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
6153 realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
6154 if (!strcmp(Cmd_Argv(1), "origin"))
6156 if (Cmd_Argc() != 5)
6158 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6161 origin[0] = atof(Cmd_Argv(2));
6162 origin[1] = atof(Cmd_Argv(3));
6163 origin[2] = atof(Cmd_Argv(4));
6165 else if (!strcmp(Cmd_Argv(1), "originscale"))
6167 if (Cmd_Argc() != 5)
6169 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6172 origin[0] *= atof(Cmd_Argv(2));
6173 origin[1] *= atof(Cmd_Argv(3));
6174 origin[2] *= atof(Cmd_Argv(4));
6176 else if (!strcmp(Cmd_Argv(1), "originx"))
6178 if (Cmd_Argc() != 3)
6180 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6183 origin[0] = atof(Cmd_Argv(2));
6185 else if (!strcmp(Cmd_Argv(1), "originy"))
6187 if (Cmd_Argc() != 3)
6189 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6192 origin[1] = atof(Cmd_Argv(2));
6194 else if (!strcmp(Cmd_Argv(1), "originz"))
6196 if (Cmd_Argc() != 3)
6198 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6201 origin[2] = atof(Cmd_Argv(2));
6203 else if (!strcmp(Cmd_Argv(1), "move"))
6205 if (Cmd_Argc() != 5)
6207 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6210 origin[0] += atof(Cmd_Argv(2));
6211 origin[1] += atof(Cmd_Argv(3));
6212 origin[2] += atof(Cmd_Argv(4));
6214 else if (!strcmp(Cmd_Argv(1), "movex"))
6216 if (Cmd_Argc() != 3)
6218 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6221 origin[0] += atof(Cmd_Argv(2));
6223 else if (!strcmp(Cmd_Argv(1), "movey"))
6225 if (Cmd_Argc() != 3)
6227 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6230 origin[1] += atof(Cmd_Argv(2));
6232 else if (!strcmp(Cmd_Argv(1), "movez"))
6234 if (Cmd_Argc() != 3)
6236 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6239 origin[2] += atof(Cmd_Argv(2));
6241 else if (!strcmp(Cmd_Argv(1), "angles"))
6243 if (Cmd_Argc() != 5)
6245 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6248 angles[0] = atof(Cmd_Argv(2));
6249 angles[1] = atof(Cmd_Argv(3));
6250 angles[2] = atof(Cmd_Argv(4));
6252 else if (!strcmp(Cmd_Argv(1), "anglesx"))
6254 if (Cmd_Argc() != 3)
6256 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6259 angles[0] = atof(Cmd_Argv(2));
6261 else if (!strcmp(Cmd_Argv(1), "anglesy"))
6263 if (Cmd_Argc() != 3)
6265 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6268 angles[1] = atof(Cmd_Argv(2));
6270 else if (!strcmp(Cmd_Argv(1), "anglesz"))
6272 if (Cmd_Argc() != 3)
6274 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6277 angles[2] = atof(Cmd_Argv(2));
6279 else if (!strcmp(Cmd_Argv(1), "color"))
6281 if (Cmd_Argc() != 5)
6283 Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
6286 color[0] = atof(Cmd_Argv(2));
6287 color[1] = atof(Cmd_Argv(3));
6288 color[2] = atof(Cmd_Argv(4));
6290 else if (!strcmp(Cmd_Argv(1), "radius"))
6292 if (Cmd_Argc() != 3)
6294 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6297 radius = atof(Cmd_Argv(2));
6299 else if (!strcmp(Cmd_Argv(1), "colorscale"))
6301 if (Cmd_Argc() == 3)
6303 double scale = atof(Cmd_Argv(2));
6310 if (Cmd_Argc() != 5)
6312 Con_Printf("usage: r_editlights_edit %s red green blue (OR grey instead of red green blue)\n", Cmd_Argv(1));
6315 color[0] *= atof(Cmd_Argv(2));
6316 color[1] *= atof(Cmd_Argv(3));
6317 color[2] *= atof(Cmd_Argv(4));
6320 else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
6322 if (Cmd_Argc() != 3)
6324 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6327 radius *= atof(Cmd_Argv(2));
6329 else if (!strcmp(Cmd_Argv(1), "style"))
6331 if (Cmd_Argc() != 3)
6333 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6336 style = atoi(Cmd_Argv(2));
6338 else if (!strcmp(Cmd_Argv(1), "cubemap"))
6342 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6345 if (Cmd_Argc() == 3)
6346 strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
6350 else if (!strcmp(Cmd_Argv(1), "shadows"))
6352 if (Cmd_Argc() != 3)
6354 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6357 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6359 else if (!strcmp(Cmd_Argv(1), "corona"))
6361 if (Cmd_Argc() != 3)
6363 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6366 corona = atof(Cmd_Argv(2));
6368 else if (!strcmp(Cmd_Argv(1), "coronasize"))
6370 if (Cmd_Argc() != 3)
6372 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6375 coronasizescale = atof(Cmd_Argv(2));
6377 else if (!strcmp(Cmd_Argv(1), "ambient"))
6379 if (Cmd_Argc() != 3)
6381 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6384 ambientscale = atof(Cmd_Argv(2));
6386 else if (!strcmp(Cmd_Argv(1), "diffuse"))
6388 if (Cmd_Argc() != 3)
6390 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6393 diffusescale = atof(Cmd_Argv(2));
6395 else if (!strcmp(Cmd_Argv(1), "specular"))
6397 if (Cmd_Argc() != 3)
6399 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6402 specularscale = atof(Cmd_Argv(2));
6404 else if (!strcmp(Cmd_Argv(1), "normalmode"))
6406 if (Cmd_Argc() != 3)
6408 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6411 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6413 else if (!strcmp(Cmd_Argv(1), "realtimemode"))
6415 if (Cmd_Argc() != 3)
6417 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6420 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6424 Con_Print("usage: r_editlights_edit [property] [value]\n");
6425 Con_Print("Selected light's properties:\n");
6426 Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
6427 Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
6428 Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
6429 Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius);
6430 Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona);
6431 Con_Printf("Style : %i\n", r_shadow_selectedlight->style);
6432 Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
6433 Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname);
6434 Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);
6435 Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale);
6436 Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale);
6437 Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale);
6438 Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
6439 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
6442 flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
6443 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
6446 void R_Shadow_EditLights_EditAll_f(void)
6449 dlight_t *light, *oldselected;
6452 if (!r_editlights.integer)
6454 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
6458 oldselected = r_shadow_selectedlight;
6459 // EditLights doesn't seem to have a "remove" command or something so:
6460 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6461 for (lightindex = 0;lightindex < range;lightindex++)
6463 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6466 R_Shadow_SelectLight(light);
6467 R_Shadow_EditLights_Edit_f();
6469 // return to old selected (to not mess editing once selection is locked)
6470 R_Shadow_SelectLight(oldselected);
6473 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
6475 int lightnumber, lightcount;
6476 size_t lightindex, range;
6480 if (!r_editlights.integer)
6482 x = vid_conwidth.value - 240;
6484 DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
6487 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6488 for (lightindex = 0;lightindex < range;lightindex++)
6490 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6493 if (light == r_shadow_selectedlight)
6494 lightnumber = lightindex;
6497 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, FONT_DEFAULT);y += 8;
6498 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, FONT_DEFAULT);y += 8;
6500 if (r_shadow_selectedlight == NULL)
6502 dpsnprintf(temp, sizeof(temp), "Light #%i properties:", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
6503 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, FONT_DEFAULT);y += 8;
6504 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, FONT_DEFAULT);y += 8;
6505 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, FONT_DEFAULT);y += 8;
6506 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, FONT_DEFAULT);y += 8;
6507 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, FONT_DEFAULT);y += 8;
6508 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, FONT_DEFAULT);y += 8;
6509 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, FONT_DEFAULT);y += 8;
6510 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, FONT_DEFAULT);y += 8;
6511 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, FONT_DEFAULT);y += 8;
6512 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, FONT_DEFAULT);y += 8;
6513 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, FONT_DEFAULT);y += 8;
6514 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, FONT_DEFAULT);y += 8;
6515 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, FONT_DEFAULT);y += 8;
6516 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, FONT_DEFAULT);y += 8;
6519 void R_Shadow_EditLights_ToggleShadow_f(void)
6521 if (!r_editlights.integer)
6523 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6526 if (!r_shadow_selectedlight)
6528 Con_Print("No selected light.\n");
6531 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);
6534 void R_Shadow_EditLights_ToggleCorona_f(void)
6536 if (!r_editlights.integer)
6538 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6541 if (!r_shadow_selectedlight)
6543 Con_Print("No selected light.\n");
6546 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);
6549 void R_Shadow_EditLights_Remove_f(void)
6551 if (!r_editlights.integer)
6553 Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n");
6556 if (!r_shadow_selectedlight)
6558 Con_Print("No selected light.\n");
6561 R_Shadow_FreeWorldLight(r_shadow_selectedlight);
6562 r_shadow_selectedlight = NULL;
6565 void R_Shadow_EditLights_Help_f(void)
6568 "Documentation on r_editlights system:\n"
6570 "r_editlights : enable/disable editing mode\n"
6571 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
6572 "r_editlights_cursorpushback : push back cursor this far from surface\n"
6573 "r_editlights_cursorpushoff : push cursor off surface this far\n"
6574 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
6575 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
6577 "r_editlights_help : this help\n"
6578 "r_editlights_clear : remove all lights\n"
6579 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
6580 "r_editlights_lock : lock selection to current light, if already locked - unlock\n"
6581 "r_editlights_save : save to .rtlights file\n"
6582 "r_editlights_spawn : create a light with default settings\n"
6583 "r_editlights_edit command : edit selected light - more documentation below\n"
6584 "r_editlights_remove : remove selected light\n"
6585 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
6586 "r_editlights_importlightentitiesfrommap : reload light entities\n"
6587 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
6589 "origin x y z : set light location\n"
6590 "originx x: set x component of light location\n"
6591 "originy y: set y component of light location\n"
6592 "originz z: set z component of light location\n"
6593 "move x y z : adjust light location\n"
6594 "movex x: adjust x component of light location\n"
6595 "movey y: adjust y component of light location\n"
6596 "movez z: adjust z component of light location\n"
6597 "angles x y z : set light angles\n"
6598 "anglesx x: set x component of light angles\n"
6599 "anglesy y: set y component of light angles\n"
6600 "anglesz z: set z component of light angles\n"
6601 "color r g b : set color of light (can be brighter than 1 1 1)\n"
6602 "radius radius : set radius (size) of light\n"
6603 "colorscale grey : multiply color of light (1 does nothing)\n"
6604 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
6605 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
6606 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
6607 "originscale x y z : multiply origin of light (1 1 1 does nothing)\n"
6608 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
6609 "cubemap basename : set filter cubemap of light (not yet supported)\n"
6610 "shadows 1/0 : turn on/off shadows\n"
6611 "corona n : set corona intensity\n"
6612 "coronasize n : set corona size (0-1)\n"
6613 "ambient n : set ambient intensity (0-1)\n"
6614 "diffuse n : set diffuse intensity (0-1)\n"
6615 "specular n : set specular intensity (0-1)\n"
6616 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
6617 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
6618 "<nothing> : print light properties to console\n"
6622 void R_Shadow_EditLights_CopyInfo_f(void)
6624 if (!r_editlights.integer)
6626 Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n");
6629 if (!r_shadow_selectedlight)
6631 Con_Print("No selected light.\n");
6634 VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
6635 VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
6636 r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
6637 r_shadow_bufferlight.style = r_shadow_selectedlight->style;
6638 if (r_shadow_selectedlight->cubemapname)
6639 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
6641 r_shadow_bufferlight.cubemapname[0] = 0;
6642 r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
6643 r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
6644 r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
6645 r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
6646 r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
6647 r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
6648 r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
6651 void R_Shadow_EditLights_PasteInfo_f(void)
6653 if (!r_editlights.integer)
6655 Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n");
6658 if (!r_shadow_selectedlight)
6660 Con_Print("No selected light.\n");
6663 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);
6666 void R_Shadow_EditLights_Lock_f(void)
6668 if (!r_editlights.integer)
6670 Con_Print("Cannot lock on light when not in editing mode. Set r_editlights to 1.\n");
6673 if (r_editlights_lockcursor)
6675 r_editlights_lockcursor = false;
6678 if (!r_shadow_selectedlight)
6680 Con_Print("No selected light to lock on.\n");
6683 r_editlights_lockcursor = true;
6686 void R_Shadow_EditLights_Init(void)
6688 Cvar_RegisterVariable(&r_editlights);
6689 Cvar_RegisterVariable(&r_editlights_cursordistance);
6690 Cvar_RegisterVariable(&r_editlights_cursorpushback);
6691 Cvar_RegisterVariable(&r_editlights_cursorpushoff);
6692 Cvar_RegisterVariable(&r_editlights_cursorgrid);
6693 Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
6694 Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
6695 Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
6696 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)");
6697 Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
6698 Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
6699 Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
6700 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)");
6701 Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
6702 Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
6703 Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
6704 Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
6705 Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
6706 Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
6707 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)");
6708 Cmd_AddCommand("r_editlights_lock", R_Shadow_EditLights_Lock_f, "lock selection to current light, if already locked - unlock");
6714 =============================================================================
6718 =============================================================================
6721 void R_LightPoint(vec3_t color, const vec3_t p, const int flags)
6723 int i, numlights, flag;
6724 float f, relativepoint[3], dist, dist2, lightradius2;
6731 if (r_fullbright.integer)
6733 VectorSet(color, 1, 1, 1);
6737 if (flags & LP_LIGHTMAP)
6739 if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
6741 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, color, diffuse, n);
6742 color[0] += r_refdef.scene.ambient + diffuse[0];
6743 color[1] += r_refdef.scene.ambient + diffuse[1];
6744 color[2] += r_refdef.scene.ambient + diffuse[2];
6747 VectorSet(color, 1, 1, 1);
6749 if (flags & LP_RTWORLD)
6751 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6752 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6753 for (i = 0; i < numlights; i++)
6755 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6758 light = &dlight->rtlight;
6759 if (!(light->flags & flag))
6762 lightradius2 = light->radius * light->radius;
6763 VectorSubtract(light->shadoworigin, p, relativepoint);
6764 dist2 = VectorLength2(relativepoint);
6765 if (dist2 >= lightradius2)
6767 dist = sqrt(dist2) / light->radius;
6768 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6771 // todo: add to both ambient and diffuse
6772 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6773 VectorMA(color, f, light->currentcolor, color);
6776 if (flags & LP_DYNLIGHT)
6779 for (i = 0;i < r_refdef.scene.numlights;i++)
6781 light = r_refdef.scene.lights[i];
6783 lightradius2 = light->radius * light->radius;
6784 VectorSubtract(light->shadoworigin, p, relativepoint);
6785 dist2 = VectorLength2(relativepoint);
6786 if (dist2 >= lightradius2)
6788 dist = sqrt(dist2) / light->radius;
6789 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6792 // todo: add to both ambient and diffuse
6793 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6794 VectorMA(color, f, light->color, color);
6799 void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags)
6801 int i, numlights, flag;
6804 float relativepoint[3];
6813 if (r_fullbright.integer)
6815 VectorSet(ambient, 1, 1, 1);
6816 VectorClear(diffuse);
6817 VectorClear(lightdir);
6821 if (flags == LP_LIGHTMAP)
6823 VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6824 VectorClear(diffuse);
6825 VectorClear(lightdir);
6826 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
6827 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambient, diffuse, lightdir);
6831 memset(sample, 0, sizeof(sample));
6832 VectorSet(sample, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6834 if ((flags & LP_LIGHTMAP) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
6837 VectorClear(tempambient);
6839 VectorClear(relativepoint);
6840 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
6841 VectorScale(tempambient, r_refdef.lightmapintensity, tempambient);
6842 VectorScale(color, r_refdef.lightmapintensity, color);
6843 VectorAdd(sample, tempambient, sample);
6844 VectorMA(sample , 0.5f , color, sample );
6845 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6846 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6847 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6848 // calculate a weighted average light direction as well
6849 intensity = VectorLength(color);
6850 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6853 if (flags & LP_RTWORLD)
6855 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6856 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6857 for (i = 0; i < numlights; i++)
6859 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6862 light = &dlight->rtlight;
6863 if (!(light->flags & flag))
6866 lightradius2 = light->radius * light->radius;
6867 VectorSubtract(light->shadoworigin, p, relativepoint);
6868 dist2 = VectorLength2(relativepoint);
6869 if (dist2 >= lightradius2)
6871 dist = sqrt(dist2) / light->radius;
6872 intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value;
6873 if (intensity <= 0.0f)
6875 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6877 // scale down intensity to add to both ambient and diffuse
6878 //intensity *= 0.5f;
6879 VectorNormalize(relativepoint);
6880 VectorScale(light->currentcolor, intensity, color);
6881 VectorMA(sample , 0.5f , color, sample );
6882 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6883 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6884 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6885 // calculate a weighted average light direction as well
6886 intensity *= VectorLength(color);
6887 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6891 if (flags & LP_DYNLIGHT)
6894 for (i = 0;i < r_refdef.scene.numlights;i++)
6896 light = r_refdef.scene.lights[i];
6898 lightradius2 = light->radius * light->radius;
6899 VectorSubtract(light->shadoworigin, p, relativepoint);
6900 dist2 = VectorLength2(relativepoint);
6901 if (dist2 >= lightradius2)
6903 dist = sqrt(dist2) / light->radius;
6904 intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value;
6905 if (intensity <= 0.0f)
6907 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6909 // scale down intensity to add to both ambient and diffuse
6910 //intensity *= 0.5f;
6911 VectorNormalize(relativepoint);
6912 VectorScale(light->currentcolor, intensity, color);
6913 VectorMA(sample , 0.5f , color, sample );
6914 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6915 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6916 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6917 // calculate a weighted average light direction as well
6918 intensity *= VectorLength(color);
6919 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6923 // calculate the direction we'll use to reduce the sample to a directional light source
6924 VectorCopy(sample + 12, dir);
6925 //VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
6926 VectorNormalize(dir);
6927 // extract the diffuse color along the chosen direction and scale it
6928 diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]);
6929 diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]);
6930 diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]);
6931 // subtract some of diffuse from ambient
6932 VectorMA(sample, -0.333f, diffuse, ambient);
6933 // store the normalized lightdir
6934 VectorCopy(dir, lightdir);