3 Terminology: Stencil Shadow Volume (sometimes called Stencil Shadows)
4 An extrusion of the lit faces, beginning at the original geometry and ending
5 further from the light source than the original geometry (presumably at least
6 as far as the light's radius, if the light has a radius at all), capped at
7 both front and back to avoid any problems (extrusion from dark faces also
8 works but has a different set of problems)
10 This is normally rendered using Carmack's Reverse technique, in which
11 backfaces behind zbuffer (zfail) increment the stencil, and frontfaces behind
12 zbuffer (zfail) decrement the stencil, the result is a stencil value of zero
13 where shadows did not intersect the visible geometry, suitable as a stencil
14 mask for rendering lighting everywhere but shadow.
16 In our case to hopefully avoid the Creative Labs patent, we draw the backfaces
17 as decrement and the frontfaces as increment, and we redefine the DepthFunc to
18 GL_LESS (the patent uses GL_GEQUAL) which causes zfail when behind surfaces
19 and zpass when infront (the patent draws where zpass with a GL_GEQUAL test),
20 additionally we clear stencil to 128 to avoid the need for the unclamped
21 incr/decr extension (not related to patent).
24 This algorithm may be covered by Creative's patent (US Patent #6384822),
25 however that patent is quite specific about increment on backfaces and
26 decrement on frontfaces where zpass with GL_GEQUAL depth test, which is
27 opposite this implementation and partially opposite Carmack's Reverse paper
28 (which uses GL_LESS, but increments on backfaces and decrements on frontfaces).
32 Terminology: Stencil Light Volume (sometimes called Light Volumes)
33 Similar to a Stencil Shadow Volume, but inverted; rather than containing the
34 areas in shadow it contains the areas in light, this can only be built
35 quickly for certain limited cases (such as portal visibility from a point),
36 but is quite useful for some effects (sunlight coming from sky polygons is
37 one possible example, translucent occluders is another example).
41 Terminology: Optimized Stencil Shadow Volume
42 A Stencil Shadow Volume that has been processed sufficiently to ensure it has
43 no duplicate coverage of areas (no need to shadow an area twice), often this
44 greatly improves performance but is an operation too costly to use on moving
45 lights (however completely optimal Stencil Light Volumes can be constructed
50 Terminology: Per Pixel Lighting (sometimes abbreviated PPL)
51 Per pixel evaluation of lighting equations, at a bare minimum this involves
52 DOT3 shading of diffuse lighting (per pixel dotproduct of negated incidence
53 vector and surface normal, using a texture of the surface bumps, called a
54 NormalMap) if supported by hardware; in our case there is support for cards
55 which are incapable of DOT3, the quality is quite poor however. Additionally
56 it is desirable to have specular evaluation per pixel, per vertex
57 normalization of specular halfangle vectors causes noticable distortion but
58 is unavoidable on hardware without GL_ARB_fragment_program or
59 GL_ARB_fragment_shader.
63 Terminology: Normalization CubeMap
64 A cubemap containing normalized dot3-encoded (vectors of length 1 or less
65 encoded as RGB colors) for any possible direction, this technique allows per
66 pixel calculation of incidence vector for per pixel lighting purposes, which
67 would not otherwise be possible per pixel without GL_ARB_fragment_program or
68 GL_ARB_fragment_shader.
72 Terminology: 2D+1D Attenuation Texturing
73 A very crude approximation of light attenuation with distance which results
74 in cylindrical light shapes which fade vertically as a streak (some games
75 such as Doom3 allow this to be rotated to be less noticable in specific
76 cases), the technique is simply modulating lighting by two 2D textures (which
77 can be the same) on different axes of projection (XY and Z, typically), this
78 is the second best technique available without 3D Attenuation Texturing,
79 GL_ARB_fragment_program or GL_ARB_fragment_shader technology.
83 Terminology: 2D+1D Inverse Attenuation Texturing
84 A clever method described in papers on the Abducted engine, this has a squared
85 distance texture (bright on the outside, black in the middle), which is used
86 twice using GL_ADD blending, the result of this is used in an inverse modulate
87 (GL_ONE_MINUS_DST_ALPHA, GL_ZERO) to implement the equation
88 lighting*=(1-((X*X+Y*Y)+(Z*Z))) which is spherical (unlike 2D+1D attenuation
93 Terminology: 3D Attenuation Texturing
94 A slightly crude approximation of light attenuation with distance, its flaws
95 are limited radius and resolution (performance tradeoffs).
99 Terminology: 3D Attenuation-Normalization Texturing
100 A 3D Attenuation Texture merged with a Normalization CubeMap, by making the
101 vectors shorter the lighting becomes darker, a very effective optimization of
102 diffuse lighting if 3D Attenuation Textures are already used.
106 Terminology: Light Cubemap Filtering
107 A technique for modeling non-uniform light distribution according to
108 direction, for example a lantern may use a cubemap to describe the light
109 emission pattern of the cage around the lantern (as well as soot buildup
110 discoloring the light in certain areas), often also used for softened grate
111 shadows and light shining through a stained glass window (done crudely by
112 texturing the lighting with a cubemap), another good example would be a disco
113 light. This technique is used heavily in many games (Doom3 does not support
118 Terminology: Light Projection Filtering
119 A technique for modeling shadowing of light passing through translucent
120 surfaces, allowing stained glass windows and other effects to be done more
121 elegantly than possible with Light Cubemap Filtering by applying an occluder
122 texture to the lighting combined with a stencil light volume to limit the lit
123 area, this technique is used by Doom3 for spotlights and flashlights, among
124 other things, this can also be used more generally to render light passing
125 through multiple translucent occluders in a scene (using a light volume to
126 describe the area beyond the occluder, and thus mask off rendering of all
131 Terminology: Doom3 Lighting
132 A combination of Stencil Shadow Volume, Per Pixel Lighting, Normalization
133 CubeMap, 2D+1D Attenuation Texturing, and Light Projection Filtering, as
134 demonstrated by the game Doom3.
137 #include "quakedef.h"
138 #include "r_shadow.h"
139 #include "cl_collision.h"
142 #include "dpsoftrast.h"
146 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
149 extern void R_Shadow_EditLights_Init(void);
151 typedef enum r_shadow_rendermode_e
153 R_SHADOW_RENDERMODE_NONE,
154 R_SHADOW_RENDERMODE_ZPASS_STENCIL,
155 R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL,
156 R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE,
157 R_SHADOW_RENDERMODE_ZFAIL_STENCIL,
158 R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL,
159 R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE,
160 R_SHADOW_RENDERMODE_LIGHT_VERTEX,
161 R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN,
162 R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN,
163 R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN,
164 R_SHADOW_RENDERMODE_LIGHT_GLSL,
165 R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
166 R_SHADOW_RENDERMODE_VISIBLELIGHTING,
167 R_SHADOW_RENDERMODE_SHADOWMAP2D
169 r_shadow_rendermode_t;
171 typedef enum r_shadow_shadowmode_e
173 R_SHADOW_SHADOWMODE_STENCIL,
174 R_SHADOW_SHADOWMODE_SHADOWMAP2D
176 r_shadow_shadowmode_t;
178 r_shadow_rendermode_t r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
179 r_shadow_rendermode_t r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_NONE;
180 r_shadow_rendermode_t r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_NONE;
181 r_shadow_rendermode_t r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_NONE;
182 qboolean r_shadow_usingshadowmap2d;
183 qboolean r_shadow_usingshadowmaportho;
184 int r_shadow_shadowmapside;
185 float r_shadow_shadowmap_texturescale[2];
186 float r_shadow_shadowmap_parameters[4];
188 int r_shadow_drawbuffer;
189 int r_shadow_readbuffer;
191 int r_shadow_cullface_front, r_shadow_cullface_back;
192 GLuint r_shadow_fbo2d;
193 r_shadow_shadowmode_t r_shadow_shadowmode;
194 int r_shadow_shadowmapfilterquality;
195 int r_shadow_shadowmapdepthbits;
196 int r_shadow_shadowmapmaxsize;
197 qboolean r_shadow_shadowmapvsdct;
198 qboolean r_shadow_shadowmapsampler;
199 int r_shadow_shadowmappcf;
200 int r_shadow_shadowmapborder;
201 matrix4x4_t r_shadow_shadowmapmatrix;
202 int r_shadow_lightscissor[4];
203 qboolean r_shadow_usingdeferredprepass;
205 int maxshadowtriangles;
208 int maxshadowvertices;
209 float *shadowvertex3f;
219 unsigned char *shadowsides;
220 int *shadowsideslist;
227 int r_shadow_buffer_numleafpvsbytes;
228 unsigned char *r_shadow_buffer_visitingleafpvs;
229 unsigned char *r_shadow_buffer_leafpvs;
230 int *r_shadow_buffer_leaflist;
232 int r_shadow_buffer_numsurfacepvsbytes;
233 unsigned char *r_shadow_buffer_surfacepvs;
234 int *r_shadow_buffer_surfacelist;
235 unsigned char *r_shadow_buffer_surfacesides;
237 int r_shadow_buffer_numshadowtrispvsbytes;
238 unsigned char *r_shadow_buffer_shadowtrispvs;
239 int r_shadow_buffer_numlighttrispvsbytes;
240 unsigned char *r_shadow_buffer_lighttrispvs;
242 rtexturepool_t *r_shadow_texturepool;
243 rtexture_t *r_shadow_attenuationgradienttexture;
244 rtexture_t *r_shadow_attenuation2dtexture;
245 rtexture_t *r_shadow_attenuation3dtexture;
246 skinframe_t *r_shadow_lightcorona;
247 rtexture_t *r_shadow_shadowmap2dtexture;
248 rtexture_t *r_shadow_shadowmap2dcolortexture;
249 rtexture_t *r_shadow_shadowmapvsdcttexture;
250 int r_shadow_shadowmapsize; // changes for each light based on distance
251 int r_shadow_shadowmaplod; // changes for each light based on distance
253 GLuint r_shadow_prepassgeometryfbo;
254 GLuint r_shadow_prepasslightingdiffusespecularfbo;
255 GLuint r_shadow_prepasslightingdiffusefbo;
256 int r_shadow_prepass_width;
257 int r_shadow_prepass_height;
258 rtexture_t *r_shadow_prepassgeometrydepthtexture;
259 rtexture_t *r_shadow_prepassgeometrydepthcolortexture;
260 rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
261 rtexture_t *r_shadow_prepasslightingdiffusetexture;
262 rtexture_t *r_shadow_prepasslightingspeculartexture;
264 // lights are reloaded when this changes
265 char r_shadow_mapname[MAX_QPATH];
267 // used only for light filters (cubemaps)
268 rtexturepool_t *r_shadow_filters_texturepool;
270 static const GLenum r_shadow_prepasslightingdrawbuffers[2] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
272 cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"};
273 cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
274 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
275 cvar_t r_shadow_deferred = {CVAR_SAVE, "r_shadow_deferred", "0", "uses image-based lighting instead of geometry-based lighting, the method used renders a depth image and a normalmap image, renders lights into separate diffuse and specular images, and then combines this into the normal rendering, requires r_shadow_shadowmapping"};
276 cvar_t r_shadow_deferred_8bitrange = {CVAR_SAVE, "r_shadow_deferred_8bitrange", "4", "dynamic range of image-based lighting when using 32bit color (does not apply to fp)"};
277 //cvar_t r_shadow_deferred_fp = {CVAR_SAVE, "r_shadow_deferred_fp", "0", "use 16bit (1) or 32bit (2) floating point for accumulation of image-based lighting"};
278 cvar_t r_shadow_usebihculling = {0, "r_shadow_usebihculling", "1", "use BIH (Bounding Interval Hierarchy) for culling lit surfaces instead of BSP (Binary Space Partitioning)"};
279 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
280 cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"};
281 cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};
282 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
283 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
284 cvar_t r_shadow_gloss2exponent = {0, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
285 cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
286 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
287 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
288 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
289 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
290 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "0", "how far to cast shadows"};
291 cvar_t r_shadow_frontsidecasting = {0, "r_shadow_frontsidecasting", "1", "whether to cast shadows from illuminated triangles (front side of model) or unlit triangles (back side of model)"};
292 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
293 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
294 cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
295 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
296 cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0", "enables rendering of full world lighting (whether loaded from the map, or a .rtlights file, or a .ent file, or a .lights file produced by hlight)"};
297 cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0", "brightness to render lightmaps when using full world lighting, try 0.5 for a tenebrae-like appearance"};
298 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
299 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
300 cvar_t r_shadow_realtime_world_compileshadow = {0, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"};
301 cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation (slower than compileportalculling but more exact)"};
302 cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation (overrides compilesvbsp)"};
303 cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"};
304 cvar_t r_shadow_shadowmapping = {CVAR_SAVE, "r_shadow_shadowmapping", "1", "enables use of shadowmapping (depth texture sampling) instead of stencil shadow volumes, requires gl_fbo 1"};
305 cvar_t r_shadow_shadowmapping_filterquality = {CVAR_SAVE, "r_shadow_shadowmapping_filterquality", "-1", "shadowmap filter modes: -1 = auto-select, 0 = no filtering, 1 = bilinear, 2 = bilinear 2x2 blur (fast), 3 = 3x3 blur (moderate), 4 = 4x4 blur (slow)"};
306 cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
307 cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
308 cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "shadowmap size limit"};
309 cvar_t r_shadow_shadowmapping_maxsize = {CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "shadowmap size limit"};
310 cvar_t r_shadow_shadowmapping_precision = {CVAR_SAVE, "r_shadow_shadowmapping_precision", "1", "makes shadowmaps have a maximum resolution of this number of pixels per light source radius unit such that, for example, at precision 0.5 a light with radius 200 will have a maximum resolution of 100 pixels"};
311 //cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
312 //cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
313 cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
314 cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
315 cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
316 cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
317 cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
318 cvar_t r_shadow_sortsurfaces = {0, "r_shadow_sortsurfaces", "1", "improve performance by sorting illuminated surfaces by texture"};
319 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
320 cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"};
321 cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect OpenGL 2.0 render path)"};
322 cvar_t r_shadow_bouncegrid = {CVAR_SAVE, "r_shadow_bouncegrid", "0", "perform particle tracing for indirect lighting (Global Illumination / radiosity) using a 3D texture covering the scene, only active on levels with realtime lights active (r_shadow_realtime_world is usually required for these)"};
323 cvar_t r_shadow_bouncegrid_airstepmax = {CVAR_SAVE, "r_shadow_bouncegrid_airstepmax", "1024", "maximum number of photon accumulation contributions for one photon"};
324 cvar_t r_shadow_bouncegrid_airstepsize = {CVAR_SAVE, "r_shadow_bouncegrid_airstepsize", "64", "maximum spacing of photon accumulation through the air"};
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", "10", "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", "5", "maximum number of bounces for a particle (minimum is 1)"};
333 cvar_t r_shadow_bouncegrid_particlebounceintensity = {CVAR_SAVE, "r_shadow_bouncegrid_particlebounceintensity", "4", "amount of energy carried over after each bounce, this is a multiplier of texture color and the result is clamped to 1 or less, to prevent adding energy on each bounce"};
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_spacingx = {CVAR_SAVE, "r_shadow_bouncegrid_spacingx", "64", "unit size of bouncegrid pixel on X axis"};
337 cvar_t r_shadow_bouncegrid_spacingy = {CVAR_SAVE, "r_shadow_bouncegrid_spacingy", "64", "unit size of bouncegrid pixel on Y axis"};
338 cvar_t r_shadow_bouncegrid_spacingz = {CVAR_SAVE, "r_shadow_bouncegrid_spacingz", "64", "unit size of bouncegrid pixel on Z axis"};
339 cvar_t r_shadow_bouncegrid_stablerandom = {CVAR_SAVE, "r_shadow_bouncegrid_stablerandom", "1", "make particle distribution consistent from frame to frame"};
340 cvar_t r_shadow_bouncegrid_static = {CVAR_SAVE, "r_shadow_bouncegrid_static", "1", "use static radiosity solution (high quality) rather than dynamic (splotchy)"};
341 cvar_t r_shadow_bouncegrid_static_directionalshading = {CVAR_SAVE, "r_shadow_bouncegrid_static_directionalshading", "1", "whether to use directionalshading when 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;
378 r_shadow_bouncegrid_settings_t;
380 r_shadow_bouncegrid_settings_t r_shadow_bouncegridsettings;
381 rtexture_t *r_shadow_bouncegridtexture;
382 matrix4x4_t r_shadow_bouncegridmatrix;
383 vec_t r_shadow_bouncegridintensity;
384 qboolean r_shadow_bouncegriddirectional;
385 static double r_shadow_bouncegridtime;
386 static int r_shadow_bouncegridresolution[3];
387 static int r_shadow_bouncegridnumpixels;
388 static unsigned char *r_shadow_bouncegridpixels;
389 static float *r_shadow_bouncegridhighpixels;
391 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
392 #define ATTENTABLESIZE 256
393 // 1D gradient, 2D circle and 3D sphere attenuation textures
394 #define ATTEN1DSIZE 32
395 #define ATTEN2DSIZE 64
396 #define ATTEN3DSIZE 32
398 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
399 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
400 static float r_shadow_attentable[ATTENTABLESIZE+1];
402 rtlight_t *r_shadow_compilingrtlight;
403 static memexpandablearray_t r_shadow_worldlightsarray;
404 dlight_t *r_shadow_selectedlight;
405 dlight_t r_shadow_bufferlight;
406 vec3_t r_editlights_cursorlocation;
407 qboolean r_editlights_lockcursor;
409 extern int con_vislines;
411 void R_Shadow_UncompileWorldLights(void);
412 void R_Shadow_ClearWorldLights(void);
413 void R_Shadow_SaveWorldLights(void);
414 void R_Shadow_LoadWorldLights(void);
415 void R_Shadow_LoadLightsFile(void);
416 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
417 void R_Shadow_EditLights_Reload_f(void);
418 void R_Shadow_ValidateCvars(void);
419 static void R_Shadow_MakeTextures(void);
421 #define EDLIGHTSPRSIZE 8
422 skinframe_t *r_editlights_sprcursor;
423 skinframe_t *r_editlights_sprlight;
424 skinframe_t *r_editlights_sprnoshadowlight;
425 skinframe_t *r_editlights_sprcubemaplight;
426 skinframe_t *r_editlights_sprcubemapnoshadowlight;
427 skinframe_t *r_editlights_sprselection;
429 void R_Shadow_SetShadowMode(void)
431 r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
432 r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20;
433 r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
434 r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
435 r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
436 r_shadow_shadowmaplod = -1;
437 r_shadow_shadowmapsize = 0;
438 r_shadow_shadowmapsampler = false;
439 r_shadow_shadowmappcf = 0;
440 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
441 if ((r_shadow_shadowmapping.integer || r_shadow_deferred.integer) && vid.support.ext_framebuffer_object)
443 switch(vid.renderpath)
445 case RENDERPATH_GL20:
446 if(r_shadow_shadowmapfilterquality < 0)
448 if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
449 r_shadow_shadowmappcf = 1;
450 else if(strstr(gl_vendor, "NVIDIA") || strstr(gl_renderer, "Radeon HD"))
452 r_shadow_shadowmapsampler = vid.support.arb_shadow;
453 r_shadow_shadowmappcf = 1;
455 else if(strstr(gl_vendor, "ATI"))
456 r_shadow_shadowmappcf = 1;
458 r_shadow_shadowmapsampler = vid.support.arb_shadow;
462 switch (r_shadow_shadowmapfilterquality)
465 r_shadow_shadowmapsampler = vid.support.arb_shadow;
468 r_shadow_shadowmapsampler = vid.support.arb_shadow;
469 r_shadow_shadowmappcf = 1;
472 r_shadow_shadowmappcf = 1;
475 r_shadow_shadowmappcf = 2;
479 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
481 case RENDERPATH_D3D9:
482 case RENDERPATH_D3D10:
483 case RENDERPATH_D3D11:
484 case RENDERPATH_SOFT:
485 r_shadow_shadowmapsampler = false;
486 r_shadow_shadowmappcf = 1;
487 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
489 case RENDERPATH_GL11:
490 case RENDERPATH_GL13:
491 case RENDERPATH_GLES1:
492 case RENDERPATH_GLES2:
498 qboolean R_Shadow_ShadowMappingEnabled(void)
500 switch (r_shadow_shadowmode)
502 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
509 void R_Shadow_FreeShadowMaps(void)
511 R_Shadow_SetShadowMode();
513 R_Mesh_DestroyFramebufferObject(r_shadow_fbo2d);
517 if (r_shadow_shadowmap2dtexture)
518 R_FreeTexture(r_shadow_shadowmap2dtexture);
519 r_shadow_shadowmap2dtexture = NULL;
521 if (r_shadow_shadowmap2dcolortexture)
522 R_FreeTexture(r_shadow_shadowmap2dcolortexture);
523 r_shadow_shadowmap2dcolortexture = NULL;
525 if (r_shadow_shadowmapvsdcttexture)
526 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
527 r_shadow_shadowmapvsdcttexture = NULL;
530 void r_shadow_start(void)
532 // allocate vertex processing arrays
533 r_shadow_bouncegridpixels = NULL;
534 r_shadow_bouncegridhighpixels = NULL;
535 r_shadow_bouncegridnumpixels = 0;
536 r_shadow_bouncegridtexture = NULL;
537 r_shadow_bouncegriddirectional = false;
538 r_shadow_attenuationgradienttexture = NULL;
539 r_shadow_attenuation2dtexture = NULL;
540 r_shadow_attenuation3dtexture = NULL;
541 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
542 r_shadow_shadowmap2dtexture = NULL;
543 r_shadow_shadowmap2dcolortexture = NULL;
544 r_shadow_shadowmapvsdcttexture = NULL;
545 r_shadow_shadowmapmaxsize = 0;
546 r_shadow_shadowmapsize = 0;
547 r_shadow_shadowmaplod = 0;
548 r_shadow_shadowmapfilterquality = -1;
549 r_shadow_shadowmapdepthbits = 0;
550 r_shadow_shadowmapvsdct = false;
551 r_shadow_shadowmapsampler = false;
552 r_shadow_shadowmappcf = 0;
555 R_Shadow_FreeShadowMaps();
557 r_shadow_texturepool = NULL;
558 r_shadow_filters_texturepool = NULL;
559 R_Shadow_ValidateCvars();
560 R_Shadow_MakeTextures();
561 maxshadowtriangles = 0;
562 shadowelements = NULL;
563 maxshadowvertices = 0;
564 shadowvertex3f = NULL;
572 shadowmarklist = NULL;
577 shadowsideslist = NULL;
578 r_shadow_buffer_numleafpvsbytes = 0;
579 r_shadow_buffer_visitingleafpvs = NULL;
580 r_shadow_buffer_leafpvs = NULL;
581 r_shadow_buffer_leaflist = NULL;
582 r_shadow_buffer_numsurfacepvsbytes = 0;
583 r_shadow_buffer_surfacepvs = NULL;
584 r_shadow_buffer_surfacelist = NULL;
585 r_shadow_buffer_surfacesides = NULL;
586 r_shadow_buffer_numshadowtrispvsbytes = 0;
587 r_shadow_buffer_shadowtrispvs = NULL;
588 r_shadow_buffer_numlighttrispvsbytes = 0;
589 r_shadow_buffer_lighttrispvs = NULL;
591 r_shadow_usingdeferredprepass = false;
592 r_shadow_prepass_width = r_shadow_prepass_height = 0;
595 static void R_Shadow_FreeDeferred(void);
596 void r_shadow_shutdown(void)
599 R_Shadow_UncompileWorldLights();
601 R_Shadow_FreeShadowMaps();
603 r_shadow_usingdeferredprepass = false;
604 if (r_shadow_prepass_width)
605 R_Shadow_FreeDeferred();
606 r_shadow_prepass_width = r_shadow_prepass_height = 0;
609 r_shadow_bouncegridtexture = NULL;
610 r_shadow_bouncegridpixels = NULL;
611 r_shadow_bouncegridhighpixels = NULL;
612 r_shadow_bouncegridnumpixels = 0;
613 r_shadow_bouncegriddirectional = false;
614 r_shadow_attenuationgradienttexture = NULL;
615 r_shadow_attenuation2dtexture = NULL;
616 r_shadow_attenuation3dtexture = NULL;
617 R_FreeTexturePool(&r_shadow_texturepool);
618 R_FreeTexturePool(&r_shadow_filters_texturepool);
619 maxshadowtriangles = 0;
621 Mem_Free(shadowelements);
622 shadowelements = NULL;
624 Mem_Free(shadowvertex3f);
625 shadowvertex3f = NULL;
628 Mem_Free(vertexupdate);
631 Mem_Free(vertexremap);
637 Mem_Free(shadowmark);
640 Mem_Free(shadowmarklist);
641 shadowmarklist = NULL;
646 Mem_Free(shadowsides);
649 Mem_Free(shadowsideslist);
650 shadowsideslist = NULL;
651 r_shadow_buffer_numleafpvsbytes = 0;
652 if (r_shadow_buffer_visitingleafpvs)
653 Mem_Free(r_shadow_buffer_visitingleafpvs);
654 r_shadow_buffer_visitingleafpvs = NULL;
655 if (r_shadow_buffer_leafpvs)
656 Mem_Free(r_shadow_buffer_leafpvs);
657 r_shadow_buffer_leafpvs = NULL;
658 if (r_shadow_buffer_leaflist)
659 Mem_Free(r_shadow_buffer_leaflist);
660 r_shadow_buffer_leaflist = NULL;
661 r_shadow_buffer_numsurfacepvsbytes = 0;
662 if (r_shadow_buffer_surfacepvs)
663 Mem_Free(r_shadow_buffer_surfacepvs);
664 r_shadow_buffer_surfacepvs = NULL;
665 if (r_shadow_buffer_surfacelist)
666 Mem_Free(r_shadow_buffer_surfacelist);
667 r_shadow_buffer_surfacelist = NULL;
668 if (r_shadow_buffer_surfacesides)
669 Mem_Free(r_shadow_buffer_surfacesides);
670 r_shadow_buffer_surfacesides = NULL;
671 r_shadow_buffer_numshadowtrispvsbytes = 0;
672 if (r_shadow_buffer_shadowtrispvs)
673 Mem_Free(r_shadow_buffer_shadowtrispvs);
674 r_shadow_buffer_numlighttrispvsbytes = 0;
675 if (r_shadow_buffer_lighttrispvs)
676 Mem_Free(r_shadow_buffer_lighttrispvs);
679 void r_shadow_newmap(void)
681 if (r_shadow_bouncegridtexture) R_FreeTexture(r_shadow_bouncegridtexture);r_shadow_bouncegridtexture = NULL;
682 if (r_shadow_lightcorona) R_SkinFrame_MarkUsed(r_shadow_lightcorona);
683 if (r_editlights_sprcursor) R_SkinFrame_MarkUsed(r_editlights_sprcursor);
684 if (r_editlights_sprlight) R_SkinFrame_MarkUsed(r_editlights_sprlight);
685 if (r_editlights_sprnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
686 if (r_editlights_sprcubemaplight) R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
687 if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
688 if (r_editlights_sprselection) R_SkinFrame_MarkUsed(r_editlights_sprselection);
689 if (strncmp(cl.worldname, r_shadow_mapname, sizeof(r_shadow_mapname)))
690 R_Shadow_EditLights_Reload_f();
693 void R_Shadow_Init(void)
695 Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
696 Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
697 Cvar_RegisterVariable(&r_shadow_usebihculling);
698 Cvar_RegisterVariable(&r_shadow_usenormalmap);
699 Cvar_RegisterVariable(&r_shadow_debuglight);
700 Cvar_RegisterVariable(&r_shadow_deferred);
701 Cvar_RegisterVariable(&r_shadow_deferred_8bitrange);
702 // Cvar_RegisterVariable(&r_shadow_deferred_fp);
703 Cvar_RegisterVariable(&r_shadow_gloss);
704 Cvar_RegisterVariable(&r_shadow_gloss2intensity);
705 Cvar_RegisterVariable(&r_shadow_glossintensity);
706 Cvar_RegisterVariable(&r_shadow_glossexponent);
707 Cvar_RegisterVariable(&r_shadow_gloss2exponent);
708 Cvar_RegisterVariable(&r_shadow_glossexact);
709 Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
710 Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
711 Cvar_RegisterVariable(&r_shadow_lightintensityscale);
712 Cvar_RegisterVariable(&r_shadow_lightradiusscale);
713 Cvar_RegisterVariable(&r_shadow_projectdistance);
714 Cvar_RegisterVariable(&r_shadow_frontsidecasting);
715 Cvar_RegisterVariable(&r_shadow_realtime_dlight);
716 Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
717 Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
718 Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
719 Cvar_RegisterVariable(&r_shadow_realtime_world);
720 Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
721 Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
722 Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
723 Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
724 Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
725 Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
726 Cvar_RegisterVariable(&r_shadow_scissor);
727 Cvar_RegisterVariable(&r_shadow_shadowmapping);
728 Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
729 Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
730 Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
731 Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
732 Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
733 Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
734 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
735 // Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
736 Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
737 Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
738 Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
739 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
740 Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
741 Cvar_RegisterVariable(&r_shadow_sortsurfaces);
742 Cvar_RegisterVariable(&r_shadow_polygonfactor);
743 Cvar_RegisterVariable(&r_shadow_polygonoffset);
744 Cvar_RegisterVariable(&r_shadow_texture3d);
745 Cvar_RegisterVariable(&r_shadow_bouncegrid);
746 Cvar_RegisterVariable(&r_shadow_bouncegrid_airstepmax);
747 Cvar_RegisterVariable(&r_shadow_bouncegrid_airstepsize);
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_spacingx);
760 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingy);
761 Cvar_RegisterVariable(&r_shadow_bouncegrid_spacingz);
762 Cvar_RegisterVariable(&r_shadow_bouncegrid_stablerandom);
763 Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
764 Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
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 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 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 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 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_SetMainRenderTargets();
2023 R_SetViewport(&r_refdef.view.viewport);
2024 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
2025 R_Mesh_ResetTextureState();
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(NULL, NULL, GL_MODULATE, 1, 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);
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_shadowmap2dtexture) return;
2102 r_shadow_shadowmap2dtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2103 r_shadow_shadowmap2dcolortexture = NULL;
2104 switch(vid.renderpath)
2107 case RENDERPATH_D3D9:
2108 r_shadow_shadowmap2dcolortexture = R_LoadTexture2D(r_shadow_texturepool, "shadowmaprendertarget", size*2, size*(vid.support.arb_texture_non_power_of_two ? 3 : 4), NULL, TEXTYPE_BGRA, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, -1, NULL);
2109 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
2113 r_shadow_fbo2d = R_Mesh_CreateFramebufferObject(r_shadow_shadowmap2dtexture, NULL, NULL, NULL, NULL);
2121 // render depth into the fbo, do not render color at all
2122 // validate the fbo now
2126 qglDrawBuffer(GL_NONE);CHECKGLERROR
2127 qglReadBuffer(GL_NONE);CHECKGLERROR
2128 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2129 if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2131 Con_Printf("R_Shadow_MakeShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2132 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2133 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2138 void R_Shadow_RenderMode_ShadowMap(int side, int clear, int size)
2140 float nearclip, farclip, bias;
2141 r_viewport_t viewport;
2144 float clearcolor[4];
2145 nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
2147 bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
2148 r_shadow_shadowmap_parameters[1] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
2149 r_shadow_shadowmap_parameters[3] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
2150 r_shadow_shadowmapside = side;
2151 r_shadow_shadowmapsize = size;
2153 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2154 r_shadow_shadowmap_parameters[2] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2155 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2156 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
2158 // complex unrolled cube approach (more flexible)
2159 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2160 R_Shadow_MakeVSDCT();
2161 if (!r_shadow_shadowmap2dtexture)
2162 R_Shadow_MakeShadowMap(side, r_shadow_shadowmapmaxsize);
2163 if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d;
2164 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
2165 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
2166 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2168 R_Mesh_ResetTextureState();
2169 R_Shadow_RenderMode_Reset();
2170 R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
2171 R_SetupShader_DepthOrShadow(true);
2172 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2177 R_SetViewport(&viewport);
2178 flipped = (side & 1) ^ (side >> 2);
2179 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2180 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2181 switch(vid.renderpath)
2183 case RENDERPATH_GL11:
2184 case RENDERPATH_GL13:
2185 case RENDERPATH_GL20:
2186 case RENDERPATH_SOFT:
2187 case RENDERPATH_GLES1:
2188 case RENDERPATH_GLES2:
2189 GL_CullFace(r_refdef.view.cullface_back);
2190 // OpenGL lets us scissor larger than the viewport, so go ahead and clear all views at once
2191 if ((clear & ((2 << side) - 1)) == (1 << side)) // only clear if the side is the first in the mask
2193 // get tightest scissor rectangle that encloses all viewports in the clear mask
2194 int x1 = clear & 0x15 ? 0 : size;
2195 int x2 = clear & 0x2A ? 2 * size : size;
2196 int y1 = clear & 0x03 ? 0 : (clear & 0xC ? size : 2 * size);
2197 int y2 = clear & 0x30 ? 3 * size : (clear & 0xC ? 2 * size : size);
2198 GL_Scissor(x1, y1, x2 - x1, y2 - y1);
2199 GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
2201 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2203 case RENDERPATH_D3D9:
2204 case RENDERPATH_D3D10:
2205 case RENDERPATH_D3D11:
2206 Vector4Set(clearcolor, 1,1,1,1);
2207 // completely different meaning than in OpenGL path
2208 r_shadow_shadowmap_parameters[1] = 0;
2209 r_shadow_shadowmap_parameters[3] = -bias;
2210 // we invert the cull mode because we flip the projection matrix
2211 // NOTE: this actually does nothing because the DrawShadowMap code sets it to doublesided...
2212 GL_CullFace(r_refdef.view.cullface_front);
2213 // D3D considers it an error to use a scissor larger than the viewport... clear just this view
2214 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2215 if (r_shadow_shadowmapsampler)
2217 GL_ColorMask(0,0,0,0);
2219 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
2223 GL_ColorMask(1,1,1,1);
2225 GL_Clear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
2231 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2233 R_Mesh_ResetTextureState();
2234 R_Mesh_SetMainRenderTargets();
2237 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2238 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2239 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2240 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2242 R_Shadow_RenderMode_Reset();
2243 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2245 GL_DepthFunc(GL_EQUAL);
2246 // do global setup needed for the chosen lighting mode
2247 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2248 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2249 r_shadow_usingshadowmap2d = shadowmapping;
2250 r_shadow_rendermode = r_shadow_lightingrendermode;
2251 // only draw light where this geometry was already rendered AND the
2252 // stencil is 128 (values other than this mean shadow)
2254 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2256 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
2259 static const unsigned short bboxelements[36] =
2269 static const float bboxpoints[8][3] =
2281 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2284 float vertex3f[8*3];
2285 const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2286 // do global setup needed for the chosen lighting mode
2287 R_Shadow_RenderMode_Reset();
2288 r_shadow_rendermode = r_shadow_lightingrendermode;
2289 R_EntityMatrix(&identitymatrix);
2290 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2291 // only draw light where this geometry was already rendered AND the
2292 // stencil is 128 (values other than this mean shadow)
2293 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2294 if (rsurface.rtlight->specularscale > 0 && r_shadow_gloss.integer > 0)
2295 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
2297 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
2299 r_shadow_usingshadowmap2d = shadowmapping;
2301 // render the lighting
2302 R_SetupShader_DeferredLight(rsurface.rtlight);
2303 for (i = 0;i < 8;i++)
2304 Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2305 GL_ColorMask(1,1,1,1);
2306 GL_DepthMask(false);
2307 GL_DepthRange(0, 1);
2308 GL_PolygonOffset(0, 0);
2310 GL_DepthFunc(GL_GREATER);
2311 GL_CullFace(r_refdef.view.cullface_back);
2312 R_Mesh_PrepareVertices_Vertex3f(8, vertex3f, NULL);
2313 R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
2316 static void R_Shadow_UpdateBounceGridTexture(void)
2318 #define MAXBOUNCEGRIDPARTICLESPERLIGHT 1048576
2320 int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
2322 int hitsupercontentsmask;
2331 //trace_t cliptrace2;
2332 //trace_t cliptrace3;
2333 unsigned char *pixel;
2334 unsigned char *pixels;
2337 unsigned int lightindex;
2339 unsigned int range1;
2340 unsigned int range2;
2341 unsigned int seed = (unsigned int)(realtime * 1000.0f);
2343 vec3_t baseshotcolor;
2358 vec_t lightintensity;
2359 vec_t photonscaling;
2360 vec_t photonresidual;
2362 float texlerp[2][3];
2363 float splatcolor[32];
2364 float pixelweight[8];
2376 r_shadow_bouncegrid_settings_t settings;
2377 qboolean enable = r_shadow_bouncegrid.integer != 0 && r_refdef.scene.worldmodel;
2378 qboolean allowdirectionalshading = false;
2379 switch(vid.renderpath)
2381 case RENDERPATH_GL20:
2382 allowdirectionalshading = true;
2383 if (!vid.support.ext_texture_3d)
2386 case RENDERPATH_GLES2:
2387 // for performance reasons, do not use directional shading on GLES devices
2388 if (!vid.support.ext_texture_3d)
2391 // these renderpaths do not currently have the code to display the bouncegrid, so disable it on them...
2392 case RENDERPATH_GL11:
2393 case RENDERPATH_GL13:
2394 case RENDERPATH_GLES1:
2395 case RENDERPATH_SOFT:
2396 case RENDERPATH_D3D9:
2397 case RENDERPATH_D3D10:
2398 case RENDERPATH_D3D11:
2402 r_shadow_bouncegridintensity = r_shadow_bouncegrid_intensity.value;
2404 // see if there are really any lights to render...
2405 if (enable && r_shadow_bouncegrid_static.integer)
2408 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2409 for (lightindex = 0;lightindex < range;lightindex++)
2411 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2412 if (!light || !(light->flags & flag))
2414 rtlight = &light->rtlight;
2415 // when static, we skip styled lights because they tend to change...
2416 if (rtlight->style > 0)
2418 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale), lightcolor);
2419 if (!VectorLength2(lightcolor))
2428 if (r_shadow_bouncegridtexture)
2430 R_FreeTexture(r_shadow_bouncegridtexture);
2431 r_shadow_bouncegridtexture = NULL;
2433 if (r_shadow_bouncegridpixels)
2434 Mem_Free(r_shadow_bouncegridpixels);
2435 r_shadow_bouncegridpixels = NULL;
2436 if (r_shadow_bouncegridhighpixels)
2437 Mem_Free(r_shadow_bouncegridhighpixels);
2438 r_shadow_bouncegridhighpixels = NULL;
2439 r_shadow_bouncegridnumpixels = 0;
2440 r_shadow_bouncegriddirectional = false;
2444 // build up a complete collection of the desired settings, so that memcmp can be used to compare parameters
2445 memset(&settings, 0, sizeof(settings));
2446 settings.staticmode = r_shadow_bouncegrid_static.integer != 0;
2447 settings.airstepmax = bound(1, r_shadow_bouncegrid_airstepmax.integer, 1048576);
2448 settings.airstepsize = bound(1.0f, r_shadow_bouncegrid_airstepsize.value, 1024.0f);
2449 settings.bounceanglediffuse = r_shadow_bouncegrid_bounceanglediffuse.integer != 0;
2450 settings.directionalshading = (r_shadow_bouncegrid_static.integer != 0 ? r_shadow_bouncegrid_static_directionalshading.integer != 0 : r_shadow_bouncegrid_directionalshading.integer != 0) && allowdirectionalshading;
2451 settings.dlightparticlemultiplier = r_shadow_bouncegrid_dlightparticlemultiplier.value;
2452 settings.hitmodels = r_shadow_bouncegrid_hitmodels.integer != 0;
2453 settings.includedirectlighting = r_shadow_bouncegrid_includedirectlighting.integer != 0;
2454 settings.lightradiusscale = r_shadow_bouncegrid_lightradiusscale.value;
2455 settings.maxbounce = r_shadow_bouncegrid_maxbounce.integer;
2456 settings.particlebounceintensity = r_shadow_bouncegrid_particlebounceintensity.value;
2457 settings.particleintensity = r_shadow_bouncegrid_particleintensity.value;
2458 settings.photons = r_shadow_bouncegrid_static.integer ? r_shadow_bouncegrid_static_photons.integer : r_shadow_bouncegrid_photons.integer;
2459 settings.spacing[0] = r_shadow_bouncegrid_spacingx.value;
2460 settings.spacing[1] = r_shadow_bouncegrid_spacingy.value;
2461 settings.spacing[2] = r_shadow_bouncegrid_spacingz.value;
2462 settings.stablerandom = r_shadow_bouncegrid_stablerandom.integer;
2464 // bound the values for sanity
2465 settings.photons = bound(1, settings.photons, 1048576);
2466 settings.lightradiusscale = bound(0.0001f, settings.lightradiusscale, 1024.0f);
2467 settings.maxbounce = bound(0, settings.maxbounce, 16);
2468 settings.spacing[0] = bound(1, settings.spacing[0], 512);
2469 settings.spacing[1] = bound(1, settings.spacing[1], 512);
2470 settings.spacing[2] = bound(1, settings.spacing[2], 512);
2472 // get the spacing values
2473 spacing[0] = settings.spacing[0];
2474 spacing[1] = settings.spacing[1];
2475 spacing[2] = settings.spacing[2];
2476 ispacing[0] = 1.0f / spacing[0];
2477 ispacing[1] = 1.0f / spacing[1];
2478 ispacing[2] = 1.0f / spacing[2];
2480 // calculate texture size enclosing entire world bounds at the spacing
2481 VectorMA(r_refdef.scene.worldmodel->normalmins, -2.0f, spacing, mins);
2482 VectorMA(r_refdef.scene.worldmodel->normalmaxs, 2.0f, spacing, maxs);
2483 VectorSubtract(maxs, mins, size);
2484 // now we can calculate the resolution we want
2485 c[0] = (int)floor(size[0] / spacing[0] + 0.5f);
2486 c[1] = (int)floor(size[1] / spacing[1] + 0.5f);
2487 c[2] = (int)floor(size[2] / spacing[2] + 0.5f);
2488 // figure out the exact texture size (honoring power of 2 if required)
2489 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2490 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2491 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2492 if (vid.support.arb_texture_non_power_of_two)
2494 resolution[0] = c[0];
2495 resolution[1] = c[1];
2496 resolution[2] = c[2];
2500 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2501 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2502 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2504 size[0] = spacing[0] * resolution[0];
2505 size[1] = spacing[1] * resolution[1];
2506 size[2] = spacing[2] * resolution[2];
2508 // if dynamic we may or may not want to use the world bounds
2509 // if the dynamic size is smaller than the world bounds, use it instead
2510 if (!settings.staticmode && (r_shadow_bouncegrid_x.integer * r_shadow_bouncegrid_y.integer * r_shadow_bouncegrid_z.integer < resolution[0] * resolution[1] * resolution[2]))
2512 // we know the resolution we want
2513 c[0] = r_shadow_bouncegrid_x.integer;
2514 c[1] = r_shadow_bouncegrid_y.integer;
2515 c[2] = r_shadow_bouncegrid_z.integer;
2516 // now we can calculate the texture size (power of 2 if required)
2517 c[0] = bound(4, c[0], (int)vid.maxtexturesize_3d);
2518 c[1] = bound(4, c[1], (int)vid.maxtexturesize_3d);
2519 c[2] = bound(4, c[2], (int)vid.maxtexturesize_3d);
2520 if (vid.support.arb_texture_non_power_of_two)
2522 resolution[0] = c[0];
2523 resolution[1] = c[1];
2524 resolution[2] = c[2];
2528 for (resolution[0] = 4;resolution[0] < c[0];resolution[0]*=2) ;
2529 for (resolution[1] = 4;resolution[1] < c[1];resolution[1]*=2) ;
2530 for (resolution[2] = 4;resolution[2] < c[2];resolution[2]*=2) ;
2532 size[0] = spacing[0] * resolution[0];
2533 size[1] = spacing[1] * resolution[1];
2534 size[2] = spacing[2] * resolution[2];
2535 // center the rendering on the view
2536 mins[0] = floor(r_refdef.view.origin[0] * ispacing[0] + 0.5f) * spacing[0] - 0.5f * size[0];
2537 mins[1] = floor(r_refdef.view.origin[1] * ispacing[1] + 0.5f) * spacing[1] - 0.5f * size[1];
2538 mins[2] = floor(r_refdef.view.origin[2] * ispacing[2] + 0.5f) * spacing[2] - 0.5f * size[2];
2541 // recalculate the maxs in case the resolution was not satisfactory
2542 VectorAdd(mins, size, maxs);
2544 // if all the settings seem identical to the previous update, return
2545 if (r_shadow_bouncegridtexture && (settings.staticmode || realtime < r_shadow_bouncegridtime + r_shadow_bouncegrid_updateinterval.value) && !memcmp(&r_shadow_bouncegridsettings, &settings, sizeof(settings)))
2548 // store the new settings
2549 r_shadow_bouncegridsettings = settings;
2551 pixelbands = settings.directionalshading ? 8 : 1;
2552 pixelsperband = resolution[0]*resolution[1]*resolution[2];
2553 numpixels = pixelsperband*pixelbands;
2555 // we're going to update the bouncegrid, update the matrix...
2556 memset(m, 0, sizeof(m));
2557 m[0] = 1.0f / size[0];
2558 m[3] = -mins[0] * m[0];
2559 m[5] = 1.0f / size[1];
2560 m[7] = -mins[1] * m[5];
2561 m[10] = 1.0f / size[2];
2562 m[11] = -mins[2] * m[10];
2564 Matrix4x4_FromArrayFloatD3D(&r_shadow_bouncegridmatrix, m);
2565 // reallocate pixels for this update if needed...
2566 if (r_shadow_bouncegridnumpixels != numpixels || !r_shadow_bouncegridpixels || !r_shadow_bouncegridhighpixels)
2568 if (r_shadow_bouncegridtexture)
2570 R_FreeTexture(r_shadow_bouncegridtexture);
2571 r_shadow_bouncegridtexture = NULL;
2573 r_shadow_bouncegridpixels = (unsigned char *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridpixels, numpixels * sizeof(unsigned char[4]));
2574 r_shadow_bouncegridhighpixels = (float *)Mem_Realloc(r_main_mempool, r_shadow_bouncegridhighpixels, numpixels * sizeof(float[4]));
2576 r_shadow_bouncegridnumpixels = numpixels;
2577 pixels = r_shadow_bouncegridpixels;
2578 highpixels = r_shadow_bouncegridhighpixels;
2579 x = pixelsperband*4;
2580 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2583 memset(pixels + pixelband * x, 128, x);
2585 memset(pixels + pixelband * x, 0, x);
2587 memset(highpixels, 0, numpixels * sizeof(float[4]));
2588 // figure out what we want to interact with
2589 if (settings.hitmodels)
2590 hitsupercontentsmask = SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;// | SUPERCONTENTS_LIQUIDSMASK;
2592 hitsupercontentsmask = SUPERCONTENTS_SOLID;// | SUPERCONTENTS_LIQUIDSMASK;
2593 maxbounce = settings.maxbounce;
2594 // clear variables that produce warnings otherwise
2595 memset(splatcolor, 0, sizeof(splatcolor));
2596 // iterate world rtlights
2597 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
2598 range1 = settings.staticmode ? 0 : r_refdef.scene.numlights;
2599 range2 = range + range1;
2601 for (lightindex = 0;lightindex < range2;lightindex++)
2603 if (settings.staticmode)
2605 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2606 if (!light || !(light->flags & flag))
2608 rtlight = &light->rtlight;
2609 // when static, we skip styled lights because they tend to change...
2610 if (rtlight->style > 0)
2612 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) * (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1), lightcolor);
2616 if (lightindex < range)
2618 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2619 rtlight = &light->rtlight;
2622 rtlight = r_refdef.scene.lights[lightindex - range];
2623 // draw only visible lights (major speedup)
2626 VectorScale(rtlight->currentcolor, rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale, lightcolor);
2628 if (!VectorLength2(lightcolor))
2630 // shoot particles from this light
2631 // use a calculation for the number of particles that will not
2632 // vary with lightstyle, otherwise we get randomized particle
2633 // distribution, the seeded random is only consistent for a
2634 // consistent number of particles on this light...
2635 radius = rtlight->radius * settings.lightradiusscale;
2636 s = rtlight->radius;
2637 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2638 if (lightindex >= range)
2639 lightintensity *= settings.dlightparticlemultiplier;
2640 photoncount += max(0.0f, lightintensity * s * s);
2642 photonscaling = (float)settings.photons / max(1, photoncount);
2643 photonresidual = 0.0f;
2644 for (lightindex = 0;lightindex < range2;lightindex++)
2646 if (settings.staticmode)
2648 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2649 if (!light || !(light->flags & flag))
2651 rtlight = &light->rtlight;
2652 // when static, we skip styled lights because they tend to change...
2653 if (rtlight->style > 0)
2655 VectorScale(rtlight->color, (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) * (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1), lightcolor);
2659 if (lightindex < range)
2661 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
2662 rtlight = &light->rtlight;
2665 rtlight = r_refdef.scene.lights[lightindex - range];
2666 // draw only visible lights (major speedup)
2669 VectorScale(rtlight->currentcolor, rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale, lightcolor);
2671 if (!VectorLength2(lightcolor))
2673 // shoot particles from this light
2674 // use a calculation for the number of particles that will not
2675 // vary with lightstyle, otherwise we get randomized particle
2676 // distribution, the seeded random is only consistent for a
2677 // consistent number of particles on this light...
2678 radius = rtlight->radius * settings.lightradiusscale;
2679 s = rtlight->radius;
2680 lightintensity = VectorLength(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale);
2681 if (lightindex >= range)
2682 lightintensity *= settings.dlightparticlemultiplier;
2683 photonresidual += lightintensity * s * s * photonscaling;
2684 shootparticles = (int)bound(0, photonresidual, MAXBOUNCEGRIDPARTICLESPERLIGHT);
2685 if (!shootparticles)
2687 photonresidual -= shootparticles;
2688 s = settings.particleintensity / shootparticles;
2689 VectorScale(lightcolor, s, baseshotcolor);
2690 if (VectorLength2(baseshotcolor) == 0.0f)
2692 r_refdef.stats.bouncegrid_lights++;
2693 r_refdef.stats.bouncegrid_particles += shootparticles;
2694 for (shotparticles = 0;shotparticles < shootparticles;shotparticles++)
2696 if (settings.stablerandom > 0)
2697 seed = lightindex * 11937 + shotparticles;
2698 VectorCopy(baseshotcolor, shotcolor);
2699 VectorCopy(rtlight->shadoworigin, clipstart);
2700 if (settings.stablerandom < 0)
2701 VectorRandom(clipend);
2703 VectorCheeseRandom(clipend);
2704 VectorMA(clipstart, radius, clipend, clipend);
2705 for (bouncecount = 0;;bouncecount++)
2707 r_refdef.stats.bouncegrid_traces++;
2708 //r_refdef.scene.worldmodel->TraceLineAgainstSurfaces(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace, clipstart, clipend, hitsupercontentsmask);
2709 //r_refdef.scene.worldmodel->TraceLine(r_refdef.scene.worldmodel, NULL, NULL, &cliptrace2, clipstart, clipend, hitsupercontentsmask);
2710 if (settings.staticmode)
2711 Collision_ClipLineToWorld(&cliptrace, cl.worldmodel, clipstart, clipend, hitsupercontentsmask, true);
2713 cliptrace = CL_TraceLine(clipstart, clipend, settings.hitmodels ? MOVE_HITMODEL : MOVE_NOMONSTERS, NULL, hitsupercontentsmask, true, false, NULL, true, true);
2714 if (bouncecount > 0 || settings.includedirectlighting)
2716 // calculate second order spherical harmonics values (average, slopeX, slopeY, slopeZ)
2717 // accumulate average shotcolor
2718 w = VectorLength(shotcolor);
2719 splatcolor[ 0] = shotcolor[0];
2720 splatcolor[ 1] = shotcolor[1];
2721 splatcolor[ 2] = shotcolor[2];
2722 splatcolor[ 3] = 0.0f;
2725 VectorSubtract(clipstart, cliptrace.endpos, clipdiff);
2726 VectorNormalize(clipdiff);
2727 // store bentnormal in case the shader has a use for it
2728 splatcolor[ 4] = clipdiff[0] * w;
2729 splatcolor[ 5] = clipdiff[1] * w;
2730 splatcolor[ 6] = clipdiff[2] * w;
2732 // accumulate directional contributions (+X, +Y, +Z, -X, -Y, -Z)
2733 splatcolor[ 8] = shotcolor[0] * max(0.0f, clipdiff[0]);
2734 splatcolor[ 9] = shotcolor[0] * max(0.0f, clipdiff[1]);
2735 splatcolor[10] = shotcolor[0] * max(0.0f, clipdiff[2]);
2736 splatcolor[11] = 0.0f;
2737 splatcolor[12] = shotcolor[1] * max(0.0f, clipdiff[0]);
2738 splatcolor[13] = shotcolor[1] * max(0.0f, clipdiff[1]);
2739 splatcolor[14] = shotcolor[1] * max(0.0f, clipdiff[2]);
2740 splatcolor[15] = 0.0f;
2741 splatcolor[16] = shotcolor[2] * max(0.0f, clipdiff[0]);
2742 splatcolor[17] = shotcolor[2] * max(0.0f, clipdiff[1]);
2743 splatcolor[18] = shotcolor[2] * max(0.0f, clipdiff[2]);
2744 splatcolor[19] = 0.0f;
2745 splatcolor[20] = shotcolor[0] * max(0.0f, -clipdiff[0]);
2746 splatcolor[21] = shotcolor[0] * max(0.0f, -clipdiff[1]);
2747 splatcolor[22] = shotcolor[0] * max(0.0f, -clipdiff[2]);
2748 splatcolor[23] = 0.0f;
2749 splatcolor[24] = shotcolor[1] * max(0.0f, -clipdiff[0]);
2750 splatcolor[25] = shotcolor[1] * max(0.0f, -clipdiff[1]);
2751 splatcolor[26] = shotcolor[1] * max(0.0f, -clipdiff[2]);
2752 splatcolor[27] = 0.0f;
2753 splatcolor[28] = shotcolor[2] * max(0.0f, -clipdiff[0]);
2754 splatcolor[29] = shotcolor[2] * max(0.0f, -clipdiff[1]);
2755 splatcolor[30] = shotcolor[2] * max(0.0f, -clipdiff[2]);
2756 splatcolor[31] = 0.0f;
2758 // calculate the number of steps we need to traverse this distance
2759 VectorSubtract(cliptrace.endpos, clipstart, stepdelta);
2760 numsteps = (int)(VectorLength(stepdelta) / settings.airstepsize);
2761 numsteps = bound(1, numsteps, settings.airstepmax);
2762 w = 1.0f / numsteps;
2763 VectorScale(stepdelta, w, stepdelta);
2764 VectorMA(clipstart, 0.5f, stepdelta, steppos);
2765 if (settings.airstepmax == 1)
2766 VectorCopy(cliptrace.endpos, steppos);
2767 for (step = 0;step < numsteps;step++)
2769 r_refdef.stats.bouncegrid_splats++;
2770 // figure out which texture pixel this is in
2771 texlerp[1][0] = ((steppos[0] - mins[0]) * ispacing[0]);
2772 texlerp[1][1] = ((steppos[1] - mins[1]) * ispacing[1]);
2773 texlerp[1][2] = ((steppos[2] - mins[2]) * ispacing[2]);
2774 tex[0] = (int)floor(texlerp[1][0]);
2775 tex[1] = (int)floor(texlerp[1][1]);
2776 tex[2] = (int)floor(texlerp[1][2]);
2777 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)
2779 // it is within bounds... do the real work now
2780 // calculate the lerp factors
2781 texlerp[1][0] -= tex[0];
2782 texlerp[1][1] -= tex[1];
2783 texlerp[1][2] -= tex[2];
2784 texlerp[0][0] = 1.0f - texlerp[1][0];
2785 texlerp[0][1] = 1.0f - texlerp[1][1];
2786 texlerp[0][2] = 1.0f - texlerp[1][2];
2787 // calculate individual pixel indexes and weights
2788 pixelindex[0] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[0] = (texlerp[0][0]*texlerp[0][1]*texlerp[0][2]);
2789 pixelindex[1] = (((tex[2] )*resolution[1]+tex[1] )*resolution[0]+tex[0]+1);pixelweight[1] = (texlerp[1][0]*texlerp[0][1]*texlerp[0][2]);
2790 pixelindex[2] = (((tex[2] )*resolution[1]+tex[1]+1)*resolution[0]+tex[0] );pixelweight[2] = (texlerp[0][0]*texlerp[1][1]*texlerp[0][2]);
2791 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]);
2792 pixelindex[4] = (((tex[2]+1)*resolution[1]+tex[1] )*resolution[0]+tex[0] );pixelweight[4] = (texlerp[0][0]*texlerp[0][1]*texlerp[1][2]);
2793 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]);
2794 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]);
2795 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]);
2796 // update the 8 pixels...
2797 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2799 for (corner = 0;corner < 8;corner++)
2801 // calculate address for pixel
2802 w = pixelweight[corner];
2803 pixel = pixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2804 highpixel = highpixels + 4 * pixelindex[corner] + pixelband * pixelsperband * 4;
2805 // add to the high precision pixel color
2806 highpixel[0] += (splatcolor[pixelband*4+0]*w);
2807 highpixel[1] += (splatcolor[pixelband*4+1]*w);
2808 highpixel[2] += (splatcolor[pixelband*4+2]*w);
2809 highpixel[3] += (splatcolor[pixelband*4+3]*w);
2810 // flag the low precision pixel as needing to be updated
2812 // advance to next band of coefficients
2813 //pixel += pixelsperband*4;
2814 //highpixel += pixelsperband*4;
2818 VectorAdd(steppos, stepdelta, steppos);
2821 if (cliptrace.fraction >= 1.0f)
2823 r_refdef.stats.bouncegrid_hits++;
2824 if (bouncecount >= maxbounce)
2826 // scale down shot color by bounce intensity and texture color (or 50% if no texture reported)
2827 // also clamp the resulting color to never add energy, even if the user requests extreme values
2828 if (cliptrace.hittexture && cliptrace.hittexture->currentskinframe)
2829 VectorCopy(cliptrace.hittexture->currentskinframe->avgcolor, surfcolor);
2831 VectorSet(surfcolor, 0.5f, 0.5f, 0.5f);
2832 VectorScale(surfcolor, settings.particlebounceintensity, surfcolor);
2833 surfcolor[0] = min(surfcolor[0], 1.0f);
2834 surfcolor[1] = min(surfcolor[1], 1.0f);
2835 surfcolor[2] = min(surfcolor[2], 1.0f);
2836 VectorMultiply(shotcolor, surfcolor, shotcolor);
2837 if (VectorLength2(baseshotcolor) == 0.0f)
2839 r_refdef.stats.bouncegrid_bounces++;
2840 if (settings.bounceanglediffuse)
2842 // random direction, primarily along plane normal
2843 s = VectorDistance(cliptrace.endpos, clipend);
2844 if (settings.stablerandom < 0)
2845 VectorRandom(clipend);
2847 VectorCheeseRandom(clipend);
2848 VectorMA(cliptrace.plane.normal, 0.95f, clipend, clipend);
2849 VectorNormalize(clipend);
2850 VectorScale(clipend, s, clipend);
2854 // reflect the remaining portion of the line across plane normal
2855 VectorSubtract(clipend, cliptrace.endpos, clipdiff);
2856 VectorReflect(clipdiff, 1.0, cliptrace.plane.normal, clipend);
2858 // calculate the new line start and end
2859 VectorCopy(cliptrace.endpos, clipstart);
2860 VectorAdd(clipstart, clipend, clipend);
2864 // generate pixels array from highpixels array
2865 // skip first and last columns, rows, and layers as these are blank
2866 // the pixel[3] value was written above, so we can use it to detect only pixels that need to be calculated
2867 for (pixelband = 0;pixelband < pixelbands;pixelband++)
2869 for (z = 1;z < resolution[2]-1;z++)
2871 for (y = 1;y < resolution[1]-1;y++)
2873 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)
2875 // only convert pixels that were hit by photons
2876 if (pixel[3] == 255)
2878 // normalize the bentnormal...
2881 VectorNormalize(highpixel);
2882 c[0] = (int)(highpixel[0]*128.0f+128.0f);
2883 c[1] = (int)(highpixel[1]*128.0f+128.0f);
2884 c[2] = (int)(highpixel[2]*128.0f+128.0f);
2885 c[3] = (int)(highpixel[3]*128.0f+128.0f);
2889 c[0] = (int)(highpixel[0]*256.0f);
2890 c[1] = (int)(highpixel[1]*256.0f);
2891 c[2] = (int)(highpixel[2]*256.0f);
2892 c[3] = (int)(highpixel[3]*256.0f);
2894 pixel[2] = (unsigned char)bound(0, c[0], 255);
2895 pixel[1] = (unsigned char)bound(0, c[1], 255);
2896 pixel[0] = (unsigned char)bound(0, c[2], 255);
2897 pixel[3] = (unsigned char)bound(0, c[3], 255);
2903 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)
2904 R_UpdateTexture(r_shadow_bouncegridtexture, pixels, 0, 0, 0, resolution[0], resolution[1], resolution[2]*pixelbands);
2907 VectorCopy(resolution, r_shadow_bouncegridresolution);
2908 r_shadow_bouncegriddirectional = settings.directionalshading;
2909 if (r_shadow_bouncegridtexture)
2910 R_FreeTexture(r_shadow_bouncegridtexture);
2911 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);
2913 r_shadow_bouncegridtime = realtime;
2916 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2918 R_Shadow_RenderMode_Reset();
2919 GL_BlendFunc(GL_ONE, GL_ONE);
2920 GL_DepthRange(0, 1);
2921 GL_DepthTest(r_showshadowvolumes.integer < 2);
2922 GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2923 GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2924 GL_CullFace(GL_NONE);
2925 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2928 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2930 R_Shadow_RenderMode_Reset();
2931 GL_BlendFunc(GL_ONE, GL_ONE);
2932 GL_DepthRange(0, 1);
2933 GL_DepthTest(r_showlighting.integer < 2);
2934 GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2936 GL_DepthFunc(GL_EQUAL);
2937 R_SetStencil(stenciltest, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_EQUAL, 128, 255);
2938 r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2941 void R_Shadow_RenderMode_End(void)
2943 R_Shadow_RenderMode_Reset();
2944 R_Shadow_RenderMode_ActiveLight(NULL);
2946 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2947 r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2950 int bboxedges[12][2] =
2969 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2971 if (!r_shadow_scissor.integer || r_shadow_usingdeferredprepass || r_trippy.integer)
2973 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2974 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2975 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2976 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2979 if(R_ScissorForBBox(mins, maxs, r_shadow_lightscissor))
2980 return true; // invisible
2981 if(r_shadow_lightscissor[0] != r_refdef.view.viewport.x
2982 || r_shadow_lightscissor[1] != r_refdef.view.viewport.y
2983 || r_shadow_lightscissor[2] != r_refdef.view.viewport.width
2984 || r_shadow_lightscissor[3] != r_refdef.view.viewport.height)
2985 r_refdef.stats.lights_scissored++;
2989 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, const float *diffusecolor, const float *ambientcolor)
2992 const float *vertex3f;
2993 const float *normal3f;
2995 float dist, dot, distintensity, shadeintensity, v[3], n[3];
2996 switch (r_shadow_rendermode)
2998 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2999 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3000 if (VectorLength2(diffusecolor) > 0)
3002 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)
3004 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3005 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3006 if ((dot = DotProduct(n, v)) < 0)
3008 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3009 VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
3012 VectorCopy(ambientcolor, color4f);
3013 if (r_refdef.fogenabled)
3016 f = RSurf_FogVertex(vertex3f);
3017 VectorScale(color4f, f, color4f);
3024 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3026 VectorCopy(ambientcolor, color4f);
3027 if (r_refdef.fogenabled)
3030 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3031 f = RSurf_FogVertex(vertex3f);
3032 VectorScale(color4f + 4*i, f, color4f);
3038 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3039 if (VectorLength2(diffusecolor) > 0)
3041 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)
3043 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3044 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3046 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3047 if ((dot = DotProduct(n, v)) < 0)
3049 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3050 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3051 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3052 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3056 color4f[0] = ambientcolor[0] * distintensity;
3057 color4f[1] = ambientcolor[1] * distintensity;
3058 color4f[2] = ambientcolor[2] * distintensity;
3060 if (r_refdef.fogenabled)
3063 f = RSurf_FogVertex(vertex3f);
3064 VectorScale(color4f, f, color4f);
3068 VectorClear(color4f);
3074 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3076 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3077 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3079 color4f[0] = ambientcolor[0] * distintensity;
3080 color4f[1] = ambientcolor[1] * distintensity;
3081 color4f[2] = ambientcolor[2] * distintensity;
3082 if (r_refdef.fogenabled)
3085 f = RSurf_FogVertex(vertex3f);
3086 VectorScale(color4f, f, color4f);
3090 VectorClear(color4f);
3095 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3096 if (VectorLength2(diffusecolor) > 0)
3098 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)
3100 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3101 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3103 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3104 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
3105 if ((dot = DotProduct(n, v)) < 0)
3107 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
3108 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
3109 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
3110 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
3114 color4f[0] = ambientcolor[0] * distintensity;
3115 color4f[1] = ambientcolor[1] * distintensity;
3116 color4f[2] = ambientcolor[2] * distintensity;
3118 if (r_refdef.fogenabled)
3121 f = RSurf_FogVertex(vertex3f);
3122 VectorScale(color4f, f, color4f);
3126 VectorClear(color4f);
3132 for (i = 0, vertex3f = rsurface.batchvertex3f + 3*firstvertex, color4f = rsurface.passcolor4f + 4 * firstvertex;i < numverts;i++, vertex3f += 3, color4f += 4)
3134 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
3135 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
3137 distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
3138 color4f[0] = ambientcolor[0] * distintensity;
3139 color4f[1] = ambientcolor[1] * distintensity;
3140 color4f[2] = ambientcolor[2] * distintensity;
3141 if (r_refdef.fogenabled)
3144 f = RSurf_FogVertex(vertex3f);
3145 VectorScale(color4f, f, color4f);
3149 VectorClear(color4f);
3159 static void R_Shadow_RenderLighting_VisibleLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3161 // used to display how many times a surface is lit for level design purposes
3162 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3163 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
3167 static void R_Shadow_RenderLighting_Light_GLSL(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale, float specularscale)
3169 // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
3170 R_SetupShader_Surface(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT, texturenumsurfaces, texturesurfacelist, NULL, false);
3171 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3173 GL_DepthFunc(GL_EQUAL);
3177 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
3179 GL_DepthFunc(GL_LEQUAL);
3180 GL_AlphaTest(false);
3184 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
3191 int newnumtriangles;
3195 int maxtriangles = 4096;
3196 static int newelements[4096*3];
3197 R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, diffusecolor2, ambientcolor2);
3198 for (renders = 0;renders < 4;renders++)
3203 newnumtriangles = 0;
3205 // due to low fillrate on the cards this vertex lighting path is
3206 // designed for, we manually cull all triangles that do not
3207 // contain a lit vertex
3208 // this builds batches of triangles from multiple surfaces and
3209 // renders them at once
3210 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
3212 if (VectorLength2(rsurface.passcolor4f + e[0] * 4) + VectorLength2(rsurface.passcolor4f + e[1] * 4) + VectorLength2(rsurface.passcolor4f + e[2] * 4) >= 0.01)
3214 if (newnumtriangles)
3216 newfirstvertex = min(newfirstvertex, e[0]);
3217 newlastvertex = max(newlastvertex, e[0]);
3221 newfirstvertex = e[0];
3222 newlastvertex = e[0];
3224 newfirstvertex = min(newfirstvertex, e[1]);
3225 newlastvertex = max(newlastvertex, e[1]);
3226 newfirstvertex = min(newfirstvertex, e[2]);
3227 newlastvertex = max(newlastvertex, e[2]);
3233 if (newnumtriangles >= maxtriangles)
3235 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3236 newnumtriangles = 0;
3242 if (newnumtriangles >= 1)
3244 R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, NULL, NULL, 0);
3247 // if we couldn't find any lit triangles, exit early
3250 // now reduce the intensity for the next overbright pass
3251 // we have to clamp to 0 here incase the drivers have improper
3252 // handling of negative colors
3253 // (some old drivers even have improper handling of >1 color)
3255 for (i = 0, c = rsurface.passcolor4f + 4 * firstvertex;i < numvertices;i++, c += 4)
3257 if (c[0] > 1 || c[1] > 1 || c[2] > 1)
3259 c[0] = max(0, c[0] - 1);
3260 c[1] = max(0, c[1] - 1);
3261 c[2] = max(0, c[2] - 1);
3273 static void R_Shadow_RenderLighting_Light_Vertex(int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t lightcolor, float ambientscale, float diffusescale)
3275 // OpenGL 1.1 path (anything)
3276 float ambientcolorbase[3], diffusecolorbase[3];
3277 float ambientcolorpants[3], diffusecolorpants[3];
3278 float ambientcolorshirt[3], diffusecolorshirt[3];
3279 const float *surfacecolor = rsurface.texture->dlightcolor;
3280 const float *surfacepants = rsurface.colormap_pantscolor;
3281 const float *surfaceshirt = rsurface.colormap_shirtcolor;
3282 rtexture_t *basetexture = rsurface.texture->basetexture;
3283 rtexture_t *pantstexture = rsurface.texture->pantstexture;
3284 rtexture_t *shirttexture = rsurface.texture->shirttexture;
3285 qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
3286 qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
3287 ambientscale *= 2 * r_refdef.view.colorscale;
3288 diffusescale *= 2 * r_refdef.view.colorscale;
3289 ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
3290 diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
3291 ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
3292 diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
3293 ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
3294 diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
3295 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | (diffusescale > 0 ? BATCHNEED_ARRAY_NORMAL : 0) | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
3296 rsurface.passcolor4f = (float *)R_FrameData_Alloc((rsurface.batchfirstvertex + rsurface.batchnumvertices) * sizeof(float[4]));
3297 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3298 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
3299 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
3300 R_Mesh_TexBind(0, basetexture);
3301 R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
3302 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
3303 switch(r_shadow_rendermode)
3305 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3306 R_Mesh_TexBind(1, r_shadow_attenuation3dtexture);
3307 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3308 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3309 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3311 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3312 R_Mesh_TexBind(2, r_shadow_attenuation2dtexture);
3313 R_Mesh_TexMatrix(2, &rsurface.entitytoattenuationz);
3314 R_Mesh_TexCombine(2, GL_MODULATE, GL_MODULATE, 1, 1);
3315 R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3317 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3318 R_Mesh_TexBind(1, r_shadow_attenuation2dtexture);
3319 R_Mesh_TexMatrix(1, &rsurface.entitytoattenuationxyz);
3320 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, 1, 1);
3321 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
3323 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3328 //R_Mesh_TexBind(0, basetexture);
3329 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorbase, ambientcolorbase);
3332 R_Mesh_TexBind(0, pantstexture);
3333 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorpants, ambientcolorpants);
3337 R_Mesh_TexBind(0, shirttexture);
3338 R_Shadow_RenderLighting_Light_Vertex_Pass(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchnumtriangles, rsurface.batchelement3i + 3*rsurface.batchfirsttriangle, diffusecolorshirt, ambientcolorshirt);
3342 extern cvar_t gl_lightmaps;
3343 void R_Shadow_RenderLighting(int texturenumsurfaces, const msurface_t **texturesurfacelist)
3345 float ambientscale, diffusescale, specularscale;
3347 float lightcolor[3];
3348 VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
3349 ambientscale = rsurface.rtlight->ambientscale;
3350 diffusescale = rsurface.rtlight->diffusescale;
3351 specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
3352 if (!r_shadow_usenormalmap.integer)
3354 ambientscale += 1.0f * diffusescale;
3358 if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
3360 negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
3363 VectorNegate(lightcolor, lightcolor);
3364 switch(vid.renderpath)
3366 case RENDERPATH_GL11:
3367 case RENDERPATH_GL13:
3368 case RENDERPATH_GL20:
3369 case RENDERPATH_GLES1:
3370 case RENDERPATH_GLES2:
3371 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
3373 case RENDERPATH_D3D9:
3375 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
3378 case RENDERPATH_D3D10:
3379 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3381 case RENDERPATH_D3D11:
3382 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3384 case RENDERPATH_SOFT:
3385 DPSOFTRAST_BlendSubtract(true);
3389 RSurf_SetupDepthAndCulling();
3390 switch (r_shadow_rendermode)
3392 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
3393 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
3394 R_Shadow_RenderLighting_VisibleLighting(texturenumsurfaces, texturesurfacelist);
3396 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3397 R_Shadow_RenderLighting_Light_GLSL(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale, specularscale);
3399 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3400 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3401 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3402 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3403 R_Shadow_RenderLighting_Light_Vertex(texturenumsurfaces, texturesurfacelist, lightcolor, ambientscale, diffusescale);
3406 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
3411 switch(vid.renderpath)
3413 case RENDERPATH_GL11:
3414 case RENDERPATH_GL13:
3415 case RENDERPATH_GL20:
3416 case RENDERPATH_GLES1:
3417 case RENDERPATH_GLES2:
3418 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3420 case RENDERPATH_D3D9:
3422 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
3425 case RENDERPATH_D3D10:
3426 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3428 case RENDERPATH_D3D11:
3429 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3431 case RENDERPATH_SOFT:
3432 DPSOFTRAST_BlendSubtract(false);
3438 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)
3440 matrix4x4_t tempmatrix = *matrix;
3441 Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
3443 // if this light has been compiled before, free the associated data
3444 R_RTLight_Uncompile(rtlight);
3446 // clear it completely to avoid any lingering data
3447 memset(rtlight, 0, sizeof(*rtlight));
3449 // copy the properties
3450 rtlight->matrix_lighttoworld = tempmatrix;
3451 Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3452 Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3453 rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3454 VectorCopy(color, rtlight->color);
3455 rtlight->cubemapname[0] = 0;
3456 if (cubemapname && cubemapname[0])
3457 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3458 rtlight->shadow = shadow;
3459 rtlight->corona = corona;
3460 rtlight->style = style;
3461 rtlight->isstatic = isstatic;
3462 rtlight->coronasizescale = coronasizescale;
3463 rtlight->ambientscale = ambientscale;
3464 rtlight->diffusescale = diffusescale;
3465 rtlight->specularscale = specularscale;
3466 rtlight->flags = flags;
3468 // compute derived data
3469 //rtlight->cullradius = rtlight->radius;
3470 //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3471 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3472 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3473 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3474 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3475 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3476 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3479 // compiles rtlight geometry
3480 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3481 void R_RTLight_Compile(rtlight_t *rtlight)
3484 int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3485 int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3486 entity_render_t *ent = r_refdef.scene.worldentity;
3487 dp_model_t *model = r_refdef.scene.worldmodel;
3488 unsigned char *data;
3491 // compile the light
3492 rtlight->compiled = true;
3493 rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3494 rtlight->static_numleafs = 0;
3495 rtlight->static_numleafpvsbytes = 0;
3496 rtlight->static_leaflist = NULL;
3497 rtlight->static_leafpvs = NULL;
3498 rtlight->static_numsurfaces = 0;
3499 rtlight->static_surfacelist = NULL;
3500 rtlight->static_shadowmap_receivers = 0x3F;
3501 rtlight->static_shadowmap_casters = 0x3F;
3502 rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3503 rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3504 rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3505 rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3506 rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3507 rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3509 if (model && model->GetLightInfo)
3511 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3512 r_shadow_compilingrtlight = rtlight;
3513 R_FrameData_SetMark();
3514 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);
3515 R_FrameData_ReturnToMark();
3516 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3517 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3518 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3519 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3520 rtlight->static_numsurfaces = numsurfaces;
3521 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3522 rtlight->static_numleafs = numleafs;
3523 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3524 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3525 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3526 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3527 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3528 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3529 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3530 if (rtlight->static_numsurfaces)
3531 memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3532 if (rtlight->static_numleafs)
3533 memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3534 if (rtlight->static_numleafpvsbytes)
3535 memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3536 if (rtlight->static_numshadowtrispvsbytes)
3537 memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3538 if (rtlight->static_numlighttrispvsbytes)
3539 memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3540 R_FrameData_SetMark();
3541 switch (rtlight->shadowmode)
3543 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3544 if (model->CompileShadowMap && rtlight->shadow)
3545 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3548 if (model->CompileShadowVolume && rtlight->shadow)
3549 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3552 R_FrameData_ReturnToMark();
3553 // now we're done compiling the rtlight
3554 r_shadow_compilingrtlight = NULL;
3558 // use smallest available cullradius - box radius or light radius
3559 //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3560 //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3562 shadowzpasstris = 0;
3563 if (rtlight->static_meshchain_shadow_zpass)
3564 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3565 shadowzpasstris += mesh->numtriangles;
3567 shadowzfailtris = 0;
3568 if (rtlight->static_meshchain_shadow_zfail)
3569 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3570 shadowzfailtris += mesh->numtriangles;
3573 if (rtlight->static_numlighttrispvsbytes)
3574 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3575 if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3579 if (rtlight->static_numlighttrispvsbytes)
3580 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3581 if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3584 if (developer_extra.integer)
3585 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);
3588 void R_RTLight_Uncompile(rtlight_t *rtlight)
3590 if (rtlight->compiled)
3592 if (rtlight->static_meshchain_shadow_zpass)
3593 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3594 rtlight->static_meshchain_shadow_zpass = NULL;
3595 if (rtlight->static_meshchain_shadow_zfail)
3596 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3597 rtlight->static_meshchain_shadow_zfail = NULL;
3598 if (rtlight->static_meshchain_shadow_shadowmap)
3599 Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3600 rtlight->static_meshchain_shadow_shadowmap = NULL;
3601 // these allocations are grouped
3602 if (rtlight->static_surfacelist)
3603 Mem_Free(rtlight->static_surfacelist);
3604 rtlight->static_numleafs = 0;
3605 rtlight->static_numleafpvsbytes = 0;
3606 rtlight->static_leaflist = NULL;
3607 rtlight->static_leafpvs = NULL;
3608 rtlight->static_numsurfaces = 0;
3609 rtlight->static_surfacelist = NULL;
3610 rtlight->static_numshadowtrispvsbytes = 0;
3611 rtlight->static_shadowtrispvs = NULL;
3612 rtlight->static_numlighttrispvsbytes = 0;
3613 rtlight->static_lighttrispvs = NULL;
3614 rtlight->compiled = false;
3618 void R_Shadow_UncompileWorldLights(void)
3622 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3623 for (lightindex = 0;lightindex < range;lightindex++)
3625 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3628 R_RTLight_Uncompile(&light->rtlight);
3632 void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3636 // reset the count of frustum planes
3637 // see rtlight->cached_frustumplanes definition for how much this array
3639 rtlight->cached_numfrustumplanes = 0;
3641 if (r_trippy.integer)
3644 // haven't implemented a culling path for ortho rendering
3645 if (!r_refdef.view.useperspective)
3647 // check if the light is on screen and copy the 4 planes if it is
3648 for (i = 0;i < 4;i++)
3649 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3652 for (i = 0;i < 4;i++)
3653 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3658 // generate a deformed frustum that includes the light origin, this is
3659 // used to cull shadow casting surfaces that can not possibly cast a
3660 // shadow onto the visible light-receiving surfaces, which can be a
3663 // if the light origin is onscreen the result will be 4 planes exactly
3664 // if the light origin is offscreen on only one axis the result will
3665 // be exactly 5 planes (split-side case)
3666 // if the light origin is offscreen on two axes the result will be
3667 // exactly 4 planes (stretched corner case)
3668 for (i = 0;i < 4;i++)
3670 // quickly reject standard frustum planes that put the light
3671 // origin outside the frustum
3672 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3675 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3677 // if all the standard frustum planes were accepted, the light is onscreen
3678 // otherwise we need to generate some more planes below...
3679 if (rtlight->cached_numfrustumplanes < 4)
3681 // at least one of the stock frustum planes failed, so we need to
3682 // create one or two custom planes to enclose the light origin
3683 for (i = 0;i < 4;i++)
3685 // create a plane using the view origin and light origin, and a
3686 // single point from the frustum corner set
3687 TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3688 VectorNormalize(plane.normal);
3689 plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3690 // see if this plane is backwards and flip it if so
3691 for (j = 0;j < 4;j++)
3692 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3696 VectorNegate(plane.normal, plane.normal);
3698 // flipped plane, test again to see if it is now valid
3699 for (j = 0;j < 4;j++)
3700 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3702 // if the plane is still not valid, then it is dividing the
3703 // frustum and has to be rejected
3707 // we have created a valid plane, compute extra info
3708 PlaneClassify(&plane);
3710 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3712 // if we've found 5 frustum planes then we have constructed a
3713 // proper split-side case and do not need to keep searching for
3714 // planes to enclose the light origin
3715 if (rtlight->cached_numfrustumplanes == 5)
3723 for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3725 plane = rtlight->cached_frustumplanes[i];
3726 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));
3731 // now add the light-space box planes if the light box is rotated, as any
3732 // caster outside the oriented light box is irrelevant (even if it passed
3733 // the worldspace light box, which is axial)
3734 if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3736 for (i = 0;i < 6;i++)
3740 v[i >> 1] = (i & 1) ? -1 : 1;
3741 Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3742 VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3743 plane.dist = VectorNormalizeLength(plane.normal);
3744 plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3745 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3751 // add the world-space reduced box planes
3752 for (i = 0;i < 6;i++)
3754 VectorClear(plane.normal);
3755 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3756 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3757 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3766 // reduce all plane distances to tightly fit the rtlight cull box, which
3768 VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3769 VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3770 VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3771 VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3772 VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3773 VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3774 VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3775 VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3776 oldnum = rtlight->cached_numfrustumplanes;
3777 rtlight->cached_numfrustumplanes = 0;
3778 for (j = 0;j < oldnum;j++)
3780 // find the nearest point on the box to this plane
3781 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3782 for (i = 1;i < 8;i++)
3784 dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3785 if (bestdist > dist)
3788 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);
3789 // if the nearest point is near or behind the plane, we want this
3790 // plane, otherwise the plane is useless as it won't cull anything
3791 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3793 PlaneClassify(&rtlight->cached_frustumplanes[j]);
3794 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3801 void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3805 RSurf_ActiveWorldEntity();
3807 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3810 GL_CullFace(GL_NONE);
3811 mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3812 for (;mesh;mesh = mesh->next)
3814 if (!mesh->sidetotals[r_shadow_shadowmapside])
3816 r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3817 if (mesh->vertex3fbuffer)
3818 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3820 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3821 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);
3825 else if (r_refdef.scene.worldentity->model)
3826 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);
3828 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3831 void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3833 qboolean zpass = false;
3836 int surfacelistindex;
3837 msurface_t *surface;
3839 // if triangle neighbors are disabled, shadowvolumes are disabled
3840 if (r_refdef.scene.worldmodel->brush.shadowmesh ? !r_refdef.scene.worldmodel->brush.shadowmesh->neighbor3i : !r_refdef.scene.worldmodel->surfmesh.data_neighbor3i)
3843 RSurf_ActiveWorldEntity();
3845 if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3848 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3850 zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3851 R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3853 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3854 for (;mesh;mesh = mesh->next)
3856 r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3857 if (mesh->vertex3fbuffer)
3858 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vertex3fbuffer);
3860 R_Mesh_PrepareVertices_Vertex3f(mesh->numverts, mesh->vertex3f, mesh->vbo_vertexbuffer);
3861 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3863 // increment stencil if frontface is infront of depthbuffer
3864 GL_CullFace(r_refdef.view.cullface_back);
3865 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_INCR, GL_ALWAYS, 128, 255);
3866 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);
3867 // decrement stencil if backface is infront of depthbuffer
3868 GL_CullFace(r_refdef.view.cullface_front);
3869 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_DECR, GL_ALWAYS, 128, 255);
3871 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3873 // decrement stencil if backface is behind depthbuffer
3874 GL_CullFace(r_refdef.view.cullface_front);
3875 R_SetStencil(true, 255, GL_KEEP, GL_DECR, GL_KEEP, GL_ALWAYS, 128, 255);
3876 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);
3877 // increment stencil if frontface is behind depthbuffer
3878 GL_CullFace(r_refdef.view.cullface_back);
3879 R_SetStencil(true, 255, GL_KEEP, GL_INCR, GL_KEEP, GL_ALWAYS, 128, 255);
3881 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);
3885 else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh)
3887 // use the shadow trispvs calculated earlier by GetLightInfo to cull world triangles on this dynamic light
3888 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3889 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3891 surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3892 for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3893 if (CHECKPVSBIT(trispvs, t))
3894 shadowmarklist[numshadowmark++] = t;
3896 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);
3898 else if (numsurfaces)
3900 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);
3903 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3906 void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3908 vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3909 vec_t relativeshadowradius;
3910 RSurf_ActiveModelEntity(ent, false, false, false);
3911 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3912 // we need to re-init the shader for each entity because the matrix changed
3913 relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3914 relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3915 relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3916 relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3917 relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3918 relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3919 relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3920 switch (r_shadow_rendermode)
3922 case R_SHADOW_RENDERMODE_SHADOWMAP2D:
3923 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3926 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3929 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3932 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3934 // set up properties for rendering light onto this entity
3935 RSurf_ActiveModelEntity(ent, true, true, false);
3936 Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3937 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3938 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3939 Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3942 void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *lighttrispvs)
3944 if (!r_refdef.scene.worldmodel->DrawLight)
3947 // set up properties for rendering light onto this entity
3948 RSurf_ActiveWorldEntity();
3949 rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3950 Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3951 Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3952 VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3954 r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, lighttrispvs);
3956 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3959 void R_Shadow_DrawEntityLight(entity_render_t *ent)
3961 dp_model_t *model = ent->model;
3962 if (!model->DrawLight)
3965 R_Shadow_SetupEntityLight(ent);
3967 model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3969 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3972 void R_Shadow_PrepareLight(rtlight_t *rtlight)
3976 int numleafs, numsurfaces;
3977 int *leaflist, *surfacelist;
3978 unsigned char *leafpvs;
3979 unsigned char *shadowtrispvs;
3980 unsigned char *lighttrispvs;
3981 //unsigned char *surfacesides;
3982 int numlightentities;
3983 int numlightentities_noselfshadow;
3984 int numshadowentities;
3985 int numshadowentities_noselfshadow;
3986 static entity_render_t *lightentities[MAX_EDICTS];
3987 static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3988 static entity_render_t *shadowentities[MAX_EDICTS];
3989 static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3992 rtlight->draw = false;
3994 // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3995 // skip lights that are basically invisible (color 0 0 0)
3996 nolight = VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f);
3998 // loading is done before visibility checks because loading should happen
3999 // all at once at the start of a level, not when it stalls gameplay.
4000 // (especially important to benchmarks)
4002 if (rtlight->isstatic && !nolight && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
4004 if (rtlight->compiled)
4005 R_RTLight_Uncompile(rtlight);
4006 R_RTLight_Compile(rtlight);
4010 rtlight->currentcubemap = rtlight->cubemapname[0] ? R_GetCubemap(rtlight->cubemapname) : r_texture_whitecube;
4012 // look up the light style value at this time
4013 f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4014 VectorScale(rtlight->color, f, rtlight->currentcolor);
4016 if (rtlight->selected)
4018 f = 2 + sin(realtime * M_PI * 4.0);
4019 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
4023 // if lightstyle is currently off, don't draw the light
4024 if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
4027 // skip processing on corona-only lights
4031 // if the light box is offscreen, skip it
4032 if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
4035 VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
4036 VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
4038 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
4040 if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
4042 // compiled light, world available and can receive realtime lighting
4043 // retrieve leaf information
4044 numleafs = rtlight->static_numleafs;
4045 leaflist = rtlight->static_leaflist;
4046 leafpvs = rtlight->static_leafpvs;
4047 numsurfaces = rtlight->static_numsurfaces;
4048 surfacelist = rtlight->static_surfacelist;
4049 //surfacesides = NULL;
4050 shadowtrispvs = rtlight->static_shadowtrispvs;
4051 lighttrispvs = rtlight->static_lighttrispvs;
4053 else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
4055 // dynamic light, world available and can receive realtime lighting
4056 // calculate lit surfaces and leafs
4057 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);
4058 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
4059 leaflist = r_shadow_buffer_leaflist;
4060 leafpvs = r_shadow_buffer_leafpvs;
4061 surfacelist = r_shadow_buffer_surfacelist;
4062 //surfacesides = r_shadow_buffer_surfacesides;
4063 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
4064 lighttrispvs = r_shadow_buffer_lighttrispvs;
4065 // if the reduced leaf bounds are offscreen, skip it
4066 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4077 //surfacesides = NULL;
4078 shadowtrispvs = NULL;
4079 lighttrispvs = NULL;
4081 // check if light is illuminating any visible leafs
4084 for (i = 0;i < numleafs;i++)
4085 if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
4091 // make a list of lit entities and shadow casting entities
4092 numlightentities = 0;
4093 numlightentities_noselfshadow = 0;
4094 numshadowentities = 0;
4095 numshadowentities_noselfshadow = 0;
4097 // add dynamic entities that are lit by the light
4098 for (i = 0;i < r_refdef.scene.numentities;i++)
4101 entity_render_t *ent = r_refdef.scene.entities[i];
4103 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4105 // skip the object entirely if it is not within the valid
4106 // shadow-casting region (which includes the lit region)
4107 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
4109 if (!(model = ent->model))
4111 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
4113 // this entity wants to receive light, is visible, and is
4114 // inside the light box
4115 // TODO: check if the surfaces in the model can receive light
4116 // so now check if it's in a leaf seen by the light
4117 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))
4119 if (ent->flags & RENDER_NOSELFSHADOW)
4120 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
4122 lightentities[numlightentities++] = ent;
4123 // since it is lit, it probably also casts a shadow...
4124 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4125 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4126 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4128 // note: exterior models without the RENDER_NOSELFSHADOW
4129 // flag still create a RENDER_NOSELFSHADOW shadow but
4130 // are lit normally, this means that they are
4131 // self-shadowing but do not shadow other
4132 // RENDER_NOSELFSHADOW entities such as the gun
4133 // (very weird, but keeps the player shadow off the gun)
4134 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4135 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4137 shadowentities[numshadowentities++] = ent;
4140 else if (ent->flags & RENDER_SHADOW)
4142 // this entity is not receiving light, but may still need to
4144 // TODO: check if the surfaces in the model can cast shadow
4145 // now check if it is in a leaf seen by the light
4146 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))
4148 // about the VectorDistance2 - light emitting entities should not cast their own shadow
4149 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4150 if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
4152 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
4153 shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
4155 shadowentities[numshadowentities++] = ent;
4160 // return if there's nothing at all to light
4161 if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
4164 // count this light in the r_speeds
4165 r_refdef.stats.lights++;
4167 // flag it as worth drawing later
4168 rtlight->draw = true;
4170 // cache all the animated entities that cast a shadow but are not visible
4171 for (i = 0;i < numshadowentities;i++)
4172 if (!shadowentities[i]->animcache_vertex3f)
4173 R_AnimCache_GetEntity(shadowentities[i], false, false);
4174 for (i = 0;i < numshadowentities_noselfshadow;i++)
4175 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
4176 R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
4178 // allocate some temporary memory for rendering this light later in the frame
4179 // reusable buffers need to be copied, static data can be used as-is
4180 rtlight->cached_numlightentities = numlightentities;
4181 rtlight->cached_numlightentities_noselfshadow = numlightentities_noselfshadow;
4182 rtlight->cached_numshadowentities = numshadowentities;
4183 rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
4184 rtlight->cached_numsurfaces = numsurfaces;
4185 rtlight->cached_lightentities = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
4186 rtlight->cached_lightentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
4187 rtlight->cached_shadowentities = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
4188 rtlight->cached_shadowentities_noselfshadow = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
4189 if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
4191 int numshadowtrispvsbytes = (((r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles) + 7) >> 3);
4192 int numlighttrispvsbytes = ((r_refdef.scene.worldmodel->surfmesh.num_triangles + 7) >> 3);
4193 rtlight->cached_shadowtrispvs = (unsigned char *)R_FrameData_Store(numshadowtrispvsbytes, shadowtrispvs);
4194 rtlight->cached_lighttrispvs = (unsigned char *)R_FrameData_Store(numlighttrispvsbytes, lighttrispvs);
4195 rtlight->cached_surfacelist = (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
4199 // compiled light data
4200 rtlight->cached_shadowtrispvs = shadowtrispvs;
4201 rtlight->cached_lighttrispvs = lighttrispvs;
4202 rtlight->cached_surfacelist = surfacelist;
4206 void R_Shadow_DrawLight(rtlight_t *rtlight)
4210 unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
4211 int numlightentities;
4212 int numlightentities_noselfshadow;
4213 int numshadowentities;
4214 int numshadowentities_noselfshadow;
4215 entity_render_t **lightentities;
4216 entity_render_t **lightentities_noselfshadow;
4217 entity_render_t **shadowentities;
4218 entity_render_t **shadowentities_noselfshadow;
4220 static unsigned char entitysides[MAX_EDICTS];
4221 static unsigned char entitysides_noselfshadow[MAX_EDICTS];
4222 vec3_t nearestpoint;
4224 qboolean castshadows;
4227 // check if we cached this light this frame (meaning it is worth drawing)
4231 numlightentities = rtlight->cached_numlightentities;
4232 numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
4233 numshadowentities = rtlight->cached_numshadowentities;
4234 numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
4235 numsurfaces = rtlight->cached_numsurfaces;
4236 lightentities = rtlight->cached_lightentities;
4237 lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
4238 shadowentities = rtlight->cached_shadowentities;
4239 shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
4240 shadowtrispvs = rtlight->cached_shadowtrispvs;
4241 lighttrispvs = rtlight->cached_lighttrispvs;
4242 surfacelist = rtlight->cached_surfacelist;
4244 // set up a scissor rectangle for this light
4245 if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
4248 // don't let sound skip if going slow
4249 if (r_refdef.scene.extraupdate)
4252 // make this the active rtlight for rendering purposes
4253 R_Shadow_RenderMode_ActiveLight(rtlight);
4255 if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
4257 // optionally draw visible shape of the shadow volumes
4258 // for performance analysis by level designers
4259 R_Shadow_RenderMode_VisibleShadowVolumes();
4261 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4262 for (i = 0;i < numshadowentities;i++)
4263 R_Shadow_DrawEntityShadow(shadowentities[i]);
4264 for (i = 0;i < numshadowentities_noselfshadow;i++)
4265 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4266 R_Shadow_RenderMode_VisibleLighting(false, false);
4269 if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
4271 // optionally draw the illuminated areas
4272 // for performance analysis by level designers
4273 R_Shadow_RenderMode_VisibleLighting(false, false);
4275 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4276 for (i = 0;i < numlightentities;i++)
4277 R_Shadow_DrawEntityLight(lightentities[i]);
4278 for (i = 0;i < numlightentities_noselfshadow;i++)
4279 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4282 castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
4284 nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
4285 nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
4286 nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
4287 distance = VectorDistance(nearestpoint, r_refdef.view.origin);
4289 lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
4290 //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
4291 lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
4293 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4299 int receivermask = 0;
4300 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
4301 Matrix4x4_Abs(&radiustolight);
4303 r_shadow_shadowmaplod = 0;
4304 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
4305 if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
4306 r_shadow_shadowmaplod = i;
4308 size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
4310 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
4312 surfacesides = NULL;
4315 if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
4317 castermask = rtlight->static_shadowmap_casters;
4318 receivermask = rtlight->static_shadowmap_receivers;
4322 surfacesides = r_shadow_buffer_surfacesides;
4323 for(i = 0;i < numsurfaces;i++)
4325 msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
4326 surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4327 castermask |= surfacesides[i];
4328 receivermask |= surfacesides[i];
4332 if (receivermask < 0x3F)
4334 for (i = 0;i < numlightentities;i++)
4335 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4336 if (receivermask < 0x3F)
4337 for(i = 0; i < numlightentities_noselfshadow;i++)
4338 receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
4341 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
4345 for (i = 0;i < numshadowentities;i++)
4346 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4347 for (i = 0;i < numshadowentities_noselfshadow;i++)
4348 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
4351 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
4353 // render shadow casters into 6 sided depth texture
4354 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
4356 R_Shadow_RenderMode_ShadowMap(side, receivermask, size);
4357 if (! (castermask & (1 << side))) continue;
4359 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
4360 for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
4361 R_Shadow_DrawEntityShadow(shadowentities[i]);
4364 if (numlightentities_noselfshadow)
4366 // render lighting using the depth texture as shadowmap
4367 // draw lighting in the unmasked areas
4368 R_Shadow_RenderMode_Lighting(false, false, true);
4369 for (i = 0;i < numlightentities_noselfshadow;i++)
4370 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4373 // render shadow casters into 6 sided depth texture
4374 if (numshadowentities_noselfshadow)
4376 for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
4378 R_Shadow_RenderMode_ShadowMap(side, 0, size);
4379 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
4380 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4384 // render lighting using the depth texture as shadowmap
4385 // draw lighting in the unmasked areas
4386 R_Shadow_RenderMode_Lighting(false, false, true);
4387 // draw lighting in the unmasked areas
4389 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4390 for (i = 0;i < numlightentities;i++)
4391 R_Shadow_DrawEntityLight(lightentities[i]);
4393 else if (castshadows && vid.stencil)
4395 // draw stencil shadow volumes to mask off pixels that are in shadow
4396 // so that they won't receive lighting
4397 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
4398 R_Shadow_ClearStencil();
4401 R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
4402 for (i = 0;i < numshadowentities;i++)
4403 R_Shadow_DrawEntityShadow(shadowentities[i]);
4405 // draw lighting in the unmasked areas
4406 R_Shadow_RenderMode_Lighting(true, false, false);
4407 for (i = 0;i < numlightentities_noselfshadow;i++)
4408 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4410 for (i = 0;i < numshadowentities_noselfshadow;i++)
4411 R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4413 // draw lighting in the unmasked areas
4414 R_Shadow_RenderMode_Lighting(true, false, false);
4416 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4417 for (i = 0;i < numlightentities;i++)
4418 R_Shadow_DrawEntityLight(lightentities[i]);
4422 // draw lighting in the unmasked areas
4423 R_Shadow_RenderMode_Lighting(false, false, false);
4425 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4426 for (i = 0;i < numlightentities;i++)
4427 R_Shadow_DrawEntityLight(lightentities[i]);
4428 for (i = 0;i < numlightentities_noselfshadow;i++)
4429 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4432 if (r_shadow_usingdeferredprepass)
4434 // when rendering deferred lighting, we simply rasterize the box
4435 if (castshadows && r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
4436 R_Shadow_RenderMode_DrawDeferredLight(false, true);
4437 else if (castshadows && vid.stencil)
4438 R_Shadow_RenderMode_DrawDeferredLight(true, false);
4440 R_Shadow_RenderMode_DrawDeferredLight(false, false);
4444 static void R_Shadow_FreeDeferred(void)
4446 R_Mesh_DestroyFramebufferObject(r_shadow_prepassgeometryfbo);
4447 r_shadow_prepassgeometryfbo = 0;
4449 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusespecularfbo);
4450 r_shadow_prepasslightingdiffusespecularfbo = 0;
4452 R_Mesh_DestroyFramebufferObject(r_shadow_prepasslightingdiffusefbo);
4453 r_shadow_prepasslightingdiffusefbo = 0;
4455 if (r_shadow_prepassgeometrydepthtexture)
4456 R_FreeTexture(r_shadow_prepassgeometrydepthtexture);
4457 r_shadow_prepassgeometrydepthtexture = NULL;
4459 if (r_shadow_prepassgeometrydepthcolortexture)
4460 R_FreeTexture(r_shadow_prepassgeometrydepthcolortexture);
4461 r_shadow_prepassgeometrydepthcolortexture = NULL;
4463 if (r_shadow_prepassgeometrynormalmaptexture)
4464 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4465 r_shadow_prepassgeometrynormalmaptexture = NULL;
4467 if (r_shadow_prepasslightingdiffusetexture)
4468 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4469 r_shadow_prepasslightingdiffusetexture = NULL;
4471 if (r_shadow_prepasslightingspeculartexture)
4472 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4473 r_shadow_prepasslightingspeculartexture = NULL;
4476 void R_Shadow_DrawPrepass(void)
4484 entity_render_t *ent;
4485 float clearcolor[4];
4487 R_Mesh_ResetTextureState();
4489 GL_ColorMask(1,1,1,1);
4490 GL_BlendFunc(GL_ONE, GL_ZERO);
4493 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
4494 Vector4Set(clearcolor, 0.5f,0.5f,0.5f,1.0f);
4495 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4496 if (r_timereport_active)
4497 R_TimeReport("prepasscleargeom");
4499 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4500 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4501 if (r_timereport_active)
4502 R_TimeReport("prepassworld");
4504 for (i = 0;i < r_refdef.scene.numentities;i++)
4506 if (!r_refdef.viewcache.entityvisible[i])
4508 ent = r_refdef.scene.entities[i];
4509 if (ent->model && ent->model->DrawPrepass != NULL)
4510 ent->model->DrawPrepass(ent);
4513 if (r_timereport_active)
4514 R_TimeReport("prepassmodels");
4516 GL_DepthMask(false);
4517 GL_ColorMask(1,1,1,1);
4520 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4521 Vector4Set(clearcolor, 0, 0, 0, 0);
4522 GL_Clear(GL_COLOR_BUFFER_BIT, clearcolor, 1.0f, 0);
4523 if (r_timereport_active)
4524 R_TimeReport("prepassclearlit");
4526 R_Shadow_RenderMode_Begin();
4528 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4529 if (r_shadow_debuglight.integer >= 0)
4531 lightindex = r_shadow_debuglight.integer;
4532 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4533 if (light && (light->flags & flag) && light->rtlight.draw)
4534 R_Shadow_DrawLight(&light->rtlight);
4538 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4539 for (lightindex = 0;lightindex < range;lightindex++)
4541 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4542 if (light && (light->flags & flag) && light->rtlight.draw)
4543 R_Shadow_DrawLight(&light->rtlight);
4546 if (r_refdef.scene.rtdlight)
4547 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4548 if (r_refdef.scene.lights[lnum]->draw)
4549 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4551 R_Mesh_SetMainRenderTargets();
4553 R_Shadow_RenderMode_End();
4555 if (r_timereport_active)
4556 R_TimeReport("prepasslights");
4559 void R_Shadow_DrawLightSprites(void);
4560 void R_Shadow_PrepareLights(void)
4570 if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4571 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
4572 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0 && vid.renderpath == RENDERPATH_GL20) ||
4573 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4574 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4575 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4576 R_Shadow_FreeShadowMaps();
4578 r_shadow_usingshadowmaportho = false;
4580 switch (vid.renderpath)
4582 case RENDERPATH_GL20:
4583 case RENDERPATH_D3D9:
4584 case RENDERPATH_D3D10:
4585 case RENDERPATH_D3D11:
4586 case RENDERPATH_SOFT:
4587 case RENDERPATH_GLES2:
4588 if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || vid.maxdrawbuffers < 2)
4590 r_shadow_usingdeferredprepass = false;
4591 if (r_shadow_prepass_width)
4592 R_Shadow_FreeDeferred();
4593 r_shadow_prepass_width = r_shadow_prepass_height = 0;
4597 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4599 R_Shadow_FreeDeferred();
4601 r_shadow_usingdeferredprepass = true;
4602 r_shadow_prepass_width = vid.width;
4603 r_shadow_prepass_height = vid.height;
4604 r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false);
4605 switch (vid.renderpath)
4607 case RENDERPATH_D3D9:
4608 r_shadow_prepassgeometrydepthcolortexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrydepthcolormap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4613 r_shadow_prepassgeometrynormalmaptexture = R_LoadTexture2D(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4614 r_shadow_prepasslightingdiffusetexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4615 r_shadow_prepasslightingspeculartexture = R_LoadTexture2D(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, -1, NULL);
4617 // set up the geometry pass fbo (depth + normalmap)
4618 r_shadow_prepassgeometryfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, NULL, NULL, NULL);
4619 R_Mesh_SetRenderTargets(r_shadow_prepassgeometryfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepassgeometrynormalmaptexture, r_shadow_prepassgeometrydepthcolortexture, NULL, NULL);
4620 // render depth into one texture and normalmap into the other
4621 if (qglDrawBuffersARB)
4623 qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
4624 qglReadBuffer(GL_NONE);CHECKGLERROR
4625 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4626 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4628 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4629 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4630 r_shadow_usingdeferredprepass = false;
4634 // set up the lighting pass fbo (diffuse + specular)
4635 r_shadow_prepasslightingdiffusespecularfbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4636 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusespecularfbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, r_shadow_prepasslightingspeculartexture, NULL, NULL);
4637 // render diffuse into one texture and specular into another,
4638 // with depth and normalmap bound as textures,
4639 // with depth bound as attachment as well
4640 if (qglDrawBuffersARB)
4642 qglDrawBuffersARB(2, r_shadow_prepasslightingdrawbuffers);CHECKGLERROR
4643 qglReadBuffer(GL_NONE);CHECKGLERROR
4644 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4645 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4647 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4648 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4649 r_shadow_usingdeferredprepass = false;
4653 // set up the lighting pass fbo (diffuse)
4654 r_shadow_prepasslightingdiffusefbo = R_Mesh_CreateFramebufferObject(r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4655 R_Mesh_SetRenderTargets(r_shadow_prepasslightingdiffusefbo, r_shadow_prepassgeometrydepthtexture, r_shadow_prepasslightingdiffusetexture, NULL, NULL, NULL);
4656 // render diffuse into one texture,
4657 // with depth and normalmap bound as textures,
4658 // with depth bound as attachment as well
4659 if (qglDrawBuffersARB)
4661 qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
4662 qglReadBuffer(GL_NONE);CHECKGLERROR
4663 status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4664 if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4666 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4667 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4668 r_shadow_usingdeferredprepass = false;
4673 case RENDERPATH_GL11:
4674 case RENDERPATH_GL13:
4675 case RENDERPATH_GLES1:
4676 r_shadow_usingdeferredprepass = false;
4680 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);
4682 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4683 if (r_shadow_debuglight.integer >= 0)
4685 lightindex = r_shadow_debuglight.integer;
4686 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4687 if (light && (light->flags & flag))
4688 R_Shadow_PrepareLight(&light->rtlight);
4692 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4693 for (lightindex = 0;lightindex < range;lightindex++)
4695 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4696 if (light && (light->flags & flag))
4697 R_Shadow_PrepareLight(&light->rtlight);
4700 if (r_refdef.scene.rtdlight)
4702 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4703 R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4705 else if(gl_flashblend.integer)
4707 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4709 rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4710 f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4711 VectorScale(rtlight->color, f, rtlight->currentcolor);
4715 if (r_editlights.integer)
4716 R_Shadow_DrawLightSprites();
4718 R_Shadow_UpdateBounceGridTexture();
4721 void R_Shadow_DrawLights(void)
4729 R_Shadow_RenderMode_Begin();
4731 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4732 if (r_shadow_debuglight.integer >= 0)
4734 lightindex = r_shadow_debuglight.integer;
4735 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4736 if (light && (light->flags & flag))
4737 R_Shadow_DrawLight(&light->rtlight);
4741 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4742 for (lightindex = 0;lightindex < range;lightindex++)
4744 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4745 if (light && (light->flags & flag))
4746 R_Shadow_DrawLight(&light->rtlight);
4749 if (r_refdef.scene.rtdlight)
4750 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4751 R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4753 R_Shadow_RenderMode_End();
4756 extern const float r_screenvertex3f[12];
4757 extern void R_SetupView(qboolean allowwaterclippingplane);
4758 extern void R_ResetViewRendering3D(void);
4759 extern void R_ResetViewRendering2D(void);
4760 extern cvar_t r_shadows;
4761 extern cvar_t r_shadows_darken;
4762 extern cvar_t r_shadows_drawafterrtlighting;
4763 extern cvar_t r_shadows_castfrombmodels;
4764 extern cvar_t r_shadows_throwdistance;
4765 extern cvar_t r_shadows_throwdirection;
4766 extern cvar_t r_shadows_focus;
4767 extern cvar_t r_shadows_shadowmapscale;
4769 void R_Shadow_PrepareModelShadows(void)
4772 float scale, size, radius, dot1, dot2;
4773 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus, shadowmins, shadowmaxs;
4774 entity_render_t *ent;
4776 if (!r_refdef.scene.numentities)
4779 switch (r_shadow_shadowmode)
4781 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4782 if (r_shadows.integer >= 2)
4785 case R_SHADOW_SHADOWMODE_STENCIL:
4786 for (i = 0;i < r_refdef.scene.numentities;i++)
4788 ent = r_refdef.scene.entities[i];
4789 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4790 R_AnimCache_GetEntity(ent, false, false);
4797 size = 2*r_shadow_shadowmapmaxsize;
4798 scale = r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value;
4799 radius = 0.5f * size / scale;
4801 Math_atov(r_shadows_throwdirection.string, shadowdir);
4802 VectorNormalize(shadowdir);
4803 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4804 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4805 if (fabs(dot1) <= fabs(dot2))
4806 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4808 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4809 VectorNormalize(shadowforward);
4810 CrossProduct(shadowdir, shadowforward, shadowright);
4811 Math_atov(r_shadows_focus.string, shadowfocus);
4812 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4813 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4814 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4815 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4816 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4818 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4820 shadowmins[0] = shadoworigin[0] - r_shadows_throwdistance.value * fabs(shadowdir[0]) - radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4821 shadowmins[1] = shadoworigin[1] - r_shadows_throwdistance.value * fabs(shadowdir[1]) - radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4822 shadowmins[2] = shadoworigin[2] - r_shadows_throwdistance.value * fabs(shadowdir[2]) - radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4823 shadowmaxs[0] = shadoworigin[0] + r_shadows_throwdistance.value * fabs(shadowdir[0]) + radius * (fabs(shadowforward[0]) + fabs(shadowright[0]));
4824 shadowmaxs[1] = shadoworigin[1] + r_shadows_throwdistance.value * fabs(shadowdir[1]) + radius * (fabs(shadowforward[1]) + fabs(shadowright[1]));
4825 shadowmaxs[2] = shadoworigin[2] + r_shadows_throwdistance.value * fabs(shadowdir[2]) + radius * (fabs(shadowforward[2]) + fabs(shadowright[2]));
4827 for (i = 0;i < r_refdef.scene.numentities;i++)
4829 ent = r_refdef.scene.entities[i];
4830 if (!BoxesOverlap(ent->mins, ent->maxs, shadowmins, shadowmaxs))
4832 // cast shadows from anything of the map (submodels are optional)
4833 if (!ent->animcache_vertex3f && ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4834 R_AnimCache_GetEntity(ent, false, false);
4838 void R_DrawModelShadowMaps(void)
4841 float relativethrowdistance, scale, size, radius, nearclip, farclip, bias, dot1, dot2;
4842 entity_render_t *ent;
4843 vec3_t relativelightorigin;
4844 vec3_t relativelightdirection, relativeforward, relativeright;
4845 vec3_t relativeshadowmins, relativeshadowmaxs;
4846 vec3_t shadowdir, shadowforward, shadowright, shadoworigin, shadowfocus;
4848 matrix4x4_t shadowmatrix, cameramatrix, mvpmatrix, invmvpmatrix, scalematrix, texmatrix;
4849 r_viewport_t viewport;
4851 float clearcolor[4];
4853 if (!r_refdef.scene.numentities)
4856 switch (r_shadow_shadowmode)
4858 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4864 R_ResetViewRendering3D();
4865 R_Shadow_RenderMode_Begin();
4866 R_Shadow_RenderMode_ActiveLight(NULL);
4868 switch (r_shadow_shadowmode)
4870 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
4871 if (!r_shadow_shadowmap2dtexture)
4872 R_Shadow_MakeShadowMap(0, r_shadow_shadowmapmaxsize);
4873 fbo = r_shadow_fbo2d;
4874 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
4875 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
4876 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
4882 size = 2*r_shadow_shadowmapmaxsize;
4883 scale = (r_shadow_shadowmapping_precision.value * r_shadows_shadowmapscale.value) / size;
4884 radius = 0.5f / scale;
4885 nearclip = -r_shadows_throwdistance.value;
4886 farclip = r_shadows_throwdistance.value;
4887 bias = r_shadow_shadowmapping_bias.value * r_shadow_shadowmapping_nearclip.value / (2 * r_shadows_throwdistance.value) * (1024.0f / size);
4889 r_shadow_shadowmap_parameters[0] = size;
4890 r_shadow_shadowmap_parameters[1] = size;
4891 r_shadow_shadowmap_parameters[2] = 1.0;
4892 r_shadow_shadowmap_parameters[3] = bound(0.0f, 1.0f - r_shadows_darken.value, 1.0f);
4894 Math_atov(r_shadows_throwdirection.string, shadowdir);
4895 VectorNormalize(shadowdir);
4896 Math_atov(r_shadows_focus.string, shadowfocus);
4897 VectorM(shadowfocus[0], r_refdef.view.right, shadoworigin);
4898 VectorMA(shadoworigin, shadowfocus[1], r_refdef.view.up, shadoworigin);
4899 VectorMA(shadoworigin, -shadowfocus[2], r_refdef.view.forward, shadoworigin);
4900 VectorAdd(shadoworigin, r_refdef.view.origin, shadoworigin);
4901 dot1 = DotProduct(r_refdef.view.forward, shadowdir);
4902 dot2 = DotProduct(r_refdef.view.up, shadowdir);
4903 if (fabs(dot1) <= fabs(dot2))
4904 VectorMA(r_refdef.view.forward, -dot1, shadowdir, shadowforward);
4906 VectorMA(r_refdef.view.up, -dot2, shadowdir, shadowforward);
4907 VectorNormalize(shadowforward);
4908 VectorM(scale, shadowforward, &m[0]);
4909 if (shadowfocus[0] || shadowfocus[1] || shadowfocus[2])
4911 m[3] = fabs(dot1) * 0.5f - DotProduct(shadoworigin, &m[0]);
4912 CrossProduct(shadowdir, shadowforward, shadowright);
4913 VectorM(scale, shadowright, &m[4]);
4914 m[7] = 0.5f - DotProduct(shadoworigin, &m[4]);
4915 VectorM(1.0f / (farclip - nearclip), shadowdir, &m[8]);
4916 m[11] = 0.5f - DotProduct(shadoworigin, &m[8]);
4917 Matrix4x4_FromArray12FloatD3D(&shadowmatrix, m);
4918 Matrix4x4_Invert_Full(&cameramatrix, &shadowmatrix);
4919 R_Viewport_InitOrtho(&viewport, &cameramatrix, 0, 0, size, size, 0, 0, 1, 1, 0, -1, NULL);
4921 VectorMA(shadoworigin, (1.0f - fabs(dot1)) * radius, shadowforward, shadoworigin);
4923 R_Mesh_SetRenderTargets(fbo, r_shadow_shadowmap2dtexture, r_shadow_shadowmap2dcolortexture, NULL, NULL, NULL);
4924 R_SetupShader_DepthOrShadow(true);
4925 GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
4928 R_SetViewport(&viewport);
4929 GL_Scissor(viewport.x, viewport.y, min(viewport.width + r_shadow_shadowmapborder, 2*r_shadow_shadowmapmaxsize), viewport.height + r_shadow_shadowmapborder);
4930 Vector4Set(clearcolor, 1,1,1,1);
4931 // in D3D9 we have to render to a color texture shadowmap
4932 // in GL we render directly to a depth texture only
4933 if (r_shadow_shadowmap2dtexture)
4934 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4936 GL_Clear(GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4937 // render into a slightly restricted region so that the borders of the
4938 // shadowmap area fade away, rather than streaking across everything
4939 // outside the usable area
4940 GL_Scissor(viewport.x + r_shadow_shadowmapborder, viewport.y + r_shadow_shadowmapborder, viewport.width - 2*r_shadow_shadowmapborder, viewport.height - 2*r_shadow_shadowmapborder);
4944 R_Mesh_SetMainRenderTargets();
4945 R_SetupShader_ShowDepth(true);
4946 GL_ColorMask(1,1,1,1);
4947 GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, clearcolor, 1.0f, 0);
4950 for (i = 0;i < r_refdef.scene.numentities;i++)
4952 ent = r_refdef.scene.entities[i];
4954 // cast shadows from anything of the map (submodels are optional)
4955 if (ent->model && ent->model->DrawShadowMap != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4957 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4958 Matrix4x4_Transform(&ent->inversematrix, shadoworigin, relativelightorigin);
4959 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4960 Matrix4x4_Transform3x3(&ent->inversematrix, shadowforward, relativeforward);
4961 Matrix4x4_Transform3x3(&ent->inversematrix, shadowright, relativeright);
4962 relativeshadowmins[0] = relativelightorigin[0] - r_shadows_throwdistance.value * fabs(relativelightdirection[0]) - radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4963 relativeshadowmins[1] = relativelightorigin[1] - r_shadows_throwdistance.value * fabs(relativelightdirection[1]) - radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4964 relativeshadowmins[2] = relativelightorigin[2] - r_shadows_throwdistance.value * fabs(relativelightdirection[2]) - radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4965 relativeshadowmaxs[0] = relativelightorigin[0] + r_shadows_throwdistance.value * fabs(relativelightdirection[0]) + radius * (fabs(relativeforward[0]) + fabs(relativeright[0]));
4966 relativeshadowmaxs[1] = relativelightorigin[1] + r_shadows_throwdistance.value * fabs(relativelightdirection[1]) + radius * (fabs(relativeforward[1]) + fabs(relativeright[1]));
4967 relativeshadowmaxs[2] = relativelightorigin[2] + r_shadows_throwdistance.value * fabs(relativelightdirection[2]) + radius * (fabs(relativeforward[2]) + fabs(relativeright[2]));
4968 RSurf_ActiveModelEntity(ent, false, false, false);
4969 ent->model->DrawShadowMap(0, ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
4970 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4977 unsigned char *rawpixels = Z_Malloc(viewport.width*viewport.height*4);
4979 qglReadPixels(viewport.x, viewport.y, viewport.width, viewport.height, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, rawpixels);
4981 Image_WriteTGABGRA("r_shadows_2.tga", viewport.width, viewport.height, rawpixels);
4982 Cvar_SetValueQuick(&r_test, 0);
4987 R_Shadow_RenderMode_End();
4989 Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
4990 Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
4991 Matrix4x4_CreateScale3(&scalematrix, size, -size, 1);
4992 Matrix4x4_AdjustOrigin(&scalematrix, 0, size, -0.5f * bias);
4993 Matrix4x4_Concat(&texmatrix, &scalematrix, &shadowmatrix);
4994 Matrix4x4_Concat(&r_shadow_shadowmapmatrix, &texmatrix, &invmvpmatrix);
4996 switch (vid.renderpath)
4998 case RENDERPATH_GL11:
4999 case RENDERPATH_GL13:
5000 case RENDERPATH_GL20:
5001 case RENDERPATH_SOFT:
5002 case RENDERPATH_GLES1:
5003 case RENDERPATH_GLES2:
5005 case RENDERPATH_D3D9:
5006 case RENDERPATH_D3D10:
5007 case RENDERPATH_D3D11:
5008 #ifdef OPENGL_ORIENTATION
5009 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
5010 r_shadow_shadowmapmatrix.m[0][1] *= -1.0f;
5011 r_shadow_shadowmapmatrix.m[0][2] *= -1.0f;
5012 r_shadow_shadowmapmatrix.m[0][3] *= -1.0f;
5014 r_shadow_shadowmapmatrix.m[0][0] *= -1.0f;
5015 r_shadow_shadowmapmatrix.m[1][0] *= -1.0f;
5016 r_shadow_shadowmapmatrix.m[2][0] *= -1.0f;
5017 r_shadow_shadowmapmatrix.m[3][0] *= -1.0f;
5022 r_shadow_usingshadowmaportho = true;
5023 switch (r_shadow_shadowmode)
5025 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
5026 r_shadow_usingshadowmap2d = true;
5033 void R_DrawModelShadows(void)
5036 float relativethrowdistance;
5037 entity_render_t *ent;
5038 vec3_t relativelightorigin;
5039 vec3_t relativelightdirection;
5040 vec3_t relativeshadowmins, relativeshadowmaxs;
5041 vec3_t tmp, shadowdir;
5043 if (!r_refdef.scene.numentities || !vid.stencil || (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL && r_shadows.integer != 1))
5046 R_ResetViewRendering3D();
5047 //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5048 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
5049 R_Shadow_RenderMode_Begin();
5050 R_Shadow_RenderMode_ActiveLight(NULL);
5051 r_shadow_lightscissor[0] = r_refdef.view.x;
5052 r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
5053 r_shadow_lightscissor[2] = r_refdef.view.width;
5054 r_shadow_lightscissor[3] = r_refdef.view.height;
5055 R_Shadow_RenderMode_StencilShadowVolumes(false);
5058 if (r_shadows.integer == 2)
5060 Math_atov(r_shadows_throwdirection.string, shadowdir);
5061 VectorNormalize(shadowdir);
5064 R_Shadow_ClearStencil();
5066 for (i = 0;i < r_refdef.scene.numentities;i++)
5068 ent = r_refdef.scene.entities[i];
5070 // cast shadows from anything of the map (submodels are optional)
5071 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
5073 relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
5074 VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
5075 VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
5076 if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
5077 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
5080 if(ent->entitynumber != 0)
5082 if(ent->entitynumber >= MAX_EDICTS) // csqc entity
5084 // FIXME handle this
5085 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5089 // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
5090 int entnum, entnum2, recursion;
5091 entnum = entnum2 = ent->entitynumber;
5092 for(recursion = 32; recursion > 0; --recursion)
5094 entnum2 = cl.entities[entnum].state_current.tagentity;
5095 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
5100 if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
5102 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
5103 // transform into modelspace of OUR entity
5104 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
5105 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
5108 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5112 VectorNegate(ent->modellight_lightdir, relativelightdirection);
5115 VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
5116 RSurf_ActiveModelEntity(ent, false, false, false);
5117 ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
5118 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
5122 // not really the right mode, but this will disable any silly stencil features
5123 R_Shadow_RenderMode_End();
5125 // set up ortho view for rendering this pass
5126 //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
5127 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5128 //GL_ScissorTest(true);
5129 //R_EntityMatrix(&identitymatrix);
5130 //R_Mesh_ResetTextureState();
5131 R_ResetViewRendering2D();
5133 // set up a darkening blend on shadowed areas
5134 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
5135 //GL_DepthRange(0, 1);
5136 //GL_DepthTest(false);
5137 //GL_DepthMask(false);
5138 //GL_PolygonOffset(0, 0);CHECKGLERROR
5139 GL_Color(0, 0, 0, r_shadows_darken.value);
5140 //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5141 //GL_DepthFunc(GL_ALWAYS);
5142 R_SetStencil(true, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_NOTEQUAL, 128, 255);
5144 // apply the blend to the shadowed areas
5145 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
5146 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1, true);
5147 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5149 // restore the viewport
5150 R_SetViewport(&r_refdef.view.viewport);
5152 // restore other state to normal
5153 //R_Shadow_RenderMode_End();
5156 void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
5159 vec3_t centerorigin;
5161 // if it's too close, skip it
5162 if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
5164 zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
5167 if (usequery && r_numqueries + 2 <= r_maxqueries)
5169 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
5170 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
5171 // 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
5172 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
5174 switch(vid.renderpath)
5176 case RENDERPATH_GL11:
5177 case RENDERPATH_GL13:
5178 case RENDERPATH_GL20:
5179 case RENDERPATH_GLES1:
5180 case RENDERPATH_GLES2:
5182 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use GL_DepthFunc instead
5183 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
5184 GL_DepthFunc(GL_ALWAYS);
5185 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5186 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5187 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5188 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5189 GL_DepthFunc(GL_LEQUAL);
5190 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
5191 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5192 R_Mesh_PrepareVertices_Vertex3f(4, vertex3f, NULL);
5193 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
5194 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
5197 case RENDERPATH_D3D9:
5198 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5200 case RENDERPATH_D3D10:
5201 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5203 case RENDERPATH_D3D11:
5204 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5206 case RENDERPATH_SOFT:
5207 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5211 rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
5214 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
5216 void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
5219 GLint allpixels = 0, visiblepixels = 0;
5220 // now we have to check the query result
5221 if (rtlight->corona_queryindex_visiblepixels)
5223 switch(vid.renderpath)
5225 case RENDERPATH_GL11:
5226 case RENDERPATH_GL13:
5227 case RENDERPATH_GL20:
5228 case RENDERPATH_GLES1:
5229 case RENDERPATH_GLES2:
5231 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
5232 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
5235 case RENDERPATH_D3D9:
5236 Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5238 case RENDERPATH_D3D10:
5239 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5241 case RENDERPATH_D3D11:
5242 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5244 case RENDERPATH_SOFT:
5245 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5248 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
5249 if (visiblepixels < 1 || allpixels < 1)
5251 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
5252 cscale *= rtlight->corona_visibility;
5256 // FIXME: these traces should scan all render entities instead of cl.world
5257 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
5260 VectorScale(rtlight->currentcolor, cscale, color);
5261 if (VectorLength(color) > (1.0f / 256.0f))
5264 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
5267 VectorNegate(color, color);
5268 switch(vid.renderpath)
5270 case RENDERPATH_GL11:
5271 case RENDERPATH_GL13:
5272 case RENDERPATH_GL20:
5273 case RENDERPATH_GLES1:
5274 case RENDERPATH_GLES2:
5275 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
5277 case RENDERPATH_D3D9:
5279 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_SUBTRACT);
5282 case RENDERPATH_D3D10:
5283 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5285 case RENDERPATH_D3D11:
5286 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5288 case RENDERPATH_SOFT:
5289 DPSOFTRAST_BlendSubtract(true);
5293 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
5294 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);
5295 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5298 switch(vid.renderpath)
5300 case RENDERPATH_GL11:
5301 case RENDERPATH_GL13:
5302 case RENDERPATH_GL20:
5303 case RENDERPATH_GLES1:
5304 case RENDERPATH_GLES2:
5305 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
5307 case RENDERPATH_D3D9:
5309 IDirect3DDevice9_SetRenderState(vid_d3d9dev, D3DRS_BLENDOP, D3DBLENDOP_ADD);
5312 case RENDERPATH_D3D10:
5313 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5315 case RENDERPATH_D3D11:
5316 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5318 case RENDERPATH_SOFT:
5319 DPSOFTRAST_BlendSubtract(false);
5326 void R_Shadow_DrawCoronas(void)
5329 qboolean usequery = false;
5334 if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
5336 if (r_waterstate.renderingscene)
5338 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
5339 R_EntityMatrix(&identitymatrix);
5341 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5343 // check occlusion of coronas
5344 // use GL_ARB_occlusion_query if available
5345 // otherwise use raytraces
5347 switch (vid.renderpath)
5349 case RENDERPATH_GL11:
5350 case RENDERPATH_GL13:
5351 case RENDERPATH_GL20:
5352 case RENDERPATH_GLES1:
5353 case RENDERPATH_GLES2:
5354 usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
5357 GL_ColorMask(0,0,0,0);
5358 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
5359 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
5362 r_maxqueries = (range + r_refdef.scene.numlights) * 4;
5363 r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
5365 qglGenQueriesARB(r_maxqueries - i, r_queries + i);
5368 RSurf_ActiveWorldEntity();
5369 GL_BlendFunc(GL_ONE, GL_ZERO);
5370 GL_CullFace(GL_NONE);
5371 GL_DepthMask(false);
5372 GL_DepthRange(0, 1);
5373 GL_PolygonOffset(0, 0);
5375 R_Mesh_ResetTextureState();
5376 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1, false);
5379 case RENDERPATH_D3D9:
5381 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5383 case RENDERPATH_D3D10:
5384 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5386 case RENDERPATH_D3D11:
5387 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5389 case RENDERPATH_SOFT:
5391 //Con_DPrintf("FIXME SOFT %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
5394 for (lightindex = 0;lightindex < range;lightindex++)
5396 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5399 rtlight = &light->rtlight;
5400 rtlight->corona_visibility = 0;
5401 rtlight->corona_queryindex_visiblepixels = 0;
5402 rtlight->corona_queryindex_allpixels = 0;
5403 if (!(rtlight->flags & flag))
5405 if (rtlight->corona <= 0)
5407 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
5409 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5411 for (i = 0;i < r_refdef.scene.numlights;i++)
5413 rtlight = r_refdef.scene.lights[i];
5414 rtlight->corona_visibility = 0;
5415 rtlight->corona_queryindex_visiblepixels = 0;
5416 rtlight->corona_queryindex_allpixels = 0;
5417 if (!(rtlight->flags & flag))
5419 if (rtlight->corona <= 0)
5421 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
5424 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5426 // now draw the coronas using the query data for intensity info
5427 for (lightindex = 0;lightindex < range;lightindex++)
5429 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5432 rtlight = &light->rtlight;
5433 if (rtlight->corona_visibility <= 0)
5435 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5437 for (i = 0;i < r_refdef.scene.numlights;i++)
5439 rtlight = r_refdef.scene.lights[i];
5440 if (rtlight->corona_visibility <= 0)
5442 if (gl_flashblend.integer)
5443 R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
5445 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
5451 dlight_t *R_Shadow_NewWorldLight(void)
5453 return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
5456 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)
5459 // validate parameters
5460 if (style < 0 || style >= MAX_LIGHTSTYLES)
5462 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
5468 // copy to light properties
5469 VectorCopy(origin, light->origin);
5470 light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
5471 light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
5472 light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
5474 light->color[0] = max(color[0], 0);
5475 light->color[1] = max(color[1], 0);
5476 light->color[2] = max(color[2], 0);
5478 light->color[0] = color[0];
5479 light->color[1] = color[1];
5480 light->color[2] = color[2];
5481 light->radius = max(radius, 0);
5482 light->style = style;
5483 light->shadow = shadowenable;
5484 light->corona = corona;
5485 strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
5486 light->coronasizescale = coronasizescale;
5487 light->ambientscale = ambientscale;
5488 light->diffusescale = diffusescale;
5489 light->specularscale = specularscale;
5490 light->flags = flags;
5492 // update renderable light data
5493 Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
5494 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);
5497 void R_Shadow_FreeWorldLight(dlight_t *light)
5499 if (r_shadow_selectedlight == light)
5500 r_shadow_selectedlight = NULL;
5501 R_RTLight_Uncompile(&light->rtlight);
5502 Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
5505 void R_Shadow_ClearWorldLights(void)
5509 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5510 for (lightindex = 0;lightindex < range;lightindex++)
5512 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5514 R_Shadow_FreeWorldLight(light);
5516 r_shadow_selectedlight = NULL;
5519 void R_Shadow_SelectLight(dlight_t *light)
5521 if (r_shadow_selectedlight)
5522 r_shadow_selectedlight->selected = false;
5523 r_shadow_selectedlight = light;
5524 if (r_shadow_selectedlight)
5525 r_shadow_selectedlight->selected = true;
5528 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5530 // this is never batched (there can be only one)
5532 R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
5533 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5534 R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5537 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
5542 skinframe_t *skinframe;
5545 // this is never batched (due to the ent parameter changing every time)
5546 // so numsurfaces == 1 and surfacelist[0] == lightnumber
5547 const dlight_t *light = (dlight_t *)ent;
5550 R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
5553 VectorScale(light->color, intensity, spritecolor);
5554 if (VectorLength(spritecolor) < 0.1732f)
5555 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
5556 if (VectorLength(spritecolor) > 1.0f)
5557 VectorNormalize(spritecolor);
5559 // draw light sprite
5560 if (light->cubemapname[0] && !light->shadow)
5561 skinframe = r_editlights_sprcubemapnoshadowlight;
5562 else if (light->cubemapname[0])
5563 skinframe = r_editlights_sprcubemaplight;
5564 else if (!light->shadow)
5565 skinframe = r_editlights_sprnoshadowlight;
5567 skinframe = r_editlights_sprlight;
5569 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);
5570 R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5572 // draw selection sprite if light is selected
5573 if (light->selected)
5575 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
5576 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
5577 // VorteX todo: add normalmode/realtime mode light overlay sprites?
5581 void R_Shadow_DrawLightSprites(void)
5585 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5586 for (lightindex = 0;lightindex < range;lightindex++)
5588 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5590 R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
5592 if (!r_editlights_lockcursor)
5593 R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
5596 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
5601 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
5602 if (lightindex >= range)
5604 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5607 rtlight = &light->rtlight;
5608 //if (!(rtlight->flags & flag))
5610 VectorCopy(rtlight->shadoworigin, origin);
5611 *radius = rtlight->radius;
5612 VectorCopy(rtlight->color, color);
5616 void R_Shadow_SelectLightInView(void)
5618 float bestrating, rating, temp[3];
5622 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5626 if (r_editlights_lockcursor)
5628 for (lightindex = 0;lightindex < range;lightindex++)
5630 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5633 VectorSubtract(light->origin, r_refdef.view.origin, temp);
5634 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
5637 rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
5638 if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1.0f)
5640 bestrating = rating;
5645 R_Shadow_SelectLight(best);
5648 void R_Shadow_LoadWorldLights(void)
5650 int n, a, style, shadow, flags;
5651 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
5652 float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
5653 if (cl.worldmodel == NULL)
5655 Con_Print("No map loaded.\n");
5658 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5659 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5669 for (;COM_Parse(t, true) && strcmp(
5670 if (COM_Parse(t, true))
5672 if (com_token[0] == '!')
5675 origin[0] = atof(com_token+1);
5678 origin[0] = atof(com_token);
5683 while (*s && *s != '\n' && *s != '\r')
5689 // check for modifier flags
5696 #if _MSC_VER >= 1400
5697 #define sscanf sscanf_s
5699 cubemapname[sizeof(cubemapname)-1] = 0;
5700 #if MAX_QPATH != 128
5701 #error update this code if MAX_QPATH changes
5703 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
5704 #if _MSC_VER >= 1400
5705 , sizeof(cubemapname)
5707 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
5710 flags = LIGHTFLAG_REALTIMEMODE;
5718 coronasizescale = 0.25f;
5720 VectorClear(angles);
5723 if (a < 9 || !strcmp(cubemapname, "\"\""))
5725 // remove quotes on cubemapname
5726 if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
5729 namelen = strlen(cubemapname) - 2;
5730 memmove(cubemapname, cubemapname + 1, namelen);
5731 cubemapname[namelen] = '\0';
5735 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);
5738 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5746 Con_Printf("invalid rtlights file \"%s\"\n", name);
5747 Mem_Free(lightsstring);
5751 void R_Shadow_SaveWorldLights(void)
5755 size_t bufchars, bufmaxchars;
5757 char name[MAX_QPATH];
5758 char line[MAX_INPUTLINE];
5759 size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5760 // I hate lines which are 3 times my screen size :( --blub
5763 if (cl.worldmodel == NULL)
5765 Con_Print("No map loaded.\n");
5768 dpsnprintf(name, sizeof(name), "%s.rtlights", cl.worldnamenoextension);
5769 bufchars = bufmaxchars = 0;
5771 for (lightindex = 0;lightindex < range;lightindex++)
5773 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5776 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5777 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);
5778 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5779 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]);
5781 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);
5782 if (bufchars + strlen(line) > bufmaxchars)
5784 bufmaxchars = bufchars + strlen(line) + 2048;
5786 buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5790 memcpy(buf, oldbuf, bufchars);
5796 memcpy(buf + bufchars, line, strlen(line));
5797 bufchars += strlen(line);
5801 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5806 void R_Shadow_LoadLightsFile(void)
5809 char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5810 float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5811 if (cl.worldmodel == NULL)
5813 Con_Print("No map loaded.\n");
5816 dpsnprintf(name, sizeof(name), "%s.lights", cl.worldnamenoextension);
5817 lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5825 while (*s && *s != '\n' && *s != '\r')
5831 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);
5835 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);
5838 radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5839 radius = bound(15, radius, 4096);
5840 VectorScale(color, (2.0f / (8388608.0f)), color);
5841 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5849 Con_Printf("invalid lights file \"%s\"\n", name);
5850 Mem_Free(lightsstring);
5854 // tyrlite/hmap2 light types in the delay field
5855 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5857 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5869 float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5870 char key[256], value[MAX_INPUTLINE];
5872 if (cl.worldmodel == NULL)
5874 Con_Print("No map loaded.\n");
5877 // try to load a .ent file first
5878 dpsnprintf(key, sizeof(key), "%s.ent", cl.worldnamenoextension);
5879 data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5880 // and if that is not found, fall back to the bsp file entity string
5882 data = cl.worldmodel->brush.entities;
5885 for (entnum = 0;COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{';entnum++)
5887 type = LIGHTTYPE_MINUSX;
5888 origin[0] = origin[1] = origin[2] = 0;
5889 originhack[0] = originhack[1] = originhack[2] = 0;
5890 angles[0] = angles[1] = angles[2] = 0;
5891 color[0] = color[1] = color[2] = 1;
5892 light[0] = light[1] = light[2] = 1;light[3] = 300;
5893 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5903 if (!COM_ParseToken_Simple(&data, false, false))
5905 if (com_token[0] == '}')
5906 break; // end of entity
5907 if (com_token[0] == '_')
5908 strlcpy(key, com_token + 1, sizeof(key));
5910 strlcpy(key, com_token, sizeof(key));
5911 while (key[strlen(key)-1] == ' ') // remove trailing spaces
5912 key[strlen(key)-1] = 0;
5913 if (!COM_ParseToken_Simple(&data, false, false))
5915 strlcpy(value, com_token, sizeof(value));
5917 // now that we have the key pair worked out...
5918 if (!strcmp("light", key))
5920 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5924 light[0] = vec[0] * (1.0f / 256.0f);
5925 light[1] = vec[0] * (1.0f / 256.0f);
5926 light[2] = vec[0] * (1.0f / 256.0f);
5932 light[0] = vec[0] * (1.0f / 255.0f);
5933 light[1] = vec[1] * (1.0f / 255.0f);
5934 light[2] = vec[2] * (1.0f / 255.0f);
5938 else if (!strcmp("delay", key))
5940 else if (!strcmp("origin", key))
5941 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5942 else if (!strcmp("angle", key))
5943 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5944 else if (!strcmp("angles", key))
5945 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5946 else if (!strcmp("color", key))
5947 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5948 else if (!strcmp("wait", key))
5949 fadescale = atof(value);
5950 else if (!strcmp("classname", key))
5952 if (!strncmp(value, "light", 5))
5955 if (!strcmp(value, "light_fluoro"))
5960 overridecolor[0] = 1;
5961 overridecolor[1] = 1;
5962 overridecolor[2] = 1;
5964 if (!strcmp(value, "light_fluorospark"))
5969 overridecolor[0] = 1;
5970 overridecolor[1] = 1;
5971 overridecolor[2] = 1;
5973 if (!strcmp(value, "light_globe"))
5978 overridecolor[0] = 1;
5979 overridecolor[1] = 0.8;
5980 overridecolor[2] = 0.4;
5982 if (!strcmp(value, "light_flame_large_yellow"))
5987 overridecolor[0] = 1;
5988 overridecolor[1] = 0.5;
5989 overridecolor[2] = 0.1;
5991 if (!strcmp(value, "light_flame_small_yellow"))
5996 overridecolor[0] = 1;
5997 overridecolor[1] = 0.5;
5998 overridecolor[2] = 0.1;
6000 if (!strcmp(value, "light_torch_small_white"))
6005 overridecolor[0] = 1;
6006 overridecolor[1] = 0.5;
6007 overridecolor[2] = 0.1;
6009 if (!strcmp(value, "light_torch_small_walltorch"))
6014 overridecolor[0] = 1;
6015 overridecolor[1] = 0.5;
6016 overridecolor[2] = 0.1;
6020 else if (!strcmp("style", key))
6021 style = atoi(value);
6022 else if (!strcmp("skin", key))
6023 skin = (int)atof(value);
6024 else if (!strcmp("pflags", key))
6025 pflags = (int)atof(value);
6026 //else if (!strcmp("effects", key))
6027 // effects = (int)atof(value);
6028 else if (cl.worldmodel->type == mod_brushq3)
6030 if (!strcmp("scale", key))
6031 lightscale = atof(value);
6032 if (!strcmp("fade", key))
6033 fadescale = atof(value);
6038 if (lightscale <= 0)
6042 if (color[0] == color[1] && color[0] == color[2])
6044 color[0] *= overridecolor[0];
6045 color[1] *= overridecolor[1];
6046 color[2] *= overridecolor[2];
6048 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
6049 color[0] = color[0] * light[0];
6050 color[1] = color[1] * light[1];
6051 color[2] = color[2] * light[2];
6054 case LIGHTTYPE_MINUSX:
6056 case LIGHTTYPE_RECIPX:
6058 VectorScale(color, (1.0f / 16.0f), color);
6060 case LIGHTTYPE_RECIPXX:
6062 VectorScale(color, (1.0f / 16.0f), color);
6065 case LIGHTTYPE_NONE:
6069 case LIGHTTYPE_MINUSXX:
6072 VectorAdd(origin, originhack, origin);
6074 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, (pflags & PFLAGS_CORONA) != 0, style, (pflags & PFLAGS_NOSHADOW) == 0, skin >= 16 ? va("cubemaps/%i", skin) : NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
6077 Mem_Free(entfiledata);
6081 void R_Shadow_SetCursorLocationForView(void)
6084 vec3_t dest, endpos;
6086 VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
6087 trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true);
6088 if (trace.fraction < 1)
6090 dist = trace.fraction * r_editlights_cursordistance.value;
6091 push = r_editlights_cursorpushback.value;
6095 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
6096 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
6100 VectorClear( endpos );
6102 r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6103 r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6104 r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
6107 void R_Shadow_UpdateWorldLightSelection(void)
6109 if (r_editlights.integer)
6111 R_Shadow_SetCursorLocationForView();
6112 R_Shadow_SelectLightInView();
6115 R_Shadow_SelectLight(NULL);
6118 void R_Shadow_EditLights_Clear_f(void)
6120 R_Shadow_ClearWorldLights();
6123 void R_Shadow_EditLights_Reload_f(void)
6127 strlcpy(r_shadow_mapname, cl.worldname, sizeof(r_shadow_mapname));
6128 R_Shadow_ClearWorldLights();
6129 R_Shadow_LoadWorldLights();
6130 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
6132 R_Shadow_LoadLightsFile();
6133 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
6134 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
6138 void R_Shadow_EditLights_Save_f(void)
6142 R_Shadow_SaveWorldLights();
6145 void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
6147 R_Shadow_ClearWorldLights();
6148 R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
6151 void R_Shadow_EditLights_ImportLightsFile_f(void)
6153 R_Shadow_ClearWorldLights();
6154 R_Shadow_LoadLightsFile();
6157 void R_Shadow_EditLights_Spawn_f(void)
6160 if (!r_editlights.integer)
6162 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6165 if (Cmd_Argc() != 1)
6167 Con_Print("r_editlights_spawn does not take parameters\n");
6170 color[0] = color[1] = color[2] = 1;
6171 R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
6174 void R_Shadow_EditLights_Edit_f(void)
6176 vec3_t origin, angles, color;
6177 vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
6178 int style, shadows, flags, normalmode, realtimemode;
6179 char cubemapname[MAX_INPUTLINE];
6180 if (!r_editlights.integer)
6182 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6185 if (!r_shadow_selectedlight)
6187 Con_Print("No selected light.\n");
6190 VectorCopy(r_shadow_selectedlight->origin, origin);
6191 VectorCopy(r_shadow_selectedlight->angles, angles);
6192 VectorCopy(r_shadow_selectedlight->color, color);
6193 radius = r_shadow_selectedlight->radius;
6194 style = r_shadow_selectedlight->style;
6195 if (r_shadow_selectedlight->cubemapname)
6196 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
6199 shadows = r_shadow_selectedlight->shadow;
6200 corona = r_shadow_selectedlight->corona;
6201 coronasizescale = r_shadow_selectedlight->coronasizescale;
6202 ambientscale = r_shadow_selectedlight->ambientscale;
6203 diffusescale = r_shadow_selectedlight->diffusescale;
6204 specularscale = r_shadow_selectedlight->specularscale;
6205 flags = r_shadow_selectedlight->flags;
6206 normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
6207 realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
6208 if (!strcmp(Cmd_Argv(1), "origin"))
6210 if (Cmd_Argc() != 5)
6212 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6215 origin[0] = atof(Cmd_Argv(2));
6216 origin[1] = atof(Cmd_Argv(3));
6217 origin[2] = atof(Cmd_Argv(4));
6219 else if (!strcmp(Cmd_Argv(1), "originscale"))
6221 if (Cmd_Argc() != 5)
6223 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6226 origin[0] *= atof(Cmd_Argv(2));
6227 origin[1] *= atof(Cmd_Argv(3));
6228 origin[2] *= atof(Cmd_Argv(4));
6230 else if (!strcmp(Cmd_Argv(1), "originx"))
6232 if (Cmd_Argc() != 3)
6234 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6237 origin[0] = atof(Cmd_Argv(2));
6239 else if (!strcmp(Cmd_Argv(1), "originy"))
6241 if (Cmd_Argc() != 3)
6243 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6246 origin[1] = atof(Cmd_Argv(2));
6248 else if (!strcmp(Cmd_Argv(1), "originz"))
6250 if (Cmd_Argc() != 3)
6252 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6255 origin[2] = atof(Cmd_Argv(2));
6257 else if (!strcmp(Cmd_Argv(1), "move"))
6259 if (Cmd_Argc() != 5)
6261 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6264 origin[0] += atof(Cmd_Argv(2));
6265 origin[1] += atof(Cmd_Argv(3));
6266 origin[2] += atof(Cmd_Argv(4));
6268 else if (!strcmp(Cmd_Argv(1), "movex"))
6270 if (Cmd_Argc() != 3)
6272 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6275 origin[0] += atof(Cmd_Argv(2));
6277 else if (!strcmp(Cmd_Argv(1), "movey"))
6279 if (Cmd_Argc() != 3)
6281 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6284 origin[1] += atof(Cmd_Argv(2));
6286 else if (!strcmp(Cmd_Argv(1), "movez"))
6288 if (Cmd_Argc() != 3)
6290 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6293 origin[2] += atof(Cmd_Argv(2));
6295 else if (!strcmp(Cmd_Argv(1), "angles"))
6297 if (Cmd_Argc() != 5)
6299 Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
6302 angles[0] = atof(Cmd_Argv(2));
6303 angles[1] = atof(Cmd_Argv(3));
6304 angles[2] = atof(Cmd_Argv(4));
6306 else if (!strcmp(Cmd_Argv(1), "anglesx"))
6308 if (Cmd_Argc() != 3)
6310 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6313 angles[0] = atof(Cmd_Argv(2));
6315 else if (!strcmp(Cmd_Argv(1), "anglesy"))
6317 if (Cmd_Argc() != 3)
6319 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6322 angles[1] = atof(Cmd_Argv(2));
6324 else if (!strcmp(Cmd_Argv(1), "anglesz"))
6326 if (Cmd_Argc() != 3)
6328 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6331 angles[2] = atof(Cmd_Argv(2));
6333 else if (!strcmp(Cmd_Argv(1), "color"))
6335 if (Cmd_Argc() != 5)
6337 Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
6340 color[0] = atof(Cmd_Argv(2));
6341 color[1] = atof(Cmd_Argv(3));
6342 color[2] = atof(Cmd_Argv(4));
6344 else if (!strcmp(Cmd_Argv(1), "radius"))
6346 if (Cmd_Argc() != 3)
6348 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6351 radius = atof(Cmd_Argv(2));
6353 else if (!strcmp(Cmd_Argv(1), "colorscale"))
6355 if (Cmd_Argc() == 3)
6357 double scale = atof(Cmd_Argv(2));
6364 if (Cmd_Argc() != 5)
6366 Con_Printf("usage: r_editlights_edit %s red green blue (OR grey instead of red green blue)\n", Cmd_Argv(1));
6369 color[0] *= atof(Cmd_Argv(2));
6370 color[1] *= atof(Cmd_Argv(3));
6371 color[2] *= atof(Cmd_Argv(4));
6374 else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
6376 if (Cmd_Argc() != 3)
6378 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6381 radius *= atof(Cmd_Argv(2));
6383 else if (!strcmp(Cmd_Argv(1), "style"))
6385 if (Cmd_Argc() != 3)
6387 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6390 style = atoi(Cmd_Argv(2));
6392 else if (!strcmp(Cmd_Argv(1), "cubemap"))
6396 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6399 if (Cmd_Argc() == 3)
6400 strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
6404 else if (!strcmp(Cmd_Argv(1), "shadows"))
6406 if (Cmd_Argc() != 3)
6408 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6411 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6413 else if (!strcmp(Cmd_Argv(1), "corona"))
6415 if (Cmd_Argc() != 3)
6417 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6420 corona = atof(Cmd_Argv(2));
6422 else if (!strcmp(Cmd_Argv(1), "coronasize"))
6424 if (Cmd_Argc() != 3)
6426 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6429 coronasizescale = atof(Cmd_Argv(2));
6431 else if (!strcmp(Cmd_Argv(1), "ambient"))
6433 if (Cmd_Argc() != 3)
6435 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6438 ambientscale = atof(Cmd_Argv(2));
6440 else if (!strcmp(Cmd_Argv(1), "diffuse"))
6442 if (Cmd_Argc() != 3)
6444 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6447 diffusescale = atof(Cmd_Argv(2));
6449 else if (!strcmp(Cmd_Argv(1), "specular"))
6451 if (Cmd_Argc() != 3)
6453 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6456 specularscale = atof(Cmd_Argv(2));
6458 else if (!strcmp(Cmd_Argv(1), "normalmode"))
6460 if (Cmd_Argc() != 3)
6462 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6465 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6467 else if (!strcmp(Cmd_Argv(1), "realtimemode"))
6469 if (Cmd_Argc() != 3)
6471 Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
6474 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
6478 Con_Print("usage: r_editlights_edit [property] [value]\n");
6479 Con_Print("Selected light's properties:\n");
6480 Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
6481 Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
6482 Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
6483 Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius);
6484 Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona);
6485 Con_Printf("Style : %i\n", r_shadow_selectedlight->style);
6486 Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
6487 Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname);
6488 Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);
6489 Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale);
6490 Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale);
6491 Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale);
6492 Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
6493 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
6496 flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
6497 R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
6500 void R_Shadow_EditLights_EditAll_f(void)
6503 dlight_t *light, *oldselected;
6506 if (!r_editlights.integer)
6508 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
6512 oldselected = r_shadow_selectedlight;
6513 // EditLights doesn't seem to have a "remove" command or something so:
6514 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6515 for (lightindex = 0;lightindex < range;lightindex++)
6517 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6520 R_Shadow_SelectLight(light);
6521 R_Shadow_EditLights_Edit_f();
6523 // return to old selected (to not mess editing once selection is locked)
6524 R_Shadow_SelectLight(oldselected);
6527 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
6529 int lightnumber, lightcount;
6530 size_t lightindex, range;
6534 if (!r_editlights.integer)
6536 x = vid_conwidth.value - 240;
6538 DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
6541 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
6542 for (lightindex = 0;lightindex < range;lightindex++)
6544 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
6547 if (light == r_shadow_selectedlight)
6548 lightnumber = lightindex;
6551 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;
6552 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;
6554 if (r_shadow_selectedlight == NULL)
6556 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;
6557 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;
6558 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;
6559 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;
6560 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;
6561 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;
6562 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;
6563 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;
6564 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;
6565 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;
6566 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;
6567 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;
6568 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;
6569 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;
6570 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;
6573 void R_Shadow_EditLights_ToggleShadow_f(void)
6575 if (!r_editlights.integer)
6577 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6580 if (!r_shadow_selectedlight)
6582 Con_Print("No selected light.\n");
6585 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);
6588 void R_Shadow_EditLights_ToggleCorona_f(void)
6590 if (!r_editlights.integer)
6592 Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n");
6595 if (!r_shadow_selectedlight)
6597 Con_Print("No selected light.\n");
6600 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);
6603 void R_Shadow_EditLights_Remove_f(void)
6605 if (!r_editlights.integer)
6607 Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n");
6610 if (!r_shadow_selectedlight)
6612 Con_Print("No selected light.\n");
6615 R_Shadow_FreeWorldLight(r_shadow_selectedlight);
6616 r_shadow_selectedlight = NULL;
6619 void R_Shadow_EditLights_Help_f(void)
6622 "Documentation on r_editlights system:\n"
6624 "r_editlights : enable/disable editing mode\n"
6625 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
6626 "r_editlights_cursorpushback : push back cursor this far from surface\n"
6627 "r_editlights_cursorpushoff : push cursor off surface this far\n"
6628 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
6629 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
6631 "r_editlights_help : this help\n"
6632 "r_editlights_clear : remove all lights\n"
6633 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
6634 "r_editlights_lock : lock selection to current light, if already locked - unlock\n"
6635 "r_editlights_save : save to .rtlights file\n"
6636 "r_editlights_spawn : create a light with default settings\n"
6637 "r_editlights_edit command : edit selected light - more documentation below\n"
6638 "r_editlights_remove : remove selected light\n"
6639 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
6640 "r_editlights_importlightentitiesfrommap : reload light entities\n"
6641 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
6643 "origin x y z : set light location\n"
6644 "originx x: set x component of light location\n"
6645 "originy y: set y component of light location\n"
6646 "originz z: set z component of light location\n"
6647 "move x y z : adjust light location\n"
6648 "movex x: adjust x component of light location\n"
6649 "movey y: adjust y component of light location\n"
6650 "movez z: adjust z component of light location\n"
6651 "angles x y z : set light angles\n"
6652 "anglesx x: set x component of light angles\n"
6653 "anglesy y: set y component of light angles\n"
6654 "anglesz z: set z component of light angles\n"
6655 "color r g b : set color of light (can be brighter than 1 1 1)\n"
6656 "radius radius : set radius (size) of light\n"
6657 "colorscale grey : multiply color of light (1 does nothing)\n"
6658 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
6659 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
6660 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
6661 "originscale x y z : multiply origin of light (1 1 1 does nothing)\n"
6662 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
6663 "cubemap basename : set filter cubemap of light (not yet supported)\n"
6664 "shadows 1/0 : turn on/off shadows\n"
6665 "corona n : set corona intensity\n"
6666 "coronasize n : set corona size (0-1)\n"
6667 "ambient n : set ambient intensity (0-1)\n"
6668 "diffuse n : set diffuse intensity (0-1)\n"
6669 "specular n : set specular intensity (0-1)\n"
6670 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
6671 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
6672 "<nothing> : print light properties to console\n"
6676 void R_Shadow_EditLights_CopyInfo_f(void)
6678 if (!r_editlights.integer)
6680 Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n");
6683 if (!r_shadow_selectedlight)
6685 Con_Print("No selected light.\n");
6688 VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
6689 VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
6690 r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
6691 r_shadow_bufferlight.style = r_shadow_selectedlight->style;
6692 if (r_shadow_selectedlight->cubemapname)
6693 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
6695 r_shadow_bufferlight.cubemapname[0] = 0;
6696 r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
6697 r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
6698 r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
6699 r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
6700 r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
6701 r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
6702 r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
6705 void R_Shadow_EditLights_PasteInfo_f(void)
6707 if (!r_editlights.integer)
6709 Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n");
6712 if (!r_shadow_selectedlight)
6714 Con_Print("No selected light.\n");
6717 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);
6720 void R_Shadow_EditLights_Lock_f(void)
6722 if (!r_editlights.integer)
6724 Con_Print("Cannot lock on light when not in editing mode. Set r_editlights to 1.\n");
6727 if (r_editlights_lockcursor)
6729 r_editlights_lockcursor = false;
6732 if (!r_shadow_selectedlight)
6734 Con_Print("No selected light to lock on.\n");
6737 r_editlights_lockcursor = true;
6740 void R_Shadow_EditLights_Init(void)
6742 Cvar_RegisterVariable(&r_editlights);
6743 Cvar_RegisterVariable(&r_editlights_cursordistance);
6744 Cvar_RegisterVariable(&r_editlights_cursorpushback);
6745 Cvar_RegisterVariable(&r_editlights_cursorpushoff);
6746 Cvar_RegisterVariable(&r_editlights_cursorgrid);
6747 Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
6748 Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
6749 Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
6750 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)");
6751 Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
6752 Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
6753 Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
6754 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)");
6755 Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
6756 Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
6757 Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
6758 Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
6759 Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
6760 Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
6761 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)");
6762 Cmd_AddCommand("r_editlights_lock", R_Shadow_EditLights_Lock_f, "lock selection to current light, if already locked - unlock");
6768 =============================================================================
6772 =============================================================================
6775 void R_LightPoint(vec3_t color, const vec3_t p, const int flags)
6777 int i, numlights, flag;
6778 float f, relativepoint[3], dist, dist2, lightradius2;
6783 if (r_fullbright.integer)
6785 VectorSet(color, 1, 1, 1);
6791 if (flags & LP_LIGHTMAP)
6793 if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6795 VectorClear(diffuse);
6796 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, color, diffuse, n);
6797 VectorAdd(color, diffuse, color);
6800 VectorSet(color, 1, 1, 1);
6801 color[0] += r_refdef.scene.ambient;
6802 color[1] += r_refdef.scene.ambient;
6803 color[2] += r_refdef.scene.ambient;
6806 if (flags & LP_RTWORLD)
6808 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6809 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6810 for (i = 0; i < numlights; i++)
6812 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6815 light = &dlight->rtlight;
6816 if (!(light->flags & flag))
6819 lightradius2 = light->radius * light->radius;
6820 VectorSubtract(light->shadoworigin, p, relativepoint);
6821 dist2 = VectorLength2(relativepoint);
6822 if (dist2 >= lightradius2)
6824 dist = sqrt(dist2) / light->radius;
6825 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6828 // todo: add to both ambient and diffuse
6829 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6830 VectorMA(color, f, light->currentcolor, color);
6833 if (flags & LP_DYNLIGHT)
6836 for (i = 0;i < r_refdef.scene.numlights;i++)
6838 light = r_refdef.scene.lights[i];
6840 lightradius2 = light->radius * light->radius;
6841 VectorSubtract(light->shadoworigin, p, relativepoint);
6842 dist2 = VectorLength2(relativepoint);
6843 if (dist2 >= lightradius2)
6845 dist = sqrt(dist2) / light->radius;
6846 f = dist < 1 ? (r_shadow_lightintensityscale.value * ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist))) : 0;
6849 // todo: add to both ambient and diffuse
6850 if (!light->shadow || CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction == 1)
6851 VectorMA(color, f, light->color, color);
6856 void R_CompleteLightPoint(vec3_t ambient, vec3_t diffuse, vec3_t lightdir, const vec3_t p, const int flags)
6858 int i, numlights, flag;
6861 float relativepoint[3];
6870 if (r_fullbright.integer)
6872 VectorSet(ambient, 1, 1, 1);
6873 VectorClear(diffuse);
6874 VectorClear(lightdir);
6878 if (flags == LP_LIGHTMAP)
6880 VectorSet(ambient, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6881 VectorClear(diffuse);
6882 VectorClear(lightdir);
6883 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6884 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambient, diffuse, lightdir);
6886 VectorSet(ambient, 1, 1, 1);
6890 memset(sample, 0, sizeof(sample));
6891 VectorSet(sample, r_refdef.scene.ambient, r_refdef.scene.ambient, r_refdef.scene.ambient);
6893 if ((flags & LP_LIGHTMAP) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
6896 VectorClear(tempambient);
6898 VectorClear(relativepoint);
6899 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, tempambient, color, relativepoint);
6900 VectorScale(tempambient, r_refdef.lightmapintensity, tempambient);
6901 VectorScale(color, r_refdef.lightmapintensity, color);
6902 VectorAdd(sample, tempambient, sample);
6903 VectorMA(sample , 0.5f , color, sample );
6904 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6905 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6906 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6907 // calculate a weighted average light direction as well
6908 intensity = VectorLength(color);
6909 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6912 if (flags & LP_RTWORLD)
6914 flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
6915 numlights = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
6916 for (i = 0; i < numlights; i++)
6918 dlight = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, i);
6921 light = &dlight->rtlight;
6922 if (!(light->flags & flag))
6925 lightradius2 = light->radius * light->radius;
6926 VectorSubtract(light->shadoworigin, p, relativepoint);
6927 dist2 = VectorLength2(relativepoint);
6928 if (dist2 >= lightradius2)
6930 dist = sqrt(dist2) / light->radius;
6931 intensity = min(1.0f, (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) * r_shadow_lightintensityscale.value;
6932 if (intensity <= 0.0f)
6934 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6936 // scale down intensity to add to both ambient and diffuse
6937 //intensity *= 0.5f;
6938 VectorNormalize(relativepoint);
6939 VectorScale(light->currentcolor, intensity, color);
6940 VectorMA(sample , 0.5f , color, sample );
6941 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6942 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6943 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6944 // calculate a weighted average light direction as well
6945 intensity *= VectorLength(color);
6946 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6950 if (flags & LP_DYNLIGHT)
6953 for (i = 0;i < r_refdef.scene.numlights;i++)
6955 light = r_refdef.scene.lights[i];
6957 lightradius2 = light->radius * light->radius;
6958 VectorSubtract(light->shadoworigin, p, relativepoint);
6959 dist2 = VectorLength2(relativepoint);
6960 if (dist2 >= lightradius2)
6962 dist = sqrt(dist2) / light->radius;
6963 intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist) * r_shadow_lightintensityscale.value;
6964 if (intensity <= 0.0f)
6966 if (light->shadow && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false, true).fraction < 1)
6968 // scale down intensity to add to both ambient and diffuse
6969 //intensity *= 0.5f;
6970 VectorNormalize(relativepoint);
6971 VectorScale(light->currentcolor, intensity, color);
6972 VectorMA(sample , 0.5f , color, sample );
6973 VectorMA(sample + 3, relativepoint[0], color, sample + 3);
6974 VectorMA(sample + 6, relativepoint[1], color, sample + 6);
6975 VectorMA(sample + 9, relativepoint[2], color, sample + 9);
6976 // calculate a weighted average light direction as well
6977 intensity *= VectorLength(color);
6978 VectorMA(sample + 12, intensity, relativepoint, sample + 12);
6982 // calculate the direction we'll use to reduce the sample to a directional light source
6983 VectorCopy(sample + 12, dir);
6984 //VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
6985 VectorNormalize(dir);
6986 // extract the diffuse color along the chosen direction and scale it
6987 diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]);
6988 diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]);
6989 diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]);
6990 // subtract some of diffuse from ambient
6991 VectorMA(sample, -0.333f, diffuse, ambient);
6992 // store the normalized lightdir
6993 VectorCopy(dir, lightdir);