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 static 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_shadowmap2ddepthbuffer;
248 rtexture_t *r_shadow_shadowmap2ddepthtexture;
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_prepassgeometrydepthbuffer;
259 rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
260 rtexture_t *r_shadow_prepasslightingdiffusetexture;
261 rtexture_t *r_shadow_prepasslightingspeculartexture;
263 // keep track of the provided framebuffer info
264 static int r_shadow_fb_fbo;
265 static rtexture_t *r_shadow_fb_depthtexture;
266 static rtexture_t *r_shadow_fb_colortexture;
268 // lights are reloaded when this changes
269 char r_shadow_mapname[MAX_QPATH];
271 // used only for light filters (cubemaps)
272 rtexturepool_t *r_shadow_filters_texturepool;
274 cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"};
275 cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
276 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
277 cvar_t r_shadow_deferred = {CVAR_SAVE, "r_shadow_deferred", "0", "uses image-based lighting instead of geometry-based lighting, the method used renders a depth image and a normalmap image, renders lights into separate diffuse and specular images, and then combines this into the normal rendering, requires r_shadow_shadowmapping"};
278 cvar_t r_shadow_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 8x 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_includedirectlighting = {CVAR_SAVE, "r_shadow_bouncegrid_includedirectlighting", "0", "allows direct lighting to be recorded, not just indirect (gives an effect somewhat like r_shadow_realtime_world_lightmaps)"};
328 cvar_t r_shadow_bouncegrid_intensity = {CVAR_SAVE, "r_shadow_bouncegrid_intensity", "4", "overall brightness of bouncegrid texture"};
329 cvar_t r_shadow_bouncegrid_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_lightradiusscale", "4", "particles stop at this fraction of light radius (can be more than 1)"};
330 cvar_t r_shadow_bouncegrid_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_maxbounce", "2", "maximum number of bounces for a particle (minimum is 0)"};
331 cvar_t r_shadow_bouncegrid_particlebounceintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particlebounceintensity", "1", "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"};
332 cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "1", "brightness of particles contributing to bouncegrid texture"};
333 cvar_t r_shadow_bouncegrid_photons = {CVAR_SAVE, "r_shadow_bouncegrid_photons", "2000", "total photons to shoot per update, divided proportionately between lights"};
334 cvar_t r_shadow_bouncegrid_spacing = {CVAR_SAVE, "r_shadow_bouncegrid_spacing", "64", "unit size of bouncegrid pixel"};
335 cvar_t r_shadow_bouncegrid_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_stablerandom", "1", "make particle distribution consistent from frame to frame"};
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_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when in static mode"};
338 cvar_t r_shadow_bouncegrid_static_lightradiusscale = {CVAR_SAVE, "r_shadow_bouncegrid_static_lightradiusscale", "10", "particles stop at this fraction of light radius (can be more than 1) when in static mode"};
339 cvar_t r_shadow_bouncegrid_static_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_static_maxbounce", "5", "maximum number of bounces for a particle (minimum is 0) in static mode"};
340 cvar_t r_shadow_bouncegrid_static_photons = {CVAR_SAVE, "r_shadow_bouncegrid_static_photons", "25000", "photons value to use when in static mode"};
341 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"};
342 cvar_t r_shadow_bouncegrid_x = {CVAR_SAVE, "r_shadow_bouncegrid_x", "64", "maximum texture size of bouncegrid on X axis"};
343 cvar_t r_shadow_bouncegrid_y = {CVAR_SAVE, "r_shadow_bouncegrid_y", "64", "maximum texture size of bouncegrid on Y axis"};
344 cvar_t r_shadow_bouncegrid_z = {CVAR_SAVE, "r_shadow_bouncegrid_z", "32", "maximum texture size of bouncegrid on Z axis"};
345 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
346 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"};
347 cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
348 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
349 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
350 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
351 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
352 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
353 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
354 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
355 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
356 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
358 typedef struct r_shadow_bouncegrid_settings_s
361 qboolean bounceanglediffuse;
362 qboolean directionalshading;
363 qboolean includedirectlighting;
364 float dlightparticlemultiplier;
366 float lightradiusscale;
368 float particlebounceintensity;
369 float particleintensity;
374 r_shadow_bouncegrid_settings_t;
376 r_shadow_bouncegrid_settings_t r_shadow_bouncegridsettings;
377 rtexture_t *r_shadow_bouncegridtexture;
378 matrix4x4_t r_shadow_bouncegridmatrix;
379 vec_t r_shadow_bouncegridintensity;
380 qboolean r_shadow_bouncegriddirectional;
381 static double r_shadow_bouncegridtime;
382 static int r_shadow_bouncegridresolution[3];
383 static int r_shadow_bouncegridnumpixels;
384 static unsigned char *r_shadow_bouncegridpixels;
385 static float *r_shadow_bouncegridhighpixels;
387 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
388 #define ATTENTABLESIZE 256
389 // 1D gradient, 2D circle and 3D sphere attenuation textures
390 #define ATTEN1DSIZE 32
391 #define ATTEN2DSIZE 64
392 #define ATTEN3DSIZE 32
394 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
395 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
396 static float r_shadow_attentable[ATTENTABLESIZE+1];
398 rtlight_t *r_shadow_compilingrtlight;
399 static memexpandablearray_t r_shadow_worldlightsarray;
400 dlight_t *r_shadow_selectedlight;
401 dlight_t r_shadow_bufferlight;
402 vec3_t r_editlights_cursorlocation;
403 qboolean r_editlights_lockcursor;
405 extern int con_vislines;
407 void R_Shadow_UncompileWorldLights(void);
408 void R_Shadow_ClearWorldLights(void);
409 void R_Shadow_SaveWorldLights(void);
410 void R_Shadow_LoadWorldLights(void);
411 void R_Shadow_LoadLightsFile(void);
412 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
413 void R_Shadow_EditLights_Reload_f(void);
414 void R_Shadow_ValidateCvars(void);
415 static void R_Shadow_MakeTextures(void);
417 #define EDLIGHTSPRSIZE 8
418 skinframe_t *r_editlights_sprcursor;
419 skinframe_t *r_editlights_sprlight;
420 skinframe_t *r_editlights_sprnoshadowlight;
421 skinframe_t *r_editlights_sprcubemaplight;
422 skinframe_t *r_editlights_sprcubemapnoshadowlight;
423 skinframe_t *r_editlights_sprselection;
425 static void R_Shadow_SetShadowMode(void)
427 r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
428 r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20;
429 r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
430 r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
431 r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
432 r_shadow_shadowmaplod = -1;
433 r_shadow_shadowmapsize = 0;
434 r_shadow_shadowmapsampler = false;
435 r_shadow_shadowmappcf = 0;
436 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
437 if ((r_shadow_shadowmapping.integer || r_shadow_deferred.integer) && vid.support.ext_framebuffer_object)
439 switch(vid.renderpath)
441 case RENDERPATH_GL20:
442 if(r_shadow_shadowmapfilterquality < 0)
444 if (!r_fb.usedepthtextures)
445 r_shadow_shadowmappcf = 1;
446 else if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
447 r_shadow_shadowmappcf = 1;
448 else if(strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD"))
450 r_shadow_shadowmapsampler = vid.support.arb_shadow;
451 r_shadow_shadowmappcf = 1;
453 else if(strstr(gl_vendor, "ATI"))
454 r_shadow_shadowmappcf = 1;
456 r_shadow_shadowmapsampler = vid.support.arb_shadow;
460 switch (r_shadow_shadowmapfilterquality)
463 r_shadow_shadowmapsampler = vid.support.arb_shadow;
466 r_shadow_shadowmapsampler = vid.support.arb_shadow;
467 r_shadow_shadowmappcf = 1;
470 r_shadow_shadowmappcf = 1;
473 r_shadow_shadowmappcf = 2;
477 if (!r_fb.usedepthtextures)
478 r_shadow_shadowmapsampler = false;
479 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
481 case RENDERPATH_D3D9:
482 case RENDERPATH_D3D10:
483 case RENDERPATH_D3D11:
484 case RENDERPATH_SOFT:
485 r_shadow_shadowmapsampler = false;
486 r_shadow_shadowmappcf = 1;
487 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
489 case RENDERPATH_GL11:
490 case RENDERPATH_GL13:
491 case RENDERPATH_GLES1:
492 case RENDERPATH_GLES2:
498 qboolean R_Shadow_ShadowMappingEnabled(void)
500 switch (r_shadow_shadowmode)
502 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
509 static void R_Shadow_FreeShadowMaps(void)
511 R_Shadow_SetShadowMode();
513 R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d);
517 if (r_shadow_shadowmap2ddepthtexture)
518 R_FreeTexture(r_shadow_shadowmap2ddepthtexture);
519 r_shadow_shadowmap2ddepthtexture = NULL;
521 if (r_shadow_shadowmap2ddepthbuffer)
522 R_FreeTexture(r_shadow_shadowmap2ddepthbuffer);
523 r_shadow_shadowmap2ddepthbuffer = NULL;
525 if (r_shadow_shadowmapvsdcttexture)
526 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
527 r_shadow_shadowmapvsdcttexture = NULL;
530 static void r_shadow_start(void)
532 // allocate vertex processing arrays
533 r_shadow_bouncegridpixels = NULL;
534 r_shadow_bouncegridhighpixels = NULL;
535 r_shadow_bouncegridnumpixels = 0;
536 r_shadow_bouncegridtexture = NULL;
537 r_shadow_bouncegriddirectional = false;
538 r_shadow_attenuationgradienttexture = NULL;
539 r_shadow_attenuation2dtexture = NULL;
540 r_shadow_attenuation3dtexture = NULL;
541 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
542 r_shadow_shadowmap2ddepthtexture = NULL;
543 r_shadow_shadowmap2ddepthbuffer = NULL;
544 r_shadow_shadowmapvsdcttexture = NULL;
545 r_shadow_shadowmapmaxsize = 0;
546 r_shadow_shadowmapsize = 0;
547 r_shadow_shadowmaplod = 0;
548 r_shadow_shadowmapfilterquality = -1;
549 r_shadow_shadowmapdepthbits = 0;
550 r_shadow_shadowmapvsdct = false;
551 r_shadow_shadowmapsampler = false;
552 r_shadow_shadowmappcf = 0;
555 R_Shadow_FreeShadowMaps();
557 r_shadow_texturepool = NULL;
558 r_shadow_filters_texturepool = NULL;
559 R_Shadow_ValidateCvars();
560 R_Shadow_MakeTextures();
561 maxshadowtriangles = 0;
562 shadowelements = NULL;
563 maxshadowvertices = 0;
564 shadowvertex3f = NULL;
572 shadowmarklist = NULL;
577 shadowsideslist = NULL;
578 r_shadow_buffer_numleafpvsbytes = 0;
579 r_shadow_buffer_visitingleafpvs = NULL;
580 r_shadow_buffer_leafpvs = NULL;
581 r_shadow_buffer_leaflist = NULL;
582 r_shadow_buffer_numsurfacepvsbytes = 0;
583 r_shadow_buffer_surfacepvs = NULL;
584 r_shadow_buffer_surfacelist = NULL;
585 r_shadow_buffer_surfacesides = NULL;
586 r_shadow_buffer_numshadowtrispvsbytes = 0;
587 r_shadow_buffer_shadowtrispvs = NULL;
588 r_shadow_buffer_numlighttrispvsbytes = 0;
589 r_shadow_buffer_lighttrispvs = NULL;
591 r_shadow_usingdeferredprepass = false;
592 r_shadow_prepass_width = r_shadow_prepass_height = 0;
595 static void R_Shadow_FreeDeferred(void);
596 static void r_shadow_shutdown(void)
599 R_Shadow_UncompileWorldLights();
601 R_Shadow_FreeShadowMaps();
603 r_shadow_usingdeferredprepass = false;
604 if (r_shadow_prepass_width)
605 R_Shadow_FreeDeferred();
606 r_shadow_prepass_width = r_shadow_prepass_height = 0;
609 r_shadow_bouncegridtexture = NULL;
610 r_shadow_bouncegridpixels = NULL;
611 r_shadow_bouncegridhighpixels = NULL;
612 r_shadow_bouncegridnumpixels = 0;
613 r_shadow_bouncegriddirectional = false;
614 r_shadow_attenuationgradienttexture = NULL;
615 r_shadow_attenuation2dtexture = NULL;
616 r_shadow_attenuation3dtexture = NULL;
617 R_FreeTexturePool(&r_shadow_texturepool);
618 R_FreeTexturePool(&r_shadow_filters_texturepool);
619 maxshadowtriangles = 0;
621 Mem_Free(shadowelements);
622 shadowelements = NULL;
624 Mem_Free(shadowvertex3f);
625 shadowvertex3f = NULL;
628 Mem_Free(vertexupdate);
631 Mem_Free(vertexremap);
637 Mem_Free(shadowmark);
640 Mem_Free(shadowmarklist);
641 shadowmarklist = NULL;
646 Mem_Free(shadowsides);
649 Mem_Free(shadowsideslist);
650 shadowsideslist = NULL;
651 r_shadow_buffer_numleafpvsbytes = 0;
652 if (r_shadow_buffer_visitingleafpvs)
653 Mem_Free(r_shadow_buffer_visitingleafpvs);
654 r_shadow_buffer_visitingleafpvs = NULL;
655 if (r_shadow_buffer_leafpvs)
656 Mem_Free(r_shadow_buffer_leafpvs);
657 r_shadow_buffer_leafpvs = NULL;
658 if (r_shadow_buffer_leaflist)
659 Mem_Free(r_shadow_buffer_leaflist);
660 r_shadow_buffer_leaflist = NULL;
661 r_shadow_buffer_numsurfacepvsbytes = 0;
662 if (r_shadow_buffer_surfacepvs)
663 Mem_Free(r_shadow_buffer_surfacepvs);
664 r_shadow_buffer_surfacepvs = NULL;
665 if (r_shadow_buffer_surfacelist)
666 Mem_Free(r_shadow_buffer_surfacelist);
667 r_shadow_buffer_surfacelist = NULL;
668 if (r_shadow_buffer_surfacesides)
669 Mem_Free(r_shadow_buffer_surfacesides);
670 r_shadow_buffer_surfacesides = NULL;
671 r_shadow_buffer_numshadowtrispvsbytes = 0;
672 if (r_shadow_buffer_shadowtrispvs)
673 Mem_Free(r_shadow_buffer_shadowtrispvs);
674 r_shadow_buffer_numlighttrispvsbytes = 0;
675 if (r_shadow_buffer_lighttrispvs)
676 Mem_Free(r_shadow_buffer_lighttrispvs);
679 static void r_shadow_newmap(void)
681 if (r_shadow_bouncegridtexture) R_FreeTexture(r_shadow_bouncegridtexture);r_shadow_bouncegridtexture = NULL;
682 if (r_shadow_lightcorona) R_SkinFrame_MarkUsed(r_shadow_lightcorona);
683 if (r_editlights_sprcursor) R_SkinFrame_MarkUsed(r_editlights_sprcursor);
684 if (r_editlights_sprlight) R_SkinFrame_MarkUsed(r_editlights_sprlight);
685 if (r_editlights_sprnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
686 if (r_editlights_sprcubemaplight) R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
687 if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
688 if (r_editlights_sprselection) R_SkinFrame_MarkUsed(r_editlights_sprselection);
689 if (strncmp(cl.worldname, r_shadow_mapname, sizeof(r_shadow_mapname)))
690 R_Shadow_EditLights_Reload_f();
693 void R_Shadow_Init(void)
695 Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
696 Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
697 Cvar_RegisterVariable(&r_shadow_usebihculling);
698 Cvar_RegisterVariable(&r_shadow_usenormalmap);
699 Cvar_RegisterVariable(&r_shadow_debuglight);
700 Cvar_RegisterVariable(&r_shadow_deferred);
701 Cvar_RegisterVariable(&r_shadow_gloss);
702 Cvar_RegisterVariable(&r_shadow_gloss2intensity);
703 Cvar_RegisterVariable(&r_shadow_glossintensity);
704 Cvar_RegisterVariable(&r_shadow_glossexponent);
705 Cvar_RegisterVariable(&r_shadow_gloss2exponent);
706 Cvar_RegisterVariable(&r_shadow_glossexact);
707 Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
708 Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
709 Cvar_RegisterVariable(&r_shadow_lightintensityscale);
710 Cvar_RegisterVariable(&r_shadow_lightradiusscale);
711 Cvar_RegisterVariable(&r_shadow_projectdistance);
712 Cvar_RegisterVariable(&r_shadow_frontsidecasting);
713 Cvar_RegisterVariable(&r_shadow_realtime_dlight);
714 Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
715 Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
716 Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
717 Cvar_RegisterVariable(&r_shadow_realtime_world);
718 Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
719 Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
720 Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
721 Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
722 Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
723 Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
724 Cvar_RegisterVariable(&r_shadow_scissor);
725 Cvar_RegisterVariable(&r_shadow_shadowmapping);
726 Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
727 Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
728 Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
729 Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
730 Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
731 Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
732 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
733 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
734 Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
735 Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
736 Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
737 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
738 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
739 Cvar_RegisterVariable(&r_shadow_sortsurfaces);
740 Cvar_RegisterVariable(&r_shadow_polygonfactor);
741 Cvar_RegisterVariable(&r_shadow_polygonoffset);
742 Cvar_RegisterVariable(&r_shadow_texture3d);
743 Cvar_RegisterVariable(&r_shadow_bouncegrid);
744 Cvar_RegisterVariable(&r_shadow_bouncegrid_bounceanglediffuse);
745 Cvar_RegisterVariable(&r_shadow_bouncegrid_directionalshading);
746 Cvar_RegisterVariable(&r_shadow_bouncegrid_dlightparticlemultiplier);
747 Cvar_RegisterVariable(&r_shadow_bouncegrid_hitmodels);
748 Cvar_RegisterVariable(&r_shadow_bouncegrid_includedirectlighting);
749 Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
750 Cvar_RegisterVariable(&r_shadow_bouncegrid_lightradiusscale);
751 Cvar_RegisterVariable(&r_shadow_bouncegrid_maxbounce);
752 Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
753 Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
754 Cvar_RegisterVariable(&r_shadow_bouncegrid_photons);
755 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacing);
756 Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom);
757 Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
758 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
759 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_lightradiusscale);
760 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxbounce);
761 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_photons);
762 Cvar_RegisterVariable(&r_shadow_bouncegrid_updateinterval);
763 Cvar_RegisterVariable(&r_shadow_bouncegrid_x);
764 Cvar_RegisterVariable(&r_shadow_bouncegrid_y);
765 Cvar_RegisterVariable(&r_shadow_bouncegrid_z);
766 Cvar_RegisterVariable(&r_coronas);
767 Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
768 Cvar_RegisterVariable(&r_coronas_occlusionquery);
769 Cvar_RegisterVariable(&gl_flashblend);
770 Cvar_RegisterVariable(&gl_ext_separatestencil);
771 Cvar_RegisterVariable(&gl_ext_stenciltwoside);
772 R_Shadow_EditLights_Init();
773 Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
774 maxshadowtriangles = 0;
775 shadowelements = NULL;
776 maxshadowvertices = 0;
777 shadowvertex3f = NULL;
785 shadowmarklist = NULL;
790 shadowsideslist = NULL;
791 r_shadow_buffer_numleafpvsbytes = 0;
792 r_shadow_buffer_visitingleafpvs = NULL;
793 r_shadow_buffer_leafpvs = NULL;
794 r_shadow_buffer_leaflist = NULL;
795 r_shadow_buffer_numsurfacepvsbytes = 0;
796 r_shadow_buffer_surfacepvs = NULL;
797 r_shadow_buffer_surfacelist = NULL;
798 r_shadow_buffer_surfacesides = NULL;
799 r_shadow_buffer_shadowtrispvs = NULL;
800 r_shadow_buffer_lighttrispvs = NULL;
801 R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
804 matrix4x4_t matrix_attenuationxyz =
807 {0.5, 0.0, 0.0, 0.5},
808 {0.0, 0.5, 0.0, 0.5},
809 {0.0, 0.0, 0.5, 0.5},
814 matrix4x4_t matrix_attenuationz =
817 {0.0, 0.0, 0.5, 0.5},
818 {0.0, 0.0, 0.0, 0.5},
819 {0.0, 0.0, 0.0, 0.5},
824 static void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
826 numvertices = ((numvertices + 255) & ~255) * vertscale;
827 numtriangles = ((numtriangles + 255) & ~255) * triscale;
828 // make sure shadowelements is big enough for this volume
829 if (maxshadowtriangles < numtriangles)
831 maxshadowtriangles = numtriangles;
833 Mem_Free(shadowelements);
834 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
836 // make sure shadowvertex3f is big enough for this volume
837 if (maxshadowvertices < numvertices)
839 maxshadowvertices = numvertices;
841 Mem_Free(shadowvertex3f);
842 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
846 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
848 int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
849 int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
850 int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
851 int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
852 if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
854 if (r_shadow_buffer_visitingleafpvs)
855 Mem_Free(r_shadow_buffer_visitingleafpvs);
856 if (r_shadow_buffer_leafpvs)
857 Mem_Free(r_shadow_buffer_leafpvs);
858 if (r_shadow_buffer_leaflist)
859 Mem_Free(r_shadow_buffer_leaflist);
860 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
861 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
862 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
863 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
865 if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
867 if (r_shadow_buffer_surfacepvs)
868 Mem_Free(r_shadow_buffer_surfacepvs);
869 if (r_shadow_buffer_surfacelist)
870 Mem_Free(r_shadow_buffer_surfacelist);
871 if (r_shadow_buffer_surfacesides)
872 Mem_Free(r_shadow_buffer_surfacesides);
873 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
874 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
875 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
876 r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
878 if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
880 if (r_shadow_buffer_shadowtrispvs)
881 Mem_Free(r_shadow_buffer_shadowtrispvs);
882 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
883 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
885 if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
887 if (r_shadow_buffer_lighttrispvs)
888 Mem_Free(r_shadow_buffer_lighttrispvs);
889 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
890 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
894 void R_Shadow_PrepareShadowMark(int numtris)
896 // make sure shadowmark is big enough for this volume
897 if (maxshadowmark < numtris)
899 maxshadowmark = numtris;
901 Mem_Free(shadowmark);
903 Mem_Free(shadowmarklist);
904 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
905 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
909 // if shadowmarkcount wrapped we clear the array and adjust accordingly
910 if (shadowmarkcount == 0)
913 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
918 void R_Shadow_PrepareShadowSides(int numtris)
920 if (maxshadowsides < numtris)
922 maxshadowsides = numtris;
924 Mem_Free(shadowsides);
926 Mem_Free(shadowsideslist);
927 shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
928 shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
933 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)
936 int outtriangles = 0, outvertices = 0;
939 float ratio, direction[3], projectvector[3];
941 if (projectdirection)
942 VectorScale(projectdirection, projectdistance, projectvector);
944 VectorClear(projectvector);
946 // create the vertices
947 if (projectdirection)
949 for (i = 0;i < numshadowmarktris;i++)
951 element = inelement3i + shadowmarktris[i] * 3;
952 for (j = 0;j < 3;j++)
954 if (vertexupdate[element[j]] != vertexupdatenum)
956 vertexupdate[element[j]] = vertexupdatenum;
957 vertexremap[element[j]] = outvertices;
958 vertex = invertex3f + element[j] * 3;
959 // project one copy of the vertex according to projectvector
960 VectorCopy(vertex, outvertex3f);
961 VectorAdd(vertex, projectvector, (outvertex3f + 3));
970 for (i = 0;i < numshadowmarktris;i++)
972 element = inelement3i + shadowmarktris[i] * 3;
973 for (j = 0;j < 3;j++)
975 if (vertexupdate[element[j]] != vertexupdatenum)
977 vertexupdate[element[j]] = vertexupdatenum;
978 vertexremap[element[j]] = outvertices;
979 vertex = invertex3f + element[j] * 3;
980 // project one copy of the vertex to the sphere radius of the light
981 // (FIXME: would projecting it to the light box be better?)
982 VectorSubtract(vertex, projectorigin, direction);
983 ratio = projectdistance / VectorLength(direction);
984 VectorCopy(vertex, outvertex3f);
985 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
993 if (r_shadow_frontsidecasting.integer)
995 for (i = 0;i < numshadowmarktris;i++)
997 int remappedelement[3];
999 const int *neighbortriangle;
1001 markindex = shadowmarktris[i] * 3;
1002 element = inelement3i + markindex;
1003 neighbortriangle = inneighbor3i + markindex;
1004 // output the front and back triangles
1005 outelement3i[0] = vertexremap[element[0]];
1006 outelement3i[1] = vertexremap[element[1]];
1007 outelement3i[2] = vertexremap[element[2]];
1008 outelement3i[3] = vertexremap[element[2]] + 1;
1009 outelement3i[4] = vertexremap[element[1]] + 1;
1010 outelement3i[5] = vertexremap[element[0]] + 1;
1014 // output the sides (facing outward from this triangle)
1015 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1017 remappedelement[0] = vertexremap[element[0]];
1018 remappedelement[1] = vertexremap[element[1]];
1019 outelement3i[0] = remappedelement[1];
1020 outelement3i[1] = remappedelement[0];
1021 outelement3i[2] = remappedelement[0] + 1;
1022 outelement3i[3] = remappedelement[1];
1023 outelement3i[4] = remappedelement[0] + 1;
1024 outelement3i[5] = remappedelement[1] + 1;
1029 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1031 remappedelement[1] = vertexremap[element[1]];
1032 remappedelement[2] = vertexremap[element[2]];
1033 outelement3i[0] = remappedelement[2];
1034 outelement3i[1] = remappedelement[1];
1035 outelement3i[2] = remappedelement[1] + 1;
1036 outelement3i[3] = remappedelement[2];
1037 outelement3i[4] = remappedelement[1] + 1;
1038 outelement3i[5] = remappedelement[2] + 1;
1043 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1045 remappedelement[0] = vertexremap[element[0]];
1046 remappedelement[2] = vertexremap[element[2]];
1047 outelement3i[0] = remappedelement[0];
1048 outelement3i[1] = remappedelement[2];
1049 outelement3i[2] = remappedelement[2] + 1;
1050 outelement3i[3] = remappedelement[0];
1051 outelement3i[4] = remappedelement[2] + 1;
1052 outelement3i[5] = remappedelement[0] + 1;
1061 for (i = 0;i < numshadowmarktris;i++)
1063 int remappedelement[3];
1065 const int *neighbortriangle;
1067 markindex = shadowmarktris[i] * 3;
1068 element = inelement3i + markindex;
1069 neighbortriangle = inneighbor3i + markindex;
1070 // output the front and back triangles
1071 outelement3i[0] = vertexremap[element[2]];
1072 outelement3i[1] = vertexremap[element[1]];
1073 outelement3i[2] = vertexremap[element[0]];
1074 outelement3i[3] = vertexremap[element[0]] + 1;
1075 outelement3i[4] = vertexremap[element[1]] + 1;
1076 outelement3i[5] = vertexremap[element[2]] + 1;
1080 // output the sides (facing outward from this triangle)
1081 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1083 remappedelement[0] = vertexremap[element[0]];
1084 remappedelement[1] = vertexremap[element[1]];
1085 outelement3i[0] = remappedelement[0];
1086 outelement3i[1] = remappedelement[1];
1087 outelement3i[2] = remappedelement[1] + 1;
1088 outelement3i[3] = remappedelement[0];
1089 outelement3i[4] = remappedelement[1] + 1;
1090 outelement3i[5] = remappedelement[0] + 1;
1095 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1097 remappedelement[1] = vertexremap[element[1]];
1098 remappedelement[2] = vertexremap[element[2]];
1099 outelement3i[0] = remappedelement[1];
1100 outelement3i[1] = remappedelement[2];
1101 outelement3i[2] = remappedelement[2] + 1;
1102 outelement3i[3] = remappedelement[1];
1103 outelement3i[4] = remappedelement[2] + 1;
1104 outelement3i[5] = remappedelement[1] + 1;
1109 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1111 remappedelement[0] = vertexremap[element[0]];
1112 remappedelement[2] = vertexremap[element[2]];
1113 outelement3i[0] = remappedelement[2];
1114 outelement3i[1] = remappedelement[0];
1115 outelement3i[2] = remappedelement[0] + 1;
1116 outelement3i[3] = remappedelement[2];
1117 outelement3i[4] = remappedelement[0] + 1;
1118 outelement3i[5] = remappedelement[2] + 1;
1126 *outnumvertices = outvertices;
1127 return outtriangles;
1130 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)
1133 int outtriangles = 0, outvertices = 0;
1135 const float *vertex;
1136 float ratio, direction[3], projectvector[3];
1139 if (projectdirection)
1140 VectorScale(projectdirection, projectdistance, projectvector);
1142 VectorClear(projectvector);
1144 for (i = 0;i < numshadowmarktris;i++)
1146 int remappedelement[3];
1148 const int *neighbortriangle;
1150 markindex = shadowmarktris[i] * 3;
1151 neighbortriangle = inneighbor3i + markindex;
1152 side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
1153 side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
1154 side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
1155 if (side[0] + side[1] + side[2] == 0)
1159 element = inelement3i + markindex;
1161 // create the vertices
1162 for (j = 0;j < 3;j++)
1164 if (side[j] + side[j+1] == 0)
1167 if (vertexupdate[k] != vertexupdatenum)
1169 vertexupdate[k] = vertexupdatenum;
1170 vertexremap[k] = outvertices;
1171 vertex = invertex3f + k * 3;
1172 VectorCopy(vertex, outvertex3f);
1173 if (projectdirection)
1175 // project one copy of the vertex according to projectvector
1176 VectorAdd(vertex, projectvector, (outvertex3f + 3));
1180 // project one copy of the vertex to the sphere radius of the light
1181 // (FIXME: would projecting it to the light box be better?)
1182 VectorSubtract(vertex, projectorigin, direction);
1183 ratio = projectdistance / VectorLength(direction);
1184 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
1191 // output the sides (facing outward from this triangle)
1194 remappedelement[0] = vertexremap[element[0]];
1195 remappedelement[1] = vertexremap[element[1]];
1196 outelement3i[0] = remappedelement[1];
1197 outelement3i[1] = remappedelement[0];
1198 outelement3i[2] = remappedelement[0] + 1;
1199 outelement3i[3] = remappedelement[1];
1200 outelement3i[4] = remappedelement[0] + 1;
1201 outelement3i[5] = remappedelement[1] + 1;
1208 remappedelement[1] = vertexremap[element[1]];
1209 remappedelement[2] = vertexremap[element[2]];
1210 outelement3i[0] = remappedelement[2];
1211 outelement3i[1] = remappedelement[1];
1212 outelement3i[2] = remappedelement[1] + 1;
1213 outelement3i[3] = remappedelement[2];
1214 outelement3i[4] = remappedelement[1] + 1;
1215 outelement3i[5] = remappedelement[2] + 1;
1222 remappedelement[0] = vertexremap[element[0]];
1223 remappedelement[2] = vertexremap[element[2]];
1224 outelement3i[0] = remappedelement[0];
1225 outelement3i[1] = remappedelement[2];
1226 outelement3i[2] = remappedelement[2] + 1;
1227 outelement3i[3] = remappedelement[0];
1228 outelement3i[4] = remappedelement[2] + 1;
1229 outelement3i[5] = remappedelement[0] + 1;
1236 *outnumvertices = outvertices;
1237 return outtriangles;
1240 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)
1246 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1248 tend = firsttriangle + numtris;
1249 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1251 // surface box entirely inside light box, no box cull
1252 if (projectdirection)
1254 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1256 TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal);
1257 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1258 shadowmarklist[numshadowmark++] = t;
1263 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1264 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
1265 shadowmarklist[numshadowmark++] = t;
1270 // surface box not entirely inside light box, cull each triangle
1271 if (projectdirection)
1273 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1275 v[0] = invertex3f + e[0] * 3;
1276 v[1] = invertex3f + e[1] * 3;
1277 v[2] = invertex3f + e[2] * 3;
1278 TriangleNormal(v[0], v[1], v[2], normal);
1279 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1280 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1281 shadowmarklist[numshadowmark++] = t;
1286 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1288 v[0] = invertex3f + e[0] * 3;
1289 v[1] = invertex3f + e[1] * 3;
1290 v[2] = invertex3f + e[2] * 3;
1291 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1292 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1293 shadowmarklist[numshadowmark++] = t;
1299 static qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
1304 if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
1306 // check if the shadow volume intersects the near plane
1308 // a ray between the eye and light origin may intersect the caster,
1309 // indicating that the shadow may touch the eye location, however we must
1310 // test the near plane (a polygon), not merely the eye location, so it is
1311 // easiest to enlarge the caster bounding shape slightly for this.
1317 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)
1319 int i, tris, outverts;
1320 if (projectdistance < 0.1)
1322 Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
1325 if (!numverts || !nummarktris)
1327 // make sure shadowelements is big enough for this volume
1328 if (maxshadowtriangles < nummarktris*8 || maxshadowvertices < numverts*2)
1329 R_Shadow_ResizeShadowArrays(numverts, nummarktris, 2, 8);
1331 if (maxvertexupdate < numverts)
1333 maxvertexupdate = numverts;
1335 Mem_Free(vertexupdate);
1337 Mem_Free(vertexremap);
1338 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1339 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1340 vertexupdatenum = 0;
1343 if (vertexupdatenum == 0)
1345 vertexupdatenum = 1;
1346 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
1347 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
1350 for (i = 0;i < nummarktris;i++)
1351 shadowmark[marktris[i]] = shadowmarkcount;
1353 if (r_shadow_compilingrtlight)
1355 // if we're compiling an rtlight, capture the mesh
1356 //tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1357 //Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1358 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1359 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1361 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
1363 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1364 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1365 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1369 // decide which type of shadow to generate and set stencil mode
1370 R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
1371 // generate the sides or a solid volume, depending on type
1372 if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
1373 tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1375 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1376 r_refdef.stats.lights_dynamicshadowtriangles += tris;
1377 r_refdef.stats.lights_shadowtriangles += tris;
1378 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
1380 // increment stencil if frontface is infront of depthbuffer
1381 GL_CullFace(r_refdef.view.cullface_front);
1382 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
1383 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1384 // decrement stencil if backface is infront of depthbuffer
1385 GL_CullFace(r_refdef.view.cullface_back);
1386 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
1388 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
1390 // decrement stencil if backface is behind depthbuffer
1391 GL_CullFace(r_refdef.view.cullface_front);
1392 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
1393 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1394 // increment stencil if frontface is behind depthbuffer
1395 GL_CullFace(r_refdef.view.cullface_back);
1396 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
1398 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1399 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1403 int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
1405 // p1, p2, p3 are in the cubemap's local coordinate system
1406 // bias = border/(size - border)
1409 float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1410 dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
1411 dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
1412 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1414 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1415 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1416 | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1417 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1419 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1420 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1421 | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1423 dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1424 dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
1425 dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
1426 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1428 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1429 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1430 | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1431 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1433 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1434 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1435 | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1437 dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1438 dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
1439 dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
1440 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1442 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1443 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1444 | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1445 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1447 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1448 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1449 | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1454 static int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
1456 vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
1457 float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
1460 VectorSubtract(maxs, mins, radius);
1461 VectorScale(radius, 0.5f, radius);
1462 VectorAdd(mins, radius, center);
1463 Matrix4x4_Transform(worldtolight, center, lightcenter);
1464 Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
1465 VectorSubtract(lightcenter, lightradius, pmin);
1466 VectorAdd(lightcenter, lightradius, pmax);
1468 dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1469 dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
1470 if(ap1 > bias*an1 && ap2 > bias*an2)
1472 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1473 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1474 if(an1 > bias*ap1 && an2 > bias*ap2)
1476 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1477 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1479 dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1480 dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
1481 if(ap1 > bias*an1 && ap2 > bias*an2)
1483 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1484 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1485 if(an1 > bias*ap1 && an2 > bias*ap2)
1487 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1488 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1490 dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1491 dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
1492 if(ap1 > bias*an1 && ap2 > bias*an2)
1494 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1495 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1496 if(an1 > bias*ap1 && an2 > bias*ap2)
1498 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1499 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1504 #define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
1506 int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
1508 // p is in the cubemap's local coordinate system
1509 // bias = border/(size - border)
1510 float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
1511 float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
1512 float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
1514 if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
1515 if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
1516 if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
1517 if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
1518 if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
1519 if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
1523 static int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
1527 int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
1528 float scale = (size - 2*border)/size, len;
1529 float bias = border / (float)(size - border), dp, dn, ap, an;
1530 // check if cone enclosing side would cross frustum plane
1531 scale = 2 / (scale*scale + 2);
1532 for (i = 0;i < 5;i++)
1534 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) > -0.03125)
1536 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
1537 len = scale*VectorLength2(n);
1538 if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
1539 if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
1540 if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
1542 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
1544 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
1545 len = scale*VectorLength(n);
1546 if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
1547 if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
1548 if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
1550 // this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
1551 // check if frustum corners/origin cross plane sides
1553 // infinite version, assumes frustum corners merely give direction and extend to infinite distance
1554 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.origin, p);
1555 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1556 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1557 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1558 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1559 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1560 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1561 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1562 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1563 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1564 for (i = 0;i < 4;i++)
1566 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.frustumcorner[i], n);
1567 VectorSubtract(n, p, n);
1568 dp = n[0] + n[1], dn = n[0] - n[1], ap = fabs(dp), an = fabs(dn);
1569 if(ap > 0) masks[0] |= dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2);
1570 if(an > 0) masks[1] |= dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2);
1571 dp = n[1] + n[2], dn = n[1] - n[2], ap = fabs(dp), an = fabs(dn);
1572 if(ap > 0) masks[2] |= dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4);
1573 if(an > 0) masks[3] |= dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4);
1574 dp = n[2] + n[0], dn = n[2] - n[0], ap = fabs(dp), an = fabs(dn);
1575 if(ap > 0) masks[4] |= dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0);
1576 if(an > 0) masks[5] |= dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0);
1579 // finite version, assumes corners are a finite distance from origin dependent on far plane
1580 for (i = 0;i < 5;i++)
1582 Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
1583 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1584 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1585 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1586 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1587 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1588 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1589 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1590 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1591 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1594 return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
1597 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)
1605 int mask, surfacemask = 0;
1606 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1608 bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
1609 tend = firsttriangle + numtris;
1610 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1612 // surface box entirely inside light box, no box cull
1613 if (projectdirection)
1615 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1617 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1618 TriangleNormal(v[0], v[1], v[2], normal);
1619 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1621 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1622 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1623 surfacemask |= mask;
1626 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;
1627 shadowsides[numshadowsides] = mask;
1628 shadowsideslist[numshadowsides++] = t;
1635 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1637 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1638 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
1640 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1641 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1642 surfacemask |= mask;
1645 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;
1646 shadowsides[numshadowsides] = mask;
1647 shadowsideslist[numshadowsides++] = t;
1655 // surface box not entirely inside light box, cull each triangle
1656 if (projectdirection)
1658 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1660 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1661 TriangleNormal(v[0], v[1], v[2], normal);
1662 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1663 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1665 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1666 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1667 surfacemask |= mask;
1670 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;
1671 shadowsides[numshadowsides] = mask;
1672 shadowsideslist[numshadowsides++] = t;
1679 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1681 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1682 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1683 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1685 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1686 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1687 surfacemask |= mask;
1690 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;
1691 shadowsides[numshadowsides] = mask;
1692 shadowsideslist[numshadowsides++] = t;
1701 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)
1703 int i, j, outtriangles = 0;
1704 int *outelement3i[6];
1705 if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
1707 outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
1708 // make sure shadowelements is big enough for this mesh
1709 if (maxshadowtriangles < outtriangles)
1710 R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
1712 // compute the offset and size of the separate index lists for each cubemap side
1714 for (i = 0;i < 6;i++)
1716 outelement3i[i] = shadowelements + outtriangles * 3;
1717 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
1718 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
1719 outtriangles += sidetotals[i];
1722 // gather up the (sparse) triangles into separate index lists for each cubemap side
1723 for (i = 0;i < numsidetris;i++)
1725 const int *element = elements + sidetris[i] * 3;
1726 for (j = 0;j < 6;j++)
1728 if (sides[i] & (1 << j))
1730 outelement3i[j][0] = element[0];
1731 outelement3i[j][1] = element[1];
1732 outelement3i[j][2] = element[2];
1733 outelement3i[j] += 3;
1738 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, outtriangles, shadowelements);
1741 static void R_Shadow_MakeTextures_MakeCorona(void)
1745 unsigned char pixels[32][32][4];
1746 for (y = 0;y < 32;y++)
1748 dy = (y - 15.5f) * (1.0f / 16.0f);
1749 for (x = 0;x < 32;x++)
1751 dx = (x - 15.5f) * (1.0f / 16.0f);
1752 a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1753 a = bound(0, a, 255);
1754 pixels[y][x][0] = a;
1755 pixels[y][x][1] = a;
1756 pixels[y][x][2] = a;
1757 pixels[y][x][3] = 255;
1760 r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32, false);
1763 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1765 float dist = sqrt(x*x+y*y+z*z);
1766 float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1767 // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1768 return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1771 static void R_Shadow_MakeTextures(void)
1774 float intensity, dist;
1776 R_Shadow_FreeShadowMaps();
1777 R_FreeTexturePool(&r_shadow_texturepool);
1778 r_shadow_texturepool = R_AllocTexturePool();
1779 r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1780 r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1781 data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1782 // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1783 for (x = 0;x <= ATTENTABLESIZE;x++)
1785 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1786 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1787 r_shadow_attentable[x] = bound(0, intensity, 1);
1789 // 1D gradient texture
1790 for (x = 0;x < ATTEN1DSIZE;x++)
1791 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1792 r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1793 // 2D circle texture
1794 for (y = 0;y < ATTEN2DSIZE;y++)
1795 for (x = 0;x < ATTEN2DSIZE;x++)
1796 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);
1797 r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1798 // 3D sphere texture
1799 if (r_shadow_texture3d.integer && vid.support.ext_texture_3d)
1801 for (z = 0;z < ATTEN3DSIZE;z++)
1802 for (y = 0;y < ATTEN3DSIZE;y++)
1803 for (x = 0;x < ATTEN3DSIZE;x++)
1804 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));
1805 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);
1808 r_shadow_attenuation3dtexture = NULL;
1811 R_Shadow_MakeTextures_MakeCorona();
1813 // Editor light sprites
1814 r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1831 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1832 r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1849 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1850 r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1867 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1868 r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1885 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1886 r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1903 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1904 r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
1921 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1924 void R_Shadow_ValidateCvars(void)
1926 if (r_shadow_texture3d.integer && !vid.support.ext_texture_3d)
1927 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
1928 if (gl_ext_separatestencil.integer && !vid.support.ati_separate_stencil)
1929 Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
1930 if (gl_ext_stenciltwoside.integer && !vid.support.ext_stencil_two_side)
1931 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
1934 void R_Shadow_RenderMode_Begin(void)
1940 R_Shadow_ValidateCvars();
1942 if (!r_shadow_attenuation2dtexture
1943 || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
1944 || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1945 || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1946 R_Shadow_MakeTextures();
1949 R_Mesh_ResetTextureState();
1950 GL_BlendFunc(GL_ONE, GL_ZERO);
1951 GL_DepthRange(0, 1);
1952 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1954 GL_DepthMask(false);
1955 GL_Color(0, 0, 0, 1);
1956 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
1958 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1960 if (gl_ext_separatestencil.integer && vid.support.ati_separate_stencil)
1962 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
1963 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
1965 else if (gl_ext_stenciltwoside.integer && vid.support.ext_stencil_two_side)
1967 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
1968 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
1972 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
1973 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
1976 switch(vid.renderpath)
1978 case RENDERPATH_GL20:
1979 case RENDERPATH_D3D9:
1980 case RENDERPATH_D3D10:
1981 case RENDERPATH_D3D11:
1982 case RENDERPATH_SOFT:
1983 case RENDERPATH_GLES2:
1984 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1986 case RENDERPATH_GL11:
1987 case RENDERPATH_GL13:
1988 case RENDERPATH_GLES1:
1989 if (r_textureunits.integer >= 2 && vid.texunits >= 2 && r_shadow_texture3d.integer && r_shadow_attenuation3dtexture)
1990 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN;
1991 else if (r_textureunits.integer >= 3 && vid.texunits >= 3)
1992 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN;
1993 else if (r_textureunits.integer >= 2 && vid.texunits >= 2)
1994 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN;
1996 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
2002 qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
2003 qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
2004 r_shadow_drawbuffer = drawbuffer;
2005 r_shadow_readbuffer = readbuffer;
2007 r_shadow_cullface_front = r_refdef.view.cullface_front;
2008 r_shadow_cullface_back = r_refdef.view.cullface_back;
2011 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
2013 rsurface.rtlight = rtlight;
2016 void R_Shadow_RenderMode_Reset(void)
2018 R_Mesh_ResetTextureState();
2019 R_Mesh_SetRenderTargets(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture, NULL, NULL, NULL);
2020 R_SetViewport(&r_refdef.view.viewport);
2021 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
2022 GL_DepthRange(0, 1);
2024 GL_DepthMask(false);
2025 GL_DepthFunc(GL_LEQUAL);
2026 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
2027 r_refdef.view.cullface_front = r_shadow_cullface_front;
2028 r_refdef.view.cullface_back = r_shadow_cullface_back;
2029 GL_CullFace(r_refdef.view.cullface_back);
2030 GL_Color(1, 1, 1, 1);
2031 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
2032 GL_BlendFunc(GL_ONE, GL_ZERO);
2033 R_SetupShader_Generic_NoTexture(false, false);
2034 r_shadow_usingshadowmap2d = false;
2035 r_shadow_usingshadowmaportho = false;
2036 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2039 void R_Shadow_ClearStencil(void)
2041 GL_Clear(GL_STENCIL_BUFFER_BIT, NULL, 1.0f, 128);
2042 r_refdef.stats.lights_clears++;
2045 void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
2047 r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
2048 if (r_shadow_rendermode == mode)
2050 R_Shadow_RenderMode_Reset();
2051 GL_DepthFunc(GL_LESS);
2052 GL_ColorMask(0, 0, 0, 0);
2053 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2054 GL_CullFace(GL_NONE);
2055 R_SetupShader_DepthOrShadow(false, false);
2056 r_shadow_rendermode = mode;
2061 case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
2062 case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
2063 R_SetStencilSeparate(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, GL_ALWAYS, 128, 255);
2065 case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
2066 case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
2067 R_SetStencilSeparate(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, GL_ALWAYS, 128, 255);
2072 static void R_Shadow_MakeVSDCT(void)
2074 // maps to a 2x3 texture rectangle with normalized coordinates
2079 // stores abs(dir.xy), offset.xy/2.5
2080 unsigned char data[4*6] =
2082 255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
2083 255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
2084 0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
2085 0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
2086 0, 0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
2087 0, 0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
2089 r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2092 static void R_Shadow_MakeShadowMap(int side, int size)
2094 switch (r_shadow_shadowmode)
2096 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
2097 if (r_shadow_shadowmap2ddepthtexture) return;
2098 if (r_fb.usedepthtextures)
2100 r_shadow_shadowmap2ddepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits >= 24 ? (r_shadow_shadowmapsampler ? TEXTYPE_SHADOWMAP24_COMP : TEXTYPE_SHADOWMAP24_RAW) : (r_shadow_shadowmapsampler ? TEXTYPE_SHADOWMAP16_COMP : TEXTYPE_SHADOWMAP16_RAW), false);
2101 r_shadow_shadowmap2ddepthbuffer = NULL;
2102 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
2106 r_shadow_shadowmap2ddepthtexture = R_LoadTexture2D(r_shadow_texturepool, "shadowmaprendertarget", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2107 r_shadow_shadowmap2ddepthbuffer = R_LoadTextureRenderBuffer(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits >= 24 ? TEXTYPE_DEPTHBUFFER24 : TEXTYPE_DEPTHBUFFER16);
2108 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
2116 static void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size)
2118 float nearclip, farclip, bias;
2119 r_viewport_t viewport;
2122 float clearcolor[4];
2123 nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
2125 bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
2126 r_shadow_shadowmap_parameters[1] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
2127 r_shadow_shadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
2128 r_shadow_shadowmapside = side;
2129 r_shadow_shadowmapsize = size;
2131 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2132 r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2133 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2134 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
2136 // complex unrolled cube approach (more flexible)
2137 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2138 R_Shadow_MakeVSDCT();
2139 if (!r_shadow_shadowmap2ddepthtexture)
2140 R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize);
2141 fbo2d = r_shadow_fbo2d;
2142 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2ddepthtexture);
2143 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2ddepthtexture);
2144 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2146 R_Mesh_ResetTextureState();
2147 R_Shadow_RenderMode_Reset();
2148 if (r_shadow_shadowmap2ddepthbuffer)
2149 R_Mesh_SetRenderTargets(fbo2d, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
2151 R_Mesh_SetRenderTargets(fbo2d, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
2152 R_SetupShader_DepthOrShadow(true, r_shadow_shadowmap2ddepthbuffer != NULL);
2153 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2158 R_SetViewport(&viewport);
2159 flipped = (side & 1) ^ (side >> 2);
2160 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2161 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2162 if (r_shadow_shadowmap2ddepthbuffer)
2164 // completely different meaning than in depthtexture approach
2165 r_shadow_shadowmap_parameters[1] = 0;
2166 r_shadow_shadowmap_parameters[3] = -bias;
2168 Vector4Set(clearcolor, 1,1,1,1);
2169 if (r_shadow_shadowmap2ddepthbuffer)
2170 GL_ColorMask(1,1,1,1);
2172 GL_ColorMask(0,0,0,0);
2173 switch(vid.renderpath)
2175 case RENDERPATH_GL11:
2176 case RENDERPATH_GL13:
2177 case RENDERPATH_GL20:
2178 case RENDERPATH_SOFT:
2179 case RENDERPATH_GLES1:
2180 case RENDERPATH_GLES2:
2181 GL_CullFace(r_refdef.view.cullface_back);
2182 // OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once
2183 if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask
2185 // get tightest scissor rectangle that encloses all viewports in the clear mask
2186 int x1 = clear & 0x15 ? 0 : size;
2187 int x2 = clear & 0x2A ? 2 * size : size;
2188 int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size);
2189 int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size);
2190 GL_Scissor(x1, y1, x2 - x1, y2 - y1);
2193 if (r_shadow_shadowmap2ddepthbuffer)
2194 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
2196 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
2199 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2201 case RENDERPATH_D3D9:
2202 case RENDERPATH_D3D10:
2203 case RENDERPATH_D3D11:
2204 // we invert the cull mode because we flip the projection matrix
2205 // NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided...
2206 GL_CullFace(r_refdef.view.cullface_front);
2207 // D3D considers it an error to use a scissor larger than the viewport... clear just this view
2208 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2211 if (r_shadow_shadowmap2ddepthbuffer)
2212 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
2214 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
2220 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2222 R_Mesh_ResetTextureState();
2225 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2226 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2227 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2228 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2230 R_Shadow_RenderMode_Reset();
2231 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2233 GL_DepthFunc(GL_EQUAL);
2234 // do global setup needed for the chosen lighting mode
2235 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2236 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2237 r_shadow_usingshadowmap2d = shadowmapping;
2238 r_shadow_rendermode = r_shadow_lightingrendermode;
2239 // only draw light where this geometry was already rendered AND the
2240 // stencil is 128 (values other than this mean shadow)
2242 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2244 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2247 static const unsigned short bboxelements[36] =
2257 static const float bboxpoints[8][3] =
2269 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2272 float vertex3f[8*3];
2273 const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2274 // do global setup needed for the chosen lighting mode
2275 R_Shadow_RenderMode_Reset();
2276 r_shadow_rendermode = r_shadow_lightingrendermode;
2277 R_EntityMatrix(&identitymatrix);
2278 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2279 // only draw light where this geometry was already rendered AND the
2280 // stencil is 128 (values other than this mean shadow)
2281 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2282 if (rsurface.rtlight->specularscale > 0 && r_shadow_gloss.integer > 0)
2283 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
2285 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
2287 r_shadow_usingshadowmap2d = shadowmapping;
2289 // render the lighting
2290 R_SetupShader_DeferredLight(rsurface.rtlight);
2291 for (i = 0;i < 8;i++)
2292 Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2293 GL_ColorMask(1,1,1,1);
2294 GL_DepthMask(false);
2295 GL_DepthRange(0, 1);
2296 GL_PolygonOffset(0, 0);
2298 GL_DepthFunc(GL_GREATER);
2299 GL_CullFace(r_refdef.view.cullface_back);
2300 R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL);
2301 R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
2304 void R_Shadow_UpdateBounceGridTexture(void)
2306 #define MAXBOUNCEGRIDPARTICLESPERLIGHT 1048576
2308 int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2310 int hitsupercontentsmask;
2319 //trace_t cliptrace2;
2320 //trace_t cliptrace3;
2321 unsigned char *pixel;
2322 unsigned char *pixels;
2325 unsigned int lightindex;
2327 unsigned int range1;
2328 unsigned int range2;
2329 unsigned int seed = (unsigned int)(realtime * 1000.0f);
2331 vec3_t baseshotcolor;
2344 vec3_t cullmins, cullmaxs;
2347 vec_t lightintensity;
2348 vec_t photonscaling;
2349 vec_t photonresidual;
2351 float texlerp[2][3];
2352 float splatcolor[32];
2353 float pixelweight[8];
2365 r_shadow_bouncegrid_settings_t settings;
2366 qboolean enable = r_shadow_bouncegrid.integer != 0 && r_refdef.scene.worldmodel;
2367 qboolean allowdirectionalshading = false;
2368 switch(vid.renderpath)
2370 case RENDERPATH_GL20:
2371 allowdirectionalshading = true;
2372 if (!vid.support.ext_texture_3d)
2375 case RENDERPATH_GLES2:
2376 // for performance reasons, do not use directional shading on GLES devices
2377 if (!vid.support.ext_texture_3d)
2380 // these renderpaths do not currently have the code to display the bouncegrid, so disable it on them...
2381 case RENDERPATH_GL11:
2382 case RENDERPATH_GL13:
2383 case RENDERPATH_GLES1:
2384 case RENDERPATH_SOFT:
2385 case RENDERPATH_D3D9:
2386 case RENDERPATH_D3D10:
2387 case RENDERPATH_D3D11:
2391 r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value;
2393 // see if there are really any lights to render...
2394 if (enable && r_shadow_bouncegrid_static.integer)
2397 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2398 for (lightindex = 0;lightindex < range;lightindex++)
2400 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2401 if (!light || !(light->flags & flag))
2403 rtlight = &light->rtlight;
2404 // when static, we skip styled lights because they tend to change...
2405 if (rtlight->style > 0)
2407 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale), lightcolor);
2408 if (!VectorLength2(lightcolor))
2417 if (r_shadow_bouncegridtexture)
2419 R_FreeTexture(r_shadow_bouncegridtexture);
2420 r_shadow_bouncegridtexture = NULL;
2422 if (r_shadow_bouncegridpixels)
2423 Mem_Free(r_shadow_bouncegridpixels);
2424 r_shadow_bouncegridpixels = NULL;
2425 if (r_shadow_bouncegridhighpixels)
2426 Mem_Free(r_shadow_bouncegridhighpixels);
2427 r_shadow_bouncegridhighpixels = NULL;
2428 r_shadow_bouncegridnumpixels = 0;
2429 r_shadow_bouncegriddirectional = false;
2433 // build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
2434 memset(&settings, 0, sizeof(settings));
2435 settings.staticmode = r_shadow_bouncegrid_static.integer != 0;
2436 settings.bounceanglediffuse = r_shadow_bouncegrid_bounceanglediffuse.integer != 0;
2437 settings.directionalshading = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_directionalshading.integer != 0) && allowdirectionalshading;
2438 settings.dlightparticlemultiplier = r_shadow_bouncegrid_dlightparticlemultiplier.value;
2439 settings.hitmodels = r_shadow_bouncegrid_hitmodels.integer != 0;
2440 settings.includedirectlighting = r_shadow_bouncegrid_includedirectlighting.integer != 0 || r_shadow_bouncegrid.integer == 2;
2441 settings.lightradiusscale = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_lightradiusscale.value : r_shadow_bouncegrid_lightradiusscale.value);
2442 settings.maxbounce = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_maxbounce.integer : r_shadow_bouncegrid_maxbounce.integer);
2443 settings.particlebounceintensity = r_shadow_bouncegrid_particlebounceintensity.value;
2444 settings.particleintensity = r_shadow_bouncegrid_particleintensity.value * 16384.0f * (settings.directionalshading ? 4.0f : 1.0f) / (r_shadow_bouncegrid_spacing.value * r_shadow_bouncegrid_spacing.value);
2445 settings.photons = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_photons.integer : r_shadow_bouncegrid_photons.integer;
2446 settings.spacing[0] = r_shadow_bouncegrid_spacing.value;
2447 settings.spacing[1] = r_shadow_bouncegrid_spacing.value;
2448 settings.spacing[2] = r_shadow_bouncegrid_spacing.value;
2449 settings.stablerandom = r_shadow_bouncegrid_stablerandom.integer;
2451 // bound the values for sanity
2452 settings.photons = bound(1, settings.photons, 1048576);
2453 settings.lightradiusscale = bound(0.0001f, settings.lightradiusscale, 1024.0f);
2454 settings.maxbounce = bound(0, settings.maxbounce, 16);
2455 settings.spacing[0] = bound(1, settings.spacing[0], 512);
2456 settings.spacing[1] = bound(1, settings.spacing[1], 512);
2457 settings.spacing[2] = bound(1, settings.spacing[2], 512);
2459 // get the spacing values
2460 spacing[0] = settings.spacing[0];
2461 spacing[1] = settings.spacing[1];
2462 spacing[2] = settings.spacing[2];
2463 ispacing[0] = 1.0f / spacing[0];
2464 ispacing[1] = 1.0f / spacing[1];
2465 ispacing[2] = 1.0f / spacing[2];
2467 // calculate texture size enclosing entire world bounds at the spacing
2468 VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
2469 VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
2470 VectorSubtract(maxs, mins, size);
2471 // now we can calculate the resolution we want
2472 c[0] = (int)floor(size[0] / spacing[0] + 0.5f);
2473 c[1] = (int)floor(size[1] / spacing[1] + 0.5f);
2474 c[2] = (int)floor(size[2] / spacing[2] + 0.5f);
2475 // figure out the exact texture size (honoring 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];
2495 // if dynamic we may or may not want to use the world bounds
2496 // if the dynamic size is smaller than the world bounds, use it instead
2497 if (!settings.staticmode && (r_shadow_bouncegrid_x.integer * r_shadow_bouncegrid_y.integer * r_shadow_bouncegrid_z.integer < resolution[0] * resolution[1] * resolution[2]))
2499 // we know the resolution we want
2500 c[0] = r_shadow_bouncegrid_x.integer;
2501 c[1] = r_shadow_bouncegrid_y.integer;
2502 c[2] = r_shadow_bouncegrid_z.integer;
2503 // now we can calculate the texture size (power of 2 if required)
2504 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2505 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2506 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2507 if (vid.support.arb_texture_non_power_of_two)
2509 resolution[0] = c[0];
2510 resolution[1] = c[1];
2511 resolution[2] = c[2];
2515 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2516 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2517 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2519 size[0] = spacing[0] * resolution[0];
2520 size[1] = spacing[1] * resolution[1];
2521 size[2] = spacing[2] * resolution[2];
2522 // center the rendering on the view
2523 mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0];
2524 mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1];
2525 mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2];
2528 // recalculate the maxs in case the resolution was not satisfactory
2529 VectorAdd(mins, size, maxs);
2531 // if all the settings seem identical to the previous update, return
2532 if (r_shadow_bouncegridtexture && (settings.staticmode || realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value) && !memcmp(&r_shadow_bouncegridsettings, &settings, sizeof(settings)))
2535 // store the new settings
2536 r_shadow_bouncegridsettings = settings;
2538 pixelbands = settings.directionalshading ? 8 : 1;
2539 pixelsperband = resolution[0]*resolution[1]*resolution[2];
2540 numpixels = pixelsperband*pixelbands;
2542 // we're going to update the bouncegrid, update the matrix...
2543 memset(m, 0, sizeof(m));
2544 m[0] = 1.0f / size[0];
2545 m[3] = -mins[0] * m[0];
2546 m[5] = 1.0f / size[1];
2547 m[7] = -mins[1] * m[5];
2548 m[10] = 1.0f / size[2];
2549 m[11] = -mins[2] * m[10];
2551 Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegridmatrix, m);
2552 // reallocate pixels for this update if needed...
2553 if (r_shadow_bouncegridnumpixels != numpixels || !r_shadow_bouncegridpixels || !r_shadow_bouncegridhighpixels)
2555 if (r_shadow_bouncegridtexture)
2557 R_FreeTexture(r_shadow_bouncegridtexture);
2558 r_shadow_bouncegridtexture = NULL;
2560 r_shadow_bouncegridpixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridpixels, numpixels * sizeof(unsigned char[4]));
2561 r_shadow_bouncegridhighpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(float[4]));
2563 r_shadow_bouncegridnumpixels = numpixels;
2564 pixels = r_shadow_bouncegridpixels;
2565 highpixels = r_shadow_bouncegridhighpixels;
2566 x = pixelsperband*4;
2567 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2570 memset(pixels + pixelband * x, 128, x);
2572 memset(pixels + pixelband * x, 0, x);
2574 memset(highpixels, 0, numpixels * sizeof(float[4]));
2575 // figure out what we want to interact with
2576 if (settings.hitmodels)
2577 hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;// | SUPERCONTENTS_LIQUIDSMASK;
2579 hitsupercontentsmask = SUPERCONTENTS_SOLID;// | SUPERCONTENTS_LIQUIDSMASK;
2580 maxbounce = settings.maxbounce;
2581 // clear variables that produce warnings otherwise
2582 memset(splatcolor, 0, sizeof(splatcolor));
2583 // iterate world rtlights
2584 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2585 range1 = settings.staticmode ? 0 : r_refdef.scene.numlights;
2586 range2 = range + range1;
2588 for (lightindex = 0;lightindex < range2;lightindex++)
2590 if (lightindex < range)
2592 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2595 rtlight = &light->rtlight;
2596 VectorClear(rtlight->photoncolor);
2597 rtlight->photons = 0;
2598 if (!(light->flags & flag))
2600 if (settings.staticmode)
2602 // when static, we skip styled lights because they tend to change...
2603 if (rtlight->style > 0 && r_shadow_bouncegrid.integer != 2)
2609 rtlight = r_refdef.scene.lights[lightindex - range];
2610 VectorClear(rtlight->photoncolor);
2611 rtlight->photons = 0;
2613 // draw only visible lights (major speedup)
2614 radius = rtlight->radius * settings.lightradiusscale;
2615 cullmins[0] = rtlight->shadoworigin[0] - radius;
2616 cullmins[1] = rtlight->shadoworigin[1] - radius;
2617 cullmins[2] = rtlight->shadoworigin[2] - radius;
2618 cullmaxs[0] = rtlight->shadoworigin[0] + radius;
2619 cullmaxs[1] = rtlight->shadoworigin[1] + radius;
2620 cullmaxs[2] = rtlight->shadoworigin[2] + radius;
2621 if (R_CullBox(cullmins, cullmaxs))
2623 if (r_refdef.scene.worldmodel
2624 && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs
2625 && !r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, cullmins, cullmaxs))
2627 w = r_shadow_lightintensityscale.value * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2628 if (w * VectorLength2(rtlight->color) == 0.0f)
2630 w *= (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1);
2631 VectorScale(rtlight->color, w, rtlight->photoncolor);
2632 //if (!VectorLength2(rtlight->photoncolor))
2634 // shoot particles from this light
2635 // use a calculation for the number of particles that will not
2636 // vary with lightstyle, otherwise we get randomized particle
2637 // distribution, the seeded random is only consistent for a
2638 // consistent number of particles on this light...
2639 s = rtlight->radius;
2640 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2641 if (lightindex >= range)
2642 lightintensity *= settings.dlightparticlemultiplier;
2643 rtlight->photons = max(0.0f, lightintensity * s * s);
2644 photoncount += rtlight->photons;
2646 photonscaling = (float)settings.photons / max(1, photoncount);
2647 photonresidual = 0.0f;
2648 for (lightindex = 0;lightindex < range2;lightindex++)
2650 if (lightindex < range)
2652 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2655 rtlight = &light->rtlight;
2658 rtlight = r_refdef.scene.lights[lightindex - range];
2659 // skip a light with no photons
2660 if (rtlight->photons == 0.0f)
2662 // skip a light with no photon color)
2663 if (VectorLength2(rtlight->photoncolor) == 0.0f)
2665 photonresidual += rtlight->photons * photonscaling;
2666 shootparticles = (int)bound(0, photonresidual, MAXBOUNCEGRIDPARTICLESPERLIGHT);
2667 if (!shootparticles)
2669 photonresidual -= shootparticles;
2670 radius = rtlight->radius * settings.lightradiusscale;
2671 s = settings.particleintensity / shootparticles;
2672 VectorScale(rtlight->photoncolor, s, baseshotcolor);
2673 r_refdef.stats.bouncegrid_lights++;
2674 r_refdef.stats.bouncegrid_particles += shootparticles;
2675 for (shotparticles = 0;shotparticles < shootparticles;shotparticles++)
2677 if (settings.stablerandom > 0)
2678 seed = lightindex * 11937 + shotparticles;
2679 VectorCopy(baseshotcolor, shotcolor);
2680 VectorCopy(rtlight->shadoworigin, clipstart);
2681 if (settings.stablerandom < 0)
2682 VectorRandom(clipend);
2684 VectorCheeseRandom(clipend);
2685 VectorMA(clipstart, radius, clipend, clipend);
2686 for (bouncecount = 0;;bouncecount++)
2688 r_refdef.stats.bouncegrid_traces++;
2689 //r_refdef.scene.worldmodel->TraceLineAgainstSurfaces(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace, clipstart, clipend, hitsupercontentsmask);
2690 //r_refdef.scene.worldmodel->TraceLine(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace2, clipstart, clipend, hitsupercontentsmask);
2691 if (settings.staticmode)
2693 // static mode fires a LOT of rays but none of them are identical, so they are not cached
2694 cliptrace = CL_TraceLine(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, true, false, NULL, true, true);
2698 // dynamic mode fires many rays and most will match the cache from the previous frame
2699 cliptrace = CL_Cache_TraceLineSurfaces(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask);
2701 if (bouncecount > 0 || settings.includedirectlighting)
2703 // calculate second order spherical harmonics values (average, slopeX, slopeY, slopeZ)
2704 // accumulate average shotcolor
2705 w = VectorLength(shotcolor);
2706 splatcolor[ 0] = shotcolor[0];
2707 splatcolor[ 1] = shotcolor[1];
2708 splatcolor[ 2] = shotcolor[2];
2709 splatcolor[ 3] = 0.0f;
2712 VectorSubtract(clipstart, cliptrace.endpos, clipdiff);
2713 VectorNormalize(clipdiff);
2714 // store bentnormal in case the shader has a use for it
2715 splatcolor[ 4] = clipdiff[0] * w;
2716 splatcolor[ 5] = clipdiff[1] * w;
2717 splatcolor[ 6] = clipdiff[2] * w;
2719 // accumulate directional contributions (+X, +Y, +Z, -X, -Y, -Z)
2720 splatcolor[ 8] = shotcolor[0] * max(0.0f, clipdiff[0]);
2721 splatcolor[ 9] = shotcolor[0] * max(0.0f, clipdiff[1]);
2722 splatcolor[10] = shotcolor[0] * max(0.0f, clipdiff[2]);
2723 splatcolor[11] = 0.0f;
2724 splatcolor[12] = shotcolor[1] * max(0.0f, clipdiff[0]);
2725 splatcolor[13] = shotcolor[1] * max(0.0f, clipdiff[1]);
2726 splatcolor[14] = shotcolor[1] * max(0.0f, clipdiff[2]);
2727 splatcolor[15] = 0.0f;
2728 splatcolor[16] = shotcolor[2] * max(0.0f, clipdiff[0]);
2729 splatcolor[17] = shotcolor[2] * max(0.0f, clipdiff[1]);
2730 splatcolor[18] = shotcolor[2] * max(0.0f, clipdiff[2]);
2731 splatcolor[19] = 0.0f;
2732 splatcolor[20] = shotcolor[0] * max(0.0f, -clipdiff[0]);
2733 splatcolor[21] = shotcolor[0] * max(0.0f, -clipdiff[1]);
2734 splatcolor[22] = shotcolor[0] * max(0.0f, -clipdiff[2]);
2735 splatcolor[23] = 0.0f;
2736 splatcolor[24] = shotcolor[1] * max(0.0f, -clipdiff[0]);
2737 splatcolor[25] = shotcolor[1] * max(0.0f, -clipdiff[1]);
2738 splatcolor[26] = shotcolor[1] * max(0.0f, -clipdiff[2]);
2739 splatcolor[27] = 0.0f;
2740 splatcolor[28] = shotcolor[2] * max(0.0f, -clipdiff[0]);
2741 splatcolor[29] = shotcolor[2] * max(0.0f, -clipdiff[1]);
2742 splatcolor[30] = shotcolor[2] * max(0.0f, -clipdiff[2]);
2743 splatcolor[31] = 0.0f;
2745 // calculate the number of steps we need to traverse this distance
2746 VectorSubtract(cliptrace.endpos, clipstart, stepdelta);
2747 numsteps = (int)(VectorLength(stepdelta) * ispacing[0]);
2748 numsteps = bound(1, numsteps, 1024);
2749 w = 1.0f / numsteps;
2750 VectorScale(stepdelta, w, stepdelta);
2751 VectorMA(clipstart, 0.5f, stepdelta, steppos);
2752 for (step = 0;step < numsteps;step++)
2754 r_refdef.stats.bouncegrid_splats++;
2755 // figure out which texture pixel this is in
2756 texlerp[1][0] = ((steppos[0] - mins[0]) * ispacing[0]) - 0.5f;
2757 texlerp[1][1] = ((steppos[1] - mins[1]) * ispacing[1]) - 0.5f;
2758 texlerp[1][2] = ((steppos[2] - mins[2]) * ispacing[2]) - 0.5f;
2759 tex[0] = (int)floor(texlerp[1][0]);
2760 tex[1] = (int)floor(texlerp[1][1]);
2761 tex[2] = (int)floor(texlerp[1][2]);
2762 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)
2764 // it is within bounds... do the real work now
2765 // calculate the lerp factors
2766 texlerp[1][0] -= tex[0];
2767 texlerp[1][1] -= tex[1];
2768 texlerp[1][2] -= tex[2];
2769 texlerp[0][0] = 1.0f - texlerp[1][0];
2770 texlerp[0][1] = 1.0f - texlerp[1][1];
2771 texlerp[0][2] = 1.0f - texlerp[1][2];
2772 // calculate individual pixel indexes and weights
2773 pixelindex[0] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[0] = (texlerp[0][0]*texlerp[0][1]*texlerp[0][2]);
2774 pixelindex[1] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[1] = (texlerp[1][0]*texlerp[0][1]*texlerp[0][2]);
2775 pixelindex[2] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[2] = (texlerp[0][0]*texlerp[1][1]*texlerp[0][2]);
2776 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]);
2777 pixelindex[4] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[4] = (texlerp[0][0]*texlerp[0][1]*texlerp[1][2]);
2778 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]);
2779 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]);
2780 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]);
2781 // update the 8 pixels...
2782 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2784 for (corner = 0;corner < 8;corner++)
2786 // calculate address for pixel
2787 w = pixelweight[corner];
2788 pixel = pixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2789 highpixel = highpixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2790 // add to the high precision pixel color
2791 highpixel[0] += (splatcolor[pixelband*4+0]*w);
2792 highpixel[1] += (splatcolor[pixelband*4+1]*w);
2793 highpixel[2] += (splatcolor[pixelband*4+2]*w);
2794 highpixel[3] += (splatcolor[pixelband*4+3]*w);
2795 // flag the low precision pixel as needing to be updated
2797 // advance to next band of coefficients
2798 //pixel += pixelsperband*4;
2799 //highpixel += pixelsperband*4;
2803 VectorAdd(steppos, stepdelta, steppos);
2806 if (cliptrace.fraction >= 1.0f)
2808 r_refdef.stats.bouncegrid_hits++;
2809 if (bouncecount >= maxbounce)
2811 // scale down shot color by bounce intensity and texture color (or 50% if no texture reported)
2812 // also clamp the resulting color to never add energy, even if the user requests extreme values
2813 if (cliptrace.hittexture && cliptrace.hittexture->currentskinframe)
2814 VectorCopy(cliptrace.hittexture->currentskinframe->avgcolor, surfcolor);
2816 VectorSet(surfcolor, 0.5f, 0.5f, 0.5f);
2817 VectorScale(surfcolor, settings.particlebounceintensity, surfcolor);
2818 surfcolor[0] = min(surfcolor[0], 1.0f);
2819 surfcolor[1] = min(surfcolor[1], 1.0f);
2820 surfcolor[2] = min(surfcolor[2], 1.0f);
2821 VectorMultiply(shotcolor, surfcolor, shotcolor);
2822 if (VectorLength2(baseshotcolor) == 0.0f)
2824 r_refdef.stats.bouncegrid_bounces++;
2825 if (settings.bounceanglediffuse)
2827 // random direction, primarily along plane normal
2828 s = VectorDistance(cliptrace.endpos, clipend);
2829 if (settings.stablerandom < 0)
2830 VectorRandom(clipend);
2832 VectorCheeseRandom(clipend);
2833 VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend);
2834 VectorNormalize(clipend);
2835 VectorScale(clipend, s, clipend);
2839 // reflect the remaining portion of the line across plane normal
2840 VectorSubtract(clipend, cliptrace.endpos, clipdiff);
2841 VectorReflect(clipdiff, 1.0, cliptrace.plane.normal, clipend);
2843 // calculate the new line start and end
2844 VectorCopy(cliptrace.endpos, clipstart);
2845 VectorAdd(clipstart, clipend, clipend);
2849 // generate pixels array from highpixels array
2850 // skip first and last columns, rows, and layers as these are blank
2851 // the pixel[3] value was written above, so we can use it to detect only pixels that need to be calculated
2852 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2854 for (z = 1;z < resolution[2]-1;z++)
2856 for (y = 1;y < resolution[1]-1;y++)
2858 for (x = 1, pixelindex[0] = ((pixelband*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)
2860 // only convert pixels that were hit by photons
2861 if (pixel[3] == 255)
2863 // normalize the bentnormal...
2866 VectorNormalize(highpixel);
2867 c[0] = (int)(highpixel[0]*128.0f+128.0f);
2868 c[1] = (int)(highpixel[1]*128.0f+128.0f);
2869 c[2] = (int)(highpixel[2]*128.0f+128.0f);
2870 c[3] = (int)(highpixel[3]*128.0f+128.0f);
2874 c[0] = (int)(highpixel[0]*256.0f);
2875 c[1] = (int)(highpixel[1]*256.0f);
2876 c[2] = (int)(highpixel[2]*256.0f);
2877 c[3] = (int)(highpixel[3]*256.0f);
2879 pixel[2] = (unsigned char)bound(0, c[0], 255);
2880 pixel[1] = (unsigned char)bound(0, c[1], 255);
2881 pixel[0] = (unsigned char)bound(0, c[2], 255);
2882 pixel[3] = (unsigned char)bound(0, c[3], 255);
2888 if (r_shadow_bouncegridtexture && r_shadow_bouncegridresolution[0] == resolution[0] && r_shadow_bouncegridresolution[1] == resolution[1] && r_shadow_bouncegridresolution[2] == resolution[2] && r_shadow_bouncegriddirectional == settings.directionalshading)
2889 R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
2892 VectorCopy(resolution, r_shadow_bouncegridresolution);
2893 r_shadow_bouncegriddirectional = settings.directionalshading;
2894 if (r_shadow_bouncegridtexture)
2895 R_FreeTexture(r_shadow_bouncegridtexture);
2896 r_shadow_bouncegridtexture = R_LoadTexture3D(r_shadow_texturepool, "bouncegrid", resolution[0], resolution[1], resolution[2]*pixelbands, pixels, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, 0, NULL);
2898 r_shadow_bouncegridtime = realtime;
2901 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2903 R_Shadow_RenderMode_Reset();
2904 GL_BlendFunc(GL_ONE, GL_ONE);
2905 GL_DepthRange(0, 1);
2906 GL_DepthTest(r_showshadowvolumes.integer < 2);
2907 GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2908 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2909 GL_CullFace(GL_NONE);
2910 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2913 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2915 R_Shadow_RenderMode_Reset();
2916 GL_BlendFunc(GL_ONE, GL_ONE);
2917 GL_DepthRange(0, 1);
2918 GL_DepthTest(r_showlighting.integer < 2);
2919 GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2921 GL_DepthFunc(GL_EQUAL);
2922 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2923 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2926 void R_Shadow_RenderMode_End(void)
2928 R_Shadow_RenderMode_Reset();
2929 R_Shadow_RenderMode_ActiveLight(NULL);
2931 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2932 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2935 int bboxedges[12][2] =
2954 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2956 if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass || r_trippy.integer)
2958 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2959 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2960 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2961 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2964 if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor))
2965 return true; // invisible
2966 if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x
2967 || r_shadow_lightscissor[1] != r_refdef.view.viewport.y
2968 || r_shadow_lightscissor[2] != r_refdef.view.viewport.width
2969 || r_shadow_lightscissor[3] != r_refdef.view.viewport.height)
2970 r_refdef.stats.lights_scissored++;
2974 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, const float *diffusecolor, const float *ambientcolor)
2977 const float *vertex3f;
2978 const float *normal3f;
2980 float dist, dot, distintensity, shadeintensity, v[3], n[3];
2981 switch (r_shadow_rendermode)
2983 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2984 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2985 if (VectorLength2(diffusecolor) > 0)
2987 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)
2989 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2990 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2991 if ((dot = DotProduct(n, v)) < 0)
2993 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2994 VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
2997 VectorCopy(ambientcolor, color4f);
2998 if (r_refdef.fogenabled)
3001 f = RSurf_FogVertex(vertex3f);
3002 VectorScale(color4f, f, color4f);
3009 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3011 VectorCopy(ambientcolor, color4f);
3012 if (r_refdef.fogenabled)
3015 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3016 f = RSurf_FogVertex(vertex3f);
3017 VectorScale(color4f + 4*i, f, color4f);
3023 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3024 if (VectorLength2(diffusecolor) > 0)
3026 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)
3028 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3029 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3031 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3032 if ((dot = DotProduct(n, v)) < 0)
3034 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3035 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3036 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3037 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3041 color4f[0] = ambientcolor[0] * distintensity;
3042 color4f[1] = ambientcolor[1] * distintensity;
3043 color4f[2] = ambientcolor[2] * distintensity;
3045 if (r_refdef.fogenabled)
3048 f = RSurf_FogVertex(vertex3f);
3049 VectorScale(color4f, f, color4f);
3053 VectorClear(color4f);
3059 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3061 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3062 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3064 color4f[0] = ambientcolor[0] * distintensity;
3065 color4f[1] = ambientcolor[1] * distintensity;
3066 color4f[2] = ambientcolor[2] * distintensity;
3067 if (r_refdef.fogenabled)
3070 f = RSurf_FogVertex(vertex3f);
3071 VectorScale(color4f, f, color4f);
3075 VectorClear(color4f);
3080 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3081 if (VectorLength2(diffusecolor) > 0)
3083 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)
3085 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3086 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3088 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3089 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3090 if ((dot = DotProduct(n, v)) < 0)
3092 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3093 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3094 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3095 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3099 color4f[0] = ambientcolor[0] * distintensity;
3100 color4f[1] = ambientcolor[1] * distintensity;
3101 color4f[2] = ambientcolor[2] * distintensity;
3103 if (r_refdef.fogenabled)
3106 f = RSurf_FogVertex(vertex3f);
3107 VectorScale(color4f, f, color4f);
3111 VectorClear(color4f);
3117 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3119 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3120 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3122 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3123 color4f[0] = ambientcolor[0] * distintensity;
3124 color4f[1] = ambientcolor[1] * distintensity;
3125 color4f[2] = ambientcolor[2] * distintensity;
3126 if (r_refdef.fogenabled)
3129 f = RSurf_FogVertex(vertex3f);
3130 VectorScale(color4f, f, color4f);
3134 VectorClear(color4f);
3144 static void R_Shadow_RenderLighting_VisibleLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3146 // used to display how many times a surface is lit for level design purposes
3147 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3148 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
3152 static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale, float specularscale)
3154 // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
3155 R_SetupShader_Surface(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL, false);
3159 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
3166 int newnumtriangles;
3170 int maxtriangles = 1024;
3171 int newelements[1024*3];
3172 R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, diffusecolor2, ambientcolor2);
3173 for (renders = 0;renders < 4;renders++)
3178 newnumtriangles = 0;
3180 // due to low fillrate on the cards this vertex lighting path is
3181 // designed for, we manually cull all triangles that do not
3182 // contain a lit vertex
3183 // this builds batches of triangles from multiple surfaces and
3184 // renders them at once
3185 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
3187 if (VectorLength2(rsurface.passcolor4f + e[0] * 4) + VectorLength2(rsurface.passcolor4f + e[1] * 4) + VectorLength2(rsurface.passcolor4f + e[2] * 4) >= 0.01)
3189 if (newnumtriangles)
3191 newfirstvertex = min(newfirstvertex, e[0]);
3192 newlastvertex = max(newlastvertex, e[0]);
3196 newfirstvertex = e[0];
3197 newlastvertex = e[0];
3199 newfirstvertex = min(newfirstvertex, e[1]);
3200 newlastvertex = max(newlastvertex, e[1]);
3201 newfirstvertex = min(newfirstvertex, e[2]);
3202 newlastvertex = max(newlastvertex, e[2]);
3208 if (newnumtriangles >= maxtriangles)
3210 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3211 newnumtriangles = 0;
3217 if (newnumtriangles >= 1)
3219 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3222 // if we couldn't find any lit triangles, exit early
3225 // now reduce the intensity for the next overbright pass
3226 // we have to clamp to 0 here incase the drivers have improper
3227 // handling of negative colors
3228 // (some old drivers even have improper handling of >1 color)
3230 for (i = 0, c = rsurface.passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4)
3232 if (c[0] > 1 || c[1] > 1 || c[2] > 1)
3234 c[0] = max(0, c[0] - 1);
3235 c[1] = max(0, c[1] - 1);
3236 c[2] = max(0, c[2] - 1);
3248 static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale)
3250 // OpenGL 1.1 path (anything)
3251 float ambientcolorbase[3], diffusecolorbase[3];
3252 float ambientcolorpants[3], diffusecolorpants[3];
3253 float ambientcolorshirt[3], diffusecolorshirt[3];
3254 const float *surfacecolor = rsurface.texture->dlightcolor;
3255 const float *surfacepants = rsurface.colormap_pantscolor;
3256 const float *surfaceshirt = rsurface.colormap_shirtcolor;
3257 rtexture_t *basetexture = rsurface.texture->basetexture;
3258 rtexture_t *pantstexture = rsurface.texture->pantstexture;
3259 rtexture_t *shirttexture = rsurface.texture->shirttexture;
3260 qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
3261 qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
3262 ambientscale *= 2 * r_refdef.view.colorscale;
3263 diffusescale *= 2 * r_refdef.view.colorscale;
3264 ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
3265 diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
3266 ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
3267 diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
3268 ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
3269 diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
3270 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3271 rsurface.passcolor4f = (float *)R_FrameData_Alloc((rsurface.batchfirstvertex + rsurface.batchnumvertices) * sizeof(float[4]));
3272 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3273 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
3274 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
3275 R_Mesh_TexBind(0, basetexture);
3276 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
3277 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
3278 switch(r_shadow_rendermode)
3280 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3281 R_Mesh_TexBind(1, r_shadow_attenuation3dtexture);
3282 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3283 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3284 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3286 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3287 R_Mesh_TexBind(2, r_shadow_attenuation2dtexture);
3288 R_Mesh_TexMatrix(2, &rsurface.entitytoattenuationz);
3289 R_Mesh_TexCombine(2, GL_MODULATE, GL_MODULATE, 1, 1);
3290 R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3292 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3293 R_Mesh_TexBind(1, r_shadow_attenuation2dtexture);
3294 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3295 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3296 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3298 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3303 //R_Mesh_TexBind(0, basetexture);
3304 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorbase, ambientcolorbase);
3307 R_Mesh_TexBind(0, pantstexture);
3308 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorpants, ambientcolorpants);
3312 R_Mesh_TexBind(0, shirttexture);
3313 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorshirt, ambientcolorshirt);
3317 extern cvar_t gl_lightmaps;
3318 void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3320 float ambientscale, diffusescale, specularscale;
3322 float lightcolor[3];
3323 VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
3324 ambientscale = rsurface.rtlight->ambientscale + rsurface.texture->rtlightambient;
3325 diffusescale = rsurface.rtlight->diffusescale * max(0, 1.0 - rsurface.texture->rtlightambient);
3326 specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
3327 if (!r_shadow_usenormalmap.integer)
3329 ambientscale += 1.0f * diffusescale;
3333 if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
3335 negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
3338 VectorNegate(lightcolor, lightcolor);
3339 GL_BlendEquationSubtract(true);
3341 RSurf_SetupDepthAndCulling();
3342 switch (r_shadow_rendermode)
3344 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
3345 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
3346 R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
3348 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3349 R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale, specularscale);
3351 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3352 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3353 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3354 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3355 R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale);
3358 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
3362 GL_BlendEquationSubtract(false);
3365 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)
3367 matrix4x4_t tempmatrix = *matrix;
3368 Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
3370 // if this light has been compiled before, free the associated data
3371 R_RTLight_Uncompile(rtlight);
3373 // clear it completely to avoid any lingering data
3374 memset(rtlight, 0, sizeof(*rtlight));
3376 // copy the properties
3377 rtlight->matrix_lighttoworld = tempmatrix;
3378 Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3379 Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3380 rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3381 VectorCopy(color, rtlight->color);
3382 rtlight->cubemapname[0] = 0;
3383 if (cubemapname && cubemapname[0])
3384 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3385 rtlight->shadow = shadow;
3386 rtlight->corona = corona;
3387 rtlight->style = style;
3388 rtlight->isstatic = isstatic;
3389 rtlight->coronasizescale = coronasizescale;
3390 rtlight->ambientscale = ambientscale;
3391 rtlight->diffusescale = diffusescale;
3392 rtlight->specularscale = specularscale;
3393 rtlight->flags = flags;
3395 // compute derived data
3396 //rtlight->cullradius = rtlight->radius;
3397 //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3398 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3399 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3400 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3401 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3402 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3403 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3406 // compiles rtlight geometry
3407 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3408 void R_RTLight_Compile(rtlight_t *rtlight)
3411 int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3412 int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3413 entity_render_t *ent = r_refdef.scene.worldentity;
3414 dp_model_t *model = r_refdef.scene.worldmodel;
3415 unsigned char *data;
3418 // compile the light
3419 rtlight->compiled = true;
3420 rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3421 rtlight->static_numleafs = 0;
3422 rtlight->static_numleafpvsbytes = 0;
3423 rtlight->static_leaflist = NULL;
3424 rtlight->static_leafpvs = NULL;
3425 rtlight->static_numsurfaces = 0;
3426 rtlight->static_surfacelist = NULL;
3427 rtlight->static_shadowmap_receivers = 0x3F;
3428 rtlight->static_shadowmap_casters = 0x3F;
3429 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3430 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3431 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3432 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3433 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3434 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3436 if (model && model->GetLightInfo)
3438 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3439 r_shadow_compilingrtlight = rtlight;
3440 R_FrameData_SetMark();
3441 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);
3442 R_FrameData_ReturnToMark();
3443 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3444 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3445 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3446 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3447 rtlight->static_numsurfaces = numsurfaces;
3448 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3449 rtlight->static_numleafs = numleafs;
3450 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3451 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3452 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3453 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3454 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3455 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3456 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3457 if (rtlight->static_numsurfaces)
3458 memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3459 if (rtlight->static_numleafs)
3460 memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3461 if (rtlight->static_numleafpvsbytes)
3462 memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3463 if (rtlight->static_numshadowtrispvsbytes)
3464 memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3465 if (rtlight->static_numlighttrispvsbytes)
3466 memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3467 R_FrameData_SetMark();
3468 switch (rtlight->shadowmode)
3470 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3471 if (model->CompileShadowMap && rtlight->shadow)
3472 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3475 if (model->CompileShadowVolume && rtlight->shadow)
3476 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3479 R_FrameData_ReturnToMark();
3480 // now we're done compiling the rtlight
3481 r_shadow_compilingrtlight = NULL;
3485 // use smallest available cullradius - box radius or light radius
3486 //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3487 //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3489 shadowzpasstris = 0;
3490 if (rtlight->static_meshchain_shadow_zpass)
3491 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3492 shadowzpasstris += mesh->numtriangles;
3494 shadowzfailtris = 0;
3495 if (rtlight->static_meshchain_shadow_zfail)
3496 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3497 shadowzfailtris += mesh->numtriangles;
3500 if (rtlight->static_numlighttrispvsbytes)
3501 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3502 if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3506 if (rtlight->static_numlighttrispvsbytes)
3507 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3508 if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3511 if (developer_extra.integer)
3512 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);
3515 void R_RTLight_Uncompile(rtlight_t *rtlight)
3517 if (rtlight->compiled)
3519 if (rtlight->static_meshchain_shadow_zpass)
3520 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3521 rtlight->static_meshchain_shadow_zpass = NULL;
3522 if (rtlight->static_meshchain_shadow_zfail)
3523 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3524 rtlight->static_meshchain_shadow_zfail = NULL;
3525 if (rtlight->static_meshchain_shadow_shadowmap)
3526 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3527 rtlight->static_meshchain_shadow_shadowmap = NULL;
3528 // these allocations are grouped
3529 if (rtlight->static_surfacelist)
3530 Mem_Free(rtlight->static_surfacelist);
3531 rtlight->static_numleafs = 0;
3532 rtlight->static_numleafpvsbytes = 0;
3533 rtlight->static_leaflist = NULL;
3534 rtlight->static_leafpvs = NULL;
3535 rtlight->static_numsurfaces = 0;
3536 rtlight->static_surfacelist = NULL;
3537 rtlight->static_numshadowtrispvsbytes = 0;
3538 rtlight->static_shadowtrispvs = NULL;
3539 rtlight->static_numlighttrispvsbytes = 0;
3540 rtlight->static_lighttrispvs = NULL;
3541 rtlight->compiled = false;
3545 void R_Shadow_UncompileWorldLights(void)
3549 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3550 for (lightindex = 0;lightindex < range;lightindex++)
3552 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3555 R_RTLight_Uncompile(&light->rtlight);
3559 static void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3563 // reset the count of frustum planes
3564 // see rtlight->cached_frustumplanes definition for how much this array
3566 rtlight->cached_numfrustumplanes = 0;
3568 if (r_trippy.integer)
3571 // haven't implemented a culling path for ortho rendering
3572 if (!r_refdef.view.useperspective)
3574 // check if the light is on screen and copy the 4 planes if it is
3575 for (i = 0;i < 4;i++)
3576 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3579 for (i = 0;i < 4;i++)
3580 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3585 // generate a deformed frustum that includes the light origin, this is
3586 // used to cull shadow casting surfaces that can not possibly cast a
3587 // shadow onto the visible light-receiving surfaces, which can be a
3590 // if the light origin is onscreen the result will be 4 planes exactly
3591 // if the light origin is offscreen on only one axis the result will
3592 // be exactly 5 planes (split-side case)
3593 // if the light origin is offscreen on two axes the result will be
3594 // exactly 4 planes (stretched corner case)
3595 for (i = 0;i < 4;i++)
3597 // quickly reject standard frustum planes that put the light
3598 // origin outside the frustum
3599 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3602 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3604 // if all the standard frustum planes were accepted, the light is onscreen
3605 // otherwise we need to generate some more planes below...
3606 if (rtlight->cached_numfrustumplanes < 4)
3608 // at least one of the stock frustum planes failed, so we need to
3609 // create one or two custom planes to enclose the light origin
3610 for (i = 0;i < 4;i++)
3612 // create a plane using the view origin and light origin, and a
3613 // single point from the frustum corner set
3614 TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3615 VectorNormalize(plane.normal);
3616 plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3617 // see if this plane is backwards and flip it if so
3618 for (j = 0;j < 4;j++)
3619 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3623 VectorNegate(plane.normal, plane.normal);
3625 // flipped plane, test again to see if it is now valid
3626 for (j = 0;j < 4;j++)
3627 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3629 // if the plane is still not valid, then it is dividing the
3630 // frustum and has to be rejected
3634 // we have created a valid plane, compute extra info
3635 PlaneClassify(&plane);
3637 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3639 // if we've found 5 frustum planes then we have constructed a
3640 // proper split-side case and do not need to keep searching for
3641 // planes to enclose the light origin
3642 if (rtlight->cached_numfrustumplanes == 5)
3650 for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3652 plane = rtlight->cached_frustumplanes[i];
3653 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));
3658 // now add the light-space box planes if the light box is rotated, as any
3659 // caster outside the oriented light box is irrelevant (even if it passed
3660 // the worldspace light box, which is axial)
3661 if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3663 for (i = 0;i < 6;i++)
3667 v[i >> 1] = (i & 1) ? -1 : 1;
3668 Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3669 VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3670 plane.dist = VectorNormalizeLength(plane.normal);
3671 plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3672 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3678 // add the world-space reduced box planes
3679 for (i = 0;i < 6;i++)
3681 VectorClear(plane.normal);
3682 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3683 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3684 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3693 // reduce all plane distances to tightly fit the rtlight cull box, which
3695 VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3696 VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3697 VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3698 VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3699 VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3700 VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3701 VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3702 VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3703 oldnum = rtlight->cached_numfrustumplanes;
3704 rtlight->cached_numfrustumplanes = 0;
3705 for (j = 0;j < oldnum;j++)
3707 // find the nearest point on the box to this plane
3708 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3709 for (i = 1;i < 8;i++)
3711 dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3712 if (bestdist > dist)
3715 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);
3716 // if the nearest point is near or behind the plane, we want this
3717 // plane, otherwise the plane is useless as it won't cull anything
3718 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3720 PlaneClassify(&rtlight->cached_frustumplanes[j]);
3721 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3728 static void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3732 RSurf_ActiveWorldEntity();
3734 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3737 GL_CullFace(GL_NONE);
3738 mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3739 for (;mesh;mesh = mesh->next)
3741 if (!mesh->sidetotals[r_shadow_shadowmapside])
3743 r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3744 if (mesh->vertex3fbuffer)
3745 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3747 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3748 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);
3752 else if (r_refdef.scene.worldentity->model)
3753 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);
3755 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3758 static void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3760 qboolean zpass = false;
3763 int surfacelistindex;
3764 msurface_t *surface;
3766 // if triangle neighbors are disabled, shadowvolumes are disabled
3767 if (r_refdef.scene.worldmodel->brush.shadowmesh ? !r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i : !r_refdef.scene.worldmodel->surfmesh.data_neighbor3i)
3770 RSurf_ActiveWorldEntity();
3772 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3775 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3777 zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3778 R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3780 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3781 for (;mesh;mesh = mesh->next)
3783 r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3784 if (mesh->vertex3fbuffer)
3785 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3787 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3788 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3790 // increment stencil if frontface is infront of depthbuffer
3791 GL_CullFace(r_refdef.view.cullface_back);
3792 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
3793 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);
3794 // decrement stencil if backface is infront of depthbuffer
3795 GL_CullFace(r_refdef.view.cullface_front);
3796 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
3798 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3800 // decrement stencil if backface is behind depthbuffer
3801 GL_CullFace(r_refdef.view.cullface_front);
3802 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
3803 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);
3804 // increment stencil if frontface is behind depthbuffer
3805 GL_CullFace(r_refdef.view.cullface_back);
3806 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
3808 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);
3812 else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh)
3814 // use the shadow trispvs calculated earlier by GetLightInfo to cull world triangles on this dynamic light
3815 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3816 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3818 surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3819 for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3820 if (CHECKPVSBIT(trispvs, t))
3821 shadowmarklist[numshadowmark++] = t;
3823 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);
3825 else if (numsurfaces)
3827 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);
3830 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3833 static void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3835 vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3836 vec_t relativeshadowradius;
3837 RSurf_ActiveModelEntity(ent, false, false, false);
3838 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3839 // we need to re-init the shader for each entity because the matrix changed
3840 relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3841 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3842 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3843 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3844 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3845 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3846 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3847 switch (r_shadow_rendermode)
3849 case R_SHADOW_RENDERMODE_SHADOWMAP2D:
3850 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3853 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3856 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3859 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3861 // set up properties for rendering light onto this entity
3862 RSurf_ActiveModelEntity(ent, true, true, false);
3863 Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3864 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3865 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3866 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3869 static void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *lighttrispvs)
3871 if (!r_refdef.scene.worldmodel->DrawLight)
3874 // set up properties for rendering light onto this entity
3875 RSurf_ActiveWorldEntity();
3876 rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3877 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3878 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3879 VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3881 r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
3883 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3886 static void R_Shadow_DrawEntityLight(entity_render_t *ent)
3888 dp_model_t *model = ent->model;
3889 if (!model->DrawLight)
3892 R_Shadow_SetupEntityLight(ent);
3894 model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3896 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3899 static void R_Shadow_PrepareLight(rtlight_t *rtlight)
3903 int numleafs, numsurfaces;
3904 int *leaflist, *surfacelist;
3905 unsigned char *leafpvs;
3906 unsigned char *shadowtrispvs;
3907 unsigned char *lighttrispvs;
3908 //unsigned char *surfacesides;
3909 int numlightentities;
3910 int numlightentities_noselfshadow;
3911 int numshadowentities;
3912 int numshadowentities_noselfshadow;
3913 static entity_render_t *lightentities[MAX_EDICTS];
3914 static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3915 static entity_render_t *shadowentities[MAX_EDICTS];
3916 static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3919 rtlight->draw = false;
3921 // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3922 // skip lights that are basically invisible (color 0 0 0)
3923 nolight = VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f);
3925 // loading is done before visibility checks because loading should happen
3926 // all at once at the start of a level, not when it stalls gameplay.
3927 // (especially important to benchmarks)
3929 if (rtlight->isstatic && !nolight && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
3931 if (rtlight->compiled)
3932 R_RTLight_Uncompile(rtlight);
3933 R_RTLight_Compile(rtlight);
3937 rtlight->currentcubemap = rtlight->cubemapname[0] ? R_GetCubemap(rtlight->cubemapname) : r_texture_whitecube;
3939 // look up the light style value at this time
3940 f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3941 VectorScale(rtlight->color, f, rtlight->currentcolor);
3943 if (rtlight->selected)
3945 f = 2 + sin(realtime * M_PI * 4.0);
3946 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3950 // if lightstyle is currently off, don't draw the light
3951 if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3954 // skip processing on corona-only lights
3958 // if the light box is offscreen, skip it
3959 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3962 VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
3963 VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
3965 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3967 if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3969 // compiled light, world available and can receive realtime lighting
3970 // retrieve leaf information
3971 numleafs = rtlight->static_numleafs;
3972 leaflist = rtlight->static_leaflist;
3973 leafpvs = rtlight->static_leafpvs;
3974 numsurfaces = rtlight->static_numsurfaces;
3975 surfacelist = rtlight->static_surfacelist;
3976 //surfacesides = NULL;
3977 shadowtrispvs = rtlight->static_shadowtrispvs;
3978 lighttrispvs = rtlight->static_lighttrispvs;
3980 else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
3982 // dynamic light, world available and can receive realtime lighting
3983 // calculate lit surfaces and leafs
3984 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);
3985 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3986 leaflist = r_shadow_buffer_leaflist;
3987 leafpvs = r_shadow_buffer_leafpvs;
3988 surfacelist = r_shadow_buffer_surfacelist;
3989 //surfacesides = r_shadow_buffer_surfacesides;
3990 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
3991 lighttrispvs = r_shadow_buffer_lighttrispvs;
3992 // if the reduced leaf bounds are offscreen, skip it
3993 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4004 //surfacesides = NULL;
4005 shadowtrispvs = NULL;
4006 lighttrispvs = NULL;
4008 // check if light is illuminating any visible leafs
4011 for (i = 0;i < numleafs;i++)
4012 if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
4018 // make a list of lit entities and shadow casting entities
4019 numlightentities = 0;
4020 numlightentities_noselfshadow = 0;
4021 numshadowentities = 0;
4022 numshadowentities_noselfshadow = 0;
4024 // add dynamic entities that are lit by the light
4025 for (i = 0;i < r_refdef.scene.numentities;i++)
4028 entity_render_t *ent = r_refdef.scene.entities[i];
4030 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4032 // skip the object entirely if it is not within the valid
4033 // shadow-casting region (which includes the lit region)
4034 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
4036 if (!(model = ent->model))
4038 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
4040 // this entity wants to receive light, is visible, and is
4041 // inside the light box
4042 // TODO: check if the surfaces in the model can receive light
4043 // so now check if it's in a leaf seen by the light
4044 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))
4046 if (ent->flags & RENDER_NOSELFSHADOW)
4047 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
4049 lightentities[numlightentities++] = ent;
4050 // since it is lit, it probably also casts a shadow...
4051 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4052 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4053 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4055 // note: exterior models without the RENDER_NOSELFSHADOW
4056 // flag still create a RENDER_NOSELFSHADOW shadow but
4057 // are lit normally, this means that they are
4058 // self-shadowing but do not shadow other
4059 // RENDER_NOSELFSHADOW entities such as the gun
4060 // (very weird, but keeps the player shadow off the gun)
4061 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4062 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4064 shadowentities[numshadowentities++] = ent;
4067 else if (ent->flags & RENDER_SHADOW)
4069 // this entity is not receiving light, but may still need to
4071 // TODO: check if the surfaces in the model can cast shadow
4072 // now check if it is in a leaf seen by the light
4073 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))
4075 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4076 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4077 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4079 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4080 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4082 shadowentities[numshadowentities++] = ent;
4087 // return if there's nothing at all to light
4088 if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
4091 // count this light in the r_speeds
4092 r_refdef.stats.lights++;
4094 // flag it as worth drawing later
4095 rtlight->draw = true;
4097 // cache all the animated entities that cast a shadow but are not visible
4098 for (i = 0;i < numshadowentities;i++)
4099 if (!shadowentities[i]->animcache_vertex3f)
4100 R_AnimCache_GetEntity(shadowentities[i], false, false);
4101 for (i = 0;i < numshadowentities_noselfshadow;i++)
4102 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
4103 R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
4105 // allocate some temporary memory for rendering this light later in the frame
4106 // reusable buffers need to be copied, static data can be used as-is
4107 rtlight->cached_numlightentities = numlightentities;
4108 rtlight->cached_numlightentities_noselfshadow = numlightentities_noselfshadow;
4109 rtlight->cached_numshadowentities = numshadowentities;
4110 rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
4111 rtlight->cached_numsurfaces = numsurfaces;
4112 rtlight->cached_lightentities = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
4113 rtlight->cached_lightentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
4114 rtlight->cached_shadowentities = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
4115 rtlight->cached_shadowentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
4116 if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
4118 int numshadowtrispvsbytes = (((r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles) + 7) >> 3);
4119 int numlighttrispvsbytes = ((r_refdef.scene.worldmodel->surfmesh.num_triangles + 7) >> 3);
4120 rtlight->cached_shadowtrispvs = (unsigned char *)R_FrameData_Store(numshadowtrispvsbytes, shadowtrispvs);
4121 rtlight->cached_lighttrispvs = (unsigned char *)R_FrameData_Store(numlighttrispvsbytes, lighttrispvs);
4122 rtlight->cached_surfacelist = (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
4126 // compiled light data
4127 rtlight->cached_shadowtrispvs = shadowtrispvs;
4128 rtlight->cached_lighttrispvs = lighttrispvs;
4129 rtlight->cached_surfacelist = surfacelist;
4133 static void R_Shadow_DrawLight(rtlight_t *rtlight)
4137 unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
4138 int numlightentities;
4139 int numlightentities_noselfshadow;
4140 int numshadowentities;
4141 int numshadowentities_noselfshadow;
4142 entity_render_t **lightentities;
4143 entity_render_t **lightentities_noselfshadow;
4144 entity_render_t **shadowentities;
4145 entity_render_t **shadowentities_noselfshadow;
4147 static unsigned char entitysides[MAX_EDICTS];
4148 static unsigned char entitysides_noselfshadow[MAX_EDICTS];
4149 vec3_t nearestpoint;
4151 qboolean castshadows;
4154 // check if we cached this light this frame (meaning it is worth drawing)
4158 numlightentities = rtlight->cached_numlightentities;
4159 numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
4160 numshadowentities = rtlight->cached_numshadowentities;
4161 numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
4162 numsurfaces = rtlight->cached_numsurfaces;
4163 lightentities = rtlight->cached_lightentities;
4164 lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
4165 shadowentities = rtlight->cached_shadowentities;
4166 shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
4167 shadowtrispvs = rtlight->cached_shadowtrispvs;
4168 lighttrispvs = rtlight->cached_lighttrispvs;
4169 surfacelist = rtlight->cached_surfacelist;
4171 // set up a scissor rectangle for this light
4172 if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4175 // don't let sound skip if going slow
4176 if (r_refdef.scene.extraupdate)
4179 // make this the active rtlight for rendering purposes
4180 R_Shadow_RenderMode_ActiveLight(rtlight);
4182 if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
4184 // optionally draw visible shape of the shadow volumes
4185 // for performance analysis by level designers
4186 R_Shadow_RenderMode_VisibleShadowVolumes();
4188 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4189 for (i = 0;i < numshadowentities;i++)
4190 R_Shadow_DrawEntityShadow(shadowentities[i]);
4191 for (i = 0;i < numshadowentities_noselfshadow;i++)
4192 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4193 R_Shadow_RenderMode_VisibleLighting(false, false);
4196 if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
4198 // optionally draw the illuminated areas
4199 // for performance analysis by level designers
4200 R_Shadow_RenderMode_VisibleLighting(false, false);
4202 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4203 for (i = 0;i < numlightentities;i++)
4204 R_Shadow_DrawEntityLight(lightentities[i]);
4205 for (i = 0;i < numlightentities_noselfshadow;i++)
4206 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4209 castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
4211 nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
4212 nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
4213 nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
4214 distance = VectorDistance(nearestpoint, r_refdef.view.origin);
4216 lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
4217 //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
4218 lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
4220 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4226 int receivermask = 0;
4227 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
4228 Matrix4x4_Abs(&radiustolight);
4230 r_shadow_shadowmaplod = 0;
4231 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
4232 if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
4233 r_shadow_shadowmaplod = i;
4235 size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
4237 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
4239 surfacesides = NULL;
4242 if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
4244 castermask = rtlight->static_shadowmap_casters;
4245 receivermask = rtlight->static_shadowmap_receivers;
4249 surfacesides = r_shadow_buffer_surfacesides;
4250 for(i = 0;i < numsurfaces;i++)
4252 msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
4253 surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4254 castermask |= surfacesides[i];
4255 receivermask |= surfacesides[i];
4259 if (receivermask < 0x3F)
4261 for (i = 0;i < numlightentities;i++)
4262 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4263 if (receivermask < 0x3F)
4264 for(i = 0; i < numlightentities_noselfshadow;i++)
4265 receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4268 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
4272 for (i = 0;i < numshadowentities;i++)
4273 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4274 for (i = 0;i < numshadowentities_noselfshadow;i++)
4275 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4278 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
4280 // render shadow casters into 6 sided depth texture
4281 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
4283 R_Shadow_RenderMode_ShadowMap(side, receivermask, size);
4284 if (! (castermask & (1 << side))) continue;
4286 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
4287 for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
4288 R_Shadow_DrawEntityShadow(shadowentities[i]);
4291 if (numlightentities_noselfshadow)
4293 // render lighting using the depth texture as shadowmap
4294 // draw lighting in the unmasked areas
4295 R_Shadow_RenderMode_Lighting(false, false, true);
4296 for (i = 0;i < numlightentities_noselfshadow;i++)
4297 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4300 // render shadow casters into 6 sided depth texture
4301 if (numshadowentities_noselfshadow)
4303 for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
4305 R_Shadow_RenderMode_ShadowMap(side, 0, size);
4306 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
4307 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4311 // render lighting using the depth texture as shadowmap
4312 // draw lighting in the unmasked areas
4313 R_Shadow_RenderMode_Lighting(false, false, true);
4314 // draw lighting in the unmasked areas
4316 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4317 for (i = 0;i < numlightentities;i++)
4318 R_Shadow_DrawEntityLight(lightentities[i]);
4320 else if (castshadows && vid.stencil)
4322 // draw stencil shadow volumes to mask off pixels that are in shadow
4323 // so that they won't receive lighting
4324 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
4325 R_Shadow_ClearStencil();
4328 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4329 for (i = 0;i < numshadowentities;i++)
4330 R_Shadow_DrawEntityShadow(shadowentities[i]);
4332 // draw lighting in the unmasked areas
4333 R_Shadow_RenderMode_Lighting(true, false, false);
4334 for (i = 0;i < numlightentities_noselfshadow;i++)
4335 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4337 for (i = 0;i < numshadowentities_noselfshadow;i++)
4338 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4340 // draw lighting in the unmasked areas
4341 R_Shadow_RenderMode_Lighting(true, false, false);
4343 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4344 for (i = 0;i < numlightentities;i++)
4345 R_Shadow_DrawEntityLight(lightentities[i]);
4349 // draw lighting in the unmasked areas
4350 R_Shadow_RenderMode_Lighting(false, false, false);
4352 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4353 for (i = 0;i < numlightentities;i++)
4354 R_Shadow_DrawEntityLight(lightentities[i]);
4355 for (i = 0;i < numlightentities_noselfshadow;i++)
4356 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4359 if (r_shadow_usingdeferredprepass)
4361 // when rendering deferred lighting, we simply rasterize the box
4362 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4363 R_Shadow_RenderMode_DrawDeferredLight(false, true);
4364 else if (castshadows && vid.stencil)
4365 R_Shadow_RenderMode_DrawDeferredLight(true, false);
4367 R_Shadow_RenderMode_DrawDeferredLight(false, false);
4371 static void R_Shadow_FreeDeferred(void)
4373 R_Mesh_DestroyFramebufferObject(r_shadow_prepassgeometryfbo);
4374 r_shadow_prepassgeometryfbo = 0;
4376 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusespecularfbo);
4377 r_shadow_prepasslightingdiffusespecularfbo = 0;
4379 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusefbo);
4380 r_shadow_prepasslightingdiffusefbo = 0;
4382 if (r_shadow_prepassgeometrydepthbuffer)
4383 R_FreeTexture(r_shadow_prepassgeometrydepthbuffer);
4384 r_shadow_prepassgeometrydepthbuffer = NULL;
4386 if (r_shadow_prepassgeometrynormalmaptexture)
4387 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4388 r_shadow_prepassgeometrynormalmaptexture = NULL;
4390 if (r_shadow_prepasslightingdiffusetexture)
4391 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4392 r_shadow_prepasslightingdiffusetexture = NULL;
4394 if (r_shadow_prepasslightingspeculartexture)
4395 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4396 r_shadow_prepasslightingspeculartexture = NULL;
4399 void R_Shadow_DrawPrepass(void)
4407 entity_render_t *ent;
4408 float clearcolor[4];
4410 R_Mesh_ResetTextureState();
4412 GL_ColorMask(1,1,1,1);
4413 GL_BlendFunc(GL_ONE, GL_ZERO);
4416 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4417 Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f);
4418 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4419 if (r_timereport_active)
4420 R_TimeReport("prepasscleargeom");
4422 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4423 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4424 if (r_timereport_active)
4425 R_TimeReport("prepassworld");
4427 for (i = 0;i < r_refdef.scene.numentities;i++)
4429 if (!r_refdef.viewcache.entityvisible[i])
4431 ent = r_refdef.scene.entities[i];
4432 if (ent->model && ent->model->DrawPrepass != NULL)
4433 ent->model->DrawPrepass(ent);
4436 if (r_timereport_active)
4437 R_TimeReport("prepassmodels");
4439 GL_DepthMask(false);
4440 GL_ColorMask(1,1,1,1);
4443 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4444 Vector4Set(clearcolor, 0, 0, 0, 0);
4445 GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
4446 if (r_timereport_active)
4447 R_TimeReport("prepassclearlit");
4449 R_Shadow_RenderMode_Begin();
4451 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4452 if (r_shadow_debuglight.integer >= 0)
4454 lightindex = r_shadow_debuglight.integer;
4455 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4456 if (light && (light->flags & flag) && light->rtlight.draw)
4457 R_Shadow_DrawLight(&light->rtlight);
4461 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4462 for (lightindex = 0;lightindex < range;lightindex++)
4464 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4465 if (light && (light->flags & flag) && light->rtlight.draw)
4466 R_Shadow_DrawLight(&light->rtlight);
4469 if (r_refdef.scene.rtdlight)
4470 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4471 if (r_refdef.scene.lights[lnum]->draw)
4472 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4474 R_Shadow_RenderMode_End();
4476 if (r_timereport_active)
4477 R_TimeReport("prepasslights");
4480 void R_Shadow_DrawLightSprites(void);
4481 void R_Shadow_PrepareLights(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4490 if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4491 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
4492 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20) ||
4493 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4494 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4495 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4496 R_Shadow_FreeShadowMaps();
4498 r_shadow_fb_fbo = fbo;
4499 r_shadow_fb_depthtexture = depthtexture;
4500 r_shadow_fb_colortexture = colortexture;
4502 r_shadow_usingshadowmaportho = false;
4504 switch (vid.renderpath)
4506 case RENDERPATH_GL20:
4507 case RENDERPATH_D3D9:
4508 case RENDERPATH_D3D10:
4509 case RENDERPATH_D3D11:
4510 case RENDERPATH_SOFT:
4512 if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || vid.maxdrawbuffers < 2)
4514 r_shadow_usingdeferredprepass = false;
4515 if (r_shadow_prepass_width)
4516 R_Shadow_FreeDeferred();
4517 r_shadow_prepass_width = r_shadow_prepass_height = 0;
4521 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4523 R_Shadow_FreeDeferred();
4525 r_shadow_usingdeferredprepass = true;
4526 r_shadow_prepass_width = vid.width;
4527 r_shadow_prepass_height = vid.height;
4528 r_shadow_prepassgeometrydepthbuffer = R_LoadTextureRenderBuffer(r_shadow_texturepool, "prepassgeometrydepthbuffer", vid.width, vid.height, TEXTYPE_DEPTHBUFFER24);
4529 r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4530 r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4531 r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4533 // set up the geometry pass fbo (depth + normalmap)
4534 r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4535 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4536 // render depth into a renderbuffer and other important properties into the normalmap texture
4538 // set up the lighting pass fbo (diffuse + specular)
4539 r_shadow_prepasslightingdiffusespecularfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4540 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4541 // render diffuse into one texture and specular into another,
4542 // with depth and normalmap bound as textures,
4543 // with depth bound as attachment as well
4545 // set up the lighting pass fbo (diffuse)
4546 r_shadow_prepasslightingdiffusefbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4547 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4548 // render diffuse into one texture,
4549 // with depth and normalmap bound as textures,
4550 // with depth bound as attachment as well
4554 case RENDERPATH_GL11:
4555 case RENDERPATH_GL13:
4556 case RENDERPATH_GLES1:
4557 case RENDERPATH_GLES2:
4558 r_shadow_usingdeferredprepass = false;
4562 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);
4564 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4565 if (r_shadow_bouncegrid.integer != 2)
4567 if (r_shadow_debuglight.integer >= 0)
4569 lightindex = r_shadow_debuglight.integer;
4570 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4572 R_Shadow_PrepareLight(&light->rtlight);
4576 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4577 for (lightindex = 0;lightindex < range;lightindex++)
4579 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4580 if (light && (light->flags & flag))
4581 R_Shadow_PrepareLight(&light->rtlight);
4585 if (r_refdef.scene.rtdlight)
4587 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4588 R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4590 else if(gl_flashblend.integer)
4592 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4594 rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4595 f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4596 VectorScale(rtlight->color, f, rtlight->currentcolor);
4600 if (r_editlights.integer)
4601 R_Shadow_DrawLightSprites();
4604 void R_Shadow_DrawLights(void)
4612 R_Shadow_RenderMode_Begin();
4614 if (r_shadow_bouncegrid.integer != 2)
4616 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4617 if (r_shadow_debuglight.integer >= 0)
4619 lightindex = r_shadow_debuglight.integer;
4620 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4622 R_Shadow_DrawLight(&light->rtlight);
4626 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4627 for (lightindex = 0;lightindex < range;lightindex++)
4629 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4630 if (light && (light->flags & flag))
4631 R_Shadow_DrawLight(&light->rtlight);
4635 if (r_refdef.scene.rtdlight)
4636 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4637 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4639 R_Shadow_RenderMode_End();
4642 void R_Shadow_PrepareModelShadows(void)
4645 float scale, size, radius, dot1, dot2;
4646 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus, shadowmins, shadowmaxs;
4647 entity_render_t *ent;
4649 if (!r_refdef.scene.numentities)
4652 switch (r_shadow_shadowmode)
4654 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4655 if (r_shadows.integer >= 2)
4658 case R_SHADOW_SHADOWMODE_STENCIL:
4659 for (i = 0;i < r_refdef.scene.numentities;i++)
4661 ent = r_refdef.scene.entities[i];
4662 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4663 R_AnimCache_GetEntity(ent, false, false);
4670 size = 2*r_shadow_shadowmapmaxsize;
4671 scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
4672 radius = 0.5f * size / scale;
4674 Math_atov(r_shadows_throwdirection.string, shadowdir);
4675 VectorNormalize(shadowdir);
4676 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4677 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4678 if (fabs(dot1) <= fabs(dot2))
4679 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4681 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4682 VectorNormalize(shadowforward);
4683 CrossProduct(shadowdir, shadowforward, shadowright);
4684 Math_atov(r_shadows_focus.string, shadowfocus);
4685 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4686 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4687 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4688 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4689 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4691 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4693 shadowmins[0] = shadoworigin[0] - r_shadows_throwdistance.value * fabs(shadowdir[0]) - radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4694 shadowmins[1] = shadoworigin[1] - r_shadows_throwdistance.value * fabs(shadowdir[1]) - radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4695 shadowmins[2] = shadoworigin[2] - r_shadows_throwdistance.value * fabs(shadowdir[2]) - radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4696 shadowmaxs[0] = shadoworigin[0] + r_shadows_throwdistance.value * fabs(shadowdir[0]) + radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4697 shadowmaxs[1] = shadoworigin[1] + r_shadows_throwdistance.value * fabs(shadowdir[1]) + radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4698 shadowmaxs[2] = shadoworigin[2] + r_shadows_throwdistance.value * fabs(shadowdir[2]) + radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4700 for (i = 0;i < r_refdef.scene.numentities;i++)
4702 ent = r_refdef.scene.entities[i];
4703 if (!BoxesOverlap(ent->mins, ent->maxs, shadowmins, shadowmaxs))
4705 // cast shadows from anything of the map (submodels are optional)
4706 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4707 R_AnimCache_GetEntity(ent, false, false);
4711 void R_DrawModelShadowMaps(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4714 float relativethrowdistance, scale, size, radius, nearclip, farclip, bias, dot1, dot2;
4715 entity_render_t *ent;
4716 vec3_t relativelightorigin;
4717 vec3_t relativelightdirection, relativeforward, relativeright;
4718 vec3_t relativeshadowmins, relativeshadowmaxs;
4719 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus;
4721 matrix4x4_t shadowmatrix, cameramatrix, mvpmatrix, invmvpmatrix, scalematrix, texmatrix;
4722 r_viewport_t viewport;
4723 GLuint shadowfbo = 0;
4724 float clearcolor[4];
4726 if (!r_refdef.scene.numentities)
4729 switch (r_shadow_shadowmode)
4731 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4737 r_shadow_fb_fbo = fbo;
4738 r_shadow_fb_depthtexture = depthtexture;
4739 r_shadow_fb_colortexture = colortexture;
4741 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
4742 R_Shadow_RenderMode_Begin();
4743 R_Shadow_RenderMode_ActiveLight(NULL);
4745 switch (r_shadow_shadowmode)
4747 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4748 if (!r_shadow_shadowmap2ddepthtexture)
4749 R_Shadow_MakeShadowMap(0, r_shadow_shadowmapmaxsize);
4750 shadowfbo = r_shadow_fbo2d;
4751 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2ddepthtexture);
4752 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2ddepthtexture);
4753 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
4759 size = 2*r_shadow_shadowmapmaxsize;
4760 scale = (r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value) / size;
4761 radius = 0.5f / scale;
4762 nearclip = -r_shadows_throwdistance.value;
4763 farclip = r_shadows_throwdistance.value;
4764 bias = r_shadow_shadowmapping_bias.value * r_shadow_shadowmapping_nearclip.value / (2 * r_shadows_throwdistance.value) * (1024.0f / size);
4766 r_shadow_shadowmap_parameters[0] = size;
4767 r_shadow_shadowmap_parameters[1] = size;
4768 r_shadow_shadowmap_parameters[2] = 1.0;
4769 r_shadow_shadowmap_parameters[3] = bound(0.0f, 1.0f - r_shadows_darken.value, 1.0f);
4771 Math_atov(r_shadows_throwdirection.string, shadowdir);
4772 VectorNormalize(shadowdir);
4773 Math_atov(r_shadows_focus.string, shadowfocus);
4774 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4775 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4776 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4777 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4778 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4779 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4780 if (fabs(dot1) <= fabs(dot2))
4781 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4783 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4784 VectorNormalize(shadowforward);
4785 VectorM(scale, shadowforward, &m[0]);
4786 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4788 m[3] = fabs(dot1) * 0.5f - DotProduct(shadoworigin, &m[0]);
4789 CrossProduct(shadowdir, shadowforward, shadowright);
4790 VectorM(scale, shadowright, &m[4]);
4791 m[7] = 0.5f - DotProduct(shadoworigin, &m[4]);
4792 VectorM(1.0f / (farclip - nearclip), shadowdir, &m[8]);
4793 m[11] = 0.5f - DotProduct(shadoworigin, &m[8]);
4794 Matrix4x4_FromArray12FloatD3D(&shadowmatrix, m);
4795 Matrix4x4_Invert_Full(&cameramatrix, &shadowmatrix);
4796 R_Viewport_InitOrtho(&viewport, &cameramatrix, 0, 0, size, size, 0, 0, 1, 1, 0, -1, NULL);
4798 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4800 if (r_shadow_shadowmap2ddepthbuffer)
4801 R_Mesh_SetRenderTargets(shadowfbo, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
4803 R_Mesh_SetRenderTargets(shadowfbo, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
4804 R_SetupShader_DepthOrShadow(true, r_shadow_shadowmap2ddepthbuffer != NULL);
4805 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
4808 R_SetViewport(&viewport);
4809 GL_Scissor(viewport.x, viewport.y, min(viewport.width + r_shadow_shadowmapborder, 2*r_shadow_shadowmapmaxsize), viewport.height + r_shadow_shadowmapborder);
4810 Vector4Set(clearcolor, 1,1,1,1);
4811 // in D3D9 we have to render to a color texture shadowmap
4812 // in GL we render directly to a depth texture only
4813 if (r_shadow_shadowmap2ddepthbuffer)
4814 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4816 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4817 // render into a slightly restricted region so that the borders of the
4818 // shadowmap area fade away, rather than streaking across everything
4819 // outside the usable area
4820 GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder);
4824 R_Mesh_SetRenderTargets(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture, NULL, NULL, NULL);
4825 R_SetupShader_ShowDepth(true);
4826 GL_ColorMask(1,1,1,1);
4827 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4830 for (i = 0;i < r_refdef.scene.numentities;i++)
4832 ent = r_refdef.scene.entities[i];
4834 // cast shadows from anything of the map (submodels are optional)
4835 if (ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4837 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4838 Matrix4x4_Transform(&ent->inversematrix, shadoworigin, relativelightorigin);
4839 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4840 Matrix4x4_Transform3x3(&ent->inversematrix, shadowforward, relativeforward);
4841 Matrix4x4_Transform3x3(&ent->inversematrix, shadowright, relativeright);
4842 relativeshadowmins[0] = relativelightorigin[0] - r_shadows_throwdistance.value * fabs(relativelightdirection[0]) - radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4843 relativeshadowmins[1] = relativelightorigin[1] - r_shadows_throwdistance.value * fabs(relativelightdirection[1]) - radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4844 relativeshadowmins[2] = relativelightorigin[2] - r_shadows_throwdistance.value * fabs(relativelightdirection[2]) - radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4845 relativeshadowmaxs[0] = relativelightorigin[0] + r_shadows_throwdistance.value * fabs(relativelightdirection[0]) + radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4846 relativeshadowmaxs[1] = relativelightorigin[1] + r_shadows_throwdistance.value * fabs(relativelightdirection[1]) + radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4847 relativeshadowmaxs[2] = relativelightorigin[2] + r_shadows_throwdistance.value * fabs(relativelightdirection[2]) + radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4848 RSurf_ActiveModelEntity(ent, false, false, false);
4849 ent->model->DrawShadowMap(0, ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
4850 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4857 unsigned char *rawpixels = Z_Malloc(viewport.width*viewport.height*4);
4859 qglReadPixels(viewport.x, viewport.y, viewport.width, viewport.height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, rawpixels);
4861 Image_WriteTGABGRA("r_shadows_2.tga", viewport.width, viewport.height, rawpixels);
4862 Cvar_SetValueQuick(&r_test, 0);
4867 R_Shadow_RenderMode_End();
4869 Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
4870 Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
4871 Matrix4x4_CreateScale3(&scalematrix, size, -size, 1);
4872 Matrix4x4_AdjustOrigin(&scalematrix, 0, size, -0.5f * bias);
4873 Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix);
4874 Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix);
4876 switch (vid.renderpath)
4878 case RENDERPATH_GL11:
4879 case RENDERPATH_GL13:
4880 case RENDERPATH_GL20:
4881 case RENDERPATH_SOFT:
4882 case RENDERPATH_GLES1:
4883 case RENDERPATH_GLES2:
4885 case RENDERPATH_D3D9:
4886 case RENDERPATH_D3D10:
4887 case RENDERPATH_D3D11:
4888 #ifdef OPENGL_ORIENTATION
4889 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4890 r_shadow_shadowmapmatrix.m[0][1] *= -1.0f;
4891 r_shadow_shadowmapmatrix.m[0][2] *= -1.0f;
4892 r_shadow_shadowmapmatrix.m[0][3] *= -1.0f;
4894 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4895 r_shadow_shadowmapmatrix.m[1][0] *= -1.0f;
4896 r_shadow_shadowmapmatrix.m[2][0] *= -1.0f;
4897 r_shadow_shadowmapmatrix.m[3][0] *= -1.0f;
4902 r_shadow_usingshadowmaportho = true;
4903 switch (r_shadow_shadowmode)
4905 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4906 r_shadow_usingshadowmap2d = true;
4913 void R_DrawModelShadows(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4916 float relativethrowdistance;
4917 entity_render_t *ent;
4918 vec3_t relativelightorigin;
4919 vec3_t relativelightdirection;
4920 vec3_t relativeshadowmins, relativeshadowmaxs;
4921 vec3_t tmp, shadowdir;
4923 if (!r_refdef.scene.numentities || !vid.stencil || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL && r_shadows.integer != 1))
4926 r_shadow_fb_fbo = fbo;
4927 r_shadow_fb_depthtexture = depthtexture;
4928 r_shadow_fb_colortexture = colortexture;
4930 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
4931 //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
4932 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4933 R_Shadow_RenderMode_Begin();
4934 R_Shadow_RenderMode_ActiveLight(NULL);
4935 r_shadow_lightscissor[0] = r_refdef.view.x;
4936 r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
4937 r_shadow_lightscissor[2] = r_refdef.view.width;
4938 r_shadow_lightscissor[3] = r_refdef.view.height;
4939 R_Shadow_RenderMode_StencilShadowVolumes(false);
4942 if (r_shadows.integer == 2)
4944 Math_atov(r_shadows_throwdirection.string, shadowdir);
4945 VectorNormalize(shadowdir);
4948 R_Shadow_ClearStencil();
4950 for (i = 0;i < r_refdef.scene.numentities;i++)
4952 ent = r_refdef.scene.entities[i];
4954 // cast shadows from anything of the map (submodels are optional)
4955 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4957 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4958 VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
4959 VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
4960 if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
4961 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4964 if(ent->entitynumber != 0)
4966 if(ent->entitynumber >= MAX_EDICTS) // csqc entity
4968 // FIXME handle this
4969 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4973 // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
4974 int entnum, entnum2, recursion;
4975 entnum = entnum2 = ent->entitynumber;
4976 for(recursion = 32; recursion > 0; --recursion)
4978 entnum2 = cl.entities[entnum].state_current.tagentity;
4979 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
4984 if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
4986 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
4987 // transform into modelspace of OUR entity
4988 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
4989 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
4992 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4996 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4999 VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
5000 RSurf_ActiveModelEntity(ent, false, false, false);
5001 ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
5002 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
5006 // not really the right mode, but this will disable any silly stencil features
5007 R_Shadow_RenderMode_End();
5009 // set up ortho view for rendering this pass
5010 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
5011 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5012 //GL_ScissorTest(true);
5013 //R_EntityMatrix(&identitymatrix);
5014 //R_Mesh_ResetTextureState();
5015 R_ResetViewRendering2D(fbo, depthtexture, colortexture);
5017 // set up a darkening blend on shadowed areas
5018 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5019 //GL_DepthRange(0, 1);
5020 //GL_DepthTest(false);
5021 //GL_DepthMask(false);
5022 //GL_PolygonOffset(0, 0);CHECKGLERROR
5023 GL_Color(0, 0, 0, r_shadows_darken.value);
5024 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5025 //GL_DepthFunc(GL_ALWAYS);
5026 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_NOTEQUAL, 128, 255);
5028 // apply the blend to the shadowed areas
5029 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
5030 R_SetupShader_Generic_NoTexture(false, true);
5031 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5033 // restore the viewport
5034 R_SetViewport(&r_refdef.view.viewport);
5036 // restore other state to normal
5037 //R_Shadow_RenderMode_End();
5040 static void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
5043 vec3_t centerorigin;
5045 // if it's too close, skip it
5046 if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
5048 zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
5051 if (usequery && r_numqueries + 2 <= r_maxqueries)
5053 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
5054 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
5055 // 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
5056 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
5058 switch(vid.renderpath)
5060 case RENDERPATH_GL11:
5061 case RENDERPATH_GL13:
5062 case RENDERPATH_GL20:
5063 case RENDERPATH_GLES1:
5064 case RENDERPATH_GLES2:
5065 #ifdef GL_SAMPLES_PASSED_ARB
5067 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead
5068 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
5069 GL_DepthFunc(GL_ALWAYS);
5070 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5071 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5072 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5073 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5074 GL_DepthFunc(GL_LEQUAL);
5075 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
5076 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5077 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5078 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5079 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5083 case RENDERPATH_D3D9:
5084 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5086 case RENDERPATH_D3D10:
5087 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5089 case RENDERPATH_D3D11:
5090 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5092 case RENDERPATH_SOFT:
5093 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5097 rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
5100 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
5102 static void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
5105 GLint allpixels = 0, visiblepixels = 0;
5106 // now we have to check the query result
5107 if (rtlight->corona_queryindex_visiblepixels)
5109 switch(vid.renderpath)
5111 case RENDERPATH_GL11:
5112 case RENDERPATH_GL13:
5113 case RENDERPATH_GL20:
5114 case RENDERPATH_GLES1:
5115 case RENDERPATH_GLES2:
5116 #ifdef GL_SAMPLES_PASSED_ARB
5118 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
5119 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
5123 case RENDERPATH_D3D9:
5124 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5126 case RENDERPATH_D3D10:
5127 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5129 case RENDERPATH_D3D11:
5130 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5132 case RENDERPATH_SOFT:
5133 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5136 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
5137 if (visiblepixels < 1 || allpixels < 1)
5139 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
5140 cscale *= rtlight->corona_visibility;
5144 // FIXME: these traces should scan all render entities instead of cl.world
5145 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
5148 VectorScale(rtlight->currentcolor, cscale, color);
5149 if (VectorLength(color) > (1.0f / 256.0f))
5152 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
5155 VectorNegate(color, color);
5156 GL_BlendEquationSubtract(true);
5158 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5159 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);
5160 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5162 GL_BlendEquationSubtract(false);
5166 void R_Shadow_DrawCoronas(void)
5169 qboolean usequery = false;
5174 if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
5176 if (r_fb.water.renderingscene)
5178 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
5179 R_EntityMatrix(&identitymatrix);
5181 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5183 // check occlusion of coronas
5184 // use GL_ARB_occlusion_query if available
5185 // otherwise use raytraces
5187 switch (vid.renderpath)
5189 case RENDERPATH_GL11:
5190 case RENDERPATH_GL13:
5191 case RENDERPATH_GL20:
5192 case RENDERPATH_GLES1:
5193 case RENDERPATH_GLES2:
5194 usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
5195 #ifdef GL_SAMPLES_PASSED_ARB
5198 GL_ColorMask(0,0,0,0);
5199 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
5200 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
5203 r_maxqueries = (range + r_refdef.scene.numlights) * 4;
5204 r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
5206 qglGenQueriesARB(r_maxqueries - i, r_queries + i);
5209 RSurf_ActiveWorldEntity();
5210 GL_BlendFunc(GL_ONE, GL_ZERO);
5211 GL_CullFace(GL_NONE);
5212 GL_DepthMask(false);
5213 GL_DepthRange(0, 1);
5214 GL_PolygonOffset(0, 0);
5216 R_Mesh_ResetTextureState();
5217 R_SetupShader_Generic_NoTexture(false, false);
5221 case RENDERPATH_D3D9:
5223 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5225 case RENDERPATH_D3D10:
5226 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5228 case RENDERPATH_D3D11:
5229 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5231 case RENDERPATH_SOFT:
5233 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5236 for (lightindex = 0;lightindex < range;lightindex++)
5238 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5241 rtlight = &light->rtlight;
5242 rtlight->corona_visibility = 0;
5243 rtlight->corona_queryindex_visiblepixels = 0;
5244 rtlight->corona_queryindex_allpixels = 0;
5245 if (!(rtlight->flags & flag))
5247 if (rtlight->corona <= 0)
5249 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
5251 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5253 for (i = 0;i < r_refdef.scene.numlights;i++)
5255 rtlight = r_refdef.scene.lights[i];
5256 rtlight->corona_visibility = 0;
5257 rtlight->corona_queryindex_visiblepixels = 0;
5258 rtlight->corona_queryindex_allpixels = 0;
5259 if (!(rtlight->flags & flag))
5261 if (rtlight->corona <= 0)
5263 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5266 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5268 // now draw the coronas using the query data for intensity info
5269 for (lightindex = 0;lightindex < range;lightindex++)
5271 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5274 rtlight = &light->rtlight;
5275 if (rtlight->corona_visibility <= 0)
5277 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5279 for (i = 0;i < r_refdef.scene.numlights;i++)
5281 rtlight = r_refdef.scene.lights[i];
5282 if (rtlight->corona_visibility <= 0)
5284 if (gl_flashblend.integer)
5285 R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
5287 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5293 static dlight_t *R_Shadow_NewWorldLight(void)
5295 return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
5298 static 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)
5301 // validate parameters
5302 if (style < 0 || style >= MAX_LIGHTSTYLES)
5304 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
5310 // copy to light properties
5311 VectorCopy(origin, light->origin);
5312 light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
5313 light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
5314 light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
5316 light->color[0] = max(color[0], 0);
5317 light->color[1] = max(color[1], 0);
5318 light->color[2] = max(color[2], 0);
5320 light->color[0] = color[0];
5321 light->color[1] = color[1];
5322 light->color[2] = color[2];
5323 light->radius = max(radius, 0);
5324 light->style = style;
5325 light->shadow = shadowenable;
5326 light->corona = corona;
5327 strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
5328 light->coronasizescale = coronasizescale;
5329 light->ambientscale = ambientscale;
5330 light->diffusescale = diffusescale;
5331 light->specularscale = specularscale;
5332 light->flags = flags;
5334 // update renderable light data
5335 Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
5336 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);
5339 static void R_Shadow_FreeWorldLight(dlight_t *light)
5341 if (r_shadow_selectedlight == light)
5342 r_shadow_selectedlight = NULL;
5343 R_RTLight_Uncompile(&light->rtlight);
5344 Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
5347 void R_Shadow_ClearWorldLights(void)
5351 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5352 for (lightindex = 0;lightindex < range;lightindex++)
5354 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5356 R_Shadow_FreeWorldLight(light);
5358 r_shadow_selectedlight = NULL;
5361 static void R_Shadow_SelectLight(dlight_t *light)
5363 if (r_shadow_selectedlight)
5364 r_shadow_selectedlight->selected = false;
5365 r_shadow_selectedlight = light;
5366 if (r_shadow_selectedlight)
5367 r_shadow_selectedlight->selected = true;
5370 static void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5372 // this is never batched (there can be only one)
5374 R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
5375 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5376 R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5379 static void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5384 skinframe_t *skinframe;
5387 // this is never batched (due to the ent parameter changing every time)
5388 // so numsurfaces == 1 and surfacelist[0] == lightnumber
5389 const dlight_t *light = (dlight_t *)ent;
5392 R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
5395 VectorScale(light->color, intensity, spritecolor);
5396 if (VectorLength(spritecolor) < 0.1732f)
5397 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
5398 if (VectorLength(spritecolor) > 1.0f)
5399 VectorNormalize(spritecolor);
5401 // draw light sprite
5402 if (light->cubemapname[0] && !light->shadow)
5403 skinframe = r_editlights_sprcubemapnoshadowlight;
5404 else if (light->cubemapname[0])
5405 skinframe = r_editlights_sprcubemaplight;
5406 else if (!light->shadow)
5407 skinframe = r_editlights_sprnoshadowlight;
5409 skinframe = r_editlights_sprlight;
5411 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);
5412 R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5414 // draw selection sprite if light is selected
5415 if (light->selected)
5417 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5418 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5419 // VorteX todo: add normalmode/realtime mode light overlay sprites?
5423 void R_Shadow_DrawLightSprites(void)
5427 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5428 for (lightindex = 0;lightindex < range;lightindex++)
5430 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5432 R_MeshQueue_AddTransparent(MESHQUEUE_SORT_DISTANCE, light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
5434 if (!r_editlights_lockcursor)
5435 R_MeshQueue_AddTransparent(MESHQUEUE_SORT_DISTANCE, r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
5438 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
5443 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
5444 if (lightindex >= range)
5446 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5449 rtlight = &light->rtlight;
5450 //if (!(rtlight->flags & flag))
5452 VectorCopy(rtlight->shadoworigin, origin);
5453 *radius = rtlight->radius;
5454 VectorCopy(rtlight->color, color);
5458 static void R_Shadow_SelectLightInView(void)
5460 float bestrating, rating, temp[3];
5464 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5468 if (r_editlights_lockcursor)
5470 for (lightindex = 0;lightindex < range;lightindex++)
5472 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5475 VectorSubtract(light->origin, r_refdef.view.origin, temp);
5476 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
5479 rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
5480 if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1.0f)
5482 bestrating = rating;
5487 R_Shadow_SelectLight(best);
5490 void R_Shadow_LoadWorldLights(void)
5492 int n, a, style, shadow, flags;
5493 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
5494 float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
5495 if (cl.worldmodel == NULL)
5497 Con_Print("No map loaded.\n");
5500 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5501 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5511 for (;COM_Parse(t, true) && strcmp(
5512 if (COM_Parse(t, true))
5514 if (com_token[0] == '!')
5517 origin[0] = atof(com_token+1);
5520 origin[0] = atof(com_token);
5525 while (*s && *s != '\n' && *s != '\r')
5531 // check for modifier flags
5538 #if _MSC_VER >= 1400
5539 #define sscanf sscanf_s
5541 cubemapname[sizeof(cubemapname)-1] = 0;
5542 #if MAX_QPATH != 128
5543 #error update this code if MAX_QPATH changes
5545 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
5546 #if _MSC_VER >= 1400
5547 , sizeof(cubemapname)
5549 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
5552 flags = LIGHTFLAG_REALTIMEMODE;
5560 coronasizescale = 0.25f;
5562 VectorClear(angles);
5565 if (a < 9 || !strcmp(cubemapname, "\"\""))
5567 // remove quotes on cubemapname
5568 if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
5571 namelen = strlen(cubemapname) - 2;
5572 memmove(cubemapname, cubemapname + 1, namelen);
5573 cubemapname[namelen] = '\0';
5577 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);
5580 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5588 Con_Printf("invalid rtlights file \"%s\"\n", name);
5589 Mem_Free(lightsstring);
5593 void R_Shadow_SaveWorldLights(void)
5597 size_t bufchars, bufmaxchars;
5599 char name[MAX_QPATH];
5600 char line[MAX_INPUTLINE];
5601 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5602 // I hate lines which are 3 times my screen size :( --blub
5605 if (cl.worldmodel == NULL)
5607 Con_Print("No map loaded.\n");
5610 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5611 bufchars = bufmaxchars = 0;
5613 for (lightindex = 0;lightindex < range;lightindex++)
5615 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5618 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5619 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);
5620 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5621 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]);
5623 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);
5624 if (bufchars + strlen(line) > bufmaxchars)
5626 bufmaxchars = bufchars + strlen(line) + 2048;
5628 buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5632 memcpy(buf, oldbuf, bufchars);
5638 memcpy(buf + bufchars, line, strlen(line));
5639 bufchars += strlen(line);
5643 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5648 void R_Shadow_LoadLightsFile(void)
5651 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5652 float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5653 if (cl.worldmodel == NULL)
5655 Con_Print("No map loaded.\n");
5658 dpsnprintf(name, sizeof(name), "%s.lights", cl.worldnamenoextension);
5659 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5667 while (*s && *s != '\n' && *s != '\r')
5673 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);
5677 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);
5680 radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5681 radius = bound(15, radius, 4096);
5682 VectorScale(color, (2.0f / (8388608.0f)), color);
5683 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5691 Con_Printf("invalid lights file \"%s\"\n", name);
5692 Mem_Free(lightsstring);
5696 // tyrlite/hmap2 light types in the delay field
5697 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5699 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5711 float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5712 char key[256], value[MAX_INPUTLINE];
5715 if (cl.worldmodel == NULL)
5717 Con_Print("No map loaded.\n");
5720 // try to load a .ent file first
5721 dpsnprintf(key, sizeof(key), "%s.ent", cl.worldnamenoextension);
5722 data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5723 // and if that is not found, fall back to the bsp file entity string
5725 data = cl.worldmodel->brush.entities;
5728 for (entnum = 0;COM_ParseToken_Simple(&data, false, false, true) && com_token[0] == '{';entnum++)
5730 type = LIGHTTYPE_MINUSX;
5731 origin[0] = origin[1] = origin[2] = 0;
5732 originhack[0] = originhack[1] = originhack[2] = 0;
5733 angles[0] = angles[1] = angles[2] = 0;
5734 color[0] = color[1] = color[2] = 1;
5735 light[0] = light[1] = light[2] = 1;light[3] = 300;
5736 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5746 if (!COM_ParseToken_Simple(&data, false, false, true))
5748 if (com_token[0] == '}')
5749 break; // end of entity
5750 if (com_token[0] == '_')
5751 strlcpy(key, com_token + 1, sizeof(key));
5753 strlcpy(key, com_token, sizeof(key));
5754 while (key[strlen(key)-1] == ' ') // remove trailing spaces
5755 key[strlen(key)-1] = 0;
5756 if (!COM_ParseToken_Simple(&data, false, false, true))
5758 strlcpy(value, com_token, sizeof(value));
5760 // now that we have the key pair worked out...
5761 if (!strcmp("light", key))
5763 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5767 light[0] = vec[0] * (1.0f / 256.0f);
5768 light[1] = vec[0] * (1.0f / 256.0f);
5769 light[2] = vec[0] * (1.0f / 256.0f);
5775 light[0] = vec[0] * (1.0f / 255.0f);
5776 light[1] = vec[1] * (1.0f / 255.0f);
5777 light[2] = vec[2] * (1.0f / 255.0f);
5781 else if (!strcmp("delay", key))
5783 else if (!strcmp("origin", key))
5784 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5785 else if (!strcmp("angle", key))
5786 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5787 else if (!strcmp("angles", key))
5788 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5789 else if (!strcmp("color", key))
5790 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5791 else if (!strcmp("wait", key))
5792 fadescale = atof(value);
5793 else if (!strcmp("classname", key))
5795 if (!strncmp(value, "light", 5))
5798 if (!strcmp(value, "light_fluoro"))
5803 overridecolor[0] = 1;
5804 overridecolor[1] = 1;
5805 overridecolor[2] = 1;
5807 if (!strcmp(value, "light_fluorospark"))
5812 overridecolor[0] = 1;
5813 overridecolor[1] = 1;
5814 overridecolor[2] = 1;
5816 if (!strcmp(value, "light_globe"))
5821 overridecolor[0] = 1;
5822 overridecolor[1] = 0.8;
5823 overridecolor[2] = 0.4;
5825 if (!strcmp(value, "light_flame_large_yellow"))
5830 overridecolor[0] = 1;
5831 overridecolor[1] = 0.5;
5832 overridecolor[2] = 0.1;
5834 if (!strcmp(value, "light_flame_small_yellow"))
5839 overridecolor[0] = 1;
5840 overridecolor[1] = 0.5;
5841 overridecolor[2] = 0.1;
5843 if (!strcmp(value, "light_torch_small_white"))
5848 overridecolor[0] = 1;
5849 overridecolor[1] = 0.5;
5850 overridecolor[2] = 0.1;
5852 if (!strcmp(value, "light_torch_small_walltorch"))
5857 overridecolor[0] = 1;
5858 overridecolor[1] = 0.5;
5859 overridecolor[2] = 0.1;
5863 else if (!strcmp("style", key))
5864 style = atoi(value);
5865 else if (!strcmp("skin", key))
5866 skin = (int)atof(value);
5867 else if (!strcmp("pflags", key))
5868 pflags = (int)atof(value);
5869 //else if (!strcmp("effects", key))
5870 // effects = (int)atof(value);
5871 else if (cl.worldmodel->type == mod_brushq3)
5873 if (!strcmp("scale", key))
5874 lightscale = atof(value);
5875 if (!strcmp("fade", key))
5876 fadescale = atof(value);
5881 if (lightscale <= 0)
5885 if (color[0] == color[1] && color[0] == color[2])
5887 color[0] *= overridecolor[0];
5888 color[1] *= overridecolor[1];
5889 color[2] *= overridecolor[2];
5891 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
5892 color[0] = color[0] * light[0];
5893 color[1] = color[1] * light[1];
5894 color[2] = color[2] * light[2];
5897 case LIGHTTYPE_MINUSX:
5899 case LIGHTTYPE_RECIPX:
5901 VectorScale(color, (1.0f / 16.0f), color);
5903 case LIGHTTYPE_RECIPXX:
5905 VectorScale(color, (1.0f / 16.0f), color);
5908 case LIGHTTYPE_NONE:
5912 case LIGHTTYPE_MINUSXX:
5915 VectorAdd(origin, originhack, origin);
5917 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, (pflags & PFLAGS_CORONA) != 0, style, (pflags & PFLAGS_NOSHADOW) == 0, skin >= 16 ? va(vabuf, sizeof(vabuf), "cubemaps/%i", skin) : NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5920 Mem_Free(entfiledata);
5924 static void R_Shadow_SetCursorLocationForView(void)
5927 vec3_t dest, endpos;
5929 VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
5930 trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true);
5931 if (trace.fraction < 1)
5933 dist = trace.fraction * r_editlights_cursordistance.value;
5934 push = r_editlights_cursorpushback.value;
5938 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
5939 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
5943 VectorClear( endpos );
5945 r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5946 r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5947 r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5950 void R_Shadow_UpdateWorldLightSelection(void)
5952 if (r_editlights.integer)
5954 R_Shadow_SetCursorLocationForView();
5955 R_Shadow_SelectLightInView();
5958 R_Shadow_SelectLight(NULL);
5961 static void R_Shadow_EditLights_Clear_f(void)
5963 R_Shadow_ClearWorldLights();
5966 void R_Shadow_EditLights_Reload_f(void)
5970 strlcpy(r_shadow_mapname, cl.worldname, sizeof(r_shadow_mapname));
5971 R_Shadow_ClearWorldLights();
5972 R_Shadow_LoadWorldLights();
5973 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5975 R_Shadow_LoadLightsFile();
5976 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5977 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5981 static void R_Shadow_EditLights_Save_f(void)
5985 R_Shadow_SaveWorldLights();
5988 static void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
5990 R_Shadow_ClearWorldLights();
5991 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5994 static void R_Shadow_EditLights_ImportLightsFile_f(void)
5996 R_Shadow_ClearWorldLights();
5997 R_Shadow_LoadLightsFile();
6000 static void R_Shadow_EditLights_Spawn_f(void)
6003 if (!r_editlights.integer)
6005 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6008 if (Cmd_Argc() != 1)
6010 Con_Print("r_editlights_spawn does not take parameters\n");
6013 color[0] = color[1] = color[2] = 1;
6014 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
6017 static void R_Shadow_EditLights_Edit_f(void)
6019 vec3_t origin, angles, color;
6020 vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
6021 int style, shadows, flags, normalmode, realtimemode;
6022 char cubemapname[MAX_INPUTLINE];
6023 if (!r_editlights.integer)
6025 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6028 if (!r_shadow_selectedlight)
6030 Con_Print("No selected light.\n");
6033 VectorCopy(r_shadow_selectedlight->origin, origin);
6034 VectorCopy(r_shadow_selectedlight->angles, angles);
6035 VectorCopy(r_shadow_selectedlight->color, color);
6036 radius = r_shadow_selectedlight->radius;
6037 style = r_shadow_selectedlight->style;
6038 if (r_shadow_selectedlight->cubemapname)
6039 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
6042 shadows = r_shadow_selectedlight->shadow;
6043 corona = r_shadow_selectedlight->corona;
6044 coronasizescale = r_shadow_selectedlight->coronasizescale;
6045 ambientscale = r_shadow_selectedlight->ambientscale;
6046 diffusescale = r_shadow_selectedlight->diffusescale;
6047 specularscale = r_shadow_selectedlight->specularscale;
6048 flags = r_shadow_selectedlight->flags;
6049 normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
6050 realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
6051 if (!strcmp(Cmd_Argv(1), "origin"))
6053 if (Cmd_Argc() != 5)
6055 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6058 origin[0] = atof(Cmd_Argv(2));
6059 origin[1] = atof(Cmd_Argv(3));
6060 origin[2] = atof(Cmd_Argv(4));
6062 else if (!strcmp(Cmd_Argv(1), "originscale"))
6064 if (Cmd_Argc() != 5)
6066 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6069 origin[0] *= atof(Cmd_Argv(2));
6070 origin[1] *= atof(Cmd_Argv(3));
6071 origin[2] *= atof(Cmd_Argv(4));
6073 else if (!strcmp(Cmd_Argv(1), "originx"))
6075 if (Cmd_Argc() != 3)
6077 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6080 origin[0] = atof(Cmd_Argv(2));
6082 else if (!strcmp(Cmd_Argv(1), "originy"))
6084 if (Cmd_Argc() != 3)
6086 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6089 origin[1] = atof(Cmd_Argv(2));
6091 else if (!strcmp(Cmd_Argv(1), "originz"))
6093 if (Cmd_Argc() != 3)
6095 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6098 origin[2] = atof(Cmd_Argv(2));
6100 else if (!strcmp(Cmd_Argv(1), "move"))
6102 if (Cmd_Argc() != 5)
6104 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6107 origin[0] += atof(Cmd_Argv(2));
6108 origin[1] += atof(Cmd_Argv(3));
6109 origin[2] += atof(Cmd_Argv(4));
6111 else if (!strcmp(Cmd_Argv(1), "movex"))
6113 if (Cmd_Argc() != 3)
6115 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6118 origin[0] += atof(Cmd_Argv(2));
6120 else if (!strcmp(Cmd_Argv(1), "movey"))
6122 if (Cmd_Argc() != 3)
6124 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6127 origin[1] += atof(Cmd_Argv(2));
6129 else if (!strcmp(Cmd_Argv(1), "movez"))
6131 if (Cmd_Argc() != 3)
6133 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6136 origin[2] += atof(Cmd_Argv(2));
6138 else if (!strcmp(Cmd_Argv(1), "angles"))
6140 if (Cmd_Argc() != 5)
6142 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6145 angles[0] = atof(Cmd_Argv(2));
6146 angles[1] = atof(Cmd_Argv(3));
6147 angles[2] = atof(Cmd_Argv(4));
6149 else if (!strcmp(Cmd_Argv(1), "anglesx"))
6151 if (Cmd_Argc() != 3)
6153 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6156 angles[0] = atof(Cmd_Argv(2));
6158 else if (!strcmp(Cmd_Argv(1), "anglesy"))
6160 if (Cmd_Argc() != 3)
6162 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6165 angles[1] = atof(Cmd_Argv(2));
6167 else if (!strcmp(Cmd_Argv(1), "anglesz"))
6169 if (Cmd_Argc() != 3)
6171 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6174 angles[2] = atof(Cmd_Argv(2));
6176 else if (!strcmp(Cmd_Argv(1), "color"))
6178 if (Cmd_Argc() != 5)
6180 Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
6183 color[0] = atof(Cmd_Argv(2));
6184 color[1] = atof(Cmd_Argv(3));
6185 color[2] = atof(Cmd_Argv(4));
6187 else if (!strcmp(Cmd_Argv(1), "radius"))
6189 if (Cmd_Argc() != 3)
6191 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6194 radius = atof(Cmd_Argv(2));
6196 else if (!strcmp(Cmd_Argv(1), "colorscale"))
6198 if (Cmd_Argc() == 3)
6200 double scale = atof(Cmd_Argv(2));
6207 if (Cmd_Argc() != 5)
6209 Con_Printf("usage: r_editlights_edit %s red green blue (OR grey instead of red green blue)\n", Cmd_Argv(1));
6212 color[0] *= atof(Cmd_Argv(2));
6213 color[1] *= atof(Cmd_Argv(3));
6214 color[2] *= atof(Cmd_Argv(4));
6217 else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
6219 if (Cmd_Argc() != 3)
6221 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6224 radius *= atof(Cmd_Argv(2));
6226 else if (!strcmp(Cmd_Argv(1), "style"))
6228 if (Cmd_Argc() != 3)
6230 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6233 style = atoi(Cmd_Argv(2));
6235 else if (!strcmp(Cmd_Argv(1), "cubemap"))
6239 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6242 if (Cmd_Argc() == 3)
6243 strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
6247 else if (!strcmp(Cmd_Argv(1), "shadows"))
6249 if (Cmd_Argc() != 3)
6251 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6254 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6256 else if (!strcmp(Cmd_Argv(1), "corona"))
6258 if (Cmd_Argc() != 3)
6260 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6263 corona = atof(Cmd_Argv(2));
6265 else if (!strcmp(Cmd_Argv(1), "coronasize"))
6267 if (Cmd_Argc() != 3)
6269 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6272 coronasizescale = atof(Cmd_Argv(2));
6274 else if (!strcmp(Cmd_Argv(1), "ambient"))
6276 if (Cmd_Argc() != 3)
6278 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6281 ambientscale = atof(Cmd_Argv(2));
6283 else if (!strcmp(Cmd_Argv(1), "diffuse"))
6285 if (Cmd_Argc() != 3)
6287 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6290 diffusescale = atof(Cmd_Argv(2));
6292 else if (!strcmp(Cmd_Argv(1), "specular"))
6294 if (Cmd_Argc() != 3)
6296 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6299 specularscale = atof(Cmd_Argv(2));
6301 else if (!strcmp(Cmd_Argv(1), "normalmode"))
6303 if (Cmd_Argc() != 3)
6305 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6308 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6310 else if (!strcmp(Cmd_Argv(1), "realtimemode"))
6312 if (Cmd_Argc() != 3)
6314 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6317 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6321 Con_Print("usage: r_editlights_edit [property] [value]\n");
6322 Con_Print("Selected light's properties:\n");
6323 Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
6324 Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
6325 Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
6326 Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius);
6327 Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona);
6328 Con_Printf("Style : %i\n", r_shadow_selectedlight->style);
6329 Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
6330 Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname);
6331 Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);
6332 Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale);
6333 Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale);
6334 Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale);
6335 Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
6336 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
6339 flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
6340 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
6343 static void R_Shadow_EditLights_EditAll_f(void)
6346 dlight_t *light, *oldselected;
6349 if (!r_editlights.integer)
6351 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
6355 oldselected = r_shadow_selectedlight;
6356 // EditLights doesn't seem to have a "remove" command or something so:
6357 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6358 for (lightindex = 0;lightindex < range;lightindex++)
6360 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6363 R_Shadow_SelectLight(light);
6364 R_Shadow_EditLights_Edit_f();
6366 // return to old selected (to not mess editing once selection is locked)
6367 R_Shadow_SelectLight(oldselected);
6370 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
6372 int lightnumber, lightcount;
6373 size_t lightindex, range;
6377 if (!r_editlights.integer)
6379 x = vid_conwidth.value - 240;
6381 DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
6384 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6385 for (lightindex = 0;lightindex < range;lightindex++)
6387 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6390 if (light == r_shadow_selectedlight)
6391 lightnumber = lightindex;
6394 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;
6395 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;
6397 if (r_shadow_selectedlight == NULL)
6399 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;
6400 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;
6401 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;
6402 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;
6403 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;
6404 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;
6405 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;
6406 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;
6407 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;
6408 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;
6409 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;
6410 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;
6411 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;
6412 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;
6413 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;
6416 static void R_Shadow_EditLights_ToggleShadow_f(void)
6418 if (!r_editlights.integer)
6420 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6423 if (!r_shadow_selectedlight)
6425 Con_Print("No selected light.\n");
6428 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);
6431 static void R_Shadow_EditLights_ToggleCorona_f(void)
6433 if (!r_editlights.integer)
6435 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6438 if (!r_shadow_selectedlight)
6440 Con_Print("No selected light.\n");
6443 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);
6446 static void R_Shadow_EditLights_Remove_f(void)
6448 if (!r_editlights.integer)
6450 Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n");
6453 if (!r_shadow_selectedlight)
6455 Con_Print("No selected light.\n");
6458 R_Shadow_FreeWorldLight(r_shadow_selectedlight);
6459 r_shadow_selectedlight = NULL;
6462 static void R_Shadow_EditLights_Help_f(void)
6465 "Documentation on r_editlights system:\n"
6467 "r_editlights : enable/disable editing mode\n"
6468 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
6469 "r_editlights_cursorpushback : push back cursor this far from surface\n"
6470 "r_editlights_cursorpushoff : push cursor off surface this far\n"
6471 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
6472 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
6474 "r_editlights_help : this help\n"
6475 "r_editlights_clear : remove all lights\n"
6476 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
6477 "r_editlights_lock : lock selection to current light, if already locked - unlock\n"
6478 "r_editlights_save : save to .rtlights file\n"
6479 "r_editlights_spawn : create a light with default settings\n"
6480 "r_editlights_edit command : edit selected light - more documentation below\n"
6481 "r_editlights_remove : remove selected light\n"
6482 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
6483 "r_editlights_importlightentitiesfrommap : reload light entities\n"
6484 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
6486 "origin x y z : set light location\n"
6487 "originx x: set x component of light location\n"
6488 "originy y: set y component of light location\n"
6489 "originz z: set z component of light location\n"
6490 "move x y z : adjust light location\n"
6491 "movex x: adjust x component of light location\n"
6492 "movey y: adjust y component of light location\n"
6493 "movez z: adjust z component of light location\n"
6494 "angles x y z : set light angles\n"
6495 "anglesx x: set x component of light angles\n"
6496 "anglesy y: set y component of light angles\n"
6497 "anglesz z: set z component of light angles\n"
6498 "color r g b : set color of light (can be brighter than 1 1 1)\n"
6499 "radius radius : set radius (size) of light\n"
6500 "colorscale grey : multiply color of light (1 does nothing)\n"
6501 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
6502 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
6503 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
6504 "originscale x y z : multiply origin of light (1 1 1 does nothing)\n"
6505 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
6506 "cubemap basename : set filter cubemap of light (not yet supported)\n"
6507 "shadows 1/0 : turn on/off shadows\n"
6508 "corona n : set corona intensity\n"
6509 "coronasize n : set corona size (0-1)\n"
6510 "ambient n : set ambient intensity (0-1)\n"
6511 "diffuse n : set diffuse intensity (0-1)\n"
6512 "specular n : set specular intensity (0-1)\n"
6513 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
6514 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
6515 "<nothing> : print light properties to console\n"
6519 static void R_Shadow_EditLights_CopyInfo_f(void)
6521 if (!r_editlights.integer)
6523 Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n");
6526 if (!r_shadow_selectedlight)
6528 Con_Print("No selected light.\n");
6531 VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
6532 VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
6533 r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
6534 r_shadow_bufferlight.style = r_shadow_selectedlight->style;
6535 if (r_shadow_selectedlight->cubemapname)
6536 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
6538 r_shadow_bufferlight.cubemapname[0] = 0;
6539 r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
6540 r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
6541 r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
6542 r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
6543 r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
6544 r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
6545 r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
6548 static void R_Shadow_EditLights_PasteInfo_f(void)
6550 if (!r_editlights.integer)
6552 Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n");
6555 if (!r_shadow_selectedlight)
6557 Con_Print("No selected light.\n");
6560 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);
6563 static void R_Shadow_EditLights_Lock_f(void)
6565 if (!r_editlights.integer)
6567 Con_Print("Cannot lock on light when not in editing mode. Set r_editlights to 1.\n");
6570 if (r_editlights_lockcursor)
6572 r_editlights_lockcursor = false;
6575 if (!r_shadow_selectedlight)
6577 Con_Print("No selected light to lock on.\n");
6580 r_editlights_lockcursor = true;
6583 static void R_Shadow_EditLights_Init(void)
6585 Cvar_RegisterVariable(&r_editlights);
6586 Cvar_RegisterVariable(&r_editlights_cursordistance);
6587 Cvar_RegisterVariable(&r_editlights_cursorpushback);
6588 Cvar_RegisterVariable(&r_editlights_cursorpushoff);
6589 Cvar_RegisterVariable(&r_editlights_cursorgrid);
6590 Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
6591 Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
6592 Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
6593 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)");
6594 Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
6595 Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
6596 Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
6597 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)");
6598 Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
6599 Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
6600 Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
6601 Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
6602 Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
6603 Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
6604 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)");
6605 Cmd_AddCommand("r_editlights_lock", R_Shadow_EditLights_Lock_f, "lock selection to current light, if already locked - unlock");
6611 =============================================================================
6615 =============================================================================
6618 void R_LightPoint(vec3_t color, const vec3_t p, const int flags)
6620 int i, numlights, flag;
6621 float f, relativepoint[3], dist, dist2, lightradius2;
6626 if (r_fullbright.integer)
6628 VectorSet(color, 1, 1, 1);
6634 if (flags & LP_LIGHTMAP)
6636 if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6638 VectorClear(diffuse);
6639 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, color, diffuse, n);
6640 VectorAdd(color, diffuse, color);
6643 VectorSet(color, 1, 1, 1);
6644 color[0] += r_refdef.scene.ambient;
6645 color[1] += r_refdef.scene.ambient;
6646 color[2] += r_refdef.scene.ambient;
6649 if (flags & LP_RTWORLD)
6651 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6652 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6653 for (i = 0; i < numlights; i++)
6655 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6658 light = &dlight->rtlight;
6659 if (!(light->flags & flag))
6662 lightradius2 = light->radius * light->radius;
6663 VectorSubtract(light->shadoworigin, p, relativepoint);
6664 dist2 = VectorLength2(relativepoint);
6665 if (dist2 >= lightradius2)
6667 dist = sqrt(dist2) / light->radius;
6668 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6671 // todo: add to both ambient and diffuse
6672 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6673 VectorMA(color, f, light->currentcolor, color);
6676 if (flags & LP_DYNLIGHT)
6679 for (i = 0;i < r_refdef.scene.numlights;i++)
6681 light = r_refdef.scene.lights[i];
6683 lightradius2 = light->radius * light->radius;
6684 VectorSubtract(light->shadoworigin, p, relativepoint);
6685 dist2 = VectorLength2(relativepoint);
6686 if (dist2 >= lightradius2)
6688 dist = sqrt(dist2) / light->radius;
6689 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6692 // todo: add to both ambient and diffuse
6693 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6694 VectorMA(color, f, light->color, color);
6699 void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags)
6701 int i, numlights, flag;
6704 float relativepoint[3];
6713 if (r_fullbright.integer)
6715 VectorSet(ambient, 1, 1, 1);
6716 VectorClear(diffuse);
6717 VectorClear(lightdir);
6721 if (flags == LP_LIGHTMAP)
6723 VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6724 VectorClear(diffuse);
6725 VectorClear(lightdir);
6726 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6727 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambient, diffuse, lightdir);
6729 VectorSet(ambient, 1, 1, 1);
6733 memset(sample, 0, sizeof(sample));
6734 VectorSet(sample, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6736 if ((flags & LP_LIGHTMAP) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6739 VectorClear(tempambient);
6741 VectorClear(relativepoint);
6742 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
6743 VectorScale(tempambient, r_refdef.lightmapintensity, tempambient);
6744 VectorScale(color, r_refdef.lightmapintensity, color);
6745 VectorAdd(sample, tempambient, sample);
6746 VectorMA(sample , 0.5f , color, sample );
6747 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6748 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6749 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6750 // calculate a weighted average light direction as well
6751 intensity = VectorLength(color);
6752 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6755 if (flags & LP_RTWORLD)
6757 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6758 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6759 for (i = 0; i < numlights; i++)
6761 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6764 light = &dlight->rtlight;
6765 if (!(light->flags & flag))
6768 lightradius2 = light->radius * light->radius;
6769 VectorSubtract(light->shadoworigin, p, relativepoint);
6770 dist2 = VectorLength2(relativepoint);
6771 if (dist2 >= lightradius2)
6773 dist = sqrt(dist2) / light->radius;
6774 intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value;
6775 if (intensity <= 0.0f)
6777 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6779 // scale down intensity to add to both ambient and diffuse
6780 //intensity *= 0.5f;
6781 VectorNormalize(relativepoint);
6782 VectorScale(light->currentcolor, intensity, color);
6783 VectorMA(sample , 0.5f , color, sample );
6784 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6785 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6786 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6787 // calculate a weighted average light direction as well
6788 intensity *= VectorLength(color);
6789 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6791 // FIXME: sample bouncegrid too!
6794 if (flags & LP_DYNLIGHT)
6797 for (i = 0;i < r_refdef.scene.numlights;i++)
6799 light = r_refdef.scene.lights[i];
6801 lightradius2 = light->radius * light->radius;
6802 VectorSubtract(light->shadoworigin, p, relativepoint);
6803 dist2 = VectorLength2(relativepoint);
6804 if (dist2 >= lightradius2)
6806 dist = sqrt(dist2) / light->radius;
6807 intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value;
6808 if (intensity <= 0.0f)
6810 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6812 // scale down intensity to add to both ambient and diffuse
6813 //intensity *= 0.5f;
6814 VectorNormalize(relativepoint);
6815 VectorScale(light->currentcolor, intensity, color);
6816 VectorMA(sample , 0.5f , color, sample );
6817 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6818 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6819 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6820 // calculate a weighted average light direction as well
6821 intensity *= VectorLength(color);
6822 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6826 // calculate the direction we'll use to reduce the sample to a directional light source
6827 VectorCopy(sample + 12, dir);
6828 //VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
6829 VectorNormalize(dir);
6830 // extract the diffuse color along the chosen direction and scale it
6831 diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]);
6832 diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]);
6833 diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]);
6834 // subtract some of diffuse from ambient
6835 VectorMA(sample, -0.333f, diffuse, ambient);
6836 // store the normalized lightdir
6837 VectorCopy(dir, lightdir);