r_shadow.c

   1
   2 /*
   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)
   9
  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.
  15
  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).
  22
  23 Patent warning:
  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).
  29
  30
  31
  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).
  38
  39
  40
  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
  46 in some ideal cases).
  47
  48
  49
  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.
  60
  61
  62
  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.
  69
  70
  71
  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.
  80
  81
  82
  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
  89 texturing).
  90
  91
  92
  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).
  96
  97
  98
  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.
 103
 104
 105
 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
 114 this however).
 115
 116
 117
 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
 127 other areas).
 128
 129
 130
 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.
 135 */
 136
 137 #include "quakedef.h"
 138 #include "r_shadow.h"
 139 #include "cl_collision.h"
 140 #include "portals.h"
 141 #include "image.h"
 142
 143 #define R_SHADOW_SHADOWMAP_NUMCUBEMAPS 8
 144
 145 extern void R_Shadow_EditLights_Init(void);
 146
 147 typedef enum r_shadow_rendermode_e
 148 {
 149         R_SHADOW_RENDERMODE_NONE,
 150         R_SHADOW_RENDERMODE_ZPASS_STENCIL,
 151         R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL,
 152         R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE,
 153         R_SHADOW_RENDERMODE_ZFAIL_STENCIL,
 154         R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL,
 155         R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE,
 156         R_SHADOW_RENDERMODE_LIGHT_VERTEX,
 157         R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN,
 158         R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN,
 159         R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN,
 160         R_SHADOW_RENDERMODE_LIGHT_GLSL,
 161         R_SHADOW_RENDERMODE_VISIBLEVOLUMES,
 162         R_SHADOW_RENDERMODE_VISIBLELIGHTING,
 163         R_SHADOW_RENDERMODE_SHADOWMAP2D,
 164         R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE,
 165         R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE,
 166 }
 167 r_shadow_rendermode_t;
 168
 169 typedef enum r_shadow_shadowmode_e
 170 {
 171     R_SHADOW_SHADOWMODE_STENCIL,
 172     R_SHADOW_SHADOWMODE_SHADOWMAP2D,
 173     R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE,
 174     R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE
 175 }
 176 r_shadow_shadowmode_t;
 177
 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_usingshadowmaprect;
 183 qboolean r_shadow_usingshadowmap2d;
 184 qboolean r_shadow_usingshadowmapcube;
 185 int r_shadow_shadowmapside;
 186 float r_shadow_shadowmap_texturescale[2];
 187 float r_shadow_shadowmap_parameters[4];
 188 #if 0
 189 int r_shadow_drawbuffer;
 190 int r_shadow_readbuffer;
 191 #endif
 192 int r_shadow_cullface_front, r_shadow_cullface_back;
 193 GLuint r_shadow_fborectangle;
 194 GLuint r_shadow_fbocubeside[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
 195 GLuint r_shadow_fbo2d;
 196 r_shadow_shadowmode_t r_shadow_shadowmode;
 197 int r_shadow_shadowmapfilterquality;
 198 int r_shadow_shadowmaptexturetype;
 199 int r_shadow_shadowmapdepthbits;
 200 int r_shadow_shadowmapmaxsize;
 201 qboolean r_shadow_shadowmapvsdct;
 202 qboolean r_shadow_shadowmapsampler;
 203 int r_shadow_shadowmappcf;
 204 int r_shadow_shadowmapborder;
 205 int r_shadow_lightscissor[4];
 206 qboolean r_shadow_usingdeferredprepass;
 207
 208 int maxshadowtriangles;
 209 int *shadowelements;
 210
 211 int maxshadowvertices;
 212 float *shadowvertex3f;
 213
 214 int maxshadowmark;
 215 int numshadowmark;
 216 int *shadowmark;
 217 int *shadowmarklist;
 218 int shadowmarkcount;
 219
 220 int maxshadowsides;
 221 int numshadowsides;
 222 unsigned char *shadowsides;
 223 int *shadowsideslist;
 224
 225 int maxvertexupdate;
 226 int *vertexupdate;
 227 int *vertexremap;
 228 int vertexupdatenum;
 229
 230 int r_shadow_buffer_numleafpvsbytes;
 231 unsigned char *r_shadow_buffer_visitingleafpvs;
 232 unsigned char *r_shadow_buffer_leafpvs;
 233 int *r_shadow_buffer_leaflist;
 234
 235 int r_shadow_buffer_numsurfacepvsbytes;
 236 unsigned char *r_shadow_buffer_surfacepvs;
 237 int *r_shadow_buffer_surfacelist;
 238 unsigned char *r_shadow_buffer_surfacesides;
 239
 240 int r_shadow_buffer_numshadowtrispvsbytes;
 241 unsigned char *r_shadow_buffer_shadowtrispvs;
 242 int r_shadow_buffer_numlighttrispvsbytes;
 243 unsigned char *r_shadow_buffer_lighttrispvs;
 244
 245 rtexturepool_t *r_shadow_texturepool;
 246 rtexture_t *r_shadow_attenuationgradienttexture;
 247 rtexture_t *r_shadow_attenuation2dtexture;
 248 rtexture_t *r_shadow_attenuation3dtexture;
 249 skinframe_t *r_shadow_lightcorona;
 250 rtexture_t *r_shadow_shadowmaprectangletexture;
 251 rtexture_t *r_shadow_shadowmap2dtexture;
 252 rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS];
 253 rtexture_t *r_shadow_shadowmapvsdcttexture;
 254 int r_shadow_shadowmapsize; // changes for each light based on distance
 255 int r_shadow_shadowmaplod; // changes for each light based on distance
 256
 257 GLuint r_shadow_prepassgeometryfbo;
 258 GLuint r_shadow_prepasslightingfbo;
 259 int r_shadow_prepass_width;
 260 int r_shadow_prepass_height;
 261 rtexture_t *r_shadow_prepassgeometrydepthtexture;
 262 rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
 263 rtexture_t *r_shadow_prepasslightingdiffusetexture;
 264 rtexture_t *r_shadow_prepasslightingspeculartexture;
 265
 266 // lights are reloaded when this changes
 267 char r_shadow_mapname[MAX_QPATH];
 268
 269 // used only for light filters (cubemaps)
 270 rtexturepool_t *r_shadow_filters_texturepool;
 271
 272 static const GLenum r_shadow_prepasslightingdrawbuffers[2] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
 273
 274 cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"};
 275 cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
 276 cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
 277 cvar_t r_shadow_deferred = {CVAR_SAVE, "r_shadow_deferred", "0", "uses image-based lighting instead of geometry-based lighting, the method used renders a depth image and a normalmap image, renders lights into separate diffuse and specular images, and then combines this into the normal rendering, requires r_shadow_shadowmapping"};
 278 cvar_t r_shadow_deferred_8bitrange = {CVAR_SAVE, "r_shadow_deferred_8bitrange", "2", "dynamic range of image-based lighting when using 32bit color (does not apply to fp)"};
 279 //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"};
 280 cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"};
 281 cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"};
 282 cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};
 283 cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
 284 cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"};
 285 cvar_t r_shadow_gloss2exponent = {0, "r_shadow_gloss2exponent", "32", "same as r_shadow_glossexponent but for forced gloss (gloss 2) surfaces"};
 286 cvar_t r_shadow_glossexact = {0, "r_shadow_glossexact", "0", "use exact reflection math for gloss (slightly slower, but should look a tad better)"};
 287 cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"};
 288 cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"};
 289 cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
 290 cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"};
 291 cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1", "use portal culling to exactly determine lit triangles when compiling world lights"};
 292 cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000", "how far to cast shadows"};
 293 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)"};
 294 cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
 295 cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
 296 cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"};
 297 cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"};
 298 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)"};
 299 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"};
 300 cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
 301 cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
 302 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"};
 303 cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation"};
 304 cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation"};
 305 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)"};
 306 cvar_t r_shadow_shadowmapping = {CVAR_SAVE, "r_shadow_shadowmapping", "0", "enables use of shadowmapping (depth texture sampling) instead of stencil shadow volumes, requires gl_fbo 1"};
 307 cvar_t r_shadow_shadowmapping_texturetype = {CVAR_SAVE, "r_shadow_shadowmapping_texturetype", "-1", "shadowmap texture types: -1 = auto-select, 0 = 2D, 1 = rectangle, 2 = cubemap"};
 308 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)"};
 309 cvar_t r_shadow_shadowmapping_depthbits = {CVAR_SAVE, "r_shadow_shadowmapping_depthbits", "24", "requested minimum shadowmap texture depth bits"};
 310 cvar_t r_shadow_shadowmapping_vsdct = {CVAR_SAVE, "r_shadow_shadowmapping_vsdct", "1", "enables use of virtual shadow depth cube texture"};
 311 cvar_t r_shadow_shadowmapping_minsize = {CVAR_SAVE, "r_shadow_shadowmapping_minsize", "32", "shadowmap size limit"};
 312 cvar_t r_shadow_shadowmapping_maxsize = {CVAR_SAVE, "r_shadow_shadowmapping_maxsize", "512", "shadowmap size limit"};
 313 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"};
 314 //cvar_t r_shadow_shadowmapping_lod_bias = {CVAR_SAVE, "r_shadow_shadowmapping_lod_bias", "16", "shadowmap size bias"};
 315 //cvar_t r_shadow_shadowmapping_lod_scale = {CVAR_SAVE, "r_shadow_shadowmapping_lod_scale", "128", "shadowmap size scaling parameter"};
 316 cvar_t r_shadow_shadowmapping_bordersize = {CVAR_SAVE, "r_shadow_shadowmapping_bordersize", "4", "shadowmap size bias for filtering"};
 317 cvar_t r_shadow_shadowmapping_nearclip = {CVAR_SAVE, "r_shadow_shadowmapping_nearclip", "1", "shadowmap nearclip in world units"};
 318 cvar_t r_shadow_shadowmapping_bias = {CVAR_SAVE, "r_shadow_shadowmapping_bias", "0.03", "shadowmap bias parameter (this is multiplied by nearclip * 1024 / lodsize)"};
 319 cvar_t r_shadow_shadowmapping_polygonfactor = {CVAR_SAVE, "r_shadow_shadowmapping_polygonfactor", "2", "slope-dependent shadowmapping bias"};
 320 cvar_t r_shadow_shadowmapping_polygonoffset = {CVAR_SAVE, "r_shadow_shadowmapping_polygonoffset", "0", "constant shadowmapping bias"};
 321 cvar_t r_shadow_culltriangles = {0, "r_shadow_culltriangles", "1", "performs more expensive tests to remove unnecessary triangles of lit surfaces"};
 322 cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
 323 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)"};
 324 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)"};
 325 cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
 326 cvar_t r_coronas_occlusionsizescale = {CVAR_SAVE, "r_coronas_occlusionsizescale", "0.1", "size of light source for corona occlusion checksm the proportion of hidden pixels controls corona intensity"};
 327 cvar_t r_coronas_occlusionquery = {CVAR_SAVE, "r_coronas_occlusionquery", "1", "use GL_ARB_occlusion_query extension if supported (fades coronas according to visibility)"};
 328 cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
 329 cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"};
 330 cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
 331 cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
 332 cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
 333 cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
 334 cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
 335 cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
 336 cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
 337
 338 // note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error
 339 #define ATTENTABLESIZE 256
 340 // 1D gradient, 2D circle and 3D sphere attenuation textures
 341 #define ATTEN1DSIZE 32
 342 #define ATTEN2DSIZE 64
 343 #define ATTEN3DSIZE 32
 344
 345 static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias
 346 static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale
 347 static float r_shadow_attentable[ATTENTABLESIZE+1];
 348
 349 rtlight_t *r_shadow_compilingrtlight;
 350 static memexpandablearray_t r_shadow_worldlightsarray;
 351 dlight_t *r_shadow_selectedlight;
 352 dlight_t r_shadow_bufferlight;
 353 vec3_t r_editlights_cursorlocation;
 354
 355 extern int con_vislines;
 356
 357 typedef struct cubemapinfo_s
 358 {
 359         char basename[64];
 360         rtexture_t *texture;
 361 }
 362 cubemapinfo_t;
 363
 364 static int numcubemaps;
 365 static cubemapinfo_t cubemaps[MAX_CUBEMAPS];
 366
 367 void R_Shadow_UncompileWorldLights(void);
 368 void R_Shadow_ClearWorldLights(void);
 369 void R_Shadow_SaveWorldLights(void);
 370 void R_Shadow_LoadWorldLights(void);
 371 void R_Shadow_LoadLightsFile(void);
 372 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void);
 373 void R_Shadow_EditLights_Reload_f(void);
 374 void R_Shadow_ValidateCvars(void);
 375 static void R_Shadow_MakeTextures(void);
 376
 377 #define EDLIGHTSPRSIZE                  8
 378 skinframe_t *r_editlights_sprcursor;
 379 skinframe_t *r_editlights_sprlight;
 380 skinframe_t *r_editlights_sprnoshadowlight;
 381 skinframe_t *r_editlights_sprcubemaplight;
 382 skinframe_t *r_editlights_sprcubemapnoshadowlight;
 383 skinframe_t *r_editlights_sprselection;
 384
 385 void R_Shadow_SetShadowMode(void)
 386 {
 387         r_shadow_shadowmapmaxsize = bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4);
 388         r_shadow_shadowmapvsdct = r_shadow_shadowmapping_vsdct.integer != 0;
 389         r_shadow_shadowmapfilterquality = r_shadow_shadowmapping_filterquality.integer;
 390         r_shadow_shadowmaptexturetype = r_shadow_shadowmapping_texturetype.integer;
 391         r_shadow_shadowmapdepthbits = r_shadow_shadowmapping_depthbits.integer;
 392         r_shadow_shadowmapborder = bound(0, r_shadow_shadowmapping_bordersize.integer, 16);
 393         r_shadow_shadowmaplod = -1;
 394         r_shadow_shadowmapsize = 0;
 395         r_shadow_shadowmapsampler = false;
 396         r_shadow_shadowmappcf = 0;
 397         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
 398         switch(vid.renderpath)
 399         {
 400         case RENDERPATH_GL20:
 401                 if(r_shadow_shadowmapping.integer && vid.support.ext_framebuffer_object)
 402                 {
 403                         if(r_shadow_shadowmapfilterquality < 0)
 404                         {
 405                                 if(strstr(gl_vendor, "NVIDIA"))
 406                                 {
 407                                         r_shadow_shadowmapsampler = vid.support.arb_shadow;
 408                                         r_shadow_shadowmappcf = 1;
 409                                 }
 410                                 else if(vid.support.amd_texture_texture4 || vid.support.arb_texture_gather)
 411                                         r_shadow_shadowmappcf = 1;
 412                                 else if(strstr(gl_vendor, "ATI"))
 413                                         r_shadow_shadowmappcf = 1;
 414                                 else
 415                                         r_shadow_shadowmapsampler = vid.support.arb_shadow;
 416                         }
 417                         else
 418                         {
 419                                 switch (r_shadow_shadowmapfilterquality)
 420                                 {
 421                                 case 1:
 422                                         r_shadow_shadowmapsampler = vid.support.arb_shadow;
 423                                         break;
 424                                 case 2:
 425                                         r_shadow_shadowmapsampler = vid.support.arb_shadow;
 426                                         r_shadow_shadowmappcf = 1;
 427                                         break;
 428                                 case 3:
 429                                         r_shadow_shadowmappcf = 1;
 430                                         break;
 431                                 case 4:
 432                                         r_shadow_shadowmappcf = 2;
 433                                         break;
 434                                 }
 435                         }
 436                         switch (r_shadow_shadowmaptexturetype)
 437                         {
 438                         case 0:
 439                                 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
 440                                 break;
 441                         case 1:
 442                                 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE;
 443                                 break;
 444                         case 2:
 445                                 r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE;
 446                                 break;
 447                         default:
 448                                 if((vid.support.amd_texture_texture4 || vid.support.arb_texture_gather) && r_shadow_shadowmappcf && !r_shadow_shadowmapsampler)
 449                                         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
 450                                 else if(vid.support.arb_texture_rectangle)
 451                                         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE;
 452                                 else
 453                                         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_SHADOWMAP2D;
 454                                 break;
 455                         }
 456                 }
 457                 break;
 458         case RENDERPATH_GL13:
 459                 break;
 460         case RENDERPATH_GL11:
 461                 break;
 462         }
 463 }
 464
 465 void R_Shadow_FreeShadowMaps(void)
 466 {
 467         int i;
 468
 469         R_Shadow_SetShadowMode();
 470
 471         if (!vid.support.ext_framebuffer_object || !vid.support.arb_fragment_shader)
 472                 return;
 473
 474         CHECKGLERROR
 475
 476         if (r_shadow_fborectangle)
 477                 qglDeleteFramebuffersEXT(1, &r_shadow_fborectangle);CHECKGLERROR
 478         r_shadow_fborectangle = 0;
 479
 480         if (r_shadow_fbo2d)
 481                 qglDeleteFramebuffersEXT(1, &r_shadow_fbo2d);CHECKGLERROR
 482         r_shadow_fbo2d = 0;
 483         for (i = 0;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
 484                 if (r_shadow_fbocubeside[i])
 485                         qglDeleteFramebuffersEXT(1, &r_shadow_fbocubeside[i]);CHECKGLERROR
 486         memset(r_shadow_fbocubeside, 0, sizeof(r_shadow_fbocubeside));
 487
 488         if (r_shadow_shadowmaprectangletexture)
 489                 R_FreeTexture(r_shadow_shadowmaprectangletexture);
 490         r_shadow_shadowmaprectangletexture = NULL;
 491
 492         if (r_shadow_shadowmap2dtexture)
 493                 R_FreeTexture(r_shadow_shadowmap2dtexture);
 494         r_shadow_shadowmap2dtexture = NULL;
 495
 496         for (i = 0;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
 497                 if (r_shadow_shadowmapcubetexture[i])
 498                         R_FreeTexture(r_shadow_shadowmapcubetexture[i]);
 499         memset(r_shadow_shadowmapcubetexture, 0, sizeof(r_shadow_shadowmapcubetexture));
 500
 501         if (r_shadow_shadowmapvsdcttexture)
 502                 R_FreeTexture(r_shadow_shadowmapvsdcttexture);
 503         r_shadow_shadowmapvsdcttexture = NULL;
 504
 505         CHECKGLERROR
 506 }
 507
 508 void r_shadow_start(void)
 509 {
 510         // allocate vertex processing arrays
 511         numcubemaps = 0;
 512         r_shadow_attenuationgradienttexture = NULL;
 513         r_shadow_attenuation2dtexture = NULL;
 514         r_shadow_attenuation3dtexture = NULL;
 515         r_shadow_shadowmode = R_SHADOW_SHADOWMODE_STENCIL;
 516         r_shadow_shadowmaprectangletexture = NULL;
 517         r_shadow_shadowmap2dtexture = NULL;
 518         memset(r_shadow_shadowmapcubetexture, 0, sizeof(r_shadow_shadowmapcubetexture));
 519         r_shadow_shadowmapvsdcttexture = NULL;
 520         r_shadow_shadowmapmaxsize = 0;
 521         r_shadow_shadowmapsize = 0;
 522         r_shadow_shadowmaplod = 0;
 523         r_shadow_shadowmapfilterquality = -1;
 524         r_shadow_shadowmaptexturetype = -1;
 525         r_shadow_shadowmapdepthbits = 0;
 526         r_shadow_shadowmapvsdct = false;
 527         r_shadow_shadowmapsampler = false;
 528         r_shadow_shadowmappcf = 0;
 529         r_shadow_fborectangle = 0;
 530         r_shadow_fbo2d = 0;
 531         memset(r_shadow_fbocubeside, 0, sizeof(r_shadow_fbocubeside));
 532
 533         R_Shadow_FreeShadowMaps();
 534
 535         r_shadow_texturepool = NULL;
 536         r_shadow_filters_texturepool = NULL;
 537         R_Shadow_ValidateCvars();
 538         R_Shadow_MakeTextures();
 539         maxshadowtriangles = 0;
 540         shadowelements = NULL;
 541         maxshadowvertices = 0;
 542         shadowvertex3f = NULL;
 543         maxvertexupdate = 0;
 544         vertexupdate = NULL;
 545         vertexremap = NULL;
 546         vertexupdatenum = 0;
 547         maxshadowmark = 0;
 548         numshadowmark = 0;
 549         shadowmark = NULL;
 550         shadowmarklist = NULL;
 551         shadowmarkcount = 0;
 552         maxshadowsides = 0;
 553         numshadowsides = 0;
 554         shadowsides = NULL;
 555         shadowsideslist = NULL;
 556         r_shadow_buffer_numleafpvsbytes = 0;
 557         r_shadow_buffer_visitingleafpvs = NULL;
 558         r_shadow_buffer_leafpvs = NULL;
 559         r_shadow_buffer_leaflist = NULL;
 560         r_shadow_buffer_numsurfacepvsbytes = 0;
 561         r_shadow_buffer_surfacepvs = NULL;
 562         r_shadow_buffer_surfacelist = NULL;
 563         r_shadow_buffer_surfacesides = NULL;
 564         r_shadow_buffer_numshadowtrispvsbytes = 0;
 565         r_shadow_buffer_shadowtrispvs = NULL;
 566         r_shadow_buffer_numlighttrispvsbytes = 0;
 567         r_shadow_buffer_lighttrispvs = NULL;
 568
 569         r_shadow_usingdeferredprepass = false;
 570         r_shadow_prepass_width = r_shadow_prepass_height = 0;
 571 }
 572
 573 static void R_Shadow_FreeDeferred(void);
 574 void r_shadow_shutdown(void)
 575 {
 576         CHECKGLERROR
 577         R_Shadow_UncompileWorldLights();
 578
 579         R_Shadow_FreeShadowMaps();
 580
 581         r_shadow_usingdeferredprepass = false;
 582         if (r_shadow_prepass_width)
 583                 R_Shadow_FreeDeferred();
 584         r_shadow_prepass_width = r_shadow_prepass_height = 0;
 585
 586         CHECKGLERROR
 587         numcubemaps = 0;
 588         r_shadow_attenuationgradienttexture = NULL;
 589         r_shadow_attenuation2dtexture = NULL;
 590         r_shadow_attenuation3dtexture = NULL;
 591         R_FreeTexturePool(&r_shadow_texturepool);
 592         R_FreeTexturePool(&r_shadow_filters_texturepool);
 593         maxshadowtriangles = 0;
 594         if (shadowelements)
 595                 Mem_Free(shadowelements);
 596         shadowelements = NULL;
 597         if (shadowvertex3f)
 598                 Mem_Free(shadowvertex3f);
 599         shadowvertex3f = NULL;
 600         maxvertexupdate = 0;
 601         if (vertexupdate)
 602                 Mem_Free(vertexupdate);
 603         vertexupdate = NULL;
 604         if (vertexremap)
 605                 Mem_Free(vertexremap);
 606         vertexremap = NULL;
 607         vertexupdatenum = 0;
 608         maxshadowmark = 0;
 609         numshadowmark = 0;
 610         if (shadowmark)
 611                 Mem_Free(shadowmark);
 612         shadowmark = NULL;
 613         if (shadowmarklist)
 614                 Mem_Free(shadowmarklist);
 615         shadowmarklist = NULL;
 616         shadowmarkcount = 0;
 617         maxshadowsides = 0;
 618         numshadowsides = 0;
 619         if (shadowsides)
 620                 Mem_Free(shadowsides);
 621         shadowsides = NULL;
 622         if (shadowsideslist)
 623                 Mem_Free(shadowsideslist);
 624         shadowsideslist = NULL;
 625         r_shadow_buffer_numleafpvsbytes = 0;
 626         if (r_shadow_buffer_visitingleafpvs)
 627                 Mem_Free(r_shadow_buffer_visitingleafpvs);
 628         r_shadow_buffer_visitingleafpvs = NULL;
 629         if (r_shadow_buffer_leafpvs)
 630                 Mem_Free(r_shadow_buffer_leafpvs);
 631         r_shadow_buffer_leafpvs = NULL;
 632         if (r_shadow_buffer_leaflist)
 633                 Mem_Free(r_shadow_buffer_leaflist);
 634         r_shadow_buffer_leaflist = NULL;
 635         r_shadow_buffer_numsurfacepvsbytes = 0;
 636         if (r_shadow_buffer_surfacepvs)
 637                 Mem_Free(r_shadow_buffer_surfacepvs);
 638         r_shadow_buffer_surfacepvs = NULL;
 639         if (r_shadow_buffer_surfacelist)
 640                 Mem_Free(r_shadow_buffer_surfacelist);
 641         r_shadow_buffer_surfacelist = NULL;
 642         if (r_shadow_buffer_surfacesides)
 643                 Mem_Free(r_shadow_buffer_surfacesides);
 644         r_shadow_buffer_surfacesides = NULL;
 645         r_shadow_buffer_numshadowtrispvsbytes = 0;
 646         if (r_shadow_buffer_shadowtrispvs)
 647                 Mem_Free(r_shadow_buffer_shadowtrispvs);
 648         r_shadow_buffer_numlighttrispvsbytes = 0;
 649         if (r_shadow_buffer_lighttrispvs)
 650                 Mem_Free(r_shadow_buffer_lighttrispvs);
 651 }
 652
 653 void r_shadow_newmap(void)
 654 {
 655         if (r_shadow_lightcorona)                 R_SkinFrame_MarkUsed(r_shadow_lightcorona);
 656         if (r_editlights_sprcursor)               R_SkinFrame_MarkUsed(r_editlights_sprcursor);
 657         if (r_editlights_sprlight)                R_SkinFrame_MarkUsed(r_editlights_sprlight);
 658         if (r_editlights_sprnoshadowlight)        R_SkinFrame_MarkUsed(r_editlights_sprnoshadowlight);
 659         if (r_editlights_sprcubemaplight)         R_SkinFrame_MarkUsed(r_editlights_sprcubemaplight);
 660         if (r_editlights_sprcubemapnoshadowlight) R_SkinFrame_MarkUsed(r_editlights_sprcubemapnoshadowlight);
 661         if (r_editlights_sprselection)            R_SkinFrame_MarkUsed(r_editlights_sprselection);
 662         if (cl.worldmodel && strncmp(cl.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname)))
 663                 R_Shadow_EditLights_Reload_f();
 664 }
 665
 666 void R_Shadow_Init(void)
 667 {
 668         Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
 669         Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
 670         Cvar_RegisterVariable(&r_shadow_usenormalmap);
 671         Cvar_RegisterVariable(&r_shadow_debuglight);
 672         Cvar_RegisterVariable(&r_shadow_deferred);
 673         Cvar_RegisterVariable(&r_shadow_deferred_8bitrange);
 674 //      Cvar_RegisterVariable(&r_shadow_deferred_fp);
 675         Cvar_RegisterVariable(&r_shadow_gloss);
 676         Cvar_RegisterVariable(&r_shadow_gloss2intensity);
 677         Cvar_RegisterVariable(&r_shadow_glossintensity);
 678         Cvar_RegisterVariable(&r_shadow_glossexponent);
 679         Cvar_RegisterVariable(&r_shadow_gloss2exponent);
 680         Cvar_RegisterVariable(&r_shadow_glossexact);
 681         Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
 682         Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
 683         Cvar_RegisterVariable(&r_shadow_lightintensityscale);
 684         Cvar_RegisterVariable(&r_shadow_lightradiusscale);
 685         Cvar_RegisterVariable(&r_shadow_portallight);
 686         Cvar_RegisterVariable(&r_shadow_projectdistance);
 687         Cvar_RegisterVariable(&r_shadow_frontsidecasting);
 688         Cvar_RegisterVariable(&r_shadow_realtime_dlight);
 689         Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
 690         Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
 691         Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
 692         Cvar_RegisterVariable(&r_shadow_realtime_world);
 693         Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
 694         Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
 695         Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
 696         Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
 697         Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
 698         Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
 699         Cvar_RegisterVariable(&r_shadow_scissor);
 700         Cvar_RegisterVariable(&r_shadow_shadowmapping);
 701         Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
 702         Cvar_RegisterVariable(&r_shadow_shadowmapping_texturetype);
 703         Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
 704         Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
 705         Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
 706         Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
 707         Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
 708 //      Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
 709 //      Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
 710         Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
 711         Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
 712         Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
 713         Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
 714         Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
 715         Cvar_RegisterVariable(&r_shadow_culltriangles);
 716         Cvar_RegisterVariable(&r_shadow_polygonfactor);
 717         Cvar_RegisterVariable(&r_shadow_polygonoffset);
 718         Cvar_RegisterVariable(&r_shadow_texture3d);
 719         Cvar_RegisterVariable(&r_coronas);
 720         Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
 721         Cvar_RegisterVariable(&r_coronas_occlusionquery);
 722         Cvar_RegisterVariable(&gl_flashblend);
 723         Cvar_RegisterVariable(&gl_ext_separatestencil);
 724         Cvar_RegisterVariable(&gl_ext_stenciltwoside);
 725         if (gamemode == GAME_TENEBRAE)
 726         {
 727                 Cvar_SetValue("r_shadow_gloss", 2);
 728                 Cvar_SetValue("r_shadow_bumpscale_basetexture", 4);
 729         }
 730         R_Shadow_EditLights_Init();
 731         Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
 732         maxshadowtriangles = 0;
 733         shadowelements = NULL;
 734         maxshadowvertices = 0;
 735         shadowvertex3f = NULL;
 736         maxvertexupdate = 0;
 737         vertexupdate = NULL;
 738         vertexremap = NULL;
 739         vertexupdatenum = 0;
 740         maxshadowmark = 0;
 741         numshadowmark = 0;
 742         shadowmark = NULL;
 743         shadowmarklist = NULL;
 744         shadowmarkcount = 0;
 745         maxshadowsides = 0;
 746         numshadowsides = 0;
 747         shadowsides = NULL;
 748         shadowsideslist = NULL;
 749         r_shadow_buffer_numleafpvsbytes = 0;
 750         r_shadow_buffer_visitingleafpvs = NULL;
 751         r_shadow_buffer_leafpvs = NULL;
 752         r_shadow_buffer_leaflist = NULL;
 753         r_shadow_buffer_numsurfacepvsbytes = 0;
 754         r_shadow_buffer_surfacepvs = NULL;
 755         r_shadow_buffer_surfacelist = NULL;
 756         r_shadow_buffer_surfacesides = NULL;
 757         r_shadow_buffer_shadowtrispvs = NULL;
 758         r_shadow_buffer_lighttrispvs = NULL;
 759         R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap);
 760 }
 761
 762 matrix4x4_t matrix_attenuationxyz =
 763 {
 764         {
 765                 {0.5, 0.0, 0.0, 0.5},
 766                 {0.0, 0.5, 0.0, 0.5},
 767                 {0.0, 0.0, 0.5, 0.5},
 768                 {0.0, 0.0, 0.0, 1.0}
 769         }
 770 };
 771
 772 matrix4x4_t matrix_attenuationz =
 773 {
 774         {
 775                 {0.0, 0.0, 0.5, 0.5},
 776                 {0.0, 0.0, 0.0, 0.5},
 777                 {0.0, 0.0, 0.0, 0.5},
 778                 {0.0, 0.0, 0.0, 1.0}
 779         }
 780 };
 781
 782 void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles, int vertscale, int triscale)
 783 {
 784         numvertices = ((numvertices + 255) & ~255) * vertscale;
 785         numtriangles = ((numtriangles + 255) & ~255) * triscale;
 786         // make sure shadowelements is big enough for this volume
 787         if (maxshadowtriangles < numtriangles)
 788         {
 789                 maxshadowtriangles = numtriangles;
 790                 if (shadowelements)
 791                         Mem_Free(shadowelements);
 792                 shadowelements = (int *)Mem_Alloc(r_main_mempool, maxshadowtriangles * sizeof(int[3]));
 793         }
 794         // make sure shadowvertex3f is big enough for this volume
 795         if (maxshadowvertices < numvertices)
 796         {
 797                 maxshadowvertices = numvertices;
 798                 if (shadowvertex3f)
 799                         Mem_Free(shadowvertex3f);
 800                 shadowvertex3f = (float *)Mem_Alloc(r_main_mempool, maxshadowvertices * sizeof(float[3]));
 801         }
 802 }
 803
 804 static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles)
 805 {
 806         int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255;
 807         int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255;
 808         int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255;
 809         int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255;
 810         if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes)
 811         {
 812                 if (r_shadow_buffer_visitingleafpvs)
 813                         Mem_Free(r_shadow_buffer_visitingleafpvs);
 814                 if (r_shadow_buffer_leafpvs)
 815                         Mem_Free(r_shadow_buffer_leafpvs);
 816                 if (r_shadow_buffer_leaflist)
 817                         Mem_Free(r_shadow_buffer_leaflist);
 818                 r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
 819                 r_shadow_buffer_visitingleafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
 820                 r_shadow_buffer_leafpvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes);
 821                 r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
 822         }
 823         if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
 824         {
 825                 if (r_shadow_buffer_surfacepvs)
 826                         Mem_Free(r_shadow_buffer_surfacepvs);
 827                 if (r_shadow_buffer_surfacelist)
 828                         Mem_Free(r_shadow_buffer_surfacelist);
 829                 if (r_shadow_buffer_surfacesides)
 830                         Mem_Free(r_shadow_buffer_surfacesides);
 831                 r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
 832                 r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes);
 833                 r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
 834                 r_shadow_buffer_surfacesides = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
 835         }
 836         if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes)
 837         {
 838                 if (r_shadow_buffer_shadowtrispvs)
 839                         Mem_Free(r_shadow_buffer_shadowtrispvs);
 840                 r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes;
 841                 r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes);
 842         }
 843         if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes)
 844         {
 845                 if (r_shadow_buffer_lighttrispvs)
 846                         Mem_Free(r_shadow_buffer_lighttrispvs);
 847                 r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes;
 848                 r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes);
 849         }
 850 }
 851
 852 void R_Shadow_PrepareShadowMark(int numtris)
 853 {
 854         // make sure shadowmark is big enough for this volume
 855         if (maxshadowmark < numtris)
 856         {
 857                 maxshadowmark = numtris;
 858                 if (shadowmark)
 859                         Mem_Free(shadowmark);
 860                 if (shadowmarklist)
 861                         Mem_Free(shadowmarklist);
 862                 shadowmark = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmark));
 863                 shadowmarklist = (int *)Mem_Alloc(r_main_mempool, maxshadowmark * sizeof(*shadowmarklist));
 864                 shadowmarkcount = 0;
 865         }
 866         shadowmarkcount++;
 867         // if shadowmarkcount wrapped we clear the array and adjust accordingly
 868         if (shadowmarkcount == 0)
 869         {
 870                 shadowmarkcount = 1;
 871                 memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark));
 872         }
 873         numshadowmark = 0;
 874 }
 875
 876 void R_Shadow_PrepareShadowSides(int numtris)
 877 {
 878     if (maxshadowsides < numtris)
 879     {
 880         maxshadowsides = numtris;
 881         if (shadowsides)
 882                         Mem_Free(shadowsides);
 883                 if (shadowsideslist)
 884                         Mem_Free(shadowsideslist);
 885                 shadowsides = (unsigned char *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsides));
 886                 shadowsideslist = (int *)Mem_Alloc(r_main_mempool, maxshadowsides * sizeof(*shadowsideslist));
 887         }
 888         numshadowsides = 0;
 889 }
 890
 891 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)
 892 {
 893         int i, j;
 894         int outtriangles = 0, outvertices = 0;
 895         const int *element;
 896         const float *vertex;
 897         float ratio, direction[3], projectvector[3];
 898
 899         if (projectdirection)
 900                 VectorScale(projectdirection, projectdistance, projectvector);
 901         else
 902                 VectorClear(projectvector);
 903
 904         // create the vertices
 905         if (projectdirection)
 906         {
 907                 for (i = 0;i < numshadowmarktris;i++)
 908                 {
 909                         element = inelement3i + shadowmarktris[i] * 3;
 910                         for (j = 0;j < 3;j++)
 911                         {
 912                                 if (vertexupdate[element[j]] != vertexupdatenum)
 913                                 {
 914                                         vertexupdate[element[j]] = vertexupdatenum;
 915                                         vertexremap[element[j]] = outvertices;
 916                                         vertex = invertex3f + element[j] * 3;
 917                                         // project one copy of the vertex according to projectvector
 918                                         VectorCopy(vertex, outvertex3f);
 919                                         VectorAdd(vertex, projectvector, (outvertex3f + 3));
 920                                         outvertex3f += 6;
 921                                         outvertices += 2;
 922                                 }
 923                         }
 924                 }
 925         }
 926         else
 927         {
 928                 for (i = 0;i < numshadowmarktris;i++)
 929                 {
 930                         element = inelement3i + shadowmarktris[i] * 3;
 931                         for (j = 0;j < 3;j++)
 932                         {
 933                                 if (vertexupdate[element[j]] != vertexupdatenum)
 934                                 {
 935                                         vertexupdate[element[j]] = vertexupdatenum;
 936                                         vertexremap[element[j]] = outvertices;
 937                                         vertex = invertex3f + element[j] * 3;
 938                                         // project one copy of the vertex to the sphere radius of the light
 939                                         // (FIXME: would projecting it to the light box be better?)
 940                                         VectorSubtract(vertex, projectorigin, direction);
 941                                         ratio = projectdistance / VectorLength(direction);
 942                                         VectorCopy(vertex, outvertex3f);
 943                                         VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
 944                                         outvertex3f += 6;
 945                                         outvertices += 2;
 946                                 }
 947                         }
 948                 }
 949         }
 950
 951         if (r_shadow_frontsidecasting.integer)
 952         {
 953                 for (i = 0;i < numshadowmarktris;i++)
 954                 {
 955                         int remappedelement[3];
 956                         int markindex;
 957                         const int *neighbortriangle;
 958
 959                         markindex = shadowmarktris[i] * 3;
 960                         element = inelement3i + markindex;
 961                         neighbortriangle = inneighbor3i + markindex;
 962                         // output the front and back triangles
 963                         outelement3i[0] = vertexremap[element[0]];
 964                         outelement3i[1] = vertexremap[element[1]];
 965                         outelement3i[2] = vertexremap[element[2]];
 966                         outelement3i[3] = vertexremap[element[2]] + 1;
 967                         outelement3i[4] = vertexremap[element[1]] + 1;
 968                         outelement3i[5] = vertexremap[element[0]] + 1;
 969
 970                         outelement3i += 6;
 971                         outtriangles += 2;
 972                         // output the sides (facing outward from this triangle)
 973                         if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
 974                         {
 975                                 remappedelement[0] = vertexremap[element[0]];
 976                                 remappedelement[1] = vertexremap[element[1]];
 977                                 outelement3i[0] = remappedelement[1];
 978                                 outelement3i[1] = remappedelement[0];
 979                                 outelement3i[2] = remappedelement[0] + 1;
 980                                 outelement3i[3] = remappedelement[1];
 981                                 outelement3i[4] = remappedelement[0] + 1;
 982                                 outelement3i[5] = remappedelement[1] + 1;
 983
 984                                 outelement3i += 6;
 985                                 outtriangles += 2;
 986                         }
 987                         if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
 988                         {
 989                                 remappedelement[1] = vertexremap[element[1]];
 990                                 remappedelement[2] = vertexremap[element[2]];
 991                                 outelement3i[0] = remappedelement[2];
 992                                 outelement3i[1] = remappedelement[1];
 993                                 outelement3i[2] = remappedelement[1] + 1;
 994                                 outelement3i[3] = remappedelement[2];
 995                                 outelement3i[4] = remappedelement[1] + 1;
 996                                 outelement3i[5] = remappedelement[2] + 1;
 997
 998                                 outelement3i += 6;
 999                                 outtriangles += 2;
1000                         }
1001                         if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1002                         {
1003                                 remappedelement[0] = vertexremap[element[0]];
1004                                 remappedelement[2] = vertexremap[element[2]];
1005                                 outelement3i[0] = remappedelement[0];
1006                                 outelement3i[1] = remappedelement[2];
1007                                 outelement3i[2] = remappedelement[2] + 1;
1008                                 outelement3i[3] = remappedelement[0];
1009                                 outelement3i[4] = remappedelement[2] + 1;
1010                                 outelement3i[5] = remappedelement[0] + 1;
1011
1012                                 outelement3i += 6;
1013                                 outtriangles += 2;
1014                         }
1015                 }
1016         }
1017         else
1018         {
1019                 for (i = 0;i < numshadowmarktris;i++)
1020                 {
1021                         int remappedelement[3];
1022                         int markindex;
1023                         const int *neighbortriangle;
1024
1025                         markindex = shadowmarktris[i] * 3;
1026                         element = inelement3i + markindex;
1027                         neighbortriangle = inneighbor3i + markindex;
1028                         // output the front and back triangles
1029                         outelement3i[0] = vertexremap[element[2]];
1030                         outelement3i[1] = vertexremap[element[1]];
1031                         outelement3i[2] = vertexremap[element[0]];
1032                         outelement3i[3] = vertexremap[element[0]] + 1;
1033                         outelement3i[4] = vertexremap[element[1]] + 1;
1034                         outelement3i[5] = vertexremap[element[2]] + 1;
1035
1036                         outelement3i += 6;
1037                         outtriangles += 2;
1038                         // output the sides (facing outward from this triangle)
1039                         if (shadowmark[neighbortriangle[0]] != shadowmarkcount)
1040                         {
1041                                 remappedelement[0] = vertexremap[element[0]];
1042                                 remappedelement[1] = vertexremap[element[1]];
1043                                 outelement3i[0] = remappedelement[0];
1044                                 outelement3i[1] = remappedelement[1];
1045                                 outelement3i[2] = remappedelement[1] + 1;
1046                                 outelement3i[3] = remappedelement[0];
1047                                 outelement3i[4] = remappedelement[1] + 1;
1048                                 outelement3i[5] = remappedelement[0] + 1;
1049
1050                                 outelement3i += 6;
1051                                 outtriangles += 2;
1052                         }
1053                         if (shadowmark[neighbortriangle[1]] != shadowmarkcount)
1054                         {
1055                                 remappedelement[1] = vertexremap[element[1]];
1056                                 remappedelement[2] = vertexremap[element[2]];
1057                                 outelement3i[0] = remappedelement[1];
1058                                 outelement3i[1] = remappedelement[2];
1059                                 outelement3i[2] = remappedelement[2] + 1;
1060                                 outelement3i[3] = remappedelement[1];
1061                                 outelement3i[4] = remappedelement[2] + 1;
1062                                 outelement3i[5] = remappedelement[1] + 1;
1063
1064                                 outelement3i += 6;
1065                                 outtriangles += 2;
1066                         }
1067                         if (shadowmark[neighbortriangle[2]] != shadowmarkcount)
1068                         {
1069                                 remappedelement[0] = vertexremap[element[0]];
1070                                 remappedelement[2] = vertexremap[element[2]];
1071                                 outelement3i[0] = remappedelement[2];
1072                                 outelement3i[1] = remappedelement[0];
1073                                 outelement3i[2] = remappedelement[0] + 1;
1074                                 outelement3i[3] = remappedelement[2];
1075                                 outelement3i[4] = remappedelement[0] + 1;
1076                                 outelement3i[5] = remappedelement[2] + 1;
1077
1078                                 outelement3i += 6;
1079                                 outtriangles += 2;
1080                         }
1081                 }
1082         }
1083         if (outnumvertices)
1084                 *outnumvertices = outvertices;
1085         return outtriangles;
1086 }
1087
1088 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)
1089 {
1090         int i, j, k;
1091         int outtriangles = 0, outvertices = 0;
1092         const int *element;
1093         const float *vertex;
1094         float ratio, direction[3], projectvector[3];
1095         qboolean side[4];
1096
1097         if (projectdirection)
1098                 VectorScale(projectdirection, projectdistance, projectvector);
1099         else
1100                 VectorClear(projectvector);
1101
1102         for (i = 0;i < numshadowmarktris;i++)
1103         {
1104                 int remappedelement[3];
1105                 int markindex;
1106                 const int *neighbortriangle;
1107
1108                 markindex = shadowmarktris[i] * 3;
1109                 neighbortriangle = inneighbor3i + markindex;
1110                 side[0] = shadowmark[neighbortriangle[0]] == shadowmarkcount;
1111                 side[1] = shadowmark[neighbortriangle[1]] == shadowmarkcount;
1112                 side[2] = shadowmark[neighbortriangle[2]] == shadowmarkcount;
1113                 if (side[0] + side[1] + side[2] == 0)
1114                         continue;
1115
1116                 side[3] = side[0];
1117                 element = inelement3i + markindex;
1118
1119                 // create the vertices
1120                 for (j = 0;j < 3;j++)
1121                 {
1122                         if (side[j] + side[j+1] == 0)
1123                                 continue;
1124                         k = element[j];
1125                         if (vertexupdate[k] != vertexupdatenum)
1126                         {
1127                                 vertexupdate[k] = vertexupdatenum;
1128                                 vertexremap[k] = outvertices;
1129                                 vertex = invertex3f + k * 3;
1130                                 VectorCopy(vertex, outvertex3f);
1131                                 if (projectdirection)
1132                                 {
1133                                         // project one copy of the vertex according to projectvector
1134                                         VectorAdd(vertex, projectvector, (outvertex3f + 3));
1135                                 }
1136                                 else
1137                                 {
1138                                         // project one copy of the vertex to the sphere radius of the light
1139                                         // (FIXME: would projecting it to the light box be better?)
1140                                         VectorSubtract(vertex, projectorigin, direction);
1141                                         ratio = projectdistance / VectorLength(direction);
1142                                         VectorMA(projectorigin, ratio, direction, (outvertex3f + 3));
1143                                 }
1144                                 outvertex3f += 6;
1145                                 outvertices += 2;
1146                         }
1147                 }
1148
1149                 // output the sides (facing outward from this triangle)
1150                 if (!side[0])
1151                 {
1152                         remappedelement[0] = vertexremap[element[0]];
1153                         remappedelement[1] = vertexremap[element[1]];
1154                         outelement3i[0] = remappedelement[1];
1155                         outelement3i[1] = remappedelement[0];
1156                         outelement3i[2] = remappedelement[0] + 1;
1157                         outelement3i[3] = remappedelement[1];
1158                         outelement3i[4] = remappedelement[0] + 1;
1159                         outelement3i[5] = remappedelement[1] + 1;
1160
1161                         outelement3i += 6;
1162                         outtriangles += 2;
1163                 }
1164                 if (!side[1])
1165                 {
1166                         remappedelement[1] = vertexremap[element[1]];
1167                         remappedelement[2] = vertexremap[element[2]];
1168                         outelement3i[0] = remappedelement[2];
1169                         outelement3i[1] = remappedelement[1];
1170                         outelement3i[2] = remappedelement[1] + 1;
1171                         outelement3i[3] = remappedelement[2];
1172                         outelement3i[4] = remappedelement[1] + 1;
1173                         outelement3i[5] = remappedelement[2] + 1;
1174
1175                         outelement3i += 6;
1176                         outtriangles += 2;
1177                 }
1178                 if (!side[2])
1179                 {
1180                         remappedelement[0] = vertexremap[element[0]];
1181                         remappedelement[2] = vertexremap[element[2]];
1182                         outelement3i[0] = remappedelement[0];
1183                         outelement3i[1] = remappedelement[2];
1184                         outelement3i[2] = remappedelement[2] + 1;
1185                         outelement3i[3] = remappedelement[0];
1186                         outelement3i[4] = remappedelement[2] + 1;
1187                         outelement3i[5] = remappedelement[0] + 1;
1188
1189                         outelement3i += 6;
1190                         outtriangles += 2;
1191                 }
1192         }
1193         if (outnumvertices)
1194                 *outnumvertices = outvertices;
1195         return outtriangles;
1196 }
1197
1198 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)
1199 {
1200         int t, tend;
1201         const int *e;
1202         const float *v[3];
1203         float normal[3];
1204         if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1205                 return;
1206         tend = firsttriangle + numtris;
1207         if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1208         {
1209                 // surface box entirely inside light box, no box cull
1210                 if (projectdirection)
1211                 {
1212                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1213                         {
1214                                 TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal);
1215                                 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1216                                         shadowmarklist[numshadowmark++] = t;
1217                         }
1218                 }
1219                 else
1220                 {
1221                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1222                                 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3))
1223                                         shadowmarklist[numshadowmark++] = t;
1224                 }
1225         }
1226         else
1227         {
1228                 // surface box not entirely inside light box, cull each triangle
1229                 if (projectdirection)
1230                 {
1231                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1232                         {
1233                                 v[0] = invertex3f + e[0] * 3;
1234                                 v[1] = invertex3f + e[1] * 3;
1235                                 v[2] = invertex3f + e[2] * 3;
1236                                 TriangleNormal(v[0], v[1], v[2], normal);
1237                                 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1238                                  && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1239                                         shadowmarklist[numshadowmark++] = t;
1240                         }
1241                 }
1242                 else
1243                 {
1244                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1245                         {
1246                                 v[0] = invertex3f + e[0] * 3;
1247                                 v[1] = invertex3f + e[1] * 3;
1248                                 v[2] = invertex3f + e[2] * 3;
1249                                 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1250                                  && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1251                                         shadowmarklist[numshadowmark++] = t;
1252                         }
1253                 }
1254         }
1255 }
1256
1257 qboolean R_Shadow_UseZPass(vec3_t mins, vec3_t maxs)
1258 {
1259 #if 1
1260         return false;
1261 #else
1262         if (r_shadow_compilingrtlight || !r_shadow_frontsidecasting.integer || !r_shadow_usezpassifpossible.integer)
1263                 return false;
1264         // check if the shadow volume intersects the near plane
1265         //
1266         // a ray between the eye and light origin may intersect the caster,
1267         // indicating that the shadow may touch the eye location, however we must
1268         // test the near plane (a polygon), not merely the eye location, so it is
1269         // easiest to enlarge the caster bounding shape slightly for this.
1270         // TODO
1271         return true;
1272 #endif
1273 }
1274
1275 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)
1276 {
1277         int i, tris, outverts;
1278         if (projectdistance < 0.1)
1279         {
1280                 Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance);
1281                 return;
1282         }
1283         if (!numverts || !nummarktris)
1284                 return;
1285         // make sure shadowelements is big enough for this volume
1286         if (maxshadowtriangles < nummarktris*8 || maxshadowvertices < numverts*2)
1287                 R_Shadow_ResizeShadowArrays(numverts, nummarktris, 2, 8);
1288
1289         if (maxvertexupdate < numverts)
1290         {
1291                 maxvertexupdate = numverts;
1292                 if (vertexupdate)
1293                         Mem_Free(vertexupdate);
1294                 if (vertexremap)
1295                         Mem_Free(vertexremap);
1296                 vertexupdate = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1297                 vertexremap = (int *)Mem_Alloc(r_main_mempool, maxvertexupdate * sizeof(int));
1298                 vertexupdatenum = 0;
1299         }
1300         vertexupdatenum++;
1301         if (vertexupdatenum == 0)
1302         {
1303                 vertexupdatenum = 1;
1304                 memset(vertexupdate, 0, maxvertexupdate * sizeof(int));
1305                 memset(vertexremap, 0, maxvertexupdate * sizeof(int));
1306         }
1307
1308         for (i = 0;i < nummarktris;i++)
1309                 shadowmark[marktris[i]] = shadowmarkcount;
1310
1311         if (r_shadow_compilingrtlight)
1312         {
1313                 // if we're compiling an rtlight, capture the mesh
1314                 //tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1315                 //Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zpass, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1316                 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1317                 Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_zfail, NULL, NULL, NULL, shadowvertex3f, NULL, NULL, NULL, NULL, tris, shadowelements);
1318         }
1319         else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
1320         {
1321                 tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1322                 R_Mesh_VertexPointer(shadowvertex3f, 0, 0);
1323                 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1324         }
1325         else
1326         {
1327                 // decide which type of shadow to generate and set stencil mode
1328                 R_Shadow_RenderMode_StencilShadowVolumes(R_Shadow_UseZPass(trismins, trismaxs));
1329                 // generate the sides or a solid volume, depending on type
1330                 if (r_shadow_rendermode >= R_SHADOW_RENDERMODE_ZPASS_STENCIL && r_shadow_rendermode <= R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE)
1331                         tris = R_Shadow_ConstructShadowVolume_ZPass(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1332                 else
1333                         tris = R_Shadow_ConstructShadowVolume_ZFail(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris);
1334                 r_refdef.stats.lights_dynamicshadowtriangles += tris;
1335                 r_refdef.stats.lights_shadowtriangles += tris;
1336                 CHECKGLERROR
1337                 R_Mesh_VertexPointer(shadowvertex3f, 0, 0);
1338                 GL_LockArrays(0, outverts);
1339                 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
1340                 {
1341                         // increment stencil if frontface is infront of depthbuffer
1342                         GL_CullFace(r_refdef.view.cullface_front);
1343                         qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
1344                         R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1345                         // decrement stencil if backface is infront of depthbuffer
1346                         GL_CullFace(r_refdef.view.cullface_back);
1347                         qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
1348                 }
1349                 else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
1350                 {
1351                         // decrement stencil if backface is behind depthbuffer
1352                         GL_CullFace(r_refdef.view.cullface_front);
1353                         qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
1354                         R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1355                         // increment stencil if frontface is behind depthbuffer
1356                         GL_CullFace(r_refdef.view.cullface_back);
1357                         qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
1358                 }
1359                 R_Mesh_Draw(0, outverts, 0, tris, shadowelements, NULL, 0, 0);
1360                 GL_LockArrays(0, 0);
1361                 CHECKGLERROR
1362         }
1363 }
1364
1365 int R_Shadow_CalcTriangleSideMask(const vec3_t p1, const vec3_t p2, const vec3_t p3, float bias)
1366 {
1367     // p1, p2, p3 are in the cubemap's local coordinate system
1368     // bias = border/(size - border)
1369         int mask = 0x3F;
1370
1371     float dp1 = p1[0] + p1[1], dn1 = p1[0] - p1[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1372           dp2 = p2[0] + p2[1], dn2 = p2[0] - p2[1], ap2 = fabs(dp2), an2 = fabs(dn2),
1373           dp3 = p3[0] + p3[1], dn3 = p3[0] - p3[1], ap3 = fabs(dp3), an3 = fabs(dn3);
1374         if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1375         mask &= (3<<4)
1376                         | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1377                         | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1378                         | (dp3 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1379     if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1380         mask &= (3<<4)
1381             | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1382             | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1383             | (dn3 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1384
1385     dp1 = p1[1] + p1[2], dn1 = p1[1] - p1[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1386     dp2 = p2[1] + p2[2], dn2 = p2[1] - p2[2], ap2 = fabs(dp2), an2 = fabs(dn2),
1387     dp3 = p3[1] + p3[2], dn3 = p3[1] - p3[2], ap3 = fabs(dp3), an3 = fabs(dn3);
1388     if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1389         mask &= (3<<0)
1390             | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1391             | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1392             | (dp3 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1393     if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1394         mask &= (3<<0)
1395             | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1396             | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1397             | (dn3 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1398
1399     dp1 = p1[2] + p1[0], dn1 = p1[2] - p1[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1400     dp2 = p2[2] + p2[0], dn2 = p2[2] - p2[0], ap2 = fabs(dp2), an2 = fabs(dn2),
1401     dp3 = p3[2] + p3[0], dn3 = p3[2] - p3[0], ap3 = fabs(dp3), an3 = fabs(dn3);
1402     if(ap1 > bias*an1 && ap2 > bias*an2 && ap3 > bias*an3)
1403         mask &= (3<<2)
1404             | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1405             | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1406             | (dp3 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1407     if(an1 > bias*ap1 && an2 > bias*ap2 && an3 > bias*ap3)
1408         mask &= (3<<2)
1409             | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1410             | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1411             | (dn3 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1412
1413         return mask;
1414 }
1415
1416 int R_Shadow_CalcBBoxSideMask(const vec3_t mins, const vec3_t maxs, const matrix4x4_t *worldtolight, const matrix4x4_t *radiustolight, float bias)
1417 {
1418         vec3_t center, radius, lightcenter, lightradius, pmin, pmax;
1419         float dp1, dn1, ap1, an1, dp2, dn2, ap2, an2;
1420         int mask = 0x3F;
1421
1422         VectorSubtract(maxs, mins, radius);
1423     VectorScale(radius, 0.5f, radius);
1424     VectorAdd(mins, radius, center);
1425     Matrix4x4_Transform(worldtolight, center, lightcenter);
1426         Matrix4x4_Transform3x3(radiustolight, radius, lightradius);
1427         VectorSubtract(lightcenter, lightradius, pmin);
1428         VectorAdd(lightcenter, lightradius, pmax);
1429
1430     dp1 = pmax[0] + pmax[1], dn1 = pmax[0] - pmin[1], ap1 = fabs(dp1), an1 = fabs(dn1),
1431     dp2 = pmin[0] + pmin[1], dn2 = pmin[0] - pmax[1], ap2 = fabs(dp2), an2 = fabs(dn2);
1432     if(ap1 > bias*an1 && ap2 > bias*an2)
1433         mask &= (3<<4)
1434             | (dp1 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2))
1435             | (dp2 >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1436     if(an1 > bias*ap1 && an2 > bias*ap2)
1437         mask &= (3<<4)
1438             | (dn1 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2))
1439             | (dn2 >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1440
1441     dp1 = pmax[1] + pmax[2], dn1 = pmax[1] - pmin[2], ap1 = fabs(dp1), an1 = fabs(dn1),
1442     dp2 = pmin[1] + pmin[2], dn2 = pmin[1] - pmax[2], ap2 = fabs(dp2), an2 = fabs(dn2);
1443     if(ap1 > bias*an1 && ap2 > bias*an2)
1444         mask &= (3<<0)
1445             | (dp1 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4))
1446             | (dp2 >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1447     if(an1 > bias*ap1 && an2 > bias*ap2)
1448         mask &= (3<<0)
1449             | (dn1 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4))
1450             | (dn2 >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1451
1452     dp1 = pmax[2] + pmax[0], dn1 = pmax[2] - pmin[0], ap1 = fabs(dp1), an1 = fabs(dn1),
1453     dp2 = pmin[2] + pmin[0], dn2 = pmin[2] - pmax[0], ap2 = fabs(dp2), an2 = fabs(dn2);
1454     if(ap1 > bias*an1 && ap2 > bias*an2)
1455         mask &= (3<<2)
1456             | (dp1 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0))
1457             | (dp2 >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1458     if(an1 > bias*ap1 && an2 > bias*ap2)
1459         mask &= (3<<2)
1460             | (dn1 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0))
1461             | (dn2 >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1462
1463     return mask;
1464 }
1465
1466 #define R_Shadow_CalcEntitySideMask(ent, worldtolight, radiustolight, bias) R_Shadow_CalcBBoxSideMask((ent)->mins, (ent)->maxs, worldtolight, radiustolight, bias)
1467
1468 int R_Shadow_CalcSphereSideMask(const vec3_t p, float radius, float bias)
1469 {
1470     // p is in the cubemap's local coordinate system
1471     // bias = border/(size - border)
1472     float dxyp = p[0] + p[1], dxyn = p[0] - p[1], axyp = fabs(dxyp), axyn = fabs(dxyn);
1473     float dyzp = p[1] + p[2], dyzn = p[1] - p[2], ayzp = fabs(dyzp), ayzn = fabs(dyzn);
1474     float dzxp = p[2] + p[0], dzxn = p[2] - p[0], azxp = fabs(dzxp), azxn = fabs(dzxn);
1475     int mask = 0x3F;
1476     if(axyp > bias*axyn + radius) mask &= dxyp < 0 ? ~((1<<0)|(1<<2)) : ~((2<<0)|(2<<2));
1477     if(axyn > bias*axyp + radius) mask &= dxyn < 0 ? ~((1<<0)|(2<<2)) : ~((2<<0)|(1<<2));
1478     if(ayzp > bias*ayzn + radius) mask &= dyzp < 0 ? ~((1<<2)|(1<<4)) : ~((2<<2)|(2<<4));
1479     if(ayzn > bias*ayzp + radius) mask &= dyzn < 0 ? ~((1<<2)|(2<<4)) : ~((2<<2)|(1<<4));
1480     if(azxp > bias*azxn + radius) mask &= dzxp < 0 ? ~((1<<4)|(1<<0)) : ~((2<<4)|(2<<0));
1481     if(azxn > bias*azxp + radius) mask &= dzxn < 0 ? ~((1<<4)|(2<<0)) : ~((2<<4)|(1<<0));
1482     return mask;
1483 }
1484
1485 int R_Shadow_CullFrustumSides(rtlight_t *rtlight, float size, float border)
1486 {
1487         int i;
1488         vec3_t p, n;
1489         int sides = 0x3F, masks[6] = { 3<<4, 3<<4, 3<<0, 3<<0, 3<<2, 3<<2 };
1490         float scale = (size - 2*border)/size, len;
1491         float bias = border / (float)(size - border), dp, dn, ap, an;
1492         // check if cone enclosing side would cross frustum plane
1493         scale = 2 / (scale*scale + 2);
1494         for (i = 0;i < 5;i++)
1495         {
1496                 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) > -0.03125)
1497                         continue;
1498                 Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[i].normal, n);
1499                 len = scale*VectorLength2(n);
1500                 if(n[0]*n[0] > len) sides &= n[0] < 0 ? ~(1<<0) : ~(2 << 0);
1501                 if(n[1]*n[1] > len) sides &= n[1] < 0 ? ~(1<<2) : ~(2 << 2);
1502                 if(n[2]*n[2] > len) sides &= n[2] < 0 ? ~(1<<4) : ~(2 << 4);
1503         }
1504         if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[4]) >= r_refdef.farclip - r_refdef.nearclip + 0.03125)
1505         {
1506         Matrix4x4_Transform3x3(&rtlight->matrix_worldtolight, r_refdef.view.frustum[4].normal, n);
1507         len = scale*VectorLength(n);
1508                 if(n[0]*n[0] > len) sides &= n[0] >= 0 ? ~(1<<0) : ~(2 << 0);
1509                 if(n[1]*n[1] > len) sides &= n[1] >= 0 ? ~(1<<2) : ~(2 << 2);
1510                 if(n[2]*n[2] > len) sides &= n[2] >= 0 ? ~(1<<4) : ~(2 << 4);
1511         }
1512         // this next test usually clips off more sides than the former, but occasionally clips fewer/different ones, so do both and combine results
1513         // check if frustum corners/origin cross plane sides
1514         for (i = 0;i < 5;i++)
1515         {
1516                 Matrix4x4_Transform(&rtlight->matrix_worldtolight, !i ? r_refdef.view.origin : r_refdef.view.frustumcorner[i-1], p);
1517                 dp = p[0] + p[1], dn = p[0] - p[1], ap = fabs(dp), an = fabs(dn),
1518                 masks[0] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<0)|(1<<2) : (2<<0)|(2<<2));
1519                 masks[1] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<0)|(2<<2) : (2<<0)|(1<<2));
1520                 dp = p[1] + p[2], dn = p[1] - p[2], ap = fabs(dp), an = fabs(dn),
1521                 masks[2] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<2)|(1<<4) : (2<<2)|(2<<4));
1522                 masks[3] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<2)|(2<<4) : (2<<2)|(1<<4));
1523                 dp = p[2] + p[0], dn = p[2] - p[0], ap = fabs(dp), an = fabs(dn),
1524                 masks[4] |= ap <= bias*an ? 0x3F : (dp >= 0 ? (1<<4)|(1<<0) : (2<<4)|(2<<0));
1525                 masks[5] |= an <= bias*ap ? 0x3F : (dn >= 0 ? (1<<4)|(2<<0) : (2<<4)|(1<<0));
1526         }
1527         return sides & masks[0] & masks[1] & masks[2] & masks[3] & masks[4] & masks[5];
1528 }
1529
1530 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)
1531 {
1532         int t, tend;
1533         const int *e;
1534         const float *v[3];
1535         float normal[3];
1536         vec3_t p[3];
1537         float bias;
1538         int mask, surfacemask = 0;
1539         if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs))
1540                 return 0;
1541         bias = r_shadow_shadowmapborder / (float)(r_shadow_shadowmapmaxsize - r_shadow_shadowmapborder);
1542         tend = firsttriangle + numtris;
1543         if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs))
1544         {
1545                 // surface box entirely inside light box, no box cull
1546                 if (projectdirection)
1547                 {
1548                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1549                         {
1550                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1551                                 TriangleNormal(v[0], v[1], v[2], normal);
1552                                 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0))
1553                                 {
1554                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1555                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1556                                         surfacemask |= mask;
1557                                         if(totals)
1558                                         {
1559                                                 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;
1560                                                 shadowsides[numshadowsides] = mask;
1561                                                 shadowsideslist[numshadowsides++] = t;
1562                                         }
1563                                 }
1564                         }
1565                 }
1566                 else
1567                 {
1568                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1569                         {
1570                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3,     v[2] = invertex3f + e[2] * 3;
1571                                 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]))
1572                                 {
1573                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1574                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1575                                         surfacemask |= mask;
1576                                         if(totals)
1577                                         {
1578                                                 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;
1579                                                 shadowsides[numshadowsides] = mask;
1580                                                 shadowsideslist[numshadowsides++] = t;
1581                                         }
1582                                 }
1583                         }
1584                 }
1585         }
1586         else
1587         {
1588                 // surface box not entirely inside light box, cull each triangle
1589                 if (projectdirection)
1590                 {
1591                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1592                         {
1593                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3,     v[2] = invertex3f + e[2] * 3;
1594                                 TriangleNormal(v[0], v[1], v[2], normal);
1595                                 if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)
1596                                  && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1597                                 {
1598                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1599                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1600                                         surfacemask |= mask;
1601                                         if(totals)
1602                                         {
1603                                                 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;
1604                                                 shadowsides[numshadowsides] = mask;
1605                                                 shadowsideslist[numshadowsides++] = t;
1606                                         }
1607                                 }
1608                         }
1609                 }
1610                 else
1611                 {
1612                         for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3)
1613                         {
1614                                 v[0] = invertex3f + e[0] * 3, v[1] = invertex3f + e[1] * 3, v[2] = invertex3f + e[2] * 3;
1615                                 if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2])
1616                                  && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs))
1617                                 {
1618                                         Matrix4x4_Transform(worldtolight, v[0], p[0]), Matrix4x4_Transform(worldtolight, v[1], p[1]), Matrix4x4_Transform(worldtolight, v[2], p[2]);
1619                                         mask = R_Shadow_CalcTriangleSideMask(p[0], p[1], p[2], bias);
1620                                         surfacemask |= mask;
1621                                         if(totals)
1622                                         {
1623                                                 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;
1624                                                 shadowsides[numshadowsides] = mask;
1625                                                 shadowsideslist[numshadowsides++] = t;
1626                                         }
1627                                 }
1628                         }
1629                 }
1630         }
1631         return surfacemask;
1632 }
1633
1634 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)
1635 {
1636         int i, j, outtriangles = 0;
1637         int *outelement3i[6];
1638         if (!numverts || !numsidetris || !r_shadow_compilingrtlight)
1639                 return;
1640         outtriangles = sidetotals[0] + sidetotals[1] + sidetotals[2] + sidetotals[3] + sidetotals[4] + sidetotals[5];
1641         // make sure shadowelements is big enough for this mesh
1642         if (maxshadowtriangles < outtriangles)
1643                 R_Shadow_ResizeShadowArrays(0, outtriangles, 0, 1);
1644
1645         // compute the offset and size of the separate index lists for each cubemap side
1646         outtriangles = 0;
1647         for (i = 0;i < 6;i++)
1648         {
1649                 outelement3i[i] = shadowelements + outtriangles * 3;
1650                 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sideoffsets[i] = outtriangles;
1651                 r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap->sidetotals[i] = sidetotals[i];
1652                 outtriangles += sidetotals[i];
1653         }
1654
1655         // gather up the (sparse) triangles into separate index lists for each cubemap side
1656         for (i = 0;i < numsidetris;i++)
1657         {
1658                 const int *element = elements + sidetris[i] * 3;
1659                 for (j = 0;j < 6;j++)
1660                 {
1661                         if (sides[i] & (1 << j))
1662                         {
1663                                 outelement3i[j][0] = element[0];
1664                                 outelement3i[j][1] = element[1];
1665                                 outelement3i[j][2] = element[2];
1666                                 outelement3i[j] += 3;
1667                         }
1668                 }
1669         }
1670
1671         Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow_shadowmap, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, outtriangles, shadowelements);
1672 }
1673
1674 static void R_Shadow_MakeTextures_MakeCorona(void)
1675 {
1676         float dx, dy;
1677         int x, y, a;
1678         unsigned char pixels[32][32][4];
1679         for (y = 0;y < 32;y++)
1680         {
1681                 dy = (y - 15.5f) * (1.0f / 16.0f);
1682                 for (x = 0;x < 32;x++)
1683                 {
1684                         dx = (x - 15.5f) * (1.0f / 16.0f);
1685                         a = (int)(((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2)));
1686                         a = bound(0, a, 255);
1687                         pixels[y][x][0] = a;
1688                         pixels[y][x][1] = a;
1689                         pixels[y][x][2] = a;
1690                         pixels[y][x][3] = 255;
1691                 }
1692         }
1693         r_shadow_lightcorona = R_SkinFrame_LoadInternalBGRA("lightcorona", TEXF_PRECACHE | TEXF_FORCELINEAR, &pixels[0][0][0], 32, 32);
1694 }
1695
1696 static unsigned int R_Shadow_MakeTextures_SamplePoint(float x, float y, float z)
1697 {
1698         float dist = sqrt(x*x+y*y+z*z);
1699         float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1700         // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways
1701         return (unsigned char)bound(0, intensity * 256.0f, 255) * 0x01010101;
1702 }
1703
1704 static void R_Shadow_MakeTextures(void)
1705 {
1706         int x, y, z;
1707         float intensity, dist;
1708         unsigned int *data;
1709         R_Shadow_FreeShadowMaps();
1710         R_FreeTexturePool(&r_shadow_texturepool);
1711         r_shadow_texturepool = R_AllocTexturePool();
1712         r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value;
1713         r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value;
1714         data = (unsigned int *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE) * 4);
1715         // the table includes one additional value to avoid the need to clamp indexing due to minor math errors
1716         for (x = 0;x <= ATTENTABLESIZE;x++)
1717         {
1718                 dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375);
1719                 intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
1720                 r_shadow_attentable[x] = bound(0, intensity, 1);
1721         }
1722         // 1D gradient texture
1723         for (x = 0;x < ATTEN1DSIZE;x++)
1724                 data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0);
1725         r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, NULL);
1726         // 2D circle texture
1727         for (y = 0;y < ATTEN2DSIZE;y++)
1728                 for (x = 0;x < ATTEN2DSIZE;x++)
1729                         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);
1730         r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, NULL);
1731         // 3D sphere texture
1732         if (r_shadow_texture3d.integer && vid.support.ext_texture_3d)
1733         {
1734                 for (z = 0;z < ATTEN3DSIZE;z++)
1735                         for (y = 0;y < ATTEN3DSIZE;y++)
1736                                 for (x = 0;x < ATTEN3DSIZE;x++)
1737                                         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));
1738                 r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, (unsigned char *)data, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCELINEAR, NULL);
1739         }
1740         else
1741                 r_shadow_attenuation3dtexture = NULL;
1742         Mem_Free(data);
1743
1744         R_Shadow_MakeTextures_MakeCorona();
1745
1746         // Editor light sprites
1747         r_editlights_sprcursor = R_SkinFrame_LoadInternal8bit("gfx/editlights/cursor", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1748         "................"
1749         ".3............3."
1750         "..5...2332...5.."
1751         "...7.3....3.7..."
1752         "....7......7...."
1753         "...3.7....7.3..."
1754         "..2...7..7...2.."
1755         "..3..........3.."
1756         "..3..........3.."
1757         "..2...7..7...2.."
1758         "...3.7....7.3..."
1759         "....7......7...."
1760         "...7.3....3.7..."
1761         "..5...2332...5.."
1762         ".3............3."
1763         "................"
1764         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1765         r_editlights_sprlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/light", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1766         "................"
1767         "................"
1768         "......1111......"
1769         "....11233211...."
1770         "...1234554321..."
1771         "...1356776531..."
1772         "..124677776421.."
1773         "..135777777531.."
1774         "..135777777531.."
1775         "..124677776421.."
1776         "...1356776531..."
1777         "...1234554321..."
1778         "....11233211...."
1779         "......1111......"
1780         "................"
1781         "................"
1782         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1783         r_editlights_sprnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/noshadow", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1784         "................"
1785         "................"
1786         "......1111......"
1787         "....11233211...."
1788         "...1234554321..."
1789         "...1356226531..."
1790         "..12462..26421.."
1791         "..1352....2531.."
1792         "..1352....2531.."
1793         "..12462..26421.."
1794         "...1356226531..."
1795         "...1234554321..."
1796         "....11233211...."
1797         "......1111......"
1798         "................"
1799         "................"
1800         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1801         r_editlights_sprcubemaplight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemaplight", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1802         "................"
1803         "................"
1804         "......2772......"
1805         "....27755772...."
1806         "..277533335772.."
1807         "..753333333357.."
1808         "..777533335777.."
1809         "..735775577537.."
1810         "..733357753337.."
1811         "..733337733337.."
1812         "..753337733357.."
1813         "..277537735772.."
1814         "....27777772...."
1815         "......2772......"
1816         "................"
1817         "................"
1818         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1819         r_editlights_sprcubemapnoshadowlight = R_SkinFrame_LoadInternal8bit("gfx/editlights/cubemapnoshadowlight", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (const unsigned char *)
1820         "................"
1821         "................"
1822         "......2772......"
1823         "....27722772...."
1824         "..2772....2772.."
1825         "..72........27.."
1826         "..7772....2777.."
1827         "..7.27722772.7.."
1828         "..7...2772...7.."
1829         "..7....77....7.."
1830         "..72...77...27.."
1831         "..2772.77.2772.."
1832         "....27777772...."
1833         "......2772......"
1834         "................"
1835         "................"
1836         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1837         r_editlights_sprselection = R_SkinFrame_LoadInternal8bit("gfx/editlights/selection", TEXF_PRECACHE | TEXF_ALPHA | TEXF_CLAMP, (unsigned char *)
1838         "................"
1839         ".777752..257777."
1840         ".742........247."
1841         ".72..........27."
1842         ".7............7."
1843         ".5............5."
1844         ".2............2."
1845         "................"
1846         "................"
1847         ".2............2."
1848         ".5............5."
1849         ".7............7."
1850         ".72..........27."
1851         ".742........247."
1852         ".777752..257777."
1853         "................"
1854         , 16, 16, palette_bgra_embeddedpic, palette_bgra_embeddedpic);
1855 }
1856
1857 void R_Shadow_ValidateCvars(void)
1858 {
1859         if (r_shadow_texture3d.integer && !vid.support.ext_texture_3d)
1860                 Cvar_SetValueQuick(&r_shadow_texture3d, 0);
1861         if (gl_ext_separatestencil.integer && !vid.support.ati_separate_stencil)
1862                 Cvar_SetValueQuick(&gl_ext_separatestencil, 0);
1863         if (gl_ext_stenciltwoside.integer && !vid.support.ext_stencil_two_side)
1864                 Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0);
1865 }
1866
1867 void R_Shadow_RenderMode_Begin(void)
1868 {
1869 #if 0
1870         GLint drawbuffer;
1871         GLint readbuffer;
1872 #endif
1873         R_Shadow_ValidateCvars();
1874
1875         if (!r_shadow_attenuation2dtexture
1876          || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer)
1877          || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias
1878          || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale)
1879                 R_Shadow_MakeTextures();
1880
1881         CHECKGLERROR
1882         R_Mesh_ColorPointer(NULL, 0, 0);
1883         R_Mesh_ResetTextureState();
1884         GL_BlendFunc(GL_ONE, GL_ZERO);
1885         GL_DepthRange(0, 1);
1886         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
1887         GL_DepthTest(true);
1888         GL_DepthMask(false);
1889         GL_Color(0, 0, 0, 1);
1890         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
1891
1892         r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
1893
1894         if (gl_ext_separatestencil.integer && vid.support.ati_separate_stencil)
1895         {
1896                 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL;
1897                 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL;
1898         }
1899         else if (gl_ext_stenciltwoside.integer && vid.support.ext_stencil_two_side)
1900         {
1901                 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE;
1902                 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE;
1903         }
1904         else
1905         {
1906                 r_shadow_shadowingrendermode_zpass = R_SHADOW_RENDERMODE_ZPASS_STENCIL;
1907                 r_shadow_shadowingrendermode_zfail = R_SHADOW_RENDERMODE_ZFAIL_STENCIL;
1908         }
1909
1910         switch(vid.renderpath)
1911         {
1912         case RENDERPATH_GL20:
1913                 r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_GLSL;
1914                 break;
1915         case RENDERPATH_GL13:
1916         case RENDERPATH_GL11:
1917                 if (r_textureunits.integer >= 2 && vid.texunits >= 2 && r_shadow_texture3d.integer && r_shadow_attenuation3dtexture)
1918                         r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN;
1919                 else if (r_textureunits.integer >= 3 && vid.texunits >= 3)
1920                         r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN;
1921                 else if (r_textureunits.integer >= 2 && vid.texunits >= 2)
1922                         r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN;
1923                 else
1924                         r_shadow_lightingrendermode = R_SHADOW_RENDERMODE_LIGHT_VERTEX;
1925                 break;
1926         }
1927
1928         CHECKGLERROR
1929 #if 0
1930         qglGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);CHECKGLERROR
1931         qglGetIntegerv(GL_READ_BUFFER, &readbuffer);CHECKGLERROR
1932         r_shadow_drawbuffer = drawbuffer;
1933         r_shadow_readbuffer = readbuffer;
1934 #endif
1935         r_shadow_cullface_front = r_refdef.view.cullface_front;
1936         r_shadow_cullface_back = r_refdef.view.cullface_back;
1937 }
1938
1939 void R_Shadow_RenderMode_ActiveLight(const rtlight_t *rtlight)
1940 {
1941         rsurface.rtlight = rtlight;
1942 }
1943
1944 void R_Shadow_RenderMode_Reset(void)
1945 {
1946         CHECKGLERROR
1947         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE || r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE)
1948         {
1949                 qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
1950         }
1951         if (vid.support.ext_framebuffer_object)
1952         {
1953                 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
1954         }
1955 #if 0
1956         qglDrawBuffer(r_shadow_drawbuffer);CHECKGLERROR
1957         qglReadBuffer(r_shadow_readbuffer);CHECKGLERROR
1958 #endif
1959         R_SetViewport(&r_refdef.view.viewport);
1960         GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
1961         R_Mesh_ColorPointer(NULL, 0, 0);
1962         R_Mesh_ResetTextureState();
1963         GL_DepthRange(0, 1);
1964         GL_DepthTest(true);
1965         GL_DepthMask(false);
1966         qglDepthFunc(GL_LEQUAL);CHECKGLERROR
1967         GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR
1968         qglDisable(GL_STENCIL_TEST);CHECKGLERROR
1969         qglStencilMask(~0);CHECKGLERROR
1970         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
1971         qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
1972         r_refdef.view.cullface_front = r_shadow_cullface_front;
1973         r_refdef.view.cullface_back = r_shadow_cullface_back;
1974         GL_CullFace(r_refdef.view.cullface_back);
1975         GL_Color(1, 1, 1, 1);
1976         GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
1977         GL_BlendFunc(GL_ONE, GL_ZERO);
1978         R_SetupGenericShader(false);
1979         r_shadow_usingshadowmaprect = false;
1980         r_shadow_usingshadowmapcube = false;
1981         r_shadow_usingshadowmap2d = false;
1982         CHECKGLERROR
1983 }
1984
1985 void R_Shadow_ClearStencil(void)
1986 {
1987         CHECKGLERROR
1988         GL_Clear(GL_STENCIL_BUFFER_BIT);
1989         r_refdef.stats.lights_clears++;
1990 }
1991
1992 void R_Shadow_RenderMode_StencilShadowVolumes(qboolean zpass)
1993 {
1994         r_shadow_rendermode_t mode = zpass ? r_shadow_shadowingrendermode_zpass : r_shadow_shadowingrendermode_zfail;
1995         if (r_shadow_rendermode == mode)
1996                 return;
1997         CHECKGLERROR
1998         R_Shadow_RenderMode_Reset();
1999         GL_ColorMask(0, 0, 0, 0);
2000         GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2001         R_SetupDepthOrShadowShader();
2002         qglDepthFunc(GL_LESS);CHECKGLERROR
2003         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2004         r_shadow_rendermode = mode;
2005         switch(mode)
2006         {
2007         default:
2008                 break;
2009         case R_SHADOW_RENDERMODE_ZPASS_SEPARATESTENCIL:
2010                 GL_CullFace(GL_NONE);
2011                 qglStencilOpSeparate(r_refdef.view.cullface_front, GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
2012                 qglStencilOpSeparate(r_refdef.view.cullface_back, GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
2013                 break;
2014         case R_SHADOW_RENDERMODE_ZFAIL_SEPARATESTENCIL:
2015                 GL_CullFace(GL_NONE);
2016                 qglStencilOpSeparate(r_refdef.view.cullface_front, GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
2017                 qglStencilOpSeparate(r_refdef.view.cullface_back, GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
2018                 break;
2019         case R_SHADOW_RENDERMODE_ZPASS_STENCILTWOSIDE:
2020                 GL_CullFace(GL_NONE);
2021                 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2022                 qglActiveStencilFaceEXT(r_refdef.view.cullface_front);CHECKGLERROR
2023                 qglStencilMask(~0);CHECKGLERROR
2024                 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
2025                 qglActiveStencilFaceEXT(r_refdef.view.cullface_back);CHECKGLERROR
2026                 qglStencilMask(~0);CHECKGLERROR
2027                 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
2028                 break;
2029         case R_SHADOW_RENDERMODE_ZFAIL_STENCILTWOSIDE:
2030                 GL_CullFace(GL_NONE);
2031                 qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR
2032                 qglActiveStencilFaceEXT(r_refdef.view.cullface_front);CHECKGLERROR
2033                 qglStencilMask(~0);CHECKGLERROR
2034                 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
2035                 qglActiveStencilFaceEXT(r_refdef.view.cullface_back);CHECKGLERROR
2036                 qglStencilMask(~0);CHECKGLERROR
2037                 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
2038                 break;
2039         }
2040 }
2041
2042 static void R_Shadow_MakeVSDCT(void)
2043 {
2044         // maps to a 2x3 texture rectangle with normalized coordinates
2045         // +-
2046         // XX
2047         // YY
2048         // ZZ
2049         // stores abs(dir.xy), offset.xy/2.5
2050         unsigned char data[4*6] =
2051         {
2052                 255, 0, 0x33, 0x33, // +X: <1, 0>, <0.5, 0.5>
2053                 255, 0, 0x99, 0x33, // -X: <1, 0>, <1.5, 0.5>
2054                 0, 255, 0x33, 0x99, // +Y: <0, 1>, <0.5, 1.5>
2055                 0, 255, 0x99, 0x99, // -Y: <0, 1>, <1.5, 1.5>
2056                 0,   0, 0x33, 0xFF, // +Z: <0, 0>, <0.5, 2.5>
2057                 0,   0, 0x99, 0xFF, // -Z: <0, 0>, <1.5, 2.5>
2058         };
2059         r_shadow_shadowmapvsdcttexture = R_LoadTextureCubeMap(r_shadow_texturepool, "shadowmapvsdct", 1, data, TEXTYPE_RGBA, TEXF_ALWAYSPRECACHE | TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALPHA, NULL);
2060 }
2061
2062 void R_Shadow_RenderMode_ShadowMap(int side, qboolean clear, int size)
2063 {
2064         int status;
2065         int maxsize;
2066         float nearclip, farclip, bias;
2067         r_viewport_t viewport;
2068         GLuint fbo = 0;
2069         CHECKGLERROR
2070         maxsize = r_shadow_shadowmapmaxsize;
2071         nearclip = r_shadow_shadowmapping_nearclip.value / rsurface.rtlight->radius;
2072         farclip = 1.0f;
2073         bias = r_shadow_shadowmapping_bias.value * nearclip * (1024.0f / size);// * rsurface.rtlight->radius;
2074         r_shadow_shadowmap_parameters[2] = 0.5f + 0.5f * (farclip + nearclip) / (farclip - nearclip);
2075         r_shadow_shadowmap_parameters[3] = -nearclip * farclip / (farclip - nearclip) - 0.5f * bias;
2076         r_shadow_shadowmapside = side;
2077         r_shadow_shadowmapsize = size;
2078         if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
2079         {
2080                 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2081                 r_shadow_shadowmap_parameters[1] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2082                 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2083                 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D) goto init_done;
2084
2085                 // complex unrolled cube approach (more flexible)
2086                 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2087                         R_Shadow_MakeVSDCT();
2088                 if (!r_shadow_shadowmap2dtexture)
2089                 {
2090 #if 1
2091                         int w = maxsize*2, h = vid.support.arb_texture_non_power_of_two ? maxsize*3 : maxsize*4;
2092                         r_shadow_shadowmap2dtexture = R_LoadTextureShadowMap2D(r_shadow_texturepool, "shadowmap", w, h, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2093                         qglGenFramebuffersEXT(1, &r_shadow_fbo2d);CHECKGLERROR
2094                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fbo2d);CHECKGLERROR
2095                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, R_GetTexture(r_shadow_shadowmap2dtexture), 0);CHECKGLERROR
2096             // render depth into the fbo, do not render color at all
2097                         qglDrawBuffer(GL_NONE);CHECKGLERROR
2098                         qglReadBuffer(GL_NONE);CHECKGLERROR
2099                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2100                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT && r_shadow_shadowmapping.integer)
2101                         {
2102                                 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2103                                 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2104                         }
2105 #endif
2106                 }
2107                 CHECKGLERROR
2108                 if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d;
2109                 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
2110                 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
2111                 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2112         }
2113         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE)
2114         {
2115                 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2116                 r_shadow_shadowmap_parameters[1] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2117                 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2118                 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE) goto init_done;
2119
2120                 // complex unrolled cube approach (more flexible)
2121                 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2122                         R_Shadow_MakeVSDCT();
2123                 if (!r_shadow_shadowmaprectangletexture)
2124                 {
2125 #if 1
2126                         r_shadow_shadowmaprectangletexture = R_LoadTextureShadowMapRectangle(r_shadow_texturepool, "shadowmap", maxsize*2, maxsize*3, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2127                         qglGenFramebuffersEXT(1, &r_shadow_fborectangle);CHECKGLERROR
2128                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fborectangle);CHECKGLERROR
2129                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_shadowmaprectangletexture), 0);CHECKGLERROR
2130                         // render depth into the fbo, do not render color at all
2131                         qglDrawBuffer(GL_NONE);CHECKGLERROR
2132                         qglReadBuffer(GL_NONE);CHECKGLERROR
2133                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2134                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT && r_shadow_shadowmapping.integer)
2135                         {
2136                                 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2137                                 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2138                         }
2139 #endif
2140                 }
2141                 CHECKGLERROR
2142                 if(r_shadow_shadowmaprectangletexture) fbo = r_shadow_fborectangle;
2143                 r_shadow_shadowmap_texturescale[0] = 1.0f;
2144                 r_shadow_shadowmap_texturescale[1] = 1.0f;
2145                 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE;
2146         }
2147         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
2148         {
2149                 r_shadow_shadowmap_parameters[0] = 1.0f;
2150                 r_shadow_shadowmap_parameters[1] = 1.0f;
2151                 R_Viewport_InitCubeSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, nearclip, farclip, NULL);
2152                 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE) goto init_done;
2153
2154                 // simple cube approach
2155                 if (!r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod])
2156                 {
2157  #if 1
2158                         r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod] = R_LoadTextureShadowMapCube(r_shadow_texturepool, "shadowmapcube", size, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2159                         qglGenFramebuffersEXT(1, &r_shadow_fbocubeside[r_shadow_shadowmaplod]);CHECKGLERROR
2160                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fbocubeside[r_shadow_shadowmaplod]);CHECKGLERROR
2161                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + side, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);CHECKGLERROR
2162                         // render depth into the fbo, do not render color at all
2163                         qglDrawBuffer(GL_NONE);CHECKGLERROR
2164                         qglReadBuffer(GL_NONE);CHECKGLERROR
2165                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2166                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT && r_shadow_shadowmapping.integer)
2167                         {
2168                                 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2169                                 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2170                         }
2171  #endif
2172                 }
2173                 CHECKGLERROR
2174                 if (r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]) fbo = r_shadow_fbocubeside[r_shadow_shadowmaplod];
2175                 r_shadow_shadowmap_texturescale[0] = 0.0f;
2176                 r_shadow_shadowmap_texturescale[1] = 0.0f;
2177                 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE;
2178         }
2179
2180         R_Shadow_RenderMode_Reset();
2181         if (fbo)
2182         {
2183                 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);CHECKGLERROR
2184                 R_SetupDepthOrShadowShader();
2185         }
2186         else
2187         {
2188                 R_SetupShowDepthShader();
2189                 qglClearColor(1,1,1,1);CHECKGLERROR
2190         }
2191         CHECKGLERROR
2192         GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2193         GL_DepthMask(true);
2194         GL_DepthTest(true);
2195         qglClearDepth(1);
2196         CHECKGLERROR
2197
2198 init_done:
2199         R_SetViewport(&viewport);
2200         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2201         if(r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE)
2202         {
2203                 int flipped = (side&1)^(side>>2);
2204                 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2205                 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2206                 GL_CullFace(r_refdef.view.cullface_back);
2207         }
2208         else if(r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE)
2209         {
2210                 qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + side, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);CHECKGLERROR
2211         }
2212         if (clear)
2213                 qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT |  GL_STENCIL_BUFFER_BIT);
2214         CHECKGLERROR
2215 }
2216
2217 void R_Shadow_RenderMode_SetShadowMapTexture(void)
2218 {
2219         if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
2220         {
2221                 r_shadow_usingshadowmap2d = true;
2222                 R_Mesh_TexBind(GL20TU_SHADOWMAP2D, R_GetTexture(r_shadow_shadowmap2dtexture));
2223                 CHECKGLERROR
2224         }
2225         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE)
2226         {
2227                 r_shadow_usingshadowmaprect = true;
2228                 R_Mesh_TexBindAll(GL20TU_SHADOWMAPRECT, 0, 0, 0, R_GetTexture(r_shadow_shadowmaprectangletexture));
2229                 CHECKGLERROR
2230         }
2231         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
2232         {
2233                 r_shadow_usingshadowmapcube = true;
2234                 R_Mesh_TexBindAll(GL20TU_SHADOWMAPCUBE, 0, 0, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);
2235                 CHECKGLERROR
2236         }
2237
2238         if (r_shadow_shadowmapvsdct && (r_shadow_usingshadowmap2d || r_shadow_usingshadowmaprect))
2239         {
2240                 R_Mesh_TexBindAll(GL20TU_CUBEPROJECTION, 0, 0, R_GetTexture(r_shadow_shadowmapvsdcttexture), 0);
2241                 CHECKGLERROR
2242         }
2243 }
2244
2245 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2246 {
2247         if (transparent)
2248         {
2249                 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2250                 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2251                 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2252                 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2253         }
2254         CHECKGLERROR
2255         R_Shadow_RenderMode_Reset();
2256         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2257         if (!transparent)
2258         {
2259                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2260         }
2261         if (stenciltest)
2262         {
2263                 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2264                 // only draw light where this geometry was already rendered AND the
2265                 // stencil is 128 (values other than this mean shadow)
2266                 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2267         }
2268         r_shadow_rendermode = r_shadow_lightingrendermode;
2269         // do global setup needed for the chosen lighting mode
2270         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2271         {
2272                 R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0); // light filter
2273                 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2274                 CHECKGLERROR
2275                 if (shadowmapping)
2276                         R_Shadow_RenderMode_SetShadowMapTexture();
2277         }
2278         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
2279         CHECKGLERROR
2280 }
2281
2282 static const unsigned short bboxelements[36] =
2283 {
2284         5, 1, 3, 5, 3, 7,
2285         6, 2, 0, 6, 0, 4,
2286         7, 3, 2, 7, 2, 6,
2287         4, 0, 1, 4, 1, 5,
2288         4, 5, 7, 4, 7, 6,
2289         1, 0, 2, 1, 2, 3,
2290 };
2291
2292 static const float bboxpoints[8][3] =
2293 {
2294         {-1,-1,-1},
2295         { 1,-1,-1},
2296         {-1, 1,-1},
2297         { 1, 1,-1},
2298         {-1,-1, 1},
2299         { 1,-1, 1},
2300         {-1, 1, 1},
2301         { 1, 1, 1},
2302 };
2303
2304 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2305 {
2306         int i;
2307         float vertex3f[8*3];
2308         const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2309         CHECKGLERROR
2310         R_Shadow_RenderMode_Reset();
2311         r_shadow_rendermode = r_shadow_lightingrendermode;
2312         // do global setup needed for the chosen lighting mode
2313         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2314         {
2315                 R_Mesh_Matrix(&identitymatrix);
2316                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2317                 if (stenciltest)
2318                 {
2319                         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2320                         // only draw light where this geometry was already rendered AND the
2321                         // stencil is 128 (values other than this mean shadow)
2322                         qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2323                 }
2324                 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
2325                 R_Mesh_TexBindAll(GL20TU_SCREENDEPTH, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrydepthtexture));
2326                 R_Mesh_TexBindAll(GL20TU_SCREENNORMALMAP, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture));
2327                 R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0); // light filter
2328                 if (shadowmapping)
2329                         R_Shadow_RenderMode_SetShadowMapTexture();
2330                 R_SetupSurfaceShader(rsurface.rtlight->currentcolor, false, rsurface.rtlight->ambientscale, rsurface.rtlight->diffusescale, rsurface.rtlight->specularscale, RSURFPASS_RTLIGHT);
2331                 //R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
2332                 R_Mesh_TexBind(GL20TU_ATTENUATION, R_GetTexture(r_shadow_attenuationgradienttexture));
2333
2334                 for (i = 0;i < 8;i++)
2335                         Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2336                 CHECKGLERROR
2337                 //qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
2338                 R_Mesh_VertexPointer(vertex3f, 0, 0);
2339                 R_Mesh_ColorPointer(NULL, 0, 0);
2340                 GL_ColorMask(1,1,1,1);
2341                 //GL_Color(0.25f,0.05f,0.02f,1.0f);
2342                 //R_SetupGenericShader(false);
2343                 GL_DepthMask(false);
2344                 GL_DepthRange(0, 1);
2345                 GL_PolygonOffset(0, 0);
2346                 GL_DepthTest(true);
2347                 qglDepthFunc(GL_GREATER);CHECKGLERROR
2348                 GL_CullFace(r_refdef.view.cullface_back);
2349                 //GL_AlphaTest(false);
2350                 //qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2351                 R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
2352         }
2353 }
2354
2355 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2356 {
2357         CHECKGLERROR
2358         R_Shadow_RenderMode_Reset();
2359         GL_BlendFunc(GL_ONE, GL_ONE);
2360         GL_DepthRange(0, 1);
2361         GL_DepthTest(r_showshadowvolumes.integer < 2);
2362         GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2363         GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2364         GL_CullFace(GL_NONE);
2365         r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2366 }
2367
2368 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2369 {
2370         CHECKGLERROR
2371         R_Shadow_RenderMode_Reset();
2372         GL_BlendFunc(GL_ONE, GL_ONE);
2373         GL_DepthRange(0, 1);
2374         GL_DepthTest(r_showlighting.integer < 2);
2375         GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2376         if (!transparent)
2377         {
2378                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2379         }
2380         if (stenciltest)
2381         {
2382                 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2383                 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2384         }
2385         r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2386 }
2387
2388 void R_Shadow_RenderMode_End(void)
2389 {
2390         CHECKGLERROR
2391         R_Shadow_RenderMode_Reset();
2392         R_Shadow_RenderMode_ActiveLight(NULL);
2393         GL_DepthMask(true);
2394         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2395         r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2396 }
2397
2398 int bboxedges[12][2] =
2399 {
2400         // top
2401         {0, 1}, // +X
2402         {0, 2}, // +Y
2403         {1, 3}, // Y, +X
2404         {2, 3}, // X, +Y
2405         // bottom
2406         {4, 5}, // +X
2407         {4, 6}, // +Y
2408         {5, 7}, // Y, +X
2409         {6, 7}, // X, +Y
2410         // verticals
2411         {0, 4}, // +Z
2412         {1, 5}, // X, +Z
2413         {2, 6}, // Y, +Z
2414         {3, 7}, // XY, +Z
2415 };
2416
2417 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2418 {
2419         int i, ix1, iy1, ix2, iy2;
2420         float x1, y1, x2, y2;
2421         vec4_t v, v2;
2422         float vertex[20][3];
2423         int j, k;
2424         vec4_t plane4f;
2425         int numvertices;
2426         float corner[8][4];
2427         float dist[8];
2428         int sign[8];
2429         float f;
2430
2431         r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2432         r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2433         r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2434         r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2435
2436         if (!r_shadow_scissor.integer)
2437                 return false;
2438
2439         // if view is inside the light box, just say yes it's visible
2440         if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs))
2441                 return false;
2442
2443         x1 = y1 = x2 = y2 = 0;
2444
2445         // transform all corners that are infront of the nearclip plane
2446         VectorNegate(r_refdef.view.frustum[4].normal, plane4f);
2447         plane4f[3] = r_refdef.view.frustum[4].dist;
2448         numvertices = 0;
2449         for (i = 0;i < 8;i++)
2450         {
2451                 Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1);
2452                 dist[i] = DotProduct4(corner[i], plane4f);
2453                 sign[i] = dist[i] > 0;
2454                 if (!sign[i])
2455                 {
2456                         VectorCopy(corner[i], vertex[numvertices]);
2457                         numvertices++;
2458                 }
2459         }
2460         // if some points are behind the nearclip, add clipped edge points to make
2461         // sure that the scissor boundary is complete
2462         if (numvertices > 0 && numvertices < 8)
2463         {
2464                 // add clipped edge points
2465                 for (i = 0;i < 12;i++)
2466                 {
2467                         j = bboxedges[i][0];
2468                         k = bboxedges[i][1];
2469                         if (sign[j] != sign[k])
2470                         {
2471                                 f = dist[j] / (dist[j] - dist[k]);
2472                                 VectorLerp(corner[j], f, corner[k], vertex[numvertices]);
2473                                 numvertices++;
2474                         }
2475                 }
2476         }
2477
2478         // if we have no points to check, the light is behind the view plane
2479         if (!numvertices)
2480                 return true;
2481
2482         // if we have some points to transform, check what screen area is covered
2483         x1 = y1 = x2 = y2 = 0;
2484         v[3] = 1.0f;
2485         //Con_Printf("%i vertices to transform...\n", numvertices);
2486         for (i = 0;i < numvertices;i++)
2487         {
2488                 VectorCopy(vertex[i], v);
2489                 R_Viewport_TransformToScreen(&r_refdef.view.viewport, v, v2);
2490                 //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]);
2491                 if (i)
2492                 {
2493                         if (x1 > v2[0]) x1 = v2[0];
2494                         if (x2 < v2[0]) x2 = v2[0];
2495                         if (y1 > v2[1]) y1 = v2[1];
2496                         if (y2 < v2[1]) y2 = v2[1];
2497                 }
2498                 else
2499                 {
2500                         x1 = x2 = v2[0];
2501                         y1 = y2 = v2[1];
2502                 }
2503         }
2504
2505         // now convert the scissor rectangle to integer screen coordinates
2506         ix1 = (int)(x1 - 1.0f);
2507         iy1 = vid.height - (int)(y2 - 1.0f);
2508         ix2 = (int)(x2 + 1.0f);
2509         iy2 = vid.height - (int)(y1 + 1.0f);
2510         //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
2511
2512         // clamp it to the screen
2513         if (ix1 < r_refdef.view.viewport.x) ix1 = r_refdef.view.viewport.x;
2514         if (iy1 < r_refdef.view.viewport.y) iy1 = r_refdef.view.viewport.y;
2515         if (ix2 > r_refdef.view.viewport.x + r_refdef.view.viewport.width) ix2 = r_refdef.view.viewport.x + r_refdef.view.viewport.width;
2516         if (iy2 > r_refdef.view.viewport.y + r_refdef.view.viewport.height) iy2 = r_refdef.view.viewport.y + r_refdef.view.viewport.height;
2517
2518         // if it is inside out, it's not visible
2519         if (ix2 <= ix1 || iy2 <= iy1)
2520                 return true;
2521
2522         // the light area is visible, set up the scissor rectangle
2523         r_shadow_lightscissor[0] = ix1;
2524         r_shadow_lightscissor[1] = iy1;
2525         r_shadow_lightscissor[2] = ix2 - ix1;
2526         r_shadow_lightscissor[3] = iy2 - iy1;
2527
2528         r_refdef.stats.lights_scissored++;
2529         return false;
2530 }
2531
2532 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, int numtriangles, const int *element3i, const float *diffusecolor, const float *ambientcolor)
2533 {
2534         const float *vertex3f = rsurface.vertex3f + 3 * firstvertex;
2535         const float *normal3f = rsurface.normal3f + 3 * firstvertex;
2536         float *color4f = rsurface.array_color4f + 4 * firstvertex;
2537         float dist, dot, distintensity, shadeintensity, v[3], n[3];
2538         switch (r_shadow_rendermode)
2539         {
2540         case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2541         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2542                 if (VectorLength2(diffusecolor) > 0)
2543                 {
2544                         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2545                         {
2546                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2547                                 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2548                                 if ((dot = DotProduct(n, v)) < 0)
2549                                 {
2550                                         shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2551                                         VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
2552                                 }
2553                                 else
2554                                         VectorCopy(ambientcolor, color4f);
2555                                 if (r_refdef.fogenabled)
2556                                 {
2557                                         float f;
2558                                         f = RSurf_FogVertex(vertex3f);
2559                                         VectorScale(color4f, f, color4f);
2560                                 }
2561                                 color4f[3] = 1;
2562                         }
2563                 }
2564                 else
2565                 {
2566                         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2567                         {
2568                                 VectorCopy(ambientcolor, color4f);
2569                                 if (r_refdef.fogenabled)
2570                                 {
2571                                         float f;
2572                                         Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2573                                         f = RSurf_FogVertex(vertex3f);
2574                                         VectorScale(color4f, f, color4f);
2575                                 }
2576                                 color4f[3] = 1;
2577                         }
2578                 }
2579                 break;
2580         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2581                 if (VectorLength2(diffusecolor) > 0)
2582                 {
2583                         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2584                         {
2585                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2586                                 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2587                                 {
2588                                         Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2589                                         if ((dot = DotProduct(n, v)) < 0)
2590                                         {
2591                                                 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2592                                                 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
2593                                                 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
2594                                                 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
2595                                         }
2596                                         else
2597                                         {
2598                                                 color4f[0] = ambientcolor[0] * distintensity;
2599                                                 color4f[1] = ambientcolor[1] * distintensity;
2600                                                 color4f[2] = ambientcolor[2] * distintensity;
2601                                         }
2602                                         if (r_refdef.fogenabled)
2603                                         {
2604                                                 float f;
2605                                                 f = RSurf_FogVertex(vertex3f);
2606                                                 VectorScale(color4f, f, color4f);
2607                                         }
2608                                 }
2609                                 else
2610                                         VectorClear(color4f);
2611                                 color4f[3] = 1;
2612                         }
2613                 }
2614                 else
2615                 {
2616                         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2617                         {
2618                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2619                                 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2620                                 {
2621                                         color4f[0] = ambientcolor[0] * distintensity;
2622                                         color4f[1] = ambientcolor[1] * distintensity;
2623                                         color4f[2] = ambientcolor[2] * distintensity;
2624                                         if (r_refdef.fogenabled)
2625                                         {
2626                                                 float f;
2627                                                 f = RSurf_FogVertex(vertex3f);
2628                                                 VectorScale(color4f, f, color4f);
2629                                         }
2630                                 }
2631                                 else
2632                                         VectorClear(color4f);
2633                                 color4f[3] = 1;
2634                         }
2635                 }
2636                 break;
2637         case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2638                 if (VectorLength2(diffusecolor) > 0)
2639                 {
2640                         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2641                         {
2642                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2643                                 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2644                                 {
2645                                         distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
2646                                         Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2647                                         if ((dot = DotProduct(n, v)) < 0)
2648                                         {
2649                                                 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2650                                                 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
2651                                                 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
2652                                                 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
2653                                         }
2654                                         else
2655                                         {
2656                                                 color4f[0] = ambientcolor[0] * distintensity;
2657                                                 color4f[1] = ambientcolor[1] * distintensity;
2658                                                 color4f[2] = ambientcolor[2] * distintensity;
2659                                         }
2660                                         if (r_refdef.fogenabled)
2661                                         {
2662                                                 float f;
2663                                                 f = RSurf_FogVertex(vertex3f);
2664                                                 VectorScale(color4f, f, color4f);
2665                                         }
2666                                 }
2667                                 else
2668                                         VectorClear(color4f);
2669                                 color4f[3] = 1;
2670                         }
2671                 }
2672                 else
2673                 {
2674                         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2675                         {
2676                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2677                                 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2678                                 {
2679                                         distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
2680                                         color4f[0] = ambientcolor[0] * distintensity;
2681                                         color4f[1] = ambientcolor[1] * distintensity;
2682                                         color4f[2] = ambientcolor[2] * distintensity;
2683                                         if (r_refdef.fogenabled)
2684                                         {
2685                                                 float f;
2686                                                 f = RSurf_FogVertex(vertex3f);
2687                                                 VectorScale(color4f, f, color4f);
2688                                         }
2689                                 }
2690                                 else
2691                                         VectorClear(color4f);
2692                                 color4f[3] = 1;
2693                         }
2694                 }
2695                 break;
2696         default:
2697                 break;
2698         }
2699 }
2700
2701 static void R_Shadow_RenderLighting_VisibleLighting(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
2702 {
2703         // used to display how many times a surface is lit for level design purposes
2704         R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2705 }
2706
2707 static void R_Shadow_RenderLighting_Light_GLSL(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
2708 {
2709         // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
2710         R_SetupSurfaceShader(lightcolorbase, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT);
2711         if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
2712                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
2713         else
2714                 R_Mesh_ColorPointer(NULL, 0, 0);
2715         R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
2716         R_Mesh_TexMatrix(1, &rsurface.texture->currentbackgroundtexmatrix);
2717         R_Mesh_TexBind(GL20TU_NORMAL, R_GetTexture(rsurface.texture->currentskinframe->nmap));
2718         R_Mesh_TexBind(GL20TU_COLOR, R_GetTexture(rsurface.texture->basetexture));
2719         R_Mesh_TexBind(GL20TU_GLOSS, R_GetTexture(rsurface.texture->glosstexture));
2720         if (rsurface.texture->backgroundcurrentskinframe)
2721         {
2722                 R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->nmap));
2723                 R_Mesh_TexBind(GL20TU_SECONDARY_COLOR, R_GetTexture(rsurface.texture->backgroundbasetexture));
2724                 R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS, R_GetTexture(rsurface.texture->backgroundglosstexture));
2725                 R_Mesh_TexBind(GL20TU_SECONDARY_GLOW, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->glow));
2726         }
2727         //R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0);
2728         R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
2729         if(rsurface.texture->colormapping)
2730         {
2731                 R_Mesh_TexBind(GL20TU_PANTS, R_GetTexture(rsurface.texture->currentskinframe->pants));
2732                 R_Mesh_TexBind(GL20TU_SHIRT, R_GetTexture(rsurface.texture->currentskinframe->shirt));
2733         }
2734         R_Mesh_TexBind(GL20TU_ATTENUATION, R_GetTexture(r_shadow_attenuationgradienttexture));
2735         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
2736         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
2737         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
2738         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
2739         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
2740         {
2741                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2742         }
2743         R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2744         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
2745         {
2746                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2747         }
2748 }
2749
2750 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
2751 {
2752         int renders;
2753         int i;
2754         int stop;
2755         int newfirstvertex;
2756         int newlastvertex;
2757         int newnumtriangles;
2758         int *newe;
2759         const int *e;
2760         float *c;
2761         int maxtriangles = 4096;
2762         int newelements[4096*3];
2763         R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, numtriangles, element3i, diffusecolor2, ambientcolor2);
2764         for (renders = 0;renders < 64;renders++)
2765         {
2766                 stop = true;
2767                 newfirstvertex = 0;
2768                 newlastvertex = 0;
2769                 newnumtriangles = 0;
2770                 newe = newelements;
2771                 // due to low fillrate on the cards this vertex lighting path is
2772                 // designed for, we manually cull all triangles that do not
2773                 // contain a lit vertex
2774                 // this builds batches of triangles from multiple surfaces and
2775                 // renders them at once
2776                 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
2777                 {
2778                         if (VectorLength2(rsurface.array_color4f + e[0] * 4) + VectorLength2(rsurface.array_color4f + e[1] * 4) + VectorLength2(rsurface.array_color4f + e[2] * 4) >= 0.01)
2779                         {
2780                                 if (newnumtriangles)
2781                                 {
2782                                         newfirstvertex = min(newfirstvertex, e[0]);
2783                                         newlastvertex  = max(newlastvertex, e[0]);
2784                                 }
2785                                 else
2786                                 {
2787                                         newfirstvertex = e[0];
2788                                         newlastvertex = e[0];
2789                                 }
2790                                 newfirstvertex = min(newfirstvertex, e[1]);
2791                                 newlastvertex  = max(newlastvertex, e[1]);
2792                                 newfirstvertex = min(newfirstvertex, e[2]);
2793                                 newlastvertex  = max(newlastvertex, e[2]);
2794                                 newe[0] = e[0];
2795                                 newe[1] = e[1];
2796                                 newe[2] = e[2];
2797                                 newnumtriangles++;
2798                                 newe += 3;
2799                                 if (newnumtriangles >= maxtriangles)
2800                                 {
2801                                         R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2802                                         newnumtriangles = 0;
2803                                         newe = newelements;
2804                                         stop = false;
2805                                 }
2806                         }
2807                 }
2808                 if (newnumtriangles >= 1)
2809                 {
2810                         R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2811                         stop = false;
2812                 }
2813                 // if we couldn't find any lit triangles, exit early
2814                 if (stop)
2815                         break;
2816                 // now reduce the intensity for the next overbright pass
2817                 // we have to clamp to 0 here incase the drivers have improper
2818                 // handling of negative colors
2819                 // (some old drivers even have improper handling of >1 color)
2820                 stop = true;
2821                 for (i = 0, c = rsurface.array_color4f + 4 * firstvertex;i < numvertices;i++, c += 4)
2822                 {
2823                         if (c[0] > 1 || c[1] > 1 || c[2] > 1)
2824                         {
2825                                 c[0] = max(0, c[0] - 1);
2826                                 c[1] = max(0, c[1] - 1);
2827                                 c[2] = max(0, c[2] - 1);
2828                                 stop = false;
2829                         }
2830                         else
2831                                 VectorClear(c);
2832                 }
2833                 // another check...
2834                 if (stop)
2835                         break;
2836         }
2837 }
2838
2839 static void R_Shadow_RenderLighting_Light_Vertex(int firstvertex, int numvertices, int numtriangles, const int *element3i, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt)
2840 {
2841         // OpenGL 1.1 path (anything)
2842         float ambientcolorbase[3], diffusecolorbase[3];
2843         float ambientcolorpants[3], diffusecolorpants[3];
2844         float ambientcolorshirt[3], diffusecolorshirt[3];
2845         rmeshstate_t m;
2846         VectorScale(lightcolorbase, ambientscale * 2 * r_refdef.view.colorscale, ambientcolorbase);
2847         VectorScale(lightcolorbase, diffusescale * 2 * r_refdef.view.colorscale, diffusecolorbase);
2848         VectorScale(lightcolorpants, ambientscale * 2 * r_refdef.view.colorscale, ambientcolorpants);
2849         VectorScale(lightcolorpants, diffusescale * 2 * r_refdef.view.colorscale, diffusecolorpants);
2850         VectorScale(lightcolorshirt, ambientscale * 2 * r_refdef.view.colorscale, ambientcolorshirt);
2851         VectorScale(lightcolorshirt, diffusescale * 2 * r_refdef.view.colorscale, diffusecolorshirt);
2852         switch(r_shadow_rendermode)
2853         {
2854         case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2855                 memset(&m, 0, sizeof(m));
2856                 m.tex[0] = R_GetTexture(basetexture);
2857                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2858                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2859                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2860                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2861                 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
2862                 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2863                 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2864                 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2865                 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2866                 R_Mesh_TextureState(&m);
2867                 break;
2868         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2869                 memset(&m, 0, sizeof(m));
2870                 m.tex[0] = R_GetTexture(basetexture);
2871                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2872                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2873                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2874                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2875                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2876                 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2877                 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2878                 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2879                 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2880                 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
2881                 m.texmatrix[2] = rsurface.entitytoattenuationz;
2882                 m.pointer_texcoord3f[2] = rsurface.vertex3f;
2883                 m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
2884                 m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
2885                 R_Mesh_TextureState(&m);
2886                 break;
2887         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2888                 memset(&m, 0, sizeof(m));
2889                 m.tex[0] = R_GetTexture(basetexture);
2890                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2891                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2892                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2893                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2894                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2895                 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2896                 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2897                 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2898                 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2899                 R_Mesh_TextureState(&m);
2900                 break;
2901         case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2902                 memset(&m, 0, sizeof(m));
2903                 m.tex[0] = R_GetTexture(basetexture);
2904                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2905                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2906                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2907                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2908                 R_Mesh_TextureState(&m);
2909                 break;
2910         default:
2911                 break;
2912         }
2913         //R_Mesh_TexBind(0, R_GetTexture(basetexture));
2914         R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorbase, ambientcolorbase);
2915         if (dopants)
2916         {
2917                 R_Mesh_TexBind(0, R_GetTexture(pantstexture));
2918                 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorpants, ambientcolorpants);
2919         }
2920         if (doshirt)
2921         {
2922                 R_Mesh_TexBind(0, R_GetTexture(shirttexture));
2923                 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorshirt, ambientcolorshirt);
2924         }
2925 }
2926
2927 extern cvar_t gl_lightmaps;
2928 void R_Shadow_RenderLighting(int firstvertex, int numvertices, int firsttriangle, int numtriangles, const int *element3i, const unsigned short *element3s, int element3i_bufferobject, int element3s_bufferobject)
2929 {
2930         float ambientscale, diffusescale, specularscale;
2931         qboolean negated;
2932         vec3_t lightcolorbase, lightcolorpants, lightcolorshirt;
2933         rtexture_t *nmap;
2934         // calculate colors to render this texture with
2935         lightcolorbase[0] = rsurface.rtlight->currentcolor[0] * rsurface.texture->dlightcolor[0];
2936         lightcolorbase[1] = rsurface.rtlight->currentcolor[1] * rsurface.texture->dlightcolor[1];
2937         lightcolorbase[2] = rsurface.rtlight->currentcolor[2] * rsurface.texture->dlightcolor[2];
2938         ambientscale = rsurface.rtlight->ambientscale;
2939         diffusescale = rsurface.rtlight->diffusescale;
2940         specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
2941         if (!r_shadow_usenormalmap.integer)
2942         {
2943                 ambientscale += 1.0f * diffusescale;
2944                 diffusescale = 0;
2945                 specularscale = 0;
2946         }
2947         if ((ambientscale + diffusescale) * VectorLength2(lightcolorbase) + specularscale * VectorLength2(lightcolorbase) < (1.0f / 1048576.0f))
2948                 return;
2949         negated = (lightcolorbase[0] + lightcolorbase[1] + lightcolorbase[2] < 0) && vid.support.ext_blend_subtract;
2950         if(negated)
2951         {
2952                 VectorNegate(lightcolorbase, lightcolorbase);
2953                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
2954         }
2955         RSurf_SetupDepthAndCulling();
2956         nmap = rsurface.texture->currentskinframe->nmap;
2957         if (gl_lightmaps.integer)
2958                 nmap = r_texture_blanknormalmap;
2959         if (rsurface.texture->colormapping && !gl_lightmaps.integer)
2960         {
2961                 qboolean dopants = rsurface.texture->currentskinframe->pants != NULL && VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f);
2962                 qboolean doshirt = rsurface.texture->currentskinframe->shirt != NULL && VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
2963                 if (dopants)
2964                 {
2965                         lightcolorpants[0] = lightcolorbase[0] * rsurface.colormap_pantscolor[0];
2966                         lightcolorpants[1] = lightcolorbase[1] * rsurface.colormap_pantscolor[1];
2967                         lightcolorpants[2] = lightcolorbase[2] * rsurface.colormap_pantscolor[2];
2968                 }
2969                 else
2970                         VectorClear(lightcolorpants);
2971                 if (doshirt)
2972                 {
2973                         lightcolorshirt[0] = lightcolorbase[0] * rsurface.colormap_shirtcolor[0];
2974                         lightcolorshirt[1] = lightcolorbase[1] * rsurface.colormap_shirtcolor[1];
2975                         lightcolorshirt[2] = lightcolorbase[2] * rsurface.colormap_shirtcolor[2];
2976                 }
2977                 else
2978                         VectorClear(lightcolorshirt);
2979                 switch (r_shadow_rendermode)
2980                 {
2981                 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2982                         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
2983                         R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
2984                         break;
2985                 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2986                         R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
2987                         break;
2988                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2989                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2990                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2991                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2992                         R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i + firsttriangle * 3, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt);
2993                         break;
2994                 default:
2995                         Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2996                         break;
2997                 }
2998         }
2999         else
3000         {
3001                 switch (r_shadow_rendermode)
3002                 {
3003                 case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
3004                         GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
3005                         R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
3006                         break;
3007                 case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3008                         R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
3009                         break;
3010                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
3011                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
3012                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
3013                 case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
3014                         R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i + firsttriangle * 3, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false);
3015                         break;
3016                 default:
3017                         Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
3018                         break;
3019                 }
3020         }
3021         if(negated)
3022                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
3023 }
3024
3025 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)
3026 {
3027         matrix4x4_t tempmatrix = *matrix;
3028         Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
3029
3030         // if this light has been compiled before, free the associated data
3031         R_RTLight_Uncompile(rtlight);
3032
3033         // clear it completely to avoid any lingering data
3034         memset(rtlight, 0, sizeof(*rtlight));
3035
3036         // copy the properties
3037         rtlight->matrix_lighttoworld = tempmatrix;
3038         Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3039         Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3040         rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3041         VectorCopy(color, rtlight->color);
3042         rtlight->cubemapname[0] = 0;
3043         if (cubemapname && cubemapname[0])
3044                 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3045         rtlight->shadow = shadow;
3046         rtlight->corona = corona;
3047         rtlight->style = style;
3048         rtlight->isstatic = isstatic;
3049         rtlight->coronasizescale = coronasizescale;
3050         rtlight->ambientscale = ambientscale;
3051         rtlight->diffusescale = diffusescale;
3052         rtlight->specularscale = specularscale;
3053         rtlight->flags = flags;
3054
3055         // compute derived data
3056         //rtlight->cullradius = rtlight->radius;
3057         //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3058         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3059         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3060         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3061         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3062         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3063         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3064 }
3065
3066 // compiles rtlight geometry
3067 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3068 void R_RTLight_Compile(rtlight_t *rtlight)
3069 {
3070         int i;
3071         int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3072         int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3073         entity_render_t *ent = r_refdef.scene.worldentity;
3074         dp_model_t *model = r_refdef.scene.worldmodel;
3075         unsigned char *data;
3076         shadowmesh_t *mesh;
3077
3078         // compile the light
3079         rtlight->compiled = true;
3080         rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3081         rtlight->static_numleafs = 0;
3082         rtlight->static_numleafpvsbytes = 0;
3083         rtlight->static_leaflist = NULL;
3084         rtlight->static_leafpvs = NULL;
3085         rtlight->static_numsurfaces = 0;
3086         rtlight->static_surfacelist = NULL;
3087         rtlight->static_shadowmap_receivers = 0x3F;
3088         rtlight->static_shadowmap_casters = 0x3F;
3089         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3090         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3091         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3092         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3093         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3094         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3095
3096         if (model && model->GetLightInfo)
3097         {
3098                 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3099                 r_shadow_compilingrtlight = rtlight;
3100                 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);
3101                 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3102                 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3103                 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3104                 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3105                 rtlight->static_numsurfaces = numsurfaces;
3106                 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3107                 rtlight->static_numleafs = numleafs;
3108                 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3109                 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3110                 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3111                 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3112                 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3113                 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3114                 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3115                 if (rtlight->static_numsurfaces)
3116                         memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3117                 if (rtlight->static_numleafs)
3118                         memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3119                 if (rtlight->static_numleafpvsbytes)
3120                         memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3121                 if (rtlight->static_numshadowtrispvsbytes)
3122                         memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3123                 if (rtlight->static_numlighttrispvsbytes)
3124                         memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3125                 switch (rtlight->shadowmode)
3126                 {
3127                 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3128                 case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE:
3129                 case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE:
3130                         if (model->CompileShadowMap && rtlight->shadow)
3131                                 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3132                         break;
3133                 default:
3134                         if (model->CompileShadowVolume && rtlight->shadow)
3135                                 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3136                         break;
3137                 }
3138                 // now we're done compiling the rtlight
3139                 r_shadow_compilingrtlight = NULL;
3140         }
3141
3142
3143         // use smallest available cullradius - box radius or light radius
3144         //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3145         //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3146
3147         shadowzpasstris = 0;
3148         if (rtlight->static_meshchain_shadow_zpass)
3149                 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3150                         shadowzpasstris += mesh->numtriangles;
3151
3152         shadowzfailtris = 0;
3153         if (rtlight->static_meshchain_shadow_zfail)
3154                 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3155                         shadowzfailtris += mesh->numtriangles;
3156
3157         lighttris = 0;
3158         if (rtlight->static_numlighttrispvsbytes)
3159                 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3160                         if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3161                                 lighttris++;
3162
3163         shadowtris = 0;
3164         if (rtlight->static_numlighttrispvsbytes)
3165                 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3166                         if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3167                                 shadowtris++;
3168
3169         if (developer.integer >= 10)
3170                 Con_Printf("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);
3171 }
3172
3173 void R_RTLight_Uncompile(rtlight_t *rtlight)
3174 {
3175         if (rtlight->compiled)
3176         {
3177                 if (rtlight->static_meshchain_shadow_zpass)
3178                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3179                 rtlight->static_meshchain_shadow_zpass = NULL;
3180                 if (rtlight->static_meshchain_shadow_zfail)
3181                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3182                 rtlight->static_meshchain_shadow_zfail = NULL;
3183                 if (rtlight->static_meshchain_shadow_shadowmap)
3184                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3185                 rtlight->static_meshchain_shadow_shadowmap = NULL;
3186                 // these allocations are grouped
3187                 if (rtlight->static_surfacelist)
3188                         Mem_Free(rtlight->static_surfacelist);
3189                 rtlight->static_numleafs = 0;
3190                 rtlight->static_numleafpvsbytes = 0;
3191                 rtlight->static_leaflist = NULL;
3192                 rtlight->static_leafpvs = NULL;
3193                 rtlight->static_numsurfaces = 0;
3194                 rtlight->static_surfacelist = NULL;
3195                 rtlight->static_numshadowtrispvsbytes = 0;
3196                 rtlight->static_shadowtrispvs = NULL;
3197                 rtlight->static_numlighttrispvsbytes = 0;
3198                 rtlight->static_lighttrispvs = NULL;
3199                 rtlight->compiled = false;
3200         }
3201 }
3202
3203 void R_Shadow_UncompileWorldLights(void)
3204 {
3205         size_t lightindex;
3206         dlight_t *light;
3207         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3208         for (lightindex = 0;lightindex < range;lightindex++)
3209         {
3210                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3211                 if (!light)
3212                         continue;
3213                 R_RTLight_Uncompile(&light->rtlight);
3214         }
3215 }
3216
3217 void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3218 {
3219         int i, j;
3220         mplane_t plane;
3221         // reset the count of frustum planes
3222         // see rtlight->cached_frustumplanes definition for how much this array
3223         // can hold
3224         rtlight->cached_numfrustumplanes = 0;
3225
3226         // haven't implemented a culling path for ortho rendering
3227         if (!r_refdef.view.useperspective)
3228         {
3229                 // check if the light is on screen and copy the 4 planes if it is
3230                 for (i = 0;i < 4;i++)
3231                         if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3232                                 break;
3233                 if (i == 4)
3234                         for (i = 0;i < 4;i++)
3235                                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3236                 return;
3237         }
3238
3239 #if 1
3240         // generate a deformed frustum that includes the light origin, this is
3241         // used to cull shadow casting surfaces that can not possibly cast a
3242         // shadow onto the visible light-receiving surfaces, which can be a
3243         // performance gain
3244         //
3245         // if the light origin is onscreen the result will be 4 planes exactly
3246         // if the light origin is offscreen on only one axis the result will
3247         // be exactly 5 planes (split-side case)
3248         // if the light origin is offscreen on two axes the result will be
3249         // exactly 4 planes (stretched corner case)
3250         for (i = 0;i < 4;i++)
3251         {
3252                 // quickly reject standard frustum planes that put the light
3253                 // origin outside the frustum
3254                 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3255                         continue;
3256                 // copy the plane
3257                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3258         }
3259         // if all the standard frustum planes were accepted, the light is onscreen
3260         // otherwise we need to generate some more planes below...
3261         if (rtlight->cached_numfrustumplanes < 4)
3262         {
3263                 // at least one of the stock frustum planes failed, so we need to
3264                 // create one or two custom planes to enclose the light origin
3265                 for (i = 0;i < 4;i++)
3266                 {
3267                         // create a plane using the view origin and light origin, and a
3268                         // single point from the frustum corner set
3269                         TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3270                         VectorNormalize(plane.normal);
3271                         plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3272                         // see if this plane is backwards and flip it if so
3273                         for (j = 0;j < 4;j++)
3274                                 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3275                                         break;
3276                         if (j < 4)
3277                         {
3278                                 VectorNegate(plane.normal, plane.normal);
3279                                 plane.dist *= -1;
3280                                 // flipped plane, test again to see if it is now valid
3281                                 for (j = 0;j < 4;j++)
3282                                         if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3283                                                 break;
3284                                 // if the plane is still not valid, then it is dividing the
3285                                 // frustum and has to be rejected
3286                                 if (j < 4)
3287                                         continue;
3288                         }
3289                         // we have created a valid plane, compute extra info
3290                         PlaneClassify(&plane);
3291                         // copy the plane
3292                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3293 #if 1
3294                         // if we've found 5 frustum planes then we have constructed a
3295                         // proper split-side case and do not need to keep searching for
3296                         // planes to enclose the light origin
3297                         if (rtlight->cached_numfrustumplanes == 5)
3298                                 break;
3299 #endif
3300                 }
3301         }
3302 #endif
3303
3304 #if 0
3305         for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3306         {
3307                 plane = rtlight->cached_frustumplanes[i];
3308                 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));
3309         }
3310 #endif
3311
3312 #if 0
3313         // now add the light-space box planes if the light box is rotated, as any
3314         // caster outside the oriented light box is irrelevant (even if it passed
3315         // the worldspace light box, which is axial)
3316         if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3317         {
3318                 for (i = 0;i < 6;i++)
3319                 {
3320                         vec3_t v;
3321                         VectorClear(v);
3322                         v[i >> 1] = (i & 1) ? -1 : 1;
3323                         Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3324                         VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3325                         plane.dist = VectorNormalizeLength(plane.normal);
3326                         plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3327                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3328                 }
3329         }
3330 #endif
3331
3332 #if 0
3333         // add the world-space reduced box planes
3334         for (i = 0;i < 6;i++)
3335         {
3336                 VectorClear(plane.normal);
3337                 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3338                 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3339                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3340         }
3341 #endif
3342
3343 #if 0
3344         {
3345         int j, oldnum;
3346         vec3_t points[8];
3347         vec_t bestdist;
3348         // reduce all plane distances to tightly fit the rtlight cull box, which
3349         // is in worldspace
3350         VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3351         VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3352         VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3353         VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3354         VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3355         VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3356         VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3357         VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3358         oldnum = rtlight->cached_numfrustumplanes;
3359         rtlight->cached_numfrustumplanes = 0;
3360         for (j = 0;j < oldnum;j++)
3361         {
3362                 // find the nearest point on the box to this plane
3363                 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3364                 for (i = 1;i < 8;i++)
3365                 {
3366                         dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3367                         if (bestdist > dist)
3368                                 bestdist = dist;
3369                 }
3370                 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);
3371                 // if the nearest point is near or behind the plane, we want this
3372                 // plane, otherwise the plane is useless as it won't cull anything
3373                 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3374                 {
3375                         PlaneClassify(&rtlight->cached_frustumplanes[j]);
3376                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3377                 }
3378         }
3379         }
3380 #endif
3381 }
3382
3383 void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3384 {
3385         shadowmesh_t *mesh;
3386
3387         RSurf_ActiveWorldEntity();
3388
3389         if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3390         {
3391                 CHECKGLERROR
3392                 GL_CullFace(GL_NONE);
3393         mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3394         for (;mesh;mesh = mesh->next)
3395         {
3396                         if (!mesh->sidetotals[r_shadow_shadowmapside])
3397                                 continue;
3398             r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3399             R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
3400             R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3401         }
3402         CHECKGLERROR
3403     }
3404         else if (r_refdef.scene.worldentity->model)
3405                 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);
3406
3407         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3408 }
3409
3410 void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3411 {
3412         qboolean zpass = false;
3413         shadowmesh_t *mesh;
3414         int t, tend;
3415         int surfacelistindex;
3416         msurface_t *surface;
3417
3418         RSurf_ActiveWorldEntity();
3419
3420         if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3421         {
3422                 CHECKGLERROR
3423                 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3424                 {
3425                         zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3426                         R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3427                 }
3428                 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3429                 for (;mesh;mesh = mesh->next)
3430                 {
3431                         r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3432                         R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
3433                         GL_LockArrays(0, mesh->numverts);
3434                         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3435                         {
3436                                 // increment stencil if frontface is infront of depthbuffer
3437                                 GL_CullFace(r_refdef.view.cullface_back);
3438                                 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
3439                                 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3440                                 // decrement stencil if backface is infront of depthbuffer
3441                                 GL_CullFace(r_refdef.view.cullface_front);
3442                                 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
3443                         }
3444                         else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3445                         {
3446                                 // decrement stencil if backface is behind depthbuffer
3447                                 GL_CullFace(r_refdef.view.cullface_front);
3448                                 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
3449                                 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3450                                 // increment stencil if frontface is behind depthbuffer
3451                                 GL_CullFace(r_refdef.view.cullface_back);
3452                                 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
3453                         }
3454                         R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3455                         GL_LockArrays(0, 0);
3456                 }
3457                 CHECKGLERROR
3458         }
3459         else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh && r_shadow_culltriangles.integer)
3460         {
3461                 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3462                 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3463                 {
3464                         surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3465                         for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3466                                 if (CHECKPVSBIT(trispvs, t))
3467                                         shadowmarklist[numshadowmark++] = t;
3468                 }
3469                 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);
3470         }
3471         else if (numsurfaces)
3472                 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);
3473
3474         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3475 }
3476
3477 void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3478 {
3479         vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3480         vec_t relativeshadowradius;
3481         RSurf_ActiveModelEntity(ent, false, false);
3482         Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3483         relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3484         relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3485         relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3486         relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3487         relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3488         relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3489         relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3490         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D)
3491         {
3492                 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3493         }
3494         else
3495                 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3496         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3497 }
3498
3499 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3500 {
3501         // set up properties for rendering light onto this entity
3502         RSurf_ActiveModelEntity(ent, true, true);
3503         GL_AlphaTest(false);
3504         Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3505         Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3506         Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3507         Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3508         switch(r_shadow_lightingrendermode)
3509         {
3510         case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3511                 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3512                 break;
3513         default:
3514                 break;
3515         }
3516 }
3517
3518 void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3519 {
3520         if (!r_refdef.scene.worldmodel->DrawLight)
3521                 return;
3522
3523         // set up properties for rendering light onto this entity
3524         RSurf_ActiveWorldEntity();
3525         GL_AlphaTest(false);
3526         rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3527         Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3528         Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3529         VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3530         switch(r_shadow_lightingrendermode)
3531         {
3532         case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3533                 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3534                 break;
3535         default:
3536                 break;
3537         }
3538
3539         r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, trispvs);
3540
3541         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3542 }
3543
3544 void R_Shadow_DrawEntityLight(entity_render_t *ent)
3545 {
3546         dp_model_t *model = ent->model;
3547         if (!model->DrawLight)
3548                 return;
3549
3550         R_Shadow_SetupEntityLight(ent);
3551
3552         model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3553
3554         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3555 }
3556
3557 void R_Shadow_PrepareLight(rtlight_t *rtlight)
3558 {
3559         int i;
3560         float f;
3561         int numleafs, numsurfaces;
3562         int *leaflist, *surfacelist;
3563         unsigned char *leafpvs, *shadowtrispvs, *lighttrispvs, *surfacesides;
3564         int numlightentities;
3565         int numlightentities_noselfshadow;
3566         int numshadowentities;
3567         int numshadowentities_noselfshadow;
3568         static entity_render_t *lightentities[MAX_EDICTS];
3569         static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3570         static entity_render_t *shadowentities[MAX_EDICTS];
3571         static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3572
3573         rtlight->draw = false;
3574
3575         // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3576         // skip lights that are basically invisible (color 0 0 0)
3577         if (VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f))
3578                 return;
3579
3580         // loading is done before visibility checks because loading should happen
3581         // all at once at the start of a level, not when it stalls gameplay.
3582         // (especially important to benchmarks)
3583         // compile light
3584         if (rtlight->isstatic && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
3585         {
3586                 if (rtlight->compiled)
3587                         R_RTLight_Uncompile(rtlight);
3588                 R_RTLight_Compile(rtlight);
3589         }
3590
3591         // load cubemap
3592         rtlight->currentcubemap = rtlight->cubemapname[0] ? R_Shadow_Cubemap(rtlight->cubemapname) : r_texture_whitecube;
3593
3594         // look up the light style value at this time
3595         f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3596         VectorScale(rtlight->color, f, rtlight->currentcolor);
3597         /*
3598         if (rtlight->selected)
3599         {
3600                 f = 2 + sin(realtime * M_PI * 4.0);
3601                 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3602         }
3603         */
3604
3605         // if lightstyle is currently off, don't draw the light
3606         if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3607                 return;
3608
3609         // if the light box is offscreen, skip it
3610         if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3611                 return;
3612
3613         VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
3614         VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
3615
3616         R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3617
3618         if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3619         {
3620                 // compiled light, world available and can receive realtime lighting
3621                 // retrieve leaf information
3622                 numleafs = rtlight->static_numleafs;
3623                 leaflist = rtlight->static_leaflist;
3624                 leafpvs = rtlight->static_leafpvs;
3625                 numsurfaces = rtlight->static_numsurfaces;
3626                 surfacelist = rtlight->static_surfacelist;
3627                 surfacesides = NULL;
3628                 shadowtrispvs = rtlight->static_shadowtrispvs;
3629                 lighttrispvs = rtlight->static_lighttrispvs;
3630         }
3631         else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
3632         {
3633                 // dynamic light, world available and can receive realtime lighting
3634                 // calculate lit surfaces and leafs
3635                 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);
3636                 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3637                 leaflist = r_shadow_buffer_leaflist;
3638                 leafpvs = r_shadow_buffer_leafpvs;
3639                 surfacelist = r_shadow_buffer_surfacelist;
3640                 surfacesides = r_shadow_buffer_surfacesides;
3641                 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
3642                 lighttrispvs = r_shadow_buffer_lighttrispvs;
3643                 // if the reduced leaf bounds are offscreen, skip it
3644                 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3645                         return;
3646         }
3647         else
3648         {
3649                 // no world
3650                 numleafs = 0;
3651                 leaflist = NULL;
3652                 leafpvs = NULL;
3653                 numsurfaces = 0;
3654                 surfacelist = NULL;
3655                 surfacesides = NULL;
3656                 shadowtrispvs = NULL;
3657                 lighttrispvs = NULL;
3658         }
3659         // check if light is illuminating any visible leafs
3660         if (numleafs)
3661         {
3662                 for (i = 0;i < numleafs;i++)
3663                         if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
3664                                 break;
3665                 if (i == numleafs)
3666                         return;
3667         }
3668
3669         // make a list of lit entities and shadow casting entities
3670         numlightentities = 0;
3671         numlightentities_noselfshadow = 0;
3672         numshadowentities = 0;
3673         numshadowentities_noselfshadow = 0;
3674
3675         // add dynamic entities that are lit by the light
3676         for (i = 0;i < r_refdef.scene.numentities;i++)
3677         {
3678                 dp_model_t *model;
3679                 entity_render_t *ent = r_refdef.scene.entities[i];
3680                 vec3_t org;
3681                 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3682                         continue;
3683                 // skip the object entirely if it is not within the valid
3684                 // shadow-casting region (which includes the lit region)
3685                 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
3686                         continue;
3687                 if (!(model = ent->model))
3688                         continue;
3689                 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
3690                 {
3691                         // this entity wants to receive light, is visible, and is
3692                         // inside the light box
3693                         // TODO: check if the surfaces in the model can receive light
3694                         // so now check if it's in a leaf seen by the light
3695                         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))
3696                                 continue;
3697                         if (ent->flags & RENDER_NOSELFSHADOW)
3698                                 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
3699                         else
3700                                 lightentities[numlightentities++] = ent;
3701                         // since it is lit, it probably also casts a shadow...
3702                         // about the VectorDistance2 - light emitting entities should not cast their own shadow
3703                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3704                         if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3705                         {
3706                                 // note: exterior models without the RENDER_NOSELFSHADOW
3707                                 // flag still create a RENDER_NOSELFSHADOW shadow but
3708                                 // are lit normally, this means that they are
3709                                 // self-shadowing but do not shadow other
3710                                 // RENDER_NOSELFSHADOW entities such as the gun
3711                                 // (very weird, but keeps the player shadow off the gun)
3712                                 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3713                                         shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3714                                 else
3715                                         shadowentities[numshadowentities++] = ent;
3716                         }
3717                 }
3718                 else if (ent->flags & RENDER_SHADOW)
3719                 {
3720                         // this entity is not receiving light, but may still need to
3721                         // cast a shadow...
3722                         // TODO: check if the surfaces in the model can cast shadow
3723                         // now check if it is in a leaf seen by the light
3724                         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))
3725                                 continue;
3726                         // about the VectorDistance2 - light emitting entities should not cast their own shadow
3727                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3728                         if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3729                         {
3730                                 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3731                                         shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3732                                 else
3733                                         shadowentities[numshadowentities++] = ent;
3734                         }
3735                 }
3736         }
3737
3738         // return if there's nothing at all to light
3739         if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
3740                 return;
3741
3742         // count this light in the r_speeds
3743         r_refdef.stats.lights++;
3744
3745         // flag it as worth drawing later
3746         rtlight->draw = true;
3747
3748         // cache all the animated entities that cast a shadow but are not visible
3749         for (i = 0;i < numshadowentities;i++)
3750                 if (!shadowentities[i]->animcache_vertex3f)
3751                         R_AnimCache_GetEntity(shadowentities[i], false, false);
3752         for (i = 0;i < numshadowentities_noselfshadow;i++)
3753                 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
3754                         R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
3755
3756         // allocate some temporary memory for rendering this light later in the frame
3757         // reusable buffers need to be copied, static data can be used as-is
3758         rtlight->cached_numlightentities               = numlightentities;
3759         rtlight->cached_numlightentities_noselfshadow  = numlightentities_noselfshadow;
3760         rtlight->cached_numshadowentities              = numshadowentities;
3761         rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
3762         rtlight->cached_numsurfaces                    = numsurfaces;
3763         rtlight->cached_lightentities                  = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
3764         rtlight->cached_lightentities_noselfshadow     = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
3765         rtlight->cached_shadowentities                 = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
3766         rtlight->cached_shadowentities_noselfshadow    = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
3767         if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
3768         {
3769                 rtlight->cached_shadowtrispvs                  =   (unsigned char *)R_FrameData_Store(r_refdef.scene.worldmodel->brush.shadowmesh ? r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles : r_refdef.scene.worldmodel->surfmesh.num_triangles, shadowtrispvs);
3770                 rtlight->cached_lighttrispvs                   =   (unsigned char *)R_FrameData_Store(r_refdef.scene.worldmodel->surfmesh.num_triangles, lighttrispvs);
3771                 rtlight->cached_surfacelist                    =              (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
3772         }
3773         else
3774         {
3775                 // compiled light data
3776                 rtlight->cached_shadowtrispvs = shadowtrispvs;
3777                 rtlight->cached_lighttrispvs = lighttrispvs;
3778                 rtlight->cached_surfacelist = surfacelist;
3779         }
3780 }
3781
3782 void R_Shadow_DrawLight(rtlight_t *rtlight)
3783 {
3784         int i;
3785         int numsurfaces;
3786         unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
3787         int numlightentities;
3788         int numlightentities_noselfshadow;
3789         int numshadowentities;
3790         int numshadowentities_noselfshadow;
3791         entity_render_t **lightentities;
3792         entity_render_t **lightentities_noselfshadow;
3793         entity_render_t **shadowentities;
3794         entity_render_t **shadowentities_noselfshadow;
3795         int *surfacelist;
3796         static unsigned char entitysides[MAX_EDICTS];
3797         static unsigned char entitysides_noselfshadow[MAX_EDICTS];
3798         vec3_t nearestpoint;
3799         vec_t distance;
3800         qboolean castshadows;
3801         int lodlinear;
3802
3803         // check if we cached this light this frame (meaning it is worth drawing)
3804         if (!rtlight->draw)
3805                 return;
3806
3807         // if R_FrameData_Store ran out of space we skip anything dependent on it
3808         if (r_framedata_failed)
3809                 return;
3810
3811         numlightentities = rtlight->cached_numlightentities;
3812         numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
3813         numshadowentities = rtlight->cached_numshadowentities;
3814         numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
3815         numsurfaces = rtlight->cached_numsurfaces;
3816         lightentities = rtlight->cached_lightentities;
3817         lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
3818         shadowentities = rtlight->cached_shadowentities;
3819         shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
3820         shadowtrispvs = rtlight->cached_shadowtrispvs;
3821         lighttrispvs = rtlight->cached_lighttrispvs;
3822         surfacelist = rtlight->cached_surfacelist;
3823
3824         // set up a scissor rectangle for this light
3825         if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3826                 return;
3827
3828         // don't let sound skip if going slow
3829         if (r_refdef.scene.extraupdate)
3830                 S_ExtraUpdate ();
3831
3832         // make this the active rtlight for rendering purposes
3833         R_Shadow_RenderMode_ActiveLight(rtlight);
3834
3835         if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
3836         {
3837                 // optionally draw visible shape of the shadow volumes
3838                 // for performance analysis by level designers
3839                 R_Shadow_RenderMode_VisibleShadowVolumes();
3840                 if (numsurfaces)
3841                         R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
3842                 for (i = 0;i < numshadowentities;i++)
3843                         R_Shadow_DrawEntityShadow(shadowentities[i]);
3844                 for (i = 0;i < numshadowentities_noselfshadow;i++)
3845                         R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3846                 R_Shadow_RenderMode_VisibleLighting(false, false);
3847         }
3848
3849         if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
3850         {
3851                 // optionally draw the illuminated areas
3852                 // for performance analysis by level designers
3853                 R_Shadow_RenderMode_VisibleLighting(false, false);
3854                 if (numsurfaces)
3855                         R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3856                 for (i = 0;i < numlightentities;i++)
3857                         R_Shadow_DrawEntityLight(lightentities[i]);
3858                 for (i = 0;i < numlightentities_noselfshadow;i++)
3859                         R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3860         }
3861
3862         castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
3863
3864         nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
3865         nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
3866         nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
3867         distance = VectorDistance(nearestpoint, r_refdef.view.origin);
3868
3869         lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
3870         //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
3871         lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
3872
3873         if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE))
3874         {
3875                 float borderbias;
3876                 int side;
3877                 int size;
3878                 int castermask = 0;
3879                 int receivermask = 0;
3880                 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
3881                 Matrix4x4_Abs(&radiustolight);
3882
3883                 r_shadow_shadowmaplod = 0;
3884                 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
3885                         if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
3886                                 r_shadow_shadowmaplod = i;
3887
3888                 if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
3889                         size = max(1, r_shadow_shadowmapmaxsize >> r_shadow_shadowmaplod);
3890                 else
3891                         size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
3892
3893                 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
3894
3895                 surfacesides = NULL;
3896                 if (numsurfaces)
3897                 {
3898                         if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3899                         {
3900                                 castermask = rtlight->static_shadowmap_casters;
3901                                 receivermask = rtlight->static_shadowmap_receivers;
3902                         }
3903                         else
3904                         {
3905                                 surfacesides = r_shadow_buffer_surfacesides;
3906                                 for(i = 0;i < numsurfaces;i++)
3907                                 {
3908                                         msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
3909                                         surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3910                                         castermask |= surfacesides[i];
3911                                         receivermask |= surfacesides[i];
3912                                 }
3913                         }
3914                 }
3915                 if (receivermask < 0x3F)
3916                 {
3917                         for (i = 0;i < numlightentities;i++)
3918                                 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3919                         if (receivermask < 0x3F)
3920                                 for(i = 0; i < numlightentities_noselfshadow;i++)
3921                                         receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3922                 }
3923
3924                 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
3925
3926                 if (receivermask)
3927                 {
3928                         for (i = 0;i < numshadowentities;i++)
3929                                 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
3930                         for (i = 0;i < numshadowentities_noselfshadow;i++)
3931                                 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
3932                 }
3933
3934                 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
3935
3936                 // render shadow casters into 6 sided depth texture
3937                 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
3938                 {
3939                         R_Shadow_RenderMode_ShadowMap(side, true, size);
3940                         if (! (castermask & (1 << side))) continue;
3941                         if (numsurfaces)
3942                                 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
3943                         for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
3944                                 R_Shadow_DrawEntityShadow(shadowentities[i]);
3945                 }
3946
3947                 if (numlightentities_noselfshadow && !r_shadow_usingdeferredprepass)
3948                 {
3949                         // render lighting using the depth texture as shadowmap
3950                         // draw lighting in the unmasked areas
3951                         R_Shadow_RenderMode_Lighting(false, false, true);
3952                         for (i = 0;i < numlightentities_noselfshadow;i++)
3953                                 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3954                 }
3955
3956                 // render shadow casters into 6 sided depth texture
3957                 if (numshadowentities_noselfshadow)
3958                 {
3959                         for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
3960                         {
3961                                 R_Shadow_RenderMode_ShadowMap(side, false, size);
3962                                 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
3963                                         R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3964                         }
3965                 }
3966
3967                 if (!r_shadow_usingdeferredprepass)
3968                 {
3969                         // render lighting using the depth texture as shadowmap
3970                         // draw lighting in the unmasked areas
3971                         R_Shadow_RenderMode_Lighting(false, false, true);
3972                         // draw lighting in the unmasked areas
3973                         if (numsurfaces)
3974                                 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3975                         for (i = 0;i < numlightentities;i++)
3976                                 R_Shadow_DrawEntityLight(lightentities[i]);
3977                 }
3978         }
3979         else if (castshadows && vid.stencil)
3980         {
3981                 // draw stencil shadow volumes to mask off pixels that are in shadow
3982                 // so that they won't receive lighting
3983                 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
3984                 R_Shadow_ClearStencil();
3985
3986                 if (numsurfaces)
3987                         R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
3988                 for (i = 0;i < numshadowentities;i++)
3989                         R_Shadow_DrawEntityShadow(shadowentities[i]);
3990
3991                 if (!r_shadow_usingdeferredprepass)
3992                 {
3993                         // draw lighting in the unmasked areas
3994                         R_Shadow_RenderMode_Lighting(true, false, false);
3995                         for (i = 0;i < numlightentities_noselfshadow;i++)
3996                                 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3997                 }
3998
3999                 for (i = 0;i < numshadowentities_noselfshadow;i++)
4000                         R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
4001
4002                 if (!r_shadow_usingdeferredprepass)
4003                 {
4004                         // draw lighting in the unmasked areas
4005                         R_Shadow_RenderMode_Lighting(true, false, false);
4006                         if (numsurfaces)
4007                                 R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4008                         for (i = 0;i < numlightentities;i++)
4009                                 R_Shadow_DrawEntityLight(lightentities[i]);
4010                 }
4011         }
4012         else if (!r_shadow_usingdeferredprepass)
4013         {
4014                 // draw lighting in the unmasked areas
4015                 R_Shadow_RenderMode_Lighting(false, false, false);
4016                 if (numsurfaces)
4017                         R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
4018                 for (i = 0;i < numlightentities;i++)
4019                         R_Shadow_DrawEntityLight(lightentities[i]);
4020                 for (i = 0;i < numlightentities_noselfshadow;i++)
4021                         R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
4022         }
4023
4024         if (r_shadow_usingdeferredprepass)
4025         {
4026                 // when rendering deferred lighting, we simply rasterize the box
4027                 if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE))
4028                         R_Shadow_RenderMode_DrawDeferredLight(false, true);
4029                 else if (castshadows && vid.stencil)
4030                         R_Shadow_RenderMode_DrawDeferredLight(true, false);
4031                 else
4032                         R_Shadow_RenderMode_DrawDeferredLight(false, false);
4033         }
4034 }
4035
4036 static void R_Shadow_FreeDeferred(void)
4037 {
4038         if (r_shadow_prepassgeometryfbo)
4039                 qglDeleteFramebuffersEXT(1, &r_shadow_prepassgeometryfbo);CHECKGLERROR
4040         r_shadow_prepassgeometryfbo = 0;
4041
4042         if (r_shadow_prepasslightingfbo)
4043                 qglDeleteFramebuffersEXT(1, &r_shadow_prepasslightingfbo);CHECKGLERROR
4044         r_shadow_prepasslightingfbo = 0;
4045
4046         if (r_shadow_prepassgeometrydepthtexture)
4047                 R_FreeTexture(r_shadow_prepassgeometrydepthtexture);
4048         r_shadow_prepassgeometrydepthtexture = NULL;
4049
4050         if (r_shadow_prepassgeometrynormalmaptexture)
4051                 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4052         r_shadow_prepassgeometrynormalmaptexture = NULL;
4053
4054         if (r_shadow_prepasslightingdiffusetexture)
4055                 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4056         r_shadow_prepasslightingdiffusetexture = NULL;
4057
4058         if (r_shadow_prepasslightingspeculartexture)
4059                 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4060         r_shadow_prepasslightingspeculartexture = NULL;
4061 }
4062
4063 void R_Shadow_DrawPrepass(void)
4064 {
4065         int i;
4066         int flag;
4067         int lnum;
4068         size_t lightindex;
4069         dlight_t *light;
4070         size_t range;
4071         entity_render_t *ent;
4072
4073         GL_AlphaTest(false);
4074         R_Mesh_ColorPointer(NULL, 0, 0);
4075         R_Mesh_ResetTextureState();
4076         GL_DepthMask(true);
4077         GL_ColorMask(1,1,1,1);
4078         GL_BlendFunc(GL_ONE, GL_ZERO);
4079         GL_Color(1,1,1,1);
4080         GL_DepthTest(true);
4081         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepassgeometryfbo);CHECKGLERROR
4082         qglClearColor(0.5f,0.5f,0.5f,1.0f);CHECKGLERROR
4083         GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);CHECKGLERROR
4084
4085         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4086                 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4087         if (r_timereport_active)
4088                 R_TimeReport("prepassgeometry");
4089
4090         for (i = 0;i < r_refdef.scene.numentities;i++)
4091         {
4092                 if (!r_refdef.viewcache.entityvisible[i])
4093                         continue;
4094                 ent = r_refdef.scene.entities[i];
4095                 if (ent->model && ent->model->DrawPrepass != NULL)
4096                         ent->model->DrawPrepass(ent);
4097         }
4098
4099         GL_DepthMask(false);
4100         GL_ColorMask(1,1,1,1);
4101         GL_Color(1,1,1,1);
4102         GL_DepthTest(true);
4103         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
4104         qglClearColor(0.0f,0.0f,0.0f,0.0f);CHECKGLERROR
4105         GL_Clear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
4106         if (r_refdef.fogenabled)
4107                 qglClearColor(r_refdef.fogcolor[0],r_refdef.fogcolor[1],r_refdef.fogcolor[2],0);CHECKGLERROR
4108
4109         R_Shadow_RenderMode_Begin();
4110
4111         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4112         if (r_shadow_debuglight.integer >= 0)
4113         {
4114                 lightindex = r_shadow_debuglight.integer;
4115                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4116                 if (light && (light->flags & flag))
4117                         R_Shadow_DrawLight(&light->rtlight);
4118         }
4119         else
4120         {
4121                 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4122                 for (lightindex = 0;lightindex < range;lightindex++)
4123                 {
4124                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4125                         if (light && (light->flags & flag))
4126                                 R_Shadow_DrawLight(&light->rtlight);
4127                 }
4128         }
4129         if (r_refdef.scene.rtdlight)
4130                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4131                         R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4132
4133         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
4134         if (r_refdef.fogenabled)
4135                 qglClearColor(r_refdef.fogcolor[0],r_refdef.fogcolor[1],r_refdef.fogcolor[2],0);CHECKGLERROR
4136
4137         R_Shadow_RenderMode_End();
4138
4139         if (r_timereport_active)
4140                 R_TimeReport("prepasslights");
4141 }
4142
4143 void R_Shadow_DrawLightSprites(void);
4144 void R_Shadow_PrepareLights(void)
4145 {
4146         int flag;
4147         int lnum;
4148         size_t lightindex;
4149         dlight_t *light;
4150         size_t range;
4151         float f;
4152         GLenum status;
4153
4154         if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4155                 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != r_shadow_shadowmapping.integer ||
4156                 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0) ||
4157                 r_shadow_shadowmaptexturetype != r_shadow_shadowmapping_texturetype.integer ||
4158                 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4159                 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4160                 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4161                 R_Shadow_FreeShadowMaps();
4162
4163         switch (vid.renderpath)
4164         {
4165         case RENDERPATH_GL20:
4166                 if (!r_shadow_deferred.integer || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_STENCIL || !vid.support.ext_framebuffer_object || !vid.support.arb_texture_rectangle || vid.maxdrawbuffers < 2)
4167                 {
4168                         r_shadow_usingdeferredprepass = false;
4169                         if (r_shadow_prepass_width)
4170                                 R_Shadow_FreeDeferred();
4171                         r_shadow_prepass_width = r_shadow_prepass_height = 0;
4172                         break;
4173                 }
4174
4175                 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4176                 {
4177                         R_Shadow_FreeDeferred();
4178
4179                         r_shadow_usingdeferredprepass = true;
4180                         r_shadow_prepass_width = vid.width;
4181                         r_shadow_prepass_height = vid.height;
4182                         r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMapRectangle(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false);
4183                         r_shadow_prepassgeometrynormalmaptexture = R_LoadTextureRectangle(r_shadow_texturepool, "prepassgeometrynormalmap", vid.width, vid.height, NULL, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, NULL);
4184                         r_shadow_prepasslightingdiffusetexture = R_LoadTextureRectangle(r_shadow_texturepool, "prepasslightingdiffuse", vid.width, vid.height, NULL, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, NULL);
4185                         r_shadow_prepasslightingspeculartexture = R_LoadTextureRectangle(r_shadow_texturepool, "prepasslightingspecular", vid.width, vid.height, NULL, TEXTYPE_BGRA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_FORCENEAREST, NULL);
4186
4187                         // set up the geometry pass fbo (depth + normalmap)
4188                         qglGenFramebuffersEXT(1, &r_shadow_prepassgeometryfbo);CHECKGLERROR
4189                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepassgeometryfbo);CHECKGLERROR
4190                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrydepthtexture), 0);CHECKGLERROR
4191                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture), 0);CHECKGLERROR
4192                         // render depth into one texture and normalmap into the other
4193                         qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
4194                         qglReadBuffer(GL_NONE);CHECKGLERROR
4195                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4196                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4197                         {
4198                                 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4199                                 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4200                                 r_shadow_usingdeferredprepass = false;
4201                         }
4202
4203                         // set up the lighting pass fbo (diffuse + specular)
4204                         qglGenFramebuffersEXT(1, &r_shadow_prepasslightingfbo);CHECKGLERROR
4205                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
4206                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrydepthtexture), 0);CHECKGLERROR
4207                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepasslightingdiffusetexture), 0);CHECKGLERROR
4208                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepasslightingspeculartexture), 0);CHECKGLERROR
4209                         // render diffuse into one texture and specular into another,
4210                         // with depth and normalmap bound as textures,
4211                         // with depth bound as attachment as well
4212                         qglDrawBuffersARB(2, r_shadow_prepasslightingdrawbuffers);CHECKGLERROR
4213                         qglReadBuffer(GL_NONE);CHECKGLERROR
4214                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4215                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4216                         {
4217                                 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4218                                 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4219                                 r_shadow_usingdeferredprepass = false;
4220                         }
4221                 }
4222                 break;
4223         case RENDERPATH_GL13:
4224         case RENDERPATH_GL11:
4225                 r_shadow_usingdeferredprepass = false;
4226                 break;
4227         }
4228
4229         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);
4230
4231         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4232         if (r_shadow_debuglight.integer >= 0)
4233         {
4234                 lightindex = r_shadow_debuglight.integer;
4235                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4236                 if (light && (light->flags & flag))
4237                         R_Shadow_PrepareLight(&light->rtlight);
4238         }
4239         else
4240         {
4241                 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4242                 for (lightindex = 0;lightindex < range;lightindex++)
4243                 {
4244                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4245                         if (light && (light->flags & flag))
4246                                 R_Shadow_PrepareLight(&light->rtlight);
4247                 }
4248         }
4249         if (r_refdef.scene.rtdlight)
4250         {
4251                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4252                         R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4253         }
4254         else if(gl_flashblend.integer)
4255         {
4256                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4257                 {
4258                         rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4259                         f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4260                         VectorScale(rtlight->color, f, rtlight->currentcolor);
4261                 }
4262         }
4263
4264         if (r_editlights.integer)
4265                 R_Shadow_DrawLightSprites();
4266 }
4267
4268 void R_Shadow_DrawLights(void)
4269 {
4270         int flag;
4271         int lnum;
4272         size_t lightindex;
4273         dlight_t *light;
4274         size_t range;
4275
4276         R_Shadow_RenderMode_Begin();
4277
4278         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4279         if (r_shadow_debuglight.integer >= 0)
4280         {
4281                 lightindex = r_shadow_debuglight.integer;
4282                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4283                 if (light && (light->flags & flag))
4284                         R_Shadow_DrawLight(&light->rtlight);
4285         }
4286         else
4287         {
4288                 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4289                 for (lightindex = 0;lightindex < range;lightindex++)
4290                 {
4291                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4292                         if (light && (light->flags & flag))
4293                                 R_Shadow_DrawLight(&light->rtlight);
4294                 }
4295         }
4296         if (r_refdef.scene.rtdlight)
4297                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4298                         R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4299
4300         R_Shadow_RenderMode_End();
4301 }
4302
4303 extern const float r_screenvertex3f[12];
4304 extern void R_SetupView(qboolean allowwaterclippingplane);
4305 extern void R_ResetViewRendering3D(void);
4306 extern void R_ResetViewRendering2D(void);
4307 extern cvar_t r_shadows;
4308 extern cvar_t r_shadows_darken;
4309 extern cvar_t r_shadows_drawafterrtlighting;
4310 extern cvar_t r_shadows_castfrombmodels;
4311 extern cvar_t r_shadows_throwdistance;
4312 extern cvar_t r_shadows_throwdirection;
4313 void R_DrawModelShadows(void)
4314 {
4315         int i;
4316         float relativethrowdistance;
4317         entity_render_t *ent;
4318         vec3_t relativelightorigin;
4319         vec3_t relativelightdirection;
4320         vec3_t relativeshadowmins, relativeshadowmaxs;
4321         vec3_t tmp, shadowdir;
4322
4323         if (!r_refdef.scene.numentities || !vid.stencil)
4324                 return;
4325
4326         CHECKGLERROR
4327         R_ResetViewRendering3D();
4328         //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
4329         //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4330         R_Shadow_RenderMode_Begin();
4331         R_Shadow_RenderMode_ActiveLight(NULL);
4332         r_shadow_lightscissor[0] = r_refdef.view.x;
4333         r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
4334         r_shadow_lightscissor[2] = r_refdef.view.width;
4335         r_shadow_lightscissor[3] = r_refdef.view.height;
4336         R_Shadow_RenderMode_StencilShadowVolumes(false);
4337
4338         // get shadow dir
4339         if (r_shadows.integer == 2)
4340         {
4341                 Math_atov(r_shadows_throwdirection.string, shadowdir);
4342                 VectorNormalize(shadowdir);
4343         }
4344
4345         R_Shadow_ClearStencil();
4346
4347         for (i = 0;i < r_refdef.scene.numentities;i++)
4348         {
4349                 ent = r_refdef.scene.entities[i];
4350
4351                 // cast shadows from anything of the map (submodels are optional)
4352                 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4353                 {
4354                         relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4355                         VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
4356                         VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
4357                         if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
4358                                 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4359                         else
4360                         {
4361                                 if(ent->entitynumber != 0)
4362                                 {
4363                                         // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
4364                                         int entnum, entnum2, recursion;
4365                                         entnum = entnum2 = ent->entitynumber;
4366                                         for(recursion = 32; recursion > 0; --recursion)
4367                                         {
4368                                                 entnum2 = cl.entities[entnum].state_current.tagentity;
4369                                                 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
4370                                                         entnum = entnum2;
4371                                                 else
4372                                                         break;
4373                                         }
4374                                         if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
4375                                         {
4376                                                 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
4377                                                 // transform into modelspace of OUR entity
4378                                                 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
4379                                                 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
4380                                         }
4381                                         else
4382                                                 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4383                                 }
4384                                 else
4385                                         VectorNegate(ent->modellight_lightdir, relativelightdirection);
4386                         }
4387
4388                         VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
4389                         RSurf_ActiveModelEntity(ent, false, false);
4390                         ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
4391                         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4392                 }
4393         }
4394
4395         // not really the right mode, but this will disable any silly stencil features
4396         R_Shadow_RenderMode_End();
4397
4398         // set up ortho view for rendering this pass
4399         //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4400         //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4401         //GL_ScissorTest(true);
4402         //R_Mesh_Matrix(&identitymatrix);
4403         //R_Mesh_ResetTextureState();
4404         R_ResetViewRendering2D();
4405         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
4406         R_Mesh_ColorPointer(NULL, 0, 0);
4407         R_SetupGenericShader(false);
4408
4409         // set up a darkening blend on shadowed areas
4410         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
4411         //GL_DepthRange(0, 1);
4412         //GL_DepthTest(false);
4413         //GL_DepthMask(false);
4414         //GL_PolygonOffset(0, 0);CHECKGLERROR
4415         GL_Color(0, 0, 0, r_shadows_darken.value);
4416         //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4417         //qglDepthFunc(GL_ALWAYS);CHECKGLERROR
4418         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
4419         qglStencilMask(~0);CHECKGLERROR
4420         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
4421         qglStencilFunc(GL_NOTEQUAL, 128, ~0);CHECKGLERROR
4422
4423         // apply the blend to the shadowed areas
4424         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4425
4426         // restore the viewport
4427         R_SetViewport(&r_refdef.view.viewport);
4428
4429         // restore other state to normal
4430         //R_Shadow_RenderMode_End();
4431 }
4432
4433 void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
4434 {
4435         float zdist;
4436         vec3_t centerorigin;
4437         float vertex3f[12];
4438         // if it's too close, skip it
4439         if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
4440                 return;
4441         zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
4442         if (zdist < 32)
4443                 return;
4444         if (usequery && r_numqueries + 2 <= r_maxqueries)
4445         {
4446                 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
4447                 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
4448                 // 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
4449                 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
4450
4451                 CHECKGLERROR
4452                 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use qglDepthFunc instead
4453                 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
4454                 qglDepthFunc(GL_ALWAYS);
4455                 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4456                 R_Mesh_VertexPointer(vertex3f, 0, 0);
4457                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4458                 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
4459                 qglDepthFunc(GL_LEQUAL);
4460                 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
4461                 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4462                 R_Mesh_VertexPointer(vertex3f, 0, 0);
4463                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4464                 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
4465                 CHECKGLERROR
4466         }
4467         rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
4468 }
4469
4470 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
4471
4472 void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
4473 {
4474         vec3_t color;
4475         GLint allpixels = 0, visiblepixels = 0;
4476         // now we have to check the query result
4477         if (rtlight->corona_queryindex_visiblepixels)
4478         {
4479                 CHECKGLERROR
4480                 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
4481                 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
4482                 CHECKGLERROR
4483                 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
4484                 if (visiblepixels < 1 || allpixels < 1)
4485                         return;
4486                 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
4487                 cscale *= rtlight->corona_visibility;
4488         }
4489         else
4490         {
4491                 // FIXME: these traces should scan all render entities instead of cl.world
4492                 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1)
4493                         return;
4494         }
4495         VectorScale(rtlight->currentcolor, cscale, color);
4496         if (VectorLength(color) > (1.0f / 256.0f))
4497         {
4498                 float vertex3f[12];
4499                 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
4500                 if(negated)
4501                 {
4502                         VectorNegate(color, color);
4503                         qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
4504                 }
4505                 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4506                 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);
4507                 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4508                 if(negated)
4509                         qglBlendEquationEXT(GL_FUNC_ADD_EXT);
4510         }
4511 }
4512
4513 void R_Shadow_DrawCoronas(void)
4514 {
4515         int i, flag;
4516         qboolean usequery;
4517         size_t lightindex;
4518         dlight_t *light;
4519         rtlight_t *rtlight;
4520         size_t range;
4521         if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
4522                 return;
4523         if (r_waterstate.renderingscene)
4524                 return;
4525         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4526         R_Mesh_Matrix(&identitymatrix);
4527
4528         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4529
4530         // check occlusion of coronas
4531         // use GL_ARB_occlusion_query if available
4532         // otherwise use raytraces
4533         r_numqueries = 0;
4534         usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
4535         if (usequery)
4536         {
4537                 GL_ColorMask(0,0,0,0);
4538                 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
4539                 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
4540                 {
4541                         i = r_maxqueries;
4542                         r_maxqueries = (range + r_refdef.scene.numlights) * 4;
4543                         r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
4544                         CHECKGLERROR
4545                         qglGenQueriesARB(r_maxqueries - i, r_queries + i);
4546                         CHECKGLERROR
4547                 }
4548                 RSurf_ActiveWorldEntity();
4549                 GL_BlendFunc(GL_ONE, GL_ZERO);
4550                 GL_CullFace(GL_NONE);
4551                 GL_DepthMask(false);
4552                 GL_DepthRange(0, 1);
4553                 GL_PolygonOffset(0, 0);
4554                 GL_DepthTest(true);
4555                 R_Mesh_ColorPointer(NULL, 0, 0);
4556                 R_Mesh_ResetTextureState();
4557                 R_SetupGenericShader(false);
4558         }
4559         for (lightindex = 0;lightindex < range;lightindex++)
4560         {
4561                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4562                 if (!light)
4563                         continue;
4564                 rtlight = &light->rtlight;
4565                 rtlight->corona_visibility = 0;
4566                 rtlight->corona_queryindex_visiblepixels = 0;
4567                 rtlight->corona_queryindex_allpixels = 0;
4568                 if (!(rtlight->flags & flag))
4569                         continue;
4570                 if (rtlight->corona <= 0)
4571                         continue;
4572                 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
4573                         continue;
4574                 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
4575         }
4576         for (i = 0;i < r_refdef.scene.numlights;i++)
4577         {
4578                 rtlight = r_refdef.scene.lights[i];
4579                 rtlight->corona_visibility = 0;
4580                 rtlight->corona_queryindex_visiblepixels = 0;
4581                 rtlight->corona_queryindex_allpixels = 0;
4582                 if (!(rtlight->flags & flag))
4583                         continue;
4584                 if (rtlight->corona <= 0)
4585                         continue;
4586                 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
4587         }
4588         if (usequery)
4589                 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4590
4591         // now draw the coronas using the query data for intensity info
4592         for (lightindex = 0;lightindex < range;lightindex++)
4593         {
4594                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4595                 if (!light)
4596                         continue;
4597                 rtlight = &light->rtlight;
4598                 if (rtlight->corona_visibility <= 0)
4599                         continue;
4600                 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
4601         }
4602         for (i = 0;i < r_refdef.scene.numlights;i++)
4603         {
4604                 rtlight = r_refdef.scene.lights[i];
4605                 if (rtlight->corona_visibility <= 0)
4606                         continue;
4607                 if (gl_flashblend.integer)
4608                         R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
4609                 else
4610                         R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
4611         }
4612 }
4613
4614
4615
4616 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
4617 typedef struct suffixinfo_s
4618 {
4619         char *suffix;
4620         qboolean flipx, flipy, flipdiagonal;
4621 }
4622 suffixinfo_t;
4623 static suffixinfo_t suffix[3][6] =
4624 {
4625         {
4626                 {"px",   false, false, false},
4627                 {"nx",   false, false, false},
4628                 {"py",   false, false, false},
4629                 {"ny",   false, false, false},
4630                 {"pz",   false, false, false},
4631                 {"nz",   false, false, false}
4632         },
4633         {
4634                 {"posx", false, false, false},
4635                 {"negx", false, false, false},
4636                 {"posy", false, false, false},
4637                 {"negy", false, false, false},
4638                 {"posz", false, false, false},
4639                 {"negz", false, false, false}
4640         },
4641         {
4642                 {"rt",    true, false,  true},
4643                 {"lf",   false,  true,  true},
4644                 {"ft",    true,  true, false},
4645                 {"bk",   false, false, false},
4646                 {"up",    true, false,  true},
4647                 {"dn",    true, false,  true}
4648         }
4649 };
4650
4651 static int componentorder[4] = {0, 1, 2, 3};
4652
4653 rtexture_t *R_Shadow_LoadCubemap(const char *basename)
4654 {
4655         int i, j, cubemapsize;
4656         unsigned char *cubemappixels, *image_buffer;
4657         rtexture_t *cubemaptexture;
4658         char name[256];
4659         // must start 0 so the first loadimagepixels has no requested width/height
4660         cubemapsize = 0;
4661         cubemappixels = NULL;
4662         cubemaptexture = NULL;
4663         // keep trying different suffix groups (posx, px, rt) until one loads
4664         for (j = 0;j < 3 && !cubemappixels;j++)
4665         {
4666                 // load the 6 images in the suffix group
4667                 for (i = 0;i < 6;i++)
4668                 {
4669                         // generate an image name based on the base and and suffix
4670                         dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
4671                         // load it
4672                         if ((image_buffer = loadimagepixelsbgra(name, false, false)))
4673                         {
4674                                 // an image loaded, make sure width and height are equal
4675                                 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
4676                                 {
4677                                         // if this is the first image to load successfully, allocate the cubemap memory
4678                                         if (!cubemappixels && image_width >= 1)
4679                                         {
4680                                                 cubemapsize = image_width;
4681                                                 // note this clears to black, so unavailable sides are black
4682                                                 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
4683                                         }
4684                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
4685                                         if (cubemappixels)
4686                                                 Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_buffer, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder);
4687                                 }
4688                                 else
4689                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
4690                                 // free the image
4691                                 Mem_Free(image_buffer);
4692                         }
4693                 }
4694         }
4695         // if a cubemap loaded, upload it
4696         if (cubemappixels)
4697         {
4698                 if (developer_loading.integer)
4699                         Con_Printf("loading cubemap \"%s\"\n", basename);
4700
4701                 if (!r_shadow_filters_texturepool)
4702                         r_shadow_filters_texturepool = R_AllocTexturePool();
4703                 cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, TEXF_PRECACHE | (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR, NULL);
4704                 Mem_Free(cubemappixels);
4705         }
4706         else
4707         {
4708                 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
4709                 if (developer_loading.integer)
4710                 {
4711                         Con_Printf("(tried tried images ");
4712                         for (j = 0;j < 3;j++)
4713                                 for (i = 0;i < 6;i++)
4714                                         Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
4715                         Con_Print(" and was unable to find any of them).\n");
4716                 }
4717         }
4718         return cubemaptexture;
4719 }
4720
4721 rtexture_t *R_Shadow_Cubemap(const char *basename)
4722 {
4723         int i;
4724         for (i = 0;i < numcubemaps;i++)
4725                 if (!strcasecmp(cubemaps[i].basename, basename))
4726                         return cubemaps[i].texture ? cubemaps[i].texture : r_texture_whitecube;
4727         if (i >= MAX_CUBEMAPS)
4728                 return r_texture_whitecube;
4729         numcubemaps++;
4730         strlcpy(cubemaps[i].basename, basename, sizeof(cubemaps[i].basename));
4731         cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename);
4732         return cubemaps[i].texture;
4733 }
4734
4735 void R_Shadow_FreeCubemaps(void)
4736 {
4737         int i;
4738         for (i = 0;i < numcubemaps;i++)
4739         {
4740                 if (developer_loading.integer)
4741                         Con_Printf("unloading cubemap \"%s\"\n", cubemaps[i].basename);
4742                 if (cubemaps[i].texture)
4743                         R_FreeTexture(cubemaps[i].texture);
4744         }
4745
4746         numcubemaps = 0;
4747         R_FreeTexturePool(&r_shadow_filters_texturepool);
4748 }
4749
4750 dlight_t *R_Shadow_NewWorldLight(void)
4751 {
4752         return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
4753 }
4754
4755 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)
4756 {
4757         matrix4x4_t matrix;
4758         // validate parameters
4759         if (style < 0 || style >= MAX_LIGHTSTYLES)
4760         {
4761                 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
4762                 style = 0;
4763         }
4764         if (!cubemapname)
4765                 cubemapname = "";
4766
4767         // copy to light properties
4768         VectorCopy(origin, light->origin);
4769         light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
4770         light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
4771         light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
4772         /*
4773         light->color[0] = max(color[0], 0);
4774         light->color[1] = max(color[1], 0);
4775         light->color[2] = max(color[2], 0);
4776         */
4777         light->color[0] = color[0];
4778         light->color[1] = color[1];
4779         light->color[2] = color[2];
4780         light->radius = max(radius, 0);
4781         light->style = style;
4782         light->shadow = shadowenable;
4783         light->corona = corona;
4784         strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
4785         light->coronasizescale = coronasizescale;
4786         light->ambientscale = ambientscale;
4787         light->diffusescale = diffusescale;
4788         light->specularscale = specularscale;
4789         light->flags = flags;
4790
4791         // update renderable light data
4792         Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
4793         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);
4794 }
4795
4796 void R_Shadow_FreeWorldLight(dlight_t *light)
4797 {
4798         if (r_shadow_selectedlight == light)
4799                 r_shadow_selectedlight = NULL;
4800         R_RTLight_Uncompile(&light->rtlight);
4801         Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
4802 }
4803
4804 void R_Shadow_ClearWorldLights(void)
4805 {
4806         size_t lightindex;
4807         dlight_t *light;
4808         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4809         for (lightindex = 0;lightindex < range;lightindex++)
4810         {
4811                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4812                 if (light)
4813                         R_Shadow_FreeWorldLight(light);
4814         }
4815         r_shadow_selectedlight = NULL;
4816         R_Shadow_FreeCubemaps();
4817 }
4818
4819 void R_Shadow_SelectLight(dlight_t *light)
4820 {
4821         if (r_shadow_selectedlight)
4822                 r_shadow_selectedlight->selected = false;
4823         r_shadow_selectedlight = light;
4824         if (r_shadow_selectedlight)
4825                 r_shadow_selectedlight->selected = true;
4826 }
4827
4828 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
4829 {
4830         // this is never batched (there can be only one)
4831         float vertex3f[12];
4832         R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
4833         RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4834         R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4835 }
4836
4837 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
4838 {
4839         float intensity;
4840         float s;
4841         vec3_t spritecolor;
4842         skinframe_t *skinframe;
4843         float vertex3f[12];
4844
4845         // this is never batched (due to the ent parameter changing every time)
4846         // so numsurfaces == 1 and surfacelist[0] == lightnumber
4847         const dlight_t *light = (dlight_t *)ent;
4848         s = EDLIGHTSPRSIZE;
4849
4850         R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
4851
4852         intensity = 0.5f;
4853         VectorScale(light->color, intensity, spritecolor);
4854         if (VectorLength(spritecolor) < 0.1732f)
4855                 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
4856         if (VectorLength(spritecolor) > 1.0f)
4857                 VectorNormalize(spritecolor);
4858
4859         // draw light sprite
4860         if (light->cubemapname[0] && !light->shadow)
4861                 skinframe = r_editlights_sprcubemapnoshadowlight;
4862         else if (light->cubemapname[0])
4863                 skinframe = r_editlights_sprcubemaplight;
4864         else if (!light->shadow)
4865                 skinframe = r_editlights_sprnoshadowlight;
4866         else
4867                 skinframe = r_editlights_sprlight;
4868
4869         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);
4870         R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4871
4872         // draw selection sprite if light is selected
4873         if (light->selected)
4874         {
4875                 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4876                 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4877                 // VorteX todo: add normalmode/realtime mode light overlay sprites?
4878         }
4879 }
4880
4881 void R_Shadow_DrawLightSprites(void)
4882 {
4883         size_t lightindex;
4884         dlight_t *light;
4885         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4886         for (lightindex = 0;lightindex < range;lightindex++)
4887         {
4888                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4889                 if (light)
4890                         R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
4891         }
4892         R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
4893 }
4894
4895 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
4896 {
4897         unsigned int range;
4898         dlight_t *light;
4899         rtlight_t *rtlight;
4900         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
4901         if (lightindex >= range)
4902                 return -1;
4903         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4904         if (!light)
4905                 return 0;
4906         rtlight = &light->rtlight;
4907         //if (!(rtlight->flags & flag))
4908         //      return 0;
4909         VectorCopy(rtlight->shadoworigin, origin);
4910         *radius = rtlight->radius;
4911         VectorCopy(rtlight->color, color);
4912         return 1;
4913 }
4914
4915 void R_Shadow_SelectLightInView(void)
4916 {
4917         float bestrating, rating, temp[3];
4918         dlight_t *best;
4919         size_t lightindex;
4920         dlight_t *light;
4921         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4922         best = NULL;
4923         bestrating = 0;
4924         for (lightindex = 0;lightindex < range;lightindex++)
4925         {
4926                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4927                 if (!light)
4928                         continue;
4929                 VectorSubtract(light->origin, r_refdef.view.origin, temp);
4930                 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
4931                 if (rating >= 0.95)
4932                 {
4933                         rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
4934                         if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1.0f)
4935                         {
4936                                 bestrating = rating;
4937                                 best = light;
4938                         }
4939                 }
4940         }
4941         R_Shadow_SelectLight(best);
4942 }
4943
4944 void R_Shadow_LoadWorldLights(void)
4945 {
4946         int n, a, style, shadow, flags;
4947         char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
4948         float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
4949         if (cl.worldmodel == NULL)
4950         {
4951                 Con_Print("No map loaded.\n");
4952                 return;
4953         }
4954         FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
4955         strlcat (name, ".rtlights", sizeof (name));
4956         lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
4957         if (lightsstring)
4958         {
4959                 s = lightsstring;
4960                 n = 0;
4961                 while (*s)
4962                 {
4963                         t = s;
4964                         /*
4965                         shadow = true;
4966                         for (;COM_Parse(t, true) && strcmp(
4967                         if (COM_Parse(t, true))
4968                         {
4969                                 if (com_token[0] == '!')
4970                                 {
4971                                         shadow = false;
4972                                         origin[0] = atof(com_token+1);
4973                                 }
4974                                 else
4975                                         origin[0] = atof(com_token);
4976                                 if (Com_Parse(t
4977                         }
4978                         */
4979                         t = s;
4980                         while (*s && *s != '\n' && *s != '\r')
4981                                 s++;
4982                         if (!*s)
4983                                 break;
4984                         tempchar = *s;
4985                         shadow = true;
4986                         // check for modifier flags
4987                         if (*t == '!')
4988                         {
4989                                 shadow = false;
4990                                 t++;
4991                         }
4992                         *s = 0;
4993 #if _MSC_VER >= 1400
4994 #define sscanf sscanf_s
4995 #endif
4996                         cubemapname[sizeof(cubemapname)-1] = 0;
4997 #if MAX_QPATH != 128
4998 #error update this code if MAX_QPATH changes
4999 #endif
5000                         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
5001 #if _MSC_VER >= 1400
5002 , sizeof(cubemapname)
5003 #endif
5004 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
5005                         *s = tempchar;
5006                         if (a < 18)
5007                                 flags = LIGHTFLAG_REALTIMEMODE;
5008                         if (a < 17)
5009                                 specularscale = 1;
5010                         if (a < 16)
5011                                 diffusescale = 1;
5012                         if (a < 15)
5013                                 ambientscale = 0;
5014                         if (a < 14)
5015                                 coronasizescale = 0.25f;
5016                         if (a < 13)
5017                                 VectorClear(angles);
5018                         if (a < 10)
5019                                 corona = 0;
5020                         if (a < 9 || !strcmp(cubemapname, "\"\""))
5021                                 cubemapname[0] = 0;
5022                         // remove quotes on cubemapname
5023                         if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
5024                         {
5025                                 size_t namelen;
5026                                 namelen = strlen(cubemapname) - 2;
5027                                 memmove(cubemapname, cubemapname + 1, namelen);
5028                                 cubemapname[namelen] = '\0';
5029                         }
5030                         if (a < 8)
5031                         {
5032                                 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);
5033                                 break;
5034                         }
5035                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5036                         if (*s == '\r')
5037                                 s++;
5038                         if (*s == '\n')
5039                                 s++;
5040                         n++;
5041                 }
5042                 if (*s)
5043                         Con_Printf("invalid rtlights file \"%s\"\n", name);
5044                 Mem_Free(lightsstring);
5045         }
5046 }
5047
5048 void R_Shadow_SaveWorldLights(void)
5049 {
5050         size_t lightindex;
5051         dlight_t *light;
5052         size_t bufchars, bufmaxchars;
5053         char *buf, *oldbuf;
5054         char name[MAX_QPATH];
5055         char line[MAX_INPUTLINE];
5056         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5057         // I hate lines which are 3 times my screen size :( --blub
5058         if (!range)
5059                 return;
5060         if (cl.worldmodel == NULL)
5061         {
5062                 Con_Print("No map loaded.\n");
5063                 return;
5064         }
5065         FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
5066         strlcat (name, ".rtlights", sizeof (name));
5067         bufchars = bufmaxchars = 0;
5068         buf = NULL;
5069         for (lightindex = 0;lightindex < range;lightindex++)
5070         {
5071                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5072                 if (!light)
5073                         continue;
5074                 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5075                         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);
5076                 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5077                         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]);
5078                 else
5079                         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);
5080                 if (bufchars + strlen(line) > bufmaxchars)
5081                 {
5082                         bufmaxchars = bufchars + strlen(line) + 2048;
5083                         oldbuf = buf;
5084                         buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5085                         if (oldbuf)
5086                         {
5087                                 if (bufchars)
5088                                         memcpy(buf, oldbuf, bufchars);
5089                                 Mem_Free(oldbuf);
5090                         }
5091                 }
5092                 if (strlen(line))
5093                 {
5094                         memcpy(buf + bufchars, line, strlen(line));
5095                         bufchars += strlen(line);
5096                 }
5097         }
5098         if (bufchars)
5099                 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5100         if (buf)
5101                 Mem_Free(buf);
5102 }
5103
5104 void R_Shadow_LoadLightsFile(void)
5105 {
5106         int n, a, style;
5107         char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5108         float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5109         if (cl.worldmodel == NULL)
5110         {
5111                 Con_Print("No map loaded.\n");
5112                 return;
5113         }
5114         FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
5115         strlcat (name, ".lights", sizeof (name));
5116         lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5117         if (lightsstring)
5118         {
5119                 s = lightsstring;
5120                 n = 0;
5121                 while (*s)
5122                 {
5123                         t = s;
5124                         while (*s && *s != '\n' && *s != '\r')
5125                                 s++;
5126                         if (!*s)
5127                                 break;
5128                         tempchar = *s;
5129                         *s = 0;
5130                         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);
5131                         *s = tempchar;
5132                         if (a < 14)
5133                         {
5134                                 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);
5135                                 break;
5136                         }
5137                         radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5138                         radius = bound(15, radius, 4096);
5139                         VectorScale(color, (2.0f / (8388608.0f)), color);
5140                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5141                         if (*s == '\r')
5142                                 s++;
5143                         if (*s == '\n')
5144                                 s++;
5145                         n++;
5146                 }
5147                 if (*s)
5148                         Con_Printf("invalid lights file \"%s\"\n", name);
5149                 Mem_Free(lightsstring);
5150         }
5151 }
5152
5153 // tyrlite/hmap2 light types in the delay field
5154 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5155
5156 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5157 {
5158         int entnum, style, islight, skin, pflags, effects, type, n;
5159         char *entfiledata;
5160         const char *data;
5161         float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5162         char key[256], value[MAX_INPUTLINE];
5163
5164         if (cl.worldmodel == NULL)
5165         {
5166                 Con_Print("No map loaded.\n");
5167                 return;
5168         }
5169         // try to load a .ent file first
5170         FS_StripExtension (cl.worldmodel->name, key, sizeof (key));
5171         strlcat (key, ".ent", sizeof (key));
5172         data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5173         // and if that is not found, fall back to the bsp file entity string
5174         if (!data)
5175                 data = cl.worldmodel->brush.entities;
5176         if (!data)
5177                 return;
5178         for (entnum = 0;COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{';entnum++)
5179         {
5180                 type = LIGHTTYPE_MINUSX;
5181                 origin[0] = origin[1] = origin[2] = 0;
5182                 originhack[0] = originhack[1] = originhack[2] = 0;
5183                 angles[0] = angles[1] = angles[2] = 0;
5184                 color[0] = color[1] = color[2] = 1;
5185                 light[0] = light[1] = light[2] = 1;light[3] = 300;
5186                 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5187                 fadescale = 1;
5188                 lightscale = 1;
5189                 style = 0;
5190                 skin = 0;
5191                 pflags = 0;
5192                 effects = 0;
5193                 islight = false;
5194                 while (1)
5195                 {
5196                         if (!COM_ParseToken_Simple(&data, false, false))
5197                                 break; // error
5198                         if (com_token[0] == '}')
5199                                 break; // end of entity
5200                         if (com_token[0] == '_')
5201                                 strlcpy(key, com_token + 1, sizeof(key));
5202                         else
5203                                 strlcpy(key, com_token, sizeof(key));
5204                         while (key[strlen(key)-1] == ' ') // remove trailing spaces
5205                                 key[strlen(key)-1] = 0;
5206                         if (!COM_ParseToken_Simple(&data, false, false))
5207                                 break; // error
5208                         strlcpy(value, com_token, sizeof(value));
5209
5210                         // now that we have the key pair worked out...
5211                         if (!strcmp("light", key))
5212                         {
5213                                 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5214                                 if (n == 1)
5215                                 {
5216                                         // quake
5217                                         light[0] = vec[0] * (1.0f / 256.0f);
5218                                         light[1] = vec[0] * (1.0f / 256.0f);
5219                                         light[2] = vec[0] * (1.0f / 256.0f);
5220                                         light[3] = vec[0];
5221                                 }
5222                                 else if (n == 4)
5223                                 {
5224                                         // halflife
5225                                         light[0] = vec[0] * (1.0f / 255.0f);
5226                                         light[1] = vec[1] * (1.0f / 255.0f);
5227                                         light[2] = vec[2] * (1.0f / 255.0f);
5228                                         light[3] = vec[3];
5229                                 }
5230                         }
5231                         else if (!strcmp("delay", key))
5232                                 type = atoi(value);
5233                         else if (!strcmp("origin", key))
5234                                 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5235                         else if (!strcmp("angle", key))
5236                                 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5237                         else if (!strcmp("angles", key))
5238                                 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5239                         else if (!strcmp("color", key))
5240                                 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5241                         else if (!strcmp("wait", key))
5242                                 fadescale = atof(value);
5243                         else if (!strcmp("classname", key))
5244                         {
5245                                 if (!strncmp(value, "light", 5))
5246                                 {
5247                                         islight = true;
5248                                         if (!strcmp(value, "light_fluoro"))
5249                                         {
5250                                                 originhack[0] = 0;
5251                                                 originhack[1] = 0;
5252                                                 originhack[2] = 0;
5253                                                 overridecolor[0] = 1;
5254                                                 overridecolor[1] = 1;
5255                                                 overridecolor[2] = 1;
5256                                         }
5257                                         if (!strcmp(value, "light_fluorospark"))
5258                                         {
5259                                                 originhack[0] = 0;
5260                                                 originhack[1] = 0;
5261                                                 originhack[2] = 0;
5262                                                 overridecolor[0] = 1;
5263                                                 overridecolor[1] = 1;
5264                                                 overridecolor[2] = 1;
5265                                         }
5266                                         if (!strcmp(value, "light_globe"))
5267                                         {
5268                                                 originhack[0] = 0;
5269                                                 originhack[1] = 0;
5270                                                 originhack[2] = 0;
5271                                                 overridecolor[0] = 1;
5272                                                 overridecolor[1] = 0.8;
5273                                                 overridecolor[2] = 0.4;
5274                                         }
5275                                         if (!strcmp(value, "light_flame_large_yellow"))
5276                                         {
5277                                                 originhack[0] = 0;
5278                                                 originhack[1] = 0;
5279                                                 originhack[2] = 0;
5280                                                 overridecolor[0] = 1;
5281                                                 overridecolor[1] = 0.5;
5282                                                 overridecolor[2] = 0.1;
5283                                         }
5284                                         if (!strcmp(value, "light_flame_small_yellow"))
5285                                         {
5286                                                 originhack[0] = 0;
5287                                                 originhack[1] = 0;
5288                                                 originhack[2] = 0;
5289                                                 overridecolor[0] = 1;
5290                                                 overridecolor[1] = 0.5;
5291                                                 overridecolor[2] = 0.1;
5292                                         }
5293                                         if (!strcmp(value, "light_torch_small_white"))
5294                                         {
5295                                                 originhack[0] = 0;
5296                                                 originhack[1] = 0;
5297                                                 originhack[2] = 0;
5298                                                 overridecolor[0] = 1;
5299                                                 overridecolor[1] = 0.5;
5300                                                 overridecolor[2] = 0.1;
5301                                         }
5302                                         if (!strcmp(value, "light_torch_small_walltorch"))
5303                                         {
5304                                                 originhack[0] = 0;
5305                                                 originhack[1] = 0;
5306                                                 originhack[2] = 0;
5307                                                 overridecolor[0] = 1;
5308                                                 overridecolor[1] = 0.5;
5309                                                 overridecolor[2] = 0.1;
5310                                         }
5311                                 }
5312                         }
5313                         else if (!strcmp("style", key))
5314                                 style = atoi(value);
5315                         else if (!strcmp("skin", key))
5316                                 skin = (int)atof(value);
5317                         else if (!strcmp("pflags", key))
5318                                 pflags = (int)atof(value);
5319                         else if (!strcmp("effects", key))
5320                                 effects = (int)atof(value);
5321                         else if (cl.worldmodel->type == mod_brushq3)
5322                         {
5323                                 if (!strcmp("scale", key))
5324                                         lightscale = atof(value);
5325                                 if (!strcmp("fade", key))
5326                                         fadescale = atof(value);
5327                         }
5328                 }
5329                 if (!islight)
5330                         continue;
5331                 if (lightscale <= 0)
5332                         lightscale = 1;
5333                 if (fadescale <= 0)
5334                         fadescale = 1;
5335                 if (color[0] == color[1] && color[0] == color[2])
5336                 {
5337                         color[0] *= overridecolor[0];
5338                         color[1] *= overridecolor[1];
5339                         color[2] *= overridecolor[2];
5340                 }
5341                 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
5342                 color[0] = color[0] * light[0];
5343                 color[1] = color[1] * light[1];
5344                 color[2] = color[2] * light[2];
5345                 switch (type)
5346                 {
5347                 case LIGHTTYPE_MINUSX:
5348                         break;
5349                 case LIGHTTYPE_RECIPX:
5350                         radius *= 2;
5351                         VectorScale(color, (1.0f / 16.0f), color);
5352                         break;
5353                 case LIGHTTYPE_RECIPXX:
5354                         radius *= 2;
5355                         VectorScale(color, (1.0f / 16.0f), color);
5356                         break;
5357                 default:
5358                 case LIGHTTYPE_NONE:
5359                         break;
5360                 case LIGHTTYPE_SUN:
5361                         break;
5362                 case LIGHTTYPE_MINUSXX:
5363                         break;
5364                 }
5365                 VectorAdd(origin, originhack, origin);
5366                 if (radius >= 1)
5367                         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);
5368         }
5369         if (entfiledata)
5370                 Mem_Free(entfiledata);
5371 }
5372
5373
5374 void R_Shadow_SetCursorLocationForView(void)
5375 {
5376         vec_t dist, push;
5377         vec3_t dest, endpos;
5378         trace_t trace;
5379         VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
5380         trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
5381         if (trace.fraction < 1)
5382         {
5383                 dist = trace.fraction * r_editlights_cursordistance.value;
5384                 push = r_editlights_cursorpushback.value;
5385                 if (push > dist)
5386                         push = dist;
5387                 push = -push;
5388                 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
5389                 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
5390         }
5391         else
5392         {
5393                 VectorClear( endpos );
5394         }
5395         r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5396         r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5397         r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5398 }
5399
5400 void R_Shadow_UpdateWorldLightSelection(void)
5401 {
5402         if (r_editlights.integer)
5403         {
5404                 R_Shadow_SetCursorLocationForView();
5405                 R_Shadow_SelectLightInView();
5406         }
5407         else
5408                 R_Shadow_SelectLight(NULL);
5409 }
5410
5411 void R_Shadow_EditLights_Clear_f(void)
5412 {
5413         R_Shadow_ClearWorldLights();
5414 }
5415
5416 void R_Shadow_EditLights_Reload_f(void)
5417 {
5418         if (!cl.worldmodel)
5419                 return;
5420         strlcpy(r_shadow_mapname, cl.worldmodel->name, sizeof(r_shadow_mapname));
5421         R_Shadow_ClearWorldLights();
5422         R_Shadow_LoadWorldLights();
5423         if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5424         {
5425                 R_Shadow_LoadLightsFile();
5426                 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5427                         R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5428         }
5429 }
5430
5431 void R_Shadow_EditLights_Save_f(void)
5432 {
5433         if (!cl.worldmodel)
5434                 return;
5435         R_Shadow_SaveWorldLights();
5436 }
5437
5438 void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
5439 {
5440         R_Shadow_ClearWorldLights();
5441         R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5442 }
5443
5444 void R_Shadow_EditLights_ImportLightsFile_f(void)
5445 {
5446         R_Shadow_ClearWorldLights();
5447         R_Shadow_LoadLightsFile();
5448 }
5449
5450 void R_Shadow_EditLights_Spawn_f(void)
5451 {
5452         vec3_t color;
5453         if (!r_editlights.integer)
5454         {
5455                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5456                 return;
5457         }
5458         if (Cmd_Argc() != 1)
5459         {
5460                 Con_Print("r_editlights_spawn does not take parameters\n");
5461                 return;
5462         }
5463         color[0] = color[1] = color[2] = 1;
5464         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5465 }
5466
5467 void R_Shadow_EditLights_Edit_f(void)
5468 {
5469         vec3_t origin, angles, color;
5470         vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
5471         int style, shadows, flags, normalmode, realtimemode;
5472         char cubemapname[MAX_INPUTLINE];
5473         if (!r_editlights.integer)
5474         {
5475                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5476                 return;
5477         }
5478         if (!r_shadow_selectedlight)
5479         {
5480                 Con_Print("No selected light.\n");
5481                 return;
5482         }
5483         VectorCopy(r_shadow_selectedlight->origin, origin);
5484         VectorCopy(r_shadow_selectedlight->angles, angles);
5485         VectorCopy(r_shadow_selectedlight->color, color);
5486         radius = r_shadow_selectedlight->radius;
5487         style = r_shadow_selectedlight->style;
5488         if (r_shadow_selectedlight->cubemapname)
5489                 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
5490         else
5491                 cubemapname[0] = 0;
5492         shadows = r_shadow_selectedlight->shadow;
5493         corona = r_shadow_selectedlight->corona;
5494         coronasizescale = r_shadow_selectedlight->coronasizescale;
5495         ambientscale = r_shadow_selectedlight->ambientscale;
5496         diffusescale = r_shadow_selectedlight->diffusescale;
5497         specularscale = r_shadow_selectedlight->specularscale;
5498         flags = r_shadow_selectedlight->flags;
5499         normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
5500         realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
5501         if (!strcmp(Cmd_Argv(1), "origin"))
5502         {
5503                 if (Cmd_Argc() != 5)
5504                 {
5505                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5506                         return;
5507                 }
5508                 origin[0] = atof(Cmd_Argv(2));
5509                 origin[1] = atof(Cmd_Argv(3));
5510                 origin[2] = atof(Cmd_Argv(4));
5511         }
5512         else if (!strcmp(Cmd_Argv(1), "originx"))
5513         {
5514                 if (Cmd_Argc() != 3)
5515                 {
5516                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5517                         return;
5518                 }
5519                 origin[0] = atof(Cmd_Argv(2));
5520         }
5521         else if (!strcmp(Cmd_Argv(1), "originy"))
5522         {
5523                 if (Cmd_Argc() != 3)
5524                 {
5525                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5526                         return;
5527                 }
5528                 origin[1] = atof(Cmd_Argv(2));
5529         }
5530         else if (!strcmp(Cmd_Argv(1), "originz"))
5531         {
5532                 if (Cmd_Argc() != 3)
5533                 {
5534                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5535                         return;
5536                 }
5537                 origin[2] = atof(Cmd_Argv(2));
5538         }
5539         else if (!strcmp(Cmd_Argv(1), "move"))
5540         {
5541                 if (Cmd_Argc() != 5)
5542                 {
5543                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5544                         return;
5545                 }
5546                 origin[0] += atof(Cmd_Argv(2));
5547                 origin[1] += atof(Cmd_Argv(3));
5548                 origin[2] += atof(Cmd_Argv(4));
5549         }
5550         else if (!strcmp(Cmd_Argv(1), "movex"))
5551         {
5552                 if (Cmd_Argc() != 3)
5553                 {
5554                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5555                         return;
5556                 }
5557                 origin[0] += atof(Cmd_Argv(2));
5558         }
5559         else if (!strcmp(Cmd_Argv(1), "movey"))
5560         {
5561                 if (Cmd_Argc() != 3)
5562                 {
5563                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5564                         return;
5565                 }
5566                 origin[1] += atof(Cmd_Argv(2));
5567         }
5568         else if (!strcmp(Cmd_Argv(1), "movez"))
5569         {
5570                 if (Cmd_Argc() != 3)
5571                 {
5572                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5573                         return;
5574                 }
5575                 origin[2] += atof(Cmd_Argv(2));
5576         }
5577         else if (!strcmp(Cmd_Argv(1), "angles"))
5578         {
5579                 if (Cmd_Argc() != 5)
5580                 {
5581                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5582                         return;
5583                 }
5584                 angles[0] = atof(Cmd_Argv(2));
5585                 angles[1] = atof(Cmd_Argv(3));
5586                 angles[2] = atof(Cmd_Argv(4));
5587         }
5588         else if (!strcmp(Cmd_Argv(1), "anglesx"))
5589         {
5590                 if (Cmd_Argc() != 3)
5591                 {
5592                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5593                         return;
5594                 }
5595                 angles[0] = atof(Cmd_Argv(2));
5596         }
5597         else if (!strcmp(Cmd_Argv(1), "anglesy"))
5598         {
5599                 if (Cmd_Argc() != 3)
5600                 {
5601                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5602                         return;
5603                 }
5604                 angles[1] = atof(Cmd_Argv(2));
5605         }
5606         else if (!strcmp(Cmd_Argv(1), "anglesz"))
5607         {
5608                 if (Cmd_Argc() != 3)
5609                 {
5610                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5611                         return;
5612                 }
5613                 angles[2] = atof(Cmd_Argv(2));
5614         }
5615         else if (!strcmp(Cmd_Argv(1), "color"))
5616         {
5617                 if (Cmd_Argc() != 5)
5618                 {
5619                         Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
5620                         return;
5621                 }
5622                 color[0] = atof(Cmd_Argv(2));
5623                 color[1] = atof(Cmd_Argv(3));
5624                 color[2] = atof(Cmd_Argv(4));
5625         }
5626         else if (!strcmp(Cmd_Argv(1), "radius"))
5627         {
5628                 if (Cmd_Argc() != 3)
5629                 {
5630                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5631                         return;
5632                 }
5633                 radius = atof(Cmd_Argv(2));
5634         }
5635         else if (!strcmp(Cmd_Argv(1), "colorscale"))
5636         {
5637                 if (Cmd_Argc() == 3)
5638                 {
5639                         double scale = atof(Cmd_Argv(2));
5640                         color[0] *= scale;
5641                         color[1] *= scale;
5642                         color[2] *= scale;
5643                 }
5644                 else
5645                 {
5646                         if (Cmd_Argc() != 5)
5647                         {
5648                                 Con_Printf("usage: r_editlights_edit %s red green blue  (OR grey instead of red green blue)\n", Cmd_Argv(1));
5649                                 return;
5650                         }
5651                         color[0] *= atof(Cmd_Argv(2));
5652                         color[1] *= atof(Cmd_Argv(3));
5653                         color[2] *= atof(Cmd_Argv(4));
5654                 }
5655         }
5656         else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
5657         {
5658                 if (Cmd_Argc() != 3)
5659                 {
5660                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5661                         return;
5662                 }
5663                 radius *= atof(Cmd_Argv(2));
5664         }
5665         else if (!strcmp(Cmd_Argv(1), "style"))
5666         {
5667                 if (Cmd_Argc() != 3)
5668                 {
5669                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5670                         return;
5671                 }
5672                 style = atoi(Cmd_Argv(2));
5673         }
5674         else if (!strcmp(Cmd_Argv(1), "cubemap"))
5675         {
5676                 if (Cmd_Argc() > 3)
5677                 {
5678                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5679                         return;
5680                 }
5681                 if (Cmd_Argc() == 3)
5682                         strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
5683                 else
5684                         cubemapname[0] = 0;
5685         }
5686         else if (!strcmp(Cmd_Argv(1), "shadows"))
5687         {
5688                 if (Cmd_Argc() != 3)
5689                 {
5690                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5691                         return;
5692                 }
5693                 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5694         }
5695         else if (!strcmp(Cmd_Argv(1), "corona"))
5696         {
5697                 if (Cmd_Argc() != 3)
5698                 {
5699                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5700                         return;
5701                 }
5702                 corona = atof(Cmd_Argv(2));
5703         }
5704         else if (!strcmp(Cmd_Argv(1), "coronasize"))
5705         {
5706                 if (Cmd_Argc() != 3)
5707                 {
5708                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5709                         return;
5710                 }
5711                 coronasizescale = atof(Cmd_Argv(2));
5712         }
5713         else if (!strcmp(Cmd_Argv(1), "ambient"))
5714         {
5715                 if (Cmd_Argc() != 3)
5716                 {
5717                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5718                         return;
5719                 }
5720                 ambientscale = atof(Cmd_Argv(2));
5721         }
5722         else if (!strcmp(Cmd_Argv(1), "diffuse"))
5723         {
5724                 if (Cmd_Argc() != 3)
5725                 {
5726                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5727                         return;
5728                 }
5729                 diffusescale = atof(Cmd_Argv(2));
5730         }
5731         else if (!strcmp(Cmd_Argv(1), "specular"))
5732         {
5733                 if (Cmd_Argc() != 3)
5734                 {
5735                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5736                         return;
5737                 }
5738                 specularscale = atof(Cmd_Argv(2));
5739         }
5740         else if (!strcmp(Cmd_Argv(1), "normalmode"))
5741         {
5742                 if (Cmd_Argc() != 3)
5743                 {
5744                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5745                         return;
5746                 }
5747                 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5748         }
5749         else if (!strcmp(Cmd_Argv(1), "realtimemode"))
5750         {
5751                 if (Cmd_Argc() != 3)
5752                 {
5753                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5754                         return;
5755                 }
5756                 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5757         }
5758         else
5759         {
5760                 Con_Print("usage: r_editlights_edit [property] [value]\n");
5761                 Con_Print("Selected light's properties:\n");
5762                 Con_Printf("Origin       : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
5763                 Con_Printf("Angles       : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
5764                 Con_Printf("Color        : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
5765                 Con_Printf("Radius       : %f\n", r_shadow_selectedlight->radius);
5766                 Con_Printf("Corona       : %f\n", r_shadow_selectedlight->corona);
5767                 Con_Printf("Style        : %i\n", r_shadow_selectedlight->style);
5768                 Con_Printf("Shadows      : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
5769                 Con_Printf("Cubemap      : %s\n", r_shadow_selectedlight->cubemapname);
5770                 Con_Printf("CoronaSize   : %f\n", r_shadow_selectedlight->coronasizescale);
5771                 Con_Printf("Ambient      : %f\n", r_shadow_selectedlight->ambientscale);
5772                 Con_Printf("Diffuse      : %f\n", r_shadow_selectedlight->diffusescale);
5773                 Con_Printf("Specular     : %f\n", r_shadow_selectedlight->specularscale);
5774                 Con_Printf("NormalMode   : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
5775                 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
5776                 return;
5777         }
5778         flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
5779         R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5780 }
5781
5782 void R_Shadow_EditLights_EditAll_f(void)
5783 {
5784         size_t lightindex;
5785         dlight_t *light;
5786         size_t range;
5787
5788         if (!r_editlights.integer)
5789         {
5790                 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
5791                 return;
5792         }
5793
5794         // EditLights doesn't seem to have a "remove" command or something so:
5795         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5796         for (lightindex = 0;lightindex < range;lightindex++)
5797         {
5798                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5799                 if (!light)
5800                         continue;
5801                 R_Shadow_SelectLight(light);
5802                 R_Shadow_EditLights_Edit_f();
5803         }
5804 }
5805
5806 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
5807 {
5808         int lightnumber, lightcount;
5809         size_t lightindex, range;
5810         dlight_t *light;
5811         float x, y;
5812         char temp[256];
5813         if (!r_editlights.integer)
5814                 return;
5815         x = vid_conwidth.value - 240;
5816         y = 5;
5817         DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
5818         lightnumber = -1;
5819         lightcount = 0;
5820         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5821         for (lightindex = 0;lightindex < range;lightindex++)
5822         {
5823                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5824                 if (!light)
5825                         continue;
5826                 if (light == r_shadow_selectedlight)
5827                         lightnumber = lightindex;
5828                 lightcount++;
5829         }
5830         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);y += 8;
5831         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);y += 8;
5832         y += 8;
5833         if (r_shadow_selectedlight == NULL)
5834                 return;
5835         dpsnprintf(temp, sizeof(temp), "Light #%i properties:", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8;
5836         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);y += 8;
5837         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);y += 8;
5838         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);y += 8;
5839         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);y += 8;
5840         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);y += 8;
5841         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);y += 8;
5842         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);y += 8;
5843         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);y += 8;
5844         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);y += 8;
5845         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);y += 8;
5846         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);y += 8;
5847         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);y += 8;
5848         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);y += 8;
5849         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);y += 8;
5850 }
5851
5852 void R_Shadow_EditLights_ToggleShadow_f(void)
5853 {
5854         if (!r_editlights.integer)
5855         {
5856                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5857                 return;
5858         }
5859         if (!r_shadow_selectedlight)
5860         {
5861                 Con_Print("No selected light.\n");
5862                 return;
5863         }
5864         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);
5865 }
5866
5867 void R_Shadow_EditLights_ToggleCorona_f(void)
5868 {
5869         if (!r_editlights.integer)
5870         {
5871                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5872                 return;
5873         }
5874         if (!r_shadow_selectedlight)
5875         {
5876                 Con_Print("No selected light.\n");
5877                 return;
5878         }
5879         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);
5880 }
5881
5882 void R_Shadow_EditLights_Remove_f(void)
5883 {
5884         if (!r_editlights.integer)
5885         {
5886                 Con_Print("Cannot remove light when not in editing mode.  Set r_editlights to 1.\n");
5887                 return;
5888         }
5889         if (!r_shadow_selectedlight)
5890         {
5891                 Con_Print("No selected light.\n");
5892                 return;
5893         }
5894         R_Shadow_FreeWorldLight(r_shadow_selectedlight);
5895         r_shadow_selectedlight = NULL;
5896 }
5897
5898 void R_Shadow_EditLights_Help_f(void)
5899 {
5900         Con_Print(
5901 "Documentation on r_editlights system:\n"
5902 "Settings:\n"
5903 "r_editlights : enable/disable editing mode\n"
5904 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
5905 "r_editlights_cursorpushback : push back cursor this far from surface\n"
5906 "r_editlights_cursorpushoff : push cursor off surface this far\n"
5907 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
5908 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
5909 "Commands:\n"
5910 "r_editlights_help : this help\n"
5911 "r_editlights_clear : remove all lights\n"
5912 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
5913 "r_editlights_save : save to .rtlights file\n"
5914 "r_editlights_spawn : create a light with default settings\n"
5915 "r_editlights_edit command : edit selected light - more documentation below\n"
5916 "r_editlights_remove : remove selected light\n"
5917 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
5918 "r_editlights_importlightentitiesfrommap : reload light entities\n"
5919 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
5920 "Edit commands:\n"
5921 "origin x y z : set light location\n"
5922 "originx x: set x component of light location\n"
5923 "originy y: set y component of light location\n"
5924 "originz z: set z component of light location\n"
5925 "move x y z : adjust light location\n"
5926 "movex x: adjust x component of light location\n"
5927 "movey y: adjust y component of light location\n"
5928 "movez z: adjust z component of light location\n"
5929 "angles x y z : set light angles\n"
5930 "anglesx x: set x component of light angles\n"
5931 "anglesy y: set y component of light angles\n"
5932 "anglesz z: set z component of light angles\n"
5933 "color r g b : set color of light (can be brighter than 1 1 1)\n"
5934 "radius radius : set radius (size) of light\n"
5935 "colorscale grey : multiply color of light (1 does nothing)\n"
5936 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
5937 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
5938 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
5939 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
5940 "cubemap basename : set filter cubemap of light (not yet supported)\n"
5941 "shadows 1/0 : turn on/off shadows\n"
5942 "corona n : set corona intensity\n"
5943 "coronasize n : set corona size (0-1)\n"
5944 "ambient n : set ambient intensity (0-1)\n"
5945 "diffuse n : set diffuse intensity (0-1)\n"
5946 "specular n : set specular intensity (0-1)\n"
5947 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
5948 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
5949 "<nothing> : print light properties to console\n"
5950         );
5951 }
5952
5953 void R_Shadow_EditLights_CopyInfo_f(void)
5954 {
5955         if (!r_editlights.integer)
5956         {
5957                 Con_Print("Cannot copy light info when not in editing mode.  Set r_editlights to 1.\n");
5958                 return;
5959         }
5960         if (!r_shadow_selectedlight)
5961         {
5962                 Con_Print("No selected light.\n");
5963                 return;
5964         }
5965         VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
5966         VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
5967         r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
5968         r_shadow_bufferlight.style = r_shadow_selectedlight->style;
5969         if (r_shadow_selectedlight->cubemapname)
5970                 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
5971         else
5972                 r_shadow_bufferlight.cubemapname[0] = 0;
5973         r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
5974         r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
5975         r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
5976         r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
5977         r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
5978         r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
5979         r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
5980 }
5981
5982 void R_Shadow_EditLights_PasteInfo_f(void)
5983 {
5984         if (!r_editlights.integer)
5985         {
5986                 Con_Print("Cannot paste light info when not in editing mode.  Set r_editlights to 1.\n");
5987                 return;
5988         }
5989         if (!r_shadow_selectedlight)
5990         {
5991                 Con_Print("No selected light.\n");
5992                 return;
5993         }
5994         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);
5995 }
5996
5997 void R_Shadow_EditLights_Init(void)
5998 {
5999         Cvar_RegisterVariable(&r_editlights);
6000         Cvar_RegisterVariable(&r_editlights_cursordistance);
6001         Cvar_RegisterVariable(&r_editlights_cursorpushback);
6002         Cvar_RegisterVariable(&r_editlights_cursorpushoff);
6003         Cvar_RegisterVariable(&r_editlights_cursorgrid);
6004         Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
6005         Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
6006         Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
6007         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)");
6008         Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
6009         Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
6010         Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
6011         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)");
6012         Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
6013         Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
6014         Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
6015         Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
6016         Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
6017         Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
6018         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)");
6019 }
6020
6021
6022
6023 /*
6024 =============================================================================
6025
6026 LIGHT SAMPLING
6027
6028 =============================================================================
6029 */
6030
6031 void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const vec3_t p, int dynamic)
6032 {
6033         VectorClear(diffusecolor);
6034         VectorClear(diffusenormal);
6035
6036         if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
6037         {
6038                 ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_refdef.scene.ambient * (2.0f / 128.0f);
6039                 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
6040         }
6041         else
6042                 VectorSet(ambientcolor, 1, 1, 1);
6043
6044         if (dynamic)
6045         {
6046                 int i;
6047                 float f, v[3];
6048                 rtlight_t *light;
6049                 for (i = 0;i < r_refdef.scene.numlights;i++)
6050                 {
6051                         light = r_refdef.scene.lights[i];
6052                         Matrix4x4_Transform(&light->matrix_worldtolight, p, v);
6053                         f = 1 - VectorLength2(v);
6054                         if (f > 0 && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1)
6055                                 VectorMA(ambientcolor, f, light->currentcolor, ambientcolor);
6056                 }
6057         }
6058 }