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 qboolean r_shadow_shadowmapshadowsampler;
200 int r_shadow_shadowmappcf;
201 int r_shadow_shadowmapborder;
202 matrix4x4_t r_shadow_shadowmapmatrix;
203 int r_shadow_lightscissor[4];
204 qboolean r_shadow_usingdeferredprepass;
206 int maxshadowtriangles;
209 int maxshadowvertices;
210 float *shadowvertex3f;
220 unsigned char *shadowsides;
221 int *shadowsideslist;
228 int r_shadow_buffer_numleafpvsbytes;
229 unsigned char *r_shadow_buffer_visitingleafpvs;
230 unsigned char *r_shadow_buffer_leafpvs;
231 int *r_shadow_buffer_leaflist;
233 int r_shadow_buffer_numsurfacepvsbytes;
234 unsigned char *r_shadow_buffer_surfacepvs;
235 int *r_shadow_buffer_surfacelist;
236 unsigned char *r_shadow_buffer_surfacesides;
238 int r_shadow_buffer_numshadowtrispvsbytes;
239 unsigned char *r_shadow_buffer_shadowtrispvs;
240 int r_shadow_buffer_numlighttrispvsbytes;
241 unsigned char *r_shadow_buffer_lighttrispvs;
243 rtexturepool_t *r_shadow_texturepool;
244 rtexture_t *r_shadow_attenuationgradienttexture;
245 rtexture_t *r_shadow_attenuation2dtexture;
246 rtexture_t *r_shadow_attenuation3dtexture;
247 skinframe_t *r_shadow_lightcorona;
248 rtexture_t *r_shadow_shadowmap2ddepthbuffer;
249 rtexture_t *r_shadow_shadowmap2ddepthtexture;
250 rtexture_t *r_shadow_shadowmapvsdcttexture;
251 int r_shadow_shadowmapsize; // changes for each light based on distance
252 int r_shadow_shadowmaplod; // changes for each light based on distance
254 GLuint r_shadow_prepassgeometryfbo;
255 GLuint r_shadow_prepasslightingdiffusespecularfbo;
256 GLuint r_shadow_prepasslightingdiffusefbo;
257 int r_shadow_prepass_width;
258 int r_shadow_prepass_height;
259 rtexture_t *r_shadow_prepassgeometrydepthbuffer;
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;
275 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"};
276 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"};
277 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
278 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"};
279 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)"};
280 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
281 cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"};
282 cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};
283 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
284 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
285 cvar_t r_shadow_gloss2exponent = {0, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
286 cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
287 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
288 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
289 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
290 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
291 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "0", "how far to cast shadows"};
292 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)"};
293 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
294 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
295 cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
296 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
297 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)"};
298 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"};
299 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
300 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
301 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"};
302 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)"};
303 cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};
304 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)"};
305 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"};
306 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)"};
307 cvar_t r_shadow_shadowmapping_useshadowsampler = {CVAR_SAVE, "r_shadow_shadowmapping_useshadowsampler", "1", "whether to use sampler2DShadow if available"};
308 cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
309 cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
310 cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "shadowmap size limit"};
311 cvar_t r_shadow_shadowmapping_maxsize = {CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "shadowmap size limit"};
312 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"};
313 //cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
314 //cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
315 cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
316 cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
317 cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
318 cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
319 cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
320 cvar_t r_shadow_sortsurfaces = {0, "r_shadow_sortsurfaces", "1", "improve performance by sorting illuminated surfaces by texture"};
321 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
322 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)"};
323 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)"};
324 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)"};
325 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"};
326 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"};
327 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"};
328 cvar_t r_shadow_bouncegrid_hitmodels = {CVAR_SAVE, "r_shadow_bouncegrid_hitmodels", "0", "enables hitting character model geometry (SLOW)"};
329 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)"};
330 cvar_t r_shadow_bouncegrid_intensity = {CVAR_SAVE, "r_shadow_bouncegrid_intensity", "4", "overall brightness of bouncegrid texture"};
331 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)"};
332 cvar_t r_shadow_bouncegrid_maxbounce = {CVAR_SAVE, "r_shadow_bouncegrid_maxbounce", "2", "maximum number of bounces for a particle (minimum is 0)"};
333 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"};
334 cvar_t r_shadow_bouncegrid_particleintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particleintensity", "1", "brightness of particles contributing to bouncegrid texture"};
335 cvar_t r_shadow_bouncegrid_photons = {CVAR_SAVE, "r_shadow_bouncegrid_photons", "2000", "total photons to shoot per update, divided proportionately between lights"};
336 cvar_t r_shadow_bouncegrid_spacing = {CVAR_SAVE, "r_shadow_bouncegrid_spacing", "64", "unit size of bouncegrid pixel"};
337 cvar_t r_shadow_bouncegrid_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_stablerandom", "1", "make particle distribution consistent from frame to frame"};
338 cvar_t r_shadow_bouncegrid_static = {CVAR_SAVE, "r_shadow_bouncegrid_static", "1", "use static radiosity solution (high quality) rather than dynamic (splotchy)"};
339 cvar_t r_shadow_bouncegrid_static_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when in static mode"};
340 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"};
341 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"};
342 cvar_t r_shadow_bouncegrid_static_photons = {CVAR_SAVE, "r_shadow_bouncegrid_static_photons", "25000", "photons value to use when in static mode"};
343 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"};
344 cvar_t r_shadow_bouncegrid_x = {CVAR_SAVE, "r_shadow_bouncegrid_x", "64", "maximum texture size of bouncegrid on X axis"};
345 cvar_t r_shadow_bouncegrid_y = {CVAR_SAVE, "r_shadow_bouncegrid_y", "64", "maximum texture size of bouncegrid on Y axis"};
346 cvar_t r_shadow_bouncegrid_z = {CVAR_SAVE, "r_shadow_bouncegrid_z", "32", "maximum texture size of bouncegrid on Z axis"};
347 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
348 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"};
349 cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
350 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
351 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
352 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
353 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
354 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
355 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
356 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
357 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
358 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
360 typedef struct r_shadow_bouncegrid_settings_s
363 qboolean bounceanglediffuse;
364 qboolean directionalshading;
365 qboolean includedirectlighting;
366 float dlightparticlemultiplier;
368 float lightradiusscale;
370 float particlebounceintensity;
371 float particleintensity;
376 r_shadow_bouncegrid_settings_t;
378 r_shadow_bouncegrid_settings_t r_shadow_bouncegridsettings;
379 rtexture_t *r_shadow_bouncegridtexture;
380 matrix4x4_t r_shadow_bouncegridmatrix;
381 vec_t r_shadow_bouncegridintensity;
382 qboolean r_shadow_bouncegriddirectional;
383 static double r_shadow_bouncegridtime;
384 static int r_shadow_bouncegridresolution[3];
385 static int r_shadow_bouncegridnumpixels;
386 static unsigned char *r_shadow_bouncegridpixels;
387 static float *r_shadow_bouncegridhighpixels;
389 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
390 #define ATTENTABLESIZE 256
391 // 1D gradient, 2D circle and 3D sphere attenuation textures
392 #define ATTEN1DSIZE 32
393 #define ATTEN2DSIZE 64
394 #define ATTEN3DSIZE 32
396 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
397 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
398 static float r_shadow_attentable[ATTENTABLESIZE+1];
400 rtlight_t *r_shadow_compilingrtlight;
401 static memexpandablearray_t r_shadow_worldlightsarray;
402 dlight_t *r_shadow_selectedlight;
403 dlight_t r_shadow_bufferlight;
404 vec3_t r_editlights_cursorlocation;
405 qboolean r_editlights_lockcursor;
407 extern int con_vislines;
409 void R_Shadow_UncompileWorldLights(void);
410 void R_Shadow_ClearWorldLights(void);
411 void R_Shadow_SaveWorldLights(void);
412 void R_Shadow_LoadWorldLights(void);
413 void R_Shadow_LoadLightsFile(void);
414 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
415 void R_Shadow_EditLights_Reload_f(void);
416 void R_Shadow_ValidateCvars(void);
417 static void R_Shadow_MakeTextures(void);
419 #define EDLIGHTSPRSIZE 8
420 skinframe_t *r_editlights_sprcursor;
421 skinframe_t *r_editlights_sprlight;
422 skinframe_t *r_editlights_sprnoshadowlight;
423 skinframe_t *r_editlights_sprcubemaplight;
424 skinframe_t *r_editlights_sprcubemapnoshadowlight;
425 skinframe_t *r_editlights_sprselection;
427 static void R_Shadow_SetShadowMode(void)
429 r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
430 r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20;
431 r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
432 r_shadow_shadowmapshadowsampler = r_shadow_shadowmapping_useshadowsampler.integer != 0;
433 r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
434 r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
435 r_shadow_shadowmaplod = -1;
436 r_shadow_shadowmapsize = 0;
437 r_shadow_shadowmapsampler = false;
438 r_shadow_shadowmappcf = 0;
439 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
440 if ((r_shadow_shadowmapping.integer || r_shadow_deferred.integer) && vid.support.ext_framebuffer_object)
442 switch(vid.renderpath)
444 case RENDERPATH_GL20:
445 if(r_shadow_shadowmapfilterquality < 0)
447 if (!r_fb.usedepthtextures)
448 r_shadow_shadowmappcf = 1;
449 else 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 && r_shadow_shadowmapshadowsampler;
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 && r_shadow_shadowmapshadowsampler;
463 switch (r_shadow_shadowmapfilterquality)
466 r_shadow_shadowmapsampler = vid.support.arb_shadow && r_shadow_shadowmapshadowsampler;
469 r_shadow_shadowmapsampler = vid.support.arb_shadow && r_shadow_shadowmapshadowsampler;
470 r_shadow_shadowmappcf = 1;
473 r_shadow_shadowmappcf = 1;
476 r_shadow_shadowmappcf = 2;
480 if (!r_fb.usedepthtextures)
481 r_shadow_shadowmapsampler = false;
482 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
484 case RENDERPATH_D3D9:
485 case RENDERPATH_D3D10:
486 case RENDERPATH_D3D11:
487 case RENDERPATH_SOFT:
488 r_shadow_shadowmapsampler = false;
489 r_shadow_shadowmappcf = 1;
490 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
492 case RENDERPATH_GL11:
493 case RENDERPATH_GL13:
494 case RENDERPATH_GLES1:
495 case RENDERPATH_GLES2:
501 qboolean R_Shadow_ShadowMappingEnabled(void)
503 switch (r_shadow_shadowmode)
505 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
512 static void R_Shadow_FreeShadowMaps(void)
514 R_Shadow_SetShadowMode();
516 R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d);
520 if (r_shadow_shadowmap2ddepthtexture)
521 R_FreeTexture(r_shadow_shadowmap2ddepthtexture);
522 r_shadow_shadowmap2ddepthtexture = NULL;
524 if (r_shadow_shadowmap2ddepthbuffer)
525 R_FreeTexture(r_shadow_shadowmap2ddepthbuffer);
526 r_shadow_shadowmap2ddepthbuffer = NULL;
528 if (r_shadow_shadowmapvsdcttexture)
529 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
530 r_shadow_shadowmapvsdcttexture = NULL;
533 static void r_shadow_start(void)
535 // allocate vertex processing arrays
536 r_shadow_bouncegridpixels = NULL;
537 r_shadow_bouncegridhighpixels = NULL;
538 r_shadow_bouncegridnumpixels = 0;
539 r_shadow_bouncegridtexture = NULL;
540 r_shadow_bouncegriddirectional = false;
541 r_shadow_attenuationgradienttexture = NULL;
542 r_shadow_attenuation2dtexture = NULL;
543 r_shadow_attenuation3dtexture = NULL;
544 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
545 r_shadow_shadowmap2ddepthtexture = NULL;
546 r_shadow_shadowmap2ddepthbuffer = NULL;
547 r_shadow_shadowmapvsdcttexture = NULL;
548 r_shadow_shadowmapmaxsize = 0;
549 r_shadow_shadowmapsize = 0;
550 r_shadow_shadowmaplod = 0;
551 r_shadow_shadowmapfilterquality = -1;
552 r_shadow_shadowmapdepthbits = 0;
553 r_shadow_shadowmapvsdct = false;
554 r_shadow_shadowmapsampler = false;
555 r_shadow_shadowmappcf = 0;
558 R_Shadow_FreeShadowMaps();
560 r_shadow_texturepool = NULL;
561 r_shadow_filters_texturepool = NULL;
562 R_Shadow_ValidateCvars();
563 R_Shadow_MakeTextures();
564 maxshadowtriangles = 0;
565 shadowelements = NULL;
566 maxshadowvertices = 0;
567 shadowvertex3f = NULL;
575 shadowmarklist = NULL;
580 shadowsideslist = NULL;
581 r_shadow_buffer_numleafpvsbytes = 0;
582 r_shadow_buffer_visitingleafpvs = NULL;
583 r_shadow_buffer_leafpvs = NULL;
584 r_shadow_buffer_leaflist = NULL;
585 r_shadow_buffer_numsurfacepvsbytes = 0;
586 r_shadow_buffer_surfacepvs = NULL;
587 r_shadow_buffer_surfacelist = NULL;
588 r_shadow_buffer_surfacesides = NULL;
589 r_shadow_buffer_numshadowtrispvsbytes = 0;
590 r_shadow_buffer_shadowtrispvs = NULL;
591 r_shadow_buffer_numlighttrispvsbytes = 0;
592 r_shadow_buffer_lighttrispvs = NULL;
594 r_shadow_usingdeferredprepass = false;
595 r_shadow_prepass_width = r_shadow_prepass_height = 0;
598 static void R_Shadow_FreeDeferred(void);
599 static void r_shadow_shutdown(void)
602 R_Shadow_UncompileWorldLights();
604 R_Shadow_FreeShadowMaps();
606 r_shadow_usingdeferredprepass = false;
607 if (r_shadow_prepass_width)
608 R_Shadow_FreeDeferred();
609 r_shadow_prepass_width = r_shadow_prepass_height = 0;
612 r_shadow_bouncegridtexture = NULL;
613 r_shadow_bouncegridpixels = NULL;
614 r_shadow_bouncegridhighpixels = NULL;
615 r_shadow_bouncegridnumpixels = 0;
616 r_shadow_bouncegriddirectional = false;
617 r_shadow_attenuationgradienttexture = NULL;
618 r_shadow_attenuation2dtexture = NULL;
619 r_shadow_attenuation3dtexture = NULL;
620 R_FreeTexturePool(&r_shadow_texturepool);
621 R_FreeTexturePool(&r_shadow_filters_texturepool);
622 maxshadowtriangles = 0;
624 Mem_Free(shadowelements);
625 shadowelements = NULL;
627 Mem_Free(shadowvertex3f);
628 shadowvertex3f = NULL;
631 Mem_Free(vertexupdate);
634 Mem_Free(vertexremap);
640 Mem_Free(shadowmark);
643 Mem_Free(shadowmarklist);
644 shadowmarklist = NULL;
649 Mem_Free(shadowsides);
652 Mem_Free(shadowsideslist);
653 shadowsideslist = NULL;
654 r_shadow_buffer_numleafpvsbytes = 0;
655 if (r_shadow_buffer_visitingleafpvs)
656 Mem_Free(r_shadow_buffer_visitingleafpvs);
657 r_shadow_buffer_visitingleafpvs = NULL;
658 if (r_shadow_buffer_leafpvs)
659 Mem_Free(r_shadow_buffer_leafpvs);
660 r_shadow_buffer_leafpvs = NULL;
661 if (r_shadow_buffer_leaflist)
662 Mem_Free(r_shadow_buffer_leaflist);
663 r_shadow_buffer_leaflist = NULL;
664 r_shadow_buffer_numsurfacepvsbytes = 0;
665 if (r_shadow_buffer_surfacepvs)
666 Mem_Free(r_shadow_buffer_surfacepvs);
667 r_shadow_buffer_surfacepvs = NULL;
668 if (r_shadow_buffer_surfacelist)
669 Mem_Free(r_shadow_buffer_surfacelist);
670 r_shadow_buffer_surfacelist = NULL;
671 if (r_shadow_buffer_surfacesides)
672 Mem_Free(r_shadow_buffer_surfacesides);
673 r_shadow_buffer_surfacesides = NULL;
674 r_shadow_buffer_numshadowtrispvsbytes = 0;
675 if (r_shadow_buffer_shadowtrispvs)
676 Mem_Free(r_shadow_buffer_shadowtrispvs);
677 r_shadow_buffer_numlighttrispvsbytes = 0;
678 if (r_shadow_buffer_lighttrispvs)
679 Mem_Free(r_shadow_buffer_lighttrispvs);
682 static void r_shadow_newmap(void)
684 if (r_shadow_bouncegridtexture) R_FreeTexture(r_shadow_bouncegridtexture);r_shadow_bouncegridtexture = NULL;
685 if (r_shadow_lightcorona) R_SkinFrame_MarkUsed(r_shadow_lightcorona);
686 if (r_editlights_sprcursor) R_SkinFrame_MarkUsed(r_editlights_sprcursor);
687 if (r_editlights_sprlight) R_SkinFrame_MarkUsed(r_editlights_sprlight);
688 if (r_editlights_sprnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
689 if (r_editlights_sprcubemaplight) R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
690 if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
691 if (r_editlights_sprselection) R_SkinFrame_MarkUsed(r_editlights_sprselection);
692 if (strncmp(cl.worldname, r_shadow_mapname, sizeof(r_shadow_mapname)))
693 R_Shadow_EditLights_Reload_f();
696 void R_Shadow_Init(void)
698 Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
699 Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
700 Cvar_RegisterVariable(&r_shadow_usebihculling);
701 Cvar_RegisterVariable(&r_shadow_usenormalmap);
702 Cvar_RegisterVariable(&r_shadow_debuglight);
703 Cvar_RegisterVariable(&r_shadow_deferred);
704 Cvar_RegisterVariable(&r_shadow_gloss);
705 Cvar_RegisterVariable(&r_shadow_gloss2intensity);
706 Cvar_RegisterVariable(&r_shadow_glossintensity);
707 Cvar_RegisterVariable(&r_shadow_glossexponent);
708 Cvar_RegisterVariable(&r_shadow_gloss2exponent);
709 Cvar_RegisterVariable(&r_shadow_glossexact);
710 Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
711 Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
712 Cvar_RegisterVariable(&r_shadow_lightintensityscale);
713 Cvar_RegisterVariable(&r_shadow_lightradiusscale);
714 Cvar_RegisterVariable(&r_shadow_projectdistance);
715 Cvar_RegisterVariable(&r_shadow_frontsidecasting);
716 Cvar_RegisterVariable(&r_shadow_realtime_dlight);
717 Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
718 Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
719 Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
720 Cvar_RegisterVariable(&r_shadow_realtime_world);
721 Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
722 Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
723 Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
724 Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
725 Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
726 Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
727 Cvar_RegisterVariable(&r_shadow_scissor);
728 Cvar_RegisterVariable(&r_shadow_shadowmapping);
729 Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
730 Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
731 Cvar_RegisterVariable(&r_shadow_shadowmapping_useshadowsampler);
732 Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
733 Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
734 Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
735 Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
736 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
737 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
738 Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
739 Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
740 Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
741 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
742 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
743 Cvar_RegisterVariable(&r_shadow_sortsurfaces);
744 Cvar_RegisterVariable(&r_shadow_polygonfactor);
745 Cvar_RegisterVariable(&r_shadow_polygonoffset);
746 Cvar_RegisterVariable(&r_shadow_texture3d);
747 Cvar_RegisterVariable(&r_shadow_bouncegrid);
748 Cvar_RegisterVariable(&r_shadow_bouncegrid_bounceanglediffuse);
749 Cvar_RegisterVariable(&r_shadow_bouncegrid_directionalshading);
750 Cvar_RegisterVariable(&r_shadow_bouncegrid_dlightparticlemultiplier);
751 Cvar_RegisterVariable(&r_shadow_bouncegrid_hitmodels);
752 Cvar_RegisterVariable(&r_shadow_bouncegrid_includedirectlighting);
753 Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
754 Cvar_RegisterVariable(&r_shadow_bouncegrid_lightradiusscale);
755 Cvar_RegisterVariable(&r_shadow_bouncegrid_maxbounce);
756 Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
757 Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
758 Cvar_RegisterVariable(&r_shadow_bouncegrid_photons);
759 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacing);
760 Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom);
761 Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
762 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
763 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_lightradiusscale);
764 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxbounce);
765 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_photons);
766 Cvar_RegisterVariable(&r_shadow_bouncegrid_updateinterval);
767 Cvar_RegisterVariable(&r_shadow_bouncegrid_x);
768 Cvar_RegisterVariable(&r_shadow_bouncegrid_y);
769 Cvar_RegisterVariable(&r_shadow_bouncegrid_z);
770 Cvar_RegisterVariable(&r_coronas);
771 Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
772 Cvar_RegisterVariable(&r_coronas_occlusionquery);
773 Cvar_RegisterVariable(&gl_flashblend);
774 Cvar_RegisterVariable(&gl_ext_separatestencil);
775 Cvar_RegisterVariable(&gl_ext_stenciltwoside);
776 R_Shadow_EditLights_Init();
777 Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
778 maxshadowtriangles = 0;
779 shadowelements = NULL;
780 maxshadowvertices = 0;
781 shadowvertex3f = NULL;
789 shadowmarklist = NULL;
794 shadowsideslist = NULL;
795 r_shadow_buffer_numleafpvsbytes = 0;
796 r_shadow_buffer_visitingleafpvs = NULL;
797 r_shadow_buffer_leafpvs = NULL;
798 r_shadow_buffer_leaflist = NULL;
799 r_shadow_buffer_numsurfacepvsbytes = 0;
800 r_shadow_buffer_surfacepvs = NULL;
801 r_shadow_buffer_surfacelist = NULL;
802 r_shadow_buffer_surfacesides = NULL;
803 r_shadow_buffer_shadowtrispvs = NULL;
804 r_shadow_buffer_lighttrispvs = NULL;
805 R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
808 matrix4x4_t matrix_attenuationxyz =
811 {0.5, 0.0, 0.0, 0.5},
812 {0.0, 0.5, 0.0, 0.5},
813 {0.0, 0.0, 0.5, 0.5},
818 matrix4x4_t matrix_attenuationz =
821 {0.0, 0.0, 0.5, 0.5},
822 {0.0, 0.0, 0.0, 0.5},
823 {0.0, 0.0, 0.0, 0.5},
828 static void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
830 numvertices = ((numvertices + 255) & ~255) * vertscale;
831 numtriangles = ((numtriangles + 255) & ~255) * triscale;
832 // make sure shadowelements is big enough for this volume
833 if (maxshadowtriangles < numtriangles)
835 maxshadowtriangles = numtriangles;
837 Mem_Free(shadowelements);
838 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
840 // make sure shadowvertex3f is big enough for this volume
841 if (maxshadowvertices < numvertices)
843 maxshadowvertices = numvertices;
845 Mem_Free(shadowvertex3f);
846 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
850 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
852 int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
853 int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
854 int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
855 int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
856 if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
858 if (r_shadow_buffer_visitingleafpvs)
859 Mem_Free(r_shadow_buffer_visitingleafpvs);
860 if (r_shadow_buffer_leafpvs)
861 Mem_Free(r_shadow_buffer_leafpvs);
862 if (r_shadow_buffer_leaflist)
863 Mem_Free(r_shadow_buffer_leaflist);
864 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
865 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
866 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
867 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
869 if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
871 if (r_shadow_buffer_surfacepvs)
872 Mem_Free(r_shadow_buffer_surfacepvs);
873 if (r_shadow_buffer_surfacelist)
874 Mem_Free(r_shadow_buffer_surfacelist);
875 if (r_shadow_buffer_surfacesides)
876 Mem_Free(r_shadow_buffer_surfacesides);
877 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
878 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
879 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
880 r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
882 if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
884 if (r_shadow_buffer_shadowtrispvs)
885 Mem_Free(r_shadow_buffer_shadowtrispvs);
886 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
887 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
889 if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
891 if (r_shadow_buffer_lighttrispvs)
892 Mem_Free(r_shadow_buffer_lighttrispvs);
893 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
894 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
898 void R_Shadow_PrepareShadowMark(int numtris)
900 // make sure shadowmark is big enough for this volume
901 if (maxshadowmark < numtris)
903 maxshadowmark = numtris;
905 Mem_Free(shadowmark);
907 Mem_Free(shadowmarklist);
908 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
909 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
913 // if shadowmarkcount wrapped we clear the array and adjust accordingly
914 if (shadowmarkcount == 0)
917 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
922 void R_Shadow_PrepareShadowSides(int numtris)
924 if (maxshadowsides < numtris)
926 maxshadowsides = numtris;
928 Mem_Free(shadowsides);
930 Mem_Free(shadowsideslist);
931 shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
932 shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
937 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)
940 int outtriangles = 0, outvertices = 0;
943 float ratio, direction[3], projectvector[3];
945 if (projectdirection)
946 VectorScale(projectdirection, projectdistance, projectvector);
948 VectorClear(projectvector);
950 // create the vertices
951 if (projectdirection)
953 for (i = 0;i < numshadowmarktris;i++)
955 element = inelement3i + shadowmarktris[i] * 3;
956 for (j = 0;j < 3;j++)
958 if (vertexupdate[element[j]] != vertexupdatenum)
960 vertexupdate[element[j]] = vertexupdatenum;
961 vertexremap[element[j]] = outvertices;
962 vertex = invertex3f + element[j] * 3;
963 // project one copy of the vertex according to projectvector
964 VectorCopy(vertex, outvertex3f);
965 VectorAdd(vertex, projectvector, (outvertex3f + 3));
974 for (i = 0;i < numshadowmarktris;i++)
976 element = inelement3i + shadowmarktris[i] * 3;
977 for (j = 0;j < 3;j++)
979 if (vertexupdate[element[j]] != vertexupdatenum)
981 vertexupdate[element[j]] = vertexupdatenum;
982 vertexremap[element[j]] = outvertices;
983 vertex = invertex3f + element[j] * 3;
984 // project one copy of the vertex to the sphere radius of the light
985 // (FIXME: would projecting it to the light box be better?)
986 VectorSubtract(vertex, projectorigin, direction);
987 ratio = projectdistance / VectorLength(direction);
988 VectorCopy(vertex, outvertex3f);
989 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
997 if (r_shadow_frontsidecasting.integer)
999 for (i = 0;i < numshadowmarktris;i++)
1001 int remappedelement[3];
1003 const int *neighbortriangle;
1005 markindex = shadowmarktris[i] * 3;
1006 element = inelement3i + markindex;
1007 neighbortriangle = inneighbor3i + markindex;
1008 // output the front and back triangles
1009 outelement3i[0] = vertexremap[element[0]];
1010 outelement3i[1] = vertexremap[element[1]];
1011 outelement3i[2] = vertexremap[element[2]];
1012 outelement3i[3] = vertexremap[element[2]] + 1;
1013 outelement3i[4] = vertexremap[element[1]] + 1;
1014 outelement3i[5] = vertexremap[element[0]] + 1;
1018 // output the sides (facing outward from this triangle)
1019 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1021 remappedelement[0] = vertexremap[element[0]];
1022 remappedelement[1] = vertexremap[element[1]];
1023 outelement3i[0] = remappedelement[1];
1024 outelement3i[1] = remappedelement[0];
1025 outelement3i[2] = remappedelement[0] + 1;
1026 outelement3i[3] = remappedelement[1];
1027 outelement3i[4] = remappedelement[0] + 1;
1028 outelement3i[5] = remappedelement[1] + 1;
1033 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1035 remappedelement[1] = vertexremap[element[1]];
1036 remappedelement[2] = vertexremap[element[2]];
1037 outelement3i[0] = remappedelement[2];
1038 outelement3i[1] = remappedelement[1];
1039 outelement3i[2] = remappedelement[1] + 1;
1040 outelement3i[3] = remappedelement[2];
1041 outelement3i[4] = remappedelement[1] + 1;
1042 outelement3i[5] = remappedelement[2] + 1;
1047 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1049 remappedelement[0] = vertexremap[element[0]];
1050 remappedelement[2] = vertexremap[element[2]];
1051 outelement3i[0] = remappedelement[0];
1052 outelement3i[1] = remappedelement[2];
1053 outelement3i[2] = remappedelement[2] + 1;
1054 outelement3i[3] = remappedelement[0];
1055 outelement3i[4] = remappedelement[2] + 1;
1056 outelement3i[5] = remappedelement[0] + 1;
1065 for (i = 0;i < numshadowmarktris;i++)
1067 int remappedelement[3];
1069 const int *neighbortriangle;
1071 markindex = shadowmarktris[i] * 3;
1072 element = inelement3i + markindex;
1073 neighbortriangle = inneighbor3i + markindex;
1074 // output the front and back triangles
1075 outelement3i[0] = vertexremap[element[2]];
1076 outelement3i[1] = vertexremap[element[1]];
1077 outelement3i[2] = vertexremap[element[0]];
1078 outelement3i[3] = vertexremap[element[0]] + 1;
1079 outelement3i[4] = vertexremap[element[1]] + 1;
1080 outelement3i[5] = vertexremap[element[2]] + 1;
1084 // output the sides (facing outward from this triangle)
1085 if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1087 remappedelement[0] = vertexremap[element[0]];
1088 remappedelement[1] = vertexremap[element[1]];
1089 outelement3i[0] = remappedelement[0];
1090 outelement3i[1] = remappedelement[1];
1091 outelement3i[2] = remappedelement[1] + 1;
1092 outelement3i[3] = remappedelement[0];
1093 outelement3i[4] = remappedelement[1] + 1;
1094 outelement3i[5] = remappedelement[0] + 1;
1099 if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1101 remappedelement[1] = vertexremap[element[1]];
1102 remappedelement[2] = vertexremap[element[2]];
1103 outelement3i[0] = remappedelement[1];
1104 outelement3i[1] = remappedelement[2];
1105 outelement3i[2] = remappedelement[2] + 1;
1106 outelement3i[3] = remappedelement[1];
1107 outelement3i[4] = remappedelement[2] + 1;
1108 outelement3i[5] = remappedelement[1] + 1;
1113 if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1115 remappedelement[0] = vertexremap[element[0]];
1116 remappedelement[2] = vertexremap[element[2]];
1117 outelement3i[0] = remappedelement[2];
1118 outelement3i[1] = remappedelement[0];
1119 outelement3i[2] = remappedelement[0] + 1;
1120 outelement3i[3] = remappedelement[2];
1121 outelement3i[4] = remappedelement[0] + 1;
1122 outelement3i[5] = remappedelement[2] + 1;
1130 *outnumvertices = outvertices;
1131 return outtriangles;
1134 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)
1137 int outtriangles = 0, outvertices = 0;
1139 const float *vertex;
1140 float ratio, direction[3], projectvector[3];
1143 if (projectdirection)
1144 VectorScale(projectdirection, projectdistance, projectvector);
1146 VectorClear(projectvector);
1148 for (i = 0;i < numshadowmarktris;i++)
1150 int remappedelement[3];
1152 const int *neighbortriangle;
1154 markindex = shadowmarktris[i] * 3;
1155 neighbortriangle = inneighbor3i + markindex;
1156 side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
1157 side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
1158 side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
1159 if (side[0] + side[1] + side[2] == 0)
1163 element = inelement3i + markindex;
1165 // create the vertices
1166 for (j = 0;j < 3;j++)
1168 if (side[j] + side[j+1] == 0)
1171 if (vertexupdate[k] != vertexupdatenum)
1173 vertexupdate[k] = vertexupdatenum;
1174 vertexremap[k] = outvertices;
1175 vertex = invertex3f + k * 3;
1176 VectorCopy(vertex, outvertex3f);
1177 if (projectdirection)
1179 // project one copy of the vertex according to projectvector
1180 VectorAdd(vertex, projectvector, (outvertex3f + 3));
1184 // project one copy of the vertex to the sphere radius of the light
1185 // (FIXME: would projecting it to the light box be better?)
1186 VectorSubtract(vertex, projectorigin, direction);
1187 ratio = projectdistance / VectorLength(direction);
1188 VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
1195 // output the sides (facing outward from this triangle)
1198 remappedelement[0] = vertexremap[element[0]];
1199 remappedelement[1] = vertexremap[element[1]];
1200 outelement3i[0] = remappedelement[1];
1201 outelement3i[1] = remappedelement[0];
1202 outelement3i[2] = remappedelement[0] + 1;
1203 outelement3i[3] = remappedelement[1];
1204 outelement3i[4] = remappedelement[0] + 1;
1205 outelement3i[5] = remappedelement[1] + 1;
1212 remappedelement[1] = vertexremap[element[1]];
1213 remappedelement[2] = vertexremap[element[2]];
1214 outelement3i[0] = remappedelement[2];
1215 outelement3i[1] = remappedelement[1];
1216 outelement3i[2] = remappedelement[1] + 1;
1217 outelement3i[3] = remappedelement[2];
1218 outelement3i[4] = remappedelement[1] + 1;
1219 outelement3i[5] = remappedelement[2] + 1;
1226 remappedelement[0] = vertexremap[element[0]];
1227 remappedelement[2] = vertexremap[element[2]];
1228 outelement3i[0] = remappedelement[0];
1229 outelement3i[1] = remappedelement[2];
1230 outelement3i[2] = remappedelement[2] + 1;
1231 outelement3i[3] = remappedelement[0];
1232 outelement3i[4] = remappedelement[2] + 1;
1233 outelement3i[5] = remappedelement[0] + 1;
1240 *outnumvertices = outvertices;
1241 return outtriangles;
1244 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)
1250 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1252 tend = firsttriangle + numtris;
1253 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1255 // surface box entirely inside light box, no box cull
1256 if (projectdirection)
1258 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1260 TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal);
1261 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1262 shadowmarklist[numshadowmark++] = t;
1267 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1268 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
1269 shadowmarklist[numshadowmark++] = t;
1274 // surface box not entirely inside light box, cull each triangle
1275 if (projectdirection)
1277 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1279 v[0] = invertex3f + e[0] * 3;
1280 v[1] = invertex3f + e[1] * 3;
1281 v[2] = invertex3f + e[2] * 3;
1282 TriangleNormal(v[0], v[1], v[2], normal);
1283 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1284 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1285 shadowmarklist[numshadowmark++] = t;
1290 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1292 v[0] = invertex3f + e[0] * 3;
1293 v[1] = invertex3f + e[1] * 3;
1294 v[2] = invertex3f + e[2] * 3;
1295 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1296 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1297 shadowmarklist[numshadowmark++] = t;
1303 static qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
1308 if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
1310 // check if the shadow volume intersects the near plane
1312 // a ray between the eye and light origin may intersect the caster,
1313 // indicating that the shadow may touch the eye location, however we must
1314 // test the near plane (a polygon), not merely the eye location, so it is
1315 // easiest to enlarge the caster bounding shape slightly for this.
1321 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)
1323 int i, tris, outverts;
1324 if (projectdistance < 0.1)
1326 Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
1329 if (!numverts || !nummarktris)
1331 // make sure shadowelements is big enough for this volume
1332 if (maxshadowtriangles < nummarktris*8 || maxshadowvertices < numverts*2)
1333 R_Shadow_ResizeShadowArrays(numverts, nummarktris, 2, 8);
1335 if (maxvertexupdate < numverts)
1337 maxvertexupdate = numverts;
1339 Mem_Free(vertexupdate);
1341 Mem_Free(vertexremap);
1342 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1343 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1344 vertexupdatenum = 0;
1347 if (vertexupdatenum == 0)
1349 vertexupdatenum = 1;
1350 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
1351 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
1354 for (i = 0;i < nummarktris;i++)
1355 shadowmark[marktris[i]] = shadowmarkcount;
1357 if (r_shadow_compilingrtlight)
1359 // if we're compiling an rtlight, capture the mesh
1360 //tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1361 //Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1362 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1363 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1365 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
1367 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1368 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1369 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1373 // decide which type of shadow to generate and set stencil mode
1374 R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
1375 // generate the sides or a solid volume, depending on type
1376 if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
1377 tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1379 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1380 r_refdef.stats.lights_dynamicshadowtriangles += tris;
1381 r_refdef.stats.lights_shadowtriangles += tris;
1382 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
1384 // increment stencil if frontface is infront of depthbuffer
1385 GL_CullFace(r_refdef.view.cullface_front);
1386 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
1387 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1388 // decrement stencil if backface is infront of depthbuffer
1389 GL_CullFace(r_refdef.view.cullface_back);
1390 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
1392 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
1394 // decrement stencil if backface is behind depthbuffer
1395 GL_CullFace(r_refdef.view.cullface_front);
1396 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
1397 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1398 // increment stencil if frontface is behind depthbuffer
1399 GL_CullFace(r_refdef.view.cullface_back);
1400 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
1402 R_Mesh_PrepareVertices_Vertex3f(outverts, shadowvertex3f, NULL);
1403 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, NULL, NULL, 0);
1407 int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
1409 // p1, p2, p3 are in the cubemap's local coordinate system
1410 // bias = border/(size - border)
1413 float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1414 dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
1415 dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
1416 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1418 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1419 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1420 | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1421 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1423 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1424 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1425 | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1427 dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1428 dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
1429 dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
1430 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1432 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1433 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1434 | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1435 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1437 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1438 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1439 | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1441 dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1442 dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
1443 dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
1444 if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1446 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1447 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1448 | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1449 if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1451 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1452 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1453 | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1458 static int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
1460 vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
1461 float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
1464 VectorSubtract(maxs, mins, radius);
1465 VectorScale(radius, 0.5f, radius);
1466 VectorAdd(mins, radius, center);
1467 Matrix4x4_Transform(worldtolight, center, lightcenter);
1468 Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
1469 VectorSubtract(lightcenter, lightradius, pmin);
1470 VectorAdd(lightcenter, lightradius, pmax);
1472 dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1473 dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
1474 if(ap1 > bias*an1 && ap2 > bias*an2)
1476 | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1477 | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1478 if(an1 > bias*ap1 && an2 > bias*ap2)
1480 | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1481 | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1483 dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1484 dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
1485 if(ap1 > bias*an1 && ap2 > bias*an2)
1487 | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1488 | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1489 if(an1 > bias*ap1 && an2 > bias*ap2)
1491 | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1492 | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1494 dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1495 dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
1496 if(ap1 > bias*an1 && ap2 > bias*an2)
1498 | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1499 | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1500 if(an1 > bias*ap1 && an2 > bias*ap2)
1502 | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1503 | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1508 #define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
1510 int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
1512 // p is in the cubemap's local coordinate system
1513 // bias = border/(size - border)
1514 float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
1515 float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
1516 float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
1518 if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
1519 if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
1520 if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
1521 if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
1522 if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
1523 if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
1527 static int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
1531 int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
1532 float scale = (size - 2*border)/size, len;
1533 float bias = border / (float)(size - border), dp, dn, ap, an;
1534 // check if cone enclosing side would cross frustum plane
1535 scale = 2 / (scale*scale + 2);
1536 for (i = 0;i < 5;i++)
1538 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) > -0.03125)
1540 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
1541 len = scale*VectorLength2(n);
1542 if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
1543 if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
1544 if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
1546 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
1548 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
1549 len = scale*VectorLength(n);
1550 if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
1551 if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
1552 if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
1554 // this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
1555 // check if frustum corners/origin cross plane sides
1557 // infinite version, assumes frustum corners merely give direction and extend to infinite distance
1558 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.origin, p);
1559 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1560 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1561 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1562 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1563 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1564 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1565 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1566 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1567 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1568 for (i = 0;i < 4;i++)
1570 Matrix4x4_Transform(&rtlight->matrix_worldtolight, r_refdef.view.frustumcorner[i], n);
1571 VectorSubtract(n, p, n);
1572 dp = n[0] + n[1], dn = n[0] - n[1], ap = fabs(dp), an = fabs(dn);
1573 if(ap > 0) masks[0] |= dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2);
1574 if(an > 0) masks[1] |= dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2);
1575 dp = n[1] + n[2], dn = n[1] - n[2], ap = fabs(dp), an = fabs(dn);
1576 if(ap > 0) masks[2] |= dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4);
1577 if(an > 0) masks[3] |= dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4);
1578 dp = n[2] + n[0], dn = n[2] - n[0], ap = fabs(dp), an = fabs(dn);
1579 if(ap > 0) masks[4] |= dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0);
1580 if(an > 0) masks[5] |= dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0);
1583 // finite version, assumes corners are a finite distance from origin dependent on far plane
1584 for (i = 0;i < 5;i++)
1586 Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
1587 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn);
1588 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1589 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1590 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn);
1591 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1592 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1593 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn);
1594 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1595 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1598 return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
1601 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)
1609 int mask, surfacemask = 0;
1610 if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1612 bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
1613 tend = firsttriangle + numtris;
1614 if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1616 // surface box entirely inside light box, no box cull
1617 if (projectdirection)
1619 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1621 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1622 TriangleNormal(v[0], v[1], v[2], normal);
1623 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1625 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1626 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1627 surfacemask |= mask;
1630 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;
1631 shadowsides[numshadowsides] = mask;
1632 shadowsideslist[numshadowsides++] = t;
1639 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1641 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1642 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
1644 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1645 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1646 surfacemask |= mask;
1649 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;
1650 shadowsides[numshadowsides] = mask;
1651 shadowsideslist[numshadowsides++] = t;
1659 // surface box not entirely inside light box, cull each triangle
1660 if (projectdirection)
1662 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1664 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1665 TriangleNormal(v[0], v[1], v[2], normal);
1666 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1667 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1669 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1670 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1671 surfacemask |= mask;
1674 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;
1675 shadowsides[numshadowsides] = mask;
1676 shadowsideslist[numshadowsides++] = t;
1683 for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1685 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1686 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1687 && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1689 Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1690 mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1691 surfacemask |= mask;
1694 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;
1695 shadowsides[numshadowsides] = mask;
1696 shadowsideslist[numshadowsides++] = t;
1705 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)
1707 int i, j, outtriangles = 0;
1708 int *outelement3i[6];
1709 if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
1711 outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
1712 // make sure shadowelements is big enough for this mesh
1713 if (maxshadowtriangles < outtriangles)
1714 R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
1716 // compute the offset and size of the separate index lists for each cubemap side
1718 for (i = 0;i < 6;i++)
1720 outelement3i[i] = shadowelements + outtriangles * 3;
1721 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
1722 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
1723 outtriangles += sidetotals[i];
1726 // gather up the (sparse) triangles into separate index lists for each cubemap side
1727 for (i = 0;i < numsidetris;i++)
1729 const int *element = elements + sidetris[i] * 3;
1730 for (j = 0;j < 6;j++)
1732 if (sides[i] & (1 << j))
1734 outelement3i[j][0] = element[0];
1735 outelement3i[j][1] = element[1];
1736 outelement3i[j][2] = element[2];
1737 outelement3i[j] += 3;
1742 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, outtriangles, shadowelements);
1745 static void R_Shadow_MakeTextures_MakeCorona(void)
1749 unsigned char pixels[32][32][4];
1750 for (y = 0;y < 32;y++)
1752 dy = (y - 15.5f) * (1.0f / 16.0f);
1753 for (x = 0;x < 32;x++)
1755 dx = (x - 15.5f) * (1.0f / 16.0f);
1756 a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1757 a = bound(0, a, 255);
1758 pixels[y][x][0] = a;
1759 pixels[y][x][1] = a;
1760 pixels[y][x][2] = a;
1761 pixels[y][x][3] = 255;
1764 r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32, false);
1767 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1769 float dist = sqrt(x*x+y*y+z*z);
1770 float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1771 // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1772 return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1775 static void R_Shadow_MakeTextures(void)
1778 float intensity, dist;
1780 R_Shadow_FreeShadowMaps();
1781 R_FreeTexturePool(&r_shadow_texturepool);
1782 r_shadow_texturepool = R_AllocTexturePool();
1783 r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1784 r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1785 data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1786 // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1787 for (x = 0;x <= ATTENTABLESIZE;x++)
1789 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1790 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1791 r_shadow_attentable[x] = bound(0, intensity, 1);
1793 // 1D gradient texture
1794 for (x = 0;x < ATTEN1DSIZE;x++)
1795 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1796 r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1797 // 2D circle texture
1798 for (y = 0;y < ATTEN2DSIZE;y++)
1799 for (x = 0;x < ATTEN2DSIZE;x++)
1800 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);
1801 r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
1802 // 3D sphere texture
1803 if (r_shadow_texture3d.integer && vid.support.ext_texture_3d)
1805 for (z = 0;z < ATTEN3DSIZE;z++)
1806 for (y = 0;y < ATTEN3DSIZE;y++)
1807 for (x = 0;x < ATTEN3DSIZE;x++)
1808 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));
1809 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);
1812 r_shadow_attenuation3dtexture = NULL;
1815 R_Shadow_MakeTextures_MakeCorona();
1817 // Editor light sprites
1818 r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1835 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1836 r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1853 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1854 r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1871 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1872 r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1889 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1890 r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1907 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1908 r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
1925 , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1928 void R_Shadow_ValidateCvars(void)
1930 if (r_shadow_texture3d.integer && !vid.support.ext_texture_3d)
1931 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
1932 if (gl_ext_separatestencil.integer && !vid.support.ati_separate_stencil)
1933 Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
1934 if (gl_ext_stenciltwoside.integer && !vid.support.ext_stencil_two_side)
1935 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
1938 void R_Shadow_RenderMode_Begin(void)
1944 R_Shadow_ValidateCvars();
1946 if (!r_shadow_attenuation2dtexture
1947 || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
1948 || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1949 || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1950 R_Shadow_MakeTextures();
1953 R_Mesh_ResetTextureState();
1954 GL_BlendFunc(GL_ONE, GL_ZERO);
1955 GL_DepthRange(0, 1);
1956 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1958 GL_DepthMask(false);
1959 GL_Color(0, 0, 0, 1);
1960 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
1962 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1964 if (gl_ext_separatestencil.integer && vid.support.ati_separate_stencil)
1966 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
1967 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
1969 else if (gl_ext_stenciltwoside.integer && vid.support.ext_stencil_two_side)
1971 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
1972 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
1976 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
1977 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
1980 switch(vid.renderpath)
1982 case RENDERPATH_GL20:
1983 case RENDERPATH_D3D9:
1984 case RENDERPATH_D3D10:
1985 case RENDERPATH_D3D11:
1986 case RENDERPATH_SOFT:
1987 case RENDERPATH_GLES2:
1988 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1990 case RENDERPATH_GL11:
1991 case RENDERPATH_GL13:
1992 case RENDERPATH_GLES1:
1993 if (r_textureunits.integer >= 2 && vid.texunits >= 2 && r_shadow_texture3d.integer && r_shadow_attenuation3dtexture)
1994 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN;
1995 else if (r_textureunits.integer >= 3 && vid.texunits >= 3)
1996 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN;
1997 else if (r_textureunits.integer >= 2 && vid.texunits >= 2)
1998 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN;
2000 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
2006 qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
2007 qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
2008 r_shadow_drawbuffer = drawbuffer;
2009 r_shadow_readbuffer = readbuffer;
2011 r_shadow_cullface_front = r_refdef.view.cullface_front;
2012 r_shadow_cullface_back = r_refdef.view.cullface_back;
2015 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
2017 rsurface.rtlight = rtlight;
2020 void R_Shadow_RenderMode_Reset(void)
2022 R_Mesh_ResetTextureState();
2023 R_Mesh_SetRenderTargets(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture, NULL, NULL, NULL);
2024 R_SetViewport(&r_refdef.view.viewport);
2025 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
2026 GL_DepthRange(0, 1);
2028 GL_DepthMask(false);
2029 GL_DepthFunc(GL_LEQUAL);
2030 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
2031 r_refdef.view.cullface_front = r_shadow_cullface_front;
2032 r_refdef.view.cullface_back = r_shadow_cullface_back;
2033 GL_CullFace(r_refdef.view.cullface_back);
2034 GL_Color(1, 1, 1, 1);
2035 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
2036 GL_BlendFunc(GL_ONE, GL_ZERO);
2037 R_SetupShader_Generic_NoTexture(false, false);
2038 r_shadow_usingshadowmap2d = false;
2039 r_shadow_usingshadowmaportho = false;
2040 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2043 void R_Shadow_ClearStencil(void)
2045 GL_Clear(GL_STENCIL_BUFFER_BIT, NULL, 1.0f, 128);
2046 r_refdef.stats.lights_clears++;
2049 void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
2051 r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
2052 if (r_shadow_rendermode == mode)
2054 R_Shadow_RenderMode_Reset();
2055 GL_DepthFunc(GL_LESS);
2056 GL_ColorMask(0, 0, 0, 0);
2057 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2058 GL_CullFace(GL_NONE);
2059 R_SetupShader_DepthOrShadow(false, false);
2060 r_shadow_rendermode = mode;
2065 case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
2066 case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
2067 R_SetStencilSeparate(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, GL_ALWAYS, 128, 255);
2069 case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
2070 case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
2071 R_SetStencilSeparate(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, GL_ALWAYS, 128, 255);
2076 static void R_Shadow_MakeVSDCT(void)
2078 // maps to a 2x3 texture rectangle with normalized coordinates
2083 // stores abs(dir.xy), offset.xy/2.5
2084 unsigned char data[4*6] =
2086 255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
2087 255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
2088 0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
2089 0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
2090 0, 0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
2091 0, 0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
2093 r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2096 static void R_Shadow_MakeShadowMap(int side, int size)
2098 switch (r_shadow_shadowmode)
2100 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
2101 if (r_shadow_shadowmap2ddepthtexture) return;
2102 if (r_fb.usedepthtextures)
2104 r_shadow_shadowmap2ddepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits >= 24 ? (r_shadow_shadowmapsampler ? TEXTYPE_SHADOWMAP24_COMP : TEXTYPE_SHADOWMAP24_RAW) : (r_shadow_shadowmapsampler ? TEXTYPE_SHADOWMAP16_COMP : TEXTYPE_SHADOWMAP16_RAW), false);
2105 r_shadow_shadowmap2ddepthbuffer = NULL;
2106 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
2110 r_shadow_shadowmap2ddepthtexture = R_LoadTexture2D(r_shadow_texturepool, "shadowmaprendertarget", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2111 r_shadow_shadowmap2ddepthbuffer = R_LoadTextureRenderBuffer(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits >= 24 ? TEXTYPE_DEPTHBUFFER24 : TEXTYPE_DEPTHBUFFER16);
2112 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
2120 static void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size)
2122 float nearclip, farclip, bias;
2123 r_viewport_t viewport;
2126 float clearcolor[4];
2127 nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
2129 bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
2130 r_shadow_shadowmap_parameters[1] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
2131 r_shadow_shadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
2132 r_shadow_shadowmapside = side;
2133 r_shadow_shadowmapsize = size;
2135 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2136 r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2137 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2138 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
2140 // complex unrolled cube approach (more flexible)
2141 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2142 R_Shadow_MakeVSDCT();
2143 if (!r_shadow_shadowmap2ddepthtexture)
2144 R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize);
2145 fbo2d = r_shadow_fbo2d;
2146 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2ddepthtexture);
2147 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2ddepthtexture);
2148 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2150 R_Mesh_ResetTextureState();
2151 R_Shadow_RenderMode_Reset();
2152 if (r_shadow_shadowmap2ddepthbuffer)
2153 R_Mesh_SetRenderTargets(fbo2d, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
2155 R_Mesh_SetRenderTargets(fbo2d, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
2156 R_SetupShader_DepthOrShadow(true, r_shadow_shadowmap2ddepthbuffer != NULL);
2157 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2162 R_SetViewport(&viewport);
2163 flipped = (side & 1) ^ (side >> 2);
2164 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2165 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2166 if (r_shadow_shadowmap2ddepthbuffer)
2168 // completely different meaning than in depthtexture approach
2169 r_shadow_shadowmap_parameters[1] = 0;
2170 r_shadow_shadowmap_parameters[3] = -bias;
2172 Vector4Set(clearcolor, 1,1,1,1);
2173 if (r_shadow_shadowmap2ddepthbuffer)
2174 GL_ColorMask(1,1,1,1);
2176 GL_ColorMask(0,0,0,0);
2177 switch(vid.renderpath)
2179 case RENDERPATH_GL11:
2180 case RENDERPATH_GL13:
2181 case RENDERPATH_GL20:
2182 case RENDERPATH_SOFT:
2183 case RENDERPATH_GLES1:
2184 case RENDERPATH_GLES2:
2185 GL_CullFace(r_refdef.view.cullface_back);
2186 // OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once
2187 if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask
2189 // get tightest scissor rectangle that encloses all viewports in the clear mask
2190 int x1 = clear & 0x15 ? 0 : size;
2191 int x2 = clear & 0x2A ? 2 * size : size;
2192 int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size);
2193 int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size);
2194 GL_Scissor(x1, y1, x2 - x1, y2 - y1);
2197 if (r_shadow_shadowmap2ddepthbuffer)
2198 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
2200 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
2203 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2205 case RENDERPATH_D3D9:
2206 case RENDERPATH_D3D10:
2207 case RENDERPATH_D3D11:
2208 // we invert the cull mode because we flip the projection matrix
2209 // NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided...
2210 GL_CullFace(r_refdef.view.cullface_front);
2211 // D3D considers it an error to use a scissor larger than the viewport... clear just this view
2212 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2215 if (r_shadow_shadowmap2ddepthbuffer)
2216 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
2218 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
2224 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2226 R_Mesh_ResetTextureState();
2229 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2230 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2231 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2232 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2234 R_Shadow_RenderMode_Reset();
2235 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2237 GL_DepthFunc(GL_EQUAL);
2238 // do global setup needed for the chosen lighting mode
2239 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2240 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2241 r_shadow_usingshadowmap2d = shadowmapping;
2242 r_shadow_rendermode = r_shadow_lightingrendermode;
2243 // only draw light where this geometry was already rendered AND the
2244 // stencil is 128 (values other than this mean shadow)
2246 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2248 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2251 static const unsigned short bboxelements[36] =
2261 static const float bboxpoints[8][3] =
2273 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2276 float vertex3f[8*3];
2277 const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2278 // do global setup needed for the chosen lighting mode
2279 R_Shadow_RenderMode_Reset();
2280 r_shadow_rendermode = r_shadow_lightingrendermode;
2281 R_EntityMatrix(&identitymatrix);
2282 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2283 // only draw light where this geometry was already rendered AND the
2284 // stencil is 128 (values other than this mean shadow)
2285 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2286 if (rsurface.rtlight->specularscale > 0 && r_shadow_gloss.integer > 0)
2287 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
2289 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
2291 r_shadow_usingshadowmap2d = shadowmapping;
2293 // render the lighting
2294 R_SetupShader_DeferredLight(rsurface.rtlight);
2295 for (i = 0;i < 8;i++)
2296 Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2297 GL_ColorMask(1,1,1,1);
2298 GL_DepthMask(false);
2299 GL_DepthRange(0, 1);
2300 GL_PolygonOffset(0, 0);
2302 GL_DepthFunc(GL_GREATER);
2303 GL_CullFace(r_refdef.view.cullface_back);
2304 R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL);
2305 R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
2308 void R_Shadow_UpdateBounceGridTexture(void)
2310 #define MAXBOUNCEGRIDPARTICLESPERLIGHT 1048576
2312 int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2314 int hitsupercontentsmask;
2323 //trace_t cliptrace2;
2324 //trace_t cliptrace3;
2325 unsigned char *pixel;
2326 unsigned char *pixels;
2329 unsigned int lightindex;
2331 unsigned int range1;
2332 unsigned int range2;
2333 unsigned int seed = (unsigned int)(realtime * 1000.0f);
2335 vec3_t baseshotcolor;
2348 vec3_t cullmins, cullmaxs;
2351 vec_t lightintensity;
2352 vec_t photonscaling;
2353 vec_t photonresidual;
2355 float texlerp[2][3];
2356 float splatcolor[32];
2357 float pixelweight[8];
2369 r_shadow_bouncegrid_settings_t settings;
2370 qboolean enable = r_shadow_bouncegrid.integer != 0 && r_refdef.scene.worldmodel;
2371 qboolean allowdirectionalshading = false;
2372 switch(vid.renderpath)
2374 case RENDERPATH_GL20:
2375 allowdirectionalshading = true;
2376 if (!vid.support.ext_texture_3d)
2379 case RENDERPATH_GLES2:
2380 // for performance reasons, do not use directional shading on GLES devices
2381 if (!vid.support.ext_texture_3d)
2384 // these renderpaths do not currently have the code to display the bouncegrid, so disable it on them...
2385 case RENDERPATH_GL11:
2386 case RENDERPATH_GL13:
2387 case RENDERPATH_GLES1:
2388 case RENDERPATH_SOFT:
2389 case RENDERPATH_D3D9:
2390 case RENDERPATH_D3D10:
2391 case RENDERPATH_D3D11:
2395 r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value;
2397 // see if there are really any lights to render...
2398 if (enable && r_shadow_bouncegrid_static.integer)
2401 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2402 for (lightindex = 0;lightindex < range;lightindex++)
2404 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2405 if (!light || !(light->flags & flag))
2407 rtlight = &light->rtlight;
2408 // when static, we skip styled lights because they tend to change...
2409 if (rtlight->style > 0)
2411 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale), lightcolor);
2412 if (!VectorLength2(lightcolor))
2421 if (r_shadow_bouncegridtexture)
2423 R_FreeTexture(r_shadow_bouncegridtexture);
2424 r_shadow_bouncegridtexture = NULL;
2426 if (r_shadow_bouncegridpixels)
2427 Mem_Free(r_shadow_bouncegridpixels);
2428 r_shadow_bouncegridpixels = NULL;
2429 if (r_shadow_bouncegridhighpixels)
2430 Mem_Free(r_shadow_bouncegridhighpixels);
2431 r_shadow_bouncegridhighpixels = NULL;
2432 r_shadow_bouncegridnumpixels = 0;
2433 r_shadow_bouncegriddirectional = false;
2437 // build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
2438 memset(&settings, 0, sizeof(settings));
2439 settings.staticmode = r_shadow_bouncegrid_static.integer != 0;
2440 settings.bounceanglediffuse = r_shadow_bouncegrid_bounceanglediffuse.integer != 0;
2441 settings.directionalshading = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_directionalshading.integer != 0) && allowdirectionalshading;
2442 settings.dlightparticlemultiplier = r_shadow_bouncegrid_dlightparticlemultiplier.value;
2443 settings.hitmodels = r_shadow_bouncegrid_hitmodels.integer != 0;
2444 settings.includedirectlighting = r_shadow_bouncegrid_includedirectlighting.integer != 0 || r_shadow_bouncegrid.integer == 2;
2445 settings.lightradiusscale = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_lightradiusscale.value : r_shadow_bouncegrid_lightradiusscale.value);
2446 settings.maxbounce = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_maxbounce.integer : r_shadow_bouncegrid_maxbounce.integer);
2447 settings.particlebounceintensity = r_shadow_bouncegrid_particlebounceintensity.value;
2448 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);
2449 settings.photons = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_photons.integer : r_shadow_bouncegrid_photons.integer;
2450 settings.spacing[0] = r_shadow_bouncegrid_spacing.value;
2451 settings.spacing[1] = r_shadow_bouncegrid_spacing.value;
2452 settings.spacing[2] = r_shadow_bouncegrid_spacing.value;
2453 settings.stablerandom = r_shadow_bouncegrid_stablerandom.integer;
2455 // bound the values for sanity
2456 settings.photons = bound(1, settings.photons, 1048576);
2457 settings.lightradiusscale = bound(0.0001f, settings.lightradiusscale, 1024.0f);
2458 settings.maxbounce = bound(0, settings.maxbounce, 16);
2459 settings.spacing[0] = bound(1, settings.spacing[0], 512);
2460 settings.spacing[1] = bound(1, settings.spacing[1], 512);
2461 settings.spacing[2] = bound(1, settings.spacing[2], 512);
2463 // get the spacing values
2464 spacing[0] = settings.spacing[0];
2465 spacing[1] = settings.spacing[1];
2466 spacing[2] = settings.spacing[2];
2467 ispacing[0] = 1.0f / spacing[0];
2468 ispacing[1] = 1.0f / spacing[1];
2469 ispacing[2] = 1.0f / spacing[2];
2471 // calculate texture size enclosing entire world bounds at the spacing
2472 VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
2473 VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
2474 VectorSubtract(maxs, mins, size);
2475 // now we can calculate the resolution we want
2476 c[0] = (int)floor(size[0] / spacing[0] + 0.5f);
2477 c[1] = (int)floor(size[1] / spacing[1] + 0.5f);
2478 c[2] = (int)floor(size[2] / spacing[2] + 0.5f);
2479 // figure out the exact texture size (honoring power of 2 if required)
2480 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2481 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2482 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2483 if (vid.support.arb_texture_non_power_of_two)
2485 resolution[0] = c[0];
2486 resolution[1] = c[1];
2487 resolution[2] = c[2];
2491 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2492 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2493 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2495 size[0] = spacing[0] * resolution[0];
2496 size[1] = spacing[1] * resolution[1];
2497 size[2] = spacing[2] * resolution[2];
2499 // if dynamic we may or may not want to use the world bounds
2500 // if the dynamic size is smaller than the world bounds, use it instead
2501 if (!settings.staticmode && (r_shadow_bouncegrid_x.integer * r_shadow_bouncegrid_y.integer * r_shadow_bouncegrid_z.integer < resolution[0] * resolution[1] * resolution[2]))
2503 // we know the resolution we want
2504 c[0] = r_shadow_bouncegrid_x.integer;
2505 c[1] = r_shadow_bouncegrid_y.integer;
2506 c[2] = r_shadow_bouncegrid_z.integer;
2507 // now we can calculate the texture size (power of 2 if required)
2508 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2509 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2510 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2511 if (vid.support.arb_texture_non_power_of_two)
2513 resolution[0] = c[0];
2514 resolution[1] = c[1];
2515 resolution[2] = c[2];
2519 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2520 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2521 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2523 size[0] = spacing[0] * resolution[0];
2524 size[1] = spacing[1] * resolution[1];
2525 size[2] = spacing[2] * resolution[2];
2526 // center the rendering on the view
2527 mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0];
2528 mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1];
2529 mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2];
2532 // recalculate the maxs in case the resolution was not satisfactory
2533 VectorAdd(mins, size, maxs);
2535 // if all the settings seem identical to the previous update, return
2536 if (r_shadow_bouncegridtexture && (settings.staticmode || realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value) && !memcmp(&r_shadow_bouncegridsettings, &settings, sizeof(settings)))
2539 // store the new settings
2540 r_shadow_bouncegridsettings = settings;
2542 pixelbands = settings.directionalshading ? 8 : 1;
2543 pixelsperband = resolution[0]*resolution[1]*resolution[2];
2544 numpixels = pixelsperband*pixelbands;
2546 // we're going to update the bouncegrid, update the matrix...
2547 memset(m, 0, sizeof(m));
2548 m[0] = 1.0f / size[0];
2549 m[3] = -mins[0] * m[0];
2550 m[5] = 1.0f / size[1];
2551 m[7] = -mins[1] * m[5];
2552 m[10] = 1.0f / size[2];
2553 m[11] = -mins[2] * m[10];
2555 Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegridmatrix, m);
2556 // reallocate pixels for this update if needed...
2557 if (r_shadow_bouncegridnumpixels != numpixels || !r_shadow_bouncegridpixels || !r_shadow_bouncegridhighpixels)
2559 if (r_shadow_bouncegridtexture)
2561 R_FreeTexture(r_shadow_bouncegridtexture);
2562 r_shadow_bouncegridtexture = NULL;
2564 r_shadow_bouncegridpixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridpixels, numpixels * sizeof(unsigned char[4]));
2565 r_shadow_bouncegridhighpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(float[4]));
2567 r_shadow_bouncegridnumpixels = numpixels;
2568 pixels = r_shadow_bouncegridpixels;
2569 highpixels = r_shadow_bouncegridhighpixels;
2570 x = pixelsperband*4;
2571 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2574 memset(pixels + pixelband * x, 128, x);
2576 memset(pixels + pixelband * x, 0, x);
2578 memset(highpixels, 0, numpixels * sizeof(float[4]));
2579 // figure out what we want to interact with
2580 if (settings.hitmodels)
2581 hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;// | SUPERCONTENTS_LIQUIDSMASK;
2583 hitsupercontentsmask = SUPERCONTENTS_SOLID;// | SUPERCONTENTS_LIQUIDSMASK;
2584 maxbounce = settings.maxbounce;
2585 // clear variables that produce warnings otherwise
2586 memset(splatcolor, 0, sizeof(splatcolor));
2587 // iterate world rtlights
2588 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2589 range1 = settings.staticmode ? 0 : r_refdef.scene.numlights;
2590 range2 = range + range1;
2592 for (lightindex = 0;lightindex < range2;lightindex++)
2594 if (lightindex < range)
2596 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2599 rtlight = &light->rtlight;
2600 VectorClear(rtlight->photoncolor);
2601 rtlight->photons = 0;
2602 if (!(light->flags & flag))
2604 if (settings.staticmode)
2606 // when static, we skip styled lights because they tend to change...
2607 if (rtlight->style > 0 && r_shadow_bouncegrid.integer != 2)
2613 rtlight = r_refdef.scene.lights[lightindex - range];
2614 VectorClear(rtlight->photoncolor);
2615 rtlight->photons = 0;
2617 // draw only visible lights (major speedup)
2618 radius = rtlight->radius * settings.lightradiusscale;
2619 cullmins[0] = rtlight->shadoworigin[0] - radius;
2620 cullmins[1] = rtlight->shadoworigin[1] - radius;
2621 cullmins[2] = rtlight->shadoworigin[2] - radius;
2622 cullmaxs[0] = rtlight->shadoworigin[0] + radius;
2623 cullmaxs[1] = rtlight->shadoworigin[1] + radius;
2624 cullmaxs[2] = rtlight->shadoworigin[2] + radius;
2625 if (R_CullBox(cullmins, cullmaxs))
2627 if (r_refdef.scene.worldmodel
2628 && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs
2629 && !r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, cullmins, cullmaxs))
2631 w = r_shadow_lightintensityscale.value * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2632 if (w * VectorLength2(rtlight->color) == 0.0f)
2634 w *= (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1);
2635 VectorScale(rtlight->color, w, rtlight->photoncolor);
2636 //if (!VectorLength2(rtlight->photoncolor))
2638 // shoot particles from this light
2639 // use a calculation for the number of particles that will not
2640 // vary with lightstyle, otherwise we get randomized particle
2641 // distribution, the seeded random is only consistent for a
2642 // consistent number of particles on this light...
2643 s = rtlight->radius;
2644 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2645 if (lightindex >= range)
2646 lightintensity *= settings.dlightparticlemultiplier;
2647 rtlight->photons = max(0.0f, lightintensity * s * s);
2648 photoncount += rtlight->photons;
2650 photonscaling = (float)settings.photons / max(1, photoncount);
2651 photonresidual = 0.0f;
2652 for (lightindex = 0;lightindex < range2;lightindex++)
2654 if (lightindex < range)
2656 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2659 rtlight = &light->rtlight;
2662 rtlight = r_refdef.scene.lights[lightindex - range];
2663 // skip a light with no photons
2664 if (rtlight->photons == 0.0f)
2666 // skip a light with no photon color)
2667 if (VectorLength2(rtlight->photoncolor) == 0.0f)
2669 photonresidual += rtlight->photons * photonscaling;
2670 shootparticles = (int)bound(0, photonresidual, MAXBOUNCEGRIDPARTICLESPERLIGHT);
2671 if (!shootparticles)
2673 photonresidual -= shootparticles;
2674 radius = rtlight->radius * settings.lightradiusscale;
2675 s = settings.particleintensity / shootparticles;
2676 VectorScale(rtlight->photoncolor, s, baseshotcolor);
2677 r_refdef.stats.bouncegrid_lights++;
2678 r_refdef.stats.bouncegrid_particles += shootparticles;
2679 for (shotparticles = 0;shotparticles < shootparticles;shotparticles++)
2681 if (settings.stablerandom > 0)
2682 seed = lightindex * 11937 + shotparticles;
2683 VectorCopy(baseshotcolor, shotcolor);
2684 VectorCopy(rtlight->shadoworigin, clipstart);
2685 if (settings.stablerandom < 0)
2686 VectorRandom(clipend);
2688 VectorCheeseRandom(clipend);
2689 VectorMA(clipstart, radius, clipend, clipend);
2690 for (bouncecount = 0;;bouncecount++)
2692 r_refdef.stats.bouncegrid_traces++;
2693 //r_refdef.scene.worldmodel->TraceLineAgainstSurfaces(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace, clipstart, clipend, hitsupercontentsmask);
2694 //r_refdef.scene.worldmodel->TraceLine(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace2, clipstart, clipend, hitsupercontentsmask);
2695 if (settings.staticmode)
2697 // static mode fires a LOT of rays but none of them are identical, so they are not cached
2698 cliptrace = CL_TraceLine(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), NULL, hitsupercontentsmask, true, false, NULL, true, true);
2702 // dynamic mode fires many rays and most will match the cache from the previous frame
2703 cliptrace = CL_Cache_TraceLineSurfaces(clipstart, clipend, settings.staticmode ? MOVE_WORLDONLY : (settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS), hitsupercontentsmask);
2705 if (bouncecount > 0 || settings.includedirectlighting)
2707 // calculate second order spherical harmonics values (average, slopeX, slopeY, slopeZ)
2708 // accumulate average shotcolor
2709 w = VectorLength(shotcolor);
2710 splatcolor[ 0] = shotcolor[0];
2711 splatcolor[ 1] = shotcolor[1];
2712 splatcolor[ 2] = shotcolor[2];
2713 splatcolor[ 3] = 0.0f;
2716 VectorSubtract(clipstart, cliptrace.endpos, clipdiff);
2717 VectorNormalize(clipdiff);
2718 // store bentnormal in case the shader has a use for it
2719 splatcolor[ 4] = clipdiff[0] * w;
2720 splatcolor[ 5] = clipdiff[1] * w;
2721 splatcolor[ 6] = clipdiff[2] * w;
2723 // accumulate directional contributions (+X, +Y, +Z, -X, -Y, -Z)
2724 splatcolor[ 8] = shotcolor[0] * max(0.0f, clipdiff[0]);
2725 splatcolor[ 9] = shotcolor[0] * max(0.0f, clipdiff[1]);
2726 splatcolor[10] = shotcolor[0] * max(0.0f, clipdiff[2]);
2727 splatcolor[11] = 0.0f;
2728 splatcolor[12] = shotcolor[1] * max(0.0f, clipdiff[0]);
2729 splatcolor[13] = shotcolor[1] * max(0.0f, clipdiff[1]);
2730 splatcolor[14] = shotcolor[1] * max(0.0f, clipdiff[2]);
2731 splatcolor[15] = 0.0f;
2732 splatcolor[16] = shotcolor[2] * max(0.0f, clipdiff[0]);
2733 splatcolor[17] = shotcolor[2] * max(0.0f, clipdiff[1]);
2734 splatcolor[18] = shotcolor[2] * max(0.0f, clipdiff[2]);
2735 splatcolor[19] = 0.0f;
2736 splatcolor[20] = shotcolor[0] * max(0.0f, -clipdiff[0]);
2737 splatcolor[21] = shotcolor[0] * max(0.0f, -clipdiff[1]);
2738 splatcolor[22] = shotcolor[0] * max(0.0f, -clipdiff[2]);
2739 splatcolor[23] = 0.0f;
2740 splatcolor[24] = shotcolor[1] * max(0.0f, -clipdiff[0]);
2741 splatcolor[25] = shotcolor[1] * max(0.0f, -clipdiff[1]);
2742 splatcolor[26] = shotcolor[1] * max(0.0f, -clipdiff[2]);
2743 splatcolor[27] = 0.0f;
2744 splatcolor[28] = shotcolor[2] * max(0.0f, -clipdiff[0]);
2745 splatcolor[29] = shotcolor[2] * max(0.0f, -clipdiff[1]);
2746 splatcolor[30] = shotcolor[2] * max(0.0f, -clipdiff[2]);
2747 splatcolor[31] = 0.0f;
2749 // calculate the number of steps we need to traverse this distance
2750 VectorSubtract(cliptrace.endpos, clipstart, stepdelta);
2751 numsteps = (int)(VectorLength(stepdelta) * ispacing[0]);
2752 numsteps = bound(1, numsteps, 1024);
2753 w = 1.0f / numsteps;
2754 VectorScale(stepdelta, w, stepdelta);
2755 VectorMA(clipstart, 0.5f, stepdelta, steppos);
2756 for (step = 0;step < numsteps;step++)
2758 r_refdef.stats.bouncegrid_splats++;
2759 // figure out which texture pixel this is in
2760 texlerp[1][0] = ((steppos[0] - mins[0]) * ispacing[0]) - 0.5f;
2761 texlerp[1][1] = ((steppos[1] - mins[1]) * ispacing[1]) - 0.5f;
2762 texlerp[1][2] = ((steppos[2] - mins[2]) * ispacing[2]) - 0.5f;
2763 tex[0] = (int)floor(texlerp[1][0]);
2764 tex[1] = (int)floor(texlerp[1][1]);
2765 tex[2] = (int)floor(texlerp[1][2]);
2766 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)
2768 // it is within bounds... do the real work now
2769 // calculate the lerp factors
2770 texlerp[1][0] -= tex[0];
2771 texlerp[1][1] -= tex[1];
2772 texlerp[1][2] -= tex[2];
2773 texlerp[0][0] = 1.0f - texlerp[1][0];
2774 texlerp[0][1] = 1.0f - texlerp[1][1];
2775 texlerp[0][2] = 1.0f - texlerp[1][2];
2776 // calculate individual pixel indexes and weights
2777 pixelindex[0] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[0] = (texlerp[0][0]*texlerp[0][1]*texlerp[0][2]);
2778 pixelindex[1] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[1] = (texlerp[1][0]*texlerp[0][1]*texlerp[0][2]);
2779 pixelindex[2] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[2] = (texlerp[0][0]*texlerp[1][1]*texlerp[0][2]);
2780 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]);
2781 pixelindex[4] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[4] = (texlerp[0][0]*texlerp[0][1]*texlerp[1][2]);
2782 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]);
2783 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]);
2784 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]);
2785 // update the 8 pixels...
2786 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2788 for (corner = 0;corner < 8;corner++)
2790 // calculate address for pixel
2791 w = pixelweight[corner];
2792 pixel = pixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2793 highpixel = highpixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2794 // add to the high precision pixel color
2795 highpixel[0] += (splatcolor[pixelband*4+0]*w);
2796 highpixel[1] += (splatcolor[pixelband*4+1]*w);
2797 highpixel[2] += (splatcolor[pixelband*4+2]*w);
2798 highpixel[3] += (splatcolor[pixelband*4+3]*w);
2799 // flag the low precision pixel as needing to be updated
2801 // advance to next band of coefficients
2802 //pixel += pixelsperband*4;
2803 //highpixel += pixelsperband*4;
2807 VectorAdd(steppos, stepdelta, steppos);
2810 if (cliptrace.fraction >= 1.0f)
2812 r_refdef.stats.bouncegrid_hits++;
2813 if (bouncecount >= maxbounce)
2815 // scale down shot color by bounce intensity and texture color (or 50% if no texture reported)
2816 // also clamp the resulting color to never add energy, even if the user requests extreme values
2817 if (cliptrace.hittexture && cliptrace.hittexture->currentskinframe)
2818 VectorCopy(cliptrace.hittexture->currentskinframe->avgcolor, surfcolor);
2820 VectorSet(surfcolor, 0.5f, 0.5f, 0.5f);
2821 VectorScale(surfcolor, settings.particlebounceintensity, surfcolor);
2822 surfcolor[0] = min(surfcolor[0], 1.0f);
2823 surfcolor[1] = min(surfcolor[1], 1.0f);
2824 surfcolor[2] = min(surfcolor[2], 1.0f);
2825 VectorMultiply(shotcolor, surfcolor, shotcolor);
2826 if (VectorLength2(baseshotcolor) == 0.0f)
2828 r_refdef.stats.bouncegrid_bounces++;
2829 if (settings.bounceanglediffuse)
2831 // random direction, primarily along plane normal
2832 s = VectorDistance(cliptrace.endpos, clipend);
2833 if (settings.stablerandom < 0)
2834 VectorRandom(clipend);
2836 VectorCheeseRandom(clipend);
2837 VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend);
2838 VectorNormalize(clipend);
2839 VectorScale(clipend, s, clipend);
2843 // reflect the remaining portion of the line across plane normal
2844 VectorSubtract(clipend, cliptrace.endpos, clipdiff);
2845 VectorReflect(clipdiff, 1.0, cliptrace.plane.normal, clipend);
2847 // calculate the new line start and end
2848 VectorCopy(cliptrace.endpos, clipstart);
2849 VectorAdd(clipstart, clipend, clipend);
2853 // generate pixels array from highpixels array
2854 // skip first and last columns, rows, and layers as these are blank
2855 // the pixel[3] value was written above, so we can use it to detect only pixels that need to be calculated
2856 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2858 for (z = 1;z < resolution[2]-1;z++)
2860 for (y = 1;y < resolution[1]-1;y++)
2862 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)
2864 // only convert pixels that were hit by photons
2865 if (pixel[3] == 255)
2867 // normalize the bentnormal...
2870 VectorNormalize(highpixel);
2871 c[0] = (int)(highpixel[0]*128.0f+128.0f);
2872 c[1] = (int)(highpixel[1]*128.0f+128.0f);
2873 c[2] = (int)(highpixel[2]*128.0f+128.0f);
2874 c[3] = (int)(highpixel[3]*128.0f+128.0f);
2878 c[0] = (int)(highpixel[0]*256.0f);
2879 c[1] = (int)(highpixel[1]*256.0f);
2880 c[2] = (int)(highpixel[2]*256.0f);
2881 c[3] = (int)(highpixel[3]*256.0f);
2883 pixel[2] = (unsigned char)bound(0, c[0], 255);
2884 pixel[1] = (unsigned char)bound(0, c[1], 255);
2885 pixel[0] = (unsigned char)bound(0, c[2], 255);
2886 pixel[3] = (unsigned char)bound(0, c[3], 255);
2892 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)
2893 R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
2896 VectorCopy(resolution, r_shadow_bouncegridresolution);
2897 r_shadow_bouncegriddirectional = settings.directionalshading;
2898 if (r_shadow_bouncegridtexture)
2899 R_FreeTexture(r_shadow_bouncegridtexture);
2900 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);
2902 r_shadow_bouncegridtime = realtime;
2905 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2907 R_Shadow_RenderMode_Reset();
2908 GL_BlendFunc(GL_ONE, GL_ONE);
2909 GL_DepthRange(0, 1);
2910 GL_DepthTest(r_showshadowvolumes.integer < 2);
2911 GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2912 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2913 GL_CullFace(GL_NONE);
2914 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2917 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2919 R_Shadow_RenderMode_Reset();
2920 GL_BlendFunc(GL_ONE, GL_ONE);
2921 GL_DepthRange(0, 1);
2922 GL_DepthTest(r_showlighting.integer < 2);
2923 GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2925 GL_DepthFunc(GL_EQUAL);
2926 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2927 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2930 void R_Shadow_RenderMode_End(void)
2932 R_Shadow_RenderMode_Reset();
2933 R_Shadow_RenderMode_ActiveLight(NULL);
2935 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2936 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2939 int bboxedges[12][2] =
2958 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2960 if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass || r_trippy.integer)
2962 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2963 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2964 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2965 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2968 if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor))
2969 return true; // invisible
2970 if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x
2971 || r_shadow_lightscissor[1] != r_refdef.view.viewport.y
2972 || r_shadow_lightscissor[2] != r_refdef.view.viewport.width
2973 || r_shadow_lightscissor[3] != r_refdef.view.viewport.height)
2974 r_refdef.stats.lights_scissored++;
2978 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, const float *diffusecolor, const float *ambientcolor)
2981 const float *vertex3f;
2982 const float *normal3f;
2984 float dist, dot, distintensity, shadeintensity, v[3], n[3];
2985 switch (r_shadow_rendermode)
2987 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2988 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2989 if (VectorLength2(diffusecolor) > 0)
2991 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)
2993 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2994 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2995 if ((dot = DotProduct(n, v)) < 0)
2997 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2998 VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
3001 VectorCopy(ambientcolor, color4f);
3002 if (r_refdef.fogenabled)
3005 f = RSurf_FogVertex(vertex3f);
3006 VectorScale(color4f, f, color4f);
3013 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3015 VectorCopy(ambientcolor, color4f);
3016 if (r_refdef.fogenabled)
3019 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3020 f = RSurf_FogVertex(vertex3f);
3021 VectorScale(color4f + 4*i, f, color4f);
3027 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3028 if (VectorLength2(diffusecolor) > 0)
3030 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)
3032 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3033 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3035 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3036 if ((dot = DotProduct(n, v)) < 0)
3038 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3039 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3040 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3041 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3045 color4f[0] = ambientcolor[0] * distintensity;
3046 color4f[1] = ambientcolor[1] * distintensity;
3047 color4f[2] = ambientcolor[2] * distintensity;
3049 if (r_refdef.fogenabled)
3052 f = RSurf_FogVertex(vertex3f);
3053 VectorScale(color4f, f, color4f);
3057 VectorClear(color4f);
3063 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3065 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3066 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3068 color4f[0] = ambientcolor[0] * distintensity;
3069 color4f[1] = ambientcolor[1] * distintensity;
3070 color4f[2] = ambientcolor[2] * distintensity;
3071 if (r_refdef.fogenabled)
3074 f = RSurf_FogVertex(vertex3f);
3075 VectorScale(color4f, f, color4f);
3079 VectorClear(color4f);
3084 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3085 if (VectorLength2(diffusecolor) > 0)
3087 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)
3089 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3090 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3092 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3093 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3094 if ((dot = DotProduct(n, v)) < 0)
3096 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3097 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3098 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3099 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3103 color4f[0] = ambientcolor[0] * distintensity;
3104 color4f[1] = ambientcolor[1] * distintensity;
3105 color4f[2] = ambientcolor[2] * distintensity;
3107 if (r_refdef.fogenabled)
3110 f = RSurf_FogVertex(vertex3f);
3111 VectorScale(color4f, f, color4f);
3115 VectorClear(color4f);
3121 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3123 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3124 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3126 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3127 color4f[0] = ambientcolor[0] * distintensity;
3128 color4f[1] = ambientcolor[1] * distintensity;
3129 color4f[2] = ambientcolor[2] * distintensity;
3130 if (r_refdef.fogenabled)
3133 f = RSurf_FogVertex(vertex3f);
3134 VectorScale(color4f, f, color4f);
3138 VectorClear(color4f);
3148 static void R_Shadow_RenderLighting_VisibleLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3150 // used to display how many times a surface is lit for level design purposes
3151 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3152 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
3156 static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale, float specularscale)
3158 // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
3159 R_SetupShader_Surface(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL, false);
3163 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
3170 int newnumtriangles;
3174 int maxtriangles = 1024;
3175 int newelements[1024*3];
3176 R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, diffusecolor2, ambientcolor2);
3177 for (renders = 0;renders < 4;renders++)
3182 newnumtriangles = 0;
3184 // due to low fillrate on the cards this vertex lighting path is
3185 // designed for, we manually cull all triangles that do not
3186 // contain a lit vertex
3187 // this builds batches of triangles from multiple surfaces and
3188 // renders them at once
3189 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
3191 if (VectorLength2(rsurface.passcolor4f + e[0] * 4) + VectorLength2(rsurface.passcolor4f + e[1] * 4) + VectorLength2(rsurface.passcolor4f + e[2] * 4) >= 0.01)
3193 if (newnumtriangles)
3195 newfirstvertex = min(newfirstvertex, e[0]);
3196 newlastvertex = max(newlastvertex, e[0]);
3200 newfirstvertex = e[0];
3201 newlastvertex = e[0];
3203 newfirstvertex = min(newfirstvertex, e[1]);
3204 newlastvertex = max(newlastvertex, e[1]);
3205 newfirstvertex = min(newfirstvertex, e[2]);
3206 newlastvertex = max(newlastvertex, e[2]);
3212 if (newnumtriangles >= maxtriangles)
3214 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3215 newnumtriangles = 0;
3221 if (newnumtriangles >= 1)
3223 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3226 // if we couldn't find any lit triangles, exit early
3229 // now reduce the intensity for the next overbright pass
3230 // we have to clamp to 0 here incase the drivers have improper
3231 // handling of negative colors
3232 // (some old drivers even have improper handling of >1 color)
3234 for (i = 0, c = rsurface.passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4)
3236 if (c[0] > 1 || c[1] > 1 || c[2] > 1)
3238 c[0] = max(0, c[0] - 1);
3239 c[1] = max(0, c[1] - 1);
3240 c[2] = max(0, c[2] - 1);
3252 static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale)
3254 // OpenGL 1.1 path (anything)
3255 float ambientcolorbase[3], diffusecolorbase[3];
3256 float ambientcolorpants[3], diffusecolorpants[3];
3257 float ambientcolorshirt[3], diffusecolorshirt[3];
3258 const float *surfacecolor = rsurface.texture->dlightcolor;
3259 const float *surfacepants = rsurface.colormap_pantscolor;
3260 const float *surfaceshirt = rsurface.colormap_shirtcolor;
3261 rtexture_t *basetexture = rsurface.texture->basetexture;
3262 rtexture_t *pantstexture = rsurface.texture->pantstexture;
3263 rtexture_t *shirttexture = rsurface.texture->shirttexture;
3264 qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
3265 qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
3266 ambientscale *= 2 * r_refdef.view.colorscale;
3267 diffusescale *= 2 * r_refdef.view.colorscale;
3268 ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
3269 diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
3270 ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
3271 diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
3272 ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
3273 diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
3274 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3275 rsurface.passcolor4f = (float *)R_FrameData_Alloc((rsurface.batchfirstvertex + rsurface.batchnumvertices) * sizeof(float[4]));
3276 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3277 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
3278 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
3279 R_Mesh_TexBind(0, basetexture);
3280 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
3281 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
3282 switch(r_shadow_rendermode)
3284 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3285 R_Mesh_TexBind(1, r_shadow_attenuation3dtexture);
3286 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3287 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3288 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3290 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3291 R_Mesh_TexBind(2, r_shadow_attenuation2dtexture);
3292 R_Mesh_TexMatrix(2, &rsurface.entitytoattenuationz);
3293 R_Mesh_TexCombine(2, GL_MODULATE, GL_MODULATE, 1, 1);
3294 R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3296 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3297 R_Mesh_TexBind(1, r_shadow_attenuation2dtexture);
3298 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3299 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3300 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3302 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3307 //R_Mesh_TexBind(0, basetexture);
3308 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorbase, ambientcolorbase);
3311 R_Mesh_TexBind(0, pantstexture);
3312 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorpants, ambientcolorpants);
3316 R_Mesh_TexBind(0, shirttexture);
3317 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorshirt, ambientcolorshirt);
3321 extern cvar_t gl_lightmaps;
3322 void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3324 float ambientscale, diffusescale, specularscale;
3326 float lightcolor[3];
3327 VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
3328 ambientscale = rsurface.rtlight->ambientscale + rsurface.texture->rtlightambient;
3329 diffusescale = rsurface.rtlight->diffusescale * max(0, 1.0 - rsurface.texture->rtlightambient);
3330 specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
3331 if (!r_shadow_usenormalmap.integer)
3333 ambientscale += 1.0f * diffusescale;
3337 if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
3339 negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
3342 VectorNegate(lightcolor, lightcolor);
3343 GL_BlendEquationSubtract(true);
3345 RSurf_SetupDepthAndCulling();
3346 switch (r_shadow_rendermode)
3348 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
3349 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
3350 R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
3352 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3353 R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale, specularscale);
3355 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3356 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3357 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3358 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3359 R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale);
3362 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
3366 GL_BlendEquationSubtract(false);
3369 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)
3371 matrix4x4_t tempmatrix = *matrix;
3372 Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
3374 // if this light has been compiled before, free the associated data
3375 R_RTLight_Uncompile(rtlight);
3377 // clear it completely to avoid any lingering data
3378 memset(rtlight, 0, sizeof(*rtlight));
3380 // copy the properties
3381 rtlight->matrix_lighttoworld = tempmatrix;
3382 Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3383 Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3384 rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3385 VectorCopy(color, rtlight->color);
3386 rtlight->cubemapname[0] = 0;
3387 if (cubemapname && cubemapname[0])
3388 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3389 rtlight->shadow = shadow;
3390 rtlight->corona = corona;
3391 rtlight->style = style;
3392 rtlight->isstatic = isstatic;
3393 rtlight->coronasizescale = coronasizescale;
3394 rtlight->ambientscale = ambientscale;
3395 rtlight->diffusescale = diffusescale;
3396 rtlight->specularscale = specularscale;
3397 rtlight->flags = flags;
3399 // compute derived data
3400 //rtlight->cullradius = rtlight->radius;
3401 //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3402 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3403 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3404 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3405 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3406 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3407 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3410 // compiles rtlight geometry
3411 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3412 void R_RTLight_Compile(rtlight_t *rtlight)
3415 int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3416 int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3417 entity_render_t *ent = r_refdef.scene.worldentity;
3418 dp_model_t *model = r_refdef.scene.worldmodel;
3419 unsigned char *data;
3422 // compile the light
3423 rtlight->compiled = true;
3424 rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3425 rtlight->static_numleafs = 0;
3426 rtlight->static_numleafpvsbytes = 0;
3427 rtlight->static_leaflist = NULL;
3428 rtlight->static_leafpvs = NULL;
3429 rtlight->static_numsurfaces = 0;
3430 rtlight->static_surfacelist = NULL;
3431 rtlight->static_shadowmap_receivers = 0x3F;
3432 rtlight->static_shadowmap_casters = 0x3F;
3433 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3434 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3435 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3436 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3437 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3438 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3440 if (model && model->GetLightInfo)
3442 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3443 r_shadow_compilingrtlight = rtlight;
3444 R_FrameData_SetMark();
3445 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);
3446 R_FrameData_ReturnToMark();
3447 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3448 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3449 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3450 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3451 rtlight->static_numsurfaces = numsurfaces;
3452 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3453 rtlight->static_numleafs = numleafs;
3454 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3455 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3456 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3457 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3458 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3459 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3460 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3461 if (rtlight->static_numsurfaces)
3462 memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3463 if (rtlight->static_numleafs)
3464 memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3465 if (rtlight->static_numleafpvsbytes)
3466 memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3467 if (rtlight->static_numshadowtrispvsbytes)
3468 memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3469 if (rtlight->static_numlighttrispvsbytes)
3470 memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3471 R_FrameData_SetMark();
3472 switch (rtlight->shadowmode)
3474 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3475 if (model->CompileShadowMap && rtlight->shadow)
3476 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3479 if (model->CompileShadowVolume && rtlight->shadow)
3480 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3483 R_FrameData_ReturnToMark();
3484 // now we're done compiling the rtlight
3485 r_shadow_compilingrtlight = NULL;
3489 // use smallest available cullradius - box radius or light radius
3490 //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3491 //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3493 shadowzpasstris = 0;
3494 if (rtlight->static_meshchain_shadow_zpass)
3495 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3496 shadowzpasstris += mesh->numtriangles;
3498 shadowzfailtris = 0;
3499 if (rtlight->static_meshchain_shadow_zfail)
3500 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3501 shadowzfailtris += mesh->numtriangles;
3504 if (rtlight->static_numlighttrispvsbytes)
3505 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3506 if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3510 if (rtlight->static_numlighttrispvsbytes)
3511 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3512 if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3515 if (developer_extra.integer)
3516 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);
3519 void R_RTLight_Uncompile(rtlight_t *rtlight)
3521 if (rtlight->compiled)
3523 if (rtlight->static_meshchain_shadow_zpass)
3524 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3525 rtlight->static_meshchain_shadow_zpass = NULL;
3526 if (rtlight->static_meshchain_shadow_zfail)
3527 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3528 rtlight->static_meshchain_shadow_zfail = NULL;
3529 if (rtlight->static_meshchain_shadow_shadowmap)
3530 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3531 rtlight->static_meshchain_shadow_shadowmap = NULL;
3532 // these allocations are grouped
3533 if (rtlight->static_surfacelist)
3534 Mem_Free(rtlight->static_surfacelist);
3535 rtlight->static_numleafs = 0;
3536 rtlight->static_numleafpvsbytes = 0;
3537 rtlight->static_leaflist = NULL;
3538 rtlight->static_leafpvs = NULL;
3539 rtlight->static_numsurfaces = 0;
3540 rtlight->static_surfacelist = NULL;
3541 rtlight->static_numshadowtrispvsbytes = 0;
3542 rtlight->static_shadowtrispvs = NULL;
3543 rtlight->static_numlighttrispvsbytes = 0;
3544 rtlight->static_lighttrispvs = NULL;
3545 rtlight->compiled = false;
3549 void R_Shadow_UncompileWorldLights(void)
3553 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3554 for (lightindex = 0;lightindex < range;lightindex++)
3556 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3559 R_RTLight_Uncompile(&light->rtlight);
3563 static void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3567 // reset the count of frustum planes
3568 // see rtlight->cached_frustumplanes definition for how much this array
3570 rtlight->cached_numfrustumplanes = 0;
3572 if (r_trippy.integer)
3575 // haven't implemented a culling path for ortho rendering
3576 if (!r_refdef.view.useperspective)
3578 // check if the light is on screen and copy the 4 planes if it is
3579 for (i = 0;i < 4;i++)
3580 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3583 for (i = 0;i < 4;i++)
3584 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3589 // generate a deformed frustum that includes the light origin, this is
3590 // used to cull shadow casting surfaces that can not possibly cast a
3591 // shadow onto the visible light-receiving surfaces, which can be a
3594 // if the light origin is onscreen the result will be 4 planes exactly
3595 // if the light origin is offscreen on only one axis the result will
3596 // be exactly 5 planes (split-side case)
3597 // if the light origin is offscreen on two axes the result will be
3598 // exactly 4 planes (stretched corner case)
3599 for (i = 0;i < 4;i++)
3601 // quickly reject standard frustum planes that put the light
3602 // origin outside the frustum
3603 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3606 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3608 // if all the standard frustum planes were accepted, the light is onscreen
3609 // otherwise we need to generate some more planes below...
3610 if (rtlight->cached_numfrustumplanes < 4)
3612 // at least one of the stock frustum planes failed, so we need to
3613 // create one or two custom planes to enclose the light origin
3614 for (i = 0;i < 4;i++)
3616 // create a plane using the view origin and light origin, and a
3617 // single point from the frustum corner set
3618 TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3619 VectorNormalize(plane.normal);
3620 plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3621 // see if this plane is backwards and flip it if so
3622 for (j = 0;j < 4;j++)
3623 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3627 VectorNegate(plane.normal, plane.normal);
3629 // flipped plane, test again to see if it is now valid
3630 for (j = 0;j < 4;j++)
3631 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3633 // if the plane is still not valid, then it is dividing the
3634 // frustum and has to be rejected
3638 // we have created a valid plane, compute extra info
3639 PlaneClassify(&plane);
3641 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3643 // if we've found 5 frustum planes then we have constructed a
3644 // proper split-side case and do not need to keep searching for
3645 // planes to enclose the light origin
3646 if (rtlight->cached_numfrustumplanes == 5)
3654 for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3656 plane = rtlight->cached_frustumplanes[i];
3657 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));
3662 // now add the light-space box planes if the light box is rotated, as any
3663 // caster outside the oriented light box is irrelevant (even if it passed
3664 // the worldspace light box, which is axial)
3665 if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3667 for (i = 0;i < 6;i++)
3671 v[i >> 1] = (i & 1) ? -1 : 1;
3672 Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3673 VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3674 plane.dist = VectorNormalizeLength(plane.normal);
3675 plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3676 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3682 // add the world-space reduced box planes
3683 for (i = 0;i < 6;i++)
3685 VectorClear(plane.normal);
3686 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3687 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3688 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3697 // reduce all plane distances to tightly fit the rtlight cull box, which
3699 VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3700 VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3701 VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3702 VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3703 VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3704 VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3705 VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3706 VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3707 oldnum = rtlight->cached_numfrustumplanes;
3708 rtlight->cached_numfrustumplanes = 0;
3709 for (j = 0;j < oldnum;j++)
3711 // find the nearest point on the box to this plane
3712 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3713 for (i = 1;i < 8;i++)
3715 dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3716 if (bestdist > dist)
3719 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);
3720 // if the nearest point is near or behind the plane, we want this
3721 // plane, otherwise the plane is useless as it won't cull anything
3722 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3724 PlaneClassify(&rtlight->cached_frustumplanes[j]);
3725 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3732 static void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3736 RSurf_ActiveWorldEntity();
3738 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3741 GL_CullFace(GL_NONE);
3742 mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3743 for (;mesh;mesh = mesh->next)
3745 if (!mesh->sidetotals[r_shadow_shadowmapside])
3747 r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3748 if (mesh->vertex3fbuffer)
3749 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3751 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3752 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);
3756 else if (r_refdef.scene.worldentity->model)
3757 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);
3759 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3762 static void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3764 qboolean zpass = false;
3767 int surfacelistindex;
3768 msurface_t *surface;
3770 // if triangle neighbors are disabled, shadowvolumes are disabled
3771 if (r_refdef.scene.worldmodel->brush.shadowmesh ? !r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i : !r_refdef.scene.worldmodel->surfmesh.data_neighbor3i)
3774 RSurf_ActiveWorldEntity();
3776 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3779 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3781 zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3782 R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3784 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3785 for (;mesh;mesh = mesh->next)
3787 r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3788 if (mesh->vertex3fbuffer)
3789 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3791 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3792 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3794 // increment stencil if frontface is infront of depthbuffer
3795 GL_CullFace(r_refdef.view.cullface_back);
3796 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
3797 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);
3798 // decrement stencil if backface is infront of depthbuffer
3799 GL_CullFace(r_refdef.view.cullface_front);
3800 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
3802 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3804 // decrement stencil if backface is behind depthbuffer
3805 GL_CullFace(r_refdef.view.cullface_front);
3806 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
3807 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);
3808 // increment stencil if frontface is behind depthbuffer
3809 GL_CullFace(r_refdef.view.cullface_back);
3810 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
3812 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);
3816 else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh)
3818 // use the shadow trispvs calculated earlier by GetLightInfo to cull world triangles on this dynamic light
3819 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3820 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3822 surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3823 for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3824 if (CHECKPVSBIT(trispvs, t))
3825 shadowmarklist[numshadowmark++] = t;
3827 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);
3829 else if (numsurfaces)
3831 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);
3834 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3837 static void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3839 vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3840 vec_t relativeshadowradius;
3841 RSurf_ActiveModelEntity(ent, false, false, false);
3842 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3843 // we need to re-init the shader for each entity because the matrix changed
3844 relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3845 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3846 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3847 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3848 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3849 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3850 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3851 switch (r_shadow_rendermode)
3853 case R_SHADOW_RENDERMODE_SHADOWMAP2D:
3854 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3857 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3860 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3863 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3865 // set up properties for rendering light onto this entity
3866 RSurf_ActiveModelEntity(ent, true, true, false);
3867 Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3868 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3869 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3870 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3873 static void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *lighttrispvs)
3875 if (!r_refdef.scene.worldmodel->DrawLight)
3878 // set up properties for rendering light onto this entity
3879 RSurf_ActiveWorldEntity();
3880 rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3881 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3882 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3883 VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3885 r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
3887 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3890 static void R_Shadow_DrawEntityLight(entity_render_t *ent)
3892 dp_model_t *model = ent->model;
3893 if (!model->DrawLight)
3896 R_Shadow_SetupEntityLight(ent);
3898 model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3900 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3903 static void R_Shadow_PrepareLight(rtlight_t *rtlight)
3907 int numleafs, numsurfaces;
3908 int *leaflist, *surfacelist;
3909 unsigned char *leafpvs;
3910 unsigned char *shadowtrispvs;
3911 unsigned char *lighttrispvs;
3912 //unsigned char *surfacesides;
3913 int numlightentities;
3914 int numlightentities_noselfshadow;
3915 int numshadowentities;
3916 int numshadowentities_noselfshadow;
3917 static entity_render_t *lightentities[MAX_EDICTS];
3918 static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3919 static entity_render_t *shadowentities[MAX_EDICTS];
3920 static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3923 rtlight->draw = false;
3924 rtlight->cached_numlightentities = 0;
3925 rtlight->cached_numlightentities_noselfshadow = 0;
3926 rtlight->cached_numshadowentities = 0;
3927 rtlight->cached_numshadowentities_noselfshadow = 0;
3928 rtlight->cached_numsurfaces = 0;
3929 rtlight->cached_lightentities = NULL;
3930 rtlight->cached_lightentities_noselfshadow = NULL;
3931 rtlight->cached_shadowentities = NULL;
3932 rtlight->cached_shadowentities_noselfshadow = NULL;
3933 rtlight->cached_shadowtrispvs = NULL;
3934 rtlight->cached_lighttrispvs = NULL;
3935 rtlight->cached_surfacelist = NULL;
3937 // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3938 // skip lights that are basically invisible (color 0 0 0)
3939 nolight = VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f);
3941 // loading is done before visibility checks because loading should happen
3942 // all at once at the start of a level, not when it stalls gameplay.
3943 // (especially important to benchmarks)
3945 if (rtlight->isstatic && !nolight && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
3947 if (rtlight->compiled)
3948 R_RTLight_Uncompile(rtlight);
3949 R_RTLight_Compile(rtlight);
3953 rtlight->currentcubemap = rtlight->cubemapname[0] ? R_GetCubemap(rtlight->cubemapname) : r_texture_whitecube;
3955 // look up the light style value at this time
3956 f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3957 VectorScale(rtlight->color, f, rtlight->currentcolor);
3959 if (rtlight->selected)
3961 f = 2 + sin(realtime * M_PI * 4.0);
3962 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3966 // if lightstyle is currently off, don't draw the light
3967 if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3970 // skip processing on corona-only lights
3974 // if the light box is offscreen, skip it
3975 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3978 VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
3979 VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
3981 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3983 // don't allow lights to be drawn if using r_shadow_bouncegrid 2, except if we're using static bouncegrid where dynamic lights still need to draw
3984 if (r_shadow_bouncegrid.integer == 2 && (rtlight->isstatic || !r_shadow_bouncegrid_static.integer))
3987 if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3989 // compiled light, world available and can receive realtime lighting
3990 // retrieve leaf information
3991 numleafs = rtlight->static_numleafs;
3992 leaflist = rtlight->static_leaflist;
3993 leafpvs = rtlight->static_leafpvs;
3994 numsurfaces = rtlight->static_numsurfaces;
3995 surfacelist = rtlight->static_surfacelist;
3996 //surfacesides = NULL;
3997 shadowtrispvs = rtlight->static_shadowtrispvs;
3998 lighttrispvs = rtlight->static_lighttrispvs;
4000 else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
4002 // dynamic light, world available and can receive realtime lighting
4003 // calculate lit surfaces and leafs
4004 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);
4005 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
4006 leaflist = r_shadow_buffer_leaflist;
4007 leafpvs = r_shadow_buffer_leafpvs;
4008 surfacelist = r_shadow_buffer_surfacelist;
4009 //surfacesides = r_shadow_buffer_surfacesides;
4010 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
4011 lighttrispvs = r_shadow_buffer_lighttrispvs;
4012 // if the reduced leaf bounds are offscreen, skip it
4013 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4024 //surfacesides = NULL;
4025 shadowtrispvs = NULL;
4026 lighttrispvs = NULL;
4028 // check if light is illuminating any visible leafs
4031 for (i = 0;i < numleafs;i++)
4032 if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
4038 // make a list of lit entities and shadow casting entities
4039 numlightentities = 0;
4040 numlightentities_noselfshadow = 0;
4041 numshadowentities = 0;
4042 numshadowentities_noselfshadow = 0;
4044 // add dynamic entities that are lit by the light
4045 for (i = 0;i < r_refdef.scene.numentities;i++)
4048 entity_render_t *ent = r_refdef.scene.entities[i];
4050 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4052 // skip the object entirely if it is not within the valid
4053 // shadow-casting region (which includes the lit region)
4054 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
4056 if (!(model = ent->model))
4058 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
4060 // this entity wants to receive light, is visible, and is
4061 // inside the light box
4062 // TODO: check if the surfaces in the model can receive light
4063 // so now check if it's in a leaf seen by the light
4064 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))
4066 if (ent->flags & RENDER_NOSELFSHADOW)
4067 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
4069 lightentities[numlightentities++] = ent;
4070 // since it is lit, it probably also casts a shadow...
4071 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4072 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4073 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4075 // note: exterior models without the RENDER_NOSELFSHADOW
4076 // flag still create a RENDER_NOSELFSHADOW shadow but
4077 // are lit normally, this means that they are
4078 // self-shadowing but do not shadow other
4079 // RENDER_NOSELFSHADOW entities such as the gun
4080 // (very weird, but keeps the player shadow off the gun)
4081 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4082 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4084 shadowentities[numshadowentities++] = ent;
4087 else if (ent->flags & RENDER_SHADOW)
4089 // this entity is not receiving light, but may still need to
4091 // TODO: check if the surfaces in the model can cast shadow
4092 // now check if it is in a leaf seen by the light
4093 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))
4095 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4096 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4097 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4099 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4100 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4102 shadowentities[numshadowentities++] = ent;
4107 // return if there's nothing at all to light
4108 if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
4111 // count this light in the r_speeds
4112 r_refdef.stats.lights++;
4114 // flag it as worth drawing later
4115 rtlight->draw = true;
4117 // cache all the animated entities that cast a shadow but are not visible
4118 for (i = 0;i < numshadowentities;i++)
4119 if (!shadowentities[i]->animcache_vertex3f)
4120 R_AnimCache_GetEntity(shadowentities[i], false, false);
4121 for (i = 0;i < numshadowentities_noselfshadow;i++)
4122 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
4123 R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
4125 // allocate some temporary memory for rendering this light later in the frame
4126 // reusable buffers need to be copied, static data can be used as-is
4127 rtlight->cached_numlightentities = numlightentities;
4128 rtlight->cached_numlightentities_noselfshadow = numlightentities_noselfshadow;
4129 rtlight->cached_numshadowentities = numshadowentities;
4130 rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
4131 rtlight->cached_numsurfaces = numsurfaces;
4132 rtlight->cached_lightentities = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
4133 rtlight->cached_lightentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
4134 rtlight->cached_shadowentities = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
4135 rtlight->cached_shadowentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
4136 if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
4138 int numshadowtrispvsbytes = (((r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles) + 7) >> 3);
4139 int numlighttrispvsbytes = ((r_refdef.scene.worldmodel->surfmesh.num_triangles + 7) >> 3);
4140 rtlight->cached_shadowtrispvs = (unsigned char *)R_FrameData_Store(numshadowtrispvsbytes, shadowtrispvs);
4141 rtlight->cached_lighttrispvs = (unsigned char *)R_FrameData_Store(numlighttrispvsbytes, lighttrispvs);
4142 rtlight->cached_surfacelist = (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
4146 // compiled light data
4147 rtlight->cached_shadowtrispvs = shadowtrispvs;
4148 rtlight->cached_lighttrispvs = lighttrispvs;
4149 rtlight->cached_surfacelist = surfacelist;
4153 static void R_Shadow_DrawLight(rtlight_t *rtlight)
4157 unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
4158 int numlightentities;
4159 int numlightentities_noselfshadow;
4160 int numshadowentities;
4161 int numshadowentities_noselfshadow;
4162 entity_render_t **lightentities;
4163 entity_render_t **lightentities_noselfshadow;
4164 entity_render_t **shadowentities;
4165 entity_render_t **shadowentities_noselfshadow;
4167 static unsigned char entitysides[MAX_EDICTS];
4168 static unsigned char entitysides_noselfshadow[MAX_EDICTS];
4169 vec3_t nearestpoint;
4171 qboolean castshadows;
4174 // check if we cached this light this frame (meaning it is worth drawing)
4178 numlightentities = rtlight->cached_numlightentities;
4179 numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
4180 numshadowentities = rtlight->cached_numshadowentities;
4181 numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
4182 numsurfaces = rtlight->cached_numsurfaces;
4183 lightentities = rtlight->cached_lightentities;
4184 lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
4185 shadowentities = rtlight->cached_shadowentities;
4186 shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
4187 shadowtrispvs = rtlight->cached_shadowtrispvs;
4188 lighttrispvs = rtlight->cached_lighttrispvs;
4189 surfacelist = rtlight->cached_surfacelist;
4191 // set up a scissor rectangle for this light
4192 if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4195 // don't let sound skip if going slow
4196 if (r_refdef.scene.extraupdate)
4199 // make this the active rtlight for rendering purposes
4200 R_Shadow_RenderMode_ActiveLight(rtlight);
4202 if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
4204 // optionally draw visible shape of the shadow volumes
4205 // for performance analysis by level designers
4206 R_Shadow_RenderMode_VisibleShadowVolumes();
4208 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4209 for (i = 0;i < numshadowentities;i++)
4210 R_Shadow_DrawEntityShadow(shadowentities[i]);
4211 for (i = 0;i < numshadowentities_noselfshadow;i++)
4212 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4213 R_Shadow_RenderMode_VisibleLighting(false, false);
4216 if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
4218 // optionally draw the illuminated areas
4219 // for performance analysis by level designers
4220 R_Shadow_RenderMode_VisibleLighting(false, false);
4222 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4223 for (i = 0;i < numlightentities;i++)
4224 R_Shadow_DrawEntityLight(lightentities[i]);
4225 for (i = 0;i < numlightentities_noselfshadow;i++)
4226 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4229 castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
4231 nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
4232 nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
4233 nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
4234 distance = VectorDistance(nearestpoint, r_refdef.view.origin);
4236 lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
4237 //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
4238 lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
4240 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4246 int receivermask = 0;
4247 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
4248 Matrix4x4_Abs(&radiustolight);
4250 r_shadow_shadowmaplod = 0;
4251 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
4252 if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
4253 r_shadow_shadowmaplod = i;
4255 size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
4257 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
4259 surfacesides = NULL;
4262 if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
4264 castermask = rtlight->static_shadowmap_casters;
4265 receivermask = rtlight->static_shadowmap_receivers;
4269 surfacesides = r_shadow_buffer_surfacesides;
4270 for(i = 0;i < numsurfaces;i++)
4272 msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
4273 surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4274 castermask |= surfacesides[i];
4275 receivermask |= surfacesides[i];
4279 if (receivermask < 0x3F)
4281 for (i = 0;i < numlightentities;i++)
4282 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4283 if (receivermask < 0x3F)
4284 for(i = 0; i < numlightentities_noselfshadow;i++)
4285 receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4288 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
4292 for (i = 0;i < numshadowentities;i++)
4293 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4294 for (i = 0;i < numshadowentities_noselfshadow;i++)
4295 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4298 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
4300 // render shadow casters into 6 sided depth texture
4301 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
4303 R_Shadow_RenderMode_ShadowMap(side, receivermask, size);
4304 if (! (castermask & (1 << side))) continue;
4306 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
4307 for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
4308 R_Shadow_DrawEntityShadow(shadowentities[i]);
4311 if (numlightentities_noselfshadow)
4313 // render lighting using the depth texture as shadowmap
4314 // draw lighting in the unmasked areas
4315 R_Shadow_RenderMode_Lighting(false, false, true);
4316 for (i = 0;i < numlightentities_noselfshadow;i++)
4317 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4320 // render shadow casters into 6 sided depth texture
4321 if (numshadowentities_noselfshadow)
4323 for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
4325 R_Shadow_RenderMode_ShadowMap(side, 0, size);
4326 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
4327 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4331 // render lighting using the depth texture as shadowmap
4332 // draw lighting in the unmasked areas
4333 R_Shadow_RenderMode_Lighting(false, false, true);
4334 // draw lighting in the unmasked areas
4336 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4337 for (i = 0;i < numlightentities;i++)
4338 R_Shadow_DrawEntityLight(lightentities[i]);
4340 else if (castshadows && vid.stencil)
4342 // draw stencil shadow volumes to mask off pixels that are in shadow
4343 // so that they won't receive lighting
4344 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
4345 R_Shadow_ClearStencil();
4348 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4349 for (i = 0;i < numshadowentities;i++)
4350 R_Shadow_DrawEntityShadow(shadowentities[i]);
4352 // draw lighting in the unmasked areas
4353 R_Shadow_RenderMode_Lighting(true, false, false);
4354 for (i = 0;i < numlightentities_noselfshadow;i++)
4355 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4357 for (i = 0;i < numshadowentities_noselfshadow;i++)
4358 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4360 // draw lighting in the unmasked areas
4361 R_Shadow_RenderMode_Lighting(true, false, false);
4363 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4364 for (i = 0;i < numlightentities;i++)
4365 R_Shadow_DrawEntityLight(lightentities[i]);
4369 // draw lighting in the unmasked areas
4370 R_Shadow_RenderMode_Lighting(false, false, false);
4372 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4373 for (i = 0;i < numlightentities;i++)
4374 R_Shadow_DrawEntityLight(lightentities[i]);
4375 for (i = 0;i < numlightentities_noselfshadow;i++)
4376 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4379 if (r_shadow_usingdeferredprepass)
4381 // when rendering deferred lighting, we simply rasterize the box
4382 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4383 R_Shadow_RenderMode_DrawDeferredLight(false, true);
4384 else if (castshadows && vid.stencil)
4385 R_Shadow_RenderMode_DrawDeferredLight(true, false);
4387 R_Shadow_RenderMode_DrawDeferredLight(false, false);
4391 static void R_Shadow_FreeDeferred(void)
4393 R_Mesh_DestroyFramebufferObject(r_shadow_prepassgeometryfbo);
4394 r_shadow_prepassgeometryfbo = 0;
4396 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusespecularfbo);
4397 r_shadow_prepasslightingdiffusespecularfbo = 0;
4399 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusefbo);
4400 r_shadow_prepasslightingdiffusefbo = 0;
4402 if (r_shadow_prepassgeometrydepthbuffer)
4403 R_FreeTexture(r_shadow_prepassgeometrydepthbuffer);
4404 r_shadow_prepassgeometrydepthbuffer = NULL;
4406 if (r_shadow_prepassgeometrynormalmaptexture)
4407 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4408 r_shadow_prepassgeometrynormalmaptexture = NULL;
4410 if (r_shadow_prepasslightingdiffusetexture)
4411 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4412 r_shadow_prepasslightingdiffusetexture = NULL;
4414 if (r_shadow_prepasslightingspeculartexture)
4415 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4416 r_shadow_prepasslightingspeculartexture = NULL;
4419 void R_Shadow_DrawPrepass(void)
4427 entity_render_t *ent;
4428 float clearcolor[4];
4430 R_Mesh_ResetTextureState();
4432 GL_ColorMask(1,1,1,1);
4433 GL_BlendFunc(GL_ONE, GL_ZERO);
4436 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4437 Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f);
4438 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4439 if (r_timereport_active)
4440 R_TimeReport("prepasscleargeom");
4442 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4443 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4444 if (r_timereport_active)
4445 R_TimeReport("prepassworld");
4447 for (i = 0;i < r_refdef.scene.numentities;i++)
4449 if (!r_refdef.viewcache.entityvisible[i])
4451 ent = r_refdef.scene.entities[i];
4452 if (ent->model && ent->model->DrawPrepass != NULL)
4453 ent->model->DrawPrepass(ent);
4456 if (r_timereport_active)
4457 R_TimeReport("prepassmodels");
4459 GL_DepthMask(false);
4460 GL_ColorMask(1,1,1,1);
4463 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4464 Vector4Set(clearcolor, 0, 0, 0, 0);
4465 GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
4466 if (r_timereport_active)
4467 R_TimeReport("prepassclearlit");
4469 R_Shadow_RenderMode_Begin();
4471 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4472 if (r_shadow_debuglight.integer >= 0)
4474 lightindex = r_shadow_debuglight.integer;
4475 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4476 if (light && (light->flags & flag) && light->rtlight.draw)
4477 R_Shadow_DrawLight(&light->rtlight);
4481 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4482 for (lightindex = 0;lightindex < range;lightindex++)
4484 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4485 if (light && (light->flags & flag) && light->rtlight.draw)
4486 R_Shadow_DrawLight(&light->rtlight);
4489 if (r_refdef.scene.rtdlight)
4490 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4491 if (r_refdef.scene.lights[lnum]->draw)
4492 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4494 R_Shadow_RenderMode_End();
4496 if (r_timereport_active)
4497 R_TimeReport("prepasslights");
4500 void R_Shadow_DrawLightSprites(void);
4501 void R_Shadow_PrepareLights(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4510 if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4511 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
4512 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20) ||
4513 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4514 r_shadow_shadowmapshadowsampler != (vid.support.arb_shadow && r_shadow_shadowmapping_useshadowsampler.integer) ||
4515 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4516 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4517 R_Shadow_FreeShadowMaps();
4519 r_shadow_fb_fbo = fbo;
4520 r_shadow_fb_depthtexture = depthtexture;
4521 r_shadow_fb_colortexture = colortexture;
4523 r_shadow_usingshadowmaportho = false;
4525 switch (vid.renderpath)
4527 case RENDERPATH_GL20:
4528 case RENDERPATH_D3D9:
4529 case RENDERPATH_D3D10:
4530 case RENDERPATH_D3D11:
4531 case RENDERPATH_SOFT:
4533 if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || vid.maxdrawbuffers < 2)
4535 r_shadow_usingdeferredprepass = false;
4536 if (r_shadow_prepass_width)
4537 R_Shadow_FreeDeferred();
4538 r_shadow_prepass_width = r_shadow_prepass_height = 0;
4542 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4544 R_Shadow_FreeDeferred();
4546 r_shadow_usingdeferredprepass = true;
4547 r_shadow_prepass_width = vid.width;
4548 r_shadow_prepass_height = vid.height;
4549 r_shadow_prepassgeometrydepthbuffer = R_LoadTextureRenderBuffer(r_shadow_texturepool, "prepassgeometrydepthbuffer", vid.width, vid.height, TEXTYPE_DEPTHBUFFER24);
4550 r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4551 r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4552 r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER16F, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4554 // set up the geometry pass fbo (depth + normalmap)
4555 r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4556 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4557 // render depth into a renderbuffer and other important properties into the normalmap texture
4559 // set up the lighting pass fbo (diffuse + specular)
4560 r_shadow_prepasslightingdiffusespecularfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4561 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4562 // render diffuse into one texture and specular into another,
4563 // with depth and normalmap bound as textures,
4564 // with depth bound as attachment as well
4566 // set up the lighting pass fbo (diffuse)
4567 r_shadow_prepasslightingdiffusefbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4568 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthbuffer, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4569 // render diffuse into one texture,
4570 // with depth and normalmap bound as textures,
4571 // with depth bound as attachment as well
4575 case RENDERPATH_GL11:
4576 case RENDERPATH_GL13:
4577 case RENDERPATH_GLES1:
4578 case RENDERPATH_GLES2:
4579 r_shadow_usingdeferredprepass = false;
4583 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);
4585 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4586 if (r_shadow_debuglight.integer >= 0)
4588 lightindex = r_shadow_debuglight.integer;
4589 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4591 R_Shadow_PrepareLight(&light->rtlight);
4595 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4596 for (lightindex = 0;lightindex < range;lightindex++)
4598 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4599 if (light && (light->flags & flag))
4600 R_Shadow_PrepareLight(&light->rtlight);
4603 if (r_refdef.scene.rtdlight)
4605 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4606 R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4608 else if(gl_flashblend.integer)
4610 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4612 rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4613 f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4614 VectorScale(rtlight->color, f, rtlight->currentcolor);
4618 if (r_editlights.integer)
4619 R_Shadow_DrawLightSprites();
4622 void R_Shadow_DrawLights(void)
4630 R_Shadow_RenderMode_Begin();
4632 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4633 if (r_shadow_debuglight.integer >= 0)
4635 lightindex = r_shadow_debuglight.integer;
4636 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4638 R_Shadow_DrawLight(&light->rtlight);
4642 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4643 for (lightindex = 0;lightindex < range;lightindex++)
4645 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4646 if (light && (light->flags & flag))
4647 R_Shadow_DrawLight(&light->rtlight);
4650 if (r_refdef.scene.rtdlight)
4651 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4652 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4654 R_Shadow_RenderMode_End();
4657 void R_Shadow_PrepareModelShadows(void)
4660 float scale, size, radius, dot1, dot2;
4661 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus, shadowmins, shadowmaxs;
4662 entity_render_t *ent;
4664 if (!r_refdef.scene.numentities)
4667 switch (r_shadow_shadowmode)
4669 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4670 if (r_shadows.integer >= 2)
4673 case R_SHADOW_SHADOWMODE_STENCIL:
4674 for (i = 0;i < r_refdef.scene.numentities;i++)
4676 ent = r_refdef.scene.entities[i];
4677 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4678 R_AnimCache_GetEntity(ent, false, false);
4685 size = 2*r_shadow_shadowmapmaxsize;
4686 scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
4687 radius = 0.5f * size / scale;
4689 Math_atov(r_shadows_throwdirection.string, shadowdir);
4690 VectorNormalize(shadowdir);
4691 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4692 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4693 if (fabs(dot1) <= fabs(dot2))
4694 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4696 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4697 VectorNormalize(shadowforward);
4698 CrossProduct(shadowdir, shadowforward, shadowright);
4699 Math_atov(r_shadows_focus.string, shadowfocus);
4700 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4701 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4702 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4703 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4704 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4706 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4708 shadowmins[0] = shadoworigin[0] - r_shadows_throwdistance.value * fabs(shadowdir[0]) - radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4709 shadowmins[1] = shadoworigin[1] - r_shadows_throwdistance.value * fabs(shadowdir[1]) - radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4710 shadowmins[2] = shadoworigin[2] - r_shadows_throwdistance.value * fabs(shadowdir[2]) - radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4711 shadowmaxs[0] = shadoworigin[0] + r_shadows_throwdistance.value * fabs(shadowdir[0]) + radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4712 shadowmaxs[1] = shadoworigin[1] + r_shadows_throwdistance.value * fabs(shadowdir[1]) + radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4713 shadowmaxs[2] = shadoworigin[2] + r_shadows_throwdistance.value * fabs(shadowdir[2]) + radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4715 for (i = 0;i < r_refdef.scene.numentities;i++)
4717 ent = r_refdef.scene.entities[i];
4718 if (!BoxesOverlap(ent->mins, ent->maxs, shadowmins, shadowmaxs))
4720 // cast shadows from anything of the map (submodels are optional)
4721 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4722 R_AnimCache_GetEntity(ent, false, false);
4726 void R_DrawModelShadowMaps(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4729 float relativethrowdistance, scale, size, radius, nearclip, farclip, bias, dot1, dot2;
4730 entity_render_t *ent;
4731 vec3_t relativelightorigin;
4732 vec3_t relativelightdirection, relativeforward, relativeright;
4733 vec3_t relativeshadowmins, relativeshadowmaxs;
4734 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus;
4736 matrix4x4_t shadowmatrix, cameramatrix, mvpmatrix, invmvpmatrix, scalematrix, texmatrix;
4737 r_viewport_t viewport;
4738 GLuint shadowfbo = 0;
4739 float clearcolor[4];
4741 if (!r_refdef.scene.numentities)
4744 switch (r_shadow_shadowmode)
4746 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4752 r_shadow_fb_fbo = fbo;
4753 r_shadow_fb_depthtexture = depthtexture;
4754 r_shadow_fb_colortexture = colortexture;
4756 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
4757 R_Shadow_RenderMode_Begin();
4758 R_Shadow_RenderMode_ActiveLight(NULL);
4760 switch (r_shadow_shadowmode)
4762 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4763 if (!r_shadow_shadowmap2ddepthtexture)
4764 R_Shadow_MakeShadowMap(0, r_shadow_shadowmapmaxsize);
4765 shadowfbo = r_shadow_fbo2d;
4766 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2ddepthtexture);
4767 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2ddepthtexture);
4768 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
4774 size = 2*r_shadow_shadowmapmaxsize;
4775 scale = (r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value) / size;
4776 radius = 0.5f / scale;
4777 nearclip = -r_shadows_throwdistance.value;
4778 farclip = r_shadows_throwdistance.value;
4779 bias = r_shadow_shadowmapping_bias.value * r_shadow_shadowmapping_nearclip.value / (2 * r_shadows_throwdistance.value) * (1024.0f / size);
4781 r_shadow_shadowmap_parameters[0] = size;
4782 r_shadow_shadowmap_parameters[1] = size;
4783 r_shadow_shadowmap_parameters[2] = 1.0;
4784 r_shadow_shadowmap_parameters[3] = bound(0.0f, 1.0f - r_shadows_darken.value, 1.0f);
4786 Math_atov(r_shadows_throwdirection.string, shadowdir);
4787 VectorNormalize(shadowdir);
4788 Math_atov(r_shadows_focus.string, shadowfocus);
4789 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4790 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4791 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4792 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4793 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4794 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4795 if (fabs(dot1) <= fabs(dot2))
4796 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4798 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4799 VectorNormalize(shadowforward);
4800 VectorM(scale, shadowforward, &m[0]);
4801 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4803 m[3] = fabs(dot1) * 0.5f - DotProduct(shadoworigin, &m[0]);
4804 CrossProduct(shadowdir, shadowforward, shadowright);
4805 VectorM(scale, shadowright, &m[4]);
4806 m[7] = 0.5f - DotProduct(shadoworigin, &m[4]);
4807 VectorM(1.0f / (farclip - nearclip), shadowdir, &m[8]);
4808 m[11] = 0.5f - DotProduct(shadoworigin, &m[8]);
4809 Matrix4x4_FromArray12FloatD3D(&shadowmatrix, m);
4810 Matrix4x4_Invert_Full(&cameramatrix, &shadowmatrix);
4811 R_Viewport_InitOrtho(&viewport, &cameramatrix, 0, 0, size, size, 0, 0, 1, 1, 0, -1, NULL);
4813 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4815 if (r_shadow_shadowmap2ddepthbuffer)
4816 R_Mesh_SetRenderTargets(shadowfbo, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL);
4818 R_Mesh_SetRenderTargets(shadowfbo, r_shadow_shadowmap2ddepthtexture, NULL, NULL, NULL, NULL);
4819 R_SetupShader_DepthOrShadow(true, r_shadow_shadowmap2ddepthbuffer != NULL);
4820 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
4823 R_SetViewport(&viewport);
4824 GL_Scissor(viewport.x, viewport.y, min(viewport.width + r_shadow_shadowmapborder, 2*r_shadow_shadowmapmaxsize), viewport.height + r_shadow_shadowmapborder);
4825 Vector4Set(clearcolor, 1,1,1,1);
4826 // in D3D9 we have to render to a color texture shadowmap
4827 // in GL we render directly to a depth texture only
4828 if (r_shadow_shadowmap2ddepthbuffer)
4829 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4831 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4832 // render into a slightly restricted region so that the borders of the
4833 // shadowmap area fade away, rather than streaking across everything
4834 // outside the usable area
4835 GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder);
4839 R_Mesh_SetRenderTargets(r_shadow_fb_fbo, r_shadow_fb_depthtexture, r_shadow_fb_colortexture, NULL, NULL, NULL);
4840 R_SetupShader_ShowDepth(true);
4841 GL_ColorMask(1,1,1,1);
4842 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4845 for (i = 0;i < r_refdef.scene.numentities;i++)
4847 ent = r_refdef.scene.entities[i];
4849 // cast shadows from anything of the map (submodels are optional)
4850 if (ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4852 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4853 Matrix4x4_Transform(&ent->inversematrix, shadoworigin, relativelightorigin);
4854 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4855 Matrix4x4_Transform3x3(&ent->inversematrix, shadowforward, relativeforward);
4856 Matrix4x4_Transform3x3(&ent->inversematrix, shadowright, relativeright);
4857 relativeshadowmins[0] = relativelightorigin[0] - r_shadows_throwdistance.value * fabs(relativelightdirection[0]) - radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4858 relativeshadowmins[1] = relativelightorigin[1] - r_shadows_throwdistance.value * fabs(relativelightdirection[1]) - radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4859 relativeshadowmins[2] = relativelightorigin[2] - r_shadows_throwdistance.value * fabs(relativelightdirection[2]) - radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4860 relativeshadowmaxs[0] = relativelightorigin[0] + r_shadows_throwdistance.value * fabs(relativelightdirection[0]) + radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4861 relativeshadowmaxs[1] = relativelightorigin[1] + r_shadows_throwdistance.value * fabs(relativelightdirection[1]) + radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4862 relativeshadowmaxs[2] = relativelightorigin[2] + r_shadows_throwdistance.value * fabs(relativelightdirection[2]) + radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4863 RSurf_ActiveModelEntity(ent, false, false, false);
4864 ent->model->DrawShadowMap(0, ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
4865 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4872 unsigned char *rawpixels = Z_Malloc(viewport.width*viewport.height*4);
4874 qglReadPixels(viewport.x, viewport.y, viewport.width, viewport.height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, rawpixels);
4876 Image_WriteTGABGRA("r_shadows_2.tga", viewport.width, viewport.height, rawpixels);
4877 Cvar_SetValueQuick(&r_test, 0);
4882 R_Shadow_RenderMode_End();
4884 Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
4885 Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
4886 Matrix4x4_CreateScale3(&scalematrix, size, -size, 1);
4887 Matrix4x4_AdjustOrigin(&scalematrix, 0, size, -0.5f * bias);
4888 Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix);
4889 Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix);
4891 switch (vid.renderpath)
4893 case RENDERPATH_GL11:
4894 case RENDERPATH_GL13:
4895 case RENDERPATH_GL20:
4896 case RENDERPATH_SOFT:
4897 case RENDERPATH_GLES1:
4898 case RENDERPATH_GLES2:
4900 case RENDERPATH_D3D9:
4901 case RENDERPATH_D3D10:
4902 case RENDERPATH_D3D11:
4903 #ifdef OPENGL_ORIENTATION
4904 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4905 r_shadow_shadowmapmatrix.m[0][1] *= -1.0f;
4906 r_shadow_shadowmapmatrix.m[0][2] *= -1.0f;
4907 r_shadow_shadowmapmatrix.m[0][3] *= -1.0f;
4909 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
4910 r_shadow_shadowmapmatrix.m[1][0] *= -1.0f;
4911 r_shadow_shadowmapmatrix.m[2][0] *= -1.0f;
4912 r_shadow_shadowmapmatrix.m[3][0] *= -1.0f;
4917 r_shadow_usingshadowmaportho = true;
4918 switch (r_shadow_shadowmode)
4920 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4921 r_shadow_usingshadowmap2d = true;
4928 void R_DrawModelShadows(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
4931 float relativethrowdistance;
4932 entity_render_t *ent;
4933 vec3_t relativelightorigin;
4934 vec3_t relativelightdirection;
4935 vec3_t relativeshadowmins, relativeshadowmaxs;
4936 vec3_t tmp, shadowdir;
4938 if (!r_refdef.scene.numentities || !vid.stencil || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL && r_shadows.integer != 1))
4941 r_shadow_fb_fbo = fbo;
4942 r_shadow_fb_depthtexture = depthtexture;
4943 r_shadow_fb_colortexture = colortexture;
4945 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
4946 //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
4947 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4948 R_Shadow_RenderMode_Begin();
4949 R_Shadow_RenderMode_ActiveLight(NULL);
4950 r_shadow_lightscissor[0] = r_refdef.view.x;
4951 r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
4952 r_shadow_lightscissor[2] = r_refdef.view.width;
4953 r_shadow_lightscissor[3] = r_refdef.view.height;
4954 R_Shadow_RenderMode_StencilShadowVolumes(false);
4957 if (r_shadows.integer == 2)
4959 Math_atov(r_shadows_throwdirection.string, shadowdir);
4960 VectorNormalize(shadowdir);
4963 R_Shadow_ClearStencil();
4965 for (i = 0;i < r_refdef.scene.numentities;i++)
4967 ent = r_refdef.scene.entities[i];
4969 // cast shadows from anything of the map (submodels are optional)
4970 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4972 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4973 VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
4974 VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
4975 if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
4976 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4979 if(ent->entitynumber != 0)
4981 if(ent->entitynumber >= MAX_EDICTS) // csqc entity
4983 // FIXME handle this
4984 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4988 // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
4989 int entnum, entnum2, recursion;
4990 entnum = entnum2 = ent->entitynumber;
4991 for(recursion = 32; recursion > 0; --recursion)
4993 entnum2 = cl.entities[entnum].state_current.tagentity;
4994 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
4999 if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
5001 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
5002 // transform into modelspace of OUR entity
5003 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
5004 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
5007 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5011 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5014 VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
5015 RSurf_ActiveModelEntity(ent, false, false, false);
5016 ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
5017 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
5021 // not really the right mode, but this will disable any silly stencil features
5022 R_Shadow_RenderMode_End();
5024 // set up ortho view for rendering this pass
5025 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
5026 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5027 //GL_ScissorTest(true);
5028 //R_EntityMatrix(&identitymatrix);
5029 //R_Mesh_ResetTextureState();
5030 R_ResetViewRendering2D(fbo, depthtexture, colortexture);
5032 // set up a darkening blend on shadowed areas
5033 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5034 //GL_DepthRange(0, 1);
5035 //GL_DepthTest(false);
5036 //GL_DepthMask(false);
5037 //GL_PolygonOffset(0, 0);CHECKGLERROR
5038 GL_Color(0, 0, 0, r_shadows_darken.value);
5039 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5040 //GL_DepthFunc(GL_ALWAYS);
5041 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_NOTEQUAL, 128, 255);
5043 // apply the blend to the shadowed areas
5044 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
5045 R_SetupShader_Generic_NoTexture(false, true);
5046 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5048 // restore the viewport
5049 R_SetViewport(&r_refdef.view.viewport);
5051 // restore other state to normal
5052 //R_Shadow_RenderMode_End();
5055 static void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
5058 vec3_t centerorigin;
5060 // if it's too close, skip it
5061 if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
5063 zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
5066 if (usequery && r_numqueries + 2 <= r_maxqueries)
5068 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
5069 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
5070 // 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
5071 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
5073 switch(vid.renderpath)
5075 case RENDERPATH_GL11:
5076 case RENDERPATH_GL13:
5077 case RENDERPATH_GL20:
5078 case RENDERPATH_GLES1:
5079 case RENDERPATH_GLES2:
5080 #ifdef GL_SAMPLES_PASSED_ARB
5082 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead
5083 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
5084 GL_DepthFunc(GL_ALWAYS);
5085 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5086 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5087 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5088 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5089 GL_DepthFunc(GL_LEQUAL);
5090 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
5091 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5092 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5093 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5094 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5098 case RENDERPATH_D3D9:
5099 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5101 case RENDERPATH_D3D10:
5102 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5104 case RENDERPATH_D3D11:
5105 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5107 case RENDERPATH_SOFT:
5108 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5112 rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
5115 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
5117 static void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
5120 GLint allpixels = 0, visiblepixels = 0;
5121 // now we have to check the query result
5122 if (rtlight->corona_queryindex_visiblepixels)
5124 switch(vid.renderpath)
5126 case RENDERPATH_GL11:
5127 case RENDERPATH_GL13:
5128 case RENDERPATH_GL20:
5129 case RENDERPATH_GLES1:
5130 case RENDERPATH_GLES2:
5131 #ifdef GL_SAMPLES_PASSED_ARB
5133 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
5134 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
5138 case RENDERPATH_D3D9:
5139 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5141 case RENDERPATH_D3D10:
5142 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5144 case RENDERPATH_D3D11:
5145 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5147 case RENDERPATH_SOFT:
5148 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5151 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
5152 if (visiblepixels < 1 || allpixels < 1)
5154 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
5155 cscale *= rtlight->corona_visibility;
5159 // FIXME: these traces should scan all render entities instead of cl.world
5160 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
5163 VectorScale(rtlight->currentcolor, cscale, color);
5164 if (VectorLength(color) > (1.0f / 256.0f))
5167 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
5170 VectorNegate(color, color);
5171 GL_BlendEquationSubtract(true);
5173 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5174 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);
5175 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5177 GL_BlendEquationSubtract(false);
5181 void R_Shadow_DrawCoronas(void)
5184 qboolean usequery = false;
5189 if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
5191 if (r_fb.water.renderingscene)
5193 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
5194 R_EntityMatrix(&identitymatrix);
5196 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5198 // check occlusion of coronas
5199 // use GL_ARB_occlusion_query if available
5200 // otherwise use raytraces
5202 switch (vid.renderpath)
5204 case RENDERPATH_GL11:
5205 case RENDERPATH_GL13:
5206 case RENDERPATH_GL20:
5207 case RENDERPATH_GLES1:
5208 case RENDERPATH_GLES2:
5209 usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
5210 #ifdef GL_SAMPLES_PASSED_ARB
5213 GL_ColorMask(0,0,0,0);
5214 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
5215 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
5218 r_maxqueries = (range + r_refdef.scene.numlights) * 4;
5219 r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
5221 qglGenQueriesARB(r_maxqueries - i, r_queries + i);
5224 RSurf_ActiveWorldEntity();
5225 GL_BlendFunc(GL_ONE, GL_ZERO);
5226 GL_CullFace(GL_NONE);
5227 GL_DepthMask(false);
5228 GL_DepthRange(0, 1);
5229 GL_PolygonOffset(0, 0);
5231 R_Mesh_ResetTextureState();
5232 R_SetupShader_Generic_NoTexture(false, false);
5236 case RENDERPATH_D3D9:
5238 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5240 case RENDERPATH_D3D10:
5241 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5243 case RENDERPATH_D3D11:
5244 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5246 case RENDERPATH_SOFT:
5248 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5251 for (lightindex = 0;lightindex < range;lightindex++)
5253 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5256 rtlight = &light->rtlight;
5257 rtlight->corona_visibility = 0;
5258 rtlight->corona_queryindex_visiblepixels = 0;
5259 rtlight->corona_queryindex_allpixels = 0;
5260 if (!(rtlight->flags & flag))
5262 if (rtlight->corona <= 0)
5264 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
5266 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5268 for (i = 0;i < r_refdef.scene.numlights;i++)
5270 rtlight = r_refdef.scene.lights[i];
5271 rtlight->corona_visibility = 0;
5272 rtlight->corona_queryindex_visiblepixels = 0;
5273 rtlight->corona_queryindex_allpixels = 0;
5274 if (!(rtlight->flags & flag))
5276 if (rtlight->corona <= 0)
5278 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5281 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5283 // now draw the coronas using the query data for intensity info
5284 for (lightindex = 0;lightindex < range;lightindex++)
5286 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5289 rtlight = &light->rtlight;
5290 if (rtlight->corona_visibility <= 0)
5292 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5294 for (i = 0;i < r_refdef.scene.numlights;i++)
5296 rtlight = r_refdef.scene.lights[i];
5297 if (rtlight->corona_visibility <= 0)
5299 if (gl_flashblend.integer)
5300 R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
5302 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5308 static dlight_t *R_Shadow_NewWorldLight(void)
5310 return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
5313 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)
5316 // validate parameters
5317 if (style < 0 || style >= MAX_LIGHTSTYLES)
5319 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
5325 // copy to light properties
5326 VectorCopy(origin, light->origin);
5327 light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
5328 light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
5329 light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
5331 light->color[0] = max(color[0], 0);
5332 light->color[1] = max(color[1], 0);
5333 light->color[2] = max(color[2], 0);
5335 light->color[0] = color[0];
5336 light->color[1] = color[1];
5337 light->color[2] = color[2];
5338 light->radius = max(radius, 0);
5339 light->style = style;
5340 light->shadow = shadowenable;
5341 light->corona = corona;
5342 strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
5343 light->coronasizescale = coronasizescale;
5344 light->ambientscale = ambientscale;
5345 light->diffusescale = diffusescale;
5346 light->specularscale = specularscale;
5347 light->flags = flags;
5349 // update renderable light data
5350 Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
5351 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);
5354 static void R_Shadow_FreeWorldLight(dlight_t *light)
5356 if (r_shadow_selectedlight == light)
5357 r_shadow_selectedlight = NULL;
5358 R_RTLight_Uncompile(&light->rtlight);
5359 Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
5362 void R_Shadow_ClearWorldLights(void)
5366 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5367 for (lightindex = 0;lightindex < range;lightindex++)
5369 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5371 R_Shadow_FreeWorldLight(light);
5373 r_shadow_selectedlight = NULL;
5376 static void R_Shadow_SelectLight(dlight_t *light)
5378 if (r_shadow_selectedlight)
5379 r_shadow_selectedlight->selected = false;
5380 r_shadow_selectedlight = light;
5381 if (r_shadow_selectedlight)
5382 r_shadow_selectedlight->selected = true;
5385 static void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5387 // this is never batched (there can be only one)
5389 R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
5390 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5391 R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5394 static void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5399 skinframe_t *skinframe;
5402 // this is never batched (due to the ent parameter changing every time)
5403 // so numsurfaces == 1 and surfacelist[0] == lightnumber
5404 const dlight_t *light = (dlight_t *)ent;
5407 R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
5410 VectorScale(light->color, intensity, spritecolor);
5411 if (VectorLength(spritecolor) < 0.1732f)
5412 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
5413 if (VectorLength(spritecolor) > 1.0f)
5414 VectorNormalize(spritecolor);
5416 // draw light sprite
5417 if (light->cubemapname[0] && !light->shadow)
5418 skinframe = r_editlights_sprcubemapnoshadowlight;
5419 else if (light->cubemapname[0])
5420 skinframe = r_editlights_sprcubemaplight;
5421 else if (!light->shadow)
5422 skinframe = r_editlights_sprnoshadowlight;
5424 skinframe = r_editlights_sprlight;
5426 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);
5427 R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5429 // draw selection sprite if light is selected
5430 if (light->selected)
5432 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5433 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5434 // VorteX todo: add normalmode/realtime mode light overlay sprites?
5438 void R_Shadow_DrawLightSprites(void)
5442 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5443 for (lightindex = 0;lightindex < range;lightindex++)
5445 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5447 R_MeshQueue_AddTransparent(MESHQUEUE_SORT_DISTANCE, light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
5449 if (!r_editlights_lockcursor)
5450 R_MeshQueue_AddTransparent(MESHQUEUE_SORT_DISTANCE, r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
5453 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
5458 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
5459 if (lightindex >= range)
5461 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5464 rtlight = &light->rtlight;
5465 //if (!(rtlight->flags & flag))
5467 VectorCopy(rtlight->shadoworigin, origin);
5468 *radius = rtlight->radius;
5469 VectorCopy(rtlight->color, color);
5473 static void R_Shadow_SelectLightInView(void)
5475 float bestrating, rating, temp[3];
5479 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5483 if (r_editlights_lockcursor)
5485 for (lightindex = 0;lightindex < range;lightindex++)
5487 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5490 VectorSubtract(light->origin, r_refdef.view.origin, temp);
5491 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
5494 rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
5495 if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1.0f)
5497 bestrating = rating;
5502 R_Shadow_SelectLight(best);
5505 void R_Shadow_LoadWorldLights(void)
5507 int n, a, style, shadow, flags;
5508 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
5509 float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
5510 if (cl.worldmodel == NULL)
5512 Con_Print("No map loaded.\n");
5515 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5516 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5526 for (;COM_Parse(t, true) && strcmp(
5527 if (COM_Parse(t, true))
5529 if (com_token[0] == '!')
5532 origin[0] = atof(com_token+1);
5535 origin[0] = atof(com_token);
5540 while (*s && *s != '\n' && *s != '\r')
5546 // check for modifier flags
5553 #if _MSC_VER >= 1400
5554 #define sscanf sscanf_s
5556 cubemapname[sizeof(cubemapname)-1] = 0;
5557 #if MAX_QPATH != 128
5558 #error update this code if MAX_QPATH changes
5560 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
5561 #if _MSC_VER >= 1400
5562 , sizeof(cubemapname)
5564 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
5567 flags = LIGHTFLAG_REALTIMEMODE;
5575 coronasizescale = 0.25f;
5577 VectorClear(angles);
5580 if (a < 9 || !strcmp(cubemapname, "\"\""))
5582 // remove quotes on cubemapname
5583 if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
5586 namelen = strlen(cubemapname) - 2;
5587 memmove(cubemapname, cubemapname + 1, namelen);
5588 cubemapname[namelen] = '\0';
5592 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);
5595 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5603 Con_Printf("invalid rtlights file \"%s\"\n", name);
5604 Mem_Free(lightsstring);
5608 void R_Shadow_SaveWorldLights(void)
5612 size_t bufchars, bufmaxchars;
5614 char name[MAX_QPATH];
5615 char line[MAX_INPUTLINE];
5616 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5617 // I hate lines which are 3 times my screen size :( --blub
5620 if (cl.worldmodel == NULL)
5622 Con_Print("No map loaded.\n");
5625 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5626 bufchars = bufmaxchars = 0;
5628 for (lightindex = 0;lightindex < range;lightindex++)
5630 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5633 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5634 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);
5635 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5636 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]);
5638 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);
5639 if (bufchars + strlen(line) > bufmaxchars)
5641 bufmaxchars = bufchars + strlen(line) + 2048;
5643 buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5647 memcpy(buf, oldbuf, bufchars);
5653 memcpy(buf + bufchars, line, strlen(line));
5654 bufchars += strlen(line);
5658 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5663 void R_Shadow_LoadLightsFile(void)
5666 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5667 float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5668 if (cl.worldmodel == NULL)
5670 Con_Print("No map loaded.\n");
5673 dpsnprintf(name, sizeof(name), "%s.lights", cl.worldnamenoextension);
5674 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5682 while (*s && *s != '\n' && *s != '\r')
5688 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);
5692 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);
5695 radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5696 radius = bound(15, radius, 4096);
5697 VectorScale(color, (2.0f / (8388608.0f)), color);
5698 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5706 Con_Printf("invalid lights file \"%s\"\n", name);
5707 Mem_Free(lightsstring);
5711 // tyrlite/hmap2 light types in the delay field
5712 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5714 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5726 float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5727 char key[256], value[MAX_INPUTLINE];
5730 if (cl.worldmodel == NULL)
5732 Con_Print("No map loaded.\n");
5735 // try to load a .ent file first
5736 dpsnprintf(key, sizeof(key), "%s.ent", cl.worldnamenoextension);
5737 data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5738 // and if that is not found, fall back to the bsp file entity string
5740 data = cl.worldmodel->brush.entities;
5743 for (entnum = 0;COM_ParseToken_Simple(&data, false, false, true) && com_token[0] == '{';entnum++)
5745 type = LIGHTTYPE_MINUSX;
5746 origin[0] = origin[1] = origin[2] = 0;
5747 originhack[0] = originhack[1] = originhack[2] = 0;
5748 angles[0] = angles[1] = angles[2] = 0;
5749 color[0] = color[1] = color[2] = 1;
5750 light[0] = light[1] = light[2] = 1;light[3] = 300;
5751 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5761 if (!COM_ParseToken_Simple(&data, false, false, true))
5763 if (com_token[0] == '}')
5764 break; // end of entity
5765 if (com_token[0] == '_')
5766 strlcpy(key, com_token + 1, sizeof(key));
5768 strlcpy(key, com_token, sizeof(key));
5769 while (key[strlen(key)-1] == ' ') // remove trailing spaces
5770 key[strlen(key)-1] = 0;
5771 if (!COM_ParseToken_Simple(&data, false, false, true))
5773 strlcpy(value, com_token, sizeof(value));
5775 // now that we have the key pair worked out...
5776 if (!strcmp("light", key))
5778 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5782 light[0] = vec[0] * (1.0f / 256.0f);
5783 light[1] = vec[0] * (1.0f / 256.0f);
5784 light[2] = vec[0] * (1.0f / 256.0f);
5790 light[0] = vec[0] * (1.0f / 255.0f);
5791 light[1] = vec[1] * (1.0f / 255.0f);
5792 light[2] = vec[2] * (1.0f / 255.0f);
5796 else if (!strcmp("delay", key))
5798 else if (!strcmp("origin", key))
5799 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5800 else if (!strcmp("angle", key))
5801 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5802 else if (!strcmp("angles", key))
5803 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5804 else if (!strcmp("color", key))
5805 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5806 else if (!strcmp("wait", key))
5807 fadescale = atof(value);
5808 else if (!strcmp("classname", key))
5810 if (!strncmp(value, "light", 5))
5813 if (!strcmp(value, "light_fluoro"))
5818 overridecolor[0] = 1;
5819 overridecolor[1] = 1;
5820 overridecolor[2] = 1;
5822 if (!strcmp(value, "light_fluorospark"))
5827 overridecolor[0] = 1;
5828 overridecolor[1] = 1;
5829 overridecolor[2] = 1;
5831 if (!strcmp(value, "light_globe"))
5836 overridecolor[0] = 1;
5837 overridecolor[1] = 0.8;
5838 overridecolor[2] = 0.4;
5840 if (!strcmp(value, "light_flame_large_yellow"))
5845 overridecolor[0] = 1;
5846 overridecolor[1] = 0.5;
5847 overridecolor[2] = 0.1;
5849 if (!strcmp(value, "light_flame_small_yellow"))
5854 overridecolor[0] = 1;
5855 overridecolor[1] = 0.5;
5856 overridecolor[2] = 0.1;
5858 if (!strcmp(value, "light_torch_small_white"))
5863 overridecolor[0] = 1;
5864 overridecolor[1] = 0.5;
5865 overridecolor[2] = 0.1;
5867 if (!strcmp(value, "light_torch_small_walltorch"))
5872 overridecolor[0] = 1;
5873 overridecolor[1] = 0.5;
5874 overridecolor[2] = 0.1;
5878 else if (!strcmp("style", key))
5879 style = atoi(value);
5880 else if (!strcmp("skin", key))
5881 skin = (int)atof(value);
5882 else if (!strcmp("pflags", key))
5883 pflags = (int)atof(value);
5884 //else if (!strcmp("effects", key))
5885 // effects = (int)atof(value);
5886 else if (cl.worldmodel->type == mod_brushq3)
5888 if (!strcmp("scale", key))
5889 lightscale = atof(value);
5890 if (!strcmp("fade", key))
5891 fadescale = atof(value);
5896 if (lightscale <= 0)
5900 if (color[0] == color[1] && color[0] == color[2])
5902 color[0] *= overridecolor[0];
5903 color[1] *= overridecolor[1];
5904 color[2] *= overridecolor[2];
5906 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
5907 color[0] = color[0] * light[0];
5908 color[1] = color[1] * light[1];
5909 color[2] = color[2] * light[2];
5912 case LIGHTTYPE_MINUSX:
5914 case LIGHTTYPE_RECIPX:
5916 VectorScale(color, (1.0f / 16.0f), color);
5918 case LIGHTTYPE_RECIPXX:
5920 VectorScale(color, (1.0f / 16.0f), color);
5923 case LIGHTTYPE_NONE:
5927 case LIGHTTYPE_MINUSXX:
5930 VectorAdd(origin, originhack, origin);
5932 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);
5935 Mem_Free(entfiledata);
5939 static void R_Shadow_SetCursorLocationForView(void)
5942 vec3_t dest, endpos;
5944 VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
5945 trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true);
5946 if (trace.fraction < 1)
5948 dist = trace.fraction * r_editlights_cursordistance.value;
5949 push = r_editlights_cursorpushback.value;
5953 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
5954 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
5958 VectorClear( endpos );
5960 r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5961 r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5962 r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5965 void R_Shadow_UpdateWorldLightSelection(void)
5967 if (r_editlights.integer)
5969 R_Shadow_SetCursorLocationForView();
5970 R_Shadow_SelectLightInView();
5973 R_Shadow_SelectLight(NULL);
5976 static void R_Shadow_EditLights_Clear_f(void)
5978 R_Shadow_ClearWorldLights();
5981 void R_Shadow_EditLights_Reload_f(void)
5985 strlcpy(r_shadow_mapname, cl.worldname, sizeof(r_shadow_mapname));
5986 R_Shadow_ClearWorldLights();
5987 R_Shadow_LoadWorldLights();
5988 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5990 R_Shadow_LoadLightsFile();
5991 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5992 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5996 static void R_Shadow_EditLights_Save_f(void)
6000 R_Shadow_SaveWorldLights();
6003 static void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
6005 R_Shadow_ClearWorldLights();
6006 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
6009 static void R_Shadow_EditLights_ImportLightsFile_f(void)
6011 R_Shadow_ClearWorldLights();
6012 R_Shadow_LoadLightsFile();
6015 static void R_Shadow_EditLights_Spawn_f(void)
6018 if (!r_editlights.integer)
6020 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6023 if (Cmd_Argc() != 1)
6025 Con_Print("r_editlights_spawn does not take parameters\n");
6028 color[0] = color[1] = color[2] = 1;
6029 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
6032 static void R_Shadow_EditLights_Edit_f(void)
6034 vec3_t origin, angles, color;
6035 vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
6036 int style, shadows, flags, normalmode, realtimemode;
6037 char cubemapname[MAX_INPUTLINE];
6038 if (!r_editlights.integer)
6040 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6043 if (!r_shadow_selectedlight)
6045 Con_Print("No selected light.\n");
6048 VectorCopy(r_shadow_selectedlight->origin, origin);
6049 VectorCopy(r_shadow_selectedlight->angles, angles);
6050 VectorCopy(r_shadow_selectedlight->color, color);
6051 radius = r_shadow_selectedlight->radius;
6052 style = r_shadow_selectedlight->style;
6053 if (r_shadow_selectedlight->cubemapname)
6054 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
6057 shadows = r_shadow_selectedlight->shadow;
6058 corona = r_shadow_selectedlight->corona;
6059 coronasizescale = r_shadow_selectedlight->coronasizescale;
6060 ambientscale = r_shadow_selectedlight->ambientscale;
6061 diffusescale = r_shadow_selectedlight->diffusescale;
6062 specularscale = r_shadow_selectedlight->specularscale;
6063 flags = r_shadow_selectedlight->flags;
6064 normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
6065 realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
6066 if (!strcmp(Cmd_Argv(1), "origin"))
6068 if (Cmd_Argc() != 5)
6070 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6073 origin[0] = atof(Cmd_Argv(2));
6074 origin[1] = atof(Cmd_Argv(3));
6075 origin[2] = atof(Cmd_Argv(4));
6077 else if (!strcmp(Cmd_Argv(1), "originscale"))
6079 if (Cmd_Argc() != 5)
6081 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6084 origin[0] *= atof(Cmd_Argv(2));
6085 origin[1] *= atof(Cmd_Argv(3));
6086 origin[2] *= atof(Cmd_Argv(4));
6088 else if (!strcmp(Cmd_Argv(1), "originx"))
6090 if (Cmd_Argc() != 3)
6092 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6095 origin[0] = atof(Cmd_Argv(2));
6097 else if (!strcmp(Cmd_Argv(1), "originy"))
6099 if (Cmd_Argc() != 3)
6101 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6104 origin[1] = atof(Cmd_Argv(2));
6106 else if (!strcmp(Cmd_Argv(1), "originz"))
6108 if (Cmd_Argc() != 3)
6110 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6113 origin[2] = atof(Cmd_Argv(2));
6115 else if (!strcmp(Cmd_Argv(1), "move"))
6117 if (Cmd_Argc() != 5)
6119 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6122 origin[0] += atof(Cmd_Argv(2));
6123 origin[1] += atof(Cmd_Argv(3));
6124 origin[2] += atof(Cmd_Argv(4));
6126 else if (!strcmp(Cmd_Argv(1), "movex"))
6128 if (Cmd_Argc() != 3)
6130 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6133 origin[0] += atof(Cmd_Argv(2));
6135 else if (!strcmp(Cmd_Argv(1), "movey"))
6137 if (Cmd_Argc() != 3)
6139 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6142 origin[1] += atof(Cmd_Argv(2));
6144 else if (!strcmp(Cmd_Argv(1), "movez"))
6146 if (Cmd_Argc() != 3)
6148 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6151 origin[2] += atof(Cmd_Argv(2));
6153 else if (!strcmp(Cmd_Argv(1), "angles"))
6155 if (Cmd_Argc() != 5)
6157 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6160 angles[0] = atof(Cmd_Argv(2));
6161 angles[1] = atof(Cmd_Argv(3));
6162 angles[2] = atof(Cmd_Argv(4));
6164 else if (!strcmp(Cmd_Argv(1), "anglesx"))
6166 if (Cmd_Argc() != 3)
6168 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6171 angles[0] = atof(Cmd_Argv(2));
6173 else if (!strcmp(Cmd_Argv(1), "anglesy"))
6175 if (Cmd_Argc() != 3)
6177 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6180 angles[1] = atof(Cmd_Argv(2));
6182 else if (!strcmp(Cmd_Argv(1), "anglesz"))
6184 if (Cmd_Argc() != 3)
6186 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6189 angles[2] = atof(Cmd_Argv(2));
6191 else if (!strcmp(Cmd_Argv(1), "color"))
6193 if (Cmd_Argc() != 5)
6195 Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
6198 color[0] = atof(Cmd_Argv(2));
6199 color[1] = atof(Cmd_Argv(3));
6200 color[2] = atof(Cmd_Argv(4));
6202 else if (!strcmp(Cmd_Argv(1), "radius"))
6204 if (Cmd_Argc() != 3)
6206 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6209 radius = atof(Cmd_Argv(2));
6211 else if (!strcmp(Cmd_Argv(1), "colorscale"))
6213 if (Cmd_Argc() == 3)
6215 double scale = atof(Cmd_Argv(2));
6222 if (Cmd_Argc() != 5)
6224 Con_Printf("usage: r_editlights_edit %s red green blue (OR grey instead of red green blue)\n", Cmd_Argv(1));
6227 color[0] *= atof(Cmd_Argv(2));
6228 color[1] *= atof(Cmd_Argv(3));
6229 color[2] *= atof(Cmd_Argv(4));
6232 else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
6234 if (Cmd_Argc() != 3)
6236 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6239 radius *= atof(Cmd_Argv(2));
6241 else if (!strcmp(Cmd_Argv(1), "style"))
6243 if (Cmd_Argc() != 3)
6245 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6248 style = atoi(Cmd_Argv(2));
6250 else if (!strcmp(Cmd_Argv(1), "cubemap"))
6254 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6257 if (Cmd_Argc() == 3)
6258 strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
6262 else if (!strcmp(Cmd_Argv(1), "shadows"))
6264 if (Cmd_Argc() != 3)
6266 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6269 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6271 else if (!strcmp(Cmd_Argv(1), "corona"))
6273 if (Cmd_Argc() != 3)
6275 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6278 corona = atof(Cmd_Argv(2));
6280 else if (!strcmp(Cmd_Argv(1), "coronasize"))
6282 if (Cmd_Argc() != 3)
6284 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6287 coronasizescale = atof(Cmd_Argv(2));
6289 else if (!strcmp(Cmd_Argv(1), "ambient"))
6291 if (Cmd_Argc() != 3)
6293 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6296 ambientscale = atof(Cmd_Argv(2));
6298 else if (!strcmp(Cmd_Argv(1), "diffuse"))
6300 if (Cmd_Argc() != 3)
6302 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6305 diffusescale = atof(Cmd_Argv(2));
6307 else if (!strcmp(Cmd_Argv(1), "specular"))
6309 if (Cmd_Argc() != 3)
6311 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6314 specularscale = atof(Cmd_Argv(2));
6316 else if (!strcmp(Cmd_Argv(1), "normalmode"))
6318 if (Cmd_Argc() != 3)
6320 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6323 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6325 else if (!strcmp(Cmd_Argv(1), "realtimemode"))
6327 if (Cmd_Argc() != 3)
6329 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6332 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6336 Con_Print("usage: r_editlights_edit [property] [value]\n");
6337 Con_Print("Selected light's properties:\n");
6338 Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
6339 Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
6340 Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
6341 Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius);
6342 Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona);
6343 Con_Printf("Style : %i\n", r_shadow_selectedlight->style);
6344 Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
6345 Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname);
6346 Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);
6347 Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale);
6348 Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale);
6349 Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale);
6350 Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
6351 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
6354 flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
6355 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
6358 static void R_Shadow_EditLights_EditAll_f(void)
6361 dlight_t *light, *oldselected;
6364 if (!r_editlights.integer)
6366 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
6370 oldselected = r_shadow_selectedlight;
6371 // EditLights doesn't seem to have a "remove" command or something so:
6372 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6373 for (lightindex = 0;lightindex < range;lightindex++)
6375 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6378 R_Shadow_SelectLight(light);
6379 R_Shadow_EditLights_Edit_f();
6381 // return to old selected (to not mess editing once selection is locked)
6382 R_Shadow_SelectLight(oldselected);
6385 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
6387 int lightnumber, lightcount;
6388 size_t lightindex, range;
6392 if (!r_editlights.integer)
6394 x = vid_conwidth.value - 240;
6396 DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
6399 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6400 for (lightindex = 0;lightindex < range;lightindex++)
6402 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6405 if (light == r_shadow_selectedlight)
6406 lightnumber = lightindex;
6409 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;
6410 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;
6412 if (r_shadow_selectedlight == NULL)
6414 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;
6415 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;
6416 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;
6417 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;
6418 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;
6419 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;
6420 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;
6421 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;
6422 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;
6423 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;
6424 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;
6425 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;
6426 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;
6427 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;
6428 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;
6431 static void R_Shadow_EditLights_ToggleShadow_f(void)
6433 if (!r_editlights.integer)
6435 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6438 if (!r_shadow_selectedlight)
6440 Con_Print("No selected light.\n");
6443 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, r_shadow_selectedlight->origin, r_shadow_selectedlight->angles, r_shadow_selectedlight->color, r_shadow_selectedlight->radius, r_shadow_selectedlight->corona, r_shadow_selectedlight->style, !r_shadow_selectedlight->shadow, r_shadow_selectedlight->cubemapname, r_shadow_selectedlight->coronasizescale, r_shadow_selectedlight->ambientscale, r_shadow_selectedlight->diffusescale, r_shadow_selectedlight->specularscale, r_shadow_selectedlight->flags);
6446 static void R_Shadow_EditLights_ToggleCorona_f(void)
6448 if (!r_editlights.integer)
6450 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6453 if (!r_shadow_selectedlight)
6455 Con_Print("No selected light.\n");
6458 R_Shadow_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);
6461 static void R_Shadow_EditLights_Remove_f(void)
6463 if (!r_editlights.integer)
6465 Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n");
6468 if (!r_shadow_selectedlight)
6470 Con_Print("No selected light.\n");
6473 R_Shadow_FreeWorldLight(r_shadow_selectedlight);
6474 r_shadow_selectedlight = NULL;
6477 static void R_Shadow_EditLights_Help_f(void)
6480 "Documentation on r_editlights system:\n"
6482 "r_editlights : enable/disable editing mode\n"
6483 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
6484 "r_editlights_cursorpushback : push back cursor this far from surface\n"
6485 "r_editlights_cursorpushoff : push cursor off surface this far\n"
6486 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
6487 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
6489 "r_editlights_help : this help\n"
6490 "r_editlights_clear : remove all lights\n"
6491 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
6492 "r_editlights_lock : lock selection to current light, if already locked - unlock\n"
6493 "r_editlights_save : save to .rtlights file\n"
6494 "r_editlights_spawn : create a light with default settings\n"
6495 "r_editlights_edit command : edit selected light - more documentation below\n"
6496 "r_editlights_remove : remove selected light\n"
6497 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
6498 "r_editlights_importlightentitiesfrommap : reload light entities\n"
6499 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
6501 "origin x y z : set light location\n"
6502 "originx x: set x component of light location\n"
6503 "originy y: set y component of light location\n"
6504 "originz z: set z component of light location\n"
6505 "move x y z : adjust light location\n"
6506 "movex x: adjust x component of light location\n"
6507 "movey y: adjust y component of light location\n"
6508 "movez z: adjust z component of light location\n"
6509 "angles x y z : set light angles\n"
6510 "anglesx x: set x component of light angles\n"
6511 "anglesy y: set y component of light angles\n"
6512 "anglesz z: set z component of light angles\n"
6513 "color r g b : set color of light (can be brighter than 1 1 1)\n"
6514 "radius radius : set radius (size) of light\n"
6515 "colorscale grey : multiply color of light (1 does nothing)\n"
6516 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
6517 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
6518 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
6519 "originscale x y z : multiply origin of light (1 1 1 does nothing)\n"
6520 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
6521 "cubemap basename : set filter cubemap of light (not yet supported)\n"
6522 "shadows 1/0 : turn on/off shadows\n"
6523 "corona n : set corona intensity\n"
6524 "coronasize n : set corona size (0-1)\n"
6525 "ambient n : set ambient intensity (0-1)\n"
6526 "diffuse n : set diffuse intensity (0-1)\n"
6527 "specular n : set specular intensity (0-1)\n"
6528 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
6529 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
6530 "<nothing> : print light properties to console\n"
6534 static void R_Shadow_EditLights_CopyInfo_f(void)
6536 if (!r_editlights.integer)
6538 Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n");
6541 if (!r_shadow_selectedlight)
6543 Con_Print("No selected light.\n");
6546 VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
6547 VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
6548 r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
6549 r_shadow_bufferlight.style = r_shadow_selectedlight->style;
6550 if (r_shadow_selectedlight->cubemapname)
6551 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
6553 r_shadow_bufferlight.cubemapname[0] = 0;
6554 r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
6555 r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
6556 r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
6557 r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
6558 r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
6559 r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
6560 r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
6563 static void R_Shadow_EditLights_PasteInfo_f(void)
6565 if (!r_editlights.integer)
6567 Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n");
6570 if (!r_shadow_selectedlight)
6572 Con_Print("No selected light.\n");
6575 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);
6578 static void R_Shadow_EditLights_Lock_f(void)
6580 if (!r_editlights.integer)
6582 Con_Print("Cannot lock on light when not in editing mode. Set r_editlights to 1.\n");
6585 if (r_editlights_lockcursor)
6587 r_editlights_lockcursor = false;
6590 if (!r_shadow_selectedlight)
6592 Con_Print("No selected light to lock on.\n");
6595 r_editlights_lockcursor = true;
6598 static void R_Shadow_EditLights_Init(void)
6600 Cvar_RegisterVariable(&r_editlights);
6601 Cvar_RegisterVariable(&r_editlights_cursordistance);
6602 Cvar_RegisterVariable(&r_editlights_cursorpushback);
6603 Cvar_RegisterVariable(&r_editlights_cursorpushoff);
6604 Cvar_RegisterVariable(&r_editlights_cursorgrid);
6605 Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
6606 Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
6607 Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
6608 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)");
6609 Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
6610 Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
6611 Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
6612 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)");
6613 Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
6614 Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
6615 Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
6616 Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
6617 Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
6618 Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
6619 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)");
6620 Cmd_AddCommand("r_editlights_lock", R_Shadow_EditLights_Lock_f, "lock selection to current light, if already locked - unlock");
6626 =============================================================================
6630 =============================================================================
6633 void R_LightPoint(vec3_t color, const vec3_t p, const int flags)
6635 int i, numlights, flag;
6636 float f, relativepoint[3], dist, dist2, lightradius2;
6641 if (r_fullbright.integer)
6643 VectorSet(color, 1, 1, 1);
6649 if (flags & LP_LIGHTMAP)
6651 if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6653 VectorClear(diffuse);
6654 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, color, diffuse, n);
6655 VectorAdd(color, diffuse, color);
6658 VectorSet(color, 1, 1, 1);
6659 color[0] += r_refdef.scene.ambient;
6660 color[1] += r_refdef.scene.ambient;
6661 color[2] += r_refdef.scene.ambient;
6664 if (flags & LP_RTWORLD)
6666 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6667 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6668 for (i = 0; i < numlights; i++)
6670 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6673 light = &dlight->rtlight;
6674 if (!(light->flags & flag))
6677 lightradius2 = light->radius * light->radius;
6678 VectorSubtract(light->shadoworigin, p, relativepoint);
6679 dist2 = VectorLength2(relativepoint);
6680 if (dist2 >= lightradius2)
6682 dist = sqrt(dist2) / light->radius;
6683 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6686 // todo: add to both ambient and diffuse
6687 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6688 VectorMA(color, f, light->currentcolor, color);
6691 if (flags & LP_DYNLIGHT)
6694 for (i = 0;i < r_refdef.scene.numlights;i++)
6696 light = r_refdef.scene.lights[i];
6698 lightradius2 = light->radius * light->radius;
6699 VectorSubtract(light->shadoworigin, p, relativepoint);
6700 dist2 = VectorLength2(relativepoint);
6701 if (dist2 >= lightradius2)
6703 dist = sqrt(dist2) / light->radius;
6704 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6707 // todo: add to both ambient and diffuse
6708 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6709 VectorMA(color, f, light->color, color);
6714 void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags)
6716 int i, numlights, flag;
6719 float relativepoint[3];
6728 if (r_fullbright.integer)
6730 VectorSet(ambient, 1, 1, 1);
6731 VectorClear(diffuse);
6732 VectorClear(lightdir);
6736 if (flags == LP_LIGHTMAP)
6738 VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6739 VectorClear(diffuse);
6740 VectorClear(lightdir);
6741 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6742 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambient, diffuse, lightdir);
6744 VectorSet(ambient, 1, 1, 1);
6748 memset(sample, 0, sizeof(sample));
6749 VectorSet(sample, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6751 if ((flags & LP_LIGHTMAP) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6754 VectorClear(tempambient);
6756 VectorClear(relativepoint);
6757 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
6758 VectorScale(tempambient, r_refdef.lightmapintensity, tempambient);
6759 VectorScale(color, r_refdef.lightmapintensity, color);
6760 VectorAdd(sample, tempambient, sample);
6761 VectorMA(sample , 0.5f , color, sample );
6762 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6763 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6764 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6765 // calculate a weighted average light direction as well
6766 intensity = VectorLength(color);
6767 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6770 if (flags & LP_RTWORLD)
6772 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6773 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6774 for (i = 0; i < numlights; i++)
6776 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6779 light = &dlight->rtlight;
6780 if (!(light->flags & flag))
6783 lightradius2 = light->radius * light->radius;
6784 VectorSubtract(light->shadoworigin, p, relativepoint);
6785 dist2 = VectorLength2(relativepoint);
6786 if (dist2 >= lightradius2)
6788 dist = sqrt(dist2) / light->radius;
6789 intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value;
6790 if (intensity <= 0.0f)
6792 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6794 // scale down intensity to add to both ambient and diffuse
6795 //intensity *= 0.5f;
6796 VectorNormalize(relativepoint);
6797 VectorScale(light->currentcolor, intensity, color);
6798 VectorMA(sample , 0.5f , color, sample );
6799 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6800 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6801 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6802 // calculate a weighted average light direction as well
6803 intensity *= VectorLength(color);
6804 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6806 // FIXME: sample bouncegrid too!
6809 if (flags & LP_DYNLIGHT)
6812 for (i = 0;i < r_refdef.scene.numlights;i++)
6814 light = r_refdef.scene.lights[i];
6816 lightradius2 = light->radius * light->radius;
6817 VectorSubtract(light->shadoworigin, p, relativepoint);
6818 dist2 = VectorLength2(relativepoint);
6819 if (dist2 >= lightradius2)
6821 dist = sqrt(dist2) / light->radius;
6822 intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value;
6823 if (intensity <= 0.0f)
6825 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6827 // scale down intensity to add to both ambient and diffuse
6828 //intensity *= 0.5f;
6829 VectorNormalize(relativepoint);
6830 VectorScale(light->currentcolor, intensity, color);
6831 VectorMA(sample , 0.5f , color, sample );
6832 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6833 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6834 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6835 // calculate a weighted average light direction as well
6836 intensity *= VectorLength(color);
6837 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6841 // calculate the direction we'll use to reduce the sample to a directional light source
6842 VectorCopy(sample + 12, dir);
6843 //VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
6844 VectorNormalize(dir);
6845 // extract the diffuse color along the chosen direction and scale it
6846 diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]);
6847 diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]);
6848 diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]);
6849 // subtract some of diffuse from ambient
6850 VectorMA(sample, -0.333f, diffuse, ambient);
6851 // store the normalized lightdir
6852 VectorCopy(dir, lightdir);