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_shadowmap2dtexture;
248 rtexture_t *r_shadow_shadowmap2dcolortexture;
249 rtexture_t *r_shadow_shadowmapvsdcttexture;
250 int r_shadow_shadowmapsize; // changes for each light based on distance
251 int r_shadow_shadowmaplod; // changes for each light based on distance
253 GLuint r_shadow_prepassgeometryfbo;
254 GLuint r_shadow_prepasslightingdiffusespecularfbo;
255 GLuint r_shadow_prepasslightingdiffusefbo;
256 int r_shadow_prepass_width;
257 int r_shadow_prepass_height;
258 rtexture_t *r_shadow_prepassgeometrydepthtexture;
259 rtexture_t *r_shadow_prepassgeometrydepthcolortexture;
260 rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
261 rtexture_t *r_shadow_prepasslightingdiffusetexture;
262 rtexture_t *r_shadow_prepasslightingspeculartexture;
264 // keep track of the provided framebuffer info
265 static int r_shadow_fb_fbo;
266 static rtexture_t *r_shadow_fb_depthtexture;
267 static rtexture_t *r_shadow_fb_colortexture;
269 // lights are reloaded when this changes
270 char r_shadow_mapname[MAX_QPATH];
272 // used only for light filters (cubemaps)
273 rtexturepool_t *r_shadow_filters_texturepool;
276 static const GLenum r_shadow_prepasslightingdrawbuffers[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
279 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"};
280 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"};
281 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
282 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"};
283 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)"};
284 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
285 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)"};
286 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"};
287 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
288 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
289 cvar_t r_shadow_gloss2exponent = {0, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
290 cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
291 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
292 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
293 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
294 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
295 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "0", "how far to cast shadows"};
296 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)"};
297 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
298 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
299 cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
300 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
301 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)"};
302 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"};
303 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
304 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
305 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"};
306 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)"};
307 cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};
308 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)"};
309 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"};
310 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)"};
311 cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
312 cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
313 cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "shadowmap size limit"};
314 cvar_t r_shadow_shadowmapping_maxsize = {CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "shadowmap size limit"};
315 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"};
316 //cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
317 //cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
318 cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
319 cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
320 cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
321 cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
322 cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
323 cvar_t r_shadow_sortsurfaces = {0, "r_shadow_sortsurfaces", "1", "improve performance by sorting illuminated surfaces by texture"};
324 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
325 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)"};
326 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)"};
327 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)"};
328 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"};
329 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"};
330 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"};
331 cvar_t r_shadow_bouncegrid_hitmodels = {CVAR_SAVE, "r_shadow_bouncegrid_hitmodels", "0", "enables hitting character model geometry (SLOW)"};
332 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)"};
333 cvar_t r_shadow_bouncegrid_intensity = {CVAR_SAVE, "r_shadow_bouncegrid_intensity", "4", "overall brightness of bouncegrid texture"};
334 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)"};
335 cvar_t r_shadow_bouncegrid_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_maxbounce", "2", "maximum number of bounces for a particle (minimum is 0)"};
336 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"};
337 cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "1", "brightness of particles contributing to bouncegrid texture"};
338 cvar_t r_shadow_bouncegrid_photons = {CVAR_SAVE, "r_shadow_bouncegrid_photons", "2000", "total photons to shoot per update, divided proportionately between lights"};
339 cvar_t r_shadow_bouncegrid_spacing = {CVAR_SAVE, "r_shadow_bouncegrid_spacing", "64", "unit size of bouncegrid pixel"};
340 cvar_t r_shadow_bouncegrid_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_stablerandom", "1", "make particle distribution consistent from frame to frame"};
341 cvar_t r_shadow_bouncegrid_static = {CVAR_SAVE, "r_shadow_bouncegrid_static", "1", "use static radiosity solution (high quality) rather than dynamic (splotchy)"};
342 cvar_t r_shadow_bouncegrid_static_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when in static mode"};
343 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"};
344 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"};
345 cvar_t r_shadow_bouncegrid_static_photons = {CVAR_SAVE, "r_shadow_bouncegrid_static_photons", "25000", "photons value to use when in static mode"};
346 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"};
347 cvar_t r_shadow_bouncegrid_x = {CVAR_SAVE, "r_shadow_bouncegrid_x", "64", "maximum texture size of bouncegrid on X axis"};
348 cvar_t r_shadow_bouncegrid_y = {CVAR_SAVE, "r_shadow_bouncegrid_y", "64", "maximum texture size of bouncegrid on Y axis"};
349 cvar_t r_shadow_bouncegrid_z = {CVAR_SAVE, "r_shadow_bouncegrid_z", "32", "maximum texture size of bouncegrid on Z axis"};
350 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
351 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"};
352 cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
353 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
354 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
355 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
356 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
357 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
358 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
359 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
360 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
361 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
363 typedef struct r_shadow_bouncegrid_settings_s
366 qboolean bounceanglediffuse;
367 qboolean directionalshading;
368 qboolean includedirectlighting;
369 float dlightparticlemultiplier;
371 float lightradiusscale;
373 float particlebounceintensity;
374 float particleintensity;
379 r_shadow_bouncegrid_settings_t;
381 r_shadow_bouncegrid_settings_t r_shadow_bouncegridsettings;
382 rtexture_t *r_shadow_bouncegridtexture;
383 matrix4x4_t r_shadow_bouncegridmatrix;
384 vec_t r_shadow_bouncegridintensity;
385 qboolean r_shadow_bouncegriddirectional;
386 static double r_shadow_bouncegridtime;
387 static int r_shadow_bouncegridresolution[3];
388 static int r_shadow_bouncegridnumpixels;
389 static unsigned char *r_shadow_bouncegridpixels;
390 static float *r_shadow_bouncegridhighpixels;
392 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
393 #define ATTENTABLESIZE 256
394 // 1D gradient, 2D circle and 3D sphere attenuation textures
395 #define ATTEN1DSIZE 32
396 #define ATTEN2DSIZE 64
397 #define ATTEN3DSIZE 32
399 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
400 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
401 static float r_shadow_attentable[ATTENTABLESIZE+1];
403 rtlight_t *r_shadow_compilingrtlight;
404 static memexpandablearray_t r_shadow_worldlightsarray;
405 dlight_t *r_shadow_selectedlight;
406 dlight_t r_shadow_bufferlight;
407 vec3_t r_editlights_cursorlocation;
408 qboolean r_editlights_lockcursor;
410 extern int con_vislines;
412 void R_Shadow_UncompileWorldLights(void);
413 void R_Shadow_ClearWorldLights(void);
414 void R_Shadow_SaveWorldLights(void);
415 void R_Shadow_LoadWorldLights(void);
416 void R_Shadow_LoadLightsFile(void);
417 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
418 void R_Shadow_EditLights_Reload_f(void);
419 void R_Shadow_ValidateCvars(void);
420 static void R_Shadow_MakeTextures(void);
422 #define EDLIGHTSPRSIZE 8
423 skinframe_t *r_editlights_sprcursor;
424 skinframe_t *r_editlights_sprlight;
425 skinframe_t *r_editlights_sprnoshadowlight;
426 skinframe_t *r_editlights_sprcubemaplight;
427 skinframe_t *r_editlights_sprcubemapnoshadowlight;
428 skinframe_t *r_editlights_sprselection;
430 static void R_Shadow_SetShadowMode(void)
432 r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
433 r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20;
434 r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
435 r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
436 r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
437 r_shadow_shadowmaplod = -1;
438 r_shadow_shadowmapsize = 0;
439 r_shadow_shadowmapsampler = false;
440 r_shadow_shadowmappcf = 0;
441 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
442 if ((r_shadow_shadowmapping.integer || r_shadow_deferred.integer) && vid.support.ext_framebuffer_object)
444 switch(vid.renderpath)
446 case RENDERPATH_GL20:
447 if(r_shadow_shadowmapfilterquality < 0)
449 if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
450 r_shadow_shadowmappcf = 1;
451 else if(strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD"))
453 r_shadow_shadowmapsampler = vid.support.arb_shadow;
454 r_shadow_shadowmappcf = 1;
456 else if(strstr(gl_vendor, "ATI"))
457 r_shadow_shadowmappcf = 1;
459 r_shadow_shadowmapsampler = vid.support.arb_shadow;
463 switch (r_shadow_shadowmapfilterquality)
466 r_shadow_shadowmapsampler = vid.support.arb_shadow;
469 r_shadow_shadowmapsampler = vid.support.arb_shadow;
470 r_shadow_shadowmappcf = 1;
473 r_shadow_shadowmappcf = 1;
476 r_shadow_shadowmappcf = 2;
480 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
482 case RENDERPATH_D3D9:
483 case RENDERPATH_D3D10:
484 case RENDERPATH_D3D11:
485 case RENDERPATH_SOFT:
486 r_shadow_shadowmapsampler = false;
487 r_shadow_shadowmappcf = 1;
488 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
490 case RENDERPATH_GL11:
491 case RENDERPATH_GL13:
492 case RENDERPATH_GLES1:
493 case RENDERPATH_GLES2:
499 qboolean R_Shadow_ShadowMappingEnabled(void)
501 switch (r_shadow_shadowmode)
503 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
510 static void R_Shadow_FreeShadowMaps(void)
512 R_Shadow_SetShadowMode();
514 R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d);
518 if (r_shadow_shadowmap2dtexture)
519 R_FreeTexture(r_shadow_shadowmap2dtexture);
520 r_shadow_shadowmap2dtexture = NULL;
522 if (r_shadow_shadowmap2dcolortexture)
523 R_FreeTexture(r_shadow_shadowmap2dcolortexture);
524 r_shadow_shadowmap2dcolortexture = NULL;
526 if (r_shadow_shadowmapvsdcttexture)
527 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
528 r_shadow_shadowmapvsdcttexture = NULL;
531 static void r_shadow_start(void)
533 // allocate vertex processing arrays
534 r_shadow_bouncegridpixels = NULL;
535 r_shadow_bouncegridhighpixels = NULL;
536 r_shadow_bouncegridnumpixels = 0;
537 r_shadow_bouncegridtexture = NULL;
538 r_shadow_bouncegriddirectional = false;
539 r_shadow_attenuationgradienttexture = NULL;
540 r_shadow_attenuation2dtexture = NULL;
541 r_shadow_attenuation3dtexture = NULL;
542 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
543 r_shadow_shadowmap2dtexture = NULL;
544 r_shadow_shadowmap2dcolortexture = NULL;
545 r_shadow_shadowmapvsdcttexture = NULL;
546 r_shadow_shadowmapmaxsize = 0;
547 r_shadow_shadowmapsize = 0;
548 r_shadow_shadowmaplod = 0;
549 r_shadow_shadowmapfilterquality = -1;
550 r_shadow_shadowmapdepthbits = 0;
551 r_shadow_shadowmapvsdct = false;
552 r_shadow_shadowmapsampler = false;
553 r_shadow_shadowmappcf = 0;
556 R_Shadow_FreeShadowMaps();
558 r_shadow_texturepool = NULL;
559 r_shadow_filters_texturepool = NULL;
560 R_Shadow_ValidateCvars();
561 R_Shadow_MakeTextures();
562 maxshadowtriangles = 0;
563 shadowelements = NULL;
564 maxshadowvertices = 0;
565 shadowvertex3f = NULL;
573 shadowmarklist = NULL;
578 shadowsideslist = NULL;
579 r_shadow_buffer_numleafpvsbytes = 0;
580 r_shadow_buffer_visitingleafpvs = NULL;
581 r_shadow_buffer_leafpvs = NULL;
582 r_shadow_buffer_leaflist = NULL;
583 r_shadow_buffer_numsurfacepvsbytes = 0;
584 r_shadow_buffer_surfacepvs = NULL;
585 r_shadow_buffer_surfacelist = NULL;
586 r_shadow_buffer_surfacesides = NULL;
587 r_shadow_buffer_numshadowtrispvsbytes = 0;
588 r_shadow_buffer_shadowtrispvs = NULL;
589 r_shadow_buffer_numlighttrispvsbytes = 0;
590 r_shadow_buffer_lighttrispvs = NULL;
592 r_shadow_usingdeferredprepass = false;
593 r_shadow_prepass_width = r_shadow_prepass_height = 0;
596 static void R_Shadow_FreeDeferred(void);
597 static void r_shadow_shutdown(void)
600 R_Shadow_UncompileWorldLights();
602 R_Shadow_FreeShadowMaps();
604 r_shadow_usingdeferredprepass = false;
605 if (r_shadow_prepass_width)
606 R_Shadow_FreeDeferred();
607 r_shadow_prepass_width = r_shadow_prepass_height = 0;
610 r_shadow_bouncegridtexture = NULL;
611 r_shadow_bouncegridpixels = NULL;
612 r_shadow_bouncegridhighpixels = NULL;
613 r_shadow_bouncegridnumpixels = 0;
614 r_shadow_bouncegriddirectional = false;
615 r_shadow_attenuationgradienttexture = NULL;
616 r_shadow_attenuation2dtexture = NULL;
617 r_shadow_attenuation3dtexture = NULL;
618 R_FreeTexturePool(&r_shadow_texturepool);
619 R_FreeTexturePool(&r_shadow_filters_texturepool);
620 maxshadowtriangles = 0;
622 Mem_Free(shadowelements);
623 shadowelements = NULL;
625 Mem_Free(shadowvertex3f);
626 shadowvertex3f = NULL;
629 Mem_Free(vertexupdate);
632 Mem_Free(vertexremap);
638 Mem_Free(shadowmark);
641 Mem_Free(shadowmarklist);
642 shadowmarklist = NULL;
647 Mem_Free(shadowsides);
650 Mem_Free(shadowsideslist);
651 shadowsideslist = NULL;
652 r_shadow_buffer_numleafpvsbytes = 0;
653 if (r_shadow_buffer_visitingleafpvs)
654 Mem_Free(r_shadow_buffer_visitingleafpvs);
655 r_shadow_buffer_visitingleafpvs = NULL;
656 if (r_shadow_buffer_leafpvs)
657 Mem_Free(r_shadow_buffer_leafpvs);
658 r_shadow_buffer_leafpvs = NULL;
659 if (r_shadow_buffer_leaflist)
660 Mem_Free(r_shadow_buffer_leaflist);
661 r_shadow_buffer_leaflist = NULL;
662 r_shadow_buffer_numsurfacepvsbytes = 0;
663 if (r_shadow_buffer_surfacepvs)
664 Mem_Free(r_shadow_buffer_surfacepvs);
665 r_shadow_buffer_surfacepvs = NULL;
666 if (r_shadow_buffer_surfacelist)
667 Mem_Free(r_shadow_buffer_surfacelist);
668 r_shadow_buffer_surfacelist = NULL;
669 if (r_shadow_buffer_surfacesides)
670 Mem_Free(r_shadow_buffer_surfacesides);
671 r_shadow_buffer_surfacesides = NULL;
672 r_shadow_buffer_numshadowtrispvsbytes = 0;
673 if (r_shadow_buffer_shadowtrispvs)
674 Mem_Free(r_shadow_buffer_shadowtrispvs);
675 r_shadow_buffer_numlighttrispvsbytes = 0;
676 if (r_shadow_buffer_lighttrispvs)
677 Mem_Free(r_shadow_buffer_lighttrispvs);
680 static void r_shadow_newmap(void)
682 if (r_shadow_bouncegridtexture) R_FreeTexture(r_shadow_bouncegridtexture);r_shadow_bouncegridtexture = NULL;
683 if (r_shadow_lightcorona) R_SkinFrame_MarkUsed(r_shadow_lightcorona);
684 if (r_editlights_sprcursor) R_SkinFrame_MarkUsed(r_editlights_sprcursor);
685 if (r_editlights_sprlight) R_SkinFrame_MarkUsed(r_editlights_sprlight);
686 if (r_editlights_sprnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
687 if (r_editlights_sprcubemaplight) R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
688 if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
689 if (r_editlights_sprselection) R_SkinFrame_MarkUsed(r_editlights_sprselection);
690 if (strncmp(cl.worldname, r_shadow_mapname, sizeof(r_shadow_mapname)))
691 R_Shadow_EditLights_Reload_f();
694 void R_Shadow_Init(void)
696 Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
697 Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
698 Cvar_RegisterVariable(&r_shadow_usebihculling);
699 Cvar_RegisterVariable(&r_shadow_usenormalmap);
700 Cvar_RegisterVariable(&r_shadow_debuglight);
701 Cvar_RegisterVariable(&r_shadow_deferred);
702 Cvar_RegisterVariable(&r_shadow_gloss);
703 Cvar_RegisterVariable(&r_shadow_gloss2intensity);
704 Cvar_RegisterVariable(&r_shadow_glossintensity);
705 Cvar_RegisterVariable(&r_shadow_glossexponent);
706 Cvar_RegisterVariable(&r_shadow_gloss2exponent);
707 Cvar_RegisterVariable(&r_shadow_glossexact);
708 Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
709 Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
710 Cvar_RegisterVariable(&r_shadow_lightintensityscale);
711 Cvar_RegisterVariable(&r_shadow_lightradiusscale);
712 Cvar_RegisterVariable(&r_shadow_projectdistance);
713 Cvar_RegisterVariable(&r_shadow_frontsidecasting);
714 Cvar_RegisterVariable(&r_shadow_realtime_dlight);
715 Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
716 Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
717 Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
718 Cvar_RegisterVariable(&r_shadow_realtime_world);
719 Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
720 Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
721 Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
722 Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
723 Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
724 Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
725 Cvar_RegisterVariable(&r_shadow_scissor);
726 Cvar_RegisterVariable(&r_shadow_shadowmapping);
727 Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
728 Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
729 Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
730 Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
731 Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
732 Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
733 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
734 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
735 Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
736 Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
737 Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
738 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
739 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
740 Cvar_RegisterVariable(&r_shadow_sortsurfaces);
741 Cvar_RegisterVariable(&r_shadow_polygonfactor);
742 Cvar_RegisterVariable(&r_shadow_polygonoffset);
743 Cvar_RegisterVariable(&r_shadow_texture3d);
744 Cvar_RegisterVariable(&r_shadow_bouncegrid);
745 Cvar_RegisterVariable(&r_shadow_bouncegrid_bounceanglediffuse);
746 Cvar_RegisterVariable(&r_shadow_bouncegrid_directionalshading);
747 Cvar_RegisterVariable(&r_shadow_bouncegrid_dlightparticlemultiplier);
748 Cvar_RegisterVariable(&r_shadow_bouncegrid_hitmodels);
749 Cvar_RegisterVariable(&r_shadow_bouncegrid_includedirectlighting);
750 Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
751 Cvar_RegisterVariable(&r_shadow_bouncegrid_lightradiusscale);
752 Cvar_RegisterVariable(&r_shadow_bouncegrid_maxbounce);
753 Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
754 Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
755 Cvar_RegisterVariable(&r_shadow_bouncegrid_photons);
756 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacing);
757 Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom);
758 Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
759 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
760 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_lightradiusscale);
761 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxbounce);
762 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_photons);
763 Cvar_RegisterVariable(&r_shadow_bouncegrid_updateinterval);
764 Cvar_RegisterVariable(&r_shadow_bouncegrid_x);
765 Cvar_RegisterVariable(&r_shadow_bouncegrid_y);
766 Cvar_RegisterVariable(&r_shadow_bouncegrid_z);
767 Cvar_RegisterVariable(&r_coronas);
768 Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
769 Cvar_RegisterVariable(&r_coronas_occlusionquery);
770 Cvar_RegisterVariable(&gl_flashblend);
771 Cvar_RegisterVariable(&gl_ext_separatestencil);
772 Cvar_RegisterVariable(&gl_ext_stenciltwoside);
773 R_Shadow_EditLights_Init();
774 Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
775 maxshadowtriangles = 0;
776 shadowelements = NULL;
777 maxshadowvertices = 0;
778 shadowvertex3f = NULL;
786 shadowmarklist = NULL;
791 shadowsideslist = NULL;
792 r_shadow_buffer_numleafpvsbytes = 0;
793 r_shadow_buffer_visitingleafpvs = NULL;
794 r_shadow_buffer_leafpvs = NULL;
795 r_shadow_buffer_leaflist = NULL;
796 r_shadow_buffer_numsurfacepvsbytes = 0;
797 r_shadow_buffer_surfacepvs = NULL;
798 r_shadow_buffer_surfacelist = NULL;
799 r_shadow_buffer_surfacesides = NULL;
800 r_shadow_buffer_shadowtrispvs = NULL;
801 r_shadow_buffer_lighttrispvs = NULL;
802 R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
805 matrix4x4_t matrix_attenuationxyz =
808 {0.5, 0.0, 0.0, 0.5},
809 {0.0, 0.5, 0.0, 0.5},
810 {0.0, 0.0, 0.5, 0.5},
815 matrix4x4_t matrix_attenuationz =
818 {0.0, 0.0, 0.5, 0.5},
819 {0.0, 0.0, 0.0, 0.5},
820 {0.0, 0.0, 0.0, 0.5},
825 static void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
827 numvertices = ((numvertices + 255) & ~255) * vertscale;
828 numtriangles = ((numtriangles + 255) & ~255) * triscale;
829 // make sure shadowelements is big enough for this volume
830 if (maxshadowtriangles < numtriangles)
832 maxshadowtriangles = numtriangles;
834 Mem_Free(shadowelements);
835 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
837 // make sure shadowvertex3f is big enough for this volume
838 if (maxshadowvertices < numvertices)
840 maxshadowvertices = numvertices;
842 Mem_Free(shadowvertex3f);
843 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
847 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
849 int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
850 int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
851 int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
852 int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
853 if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
855 if (r_shadow_buffer_visitingleafpvs)
856 Mem_Free(r_shadow_buffer_visitingleafpvs);
857 if (r_shadow_buffer_leafpvs)
858 Mem_Free(r_shadow_buffer_leafpvs);
859 if (r_shadow_buffer_leaflist)
860 Mem_Free(r_shadow_buffer_leaflist);
861 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
862 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
863 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
864 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
866 if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
868 if (r_shadow_buffer_surfacepvs)
869 Mem_Free(r_shadow_buffer_surfacepvs);
870 if (r_shadow_buffer_surfacelist)
871 Mem_Free(r_shadow_buffer_surfacelist);
872 if (r_shadow_buffer_surfacesides)
873 Mem_Free(r_shadow_buffer_surfacesides);
874 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
875 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
876 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
877 r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
879 if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
881 if (r_shadow_buffer_shadowtrispvs)
882 Mem_Free(r_shadow_buffer_shadowtrispvs);
883 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
884 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
886 if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
888 if (r_shadow_buffer_lighttrispvs)
889 Mem_Free(r_shadow_buffer_lighttrispvs);
890 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
891 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
895 void R_Shadow_PrepareShadowMark(int numtris)
897 // make sure shadowmark is big enough for this volume
898 if (maxshadowmark < numtris)
900 maxshadowmark = numtris;
902 Mem_Free(shadowmark);
904 Mem_Free(shadowmarklist);
905 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
906 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
910 // if shadowmarkcount wrapped we clear the array and adjust accordingly
911 if (shadowmarkcount == 0)
914 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
919 void R_Shadow_PrepareShadowSides(int numtris)
921 if (maxshadowsides < numtris)
923 maxshadowsides = numtris;
925 Mem_Free(shadowsides);
927 Mem_Free(shadowsideslist);
928 shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
929 shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
934 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)
937 int outtriangles = 0, outvertices = 0;
940 float ratio, direction[3], projectvector[3];
942 if (projectdirection)
943 VectorScale(projectdirection, projectdistance, projectvector);
945 VectorClear(projectvector);
947 // create the vertices
948 if (projectdirection)
950 for (i = 0;i < numshadowmarktris;i++)
952 element = inelement3i + shadowmarktris[i] * 3;
953 for (j = 0;j < 3;j++)
955 if (vertexupdate[element[j]] != vertexupdatenum)
957 vertexupdate[element[j]] = vertexupdatenum;
958 vertexremap[element[j]] = outvertices;
959 vertex = invertex3f + element[j] * 3;
960 // project one copy of the vertex according to projectvector
961 VectorCopy(vertex, outvertex3f);
962 VectorAdd(vertex, projectvector, (outvertex3f + 3));
971 for (i = 0;i < numshadowmarktris;i++)
973 element = inelement3i + shadowmarktris[i] * 3;
974 for (j = 0;j < 3;j++)
976 if (vertexupdate[element[j]] != vertexupdatenum)
978 vertexupdate[element[j]] = vertexupdatenum;
979 vertexremap[element[j]] = outvertices;
980 vertex = invertex3f + element[j] * 3;
981 // project one copy of the vertex to the sphere radius of the light
982 // (FIXME: would projecting it to the light box be better?)
983 VectorSubtract(vertex, projectorigin, direction);
984 ratio = projectdistance / VectorLength(direction);
985 VectorCopy(vertex, outvertex3f);
986 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
994 if (r_shadow_frontsidecasting.integer)
996 for (i = 0;i < numshadowmarktris;i++)
998 int remappedelement[3];
1000 const int *neighbortriangle;
1002 markindex = shadowmarktris[i] * 3;
1003 element = inelement3i + markindex;
1004 neighbortriangle = inneighbor3i + markindex;
1005 // output the front and back triangles
1006 outelement3i[0] = vertexremap[element[0]];
1007 outelement3i[1] = vertexremap[element[1]];
1008 outelement3i[2] = vertexremap[element[2]];
1009 outelement3i[3] = vertexremap[element[2]] + 1;
1010 outelement3i[4] = vertexremap[element[1]] + 1;
1011 outelement3i[5] = vertexremap[element[0]] + 1;
1015 // output the sides (facing outward from this triangle)
1016 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1018 remappedelement[0] = vertexremap[element[0]];
1019 remappedelement[1] = vertexremap[element[1]];
1020 outelement3i[0] = remappedelement[1];
1021 outelement3i[1] = remappedelement[0];
1022 outelement3i[2] = remappedelement[0] + 1;
1023 outelement3i[3] = remappedelement[1];
1024 outelement3i[4] = remappedelement[0] + 1;
1025 outelement3i[5] = remappedelement[1] + 1;
1030 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1032 remappedelement[1] = vertexremap[element[1]];
1033 remappedelement[2] = vertexremap[element[2]];
1034 outelement3i[0] = remappedelement[2];
1035 outelement3i[1] = remappedelement[1];
1036 outelement3i[2] = remappedelement[1] + 1;
1037 outelement3i[3] = remappedelement[2];
1038 outelement3i[4] = remappedelement[1] + 1;
1039 outelement3i[5] = remappedelement[2] + 1;
1044 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1046 remappedelement[0] = vertexremap[element[0]];
1047 remappedelement[2] = vertexremap[element[2]];
1048 outelement3i[0] = remappedelement[0];
1049 outelement3i[1] = remappedelement[2];
1050 outelement3i[2] = remappedelement[2] + 1;
1051 outelement3i[3] = remappedelement[0];
1052 outelement3i[4] = remappedelement[2] + 1;
1053 outelement3i[5] = remappedelement[0] + 1;
1062 for (i = 0;i < numshadowmarktris;i++)
1064 int remappedelement[3];
1066 const int *neighbortriangle;
1068 markindex = shadowmarktris[i] * 3;
1069 element = inelement3i + markindex;
1070 neighbortriangle = inneighbor3i + markindex;
1071 // output the front and back triangles
1072 outelement3i[0] = vertexremap[element[2]];
1073 outelement3i[1] = vertexremap[element[1]];
1074 outelement3i[2] = vertexremap[element[0]];
1075 outelement3i[3] = vertexremap[element[0]] + 1;
1076 outelement3i[4] = vertexremap[element[1]] + 1;
1077 outelement3i[5] = vertexremap[element[2]] + 1;
1081 // output the sides (facing outward from this triangle)
1082 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1084 remappedelement[0] = vertexremap[element[0]];
1085 remappedelement[1] = vertexremap[element[1]];
1086 outelement3i[0] = remappedelement[0];
1087 outelement3i[1] = remappedelement[1];
1088 outelement3i[2] = remappedelement[1] + 1;
1089 outelement3i[3] = remappedelement[0];
1090 outelement3i[4] = remappedelement[1] + 1;
1091 outelement3i[5] = remappedelement[0] + 1;
1096 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1098 remappedelement[1] = vertexremap[element[1]];
1099 remappedelement[2] = vertexremap[element[2]];
1100 outelement3i[0] = remappedelement[1];
1101 outelement3i[1] = remappedelement[2];
1102 outelement3i[2] = remappedelement[2] + 1;
1103 outelement3i[3] = remappedelement[1];
1104 outelement3i[4] = remappedelement[2] + 1;
1105 outelement3i[5] = remappedelement[1] + 1;
1110 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1112 remappedelement[0] = vertexremap[element[0]];
1113 remappedelement[2] = vertexremap[element[2]];
1114 outelement3i[0] = remappedelement[2];
1115 outelement3i[1] = remappedelement[0];
1116 outelement3i[2] = remappedelement[0] + 1;
1117 outelement3i[3] = remappedelement[2];
1118 outelement3i[4] = remappedelement[0] + 1;
1119 outelement3i[5] = remappedelement[2] + 1;
1127 *outnumvertices = outvertices;
1128 return outtriangles;
1131 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)
1134 int outtriangles = 0, outvertices = 0;
1136 const float *vertex;
1137 float ratio, direction[3], projectvector[3];
1140 if (projectdirection)
1141 VectorScale(projectdirection, projectdistance, projectvector);
1143 VectorClear(projectvector);
1145 for (i = 0;i < numshadowmarktris;i++)
1147 int remappedelement[3];
1149 const int *neighbortriangle;
1151 markindex = shadowmarktris[i] * 3;
1152 neighbortriangle = inneighbor3i + markindex;
1153 side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
1154 side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
1155 side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
1156 if (side[0] + side[1] + side[2] == 0)
1160 element = inelement3i + markindex;
1162 // create the vertices
1163 for (j = 0;j < 3;j++)
1165 if (side[j] + side[j+1] == 0)
1168 if (vertexupdate[k] != vertexupdatenum)
1170 vertexupdate[k] = vertexupdatenum;
1171 vertexremap[k] = outvertices;
1172 vertex = invertex3f + k * 3;
1173 VectorCopy(vertex, outvertex3f);
1174 if (projectdirection)
1176 // project one copy of the vertex according to projectvector
1177 VectorAdd(vertex, projectvector, (outvertex3f + 3));
1181 // project one copy of the vertex to the sphere radius of the light
1182 // (FIXME: would projecting it to the light box be better?)
1183 VectorSubtract(vertex, projectorigin, direction);
1184 ratio = projectdistance / VectorLength(direction);
1185 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
1192 // output the sides (facing outward from this triangle)
1195 remappedelement[0] = vertexremap[element[0]];
1196 remappedelement[1] = vertexremap[element[1]];
1197 outelement3i[0] = remappedelement[1];
1198 outelement3i[1] = remappedelement[0];
1199 outelement3i[2] = remappedelement[0] + 1;
1200 outelement3i[3] = remappedelement[1];
1201 outelement3i[4] = remappedelement[0] + 1;
1202 outelement3i[5] = remappedelement[1] + 1;
1209 remappedelement[1] = vertexremap[element[1]];
1210 remappedelement[2] = vertexremap[element[2]];
1211 outelement3i[0] = remappedelement[2];
1212 outelement3i[1] = remappedelement[1];
1213 outelement3i[2] = remappedelement[1] + 1;
1214 outelement3i[3] = remappedelement[2];
1215 outelement3i[4] = remappedelement[1] + 1;
1216 outelement3i[5] = remappedelement[2] + 1;
1223 remappedelement[0] = vertexremap[element[0]];
1224 remappedelement[2] = vertexremap[element[2]];
1225 outelement3i[0] = remappedelement[0];
1226 outelement3i[1] = remappedelement[2];
1227 outelement3i[2] = remappedelement[2] + 1;
1228 outelement3i[3] = remappedelement[0];
1229 outelement3i[4] = remappedelement[2] + 1;
1230 outelement3i[5] = remappedelement[0] + 1;
1237 *outnumvertices = outvertices;
1238 return outtriangles;
1241 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)
1247 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1249 tend = firsttriangle + numtris;
1250 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1252 // surface box entirely inside light box, no box cull
1253 if (projectdirection)
1255 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1257 TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal);
1258 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1259 shadowmarklist[numshadowmark++] = t;
1264 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1265 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
1266 shadowmarklist[numshadowmark++] = t;
1271 // surface box not entirely inside light box, cull each triangle
1272 if (projectdirection)
1274 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1276 v[0] = invertex3f + e[0] * 3;
1277 v[1] = invertex3f + e[1] * 3;
1278 v[2] = invertex3f + e[2] * 3;
1279 TriangleNormal(v[0], v[1], v[2], normal);
1280 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1281 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1282 shadowmarklist[numshadowmark++] = t;
1287 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1289 v[0] = invertex3f + e[0] * 3;
1290 v[1] = invertex3f + e[1] * 3;
1291 v[2] = invertex3f + e[2] * 3;
1292 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1293 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1294 shadowmarklist[numshadowmark++] = t;
1300 static qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
1305 if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
1307 // check if the shadow volume intersects the near plane
1309 // a ray between the eye and light origin may intersect the caster,
1310 // indicating that the shadow may touch the eye location, however we must
1311 // test the near plane (a polygon), not merely the eye location, so it is
1312 // easiest to enlarge the caster bounding shape slightly for this.
1318 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)
1320 int i, tris, outverts;
1321 if (projectdistance < 0.1)
1323 Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
1326 if (!numverts || !nummarktris)
1328 // make sure shadowelements is big enough for this volume
1329 if (maxshadowtriangles < nummarktris*8 || maxshadowvertices < numverts*2)
1330 R_Shadow_ResizeShadowArrays(numverts, nummarktris, 2, 8);
1332 if (maxvertexupdate < numverts)
1334 maxvertexupdate = numverts;
1336 Mem_Free(vertexupdate);
1338 Mem_Free(vertexremap);
1339 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1340 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1341 vertexupdatenum = 0;
1344 if (vertexupdatenum == 0)
1346 vertexupdatenum = 1;
1347 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
1348 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
1351 for (i = 0;i < nummarktris;i++)
1352 shadowmark[marktris[i]] = shadowmarkcount;
1354 if (r_shadow_compilingrtlight)
1356 // if we're compiling an rtlight, capture the mesh
1357 //tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1358 //Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1359 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1360 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1362 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
1364 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1365 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1366 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1370 // decide which type of shadow to generate and set stencil mode
1371 R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
1372 // generate the sides or a solid volume, depending on type
1373 if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
1374 tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1376 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1377 r_refdef.stats.lights_dynamicshadowtriangles += tris;
1378 r_refdef.stats.lights_shadowtriangles += tris;
1379 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
1381 // increment stencil if frontface is infront of depthbuffer
1382 GL_CullFace(r_refdef.view.cullface_front);
1383 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
1384 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1385 // decrement stencil if backface is infront of depthbuffer
1386 GL_CullFace(r_refdef.view.cullface_back);
1387 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
1389 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
1391 // decrement stencil if backface is behind depthbuffer
1392 GL_CullFace(r_refdef.view.cullface_front);
1393 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
1394 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1395 // increment stencil if frontface is behind depthbuffer
1396 GL_CullFace(r_refdef.view.cullface_back);
1397 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
1399 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1400 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1404 int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
1406 // p1, p2, p3 are in the cubemap's local coordinate system
1407 // bias = border/(size - border)
1410 float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1411 dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
1412 dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
1413 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1415 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1416 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1417 | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1418 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1420 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1421 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1422 | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1424 dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1425 dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
1426 dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
1427 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1429 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1430 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1431 | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1432 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1434 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1435 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1436 | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1438 dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1439 dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
1440 dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
1441 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1443 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1444 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1445 | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1446 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1448 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1449 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1450 | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1455 static int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
1457 vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
1458 float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
1461 VectorSubtract(maxs, mins, radius);
1462 VectorScale(radius, 0.5f, radius);
1463 VectorAdd(mins, radius, center);
1464 Matrix4x4_Transform(worldtolight, center, lightcenter);
1465 Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
1466 VectorSubtract(lightcenter, lightradius, pmin);
1467 VectorAdd(lightcenter, lightradius, pmax);
1469 dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1470 dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
1471 if(ap1 > bias*an1 && ap2 > bias*an2)
1473 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1474 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1475 if(an1 > bias*ap1 && an2 > bias*ap2)
1477 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1478 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1480 dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1481 dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
1482 if(ap1 > bias*an1 && ap2 > bias*an2)
1484 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1485 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1486 if(an1 > bias*ap1 && an2 > bias*ap2)
1488 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1489 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1491 dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1492 dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
1493 if(ap1 > bias*an1 && ap2 > bias*an2)
1495 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1496 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1497 if(an1 > bias*ap1 && an2 > bias*ap2)
1499 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1500 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1505 #define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
1507 int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
1509 // p is in the cubemap's local coordinate system
1510 // bias = border/(size - border)
1511 float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
1512 float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
1513 float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
1515 if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
1516 if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
1517 if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
1518 if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
1519 if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
1520 if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
1524 static int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
1528 int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
1529 float scale = (size - 2*border)/size, len;
1530 float bias = border / (float)(size - border), dp, dn, ap, an;
1531 // check if cone enclosing side would cross frustum plane
1532 scale = 2 / (scale*scale + 2);
1533 for (i = 0;i < 5;i++)
1535 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) > -0.03125)
1537 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
1538 len = scale*VectorLength2(n);
1539 if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
1540 if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
1541 if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
1543 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
1545 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
1546 len = scale*VectorLength(n);
1547 if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
1548 if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
1549 if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
1551 // this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
1552 // check if frustum corners/origin cross plane sides
1554 // infinite version, assumes frustum corners merely give direction and extend to infinite distance
1555 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.origin, p);
1556 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1557 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1558 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1559 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1560 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1561 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1562 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1563 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1564 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1565 for (i = 0;i < 4;i++)
1567 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.frustumcorner[i], n);
1568 VectorSubtract(n, p, n);
1569 dp = n[0] + n[1], dn = n[0] - n[1], ap = fabs(dp), an = fabs(dn);
1570 if(ap > 0) masks[0] |= dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2);
1571 if(an > 0) masks[1] |= dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2);
1572 dp = n[1] + n[2], dn = n[1] - n[2], ap = fabs(dp), an = fabs(dn);
1573 if(ap > 0) masks[2] |= dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4);
1574 if(an > 0) masks[3] |= dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4);
1575 dp = n[2] + n[0], dn = n[2] - n[0], ap = fabs(dp), an = fabs(dn);
1576 if(ap > 0) masks[4] |= dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0);
1577 if(an > 0) masks[5] |= dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0);
1580 // finite version, assumes corners are a finite distance from origin dependent on far plane
1581 for (i = 0;i < 5;i++)
1583 Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
1584 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1585 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1586 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1587 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1588 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1589 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1590 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1591 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1592 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1595 return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
1598 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)
1606 int mask, surfacemask = 0;
1607 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1609 bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
1610 tend = firsttriangle + numtris;
1611 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1613 // surface box entirely inside light box, no box cull
1614 if (projectdirection)
1616 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1618 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1619 TriangleNormal(v[0], v[1], v[2], normal);
1620 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1622 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1623 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1624 surfacemask |= mask;
1627 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;
1628 shadowsides[numshadowsides] = mask;
1629 shadowsideslist[numshadowsides++] = t;
1636 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1638 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1639 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
1641 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1642 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1643 surfacemask |= mask;
1646 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;
1647 shadowsides[numshadowsides] = mask;
1648 shadowsideslist[numshadowsides++] = t;
1656 // surface box not entirely inside light box, cull each triangle
1657 if (projectdirection)
1659 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1661 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1662 TriangleNormal(v[0], v[1], v[2], normal);
1663 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1664 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1666 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1667 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1668 surfacemask |= mask;
1671 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;
1672 shadowsides[numshadowsides] = mask;
1673 shadowsideslist[numshadowsides++] = t;
1680 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1682 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1683 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1684 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1686 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1687 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1688 surfacemask |= mask;
1691 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;
1692 shadowsides[numshadowsides] = mask;
1693 shadowsideslist[numshadowsides++] = t;
1702 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)
1704 int i, j, outtriangles = 0;
1705 int *outelement3i[6];
1706 if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
1708 outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
1709 // make sure shadowelements is big enough for this mesh
1710 if (maxshadowtriangles < outtriangles)
1711 R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
1713 // compute the offset and size of the separate index lists for each cubemap side
1715 for (i = 0;i < 6;i++)
1717 outelement3i[i] = shadowelements + outtriangles * 3;
1718 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
1719 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
1720 outtriangles += sidetotals[i];
1723 // gather up the (sparse) triangles into separate index lists for each cubemap side
1724 for (i = 0;i < numsidetris;i++)
1726 const int *element = elements + sidetris[i] * 3;
1727 for (j = 0;j < 6;j++)
1729 if (sides[i] & (1 << j))
1731 outelement3i[j][0] = element[0];
1732 outelement3i[j][1] = element[1];
1733 outelement3i[j][2] = element[2];
1734 outelement3i[j] += 3;
1739 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, outtriangles, shadowelements);
1742 static void R_Shadow_MakeTextures_MakeCorona(void)
1746 unsigned char pixels[32][32][4];
1747 for (y = 0;y < 32;y++)
1749 dy = (y - 15.5f) * (1.0f / 16.0f);
1750 for (x = 0;x < 32;x++)
1752 dx = (x - 15.5f) * (1.0f / 16.0f);
1753 a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1754 a = bound(0, a, 255);
1755 pixels[y][x][0] = a;
1756 pixels[y][x][1] = a;
1757 pixels[y][x][2] = a;
1758 pixels[y][x][3] = 255;
1761 r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32, false);
1764 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1766 float dist = sqrt(x*x+y*y+z*z);
1767 float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1768 // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1769 return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1772 static void R_Shadow_MakeTextures(void)
1775 float intensity, dist;
1777 R_Shadow_FreeShadowMaps();
1778 R_FreeTexturePool(&r_shadow_texturepool);
1779 r_shadow_texturepool = R_AllocTexturePool();
1780 r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1781 r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1782 data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1783 // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1784 for (x = 0;x <= ATTENTABLESIZE;x++)
1786 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1787 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1788 r_shadow_attentable[x] = bound(0, intensity, 1);
1790 // 1D gradient texture
1791 for (x = 0;x < ATTEN1DSIZE;x++)
1792 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1793 r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1794 // 2D circle texture
1795 for (y = 0;y < ATTEN2DSIZE;y++)
1796 for (x = 0;x < ATTEN2DSIZE;x++)
1797 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);
1798 r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1799 // 3D sphere texture
1800 if (r_shadow_texture3d.integer && vid.support.ext_texture_3d)
1802 for (z = 0;z < ATTEN3DSIZE;z++)
1803 for (y = 0;y < ATTEN3DSIZE;y++)
1804 for (x = 0;x < ATTEN3DSIZE;x++)
1805 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));
1806 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);
1809 r_shadow_attenuation3dtexture = NULL;
1812 R_Shadow_MakeTextures_MakeCorona();
1814 // Editor light sprites
1815 r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1832 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1833 r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1850 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1851 r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1868 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1869 r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1886 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1887 r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1904 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1905 r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
1922 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1925 void R_Shadow_ValidateCvars(void)
1927 if (r_shadow_texture3d.integer && !vid.support.ext_texture_3d)
1928 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
1929 if (gl_ext_separatestencil.integer && !vid.support.ati_separate_stencil)
1930 Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
1931 if (gl_ext_stenciltwoside.integer && !vid.support.ext_stencil_two_side)
1932 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
1935 void R_Shadow_RenderMode_Begin(void)
1941 R_Shadow_ValidateCvars();
1943 if (!r_shadow_attenuation2dtexture
1944 || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
1945 || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1946 || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1947 R_Shadow_MakeTextures();
1950 R_Mesh_ResetTextureState();
1951 GL_BlendFunc(GL_ONE, GL_ZERO);
1952 GL_DepthRange(0, 1);
1953 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1955 GL_DepthMask(false);
1956 GL_Color(0, 0, 0, 1);
1957 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
1959 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1961 if (gl_ext_separatestencil.integer && vid.support.ati_separate_stencil)
1963 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
1964 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
1966 else if (gl_ext_stenciltwoside.integer && vid.support.ext_stencil_two_side)
1968 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
1969 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
1973 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
1974 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
1977 switch(vid.renderpath)
1979 case RENDERPATH_GL20:
1980 case RENDERPATH_D3D9:
1981 case RENDERPATH_D3D10:
1982 case RENDERPATH_D3D11:
1983 case RENDERPATH_SOFT:
1984 case RENDERPATH_GLES2:
1985 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1987 case RENDERPATH_GL11:
1988 case RENDERPATH_GL13:
1989 case RENDERPATH_GLES1:
1990 if (r_textureunits.integer >= 2 && vid.texunits >= 2 && r_shadow_texture3d.integer && r_shadow_attenuation3dtexture)
1991 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN;
1992 else if (r_textureunits.integer >= 3 && vid.texunits >= 3)
1993 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN;
1994 else if (r_textureunits.integer >= 2 && vid.texunits >= 2)
1995 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN;
1997 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
2003 qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
2004 qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
2005 r_shadow_drawbuffer = drawbuffer;
2006 r_shadow_readbuffer = readbuffer;
2008 r_shadow_cullface_front = r_refdef.view.cullface_front;
2009 r_shadow_cullface_back = r_refdef.view.cullface_back;
2012 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
2014 rsurface.rtlight = rtlight;
2017 void R_Shadow_RenderMode_Reset(void)
2019 R_Mesh_ResetTextureState();
2020 R_Mesh_SetRenderTargets(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture, NULL, NULL, NULL);
2021 R_SetViewport(&r_refdef.view.viewport);
2022 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
2023 GL_DepthRange(0, 1);
2025 GL_DepthMask(false);
2026 GL_DepthFunc(GL_LEQUAL);
2027 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
2028 r_refdef.view.cullface_front = r_shadow_cullface_front;
2029 r_refdef.view.cullface_back = r_shadow_cullface_back;
2030 GL_CullFace(r_refdef.view.cullface_back);
2031 GL_Color(1, 1, 1, 1);
2032 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
2033 GL_BlendFunc(GL_ONE, GL_ZERO);
2034 R_SetupShader_Generic_NoTexture(false, false);
2035 r_shadow_usingshadowmap2d = false;
2036 r_shadow_usingshadowmaportho = false;
2037 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2040 void R_Shadow_ClearStencil(void)
2042 GL_Clear(GL_STENCIL_BUFFER_BIT, NULL, 1.0f, 128);
2043 r_refdef.stats.lights_clears++;
2046 void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
2048 r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
2049 if (r_shadow_rendermode == mode)
2051 R_Shadow_RenderMode_Reset();
2052 GL_DepthFunc(GL_LESS);
2053 GL_ColorMask(0, 0, 0, 0);
2054 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2055 GL_CullFace(GL_NONE);
2056 R_SetupShader_DepthOrShadow(false);
2057 r_shadow_rendermode = mode;
2062 case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
2063 case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
2064 R_SetStencilSeparate(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, GL_ALWAYS, 128, 255);
2066 case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
2067 case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
2068 R_SetStencilSeparate(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, GL_ALWAYS, 128, 255);
2073 static void R_Shadow_MakeVSDCT(void)
2075 // maps to a 2x3 texture rectangle with normalized coordinates
2080 // stores abs(dir.xy), offset.xy/2.5
2081 unsigned char data[4*6] =
2083 255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
2084 255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
2085 0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
2086 0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
2087 0, 0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
2088 0, 0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
2090 r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2093 static void R_Shadow_MakeShadowMap(int side, int size)
2095 switch (r_shadow_shadowmode)
2097 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
2098 if (r_shadow_shadowmap2dtexture) return;
2099 r_shadow_shadowmap2dtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler, false);
2100 r_shadow_shadowmap2dcolortexture = NULL;
2101 switch(vid.renderpath)
2104 case RENDERPATH_D3D9:
2105 r_shadow_shadowmap2dcolortexture = R_LoadTexture2D(r_shadow_texturepool, "shadowmaprendertarget", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), NULL, TEXTYPE_BGRA, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2106 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
2110 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, NULL, NULL, NULL, NULL);
2119 // render depth into the fbo, do not render color at all
2120 // validate the fbo now
2124 qglDrawBuffer(GL_NONE);CHECKGLERROR
2125 qglReadBuffer(GL_NONE);CHECKGLERROR
2126 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER);CHECKGLERROR
2127 if (status != GL_FRAMEBUFFER_COMPLETE && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2129 Con_Printf("R_Shadow_MakeShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2130 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2131 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2137 static void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size)
2139 float nearclip, farclip, bias;
2140 r_viewport_t viewport;
2143 float clearcolor[4];
2144 nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
2146 bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
2147 r_shadow_shadowmap_parameters[1] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
2148 r_shadow_shadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
2149 r_shadow_shadowmapside = side;
2150 r_shadow_shadowmapsize = size;
2152 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2153 r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2154 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2155 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
2157 // complex unrolled cube approach (more flexible)
2158 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2159 R_Shadow_MakeVSDCT();
2160 if (!r_shadow_shadowmap2dtexture)
2161 R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize);
2162 if (r_shadow_shadowmap2dtexture) fbo2d = r_shadow_fbo2d;
2163 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
2164 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
2165 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2167 R_Mesh_ResetTextureState();
2168 R_Shadow_RenderMode_Reset();
2169 R_Mesh_SetRenderTargets(fbo2d, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
2170 R_SetupShader_DepthOrShadow(true);
2171 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2176 R_SetViewport(&viewport);
2177 flipped = (side & 1) ^ (side >> 2);
2178 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2179 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2180 switch(vid.renderpath)
2182 case RENDERPATH_GL11:
2183 case RENDERPATH_GL13:
2184 case RENDERPATH_GL20:
2185 case RENDERPATH_SOFT:
2186 case RENDERPATH_GLES1:
2187 case RENDERPATH_GLES2:
2188 GL_CullFace(r_refdef.view.cullface_back);
2189 // OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once
2190 if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask
2192 // get tightest scissor rectangle that encloses all viewports in the clear mask
2193 int x1 = clear & 0x15 ? 0 : size;
2194 int x2 = clear & 0x2A ? 2 * size : size;
2195 int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size);
2196 int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size);
2197 GL_Scissor(x1, y1, x2 - x1, y2 - y1);
2198 GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
2200 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2202 case RENDERPATH_D3D9:
2203 case RENDERPATH_D3D10:
2204 case RENDERPATH_D3D11:
2205 Vector4Set(clearcolor, 1,1,1,1);
2206 // completely different meaning than in OpenGL path
2207 r_shadow_shadowmap_parameters[1] = 0;
2208 r_shadow_shadowmap_parameters[3] = -bias;
2209 // we invert the cull mode because we flip the projection matrix
2210 // NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided...
2211 GL_CullFace(r_refdef.view.cullface_front);
2212 // D3D considers it an error to use a scissor larger than the viewport... clear just this view
2213 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2214 if (r_shadow_shadowmapsampler)
2216 GL_ColorMask(0,0,0,0);
2218 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
2222 GL_ColorMask(1,1,1,1);
2224 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
2230 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2232 R_Mesh_ResetTextureState();
2235 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2236 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2237 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2238 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2240 R_Shadow_RenderMode_Reset();
2241 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2243 GL_DepthFunc(GL_EQUAL);
2244 // do global setup needed for the chosen lighting mode
2245 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2246 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2247 r_shadow_usingshadowmap2d = shadowmapping;
2248 r_shadow_rendermode = r_shadow_lightingrendermode;
2249 // only draw light where this geometry was already rendered AND the
2250 // stencil is 128 (values other than this mean shadow)
2252 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2254 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2257 static const unsigned short bboxelements[36] =
2267 static const float bboxpoints[8][3] =
2279 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2282 float vertex3f[8*3];
2283 const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2284 // do global setup needed for the chosen lighting mode
2285 R_Shadow_RenderMode_Reset();
2286 r_shadow_rendermode = r_shadow_lightingrendermode;
2287 R_EntityMatrix(&identitymatrix);
2288 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2289 // only draw light where this geometry was already rendered AND the
2290 // stencil is 128 (values other than this mean shadow)
2291 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2292 if (rsurface.rtlight->specularscale > 0 && r_shadow_gloss.integer > 0)
2293 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
2295 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
2297 r_shadow_usingshadowmap2d = shadowmapping;
2299 // render the lighting
2300 R_SetupShader_DeferredLight(rsurface.rtlight);
2301 for (i = 0;i < 8;i++)
2302 Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2303 GL_ColorMask(1,1,1,1);
2304 GL_DepthMask(false);
2305 GL_DepthRange(0, 1);
2306 GL_PolygonOffset(0, 0);
2308 GL_DepthFunc(GL_GREATER);
2309 GL_CullFace(r_refdef.view.cullface_back);
2310 R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL);
2311 R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
2314 void R_Shadow_UpdateBounceGridTexture(void)
2316 #define MAXBOUNCEGRIDPARTICLESPERLIGHT 1048576
2318 int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2320 int hitsupercontentsmask;
2329 //trace_t cliptrace2;
2330 //trace_t cliptrace3;
2331 unsigned char *pixel;
2332 unsigned char *pixels;
2335 unsigned int lightindex;
2337 unsigned int range1;
2338 unsigned int range2;
2339 unsigned int seed = (unsigned int)(realtime * 1000.0f);
2341 vec3_t baseshotcolor;
2354 vec3_t cullmins, cullmaxs;
2357 vec_t lightintensity;
2358 vec_t photonscaling;
2359 vec_t photonresidual;
2361 float texlerp[2][3];
2362 float splatcolor[32];
2363 float pixelweight[8];
2375 r_shadow_bouncegrid_settings_t settings;
2376 qboolean enable = r_shadow_bouncegrid.integer != 0 && r_refdef.scene.worldmodel;
2377 qboolean allowdirectionalshading = false;
2378 switch(vid.renderpath)
2380 case RENDERPATH_GL20:
2381 allowdirectionalshading = true;
2382 if (!vid.support.ext_texture_3d)
2385 case RENDERPATH_GLES2:
2386 // for performance reasons, do not use directional shading on GLES devices
2387 if (!vid.support.ext_texture_3d)
2390 // these renderpaths do not currently have the code to display the bouncegrid, so disable it on them...
2391 case RENDERPATH_GL11:
2392 case RENDERPATH_GL13:
2393 case RENDERPATH_GLES1:
2394 case RENDERPATH_SOFT:
2395 case RENDERPATH_D3D9:
2396 case RENDERPATH_D3D10:
2397 case RENDERPATH_D3D11:
2401 r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value;
2403 // see if there are really any lights to render...
2404 if (enable && r_shadow_bouncegrid_static.integer)
2407 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2408 for (lightindex = 0;lightindex < range;lightindex++)
2410 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2411 if (!light || !(light->flags & flag))
2413 rtlight = &light->rtlight;
2414 // when static, we skip styled lights because they tend to change...
2415 if (rtlight->style > 0)
2417 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale), lightcolor);
2418 if (!VectorLength2(lightcolor))
2427 if (r_shadow_bouncegridtexture)
2429 R_FreeTexture(r_shadow_bouncegridtexture);
2430 r_shadow_bouncegridtexture = NULL;
2432 if (r_shadow_bouncegridpixels)
2433 Mem_Free(r_shadow_bouncegridpixels);
2434 r_shadow_bouncegridpixels = NULL;
2435 if (r_shadow_bouncegridhighpixels)
2436 Mem_Free(r_shadow_bouncegridhighpixels);
2437 r_shadow_bouncegridhighpixels = NULL;
2438 r_shadow_bouncegridnumpixels = 0;
2439 r_shadow_bouncegriddirectional = false;
2443 // build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
2444 memset(&settings, 0, sizeof(settings));
2445 settings.staticmode = r_shadow_bouncegrid_static.integer != 0;
2446 settings.bounceanglediffuse = r_shadow_bouncegrid_bounceanglediffuse.integer != 0;
2447 settings.directionalshading = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_directionalshading.integer != 0) && allowdirectionalshading;
2448 settings.dlightparticlemultiplier = r_shadow_bouncegrid_dlightparticlemultiplier.value;
2449 settings.hitmodels = r_shadow_bouncegrid_hitmodels.integer != 0;
2450 settings.includedirectlighting = r_shadow_bouncegrid_includedirectlighting.integer != 0 || r_shadow_bouncegrid.integer == 2;
2451 settings.lightradiusscale = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_lightradiusscale.value : r_shadow_bouncegrid_lightradiusscale.value);
2452 settings.maxbounce = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_maxbounce.integer : r_shadow_bouncegrid_maxbounce.integer);
2453 settings.particlebounceintensity = r_shadow_bouncegrid_particlebounceintensity.value;
2454 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);
2455 settings.photons = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_photons.integer : r_shadow_bouncegrid_photons.integer;
2456 settings.spacing[0] = r_shadow_bouncegrid_spacing.value;
2457 settings.spacing[1] = r_shadow_bouncegrid_spacing.value;
2458 settings.spacing[2] = r_shadow_bouncegrid_spacing.value;
2459 settings.stablerandom = r_shadow_bouncegrid_stablerandom.integer;
2461 // bound the values for sanity
2462 settings.photons = bound(1, settings.photons, 1048576);
2463 settings.lightradiusscale = bound(0.0001f, settings.lightradiusscale, 1024.0f);
2464 settings.maxbounce = bound(0, settings.maxbounce, 16);
2465 settings.spacing[0] = bound(1, settings.spacing[0], 512);
2466 settings.spacing[1] = bound(1, settings.spacing[1], 512);
2467 settings.spacing[2] = bound(1, settings.spacing[2], 512);
2469 // get the spacing values
2470 spacing[0] = settings.spacing[0];
2471 spacing[1] = settings.spacing[1];
2472 spacing[2] = settings.spacing[2];
2473 ispacing[0] = 1.0f / spacing[0];
2474 ispacing[1] = 1.0f / spacing[1];
2475 ispacing[2] = 1.0f / spacing[2];
2477 // calculate texture size enclosing entire world bounds at the spacing
2478 VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
2479 VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
2480 VectorSubtract(maxs, mins, size);
2481 // now we can calculate the resolution we want
2482 c[0] = (int)floor(size[0] / spacing[0] + 0.5f);
2483 c[1] = (int)floor(size[1] / spacing[1] + 0.5f);
2484 c[2] = (int)floor(size[2] / spacing[2] + 0.5f);
2485 // figure out the exact texture size (honoring power of 2 if required)
2486 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2487 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2488 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2489 if (vid.support.arb_texture_non_power_of_two)
2491 resolution[0] = c[0];
2492 resolution[1] = c[1];
2493 resolution[2] = c[2];
2497 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2498 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2499 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2501 size[0] = spacing[0] * resolution[0];
2502 size[1] = spacing[1] * resolution[1];
2503 size[2] = spacing[2] * resolution[2];
2505 // if dynamic we may or may not want to use the world bounds
2506 // if the dynamic size is smaller than the world bounds, use it instead
2507 if (!settings.staticmode && (r_shadow_bouncegrid_x.integer * r_shadow_bouncegrid_y.integer * r_shadow_bouncegrid_z.integer < resolution[0] * resolution[1] * resolution[2]))
2509 // we know the resolution we want
2510 c[0] = r_shadow_bouncegrid_x.integer;
2511 c[1] = r_shadow_bouncegrid_y.integer;
2512 c[2] = r_shadow_bouncegrid_z.integer;
2513 // now we can calculate the texture size (power of 2 if required)
2514 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2515 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2516 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2517 if (vid.support.arb_texture_non_power_of_two)
2519 resolution[0] = c[0];
2520 resolution[1] = c[1];
2521 resolution[2] = c[2];
2525 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2526 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2527 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2529 size[0] = spacing[0] * resolution[0];
2530 size[1] = spacing[1] * resolution[1];
2531 size[2] = spacing[2] * resolution[2];
2532 // center the rendering on the view
2533 mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0];
2534 mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1];
2535 mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2];
2538 // recalculate the maxs in case the resolution was not satisfactory
2539 VectorAdd(mins, size, maxs);
2541 // if all the settings seem identical to the previous update, return
2542 if (r_shadow_bouncegridtexture && (settings.staticmode || realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value) && !memcmp(&r_shadow_bouncegridsettings, &settings, sizeof(settings)))
2545 // store the new settings
2546 r_shadow_bouncegridsettings = settings;
2548 pixelbands = settings.directionalshading ? 8 : 1;
2549 pixelsperband = resolution[0]*resolution[1]*resolution[2];
2550 numpixels = pixelsperband*pixelbands;
2552 // we're going to update the bouncegrid, update the matrix...
2553 memset(m, 0, sizeof(m));
2554 m[0] = 1.0f / size[0];
2555 m[3] = -mins[0] * m[0];
2556 m[5] = 1.0f / size[1];
2557 m[7] = -mins[1] * m[5];
2558 m[10] = 1.0f / size[2];
2559 m[11] = -mins[2] * m[10];
2561 Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegridmatrix, m);
2562 // reallocate pixels for this update if needed...
2563 if (r_shadow_bouncegridnumpixels != numpixels || !r_shadow_bouncegridpixels || !r_shadow_bouncegridhighpixels)
2565 if (r_shadow_bouncegridtexture)
2567 R_FreeTexture(r_shadow_bouncegridtexture);
2568 r_shadow_bouncegridtexture = NULL;
2570 r_shadow_bouncegridpixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridpixels, numpixels * sizeof(unsigned char[4]));
2571 r_shadow_bouncegridhighpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(float[4]));
2573 r_shadow_bouncegridnumpixels = numpixels;
2574 pixels = r_shadow_bouncegridpixels;
2575 highpixels = r_shadow_bouncegridhighpixels;
2576 x = pixelsperband*4;
2577 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2580 memset(pixels + pixelband * x, 128, x);
2582 memset(pixels + pixelband * x, 0, x);
2584 memset(highpixels, 0, numpixels * sizeof(float[4]));
2585 // figure out what we want to interact with
2586 if (settings.hitmodels)
2587 hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;// | SUPERCONTENTS_LIQUIDSMASK;
2589 hitsupercontentsmask = SUPERCONTENTS_SOLID;// | SUPERCONTENTS_LIQUIDSMASK;
2590 maxbounce = settings.maxbounce;
2591 // clear variables that produce warnings otherwise
2592 memset(splatcolor, 0, sizeof(splatcolor));
2593 // iterate world rtlights
2594 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2595 range1 = settings.staticmode ? 0 : r_refdef.scene.numlights;
2596 range2 = range + range1;
2598 for (lightindex = 0;lightindex < range2;lightindex++)
2600 if (lightindex < range)
2602 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2605 rtlight = &light->rtlight;
2606 VectorClear(rtlight->photoncolor);
2607 rtlight->photons = 0;
2608 if (!(light->flags & flag))
2610 if (settings.staticmode)
2612 // when static, we skip styled lights because they tend to change...
2613 if (rtlight->style > 0 && r_shadow_bouncegrid.integer != 2)
2619 rtlight = r_refdef.scene.lights[lightindex - range];
2620 VectorClear(rtlight->photoncolor);
2621 rtlight->photons = 0;
2623 // draw only visible lights (major speedup)
2624 radius = rtlight->radius * settings.lightradiusscale;
2625 cullmins[0] = rtlight->shadoworigin[0] - radius;
2626 cullmins[1] = rtlight->shadoworigin[1] - radius;
2627 cullmins[2] = rtlight->shadoworigin[2] - radius;
2628 cullmaxs[0] = rtlight->shadoworigin[0] + radius;
2629 cullmaxs[1] = rtlight->shadoworigin[1] + radius;
2630 cullmaxs[2] = rtlight->shadoworigin[2] + radius;
2631 if (R_CullBox(cullmins, cullmaxs))
2633 if (r_refdef.scene.worldmodel
2634 && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs
2635 && !r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, cullmins, cullmaxs))
2637 w = r_shadow_lightintensityscale.value * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2638 if (w * VectorLength2(rtlight->color) == 0.0f)
2640 w *= (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1);
2641 VectorScale(rtlight->color, w, rtlight->photoncolor);
2642 //if (!VectorLength2(rtlight->photoncolor))
2644 // shoot particles from this light
2645 // use a calculation for the number of particles that will not
2646 // vary with lightstyle, otherwise we get randomized particle
2647 // distribution, the seeded random is only consistent for a
2648 // consistent number of particles on this light...
2649 s = rtlight->radius;
2650 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2651 if (lightindex >= range)
2652 lightintensity *= settings.dlightparticlemultiplier;
2653 rtlight->photons = max(0.0f, lightintensity * s * s);
2654 photoncount += rtlight->photons;
2656 photonscaling = (float)settings.photons / max(1, photoncount);
2657 photonresidual = 0.0f;
2658 for (lightindex = 0;lightindex < range2;lightindex++)
2660 if (lightindex < range)
2662 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2665 rtlight = &light->rtlight;
2668 rtlight = r_refdef.scene.lights[lightindex - range];
2669 // skip a light with no photons
2670 if (rtlight->photons == 0.0f)
2672 // skip a light with no photon color)
2673 if (VectorLength2(rtlight->photoncolor) == 0.0f)
2675 photonresidual += rtlight->photons * photonscaling;
2676 shootparticles = (int)bound(0, photonresidual, MAXBOUNCEGRIDPARTICLESPERLIGHT);
2677 if (!shootparticles)
2679 photonresidual -= shootparticles;
2680 radius = rtlight->radius * settings.lightradiusscale;
2681 s = settings.particleintensity / shootparticles;
2682 VectorScale(rtlight->photoncolor, s, baseshotcolor);
2683 r_refdef.stats.bouncegrid_lights++;
2684 r_refdef.stats.bouncegrid_particles += shootparticles;
2685 for (shotparticles = 0;shotparticles < shootparticles;shotparticles++)
2687 if (settings.stablerandom > 0)
2688 seed = lightindex * 11937 + shotparticles;
2689 VectorCopy(baseshotcolor, shotcolor);
2690 VectorCopy(rtlight->shadoworigin, clipstart);
2691 if (settings.stablerandom < 0)
2692 VectorRandom(clipend);
2694 VectorCheeseRandom(clipend);
2695 VectorMA(clipstart, radius, clipend, clipend);
2696 for (bouncecount = 0;;bouncecount++)
2698 r_refdef.stats.bouncegrid_traces++;
2699 //r_refdef.scene.worldmodel->TraceLineAgainstSurfaces(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace, clipstart, clipend, hitsupercontentsmask);
2700 //r_refdef.scene.worldmodel->TraceLine(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace2, clipstart, clipend, hitsupercontentsmask);
2701 if (settings.staticmode)
2703 // static mode fires a LOT of rays but none of them are identical, so they are not cached
2704 cliptrace = CL_TraceLine(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, true, false, NULL, true, true);
2708 // dynamic mode fires many rays and most will match the cache from the previous frame
2709 cliptrace = CL_Cache_TraceLineSurfaces(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask);
2711 if (bouncecount > 0 || settings.includedirectlighting)
2713 // calculate second order spherical harmonics values (average, slopeX, slopeY, slopeZ)
2714 // accumulate average shotcolor
2715 w = VectorLength(shotcolor);
2716 splatcolor[ 0] = shotcolor[0];
2717 splatcolor[ 1] = shotcolor[1];
2718 splatcolor[ 2] = shotcolor[2];
2719 splatcolor[ 3] = 0.0f;
2722 VectorSubtract(clipstart, cliptrace.endpos, clipdiff);
2723 VectorNormalize(clipdiff);
2724 // store bentnormal in case the shader has a use for it
2725 splatcolor[ 4] = clipdiff[0] * w;
2726 splatcolor[ 5] = clipdiff[1] * w;
2727 splatcolor[ 6] = clipdiff[2] * w;
2729 // accumulate directional contributions (+X, +Y, +Z, -X, -Y, -Z)
2730 splatcolor[ 8] = shotcolor[0] * max(0.0f, clipdiff[0]);
2731 splatcolor[ 9] = shotcolor[0] * max(0.0f, clipdiff[1]);
2732 splatcolor[10] = shotcolor[0] * max(0.0f, clipdiff[2]);
2733 splatcolor[11] = 0.0f;
2734 splatcolor[12] = shotcolor[1] * max(0.0f, clipdiff[0]);
2735 splatcolor[13] = shotcolor[1] * max(0.0f, clipdiff[1]);
2736 splatcolor[14] = shotcolor[1] * max(0.0f, clipdiff[2]);
2737 splatcolor[15] = 0.0f;
2738 splatcolor[16] = shotcolor[2] * max(0.0f, clipdiff[0]);
2739 splatcolor[17] = shotcolor[2] * max(0.0f, clipdiff[1]);
2740 splatcolor[18] = shotcolor[2] * max(0.0f, clipdiff[2]);
2741 splatcolor[19] = 0.0f;
2742 splatcolor[20] = shotcolor[0] * max(0.0f, -clipdiff[0]);
2743 splatcolor[21] = shotcolor[0] * max(0.0f, -clipdiff[1]);
2744 splatcolor[22] = shotcolor[0] * max(0.0f, -clipdiff[2]);
2745 splatcolor[23] = 0.0f;
2746 splatcolor[24] = shotcolor[1] * max(0.0f, -clipdiff[0]);
2747 splatcolor[25] = shotcolor[1] * max(0.0f, -clipdiff[1]);
2748 splatcolor[26] = shotcolor[1] * max(0.0f, -clipdiff[2]);
2749 splatcolor[27] = 0.0f;
2750 splatcolor[28] = shotcolor[2] * max(0.0f, -clipdiff[0]);
2751 splatcolor[29] = shotcolor[2] * max(0.0f, -clipdiff[1]);
2752 splatcolor[30] = shotcolor[2] * max(0.0f, -clipdiff[2]);
2753 splatcolor[31] = 0.0f;
2755 // calculate the number of steps we need to traverse this distance
2756 VectorSubtract(cliptrace.endpos, clipstart, stepdelta);
2757 numsteps = (int)(VectorLength(stepdelta) * ispacing[0]);
2758 numsteps = bound(1, numsteps, 1024);
2759 w = 1.0f / numsteps;
2760 VectorScale(stepdelta, w, stepdelta);
2761 VectorMA(clipstart, 0.5f, stepdelta, steppos);
2762 for (step = 0;step < numsteps;step++)
2764 r_refdef.stats.bouncegrid_splats++;
2765 // figure out which texture pixel this is in
2766 texlerp[1][0] = ((steppos[0] - mins[0]) * ispacing[0]) - 0.5f;
2767 texlerp[1][1] = ((steppos[1] - mins[1]) * ispacing[1]) - 0.5f;
2768 texlerp[1][2] = ((steppos[2] - mins[2]) * ispacing[2]) - 0.5f;
2769 tex[0] = (int)floor(texlerp[1][0]);
2770 tex[1] = (int)floor(texlerp[1][1]);
2771 tex[2] = (int)floor(texlerp[1][2]);
2772 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)
2774 // it is within bounds... do the real work now
2775 // calculate the lerp factors
2776 texlerp[1][0] -= tex[0];
2777 texlerp[1][1] -= tex[1];
2778 texlerp[1][2] -= tex[2];
2779 texlerp[0][0] = 1.0f - texlerp[1][0];
2780 texlerp[0][1] = 1.0f - texlerp[1][1];
2781 texlerp[0][2] = 1.0f - texlerp[1][2];
2782 // calculate individual pixel indexes and weights
2783 pixelindex[0] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[0] = (texlerp[0][0]*texlerp[0][1]*texlerp[0][2]);
2784 pixelindex[1] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[1] = (texlerp[1][0]*texlerp[0][1]*texlerp[0][2]);
2785 pixelindex[2] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[2] = (texlerp[0][0]*texlerp[1][1]*texlerp[0][2]);
2786 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]);
2787 pixelindex[4] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[4] = (texlerp[0][0]*texlerp[0][1]*texlerp[1][2]);
2788 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]);
2789 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]);
2790 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]);
2791 // update the 8 pixels...
2792 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2794 for (corner = 0;corner < 8;corner++)
2796 // calculate address for pixel
2797 w = pixelweight[corner];
2798 pixel = pixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2799 highpixel = highpixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2800 // add to the high precision pixel color
2801 highpixel[0] += (splatcolor[pixelband*4+0]*w);
2802 highpixel[1] += (splatcolor[pixelband*4+1]*w);
2803 highpixel[2] += (splatcolor[pixelband*4+2]*w);
2804 highpixel[3] += (splatcolor[pixelband*4+3]*w);
2805 // flag the low precision pixel as needing to be updated
2807 // advance to next band of coefficients
2808 //pixel += pixelsperband*4;
2809 //highpixel += pixelsperband*4;
2813 VectorAdd(steppos, stepdelta, steppos);
2816 if (cliptrace.fraction >= 1.0f)
2818 r_refdef.stats.bouncegrid_hits++;
2819 if (bouncecount >= maxbounce)
2821 // scale down shot color by bounce intensity and texture color (or 50% if no texture reported)
2822 // also clamp the resulting color to never add energy, even if the user requests extreme values
2823 if (cliptrace.hittexture && cliptrace.hittexture->currentskinframe)
2824 VectorCopy(cliptrace.hittexture->currentskinframe->avgcolor, surfcolor);
2826 VectorSet(surfcolor, 0.5f, 0.5f, 0.5f);
2827 VectorScale(surfcolor, settings.particlebounceintensity, surfcolor);
2828 surfcolor[0] = min(surfcolor[0], 1.0f);
2829 surfcolor[1] = min(surfcolor[1], 1.0f);
2830 surfcolor[2] = min(surfcolor[2], 1.0f);
2831 VectorMultiply(shotcolor, surfcolor, shotcolor);
2832 if (VectorLength2(baseshotcolor) == 0.0f)
2834 r_refdef.stats.bouncegrid_bounces++;
2835 if (settings.bounceanglediffuse)
2837 // random direction, primarily along plane normal
2838 s = VectorDistance(cliptrace.endpos, clipend);
2839 if (settings.stablerandom < 0)
2840 VectorRandom(clipend);
2842 VectorCheeseRandom(clipend);
2843 VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend);
2844 VectorNormalize(clipend);
2845 VectorScale(clipend, s, clipend);
2849 // reflect the remaining portion of the line across plane normal
2850 VectorSubtract(clipend, cliptrace.endpos, clipdiff);
2851 VectorReflect(clipdiff, 1.0, cliptrace.plane.normal, clipend);
2853 // calculate the new line start and end
2854 VectorCopy(cliptrace.endpos, clipstart);
2855 VectorAdd(clipstart, clipend, clipend);
2859 // generate pixels array from highpixels array
2860 // skip first and last columns, rows, and layers as these are blank
2861 // the pixel[3] value was written above, so we can use it to detect only pixels that need to be calculated
2862 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2864 for (z = 1;z < resolution[2]-1;z++)
2866 for (y = 1;y < resolution[1]-1;y++)
2868 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)
2870 // only convert pixels that were hit by photons
2871 if (pixel[3] == 255)
2873 // normalize the bentnormal...
2876 VectorNormalize(highpixel);
2877 c[0] = (int)(highpixel[0]*128.0f+128.0f);
2878 c[1] = (int)(highpixel[1]*128.0f+128.0f);
2879 c[2] = (int)(highpixel[2]*128.0f+128.0f);
2880 c[3] = (int)(highpixel[3]*128.0f+128.0f);
2884 c[0] = (int)(highpixel[0]*256.0f);
2885 c[1] = (int)(highpixel[1]*256.0f);
2886 c[2] = (int)(highpixel[2]*256.0f);
2887 c[3] = (int)(highpixel[3]*256.0f);
2889 pixel[2] = (unsigned char)bound(0, c[0], 255);
2890 pixel[1] = (unsigned char)bound(0, c[1], 255);
2891 pixel[0] = (unsigned char)bound(0, c[2], 255);
2892 pixel[3] = (unsigned char)bound(0, c[3], 255);
2898 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)
2899 R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
2902 VectorCopy(resolution, r_shadow_bouncegridresolution);
2903 r_shadow_bouncegriddirectional = settings.directionalshading;
2904 if (r_shadow_bouncegridtexture)
2905 R_FreeTexture(r_shadow_bouncegridtexture);
2906 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);
2908 r_shadow_bouncegridtime = realtime;
2911 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2913 R_Shadow_RenderMode_Reset();
2914 GL_BlendFunc(GL_ONE, GL_ONE);
2915 GL_DepthRange(0, 1);
2916 GL_DepthTest(r_showshadowvolumes.integer < 2);
2917 GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2918 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2919 GL_CullFace(GL_NONE);
2920 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2923 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2925 R_Shadow_RenderMode_Reset();
2926 GL_BlendFunc(GL_ONE, GL_ONE);
2927 GL_DepthRange(0, 1);
2928 GL_DepthTest(r_showlighting.integer < 2);
2929 GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2931 GL_DepthFunc(GL_EQUAL);
2932 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2933 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2936 void R_Shadow_RenderMode_End(void)
2938 R_Shadow_RenderMode_Reset();
2939 R_Shadow_RenderMode_ActiveLight(NULL);
2941 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2942 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2945 int bboxedges[12][2] =
2964 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2966 if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass || r_trippy.integer)
2968 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2969 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2970 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2971 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2974 if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor))
2975 return true; // invisible
2976 if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x
2977 || r_shadow_lightscissor[1] != r_refdef.view.viewport.y
2978 || r_shadow_lightscissor[2] != r_refdef.view.viewport.width
2979 || r_shadow_lightscissor[3] != r_refdef.view.viewport.height)
2980 r_refdef.stats.lights_scissored++;
2984 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, const float *diffusecolor, const float *ambientcolor)
2987 const float *vertex3f;
2988 const float *normal3f;
2990 float dist, dot, distintensity, shadeintensity, v[3], n[3];
2991 switch (r_shadow_rendermode)
2993 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2994 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2995 if (VectorLength2(diffusecolor) > 0)
2997 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)
2999 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3000 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3001 if ((dot = DotProduct(n, v)) < 0)
3003 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3004 VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
3007 VectorCopy(ambientcolor, color4f);
3008 if (r_refdef.fogenabled)
3011 f = RSurf_FogVertex(vertex3f);
3012 VectorScale(color4f, f, color4f);
3019 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3021 VectorCopy(ambientcolor, color4f);
3022 if (r_refdef.fogenabled)
3025 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3026 f = RSurf_FogVertex(vertex3f);
3027 VectorScale(color4f + 4*i, f, color4f);
3033 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3034 if (VectorLength2(diffusecolor) > 0)
3036 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)
3038 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3039 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3041 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3042 if ((dot = DotProduct(n, v)) < 0)
3044 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3045 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3046 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3047 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3051 color4f[0] = ambientcolor[0] * distintensity;
3052 color4f[1] = ambientcolor[1] * distintensity;
3053 color4f[2] = ambientcolor[2] * distintensity;
3055 if (r_refdef.fogenabled)
3058 f = RSurf_FogVertex(vertex3f);
3059 VectorScale(color4f, f, color4f);
3063 VectorClear(color4f);
3069 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3071 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3072 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3074 color4f[0] = ambientcolor[0] * distintensity;
3075 color4f[1] = ambientcolor[1] * distintensity;
3076 color4f[2] = ambientcolor[2] * distintensity;
3077 if (r_refdef.fogenabled)
3080 f = RSurf_FogVertex(vertex3f);
3081 VectorScale(color4f, f, color4f);
3085 VectorClear(color4f);
3090 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3091 if (VectorLength2(diffusecolor) > 0)
3093 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)
3095 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3096 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3098 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3099 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3100 if ((dot = DotProduct(n, v)) < 0)
3102 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3103 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3104 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3105 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3109 color4f[0] = ambientcolor[0] * distintensity;
3110 color4f[1] = ambientcolor[1] * distintensity;
3111 color4f[2] = ambientcolor[2] * distintensity;
3113 if (r_refdef.fogenabled)
3116 f = RSurf_FogVertex(vertex3f);
3117 VectorScale(color4f, f, color4f);
3121 VectorClear(color4f);
3127 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3129 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3130 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3132 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3133 color4f[0] = ambientcolor[0] * distintensity;
3134 color4f[1] = ambientcolor[1] * distintensity;
3135 color4f[2] = ambientcolor[2] * distintensity;
3136 if (r_refdef.fogenabled)
3139 f = RSurf_FogVertex(vertex3f);
3140 VectorScale(color4f, f, color4f);
3144 VectorClear(color4f);
3154 static void R_Shadow_RenderLighting_VisibleLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3156 // used to display how many times a surface is lit for level design purposes
3157 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3158 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
3162 static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale, float specularscale)
3164 // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
3165 R_SetupShader_Surface(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL, false);
3169 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
3176 int newnumtriangles;
3180 int maxtriangles = 1024;
3181 int newelements[1024*3];
3182 R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, diffusecolor2, ambientcolor2);
3183 for (renders = 0;renders < 4;renders++)
3188 newnumtriangles = 0;
3190 // due to low fillrate on the cards this vertex lighting path is
3191 // designed for, we manually cull all triangles that do not
3192 // contain a lit vertex
3193 // this builds batches of triangles from multiple surfaces and
3194 // renders them at once
3195 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
3197 if (VectorLength2(rsurface.passcolor4f + e[0] * 4) + VectorLength2(rsurface.passcolor4f + e[1] * 4) + VectorLength2(rsurface.passcolor4f + e[2] * 4) >= 0.01)
3199 if (newnumtriangles)
3201 newfirstvertex = min(newfirstvertex, e[0]);
3202 newlastvertex = max(newlastvertex, e[0]);
3206 newfirstvertex = e[0];
3207 newlastvertex = e[0];
3209 newfirstvertex = min(newfirstvertex, e[1]);
3210 newlastvertex = max(newlastvertex, e[1]);
3211 newfirstvertex = min(newfirstvertex, e[2]);
3212 newlastvertex = max(newlastvertex, e[2]);
3218 if (newnumtriangles >= maxtriangles)
3220 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3221 newnumtriangles = 0;
3227 if (newnumtriangles >= 1)
3229 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3232 // if we couldn't find any lit triangles, exit early
3235 // now reduce the intensity for the next overbright pass
3236 // we have to clamp to 0 here incase the drivers have improper
3237 // handling of negative colors
3238 // (some old drivers even have improper handling of >1 color)
3240 for (i = 0, c = rsurface.passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4)
3242 if (c[0] > 1 || c[1] > 1 || c[2] > 1)
3244 c[0] = max(0, c[0] - 1);
3245 c[1] = max(0, c[1] - 1);
3246 c[2] = max(0, c[2] - 1);
3258 static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale)
3260 // OpenGL 1.1 path (anything)
3261 float ambientcolorbase[3], diffusecolorbase[3];
3262 float ambientcolorpants[3], diffusecolorpants[3];
3263 float ambientcolorshirt[3], diffusecolorshirt[3];
3264 const float *surfacecolor = rsurface.texture->dlightcolor;
3265 const float *surfacepants = rsurface.colormap_pantscolor;
3266 const float *surfaceshirt = rsurface.colormap_shirtcolor;
3267 rtexture_t *basetexture = rsurface.texture->basetexture;
3268 rtexture_t *pantstexture = rsurface.texture->pantstexture;
3269 rtexture_t *shirttexture = rsurface.texture->shirttexture;
3270 qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
3271 qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
3272 ambientscale *= 2 * r_refdef.view.colorscale;
3273 diffusescale *= 2 * r_refdef.view.colorscale;
3274 ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
3275 diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
3276 ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
3277 diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
3278 ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
3279 diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
3280 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3281 rsurface.passcolor4f = (float *)R_FrameData_Alloc((rsurface.batchfirstvertex + rsurface.batchnumvertices) * sizeof(float[4]));
3282 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3283 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
3284 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
3285 R_Mesh_TexBind(0, basetexture);
3286 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
3287 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
3288 switch(r_shadow_rendermode)
3290 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3291 R_Mesh_TexBind(1, r_shadow_attenuation3dtexture);
3292 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3293 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3294 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3296 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3297 R_Mesh_TexBind(2, r_shadow_attenuation2dtexture);
3298 R_Mesh_TexMatrix(2, &rsurface.entitytoattenuationz);
3299 R_Mesh_TexCombine(2, GL_MODULATE, GL_MODULATE, 1, 1);
3300 R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3302 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3303 R_Mesh_TexBind(1, r_shadow_attenuation2dtexture);
3304 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3305 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3306 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3308 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3313 //R_Mesh_TexBind(0, basetexture);
3314 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorbase, ambientcolorbase);
3317 R_Mesh_TexBind(0, pantstexture);
3318 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorpants, ambientcolorpants);
3322 R_Mesh_TexBind(0, shirttexture);
3323 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorshirt, ambientcolorshirt);
3327 extern cvar_t gl_lightmaps;
3328 void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3330 float ambientscale, diffusescale, specularscale;
3332 float lightcolor[3];
3333 VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
3334 ambientscale = rsurface.rtlight->ambientscale + rsurface.texture->rtlightambient;
3335 diffusescale = rsurface.rtlight->diffusescale * max(0, 1.0 - rsurface.texture->rtlightambient);
3336 specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
3337 if (!r_shadow_usenormalmap.integer)
3339 ambientscale += 1.0f * diffusescale;
3343 if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
3345 negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
3348 VectorNegate(lightcolor, lightcolor);
3349 GL_BlendEquationSubtract(true);
3351 RSurf_SetupDepthAndCulling();
3352 switch (r_shadow_rendermode)
3354 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
3355 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
3356 R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
3358 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3359 R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale, specularscale);
3361 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3362 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3363 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3364 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3365 R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale);
3368 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
3372 GL_BlendEquationSubtract(false);
3375 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)
3377 matrix4x4_t tempmatrix = *matrix;
3378 Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
3380 // if this light has been compiled before, free the associated data
3381 R_RTLight_Uncompile(rtlight);
3383 // clear it completely to avoid any lingering data
3384 memset(rtlight, 0, sizeof(*rtlight));
3386 // copy the properties
3387 rtlight->matrix_lighttoworld = tempmatrix;
3388 Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3389 Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3390 rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3391 VectorCopy(color, rtlight->color);
3392 rtlight->cubemapname[0] = 0;
3393 if (cubemapname && cubemapname[0])
3394 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3395 rtlight->shadow = shadow;
3396 rtlight->corona = corona;
3397 rtlight->style = style;
3398 rtlight->isstatic = isstatic;
3399 rtlight->coronasizescale = coronasizescale;
3400 rtlight->ambientscale = ambientscale;
3401 rtlight->diffusescale = diffusescale;
3402 rtlight->specularscale = specularscale;
3403 rtlight->flags = flags;
3405 // compute derived data
3406 //rtlight->cullradius = rtlight->radius;
3407 //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3408 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3409 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3410 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3411 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3412 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3413 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3416 // compiles rtlight geometry
3417 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3418 void R_RTLight_Compile(rtlight_t *rtlight)
3421 int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3422 int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3423 entity_render_t *ent = r_refdef.scene.worldentity;
3424 dp_model_t *model = r_refdef.scene.worldmodel;
3425 unsigned char *data;
3428 // compile the light
3429 rtlight->compiled = true;
3430 rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3431 rtlight->static_numleafs = 0;
3432 rtlight->static_numleafpvsbytes = 0;
3433 rtlight->static_leaflist = NULL;
3434 rtlight->static_leafpvs = NULL;
3435 rtlight->static_numsurfaces = 0;
3436 rtlight->static_surfacelist = NULL;
3437 rtlight->static_shadowmap_receivers = 0x3F;
3438 rtlight->static_shadowmap_casters = 0x3F;
3439 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3440 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3441 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3442 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3443 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3444 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3446 if (model && model->GetLightInfo)
3448 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3449 r_shadow_compilingrtlight = rtlight;
3450 R_FrameData_SetMark();
3451 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);
3452 R_FrameData_ReturnToMark();
3453 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3454 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3455 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3456 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3457 rtlight->static_numsurfaces = numsurfaces;
3458 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3459 rtlight->static_numleafs = numleafs;
3460 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3461 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3462 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3463 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3464 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3465 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3466 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3467 if (rtlight->static_numsurfaces)
3468 memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3469 if (rtlight->static_numleafs)
3470 memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3471 if (rtlight->static_numleafpvsbytes)
3472 memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3473 if (rtlight->static_numshadowtrispvsbytes)
3474 memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3475 if (rtlight->static_numlighttrispvsbytes)
3476 memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3477 R_FrameData_SetMark();
3478 switch (rtlight->shadowmode)
3480 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3481 if (model->CompileShadowMap && rtlight->shadow)
3482 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3485 if (model->CompileShadowVolume && rtlight->shadow)
3486 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3489 R_FrameData_ReturnToMark();
3490 // now we're done compiling the rtlight
3491 r_shadow_compilingrtlight = NULL;
3495 // use smallest available cullradius - box radius or light radius
3496 //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3497 //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3499 shadowzpasstris = 0;
3500 if (rtlight->static_meshchain_shadow_zpass)
3501 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3502 shadowzpasstris += mesh->numtriangles;
3504 shadowzfailtris = 0;
3505 if (rtlight->static_meshchain_shadow_zfail)
3506 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3507 shadowzfailtris += mesh->numtriangles;
3510 if (rtlight->static_numlighttrispvsbytes)
3511 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3512 if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3516 if (rtlight->static_numlighttrispvsbytes)
3517 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3518 if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3521 if (developer_extra.integer)
3522 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);
3525 void R_RTLight_Uncompile(rtlight_t *rtlight)
3527 if (rtlight->compiled)
3529 if (rtlight->static_meshchain_shadow_zpass)
3530 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3531 rtlight->static_meshchain_shadow_zpass = NULL;
3532 if (rtlight->static_meshchain_shadow_zfail)
3533 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3534 rtlight->static_meshchain_shadow_zfail = NULL;
3535 if (rtlight->static_meshchain_shadow_shadowmap)
3536 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3537 rtlight->static_meshchain_shadow_shadowmap = NULL;
3538 // these allocations are grouped
3539 if (rtlight->static_surfacelist)
3540 Mem_Free(rtlight->static_surfacelist);
3541 rtlight->static_numleafs = 0;
3542 rtlight->static_numleafpvsbytes = 0;
3543 rtlight->static_leaflist = NULL;
3544 rtlight->static_leafpvs = NULL;
3545 rtlight->static_numsurfaces = 0;
3546 rtlight->static_surfacelist = NULL;
3547 rtlight->static_numshadowtrispvsbytes = 0;
3548 rtlight->static_shadowtrispvs = NULL;
3549 rtlight->static_numlighttrispvsbytes = 0;
3550 rtlight->static_lighttrispvs = NULL;
3551 rtlight->compiled = false;
3555 void R_Shadow_UncompileWorldLights(void)
3559 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3560 for (lightindex = 0;lightindex < range;lightindex++)
3562 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3565 R_RTLight_Uncompile(&light->rtlight);
3569 static void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3573 // reset the count of frustum planes
3574 // see rtlight->cached_frustumplanes definition for how much this array
3576 rtlight->cached_numfrustumplanes = 0;
3578 if (r_trippy.integer)
3581 // haven't implemented a culling path for ortho rendering
3582 if (!r_refdef.view.useperspective)
3584 // check if the light is on screen and copy the 4 planes if it is
3585 for (i = 0;i < 4;i++)
3586 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3589 for (i = 0;i < 4;i++)
3590 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3595 // generate a deformed frustum that includes the light origin, this is
3596 // used to cull shadow casting surfaces that can not possibly cast a
3597 // shadow onto the visible light-receiving surfaces, which can be a
3600 // if the light origin is onscreen the result will be 4 planes exactly
3601 // if the light origin is offscreen on only one axis the result will
3602 // be exactly 5 planes (split-side case)
3603 // if the light origin is offscreen on two axes the result will be
3604 // exactly 4 planes (stretched corner case)
3605 for (i = 0;i < 4;i++)
3607 // quickly reject standard frustum planes that put the light
3608 // origin outside the frustum
3609 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3612 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3614 // if all the standard frustum planes were accepted, the light is onscreen
3615 // otherwise we need to generate some more planes below...
3616 if (rtlight->cached_numfrustumplanes < 4)
3618 // at least one of the stock frustum planes failed, so we need to
3619 // create one or two custom planes to enclose the light origin
3620 for (i = 0;i < 4;i++)
3622 // create a plane using the view origin and light origin, and a
3623 // single point from the frustum corner set
3624 TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3625 VectorNormalize(plane.normal);
3626 plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3627 // see if this plane is backwards and flip it if so
3628 for (j = 0;j < 4;j++)
3629 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3633 VectorNegate(plane.normal, plane.normal);
3635 // flipped plane, test again to see if it is now valid
3636 for (j = 0;j < 4;j++)
3637 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3639 // if the plane is still not valid, then it is dividing the
3640 // frustum and has to be rejected
3644 // we have created a valid plane, compute extra info
3645 PlaneClassify(&plane);
3647 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3649 // if we've found 5 frustum planes then we have constructed a
3650 // proper split-side case and do not need to keep searching for
3651 // planes to enclose the light origin
3652 if (rtlight->cached_numfrustumplanes == 5)
3660 for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3662 plane = rtlight->cached_frustumplanes[i];
3663 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));
3668 // now add the light-space box planes if the light box is rotated, as any
3669 // caster outside the oriented light box is irrelevant (even if it passed
3670 // the worldspace light box, which is axial)
3671 if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3673 for (i = 0;i < 6;i++)
3677 v[i >> 1] = (i & 1) ? -1 : 1;
3678 Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3679 VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3680 plane.dist = VectorNormalizeLength(plane.normal);
3681 plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3682 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3688 // add the world-space reduced box planes
3689 for (i = 0;i < 6;i++)
3691 VectorClear(plane.normal);
3692 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3693 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3694 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3703 // reduce all plane distances to tightly fit the rtlight cull box, which
3705 VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3706 VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3707 VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3708 VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3709 VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3710 VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3711 VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3712 VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3713 oldnum = rtlight->cached_numfrustumplanes;
3714 rtlight->cached_numfrustumplanes = 0;
3715 for (j = 0;j < oldnum;j++)
3717 // find the nearest point on the box to this plane
3718 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3719 for (i = 1;i < 8;i++)
3721 dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3722 if (bestdist > dist)
3725 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);
3726 // if the nearest point is near or behind the plane, we want this
3727 // plane, otherwise the plane is useless as it won't cull anything
3728 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3730 PlaneClassify(&rtlight->cached_frustumplanes[j]);
3731 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3738 static void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3742 RSurf_ActiveWorldEntity();
3744 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3747 GL_CullFace(GL_NONE);
3748 mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3749 for (;mesh;mesh = mesh->next)
3751 if (!mesh->sidetotals[r_shadow_shadowmapside])
3753 r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3754 if (mesh->vertex3fbuffer)
3755 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3757 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3758 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);
3762 else if (r_refdef.scene.worldentity->model)
3763 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);
3765 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3768 static void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3770 qboolean zpass = false;
3773 int surfacelistindex;
3774 msurface_t *surface;
3776 // if triangle neighbors are disabled, shadowvolumes are disabled
3777 if (r_refdef.scene.worldmodel->brush.shadowmesh ? !r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i : !r_refdef.scene.worldmodel->surfmesh.data_neighbor3i)
3780 RSurf_ActiveWorldEntity();
3782 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3785 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3787 zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3788 R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3790 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3791 for (;mesh;mesh = mesh->next)
3793 r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3794 if (mesh->vertex3fbuffer)
3795 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3797 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3798 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3800 // increment stencil if frontface is infront of depthbuffer
3801 GL_CullFace(r_refdef.view.cullface_back);
3802 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, 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 // decrement stencil if backface is infront of depthbuffer
3805 GL_CullFace(r_refdef.view.cullface_front);
3806 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
3808 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3810 // decrement stencil if backface is behind depthbuffer
3811 GL_CullFace(r_refdef.view.cullface_front);
3812 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
3813 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);
3814 // increment stencil if frontface is behind depthbuffer
3815 GL_CullFace(r_refdef.view.cullface_back);
3816 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
3818 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);
3822 else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh)
3824 // use the shadow trispvs calculated earlier by GetLightInfo to cull world triangles on this dynamic light
3825 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3826 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3828 surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3829 for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3830 if (CHECKPVSBIT(trispvs, t))
3831 shadowmarklist[numshadowmark++] = t;
3833 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);
3835 else if (numsurfaces)
3837 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);
3840 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3843 static void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3845 vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3846 vec_t relativeshadowradius;
3847 RSurf_ActiveModelEntity(ent, false, false, false);
3848 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3849 // we need to re-init the shader for each entity because the matrix changed
3850 relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3851 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3852 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3853 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3854 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3855 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3856 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3857 switch (r_shadow_rendermode)
3859 case R_SHADOW_RENDERMODE_SHADOWMAP2D:
3860 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3863 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3866 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3869 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3871 // set up properties for rendering light onto this entity
3872 RSurf_ActiveModelEntity(ent, true, true, false);
3873 Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3874 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3875 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3876 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3879 static void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *lighttrispvs)
3881 if (!r_refdef.scene.worldmodel->DrawLight)
3884 // set up properties for rendering light onto this entity
3885 RSurf_ActiveWorldEntity();
3886 rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3887 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3888 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3889 VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3891 r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
3893 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3896 static void R_Shadow_DrawEntityLight(entity_render_t *ent)
3898 dp_model_t *model = ent->model;
3899 if (!model->DrawLight)
3902 R_Shadow_SetupEntityLight(ent);
3904 model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3906 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3909 static void R_Shadow_PrepareLight(rtlight_t *rtlight)
3913 int numleafs, numsurfaces;
3914 int *leaflist, *surfacelist;
3915 unsigned char *leafpvs;
3916 unsigned char *shadowtrispvs;
3917 unsigned char *lighttrispvs;
3918 //unsigned char *surfacesides;
3919 int numlightentities;
3920 int numlightentities_noselfshadow;
3921 int numshadowentities;
3922 int numshadowentities_noselfshadow;
3923 static entity_render_t *lightentities[MAX_EDICTS];
3924 static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3925 static entity_render_t *shadowentities[MAX_EDICTS];
3926 static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3929 rtlight->draw = false;
3931 // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3932 // skip lights that are basically invisible (color 0 0 0)
3933 nolight = VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f);
3935 // loading is done before visibility checks because loading should happen
3936 // all at once at the start of a level, not when it stalls gameplay.
3937 // (especially important to benchmarks)
3939 if (rtlight->isstatic && !nolight && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
3941 if (rtlight->compiled)
3942 R_RTLight_Uncompile(rtlight);
3943 R_RTLight_Compile(rtlight);
3947 rtlight->currentcubemap = rtlight->cubemapname[0] ? R_GetCubemap(rtlight->cubemapname) : r_texture_whitecube;
3949 // look up the light style value at this time
3950 f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3951 VectorScale(rtlight->color, f, rtlight->currentcolor);
3953 if (rtlight->selected)
3955 f = 2 + sin(realtime * M_PI * 4.0);
3956 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3960 // if lightstyle is currently off, don't draw the light
3961 if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3964 // skip processing on corona-only lights
3968 // if the light box is offscreen, skip it
3969 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3972 VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
3973 VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
3975 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3977 if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3979 // compiled light, world available and can receive realtime lighting
3980 // retrieve leaf information
3981 numleafs = rtlight->static_numleafs;
3982 leaflist = rtlight->static_leaflist;
3983 leafpvs = rtlight->static_leafpvs;
3984 numsurfaces = rtlight->static_numsurfaces;
3985 surfacelist = rtlight->static_surfacelist;
3986 //surfacesides = NULL;
3987 shadowtrispvs = rtlight->static_shadowtrispvs;
3988 lighttrispvs = rtlight->static_lighttrispvs;
3990 else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
3992 // dynamic light, world available and can receive realtime lighting
3993 // calculate lit surfaces and leafs
3994 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);
3995 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3996 leaflist = r_shadow_buffer_leaflist;
3997 leafpvs = r_shadow_buffer_leafpvs;
3998 surfacelist = r_shadow_buffer_surfacelist;
3999 //surfacesides = r_shadow_buffer_surfacesides;
4000 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
4001 lighttrispvs = r_shadow_buffer_lighttrispvs;
4002 // if the reduced leaf bounds are offscreen, skip it
4003 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4014 //surfacesides = NULL;
4015 shadowtrispvs = NULL;
4016 lighttrispvs = NULL;
4018 // check if light is illuminating any visible leafs
4021 for (i = 0;i < numleafs;i++)
4022 if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
4028 // make a list of lit entities and shadow casting entities
4029 numlightentities = 0;
4030 numlightentities_noselfshadow = 0;
4031 numshadowentities = 0;
4032 numshadowentities_noselfshadow = 0;
4034 // add dynamic entities that are lit by the light
4035 for (i = 0;i < r_refdef.scene.numentities;i++)
4038 entity_render_t *ent = r_refdef.scene.entities[i];
4040 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4042 // skip the object entirely if it is not within the valid
4043 // shadow-casting region (which includes the lit region)
4044 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
4046 if (!(model = ent->model))
4048 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
4050 // this entity wants to receive light, is visible, and is
4051 // inside the light box
4052 // TODO: check if the surfaces in the model can receive light
4053 // so now check if it's in a leaf seen by the light
4054 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))
4056 if (ent->flags & RENDER_NOSELFSHADOW)
4057 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
4059 lightentities[numlightentities++] = ent;
4060 // since it is lit, it probably also casts a shadow...
4061 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4062 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4063 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4065 // note: exterior models without the RENDER_NOSELFSHADOW
4066 // flag still create a RENDER_NOSELFSHADOW shadow but
4067 // are lit normally, this means that they are
4068 // self-shadowing but do not shadow other
4069 // RENDER_NOSELFSHADOW entities such as the gun
4070 // (very weird, but keeps the player shadow off the gun)
4071 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4072 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4074 shadowentities[numshadowentities++] = ent;
4077 else if (ent->flags & RENDER_SHADOW)
4079 // this entity is not receiving light, but may still need to
4081 // TODO: check if the surfaces in the model can cast shadow
4082 // now check if it is in a leaf seen by the light
4083 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))
4085 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4086 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4087 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4089 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4090 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4092 shadowentities[numshadowentities++] = ent;
4097 // return if there's nothing at all to light
4098 if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
4101 // count this light in the r_speeds
4102 r_refdef.stats.lights++;
4104 // flag it as worth drawing later
4105 rtlight->draw = true;
4107 // cache all the animated entities that cast a shadow but are not visible
4108 for (i = 0;i < numshadowentities;i++)
4109 if (!shadowentities[i]->animcache_vertex3f)
4110 R_AnimCache_GetEntity(shadowentities[i], false, false);
4111 for (i = 0;i < numshadowentities_noselfshadow;i++)
4112 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
4113 R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
4115 // allocate some temporary memory for rendering this light later in the frame
4116 // reusable buffers need to be copied, static data can be used as-is
4117 rtlight->cached_numlightentities = numlightentities;
4118 rtlight->cached_numlightentities_noselfshadow = numlightentities_noselfshadow;
4119 rtlight->cached_numshadowentities = numshadowentities;
4120 rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
4121 rtlight->cached_numsurfaces = numsurfaces;
4122 rtlight->cached_lightentities = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
4123 rtlight->cached_lightentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
4124 rtlight->cached_shadowentities = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
4125 rtlight->cached_shadowentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
4126 if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
4128 int numshadowtrispvsbytes = (((r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles) + 7) >> 3);
4129 int numlighttrispvsbytes = ((r_refdef.scene.worldmodel->surfmesh.num_triangles + 7) >> 3);
4130 rtlight->cached_shadowtrispvs = (unsigned char *)R_FrameData_Store(numshadowtrispvsbytes, shadowtrispvs);
4131 rtlight->cached_lighttrispvs = (unsigned char *)R_FrameData_Store(numlighttrispvsbytes, lighttrispvs);
4132 rtlight->cached_surfacelist = (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
4136 // compiled light data
4137 rtlight->cached_shadowtrispvs = shadowtrispvs;
4138 rtlight->cached_lighttrispvs = lighttrispvs;
4139 rtlight->cached_surfacelist = surfacelist;
4143 static void R_Shadow_DrawLight(rtlight_t *rtlight)
4147 unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
4148 int numlightentities;
4149 int numlightentities_noselfshadow;
4150 int numshadowentities;
4151 int numshadowentities_noselfshadow;
4152 entity_render_t **lightentities;
4153 entity_render_t **lightentities_noselfshadow;
4154 entity_render_t **shadowentities;
4155 entity_render_t **shadowentities_noselfshadow;
4157 static unsigned char entitysides[MAX_EDICTS];
4158 static unsigned char entitysides_noselfshadow[MAX_EDICTS];
4159 vec3_t nearestpoint;
4161 qboolean castshadows;
4164 // check if we cached this light this frame (meaning it is worth drawing)
4168 numlightentities = rtlight->cached_numlightentities;
4169 numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
4170 numshadowentities = rtlight->cached_numshadowentities;
4171 numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
4172 numsurfaces = rtlight->cached_numsurfaces;
4173 lightentities = rtlight->cached_lightentities;
4174 lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
4175 shadowentities = rtlight->cached_shadowentities;
4176 shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
4177 shadowtrispvs = rtlight->cached_shadowtrispvs;
4178 lighttrispvs = rtlight->cached_lighttrispvs;
4179 surfacelist = rtlight->cached_surfacelist;
4181 // set up a scissor rectangle for this light
4182 if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4185 // don't let sound skip if going slow
4186 if (r_refdef.scene.extraupdate)
4189 // make this the active rtlight for rendering purposes
4190 R_Shadow_RenderMode_ActiveLight(rtlight);
4192 if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
4194 // optionally draw visible shape of the shadow volumes
4195 // for performance analysis by level designers
4196 R_Shadow_RenderMode_VisibleShadowVolumes();
4198 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4199 for (i = 0;i < numshadowentities;i++)
4200 R_Shadow_DrawEntityShadow(shadowentities[i]);
4201 for (i = 0;i < numshadowentities_noselfshadow;i++)
4202 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4203 R_Shadow_RenderMode_VisibleLighting(false, false);
4206 if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
4208 // optionally draw the illuminated areas
4209 // for performance analysis by level designers
4210 R_Shadow_RenderMode_VisibleLighting(false, false);
4212 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4213 for (i = 0;i < numlightentities;i++)
4214 R_Shadow_DrawEntityLight(lightentities[i]);
4215 for (i = 0;i < numlightentities_noselfshadow;i++)
4216 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4219 castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
4221 nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
4222 nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
4223 nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
4224 distance = VectorDistance(nearestpoint, r_refdef.view.origin);
4226 lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
4227 //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
4228 lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
4230 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4236 int receivermask = 0;
4237 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
4238 Matrix4x4_Abs(&radiustolight);
4240 r_shadow_shadowmaplod = 0;
4241 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
4242 if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
4243 r_shadow_shadowmaplod = i;
4245 size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
4247 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
4249 surfacesides = NULL;
4252 if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
4254 castermask = rtlight->static_shadowmap_casters;
4255 receivermask = rtlight->static_shadowmap_receivers;
4259 surfacesides = r_shadow_buffer_surfacesides;
4260 for(i = 0;i < numsurfaces;i++)
4262 msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
4263 surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4264 castermask |= surfacesides[i];
4265 receivermask |= surfacesides[i];
4269 if (receivermask < 0x3F)
4271 for (i = 0;i < numlightentities;i++)
4272 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4273 if (receivermask < 0x3F)
4274 for(i = 0; i < numlightentities_noselfshadow;i++)
4275 receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4278 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
4282 for (i = 0;i < numshadowentities;i++)
4283 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4284 for (i = 0;i < numshadowentities_noselfshadow;i++)
4285 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4288 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
4290 // render shadow casters into 6 sided depth texture
4291 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
4293 R_Shadow_RenderMode_ShadowMap(side, receivermask, size);
4294 if (! (castermask & (1 << side))) continue;
4296 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
4297 for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
4298 R_Shadow_DrawEntityShadow(shadowentities[i]);
4301 if (numlightentities_noselfshadow)
4303 // render lighting using the depth texture as shadowmap
4304 // draw lighting in the unmasked areas
4305 R_Shadow_RenderMode_Lighting(false, false, true);
4306 for (i = 0;i < numlightentities_noselfshadow;i++)
4307 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4310 // render shadow casters into 6 sided depth texture
4311 if (numshadowentities_noselfshadow)
4313 for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
4315 R_Shadow_RenderMode_ShadowMap(side, 0, size);
4316 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
4317 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4321 // render lighting using the depth texture as shadowmap
4322 // draw lighting in the unmasked areas
4323 R_Shadow_RenderMode_Lighting(false, false, true);
4324 // draw lighting in the unmasked areas
4326 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4327 for (i = 0;i < numlightentities;i++)
4328 R_Shadow_DrawEntityLight(lightentities[i]);
4330 else if (castshadows && vid.stencil)
4332 // draw stencil shadow volumes to mask off pixels that are in shadow
4333 // so that they won't receive lighting
4334 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
4335 R_Shadow_ClearStencil();
4338 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4339 for (i = 0;i < numshadowentities;i++)
4340 R_Shadow_DrawEntityShadow(shadowentities[i]);
4342 // draw lighting in the unmasked areas
4343 R_Shadow_RenderMode_Lighting(true, false, false);
4344 for (i = 0;i < numlightentities_noselfshadow;i++)
4345 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4347 for (i = 0;i < numshadowentities_noselfshadow;i++)
4348 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4350 // draw lighting in the unmasked areas
4351 R_Shadow_RenderMode_Lighting(true, false, false);
4353 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4354 for (i = 0;i < numlightentities;i++)
4355 R_Shadow_DrawEntityLight(lightentities[i]);
4359 // draw lighting in the unmasked areas
4360 R_Shadow_RenderMode_Lighting(false, false, false);
4362 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4363 for (i = 0;i < numlightentities;i++)
4364 R_Shadow_DrawEntityLight(lightentities[i]);
4365 for (i = 0;i < numlightentities_noselfshadow;i++)
4366 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4369 if (r_shadow_usingdeferredprepass)
4371 // when rendering deferred lighting, we simply rasterize the box
4372 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4373 R_Shadow_RenderMode_DrawDeferredLight(false, true);
4374 else if (castshadows && vid.stencil)
4375 R_Shadow_RenderMode_DrawDeferredLight(true, false);
4377 R_Shadow_RenderMode_DrawDeferredLight(false, false);
4381 static void R_Shadow_FreeDeferred(void)
4383 R_Mesh_DestroyFramebufferObject(r_shadow_prepassgeometryfbo);
4384 r_shadow_prepassgeometryfbo = 0;
4386 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusespecularfbo);
4387 r_shadow_prepasslightingdiffusespecularfbo = 0;
4389 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusefbo);
4390 r_shadow_prepasslightingdiffusefbo = 0;
4392 if (r_shadow_prepassgeometrydepthtexture)
4393 R_FreeTexture(r_shadow_prepassgeometrydepthtexture);
4394 r_shadow_prepassgeometrydepthtexture = NULL;
4396 if (r_shadow_prepassgeometrydepthcolortexture)
4397 R_FreeTexture(r_shadow_prepassgeometrydepthcolortexture);
4398 r_shadow_prepassgeometrydepthcolortexture = NULL;
4400 if (r_shadow_prepassgeometrynormalmaptexture)
4401 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4402 r_shadow_prepassgeometrynormalmaptexture = NULL;
4404 if (r_shadow_prepasslightingdiffusetexture)
4405 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4406 r_shadow_prepasslightingdiffusetexture = NULL;
4408 if (r_shadow_prepasslightingspeculartexture)
4409 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4410 r_shadow_prepasslightingspeculartexture = NULL;
4413 void R_Shadow_DrawPrepass(void)
4421 entity_render_t *ent;
4422 float clearcolor[4];
4424 R_Mesh_ResetTextureState();
4426 GL_ColorMask(1,1,1,1);
4427 GL_BlendFunc(GL_ONE, GL_ZERO);
4430 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
4431 Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f);
4432 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4433 if (r_timereport_active)
4434 R_TimeReport("prepasscleargeom");
4436 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4437 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4438 if (r_timereport_active)
4439 R_TimeReport("prepassworld");
4441 for (i = 0;i < r_refdef.scene.numentities;i++)
4443 if (!r_refdef.viewcache.entityvisible[i])
4445 ent = r_refdef.scene.entities[i];
4446 if (ent->model && ent->model->DrawPrepass != NULL)
4447 ent->model->DrawPrepass(ent);
4450 if (r_timereport_active)
4451 R_TimeReport("prepassmodels");
4453 GL_DepthMask(false);
4454 GL_ColorMask(1,1,1,1);
4457 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4458 Vector4Set(clearcolor, 0, 0, 0, 0);
4459 GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
4460 if (r_timereport_active)
4461 R_TimeReport("prepassclearlit");
4463 R_Shadow_RenderMode_Begin();
4465 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4466 if (r_shadow_debuglight.integer >= 0)
4468 lightindex = r_shadow_debuglight.integer;
4469 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4470 if (light && (light->flags & flag) && light->rtlight.draw)
4471 R_Shadow_DrawLight(&light->rtlight);
4475 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4476 for (lightindex = 0;lightindex < range;lightindex++)
4478 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4479 if (light && (light->flags & flag) && light->rtlight.draw)
4480 R_Shadow_DrawLight(&light->rtlight);
4483 if (r_refdef.scene.rtdlight)
4484 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4485 if (r_refdef.scene.lights[lnum]->draw)
4486 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4488 R_Shadow_RenderMode_End();
4490 if (r_timereport_active)
4491 R_TimeReport("prepasslights");
4494 void R_Shadow_DrawLightSprites(void);
4495 void R_Shadow_PrepareLights(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4505 if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4506 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
4507 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20) ||
4508 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4509 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4510 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4511 R_Shadow_FreeShadowMaps();
4513 r_shadow_fb_fbo = fbo;
4514 r_shadow_fb_depthtexture = depthtexture;
4515 r_shadow_fb_colortexture = colortexture;
4517 r_shadow_usingshadowmaportho = false;
4519 switch (vid.renderpath)
4521 case RENDERPATH_GL20:
4522 case RENDERPATH_D3D9:
4523 case RENDERPATH_D3D10:
4524 case RENDERPATH_D3D11:
4525 case RENDERPATH_SOFT:
4527 if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || vid.maxdrawbuffers < 2)
4529 r_shadow_usingdeferredprepass = false;
4530 if (r_shadow_prepass_width)
4531 R_Shadow_FreeDeferred();
4532 r_shadow_prepass_width = r_shadow_prepass_height = 0;
4536 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4538 R_Shadow_FreeDeferred();
4540 r_shadow_usingdeferredprepass = true;
4541 r_shadow_prepass_width = vid.width;
4542 r_shadow_prepass_height = vid.height;
4543 r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false, false);
4544 switch (vid.renderpath)
4546 case RENDERPATH_D3D9:
4547 r_shadow_prepassgeometrydepthcolortexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrydepthcolormap", vid.width, vid.height, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4552 r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4553 r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4554 r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4556 // set up the geometry pass fbo (depth + normalmap)
4557 r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4558 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
4559 // render depth into one texture and normalmap into the other
4560 if (qglDrawBuffersARB)
4562 qglDrawBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR
4563 qglReadBuffer(GL_NONE);CHECKGLERROR
4564 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER);CHECKGLERROR
4565 if (status != GL_FRAMEBUFFER_COMPLETE)
4567 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4568 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4569 r_shadow_usingdeferredprepass = false;
4573 // set up the lighting pass fbo (diffuse + specular)
4574 r_shadow_prepasslightingdiffusespecularfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4575 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4576 // render diffuse into one texture and specular into another,
4577 // with depth and normalmap bound as textures,
4578 // with depth bound as attachment as well
4579 if (qglDrawBuffersARB)
4581 qglDrawBuffersARB(2, r_shadow_prepasslightingdrawbuffers);CHECKGLERROR
4582 qglReadBuffer(GL_NONE);CHECKGLERROR
4583 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER);CHECKGLERROR
4584 if (status != GL_FRAMEBUFFER_COMPLETE)
4586 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4587 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4588 r_shadow_usingdeferredprepass = false;
4592 // set up the lighting pass fbo (diffuse)
4593 r_shadow_prepasslightingdiffusefbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4594 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4595 // render diffuse into one texture,
4596 // with depth and normalmap bound as textures,
4597 // with depth bound as attachment as well
4598 if (qglDrawBuffersARB)
4600 qglDrawBuffer(GL_COLOR_ATTACHMENT0);CHECKGLERROR
4601 qglReadBuffer(GL_NONE);CHECKGLERROR
4602 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER);CHECKGLERROR
4603 if (status != GL_FRAMEBUFFER_COMPLETE)
4605 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4606 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4607 r_shadow_usingdeferredprepass = false;
4613 case RENDERPATH_GL11:
4614 case RENDERPATH_GL13:
4615 case RENDERPATH_GLES1:
4616 case RENDERPATH_GLES2:
4617 r_shadow_usingdeferredprepass = false;
4621 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);
4623 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4624 if (r_shadow_bouncegrid.integer != 2)
4626 if (r_shadow_debuglight.integer >= 0)
4628 lightindex = r_shadow_debuglight.integer;
4629 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4631 R_Shadow_PrepareLight(&light->rtlight);
4635 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4636 for (lightindex = 0;lightindex < range;lightindex++)
4638 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4639 if (light && (light->flags & flag))
4640 R_Shadow_PrepareLight(&light->rtlight);
4644 if (r_refdef.scene.rtdlight)
4646 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4647 R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4649 else if(gl_flashblend.integer)
4651 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4653 rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4654 f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4655 VectorScale(rtlight->color, f, rtlight->currentcolor);
4659 if (r_editlights.integer)
4660 R_Shadow_DrawLightSprites();
4663 void R_Shadow_DrawLights(void)
4671 R_Shadow_RenderMode_Begin();
4673 if (r_shadow_bouncegrid.integer != 2)
4675 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4676 if (r_shadow_debuglight.integer >= 0)
4678 lightindex = r_shadow_debuglight.integer;
4679 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4681 R_Shadow_DrawLight(&light->rtlight);
4685 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4686 for (lightindex = 0;lightindex < range;lightindex++)
4688 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4689 if (light && (light->flags & flag))
4690 R_Shadow_DrawLight(&light->rtlight);
4694 if (r_refdef.scene.rtdlight)
4695 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4696 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4698 R_Shadow_RenderMode_End();
4701 void R_Shadow_PrepareModelShadows(void)
4704 float scale, size, radius, dot1, dot2;
4705 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus, shadowmins, shadowmaxs;
4706 entity_render_t *ent;
4708 if (!r_refdef.scene.numentities)
4711 switch (r_shadow_shadowmode)
4713 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4714 if (r_shadows.integer >= 2)
4717 case R_SHADOW_SHADOWMODE_STENCIL:
4718 for (i = 0;i < r_refdef.scene.numentities;i++)
4720 ent = r_refdef.scene.entities[i];
4721 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4722 R_AnimCache_GetEntity(ent, false, false);
4729 size = 2*r_shadow_shadowmapmaxsize;
4730 scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
4731 radius = 0.5f * size / scale;
4733 Math_atov(r_shadows_throwdirection.string, shadowdir);
4734 VectorNormalize(shadowdir);
4735 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4736 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4737 if (fabs(dot1) <= fabs(dot2))
4738 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4740 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4741 VectorNormalize(shadowforward);
4742 CrossProduct(shadowdir, shadowforward, shadowright);
4743 Math_atov(r_shadows_focus.string, shadowfocus);
4744 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4745 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4746 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4747 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4748 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4750 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4752 shadowmins[0] = shadoworigin[0] - r_shadows_throwdistance.value * fabs(shadowdir[0]) - radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4753 shadowmins[1] = shadoworigin[1] - r_shadows_throwdistance.value * fabs(shadowdir[1]) - radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4754 shadowmins[2] = shadoworigin[2] - r_shadows_throwdistance.value * fabs(shadowdir[2]) - radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4755 shadowmaxs[0] = shadoworigin[0] + r_shadows_throwdistance.value * fabs(shadowdir[0]) + radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4756 shadowmaxs[1] = shadoworigin[1] + r_shadows_throwdistance.value * fabs(shadowdir[1]) + radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4757 shadowmaxs[2] = shadoworigin[2] + r_shadows_throwdistance.value * fabs(shadowdir[2]) + radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4759 for (i = 0;i < r_refdef.scene.numentities;i++)
4761 ent = r_refdef.scene.entities[i];
4762 if (!BoxesOverlap(ent->mins, ent->maxs, shadowmins, shadowmaxs))
4764 // cast shadows from anything of the map (submodels are optional)
4765 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4766 R_AnimCache_GetEntity(ent, false, false);
4770 void R_DrawModelShadowMaps(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4773 float relativethrowdistance, scale, size, radius, nearclip, farclip, bias, dot1, dot2;
4774 entity_render_t *ent;
4775 vec3_t relativelightorigin;
4776 vec3_t relativelightdirection, relativeforward, relativeright;
4777 vec3_t relativeshadowmins, relativeshadowmaxs;
4778 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus;
4780 matrix4x4_t shadowmatrix, cameramatrix, mvpmatrix, invmvpmatrix, scalematrix, texmatrix;
4781 r_viewport_t viewport;
4782 GLuint shadowfbo = 0;
4783 float clearcolor[4];
4785 if (!r_refdef.scene.numentities)
4788 switch (r_shadow_shadowmode)
4790 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4796 r_shadow_fb_fbo = fbo;
4797 r_shadow_fb_depthtexture = depthtexture;
4798 r_shadow_fb_colortexture = colortexture;
4800 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
4801 R_Shadow_RenderMode_Begin();
4802 R_Shadow_RenderMode_ActiveLight(NULL);
4804 switch (r_shadow_shadowmode)
4806 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4807 if (!r_shadow_shadowmap2dtexture)
4808 R_Shadow_MakeShadowMap(0, r_shadow_shadowmapmaxsize);
4809 shadowfbo = r_shadow_fbo2d;
4810 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
4811 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
4812 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
4818 size = 2*r_shadow_shadowmapmaxsize;
4819 scale = (r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value) / size;
4820 radius = 0.5f / scale;
4821 nearclip = -r_shadows_throwdistance.value;
4822 farclip = r_shadows_throwdistance.value;
4823 bias = r_shadow_shadowmapping_bias.value * r_shadow_shadowmapping_nearclip.value / (2 * r_shadows_throwdistance.value) * (1024.0f / size);
4825 r_shadow_shadowmap_parameters[0] = size;
4826 r_shadow_shadowmap_parameters[1] = size;
4827 r_shadow_shadowmap_parameters[2] = 1.0;
4828 r_shadow_shadowmap_parameters[3] = bound(0.0f, 1.0f - r_shadows_darken.value, 1.0f);
4830 Math_atov(r_shadows_throwdirection.string, shadowdir);
4831 VectorNormalize(shadowdir);
4832 Math_atov(r_shadows_focus.string, shadowfocus);
4833 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4834 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4835 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4836 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4837 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4838 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4839 if (fabs(dot1) <= fabs(dot2))
4840 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4842 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4843 VectorNormalize(shadowforward);
4844 VectorM(scale, shadowforward, &m[0]);
4845 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4847 m[3] = fabs(dot1) * 0.5f - DotProduct(shadoworigin, &m[0]);
4848 CrossProduct(shadowdir, shadowforward, shadowright);
4849 VectorM(scale, shadowright, &m[4]);
4850 m[7] = 0.5f - DotProduct(shadoworigin, &m[4]);
4851 VectorM(1.0f / (farclip - nearclip), shadowdir, &m[8]);
4852 m[11] = 0.5f - DotProduct(shadoworigin, &m[8]);
4853 Matrix4x4_FromArray12FloatD3D(&shadowmatrix, m);
4854 Matrix4x4_Invert_Full(&cameramatrix, &shadowmatrix);
4855 R_Viewport_InitOrtho(&viewport, &cameramatrix, 0, 0, size, size, 0, 0, 1, 1, 0, -1, NULL);
4857 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4859 R_Mesh_SetRenderTargets(shadowfbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
4860 R_SetupShader_DepthOrShadow(true);
4861 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
4864 R_SetViewport(&viewport);
4865 GL_Scissor(viewport.x, viewport.y, min(viewport.width + r_shadow_shadowmapborder, 2*r_shadow_shadowmapmaxsize), viewport.height + r_shadow_shadowmapborder);
4866 Vector4Set(clearcolor, 1,1,1,1);
4867 // in D3D9 we have to render to a color texture shadowmap
4868 // in GL we render directly to a depth texture only
4869 if (r_shadow_shadowmap2dtexture)
4870 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4872 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4873 // render into a slightly restricted region so that the borders of the
4874 // shadowmap area fade away, rather than streaking across everything
4875 // outside the usable area
4876 GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder);
4880 R_Mesh_SetRenderTargets(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture, NULL, NULL, NULL);
4881 R_SetupShader_ShowDepth(true);
4882 GL_ColorMask(1,1,1,1);
4883 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4886 for (i = 0;i < r_refdef.scene.numentities;i++)
4888 ent = r_refdef.scene.entities[i];
4890 // cast shadows from anything of the map (submodels are optional)
4891 if (ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4893 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4894 Matrix4x4_Transform(&ent->inversematrix, shadoworigin, relativelightorigin);
4895 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4896 Matrix4x4_Transform3x3(&ent->inversematrix, shadowforward, relativeforward);
4897 Matrix4x4_Transform3x3(&ent->inversematrix, shadowright, relativeright);
4898 relativeshadowmins[0] = relativelightorigin[0] - r_shadows_throwdistance.value * fabs(relativelightdirection[0]) - radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4899 relativeshadowmins[1] = relativelightorigin[1] - r_shadows_throwdistance.value * fabs(relativelightdirection[1]) - radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4900 relativeshadowmins[2] = relativelightorigin[2] - r_shadows_throwdistance.value * fabs(relativelightdirection[2]) - radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4901 relativeshadowmaxs[0] = relativelightorigin[0] + r_shadows_throwdistance.value * fabs(relativelightdirection[0]) + radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4902 relativeshadowmaxs[1] = relativelightorigin[1] + r_shadows_throwdistance.value * fabs(relativelightdirection[1]) + radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4903 relativeshadowmaxs[2] = relativelightorigin[2] + r_shadows_throwdistance.value * fabs(relativelightdirection[2]) + radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4904 RSurf_ActiveModelEntity(ent, false, false, false);
4905 ent->model->DrawShadowMap(0, ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
4906 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4913 unsigned char *rawpixels = Z_Malloc(viewport.width*viewport.height*4);
4915 qglReadPixels(viewport.x, viewport.y, viewport.width, viewport.height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, rawpixels);
4917 Image_WriteTGABGRA("r_shadows_2.tga", viewport.width, viewport.height, rawpixels);
4918 Cvar_SetValueQuick(&r_test, 0);
4923 R_Shadow_RenderMode_End();
4925 Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
4926 Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
4927 Matrix4x4_CreateScale3(&scalematrix, size, -size, 1);
4928 Matrix4x4_AdjustOrigin(&scalematrix, 0, size, -0.5f * bias);
4929 Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix);
4930 Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix);
4932 switch (vid.renderpath)
4934 case RENDERPATH_GL11:
4935 case RENDERPATH_GL13:
4936 case RENDERPATH_GL20:
4937 case RENDERPATH_SOFT:
4938 case RENDERPATH_GLES1:
4939 case RENDERPATH_GLES2:
4941 case RENDERPATH_D3D9:
4942 case RENDERPATH_D3D10:
4943 case RENDERPATH_D3D11:
4944 #ifdef OPENGL_ORIENTATION
4945 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4946 r_shadow_shadowmapmatrix.m[0][1] *= -1.0f;
4947 r_shadow_shadowmapmatrix.m[0][2] *= -1.0f;
4948 r_shadow_shadowmapmatrix.m[0][3] *= -1.0f;
4950 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4951 r_shadow_shadowmapmatrix.m[1][0] *= -1.0f;
4952 r_shadow_shadowmapmatrix.m[2][0] *= -1.0f;
4953 r_shadow_shadowmapmatrix.m[3][0] *= -1.0f;
4958 r_shadow_usingshadowmaportho = true;
4959 switch (r_shadow_shadowmode)
4961 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4962 r_shadow_usingshadowmap2d = true;
4969 void R_DrawModelShadows(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4972 float relativethrowdistance;
4973 entity_render_t *ent;
4974 vec3_t relativelightorigin;
4975 vec3_t relativelightdirection;
4976 vec3_t relativeshadowmins, relativeshadowmaxs;
4977 vec3_t tmp, shadowdir;
4979 if (!r_refdef.scene.numentities || !vid.stencil || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL && r_shadows.integer != 1))
4982 r_shadow_fb_fbo = fbo;
4983 r_shadow_fb_depthtexture = depthtexture;
4984 r_shadow_fb_colortexture = colortexture;
4986 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
4987 //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
4988 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4989 R_Shadow_RenderMode_Begin();
4990 R_Shadow_RenderMode_ActiveLight(NULL);
4991 r_shadow_lightscissor[0] = r_refdef.view.x;
4992 r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
4993 r_shadow_lightscissor[2] = r_refdef.view.width;
4994 r_shadow_lightscissor[3] = r_refdef.view.height;
4995 R_Shadow_RenderMode_StencilShadowVolumes(false);
4998 if (r_shadows.integer == 2)
5000 Math_atov(r_shadows_throwdirection.string, shadowdir);
5001 VectorNormalize(shadowdir);
5004 R_Shadow_ClearStencil();
5006 for (i = 0;i < r_refdef.scene.numentities;i++)
5008 ent = r_refdef.scene.entities[i];
5010 // cast shadows from anything of the map (submodels are optional)
5011 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
5013 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
5014 VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
5015 VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
5016 if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
5017 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
5020 if(ent->entitynumber != 0)
5022 if(ent->entitynumber >= MAX_EDICTS) // csqc entity
5024 // FIXME handle this
5025 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5029 // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
5030 int entnum, entnum2, recursion;
5031 entnum = entnum2 = ent->entitynumber;
5032 for(recursion = 32; recursion > 0; --recursion)
5034 entnum2 = cl.entities[entnum].state_current.tagentity;
5035 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
5040 if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
5042 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
5043 // transform into modelspace of OUR entity
5044 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
5045 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
5048 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5052 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5055 VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
5056 RSurf_ActiveModelEntity(ent, false, false, false);
5057 ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
5058 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
5062 // not really the right mode, but this will disable any silly stencil features
5063 R_Shadow_RenderMode_End();
5065 // set up ortho view for rendering this pass
5066 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
5067 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5068 //GL_ScissorTest(true);
5069 //R_EntityMatrix(&identitymatrix);
5070 //R_Mesh_ResetTextureState();
5071 R_ResetViewRendering2D(fbo, depthtexture, colortexture);
5073 // set up a darkening blend on shadowed areas
5074 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5075 //GL_DepthRange(0, 1);
5076 //GL_DepthTest(false);
5077 //GL_DepthMask(false);
5078 //GL_PolygonOffset(0, 0);CHECKGLERROR
5079 GL_Color(0, 0, 0, r_shadows_darken.value);
5080 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5081 //GL_DepthFunc(GL_ALWAYS);
5082 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_NOTEQUAL, 128, 255);
5084 // apply the blend to the shadowed areas
5085 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
5086 R_SetupShader_Generic_NoTexture(false, true);
5087 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5089 // restore the viewport
5090 R_SetViewport(&r_refdef.view.viewport);
5092 // restore other state to normal
5093 //R_Shadow_RenderMode_End();
5096 static void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
5099 vec3_t centerorigin;
5101 // if it's too close, skip it
5102 if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
5104 zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
5107 if (usequery && r_numqueries + 2 <= r_maxqueries)
5109 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
5110 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
5111 // 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
5112 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
5114 switch(vid.renderpath)
5116 case RENDERPATH_GL11:
5117 case RENDERPATH_GL13:
5118 case RENDERPATH_GL20:
5119 case RENDERPATH_GLES1:
5120 case RENDERPATH_GLES2:
5121 #ifdef GL_SAMPLES_PASSED_ARB
5123 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead
5124 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
5125 GL_DepthFunc(GL_ALWAYS);
5126 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5127 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5128 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5129 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5130 GL_DepthFunc(GL_LEQUAL);
5131 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
5132 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5133 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5134 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5135 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5139 case RENDERPATH_D3D9:
5140 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5142 case RENDERPATH_D3D10:
5143 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5145 case RENDERPATH_D3D11:
5146 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5148 case RENDERPATH_SOFT:
5149 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5153 rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
5156 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
5158 static void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
5161 GLint allpixels = 0, visiblepixels = 0;
5162 // now we have to check the query result
5163 if (rtlight->corona_queryindex_visiblepixels)
5165 switch(vid.renderpath)
5167 case RENDERPATH_GL11:
5168 case RENDERPATH_GL13:
5169 case RENDERPATH_GL20:
5170 case RENDERPATH_GLES1:
5171 case RENDERPATH_GLES2:
5172 #ifdef GL_SAMPLES_PASSED_ARB
5174 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
5175 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
5179 case RENDERPATH_D3D9:
5180 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5182 case RENDERPATH_D3D10:
5183 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5185 case RENDERPATH_D3D11:
5186 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5188 case RENDERPATH_SOFT:
5189 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5192 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
5193 if (visiblepixels < 1 || allpixels < 1)
5195 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
5196 cscale *= rtlight->corona_visibility;
5200 // FIXME: these traces should scan all render entities instead of cl.world
5201 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
5204 VectorScale(rtlight->currentcolor, cscale, color);
5205 if (VectorLength(color) > (1.0f / 256.0f))
5208 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
5211 VectorNegate(color, color);
5212 GL_BlendEquationSubtract(true);
5214 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5215 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);
5216 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5218 GL_BlendEquationSubtract(false);
5222 void R_Shadow_DrawCoronas(void)
5225 qboolean usequery = false;
5230 if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
5232 if (r_fb.water.renderingscene)
5234 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
5235 R_EntityMatrix(&identitymatrix);
5237 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5239 // check occlusion of coronas
5240 // use GL_ARB_occlusion_query if available
5241 // otherwise use raytraces
5243 switch (vid.renderpath)
5245 case RENDERPATH_GL11:
5246 case RENDERPATH_GL13:
5247 case RENDERPATH_GL20:
5248 case RENDERPATH_GLES1:
5249 case RENDERPATH_GLES2:
5250 usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
5251 #ifdef GL_SAMPLES_PASSED_ARB
5254 GL_ColorMask(0,0,0,0);
5255 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
5256 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
5259 r_maxqueries = (range + r_refdef.scene.numlights) * 4;
5260 r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
5262 qglGenQueriesARB(r_maxqueries - i, r_queries + i);
5265 RSurf_ActiveWorldEntity();
5266 GL_BlendFunc(GL_ONE, GL_ZERO);
5267 GL_CullFace(GL_NONE);
5268 GL_DepthMask(false);
5269 GL_DepthRange(0, 1);
5270 GL_PolygonOffset(0, 0);
5272 R_Mesh_ResetTextureState();
5273 R_SetupShader_Generic_NoTexture(false, false);
5277 case RENDERPATH_D3D9:
5279 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5281 case RENDERPATH_D3D10:
5282 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5284 case RENDERPATH_D3D11:
5285 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5287 case RENDERPATH_SOFT:
5289 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5292 for (lightindex = 0;lightindex < range;lightindex++)
5294 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5297 rtlight = &light->rtlight;
5298 rtlight->corona_visibility = 0;
5299 rtlight->corona_queryindex_visiblepixels = 0;
5300 rtlight->corona_queryindex_allpixels = 0;
5301 if (!(rtlight->flags & flag))
5303 if (rtlight->corona <= 0)
5305 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
5307 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5309 for (i = 0;i < r_refdef.scene.numlights;i++)
5311 rtlight = r_refdef.scene.lights[i];
5312 rtlight->corona_visibility = 0;
5313 rtlight->corona_queryindex_visiblepixels = 0;
5314 rtlight->corona_queryindex_allpixels = 0;
5315 if (!(rtlight->flags & flag))
5317 if (rtlight->corona <= 0)
5319 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5322 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5324 // now draw the coronas using the query data for intensity info
5325 for (lightindex = 0;lightindex < range;lightindex++)
5327 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5330 rtlight = &light->rtlight;
5331 if (rtlight->corona_visibility <= 0)
5333 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5335 for (i = 0;i < r_refdef.scene.numlights;i++)
5337 rtlight = r_refdef.scene.lights[i];
5338 if (rtlight->corona_visibility <= 0)
5340 if (gl_flashblend.integer)
5341 R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
5343 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5349 static dlight_t *R_Shadow_NewWorldLight(void)
5351 return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
5354 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)
5357 // validate parameters
5358 if (style < 0 || style >= MAX_LIGHTSTYLES)
5360 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
5366 // copy to light properties
5367 VectorCopy(origin, light->origin);
5368 light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
5369 light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
5370 light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
5372 light->color[0] = max(color[0], 0);
5373 light->color[1] = max(color[1], 0);
5374 light->color[2] = max(color[2], 0);
5376 light->color[0] = color[0];
5377 light->color[1] = color[1];
5378 light->color[2] = color[2];
5379 light->radius = max(radius, 0);
5380 light->style = style;
5381 light->shadow = shadowenable;
5382 light->corona = corona;
5383 strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
5384 light->coronasizescale = coronasizescale;
5385 light->ambientscale = ambientscale;
5386 light->diffusescale = diffusescale;
5387 light->specularscale = specularscale;
5388 light->flags = flags;
5390 // update renderable light data
5391 Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
5392 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);
5395 static void R_Shadow_FreeWorldLight(dlight_t *light)
5397 if (r_shadow_selectedlight == light)
5398 r_shadow_selectedlight = NULL;
5399 R_RTLight_Uncompile(&light->rtlight);
5400 Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
5403 void R_Shadow_ClearWorldLights(void)
5407 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5408 for (lightindex = 0;lightindex < range;lightindex++)
5410 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5412 R_Shadow_FreeWorldLight(light);
5414 r_shadow_selectedlight = NULL;
5417 static void R_Shadow_SelectLight(dlight_t *light)
5419 if (r_shadow_selectedlight)
5420 r_shadow_selectedlight->selected = false;
5421 r_shadow_selectedlight = light;
5422 if (r_shadow_selectedlight)
5423 r_shadow_selectedlight->selected = true;
5426 static void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5428 // this is never batched (there can be only one)
5430 R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
5431 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5432 R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5435 static void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5440 skinframe_t *skinframe;
5443 // this is never batched (due to the ent parameter changing every time)
5444 // so numsurfaces == 1 and surfacelist[0] == lightnumber
5445 const dlight_t *light = (dlight_t *)ent;
5448 R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
5451 VectorScale(light->color, intensity, spritecolor);
5452 if (VectorLength(spritecolor) < 0.1732f)
5453 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
5454 if (VectorLength(spritecolor) > 1.0f)
5455 VectorNormalize(spritecolor);
5457 // draw light sprite
5458 if (light->cubemapname[0] && !light->shadow)
5459 skinframe = r_editlights_sprcubemapnoshadowlight;
5460 else if (light->cubemapname[0])
5461 skinframe = r_editlights_sprcubemaplight;
5462 else if (!light->shadow)
5463 skinframe = r_editlights_sprnoshadowlight;
5465 skinframe = r_editlights_sprlight;
5467 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);
5468 R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5470 // draw selection sprite if light is selected
5471 if (light->selected)
5473 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5474 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5475 // VorteX todo: add normalmode/realtime mode light overlay sprites?
5479 void R_Shadow_DrawLightSprites(void)
5483 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5484 for (lightindex = 0;lightindex < range;lightindex++)
5486 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5488 R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
5490 if (!r_editlights_lockcursor)
5491 R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
5494 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
5499 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
5500 if (lightindex >= range)
5502 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5505 rtlight = &light->rtlight;
5506 //if (!(rtlight->flags & flag))
5508 VectorCopy(rtlight->shadoworigin, origin);
5509 *radius = rtlight->radius;
5510 VectorCopy(rtlight->color, color);
5514 static void R_Shadow_SelectLightInView(void)
5516 float bestrating, rating, temp[3];
5520 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5524 if (r_editlights_lockcursor)
5526 for (lightindex = 0;lightindex < range;lightindex++)
5528 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5531 VectorSubtract(light->origin, r_refdef.view.origin, temp);
5532 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
5535 rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
5536 if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1.0f)
5538 bestrating = rating;
5543 R_Shadow_SelectLight(best);
5546 void R_Shadow_LoadWorldLights(void)
5548 int n, a, style, shadow, flags;
5549 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
5550 float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
5551 if (cl.worldmodel == NULL)
5553 Con_Print("No map loaded.\n");
5556 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5557 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5567 for (;COM_Parse(t, true) && strcmp(
5568 if (COM_Parse(t, true))
5570 if (com_token[0] == '!')
5573 origin[0] = atof(com_token+1);
5576 origin[0] = atof(com_token);
5581 while (*s && *s != '\n' && *s != '\r')
5587 // check for modifier flags
5594 #if _MSC_VER >= 1400
5595 #define sscanf sscanf_s
5597 cubemapname[sizeof(cubemapname)-1] = 0;
5598 #if MAX_QPATH != 128
5599 #error update this code if MAX_QPATH changes
5601 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
5602 #if _MSC_VER >= 1400
5603 , sizeof(cubemapname)
5605 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
5608 flags = LIGHTFLAG_REALTIMEMODE;
5616 coronasizescale = 0.25f;
5618 VectorClear(angles);
5621 if (a < 9 || !strcmp(cubemapname, "\"\""))
5623 // remove quotes on cubemapname
5624 if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
5627 namelen = strlen(cubemapname) - 2;
5628 memmove(cubemapname, cubemapname + 1, namelen);
5629 cubemapname[namelen] = '\0';
5633 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);
5636 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5644 Con_Printf("invalid rtlights file \"%s\"\n", name);
5645 Mem_Free(lightsstring);
5649 void R_Shadow_SaveWorldLights(void)
5653 size_t bufchars, bufmaxchars;
5655 char name[MAX_QPATH];
5656 char line[MAX_INPUTLINE];
5657 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5658 // I hate lines which are 3 times my screen size :( --blub
5661 if (cl.worldmodel == NULL)
5663 Con_Print("No map loaded.\n");
5666 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5667 bufchars = bufmaxchars = 0;
5669 for (lightindex = 0;lightindex < range;lightindex++)
5671 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5674 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5675 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);
5676 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5677 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]);
5679 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);
5680 if (bufchars + strlen(line) > bufmaxchars)
5682 bufmaxchars = bufchars + strlen(line) + 2048;
5684 buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5688 memcpy(buf, oldbuf, bufchars);
5694 memcpy(buf + bufchars, line, strlen(line));
5695 bufchars += strlen(line);
5699 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5704 void R_Shadow_LoadLightsFile(void)
5707 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5708 float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5709 if (cl.worldmodel == NULL)
5711 Con_Print("No map loaded.\n");
5714 dpsnprintf(name, sizeof(name), "%s.lights", cl.worldnamenoextension);
5715 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5723 while (*s && *s != '\n' && *s != '\r')
5729 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);
5733 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);
5736 radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5737 radius = bound(15, radius, 4096);
5738 VectorScale(color, (2.0f / (8388608.0f)), color);
5739 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5747 Con_Printf("invalid lights file \"%s\"\n", name);
5748 Mem_Free(lightsstring);
5752 // tyrlite/hmap2 light types in the delay field
5753 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5755 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5767 float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5768 char key[256], value[MAX_INPUTLINE];
5771 if (cl.worldmodel == NULL)
5773 Con_Print("No map loaded.\n");
5776 // try to load a .ent file first
5777 dpsnprintf(key, sizeof(key), "%s.ent", cl.worldnamenoextension);
5778 data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5779 // and if that is not found, fall back to the bsp file entity string
5781 data = cl.worldmodel->brush.entities;
5784 for (entnum = 0;COM_ParseToken_Simple(&data, false, false, true) && com_token[0] == '{';entnum++)
5786 type = LIGHTTYPE_MINUSX;
5787 origin[0] = origin[1] = origin[2] = 0;
5788 originhack[0] = originhack[1] = originhack[2] = 0;
5789 angles[0] = angles[1] = angles[2] = 0;
5790 color[0] = color[1] = color[2] = 1;
5791 light[0] = light[1] = light[2] = 1;light[3] = 300;
5792 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5802 if (!COM_ParseToken_Simple(&data, false, false, true))
5804 if (com_token[0] == '}')
5805 break; // end of entity
5806 if (com_token[0] == '_')
5807 strlcpy(key, com_token + 1, sizeof(key));
5809 strlcpy(key, com_token, sizeof(key));
5810 while (key[strlen(key)-1] == ' ') // remove trailing spaces
5811 key[strlen(key)-1] = 0;
5812 if (!COM_ParseToken_Simple(&data, false, false, true))
5814 strlcpy(value, com_token, sizeof(value));
5816 // now that we have the key pair worked out...
5817 if (!strcmp("light", key))
5819 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5823 light[0] = vec[0] * (1.0f / 256.0f);
5824 light[1] = vec[0] * (1.0f / 256.0f);
5825 light[2] = vec[0] * (1.0f / 256.0f);
5831 light[0] = vec[0] * (1.0f / 255.0f);
5832 light[1] = vec[1] * (1.0f / 255.0f);
5833 light[2] = vec[2] * (1.0f / 255.0f);
5837 else if (!strcmp("delay", key))
5839 else if (!strcmp("origin", key))
5840 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5841 else if (!strcmp("angle", key))
5842 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5843 else if (!strcmp("angles", key))
5844 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5845 else if (!strcmp("color", key))
5846 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5847 else if (!strcmp("wait", key))
5848 fadescale = atof(value);
5849 else if (!strcmp("classname", key))
5851 if (!strncmp(value, "light", 5))
5854 if (!strcmp(value, "light_fluoro"))
5859 overridecolor[0] = 1;
5860 overridecolor[1] = 1;
5861 overridecolor[2] = 1;
5863 if (!strcmp(value, "light_fluorospark"))
5868 overridecolor[0] = 1;
5869 overridecolor[1] = 1;
5870 overridecolor[2] = 1;
5872 if (!strcmp(value, "light_globe"))
5877 overridecolor[0] = 1;
5878 overridecolor[1] = 0.8;
5879 overridecolor[2] = 0.4;
5881 if (!strcmp(value, "light_flame_large_yellow"))
5886 overridecolor[0] = 1;
5887 overridecolor[1] = 0.5;
5888 overridecolor[2] = 0.1;
5890 if (!strcmp(value, "light_flame_small_yellow"))
5895 overridecolor[0] = 1;
5896 overridecolor[1] = 0.5;
5897 overridecolor[2] = 0.1;
5899 if (!strcmp(value, "light_torch_small_white"))
5904 overridecolor[0] = 1;
5905 overridecolor[1] = 0.5;
5906 overridecolor[2] = 0.1;
5908 if (!strcmp(value, "light_torch_small_walltorch"))
5913 overridecolor[0] = 1;
5914 overridecolor[1] = 0.5;
5915 overridecolor[2] = 0.1;
5919 else if (!strcmp("style", key))
5920 style = atoi(value);
5921 else if (!strcmp("skin", key))
5922 skin = (int)atof(value);
5923 else if (!strcmp("pflags", key))
5924 pflags = (int)atof(value);
5925 //else if (!strcmp("effects", key))
5926 // effects = (int)atof(value);
5927 else if (cl.worldmodel->type == mod_brushq3)
5929 if (!strcmp("scale", key))
5930 lightscale = atof(value);
5931 if (!strcmp("fade", key))
5932 fadescale = atof(value);
5937 if (lightscale <= 0)
5941 if (color[0] == color[1] && color[0] == color[2])
5943 color[0] *= overridecolor[0];
5944 color[1] *= overridecolor[1];
5945 color[2] *= overridecolor[2];
5947 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
5948 color[0] = color[0] * light[0];
5949 color[1] = color[1] * light[1];
5950 color[2] = color[2] * light[2];
5953 case LIGHTTYPE_MINUSX:
5955 case LIGHTTYPE_RECIPX:
5957 VectorScale(color, (1.0f / 16.0f), color);
5959 case LIGHTTYPE_RECIPXX:
5961 VectorScale(color, (1.0f / 16.0f), color);
5964 case LIGHTTYPE_NONE:
5968 case LIGHTTYPE_MINUSXX:
5971 VectorAdd(origin, originhack, origin);
5973 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);
5976 Mem_Free(entfiledata);
5980 static void R_Shadow_SetCursorLocationForView(void)
5983 vec3_t dest, endpos;
5985 VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
5986 trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true);
5987 if (trace.fraction < 1)
5989 dist = trace.fraction * r_editlights_cursordistance.value;
5990 push = r_editlights_cursorpushback.value;
5994 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
5995 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
5999 VectorClear( endpos );
6001 r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6002 r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6003 r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6006 void R_Shadow_UpdateWorldLightSelection(void)
6008 if (r_editlights.integer)
6010 R_Shadow_SetCursorLocationForView();
6011 R_Shadow_SelectLightInView();
6014 R_Shadow_SelectLight(NULL);
6017 static void R_Shadow_EditLights_Clear_f(void)
6019 R_Shadow_ClearWorldLights();
6022 void R_Shadow_EditLights_Reload_f(void)
6026 strlcpy(r_shadow_mapname, cl.worldname, sizeof(r_shadow_mapname));
6027 R_Shadow_ClearWorldLights();
6028 R_Shadow_LoadWorldLights();
6029 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
6031 R_Shadow_LoadLightsFile();
6032 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
6033 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
6037 static void R_Shadow_EditLights_Save_f(void)
6041 R_Shadow_SaveWorldLights();
6044 static void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
6046 R_Shadow_ClearWorldLights();
6047 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
6050 static void R_Shadow_EditLights_ImportLightsFile_f(void)
6052 R_Shadow_ClearWorldLights();
6053 R_Shadow_LoadLightsFile();
6056 static void R_Shadow_EditLights_Spawn_f(void)
6059 if (!r_editlights.integer)
6061 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6064 if (Cmd_Argc() != 1)
6066 Con_Print("r_editlights_spawn does not take parameters\n");
6069 color[0] = color[1] = color[2] = 1;
6070 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
6073 static void R_Shadow_EditLights_Edit_f(void)
6075 vec3_t origin, angles, color;
6076 vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
6077 int style, shadows, flags, normalmode, realtimemode;
6078 char cubemapname[MAX_INPUTLINE];
6079 if (!r_editlights.integer)
6081 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6084 if (!r_shadow_selectedlight)
6086 Con_Print("No selected light.\n");
6089 VectorCopy(r_shadow_selectedlight->origin, origin);
6090 VectorCopy(r_shadow_selectedlight->angles, angles);
6091 VectorCopy(r_shadow_selectedlight->color, color);
6092 radius = r_shadow_selectedlight->radius;
6093 style = r_shadow_selectedlight->style;
6094 if (r_shadow_selectedlight->cubemapname)
6095 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
6098 shadows = r_shadow_selectedlight->shadow;
6099 corona = r_shadow_selectedlight->corona;
6100 coronasizescale = r_shadow_selectedlight->coronasizescale;
6101 ambientscale = r_shadow_selectedlight->ambientscale;
6102 diffusescale = r_shadow_selectedlight->diffusescale;
6103 specularscale = r_shadow_selectedlight->specularscale;
6104 flags = r_shadow_selectedlight->flags;
6105 normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
6106 realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
6107 if (!strcmp(Cmd_Argv(1), "origin"))
6109 if (Cmd_Argc() != 5)
6111 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6114 origin[0] = atof(Cmd_Argv(2));
6115 origin[1] = atof(Cmd_Argv(3));
6116 origin[2] = atof(Cmd_Argv(4));
6118 else if (!strcmp(Cmd_Argv(1), "originscale"))
6120 if (Cmd_Argc() != 5)
6122 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6125 origin[0] *= atof(Cmd_Argv(2));
6126 origin[1] *= atof(Cmd_Argv(3));
6127 origin[2] *= atof(Cmd_Argv(4));
6129 else if (!strcmp(Cmd_Argv(1), "originx"))
6131 if (Cmd_Argc() != 3)
6133 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6136 origin[0] = atof(Cmd_Argv(2));
6138 else if (!strcmp(Cmd_Argv(1), "originy"))
6140 if (Cmd_Argc() != 3)
6142 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6145 origin[1] = atof(Cmd_Argv(2));
6147 else if (!strcmp(Cmd_Argv(1), "originz"))
6149 if (Cmd_Argc() != 3)
6151 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6154 origin[2] = atof(Cmd_Argv(2));
6156 else if (!strcmp(Cmd_Argv(1), "move"))
6158 if (Cmd_Argc() != 5)
6160 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6163 origin[0] += atof(Cmd_Argv(2));
6164 origin[1] += atof(Cmd_Argv(3));
6165 origin[2] += atof(Cmd_Argv(4));
6167 else if (!strcmp(Cmd_Argv(1), "movex"))
6169 if (Cmd_Argc() != 3)
6171 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6174 origin[0] += atof(Cmd_Argv(2));
6176 else if (!strcmp(Cmd_Argv(1), "movey"))
6178 if (Cmd_Argc() != 3)
6180 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6183 origin[1] += atof(Cmd_Argv(2));
6185 else if (!strcmp(Cmd_Argv(1), "movez"))
6187 if (Cmd_Argc() != 3)
6189 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6192 origin[2] += atof(Cmd_Argv(2));
6194 else if (!strcmp(Cmd_Argv(1), "angles"))
6196 if (Cmd_Argc() != 5)
6198 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6201 angles[0] = atof(Cmd_Argv(2));
6202 angles[1] = atof(Cmd_Argv(3));
6203 angles[2] = atof(Cmd_Argv(4));
6205 else if (!strcmp(Cmd_Argv(1), "anglesx"))
6207 if (Cmd_Argc() != 3)
6209 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6212 angles[0] = atof(Cmd_Argv(2));
6214 else if (!strcmp(Cmd_Argv(1), "anglesy"))
6216 if (Cmd_Argc() != 3)
6218 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6221 angles[1] = atof(Cmd_Argv(2));
6223 else if (!strcmp(Cmd_Argv(1), "anglesz"))
6225 if (Cmd_Argc() != 3)
6227 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6230 angles[2] = atof(Cmd_Argv(2));
6232 else if (!strcmp(Cmd_Argv(1), "color"))
6234 if (Cmd_Argc() != 5)
6236 Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
6239 color[0] = atof(Cmd_Argv(2));
6240 color[1] = atof(Cmd_Argv(3));
6241 color[2] = atof(Cmd_Argv(4));
6243 else if (!strcmp(Cmd_Argv(1), "radius"))
6245 if (Cmd_Argc() != 3)
6247 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6250 radius = atof(Cmd_Argv(2));
6252 else if (!strcmp(Cmd_Argv(1), "colorscale"))
6254 if (Cmd_Argc() == 3)
6256 double scale = atof(Cmd_Argv(2));
6263 if (Cmd_Argc() != 5)
6265 Con_Printf("usage: r_editlights_edit %s red green blue (OR grey instead of red green blue)\n", Cmd_Argv(1));
6268 color[0] *= atof(Cmd_Argv(2));
6269 color[1] *= atof(Cmd_Argv(3));
6270 color[2] *= atof(Cmd_Argv(4));
6273 else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
6275 if (Cmd_Argc() != 3)
6277 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6280 radius *= atof(Cmd_Argv(2));
6282 else if (!strcmp(Cmd_Argv(1), "style"))
6284 if (Cmd_Argc() != 3)
6286 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6289 style = atoi(Cmd_Argv(2));
6291 else if (!strcmp(Cmd_Argv(1), "cubemap"))
6295 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6298 if (Cmd_Argc() == 3)
6299 strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
6303 else if (!strcmp(Cmd_Argv(1), "shadows"))
6305 if (Cmd_Argc() != 3)
6307 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6310 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6312 else if (!strcmp(Cmd_Argv(1), "corona"))
6314 if (Cmd_Argc() != 3)
6316 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6319 corona = atof(Cmd_Argv(2));
6321 else if (!strcmp(Cmd_Argv(1), "coronasize"))
6323 if (Cmd_Argc() != 3)
6325 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6328 coronasizescale = atof(Cmd_Argv(2));
6330 else if (!strcmp(Cmd_Argv(1), "ambient"))
6332 if (Cmd_Argc() != 3)
6334 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6337 ambientscale = atof(Cmd_Argv(2));
6339 else if (!strcmp(Cmd_Argv(1), "diffuse"))
6341 if (Cmd_Argc() != 3)
6343 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6346 diffusescale = atof(Cmd_Argv(2));
6348 else if (!strcmp(Cmd_Argv(1), "specular"))
6350 if (Cmd_Argc() != 3)
6352 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6355 specularscale = atof(Cmd_Argv(2));
6357 else if (!strcmp(Cmd_Argv(1), "normalmode"))
6359 if (Cmd_Argc() != 3)
6361 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6364 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6366 else if (!strcmp(Cmd_Argv(1), "realtimemode"))
6368 if (Cmd_Argc() != 3)
6370 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6373 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6377 Con_Print("usage: r_editlights_edit [property] [value]\n");
6378 Con_Print("Selected light's properties:\n");
6379 Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
6380 Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
6381 Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
6382 Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius);
6383 Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona);
6384 Con_Printf("Style : %i\n", r_shadow_selectedlight->style);
6385 Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
6386 Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname);
6387 Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);
6388 Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale);
6389 Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale);
6390 Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale);
6391 Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
6392 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
6395 flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
6396 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
6399 static void R_Shadow_EditLights_EditAll_f(void)
6402 dlight_t *light, *oldselected;
6405 if (!r_editlights.integer)
6407 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
6411 oldselected = r_shadow_selectedlight;
6412 // EditLights doesn't seem to have a "remove" command or something so:
6413 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6414 for (lightindex = 0;lightindex < range;lightindex++)
6416 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6419 R_Shadow_SelectLight(light);
6420 R_Shadow_EditLights_Edit_f();
6422 // return to old selected (to not mess editing once selection is locked)
6423 R_Shadow_SelectLight(oldselected);
6426 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
6428 int lightnumber, lightcount;
6429 size_t lightindex, range;
6433 if (!r_editlights.integer)
6435 x = vid_conwidth.value - 240;
6437 DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
6440 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6441 for (lightindex = 0;lightindex < range;lightindex++)
6443 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6446 if (light == r_shadow_selectedlight)
6447 lightnumber = lightindex;
6450 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;
6451 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;
6453 if (r_shadow_selectedlight == NULL)
6455 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;
6456 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;
6457 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;
6458 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;
6459 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;
6460 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;
6461 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;
6462 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;
6463 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;
6464 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;
6465 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;
6466 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;
6467 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;
6468 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;
6469 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;
6472 static void R_Shadow_EditLights_ToggleShadow_f(void)
6474 if (!r_editlights.integer)
6476 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6479 if (!r_shadow_selectedlight)
6481 Con_Print("No selected light.\n");
6484 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);
6487 static void R_Shadow_EditLights_ToggleCorona_f(void)
6489 if (!r_editlights.integer)
6491 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6494 if (!r_shadow_selectedlight)
6496 Con_Print("No selected light.\n");
6499 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);
6502 static void R_Shadow_EditLights_Remove_f(void)
6504 if (!r_editlights.integer)
6506 Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n");
6509 if (!r_shadow_selectedlight)
6511 Con_Print("No selected light.\n");
6514 R_Shadow_FreeWorldLight(r_shadow_selectedlight);
6515 r_shadow_selectedlight = NULL;
6518 static void R_Shadow_EditLights_Help_f(void)
6521 "Documentation on r_editlights system:\n"
6523 "r_editlights : enable/disable editing mode\n"
6524 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
6525 "r_editlights_cursorpushback : push back cursor this far from surface\n"
6526 "r_editlights_cursorpushoff : push cursor off surface this far\n"
6527 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
6528 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
6530 "r_editlights_help : this help\n"
6531 "r_editlights_clear : remove all lights\n"
6532 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
6533 "r_editlights_lock : lock selection to current light, if already locked - unlock\n"
6534 "r_editlights_save : save to .rtlights file\n"
6535 "r_editlights_spawn : create a light with default settings\n"
6536 "r_editlights_edit command : edit selected light - more documentation below\n"
6537 "r_editlights_remove : remove selected light\n"
6538 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
6539 "r_editlights_importlightentitiesfrommap : reload light entities\n"
6540 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
6542 "origin x y z : set light location\n"
6543 "originx x: set x component of light location\n"
6544 "originy y: set y component of light location\n"
6545 "originz z: set z component of light location\n"
6546 "move x y z : adjust light location\n"
6547 "movex x: adjust x component of light location\n"
6548 "movey y: adjust y component of light location\n"
6549 "movez z: adjust z component of light location\n"
6550 "angles x y z : set light angles\n"
6551 "anglesx x: set x component of light angles\n"
6552 "anglesy y: set y component of light angles\n"
6553 "anglesz z: set z component of light angles\n"
6554 "color r g b : set color of light (can be brighter than 1 1 1)\n"
6555 "radius radius : set radius (size) of light\n"
6556 "colorscale grey : multiply color of light (1 does nothing)\n"
6557 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
6558 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
6559 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
6560 "originscale x y z : multiply origin of light (1 1 1 does nothing)\n"
6561 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
6562 "cubemap basename : set filter cubemap of light (not yet supported)\n"
6563 "shadows 1/0 : turn on/off shadows\n"
6564 "corona n : set corona intensity\n"
6565 "coronasize n : set corona size (0-1)\n"
6566 "ambient n : set ambient intensity (0-1)\n"
6567 "diffuse n : set diffuse intensity (0-1)\n"
6568 "specular n : set specular intensity (0-1)\n"
6569 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
6570 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
6571 "<nothing> : print light properties to console\n"
6575 static void R_Shadow_EditLights_CopyInfo_f(void)
6577 if (!r_editlights.integer)
6579 Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n");
6582 if (!r_shadow_selectedlight)
6584 Con_Print("No selected light.\n");
6587 VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
6588 VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
6589 r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
6590 r_shadow_bufferlight.style = r_shadow_selectedlight->style;
6591 if (r_shadow_selectedlight->cubemapname)
6592 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
6594 r_shadow_bufferlight.cubemapname[0] = 0;
6595 r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
6596 r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
6597 r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
6598 r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
6599 r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
6600 r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
6601 r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
6604 static void R_Shadow_EditLights_PasteInfo_f(void)
6606 if (!r_editlights.integer)
6608 Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n");
6611 if (!r_shadow_selectedlight)
6613 Con_Print("No selected light.\n");
6616 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);
6619 static void R_Shadow_EditLights_Lock_f(void)
6621 if (!r_editlights.integer)
6623 Con_Print("Cannot lock on light when not in editing mode. Set r_editlights to 1.\n");
6626 if (r_editlights_lockcursor)
6628 r_editlights_lockcursor = false;
6631 if (!r_shadow_selectedlight)
6633 Con_Print("No selected light to lock on.\n");
6636 r_editlights_lockcursor = true;
6639 static void R_Shadow_EditLights_Init(void)
6641 Cvar_RegisterVariable(&r_editlights);
6642 Cvar_RegisterVariable(&r_editlights_cursordistance);
6643 Cvar_RegisterVariable(&r_editlights_cursorpushback);
6644 Cvar_RegisterVariable(&r_editlights_cursorpushoff);
6645 Cvar_RegisterVariable(&r_editlights_cursorgrid);
6646 Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
6647 Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
6648 Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
6649 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)");
6650 Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
6651 Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
6652 Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
6653 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)");
6654 Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
6655 Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
6656 Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
6657 Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
6658 Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
6659 Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
6660 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)");
6661 Cmd_AddCommand("r_editlights_lock", R_Shadow_EditLights_Lock_f, "lock selection to current light, if already locked - unlock");
6667 =============================================================================
6671 =============================================================================
6674 void R_LightPoint(vec3_t color, const vec3_t p, const int flags)
6676 int i, numlights, flag;
6677 float f, relativepoint[3], dist, dist2, lightradius2;
6682 if (r_fullbright.integer)
6684 VectorSet(color, 1, 1, 1);
6690 if (flags & LP_LIGHTMAP)
6692 if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6694 VectorClear(diffuse);
6695 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, color, diffuse, n);
6696 VectorAdd(color, diffuse, color);
6699 VectorSet(color, 1, 1, 1);
6700 color[0] += r_refdef.scene.ambient;
6701 color[1] += r_refdef.scene.ambient;
6702 color[2] += r_refdef.scene.ambient;
6705 if (flags & LP_RTWORLD)
6707 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6708 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6709 for (i = 0; i < numlights; i++)
6711 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6714 light = &dlight->rtlight;
6715 if (!(light->flags & flag))
6718 lightradius2 = light->radius * light->radius;
6719 VectorSubtract(light->shadoworigin, p, relativepoint);
6720 dist2 = VectorLength2(relativepoint);
6721 if (dist2 >= lightradius2)
6723 dist = sqrt(dist2) / light->radius;
6724 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6727 // todo: add to both ambient and diffuse
6728 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6729 VectorMA(color, f, light->currentcolor, color);
6732 if (flags & LP_DYNLIGHT)
6735 for (i = 0;i < r_refdef.scene.numlights;i++)
6737 light = r_refdef.scene.lights[i];
6739 lightradius2 = light->radius * light->radius;
6740 VectorSubtract(light->shadoworigin, p, relativepoint);
6741 dist2 = VectorLength2(relativepoint);
6742 if (dist2 >= lightradius2)
6744 dist = sqrt(dist2) / light->radius;
6745 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6748 // todo: add to both ambient and diffuse
6749 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6750 VectorMA(color, f, light->color, color);
6755 void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags)
6757 int i, numlights, flag;
6760 float relativepoint[3];
6769 if (r_fullbright.integer)
6771 VectorSet(ambient, 1, 1, 1);
6772 VectorClear(diffuse);
6773 VectorClear(lightdir);
6777 if (flags == LP_LIGHTMAP)
6779 VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6780 VectorClear(diffuse);
6781 VectorClear(lightdir);
6782 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6783 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambient, diffuse, lightdir);
6785 VectorSet(ambient, 1, 1, 1);
6789 memset(sample, 0, sizeof(sample));
6790 VectorSet(sample, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6792 if ((flags & LP_LIGHTMAP) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6795 VectorClear(tempambient);
6797 VectorClear(relativepoint);
6798 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
6799 VectorScale(tempambient, r_refdef.lightmapintensity, tempambient);
6800 VectorScale(color, r_refdef.lightmapintensity, color);
6801 VectorAdd(sample, tempambient, sample);
6802 VectorMA(sample , 0.5f , color, sample );
6803 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6804 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6805 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6806 // calculate a weighted average light direction as well
6807 intensity = VectorLength(color);
6808 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6811 if (flags & LP_RTWORLD)
6813 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6814 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6815 for (i = 0; i < numlights; i++)
6817 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6820 light = &dlight->rtlight;
6821 if (!(light->flags & flag))
6824 lightradius2 = light->radius * light->radius;
6825 VectorSubtract(light->shadoworigin, p, relativepoint);
6826 dist2 = VectorLength2(relativepoint);
6827 if (dist2 >= lightradius2)
6829 dist = sqrt(dist2) / light->radius;
6830 intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value;
6831 if (intensity <= 0.0f)
6833 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6835 // scale down intensity to add to both ambient and diffuse
6836 //intensity *= 0.5f;
6837 VectorNormalize(relativepoint);
6838 VectorScale(light->currentcolor, intensity, color);
6839 VectorMA(sample , 0.5f , color, sample );
6840 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6841 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6842 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6843 // calculate a weighted average light direction as well
6844 intensity *= VectorLength(color);
6845 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6847 // FIXME: sample bouncegrid too!
6850 if (flags & LP_DYNLIGHT)
6853 for (i = 0;i < r_refdef.scene.numlights;i++)
6855 light = r_refdef.scene.lights[i];
6857 lightradius2 = light->radius * light->radius;
6858 VectorSubtract(light->shadoworigin, p, relativepoint);
6859 dist2 = VectorLength2(relativepoint);
6860 if (dist2 >= lightradius2)
6862 dist = sqrt(dist2) / light->radius;
6863 intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value;
6864 if (intensity <= 0.0f)
6866 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6868 // scale down intensity to add to both ambient and diffuse
6869 //intensity *= 0.5f;
6870 VectorNormalize(relativepoint);
6871 VectorScale(light->currentcolor, intensity, color);
6872 VectorMA(sample , 0.5f , color, sample );
6873 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6874 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6875 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6876 // calculate a weighted average light direction as well
6877 intensity *= VectorLength(color);
6878 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6882 // calculate the direction we'll use to reduce the sample to a directional light source
6883 VectorCopy(sample + 12, dir);
6884 //VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
6885 VectorNormalize(dir);
6886 // extract the diffuse color along the chosen direction and scale it
6887 diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]);
6888 diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]);
6889 diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]);
6890 // subtract some of diffuse from ambient
6891 VectorMA(sample, -0.333f, diffuse, ambient);
6892 // store the normalized lightdir
6893 VectorCopy(dir, lightdir);