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 || r_shadow_deferred.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 || r_shadow_deferred.integer))
2101                         {
2102                                 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2103                                 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2104                                 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2105                         }
2106 #endif
2107                 }
2108                 CHECKGLERROR
2109                 if (r_shadow_shadowmap2dtexture) fbo = r_shadow_fbo2d;
2110                 r_shadow_shadowmap_texturescale[0] = 1.0f / R_TextureWidth(r_shadow_shadowmap2dtexture);
2111                 r_shadow_shadowmap_texturescale[1] = 1.0f / R_TextureHeight(r_shadow_shadowmap2dtexture);
2112                 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAP2D;
2113         }
2114         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE)
2115         {
2116                 r_shadow_shadowmap_parameters[0] = 0.5f * (size - r_shadow_shadowmapborder);
2117                 r_shadow_shadowmap_parameters[1] = r_shadow_shadowmapvsdct ? 2.5f*size : size;
2118                 R_Viewport_InitRectSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, r_shadow_shadowmapborder, nearclip, farclip, NULL);
2119                 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE) goto init_done;
2120
2121                 // complex unrolled cube approach (more flexible)
2122                 if (r_shadow_shadowmapvsdct && !r_shadow_shadowmapvsdcttexture)
2123                         R_Shadow_MakeVSDCT();
2124                 if (!r_shadow_shadowmaprectangletexture)
2125                 {
2126 #if 1
2127                         r_shadow_shadowmaprectangletexture = R_LoadTextureShadowMapRectangle(r_shadow_texturepool, "shadowmap", maxsize*2, maxsize*3, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2128                         qglGenFramebuffersEXT(1, &r_shadow_fborectangle);CHECKGLERROR
2129                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fborectangle);CHECKGLERROR
2130                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_shadowmaprectangletexture), 0);CHECKGLERROR
2131                         // render depth into the fbo, do not render color at all
2132                         qglDrawBuffer(GL_NONE);CHECKGLERROR
2133                         qglReadBuffer(GL_NONE);CHECKGLERROR
2134                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2135                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2136                         {
2137                                 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2138                                 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2139                                 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2140                         }
2141 #endif
2142                 }
2143                 CHECKGLERROR
2144                 if(r_shadow_shadowmaprectangletexture) fbo = r_shadow_fborectangle;
2145                 r_shadow_shadowmap_texturescale[0] = 1.0f;
2146                 r_shadow_shadowmap_texturescale[1] = 1.0f;
2147                 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE;
2148         }
2149         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
2150         {
2151                 r_shadow_shadowmap_parameters[0] = 1.0f;
2152                 r_shadow_shadowmap_parameters[1] = 1.0f;
2153                 R_Viewport_InitCubeSideView(&viewport, &rsurface.rtlight->matrix_lighttoworld, side, size, nearclip, farclip, NULL);
2154                 if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE) goto init_done;
2155
2156                 // simple cube approach
2157                 if (!r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod])
2158                 {
2159  #if 1
2160                         r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod] = R_LoadTextureShadowMapCube(r_shadow_texturepool, "shadowmapcube", size, r_shadow_shadowmapdepthbits, r_shadow_shadowmapsampler);
2161                         qglGenFramebuffersEXT(1, &r_shadow_fbocubeside[r_shadow_shadowmaplod]);CHECKGLERROR
2162                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_fbocubeside[r_shadow_shadowmaplod]);CHECKGLERROR
2163                         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
2164                         // render depth into the fbo, do not render color at all
2165                         qglDrawBuffer(GL_NONE);CHECKGLERROR
2166                         qglReadBuffer(GL_NONE);CHECKGLERROR
2167                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
2168                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT && (r_shadow_shadowmapping.integer || r_shadow_deferred.integer))
2169                         {
2170                                 Con_Printf("R_Shadow_RenderMode_ShadowMap: glCheckFramebufferStatusEXT returned %i\n", status);
2171                                 Cvar_SetValueQuick(&r_shadow_shadowmapping, 0);
2172                                 Cvar_SetValueQuick(&r_shadow_deferred, 0);
2173                         }
2174  #endif
2175                 }
2176                 CHECKGLERROR
2177                 if (r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]) fbo = r_shadow_fbocubeside[r_shadow_shadowmaplod];
2178                 r_shadow_shadowmap_texturescale[0] = 0.0f;
2179                 r_shadow_shadowmap_texturescale[1] = 0.0f;
2180                 r_shadow_rendermode = R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE;
2181         }
2182
2183         R_Shadow_RenderMode_Reset();
2184         if (fbo)
2185         {
2186                 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);CHECKGLERROR
2187                 R_SetupDepthOrShadowShader();
2188         }
2189         else
2190         {
2191                 R_SetupShowDepthShader();
2192                 qglClearColor(1,1,1,1);CHECKGLERROR
2193         }
2194         CHECKGLERROR
2195         GL_PolygonOffset(r_shadow_shadowmapping_polygonfactor.value, r_shadow_shadowmapping_polygonoffset.value);
2196         GL_DepthMask(true);
2197         GL_DepthTest(true);
2198         qglClearDepth(1);
2199         CHECKGLERROR
2200
2201 init_done:
2202         R_SetViewport(&viewport);
2203         GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
2204         if(r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE)
2205         {
2206                 int flipped = (side&1)^(side>>2);
2207                 r_refdef.view.cullface_front = flipped ? r_shadow_cullface_back : r_shadow_cullface_front;
2208                 r_refdef.view.cullface_back = flipped ? r_shadow_cullface_front : r_shadow_cullface_back;
2209                 GL_CullFace(r_refdef.view.cullface_back);
2210         }
2211         else if(r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE)
2212         {
2213                 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
2214         }
2215         if (clear)
2216                 qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT |  GL_STENCIL_BUFFER_BIT);
2217         CHECKGLERROR
2218 }
2219
2220 void R_Shadow_RenderMode_SetShadowMapTexture(void)
2221 {
2222         if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D)
2223         {
2224                 r_shadow_usingshadowmap2d = true;
2225                 R_Mesh_TexBind(GL20TU_SHADOWMAP2D, R_GetTexture(r_shadow_shadowmap2dtexture));
2226                 CHECKGLERROR
2227         }
2228         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE)
2229         {
2230                 r_shadow_usingshadowmaprect = true;
2231                 R_Mesh_TexBindAll(GL20TU_SHADOWMAPRECT, 0, 0, 0, R_GetTexture(r_shadow_shadowmaprectangletexture));
2232                 CHECKGLERROR
2233         }
2234         else if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
2235         {
2236                 r_shadow_usingshadowmapcube = true;
2237                 R_Mesh_TexBindAll(GL20TU_SHADOWMAPCUBE, 0, 0, R_GetTexture(r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]), 0);
2238                 CHECKGLERROR
2239         }
2240
2241         if (r_shadow_shadowmapvsdct && (r_shadow_usingshadowmap2d || r_shadow_usingshadowmaprect))
2242         {
2243                 R_Mesh_TexBindAll(GL20TU_CUBEPROJECTION, 0, 0, R_GetTexture(r_shadow_shadowmapvsdcttexture), 0);
2244                 CHECKGLERROR
2245         }
2246 }
2247
2248 void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent, qboolean shadowmapping)
2249 {
2250         if (transparent)
2251         {
2252                 r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2253                 r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2254                 r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2255                 r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2256         }
2257         CHECKGLERROR
2258         R_Shadow_RenderMode_Reset();
2259         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2260         if (!transparent)
2261         {
2262                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2263         }
2264         if (stenciltest)
2265         {
2266                 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2267                 // only draw light where this geometry was already rendered AND the
2268                 // stencil is 128 (values other than this mean shadow)
2269                 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2270         }
2271         r_shadow_rendermode = r_shadow_lightingrendermode;
2272         // do global setup needed for the chosen lighting mode
2273         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2274         {
2275                 R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0); // light filter
2276                 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 0);
2277                 CHECKGLERROR
2278                 if (shadowmapping)
2279                         R_Shadow_RenderMode_SetShadowMapTexture();
2280         }
2281         R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0);
2282         CHECKGLERROR
2283 }
2284
2285 static const unsigned short bboxelements[36] =
2286 {
2287         5, 1, 3, 5, 3, 7,
2288         6, 2, 0, 6, 0, 4,
2289         7, 3, 2, 7, 2, 6,
2290         4, 0, 1, 4, 1, 5,
2291         4, 5, 7, 4, 7, 6,
2292         1, 0, 2, 1, 2, 3,
2293 };
2294
2295 static const float bboxpoints[8][3] =
2296 {
2297         {-1,-1,-1},
2298         { 1,-1,-1},
2299         {-1, 1,-1},
2300         { 1, 1,-1},
2301         {-1,-1, 1},
2302         { 1,-1, 1},
2303         {-1, 1, 1},
2304         { 1, 1, 1},
2305 };
2306
2307 void R_Shadow_RenderMode_DrawDeferredLight(qboolean stenciltest, qboolean shadowmapping)
2308 {
2309         int i;
2310         float vertex3f[8*3];
2311         const matrix4x4_t *matrix = &rsurface.rtlight->matrix_lighttoworld;
2312         CHECKGLERROR
2313         R_Shadow_RenderMode_Reset();
2314         r_shadow_rendermode = r_shadow_lightingrendermode;
2315         // do global setup needed for the chosen lighting mode
2316         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL)
2317         {
2318                 R_Mesh_Matrix(&identitymatrix);
2319                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2320                 if (stenciltest)
2321                 {
2322                         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2323                         // only draw light where this geometry was already rendered AND the
2324                         // stencil is 128 (values other than this mean shadow)
2325                         qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2326                 }
2327                 qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
2328                 R_Mesh_TexBindAll(GL20TU_SCREENDEPTH, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrydepthtexture));
2329                 R_Mesh_TexBindAll(GL20TU_SCREENNORMALMAP, 0, 0, 0, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture));
2330                 R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0); // light filter
2331                 if (shadowmapping)
2332                         R_Shadow_RenderMode_SetShadowMapTexture();
2333                 R_SetupDeferredLightShader(rsurface.rtlight);
2334                 //R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
2335                 R_Mesh_TexBind(GL20TU_ATTENUATION, R_GetTexture(r_shadow_attenuationgradienttexture));
2336
2337                 for (i = 0;i < 8;i++)
2338                         Matrix4x4_Transform(matrix, bboxpoints[i], vertex3f + i*3);
2339                 CHECKGLERROR
2340                 //qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
2341                 R_Mesh_VertexPointer(vertex3f, 0, 0);
2342                 R_Mesh_ColorPointer(NULL, 0, 0);
2343                 GL_ColorMask(1,1,1,1);
2344                 //GL_Color(0.25f,0.05f,0.02f,1.0f);
2345                 //R_SetupGenericShader(false);
2346                 GL_DepthMask(false);
2347                 GL_DepthRange(0, 1);
2348                 GL_PolygonOffset(0, 0);
2349                 GL_DepthTest(true);
2350                 qglDepthFunc(GL_GREATER);CHECKGLERROR
2351                 GL_CullFace(r_refdef.view.cullface_back);
2352                 //GL_AlphaTest(false);
2353                 //qglDisable(GL_STENCIL_TEST);CHECKGLERROR
2354                 R_Mesh_Draw(0, 8, 0, 12, NULL, bboxelements, 0, 0);
2355         }
2356 }
2357
2358 void R_Shadow_RenderMode_VisibleShadowVolumes(void)
2359 {
2360         CHECKGLERROR
2361         R_Shadow_RenderMode_Reset();
2362         GL_BlendFunc(GL_ONE, GL_ONE);
2363         GL_DepthRange(0, 1);
2364         GL_DepthTest(r_showshadowvolumes.integer < 2);
2365         GL_Color(0.0, 0.0125 * r_refdef.view.colorscale, 0.1 * r_refdef.view.colorscale, 1);
2366         GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR
2367         GL_CullFace(GL_NONE);
2368         r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES;
2369 }
2370
2371 void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent)
2372 {
2373         CHECKGLERROR
2374         R_Shadow_RenderMode_Reset();
2375         GL_BlendFunc(GL_ONE, GL_ONE);
2376         GL_DepthRange(0, 1);
2377         GL_DepthTest(r_showlighting.integer < 2);
2378         GL_Color(0.1 * r_refdef.view.colorscale, 0.0125 * r_refdef.view.colorscale, 0, 1);
2379         if (!transparent)
2380         {
2381                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2382         }
2383         if (stenciltest)
2384         {
2385                 qglEnable(GL_STENCIL_TEST);CHECKGLERROR
2386                 qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR
2387         }
2388         r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING;
2389 }
2390
2391 void R_Shadow_RenderMode_End(void)
2392 {
2393         CHECKGLERROR
2394         R_Shadow_RenderMode_Reset();
2395         R_Shadow_RenderMode_ActiveLight(NULL);
2396         GL_DepthMask(true);
2397         GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
2398         r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE;
2399 }
2400
2401 int bboxedges[12][2] =
2402 {
2403         // top
2404         {0, 1}, // +X
2405         {0, 2}, // +Y
2406         {1, 3}, // Y, +X
2407         {2, 3}, // X, +Y
2408         // bottom
2409         {4, 5}, // +X
2410         {4, 6}, // +Y
2411         {5, 7}, // Y, +X
2412         {6, 7}, // X, +Y
2413         // verticals
2414         {0, 4}, // +Z
2415         {1, 5}, // X, +Z
2416         {2, 6}, // Y, +Z
2417         {3, 7}, // XY, +Z
2418 };
2419
2420 qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs)
2421 {
2422         int i, ix1, iy1, ix2, iy2;
2423         float x1, y1, x2, y2;
2424         vec4_t v, v2;
2425         float vertex[20][3];
2426         int j, k;
2427         vec4_t plane4f;
2428         int numvertices;
2429         float corner[8][4];
2430         float dist[8];
2431         int sign[8];
2432         float f;
2433
2434         r_shadow_lightscissor[0] = r_refdef.view.viewport.x;
2435         r_shadow_lightscissor[1] = r_refdef.view.viewport.y;
2436         r_shadow_lightscissor[2] = r_refdef.view.viewport.width;
2437         r_shadow_lightscissor[3] = r_refdef.view.viewport.height;
2438
2439         if (!r_shadow_scissor.integer)
2440                 return false;
2441
2442         // if view is inside the light box, just say yes it's visible
2443         if (BoxesOverlap(r_refdef.view.origin, r_refdef.view.origin, mins, maxs))
2444                 return false;
2445
2446         x1 = y1 = x2 = y2 = 0;
2447
2448         // transform all corners that are infront of the nearclip plane
2449         VectorNegate(r_refdef.view.frustum[4].normal, plane4f);
2450         plane4f[3] = r_refdef.view.frustum[4].dist;
2451         numvertices = 0;
2452         for (i = 0;i < 8;i++)
2453         {
2454                 Vector4Set(corner[i], (i & 1) ? maxs[0] : mins[0], (i & 2) ? maxs[1] : mins[1], (i & 4) ? maxs[2] : mins[2], 1);
2455                 dist[i] = DotProduct4(corner[i], plane4f);
2456                 sign[i] = dist[i] > 0;
2457                 if (!sign[i])
2458                 {
2459                         VectorCopy(corner[i], vertex[numvertices]);
2460                         numvertices++;
2461                 }
2462         }
2463         // if some points are behind the nearclip, add clipped edge points to make
2464         // sure that the scissor boundary is complete
2465         if (numvertices > 0 && numvertices < 8)
2466         {
2467                 // add clipped edge points
2468                 for (i = 0;i < 12;i++)
2469                 {
2470                         j = bboxedges[i][0];
2471                         k = bboxedges[i][1];
2472                         if (sign[j] != sign[k])
2473                         {
2474                                 f = dist[j] / (dist[j] - dist[k]);
2475                                 VectorLerp(corner[j], f, corner[k], vertex[numvertices]);
2476                                 numvertices++;
2477                         }
2478                 }
2479         }
2480
2481         // if we have no points to check, the light is behind the view plane
2482         if (!numvertices)
2483                 return true;
2484
2485         // if we have some points to transform, check what screen area is covered
2486         x1 = y1 = x2 = y2 = 0;
2487         v[3] = 1.0f;
2488         //Con_Printf("%i vertices to transform...\n", numvertices);
2489         for (i = 0;i < numvertices;i++)
2490         {
2491                 VectorCopy(vertex[i], v);
2492                 R_Viewport_TransformToScreen(&r_refdef.view.viewport, v, v2);
2493                 //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]);
2494                 if (i)
2495                 {
2496                         if (x1 > v2[0]) x1 = v2[0];
2497                         if (x2 < v2[0]) x2 = v2[0];
2498                         if (y1 > v2[1]) y1 = v2[1];
2499                         if (y2 < v2[1]) y2 = v2[1];
2500                 }
2501                 else
2502                 {
2503                         x1 = x2 = v2[0];
2504                         y1 = y2 = v2[1];
2505                 }
2506         }
2507
2508         // now convert the scissor rectangle to integer screen coordinates
2509         ix1 = (int)(x1 - 1.0f);
2510         iy1 = vid.height - (int)(y2 - 1.0f);
2511         ix2 = (int)(x2 + 1.0f);
2512         iy2 = vid.height - (int)(y1 + 1.0f);
2513         //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2);
2514
2515         // clamp it to the screen
2516         if (ix1 < r_refdef.view.viewport.x) ix1 = r_refdef.view.viewport.x;
2517         if (iy1 < r_refdef.view.viewport.y) iy1 = r_refdef.view.viewport.y;
2518         if (ix2 > r_refdef.view.viewport.x + r_refdef.view.viewport.width) ix2 = r_refdef.view.viewport.x + r_refdef.view.viewport.width;
2519         if (iy2 > r_refdef.view.viewport.y + r_refdef.view.viewport.height) iy2 = r_refdef.view.viewport.y + r_refdef.view.viewport.height;
2520
2521         // if it is inside out, it's not visible
2522         if (ix2 <= ix1 || iy2 <= iy1)
2523                 return true;
2524
2525         // the light area is visible, set up the scissor rectangle
2526         r_shadow_lightscissor[0] = ix1;
2527         r_shadow_lightscissor[1] = iy1;
2528         r_shadow_lightscissor[2] = ix2 - ix1;
2529         r_shadow_lightscissor[3] = iy2 - iy1;
2530
2531         r_refdef.stats.lights_scissored++;
2532         return false;
2533 }
2534
2535 static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, int numtriangles, const int *element3i, const float *diffusecolor, const float *ambientcolor)
2536 {
2537         const float *vertex3f = rsurface.vertex3f + 3 * firstvertex;
2538         const float *normal3f = rsurface.normal3f + 3 * firstvertex;
2539         float *color4f = rsurface.array_color4f + 4 * firstvertex;
2540         float dist, dot, distintensity, shadeintensity, v[3], n[3];
2541         switch (r_shadow_rendermode)
2542         {
2543         case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2544         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2545                 if (VectorLength2(diffusecolor) > 0)
2546                 {
2547                         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2548                         {
2549                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2550                                 Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2551                                 if ((dot = DotProduct(n, v)) < 0)
2552                                 {
2553                                         shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2554                                         VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f);
2555                                 }
2556                                 else
2557                                         VectorCopy(ambientcolor, color4f);
2558                                 if (r_refdef.fogenabled)
2559                                 {
2560                                         float f;
2561                                         f = RSurf_FogVertex(vertex3f);
2562                                         VectorScale(color4f, f, color4f);
2563                                 }
2564                                 color4f[3] = 1;
2565                         }
2566                 }
2567                 else
2568                 {
2569                         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2570                         {
2571                                 VectorCopy(ambientcolor, color4f);
2572                                 if (r_refdef.fogenabled)
2573                                 {
2574                                         float f;
2575                                         Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2576                                         f = RSurf_FogVertex(vertex3f);
2577                                         VectorScale(color4f, f, color4f);
2578                                 }
2579                                 color4f[3] = 1;
2580                         }
2581                 }
2582                 break;
2583         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2584                 if (VectorLength2(diffusecolor) > 0)
2585                 {
2586                         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2587                         {
2588                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2589                                 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2590                                 {
2591                                         Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2592                                         if ((dot = DotProduct(n, v)) < 0)
2593                                         {
2594                                                 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2595                                                 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
2596                                                 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
2597                                                 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
2598                                         }
2599                                         else
2600                                         {
2601                                                 color4f[0] = ambientcolor[0] * distintensity;
2602                                                 color4f[1] = ambientcolor[1] * distintensity;
2603                                                 color4f[2] = ambientcolor[2] * distintensity;
2604                                         }
2605                                         if (r_refdef.fogenabled)
2606                                         {
2607                                                 float f;
2608                                                 f = RSurf_FogVertex(vertex3f);
2609                                                 VectorScale(color4f, f, color4f);
2610                                         }
2611                                 }
2612                                 else
2613                                         VectorClear(color4f);
2614                                 color4f[3] = 1;
2615                         }
2616                 }
2617                 else
2618                 {
2619                         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2620                         {
2621                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2622                                 if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2623                                 {
2624                                         color4f[0] = ambientcolor[0] * distintensity;
2625                                         color4f[1] = ambientcolor[1] * distintensity;
2626                                         color4f[2] = ambientcolor[2] * distintensity;
2627                                         if (r_refdef.fogenabled)
2628                                         {
2629                                                 float f;
2630                                                 f = RSurf_FogVertex(vertex3f);
2631                                                 VectorScale(color4f, f, color4f);
2632                                         }
2633                                 }
2634                                 else
2635                                         VectorClear(color4f);
2636                                 color4f[3] = 1;
2637                         }
2638                 }
2639                 break;
2640         case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2641                 if (VectorLength2(diffusecolor) > 0)
2642                 {
2643                         for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4)
2644                         {
2645                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2646                                 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2647                                 {
2648                                         distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
2649                                         Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n);
2650                                         if ((dot = DotProduct(n, v)) < 0)
2651                                         {
2652                                                 shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n));
2653                                                 color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity;
2654                                                 color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity;
2655                                                 color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity;
2656                                         }
2657                                         else
2658                                         {
2659                                                 color4f[0] = ambientcolor[0] * distintensity;
2660                                                 color4f[1] = ambientcolor[1] * distintensity;
2661                                                 color4f[2] = ambientcolor[2] * distintensity;
2662                                         }
2663                                         if (r_refdef.fogenabled)
2664                                         {
2665                                                 float f;
2666                                                 f = RSurf_FogVertex(vertex3f);
2667                                                 VectorScale(color4f, f, color4f);
2668                                         }
2669                                 }
2670                                 else
2671                                         VectorClear(color4f);
2672                                 color4f[3] = 1;
2673                         }
2674                 }
2675                 else
2676                 {
2677                         for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4)
2678                         {
2679                                 Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v);
2680                                 if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)]))
2681                                 {
2682                                         distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
2683                                         color4f[0] = ambientcolor[0] * distintensity;
2684                                         color4f[1] = ambientcolor[1] * distintensity;
2685                                         color4f[2] = ambientcolor[2] * distintensity;
2686                                         if (r_refdef.fogenabled)
2687                                         {
2688                                                 float f;
2689                                                 f = RSurf_FogVertex(vertex3f);
2690                                                 VectorScale(color4f, f, color4f);
2691                                         }
2692                                 }
2693                                 else
2694                                         VectorClear(color4f);
2695                                 color4f[3] = 1;
2696                         }
2697                 }
2698                 break;
2699         default:
2700                 break;
2701         }
2702 }
2703
2704 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)
2705 {
2706         // used to display how many times a surface is lit for level design purposes
2707         R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2708 }
2709
2710 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 lightcolor, float ambientscale, float diffusescale, float specularscale)
2711 {
2712         // ARB2 GLSL shader path (GFFX5200, Radeon 9500)
2713         R_SetupSurfaceShader(lightcolor, false, ambientscale, diffusescale, specularscale, RSURFPASS_RTLIGHT);
2714         if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND))
2715                 R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset);
2716         else
2717                 R_Mesh_ColorPointer(NULL, 0, 0);
2718         R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix);
2719         R_Mesh_TexMatrix(1, &rsurface.texture->currentbackgroundtexmatrix);
2720         R_Mesh_TexBind(GL20TU_NORMAL, R_GetTexture(rsurface.texture->currentskinframe->nmap));
2721         R_Mesh_TexBind(GL20TU_COLOR, R_GetTexture(rsurface.texture->basetexture));
2722         R_Mesh_TexBind(GL20TU_GLOSS, R_GetTexture(rsurface.texture->glosstexture));
2723         if (rsurface.texture->backgroundcurrentskinframe)
2724         {
2725                 R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->nmap));
2726                 R_Mesh_TexBind(GL20TU_SECONDARY_COLOR, R_GetTexture(rsurface.texture->backgroundbasetexture));
2727                 R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS, R_GetTexture(rsurface.texture->backgroundglosstexture));
2728                 R_Mesh_TexBind(GL20TU_SECONDARY_GLOW, R_GetTexture(rsurface.texture->backgroundcurrentskinframe->glow));
2729         }
2730         //R_Mesh_TexBindAll(GL20TU_CUBE, 0, 0, R_GetTexture(rsurface.rtlight->currentcubemap), 0);
2731         R_Mesh_TexBind(GL20TU_FOGMASK, R_GetTexture(r_texture_fogattenuation));
2732         if(rsurface.texture->colormapping)
2733         {
2734                 R_Mesh_TexBind(GL20TU_PANTS, R_GetTexture(rsurface.texture->currentskinframe->pants));
2735                 R_Mesh_TexBind(GL20TU_SHIRT, R_GetTexture(rsurface.texture->currentskinframe->shirt));
2736         }
2737         R_Mesh_TexBind(GL20TU_ATTENUATION, R_GetTexture(r_shadow_attenuationgradienttexture));
2738         R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset);
2739         R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset);
2740         R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset);
2741         R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset);
2742         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
2743         {
2744                 qglDepthFunc(GL_EQUAL);CHECKGLERROR
2745         }
2746         R_Mesh_Draw(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2747         if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
2748         {
2749                 qglDepthFunc(GL_LEQUAL);CHECKGLERROR
2750         }
2751 }
2752
2753 static void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, vec3_t diffusecolor2, vec3_t ambientcolor2)
2754 {
2755         int renders;
2756         int i;
2757         int stop;
2758         int newfirstvertex;
2759         int newlastvertex;
2760         int newnumtriangles;
2761         int *newe;
2762         const int *e;
2763         float *c;
2764         int maxtriangles = 4096;
2765         static int newelements[4096*3];
2766         R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, numtriangles, element3i, diffusecolor2, ambientcolor2);
2767         for (renders = 0;renders < 64;renders++)
2768         {
2769                 stop = true;
2770                 newfirstvertex = 0;
2771                 newlastvertex = 0;
2772                 newnumtriangles = 0;
2773                 newe = newelements;
2774                 // due to low fillrate on the cards this vertex lighting path is
2775                 // designed for, we manually cull all triangles that do not
2776                 // contain a lit vertex
2777                 // this builds batches of triangles from multiple surfaces and
2778                 // renders them at once
2779                 for (i = 0, e = element3i;i < numtriangles;i++, e += 3)
2780                 {
2781                         if (VectorLength2(rsurface.array_color4f + e[0] * 4) + VectorLength2(rsurface.array_color4f + e[1] * 4) + VectorLength2(rsurface.array_color4f + e[2] * 4) >= 0.01)
2782                         {
2783                                 if (newnumtriangles)
2784                                 {
2785                                         newfirstvertex = min(newfirstvertex, e[0]);
2786                                         newlastvertex  = max(newlastvertex, e[0]);
2787                                 }
2788                                 else
2789                                 {
2790                                         newfirstvertex = e[0];
2791                                         newlastvertex = e[0];
2792                                 }
2793                                 newfirstvertex = min(newfirstvertex, e[1]);
2794                                 newlastvertex  = max(newlastvertex, e[1]);
2795                                 newfirstvertex = min(newfirstvertex, e[2]);
2796                                 newlastvertex  = max(newlastvertex, e[2]);
2797                                 newe[0] = e[0];
2798                                 newe[1] = e[1];
2799                                 newe[2] = e[2];
2800                                 newnumtriangles++;
2801                                 newe += 3;
2802                                 if (newnumtriangles >= maxtriangles)
2803                                 {
2804                                         R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2805                                         newnumtriangles = 0;
2806                                         newe = newelements;
2807                                         stop = false;
2808                                 }
2809                         }
2810                 }
2811                 if (newnumtriangles >= 1)
2812                 {
2813                         R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, 0, newnumtriangles, newelements, NULL, 0, 0);
2814                         stop = false;
2815                 }
2816                 // if we couldn't find any lit triangles, exit early
2817                 if (stop)
2818                         break;
2819                 // now reduce the intensity for the next overbright pass
2820                 // we have to clamp to 0 here incase the drivers have improper
2821                 // handling of negative colors
2822                 // (some old drivers even have improper handling of >1 color)
2823                 stop = true;
2824                 for (i = 0, c = rsurface.array_color4f + 4 * firstvertex;i < numvertices;i++, c += 4)
2825                 {
2826                         if (c[0] > 1 || c[1] > 1 || c[2] > 1)
2827                         {
2828                                 c[0] = max(0, c[0] - 1);
2829                                 c[1] = max(0, c[1] - 1);
2830                                 c[2] = max(0, c[2] - 1);
2831                                 stop = false;
2832                         }
2833                         else
2834                                 VectorClear(c);
2835                 }
2836                 // another check...
2837                 if (stop)
2838                         break;
2839         }
2840 }
2841
2842 static void R_Shadow_RenderLighting_Light_Vertex(int firstvertex, int numvertices, int numtriangles, const int *element3i, const vec3_t lightcolor, float ambientscale, float diffusescale)
2843 {
2844         // OpenGL 1.1 path (anything)
2845         float ambientcolorbase[3], diffusecolorbase[3];
2846         float ambientcolorpants[3], diffusecolorpants[3];
2847         float ambientcolorshirt[3], diffusecolorshirt[3];
2848         const float *surfacecolor = rsurface.texture->dlightcolor;
2849         const float *surfacepants = rsurface.colormap_pantscolor;
2850         const float *surfaceshirt = rsurface.colormap_shirtcolor;
2851         rtexture_t *basetexture = rsurface.texture->basetexture;
2852         rtexture_t *pantstexture = rsurface.texture->currentskinframe->pants;
2853         rtexture_t *shirttexture = rsurface.texture->currentskinframe->shirt;
2854         qboolean dopants = pantstexture && VectorLength2(surfacepants) >= (1.0f / 1048576.0f);
2855         qboolean doshirt = shirttexture && VectorLength2(surfaceshirt) >= (1.0f / 1048576.0f);
2856         rmeshstate_t m;
2857         ambientscale *= 2 * r_refdef.view.colorscale;
2858         diffusescale *= 2 * r_refdef.view.colorscale;
2859         ambientcolorbase[0] = lightcolor[0] * ambientscale * surfacecolor[0];ambientcolorbase[1] = lightcolor[1] * ambientscale * surfacecolor[1];ambientcolorbase[2] = lightcolor[2] * ambientscale * surfacecolor[2];
2860         diffusecolorbase[0] = lightcolor[0] * diffusescale * surfacecolor[0];diffusecolorbase[1] = lightcolor[1] * diffusescale * surfacecolor[1];diffusecolorbase[2] = lightcolor[2] * diffusescale * surfacecolor[2];
2861         ambientcolorpants[0] = ambientcolorbase[0] * surfacepants[0];ambientcolorpants[1] = ambientcolorbase[1] * surfacepants[1];ambientcolorpants[2] = ambientcolorbase[2] * surfacepants[2];
2862         diffusecolorpants[0] = diffusecolorbase[0] * surfacepants[0];diffusecolorpants[1] = diffusecolorbase[1] * surfacepants[1];diffusecolorpants[2] = diffusecolorbase[2] * surfacepants[2];
2863         ambientcolorshirt[0] = ambientcolorbase[0] * surfaceshirt[0];ambientcolorshirt[1] = ambientcolorbase[1] * surfaceshirt[1];ambientcolorshirt[2] = ambientcolorbase[2] * surfaceshirt[2];
2864         diffusecolorshirt[0] = diffusecolorbase[0] * surfaceshirt[0];diffusecolorshirt[1] = diffusecolorbase[1] * surfaceshirt[1];diffusecolorshirt[2] = diffusecolorbase[2] * surfaceshirt[2];
2865         switch(r_shadow_rendermode)
2866         {
2867         case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2868                 memset(&m, 0, sizeof(m));
2869                 m.tex[0] = R_GetTexture(basetexture);
2870                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2871                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2872                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2873                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2874                 m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture);
2875                 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2876                 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2877                 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2878                 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2879                 R_Mesh_TextureState(&m);
2880                 break;
2881         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2882                 memset(&m, 0, sizeof(m));
2883                 m.tex[0] = R_GetTexture(basetexture);
2884                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2885                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2886                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2887                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2888                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2889                 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2890                 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2891                 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2892                 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2893                 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
2894                 m.texmatrix[2] = rsurface.entitytoattenuationz;
2895                 m.pointer_texcoord3f[2] = rsurface.vertex3f;
2896                 m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject;
2897                 m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset;
2898                 R_Mesh_TextureState(&m);
2899                 break;
2900         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2901                 memset(&m, 0, sizeof(m));
2902                 m.tex[0] = R_GetTexture(basetexture);
2903                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2904                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2905                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2906                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2907                 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture);
2908                 m.texmatrix[1] = rsurface.entitytoattenuationxyz;
2909                 m.pointer_texcoord3f[1] = rsurface.vertex3f;
2910                 m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject;
2911                 m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset;
2912                 R_Mesh_TextureState(&m);
2913                 break;
2914         case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2915                 memset(&m, 0, sizeof(m));
2916                 m.tex[0] = R_GetTexture(basetexture);
2917                 m.texmatrix[0] = rsurface.texture->currenttexmatrix;
2918                 m.pointer_texcoord[0] = rsurface.texcoordtexture2f;
2919                 m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject;
2920                 m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset;
2921                 R_Mesh_TextureState(&m);
2922                 break;
2923         default:
2924                 break;
2925         }
2926         //R_Mesh_TexBind(0, R_GetTexture(basetexture));
2927         R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorbase, ambientcolorbase);
2928         if (dopants)
2929         {
2930                 R_Mesh_TexBind(0, R_GetTexture(pantstexture));
2931                 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorpants, ambientcolorpants);
2932         }
2933         if (doshirt)
2934         {
2935                 R_Mesh_TexBind(0, R_GetTexture(shirttexture));
2936                 R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, diffusecolorshirt, ambientcolorshirt);
2937         }
2938 }
2939
2940 extern cvar_t gl_lightmaps;
2941 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)
2942 {
2943         float ambientscale, diffusescale, specularscale;
2944         qboolean negated;
2945         float lightcolor[3];
2946         VectorCopy(rsurface.rtlight->currentcolor, lightcolor);
2947         ambientscale = rsurface.rtlight->ambientscale;
2948         diffusescale = rsurface.rtlight->diffusescale;
2949         specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale;
2950         if (!r_shadow_usenormalmap.integer)
2951         {
2952                 ambientscale += 1.0f * diffusescale;
2953                 diffusescale = 0;
2954                 specularscale = 0;
2955         }
2956         if ((ambientscale + diffusescale) * VectorLength2(lightcolor) + specularscale * VectorLength2(lightcolor) < (1.0f / 1048576.0f))
2957                 return;
2958         negated = (lightcolor[0] + lightcolor[1] + lightcolor[2] < 0) && vid.support.ext_blend_subtract;
2959         if(negated)
2960         {
2961                 VectorNegate(lightcolor, lightcolor);
2962                 qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
2963         }
2964         RSurf_SetupDepthAndCulling();
2965         switch (r_shadow_rendermode)
2966         {
2967         case R_SHADOW_RENDERMODE_VISIBLELIGHTING:
2968                 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer);
2969                 R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject);
2970                 break;
2971         case R_SHADOW_RENDERMODE_LIGHT_GLSL:
2972                 R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, firsttriangle, numtriangles, element3i, element3s, element3i_bufferobject, element3s_bufferobject, lightcolor, ambientscale, diffusescale, specularscale);
2973                 break;
2974         case R_SHADOW_RENDERMODE_LIGHT_VERTEX3DATTEN:
2975         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2D1DATTEN:
2976         case R_SHADOW_RENDERMODE_LIGHT_VERTEX2DATTEN:
2977         case R_SHADOW_RENDERMODE_LIGHT_VERTEX:
2978                 R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i + firsttriangle * 3, lightcolor, ambientscale, diffusescale);
2979                 break;
2980         default:
2981                 Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode);
2982                 break;
2983         }
2984         if(negated)
2985                 qglBlendEquationEXT(GL_FUNC_ADD_EXT);
2986 }
2987
2988 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)
2989 {
2990         matrix4x4_t tempmatrix = *matrix;
2991         Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1);
2992
2993         // if this light has been compiled before, free the associated data
2994         R_RTLight_Uncompile(rtlight);
2995
2996         // clear it completely to avoid any lingering data
2997         memset(rtlight, 0, sizeof(*rtlight));
2998
2999         // copy the properties
3000         rtlight->matrix_lighttoworld = tempmatrix;
3001         Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix);
3002         Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin);
3003         rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix);
3004         VectorCopy(color, rtlight->color);
3005         rtlight->cubemapname[0] = 0;
3006         if (cubemapname && cubemapname[0])
3007                 strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname));
3008         rtlight->shadow = shadow;
3009         rtlight->corona = corona;
3010         rtlight->style = style;
3011         rtlight->isstatic = isstatic;
3012         rtlight->coronasizescale = coronasizescale;
3013         rtlight->ambientscale = ambientscale;
3014         rtlight->diffusescale = diffusescale;
3015         rtlight->specularscale = specularscale;
3016         rtlight->flags = flags;
3017
3018         // compute derived data
3019         //rtlight->cullradius = rtlight->radius;
3020         //rtlight->cullradius2 = rtlight->radius * rtlight->radius;
3021         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3022         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3023         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3024         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3025         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3026         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3027 }
3028
3029 // compiles rtlight geometry
3030 // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls)
3031 void R_RTLight_Compile(rtlight_t *rtlight)
3032 {
3033         int i;
3034         int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes;
3035         int lighttris, shadowtris, shadowzpasstris, shadowzfailtris;
3036         entity_render_t *ent = r_refdef.scene.worldentity;
3037         dp_model_t *model = r_refdef.scene.worldmodel;
3038         unsigned char *data;
3039         shadowmesh_t *mesh;
3040
3041         // compile the light
3042         rtlight->compiled = true;
3043         rtlight->shadowmode = rtlight->shadow ? (int)r_shadow_shadowmode : -1;
3044         rtlight->static_numleafs = 0;
3045         rtlight->static_numleafpvsbytes = 0;
3046         rtlight->static_leaflist = NULL;
3047         rtlight->static_leafpvs = NULL;
3048         rtlight->static_numsurfaces = 0;
3049         rtlight->static_surfacelist = NULL;
3050         rtlight->static_shadowmap_receivers = 0x3F;
3051         rtlight->static_shadowmap_casters = 0x3F;
3052         rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius;
3053         rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius;
3054         rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius;
3055         rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius;
3056         rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius;
3057         rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius;
3058
3059         if (model && model->GetLightInfo)
3060         {
3061                 // this variable must be set for the CompileShadowVolume/CompileShadowMap code
3062                 r_shadow_compilingrtlight = rtlight;
3063                 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);
3064                 numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
3065                 numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3;
3066                 numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3;
3067                 data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes);
3068                 rtlight->static_numsurfaces = numsurfaces;
3069                 rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
3070                 rtlight->static_numleafs = numleafs;
3071                 rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
3072                 rtlight->static_numleafpvsbytes = numleafpvsbytes;
3073                 rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes;
3074                 rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes;
3075                 rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes;
3076                 rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes;
3077                 rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes;
3078                 if (rtlight->static_numsurfaces)
3079                         memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist));
3080                 if (rtlight->static_numleafs)
3081                         memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
3082                 if (rtlight->static_numleafpvsbytes)
3083                         memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes);
3084                 if (rtlight->static_numshadowtrispvsbytes)
3085                         memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes);
3086                 if (rtlight->static_numlighttrispvsbytes)
3087                         memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes);
3088                 switch (rtlight->shadowmode)
3089                 {
3090                 case R_SHADOW_SHADOWMODE_SHADOWMAP2D:
3091                 case R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE:
3092                 case R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE:
3093                         if (model->CompileShadowMap && rtlight->shadow)
3094                                 model->CompileShadowMap(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3095                         break;
3096                 default:
3097                         if (model->CompileShadowVolume && rtlight->shadow)
3098                                 model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist);
3099                         break;
3100                 }
3101                 // now we're done compiling the rtlight
3102                 r_shadow_compilingrtlight = NULL;
3103         }
3104
3105
3106         // use smallest available cullradius - box radius or light radius
3107         //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin);
3108         //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius);
3109
3110         shadowzpasstris = 0;
3111         if (rtlight->static_meshchain_shadow_zpass)
3112                 for (mesh = rtlight->static_meshchain_shadow_zpass;mesh;mesh = mesh->next)
3113                         shadowzpasstris += mesh->numtriangles;
3114
3115         shadowzfailtris = 0;
3116         if (rtlight->static_meshchain_shadow_zfail)
3117                 for (mesh = rtlight->static_meshchain_shadow_zfail;mesh;mesh = mesh->next)
3118                         shadowzfailtris += mesh->numtriangles;
3119
3120         lighttris = 0;
3121         if (rtlight->static_numlighttrispvsbytes)
3122                 for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++)
3123                         if (CHECKPVSBIT(rtlight->static_lighttrispvs, i))
3124                                 lighttris++;
3125
3126         shadowtris = 0;
3127         if (rtlight->static_numlighttrispvsbytes)
3128                 for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++)
3129                         if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i))
3130                                 shadowtris++;
3131
3132         if (developer.integer >= 10)
3133                 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);
3134 }
3135
3136 void R_RTLight_Uncompile(rtlight_t *rtlight)
3137 {
3138         if (rtlight->compiled)
3139         {
3140                 if (rtlight->static_meshchain_shadow_zpass)
3141                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zpass);
3142                 rtlight->static_meshchain_shadow_zpass = NULL;
3143                 if (rtlight->static_meshchain_shadow_zfail)
3144                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_zfail);
3145                 rtlight->static_meshchain_shadow_zfail = NULL;
3146                 if (rtlight->static_meshchain_shadow_shadowmap)
3147                         Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow_shadowmap);
3148                 rtlight->static_meshchain_shadow_shadowmap = NULL;
3149                 // these allocations are grouped
3150                 if (rtlight->static_surfacelist)
3151                         Mem_Free(rtlight->static_surfacelist);
3152                 rtlight->static_numleafs = 0;
3153                 rtlight->static_numleafpvsbytes = 0;
3154                 rtlight->static_leaflist = NULL;
3155                 rtlight->static_leafpvs = NULL;
3156                 rtlight->static_numsurfaces = 0;
3157                 rtlight->static_surfacelist = NULL;
3158                 rtlight->static_numshadowtrispvsbytes = 0;
3159                 rtlight->static_shadowtrispvs = NULL;
3160                 rtlight->static_numlighttrispvsbytes = 0;
3161                 rtlight->static_lighttrispvs = NULL;
3162                 rtlight->compiled = false;
3163         }
3164 }
3165
3166 void R_Shadow_UncompileWorldLights(void)
3167 {
3168         size_t lightindex;
3169         dlight_t *light;
3170         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
3171         for (lightindex = 0;lightindex < range;lightindex++)
3172         {
3173                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
3174                 if (!light)
3175                         continue;
3176                 R_RTLight_Uncompile(&light->rtlight);
3177         }
3178 }
3179
3180 void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight)
3181 {
3182         int i, j;
3183         mplane_t plane;
3184         // reset the count of frustum planes
3185         // see rtlight->cached_frustumplanes definition for how much this array
3186         // can hold
3187         rtlight->cached_numfrustumplanes = 0;
3188
3189         // haven't implemented a culling path for ortho rendering
3190         if (!r_refdef.view.useperspective)
3191         {
3192                 // check if the light is on screen and copy the 4 planes if it is
3193                 for (i = 0;i < 4;i++)
3194                         if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3195                                 break;
3196                 if (i == 4)
3197                         for (i = 0;i < 4;i++)
3198                                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3199                 return;
3200         }
3201
3202 #if 1
3203         // generate a deformed frustum that includes the light origin, this is
3204         // used to cull shadow casting surfaces that can not possibly cast a
3205         // shadow onto the visible light-receiving surfaces, which can be a
3206         // performance gain
3207         //
3208         // if the light origin is onscreen the result will be 4 planes exactly
3209         // if the light origin is offscreen on only one axis the result will
3210         // be exactly 5 planes (split-side case)
3211         // if the light origin is offscreen on two axes the result will be
3212         // exactly 4 planes (stretched corner case)
3213         for (i = 0;i < 4;i++)
3214         {
3215                 // quickly reject standard frustum planes that put the light
3216                 // origin outside the frustum
3217                 if (PlaneDiff(rtlight->shadoworigin, &r_refdef.view.frustum[i]) < -0.03125)
3218                         continue;
3219                 // copy the plane
3220                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = r_refdef.view.frustum[i];
3221         }
3222         // if all the standard frustum planes were accepted, the light is onscreen
3223         // otherwise we need to generate some more planes below...
3224         if (rtlight->cached_numfrustumplanes < 4)
3225         {
3226                 // at least one of the stock frustum planes failed, so we need to
3227                 // create one or two custom planes to enclose the light origin
3228                 for (i = 0;i < 4;i++)
3229                 {
3230                         // create a plane using the view origin and light origin, and a
3231                         // single point from the frustum corner set
3232                         TriangleNormal(r_refdef.view.origin, r_refdef.view.frustumcorner[i], rtlight->shadoworigin, plane.normal);
3233                         VectorNormalize(plane.normal);
3234                         plane.dist = DotProduct(r_refdef.view.origin, plane.normal);
3235                         // see if this plane is backwards and flip it if so
3236                         for (j = 0;j < 4;j++)
3237                                 if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3238                                         break;
3239                         if (j < 4)
3240                         {
3241                                 VectorNegate(plane.normal, plane.normal);
3242                                 plane.dist *= -1;
3243                                 // flipped plane, test again to see if it is now valid
3244                                 for (j = 0;j < 4;j++)
3245                                         if (j != i && DotProduct(r_refdef.view.frustumcorner[j], plane.normal) - plane.dist < -0.03125)
3246                                                 break;
3247                                 // if the plane is still not valid, then it is dividing the
3248                                 // frustum and has to be rejected
3249                                 if (j < 4)
3250                                         continue;
3251                         }
3252                         // we have created a valid plane, compute extra info
3253                         PlaneClassify(&plane);
3254                         // copy the plane
3255                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3256 #if 1
3257                         // if we've found 5 frustum planes then we have constructed a
3258                         // proper split-side case and do not need to keep searching for
3259                         // planes to enclose the light origin
3260                         if (rtlight->cached_numfrustumplanes == 5)
3261                                 break;
3262 #endif
3263                 }
3264         }
3265 #endif
3266
3267 #if 0
3268         for (i = 0;i < rtlight->cached_numfrustumplanes;i++)
3269         {
3270                 plane = rtlight->cached_frustumplanes[i];
3271                 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));
3272         }
3273 #endif
3274
3275 #if 0
3276         // now add the light-space box planes if the light box is rotated, as any
3277         // caster outside the oriented light box is irrelevant (even if it passed
3278         // the worldspace light box, which is axial)
3279         if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1)
3280         {
3281                 for (i = 0;i < 6;i++)
3282                 {
3283                         vec3_t v;
3284                         VectorClear(v);
3285                         v[i >> 1] = (i & 1) ? -1 : 1;
3286                         Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal);
3287                         VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal);
3288                         plane.dist = VectorNormalizeLength(plane.normal);
3289                         plane.dist += DotProduct(plane.normal, rtlight->shadoworigin);
3290                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3291                 }
3292         }
3293 #endif
3294
3295 #if 0
3296         // add the world-space reduced box planes
3297         for (i = 0;i < 6;i++)
3298         {
3299                 VectorClear(plane.normal);
3300                 plane.normal[i >> 1] = (i & 1) ? -1 : 1;
3301                 plane.dist = (i & 1) ? -rtlight->cached_cullmaxs[i >> 1] : rtlight->cached_cullmins[i >> 1];
3302                 rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = plane;
3303         }
3304 #endif
3305
3306 #if 0
3307         {
3308         int j, oldnum;
3309         vec3_t points[8];
3310         vec_t bestdist;
3311         // reduce all plane distances to tightly fit the rtlight cull box, which
3312         // is in worldspace
3313         VectorSet(points[0], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3314         VectorSet(points[1], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmins[2]);
3315         VectorSet(points[2], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3316         VectorSet(points[3], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmins[2]);
3317         VectorSet(points[4], rtlight->cached_cullmins[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3318         VectorSet(points[5], rtlight->cached_cullmaxs[0], rtlight->cached_cullmins[1], rtlight->cached_cullmaxs[2]);
3319         VectorSet(points[6], rtlight->cached_cullmins[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3320         VectorSet(points[7], rtlight->cached_cullmaxs[0], rtlight->cached_cullmaxs[1], rtlight->cached_cullmaxs[2]);
3321         oldnum = rtlight->cached_numfrustumplanes;
3322         rtlight->cached_numfrustumplanes = 0;
3323         for (j = 0;j < oldnum;j++)
3324         {
3325                 // find the nearest point on the box to this plane
3326                 bestdist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[0]);
3327                 for (i = 1;i < 8;i++)
3328                 {
3329                         dist = DotProduct(rtlight->cached_frustumplanes[j].normal, points[i]);
3330                         if (bestdist > dist)
3331                                 bestdist = dist;
3332                 }
3333                 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);
3334                 // if the nearest point is near or behind the plane, we want this
3335                 // plane, otherwise the plane is useless as it won't cull anything
3336                 if (rtlight->cached_frustumplanes[j].dist < bestdist + 0.03125)
3337                 {
3338                         PlaneClassify(&rtlight->cached_frustumplanes[j]);
3339                         rtlight->cached_frustumplanes[rtlight->cached_numfrustumplanes++] = rtlight->cached_frustumplanes[j];
3340                 }
3341         }
3342         }
3343 #endif
3344 }
3345
3346 void R_Shadow_DrawWorldShadow_ShadowMap(int numsurfaces, int *surfacelist, const unsigned char *trispvs, const unsigned char *surfacesides)
3347 {
3348         shadowmesh_t *mesh;
3349
3350         RSurf_ActiveWorldEntity();
3351
3352         if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3353         {
3354                 CHECKGLERROR
3355                 GL_CullFace(GL_NONE);
3356         mesh = rsurface.rtlight->static_meshchain_shadow_shadowmap;
3357         for (;mesh;mesh = mesh->next)
3358         {
3359                         if (!mesh->sidetotals[r_shadow_shadowmapside])
3360                                 continue;
3361             r_refdef.stats.lights_shadowtriangles += mesh->sidetotals[r_shadow_shadowmapside];
3362             R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
3363             R_Mesh_Draw(0, mesh->numverts, mesh->sideoffsets[r_shadow_shadowmapside], mesh->sidetotals[r_shadow_shadowmapside], mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3364         }
3365         CHECKGLERROR
3366     }
3367         else if (r_refdef.scene.worldentity->model)
3368                 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);
3369
3370         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3371 }
3372
3373 void R_Shadow_DrawWorldShadow_ShadowVolume(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3374 {
3375         qboolean zpass = false;
3376         shadowmesh_t *mesh;
3377         int t, tend;
3378         int surfacelistindex;
3379         msurface_t *surface;
3380
3381         RSurf_ActiveWorldEntity();
3382
3383         if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3384         {
3385                 CHECKGLERROR
3386                 if (r_shadow_rendermode != R_SHADOW_RENDERMODE_VISIBLEVOLUMES)
3387                 {
3388                         zpass = R_Shadow_UseZPass(r_refdef.scene.worldmodel->normalmins, r_refdef.scene.worldmodel->normalmaxs);
3389                         R_Shadow_RenderMode_StencilShadowVolumes(zpass);
3390                 }
3391                 mesh = zpass ? rsurface.rtlight->static_meshchain_shadow_zpass : rsurface.rtlight->static_meshchain_shadow_zfail;
3392                 for (;mesh;mesh = mesh->next)
3393                 {
3394                         r_refdef.stats.lights_shadowtriangles += mesh->numtriangles;
3395                         R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f);
3396                         GL_LockArrays(0, mesh->numverts);
3397                         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZPASS_STENCIL)
3398                         {
3399                                 // increment stencil if frontface is infront of depthbuffer
3400                                 GL_CullFace(r_refdef.view.cullface_back);
3401                                 qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);CHECKGLERROR
3402                                 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3403                                 // decrement stencil if backface is infront of depthbuffer
3404                                 GL_CullFace(r_refdef.view.cullface_front);
3405                                 qglStencilOp(GL_KEEP, GL_KEEP, GL_DECR);CHECKGLERROR
3406                         }
3407                         else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_ZFAIL_STENCIL)
3408                         {
3409                                 // decrement stencil if backface is behind depthbuffer
3410                                 GL_CullFace(r_refdef.view.cullface_front);
3411                                 qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR
3412                                 R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3413                                 // increment stencil if frontface is behind depthbuffer
3414                                 GL_CullFace(r_refdef.view.cullface_back);
3415                                 qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR
3416                         }
3417                         R_Mesh_Draw(0, mesh->numverts, 0, mesh->numtriangles, mesh->element3i, mesh->element3s, mesh->ebo3i, mesh->ebo3s);
3418                         GL_LockArrays(0, 0);
3419                 }
3420                 CHECKGLERROR
3421         }
3422         else if (numsurfaces && r_refdef.scene.worldmodel->brush.shadowmesh && r_shadow_culltriangles.integer)
3423         {
3424                 R_Shadow_PrepareShadowMark(r_refdef.scene.worldmodel->brush.shadowmesh->numtriangles);
3425                 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
3426                 {
3427                         surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[surfacelistindex];
3428                         for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++)
3429                                 if (CHECKPVSBIT(trispvs, t))
3430                                         shadowmarklist[numshadowmark++] = t;
3431                 }
3432                 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);
3433         }
3434         else if (numsurfaces)
3435                 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);
3436
3437         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3438 }
3439
3440 void R_Shadow_DrawEntityShadow(entity_render_t *ent)
3441 {
3442         vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs;
3443         vec_t relativeshadowradius;
3444         RSurf_ActiveModelEntity(ent, false, false, false);
3445         Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin);
3446         relativeshadowradius = rsurface.rtlight->radius / ent->scale;
3447         relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius;
3448         relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius;
3449         relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius;
3450         relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius;
3451         relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius;
3452         relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius;
3453         if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPRECTANGLE || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAPCUBESIDE || r_shadow_rendermode == R_SHADOW_RENDERMODE_SHADOWMAP2D)
3454         {
3455                 ent->model->DrawShadowMap(r_shadow_shadowmapside, ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, NULL, relativeshadowmins, relativeshadowmaxs);
3456         }
3457         else
3458                 ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
3459         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3460 }
3461
3462 void R_Shadow_SetupEntityLight(const entity_render_t *ent)
3463 {
3464         // set up properties for rendering light onto this entity
3465         RSurf_ActiveModelEntity(ent, true, true, false);
3466         GL_AlphaTest(false);
3467         Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix);
3468         Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3469         Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3470         Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3471         switch(r_shadow_lightingrendermode)
3472         {
3473         case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3474                 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3475                 break;
3476         default:
3477                 break;
3478         }
3479 }
3480
3481 void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *trispvs)
3482 {
3483         if (!r_refdef.scene.worldmodel->DrawLight)
3484                 return;
3485
3486         // set up properties for rendering light onto this entity
3487         RSurf_ActiveWorldEntity();
3488         GL_AlphaTest(false);
3489         rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight;
3490         Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight);
3491         Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight);
3492         VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin);
3493         switch(r_shadow_lightingrendermode)
3494         {
3495         case R_SHADOW_RENDERMODE_LIGHT_GLSL:
3496                 R_Mesh_TexMatrix(3, &rsurface.entitytolight);
3497                 break;
3498         default:
3499                 break;
3500         }
3501
3502         r_refdef.scene.worldmodel->DrawLight(r_refdef.scene.worldentity, numsurfaces, surfacelist, trispvs);
3503
3504         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3505 }
3506
3507 void R_Shadow_DrawEntityLight(entity_render_t *ent)
3508 {
3509         dp_model_t *model = ent->model;
3510         if (!model->DrawLight)
3511                 return;
3512
3513         R_Shadow_SetupEntityLight(ent);
3514
3515         model->DrawLight(ent, model->nummodelsurfaces, model->sortedmodelsurfaces, NULL);
3516
3517         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
3518 }
3519
3520 void R_Shadow_PrepareLight(rtlight_t *rtlight)
3521 {
3522         int i;
3523         float f;
3524         int numleafs, numsurfaces;
3525         int *leaflist, *surfacelist;
3526         unsigned char *leafpvs, *shadowtrispvs, *lighttrispvs, *surfacesides;
3527         int numlightentities;
3528         int numlightentities_noselfshadow;
3529         int numshadowentities;
3530         int numshadowentities_noselfshadow;
3531         static entity_render_t *lightentities[MAX_EDICTS];
3532         static entity_render_t *lightentities_noselfshadow[MAX_EDICTS];
3533         static entity_render_t *shadowentities[MAX_EDICTS];
3534         static entity_render_t *shadowentities_noselfshadow[MAX_EDICTS];
3535
3536         rtlight->draw = false;
3537
3538         // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights)
3539         // skip lights that are basically invisible (color 0 0 0)
3540         if (VectorLength2(rtlight->color) * (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale) < (1.0f / 1048576.0f))
3541                 return;
3542
3543         // loading is done before visibility checks because loading should happen
3544         // all at once at the start of a level, not when it stalls gameplay.
3545         // (especially important to benchmarks)
3546         // compile light
3547         if (rtlight->isstatic && (!rtlight->compiled || (rtlight->shadow && rtlight->shadowmode != (int)r_shadow_shadowmode)) && r_shadow_realtime_world_compile.integer)
3548         {
3549                 if (rtlight->compiled)
3550                         R_RTLight_Uncompile(rtlight);
3551                 R_RTLight_Compile(rtlight);
3552         }
3553
3554         // load cubemap
3555         rtlight->currentcubemap = rtlight->cubemapname[0] ? R_Shadow_Cubemap(rtlight->cubemapname) : r_texture_whitecube;
3556
3557         // look up the light style value at this time
3558         f = (rtlight->style >= 0 ? r_refdef.scene.rtlightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
3559         VectorScale(rtlight->color, f, rtlight->currentcolor);
3560         /*
3561         if (rtlight->selected)
3562         {
3563                 f = 2 + sin(realtime * M_PI * 4.0);
3564                 VectorScale(rtlight->currentcolor, f, rtlight->currentcolor);
3565         }
3566         */
3567
3568         // if lightstyle is currently off, don't draw the light
3569         if (VectorLength2(rtlight->currentcolor) < (1.0f / 1048576.0f))
3570                 return;
3571
3572         // if the light box is offscreen, skip it
3573         if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs))
3574                 return;
3575
3576         VectorCopy(rtlight->cullmins, rtlight->cached_cullmins);
3577         VectorCopy(rtlight->cullmaxs, rtlight->cached_cullmaxs);
3578
3579         R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3580
3581         if (rtlight->compiled && r_shadow_realtime_world_compile.integer)
3582         {
3583                 // compiled light, world available and can receive realtime lighting
3584                 // retrieve leaf information
3585                 numleafs = rtlight->static_numleafs;
3586                 leaflist = rtlight->static_leaflist;
3587                 leafpvs = rtlight->static_leafpvs;
3588                 numsurfaces = rtlight->static_numsurfaces;
3589                 surfacelist = rtlight->static_surfacelist;
3590                 surfacesides = NULL;
3591                 shadowtrispvs = rtlight->static_shadowtrispvs;
3592                 lighttrispvs = rtlight->static_lighttrispvs;
3593         }
3594         else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->GetLightInfo)
3595         {
3596                 // dynamic light, world available and can receive realtime lighting
3597                 // calculate lit surfaces and leafs
3598                 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);
3599                 R_Shadow_ComputeShadowCasterCullingPlanes(rtlight);
3600                 leaflist = r_shadow_buffer_leaflist;
3601                 leafpvs = r_shadow_buffer_leafpvs;
3602                 surfacelist = r_shadow_buffer_surfacelist;
3603                 surfacesides = r_shadow_buffer_surfacesides;
3604                 shadowtrispvs = r_shadow_buffer_shadowtrispvs;
3605                 lighttrispvs = r_shadow_buffer_lighttrispvs;
3606                 // if the reduced leaf bounds are offscreen, skip it
3607                 if (R_CullBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3608                         return;
3609         }
3610         else
3611         {
3612                 // no world
3613                 numleafs = 0;
3614                 leaflist = NULL;
3615                 leafpvs = NULL;
3616                 numsurfaces = 0;
3617                 surfacelist = NULL;
3618                 surfacesides = NULL;
3619                 shadowtrispvs = NULL;
3620                 lighttrispvs = NULL;
3621         }
3622         // check if light is illuminating any visible leafs
3623         if (numleafs)
3624         {
3625                 for (i = 0;i < numleafs;i++)
3626                         if (r_refdef.viewcache.world_leafvisible[leaflist[i]])
3627                                 break;
3628                 if (i == numleafs)
3629                         return;
3630         }
3631
3632         // make a list of lit entities and shadow casting entities
3633         numlightentities = 0;
3634         numlightentities_noselfshadow = 0;
3635         numshadowentities = 0;
3636         numshadowentities_noselfshadow = 0;
3637
3638         // add dynamic entities that are lit by the light
3639         for (i = 0;i < r_refdef.scene.numentities;i++)
3640         {
3641                 dp_model_t *model;
3642                 entity_render_t *ent = r_refdef.scene.entities[i];
3643                 vec3_t org;
3644                 if (!BoxesOverlap(ent->mins, ent->maxs, rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3645                         continue;
3646                 // skip the object entirely if it is not within the valid
3647                 // shadow-casting region (which includes the lit region)
3648                 if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rtlight->cached_numfrustumplanes, rtlight->cached_frustumplanes))
3649                         continue;
3650                 if (!(model = ent->model))
3651                         continue;
3652                 if (r_refdef.viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT))
3653                 {
3654                         // this entity wants to receive light, is visible, and is
3655                         // inside the light box
3656                         // TODO: check if the surfaces in the model can receive light
3657                         // so now check if it's in a leaf seen by the light
3658                         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))
3659                                 continue;
3660                         if (ent->flags & RENDER_NOSELFSHADOW)
3661                                 lightentities_noselfshadow[numlightentities_noselfshadow++] = ent;
3662                         else
3663                                 lightentities[numlightentities++] = ent;
3664                         // since it is lit, it probably also casts a shadow...
3665                         // about the VectorDistance2 - light emitting entities should not cast their own shadow
3666                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3667                         if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3668                         {
3669                                 // note: exterior models without the RENDER_NOSELFSHADOW
3670                                 // flag still create a RENDER_NOSELFSHADOW shadow but
3671                                 // are lit normally, this means that they are
3672                                 // self-shadowing but do not shadow other
3673                                 // RENDER_NOSELFSHADOW entities such as the gun
3674                                 // (very weird, but keeps the player shadow off the gun)
3675                                 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3676                                         shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3677                                 else
3678                                         shadowentities[numshadowentities++] = ent;
3679                         }
3680                 }
3681                 else if (ent->flags & RENDER_SHADOW)
3682                 {
3683                         // this entity is not receiving light, but may still need to
3684                         // cast a shadow...
3685                         // TODO: check if the surfaces in the model can cast shadow
3686                         // now check if it is in a leaf seen by the light
3687                         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))
3688                                 continue;
3689                         // about the VectorDistance2 - light emitting entities should not cast their own shadow
3690                         Matrix4x4_OriginFromMatrix(&ent->matrix, org);
3691                         if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1)
3692                         {
3693                                 if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL))
3694                                         shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent;
3695                                 else
3696                                         shadowentities[numshadowentities++] = ent;
3697                         }
3698                 }
3699         }
3700
3701         // return if there's nothing at all to light
3702         if (numsurfaces + numlightentities + numlightentities_noselfshadow == 0)
3703                 return;
3704
3705         // count this light in the r_speeds
3706         r_refdef.stats.lights++;
3707
3708         // flag it as worth drawing later
3709         rtlight->draw = true;
3710
3711         // cache all the animated entities that cast a shadow but are not visible
3712         for (i = 0;i < numshadowentities;i++)
3713                 if (!shadowentities[i]->animcache_vertex3f)
3714                         R_AnimCache_GetEntity(shadowentities[i], false, false);
3715         for (i = 0;i < numshadowentities_noselfshadow;i++)
3716                 if (!shadowentities_noselfshadow[i]->animcache_vertex3f)
3717                         R_AnimCache_GetEntity(shadowentities_noselfshadow[i], false, false);
3718
3719         // allocate some temporary memory for rendering this light later in the frame
3720         // reusable buffers need to be copied, static data can be used as-is
3721         rtlight->cached_numlightentities               = numlightentities;
3722         rtlight->cached_numlightentities_noselfshadow  = numlightentities_noselfshadow;
3723         rtlight->cached_numshadowentities              = numshadowentities;
3724         rtlight->cached_numshadowentities_noselfshadow = numshadowentities_noselfshadow;
3725         rtlight->cached_numsurfaces                    = numsurfaces;
3726         rtlight->cached_lightentities                  = (entity_render_t**)R_FrameData_Store(numlightentities*sizeof(entity_render_t*), (void*)lightentities);
3727         rtlight->cached_lightentities_noselfshadow     = (entity_render_t**)R_FrameData_Store(numlightentities_noselfshadow*sizeof(entity_render_t*), (void*)lightentities_noselfshadow);
3728         rtlight->cached_shadowentities                 = (entity_render_t**)R_FrameData_Store(numshadowentities*sizeof(entity_render_t*), (void*)shadowentities);
3729         rtlight->cached_shadowentities_noselfshadow    = (entity_render_t**)R_FrameData_Store(numshadowentities_noselfshadow*sizeof(entity_render_t *), (void*)shadowentities_noselfshadow);
3730         if (shadowtrispvs == r_shadow_buffer_shadowtrispvs)
3731         {
3732                 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);
3733                 rtlight->cached_lighttrispvs                   =   (unsigned char *)R_FrameData_Store(r_refdef.scene.worldmodel->surfmesh.num_triangles, lighttrispvs);
3734                 rtlight->cached_surfacelist                    =              (int*)R_FrameData_Store(numsurfaces*sizeof(int), (void*)surfacelist);
3735         }
3736         else
3737         {
3738                 // compiled light data
3739                 rtlight->cached_shadowtrispvs = shadowtrispvs;
3740                 rtlight->cached_lighttrispvs = lighttrispvs;
3741                 rtlight->cached_surfacelist = surfacelist;
3742         }
3743 }
3744
3745 void R_Shadow_DrawLight(rtlight_t *rtlight)
3746 {
3747         int i;
3748         int numsurfaces;
3749         unsigned char *shadowtrispvs, *lighttrispvs, *surfacesides;
3750         int numlightentities;
3751         int numlightentities_noselfshadow;
3752         int numshadowentities;
3753         int numshadowentities_noselfshadow;
3754         entity_render_t **lightentities;
3755         entity_render_t **lightentities_noselfshadow;
3756         entity_render_t **shadowentities;
3757         entity_render_t **shadowentities_noselfshadow;
3758         int *surfacelist;
3759         static unsigned char entitysides[MAX_EDICTS];
3760         static unsigned char entitysides_noselfshadow[MAX_EDICTS];
3761         vec3_t nearestpoint;
3762         vec_t distance;
3763         qboolean castshadows;
3764         int lodlinear;
3765
3766         // check if we cached this light this frame (meaning it is worth drawing)
3767         if (!rtlight->draw)
3768                 return;
3769
3770         // if R_FrameData_Store ran out of space we skip anything dependent on it
3771         if (r_framedata_failed)
3772                 return;
3773
3774         numlightentities = rtlight->cached_numlightentities;
3775         numlightentities_noselfshadow = rtlight->cached_numlightentities_noselfshadow;
3776         numshadowentities = rtlight->cached_numshadowentities;
3777         numshadowentities_noselfshadow = rtlight->cached_numshadowentities_noselfshadow;
3778         numsurfaces = rtlight->cached_numsurfaces;
3779         lightentities = rtlight->cached_lightentities;
3780         lightentities_noselfshadow = rtlight->cached_lightentities_noselfshadow;
3781         shadowentities = rtlight->cached_shadowentities;
3782         shadowentities_noselfshadow = rtlight->cached_shadowentities_noselfshadow;
3783         shadowtrispvs = rtlight->cached_shadowtrispvs;
3784         lighttrispvs = rtlight->cached_lighttrispvs;
3785         surfacelist = rtlight->cached_surfacelist;
3786
3787         // set up a scissor rectangle for this light
3788         if (R_Shadow_ScissorForBBox(rtlight->cached_cullmins, rtlight->cached_cullmaxs))
3789                 return;
3790
3791         // don't let sound skip if going slow
3792         if (r_refdef.scene.extraupdate)
3793                 S_ExtraUpdate ();
3794
3795         // make this the active rtlight for rendering purposes
3796         R_Shadow_RenderMode_ActiveLight(rtlight);
3797
3798         if (r_showshadowvolumes.integer && r_refdef.view.showdebug && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows))
3799         {
3800                 // optionally draw visible shape of the shadow volumes
3801                 // for performance analysis by level designers
3802                 R_Shadow_RenderMode_VisibleShadowVolumes();
3803                 if (numsurfaces)
3804                         R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
3805                 for (i = 0;i < numshadowentities;i++)
3806                         R_Shadow_DrawEntityShadow(shadowentities[i]);
3807                 for (i = 0;i < numshadowentities_noselfshadow;i++)
3808                         R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3809                 R_Shadow_RenderMode_VisibleLighting(false, false);
3810         }
3811
3812         if (r_showlighting.integer && r_refdef.view.showdebug && numsurfaces + numlightentities + numlightentities_noselfshadow)
3813         {
3814                 // optionally draw the illuminated areas
3815                 // for performance analysis by level designers
3816                 R_Shadow_RenderMode_VisibleLighting(false, false);
3817                 if (numsurfaces)
3818                         R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3819                 for (i = 0;i < numlightentities;i++)
3820                         R_Shadow_DrawEntityLight(lightentities[i]);
3821                 for (i = 0;i < numlightentities_noselfshadow;i++)
3822                         R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3823         }
3824
3825         castshadows = numsurfaces + numshadowentities + numshadowentities_noselfshadow > 0 && rtlight->shadow && (rtlight->isstatic ? r_refdef.scene.rtworldshadows : r_refdef.scene.rtdlightshadows);
3826
3827         nearestpoint[0] = bound(rtlight->cullmins[0], r_refdef.view.origin[0], rtlight->cullmaxs[0]);
3828         nearestpoint[1] = bound(rtlight->cullmins[1], r_refdef.view.origin[1], rtlight->cullmaxs[1]);
3829         nearestpoint[2] = bound(rtlight->cullmins[2], r_refdef.view.origin[2], rtlight->cullmaxs[2]);
3830         distance = VectorDistance(nearestpoint, r_refdef.view.origin);
3831
3832         lodlinear = (rtlight->radius * r_shadow_shadowmapping_precision.value) / sqrt(max(1.0f, distance/rtlight->radius));
3833         //lodlinear = (int)(r_shadow_shadowmapping_lod_bias.value + r_shadow_shadowmapping_lod_scale.value * rtlight->radius / max(1.0f, distance));
3834         lodlinear = bound(r_shadow_shadowmapping_minsize.integer, lodlinear, r_shadow_shadowmapmaxsize);
3835
3836         if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE))
3837         {
3838                 float borderbias;
3839                 int side;
3840                 int size;
3841                 int castermask = 0;
3842                 int receivermask = 0;
3843                 matrix4x4_t radiustolight = rtlight->matrix_worldtolight;
3844                 Matrix4x4_Abs(&radiustolight);
3845
3846                 r_shadow_shadowmaplod = 0;
3847                 for (i = 1;i < R_SHADOW_SHADOWMAP_NUMCUBEMAPS;i++)
3848                         if ((r_shadow_shadowmapmaxsize >> i) > lodlinear)
3849                                 r_shadow_shadowmaplod = i;
3850
3851                 if (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE)
3852                         size = max(1, r_shadow_shadowmapmaxsize >> r_shadow_shadowmaplod);
3853                 else
3854                         size = bound(r_shadow_shadowmapborder, lodlinear, r_shadow_shadowmapmaxsize);
3855
3856                 borderbias = r_shadow_shadowmapborder / (float)(size - r_shadow_shadowmapborder);
3857
3858                 surfacesides = NULL;
3859                 if (numsurfaces)
3860                 {
3861                         if (rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer)
3862                         {
3863                                 castermask = rtlight->static_shadowmap_casters;
3864                                 receivermask = rtlight->static_shadowmap_receivers;
3865                         }
3866                         else
3867                         {
3868                                 surfacesides = r_shadow_buffer_surfacesides;
3869                                 for(i = 0;i < numsurfaces;i++)
3870                                 {
3871                                         msurface_t *surface = r_refdef.scene.worldmodel->data_surfaces + surfacelist[i];
3872                                         surfacesides[i] = R_Shadow_CalcBBoxSideMask(surface->mins, surface->maxs, &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3873                                         castermask |= surfacesides[i];
3874                                         receivermask |= surfacesides[i];
3875                                 }
3876                         }
3877                 }
3878                 if (receivermask < 0x3F)
3879                 {
3880                         for (i = 0;i < numlightentities;i++)
3881                                 receivermask |= R_Shadow_CalcEntitySideMask(lightentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3882                         if (receivermask < 0x3F)
3883                                 for(i = 0; i < numlightentities_noselfshadow;i++)
3884                                         receivermask |= R_Shadow_CalcEntitySideMask(lightentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias);
3885                 }
3886
3887                 receivermask &= R_Shadow_CullFrustumSides(rtlight, size, r_shadow_shadowmapborder);
3888
3889                 if (receivermask)
3890                 {
3891                         for (i = 0;i < numshadowentities;i++)
3892                                 castermask |= (entitysides[i] = R_Shadow_CalcEntitySideMask(shadowentities[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
3893                         for (i = 0;i < numshadowentities_noselfshadow;i++)
3894                                 castermask |= (entitysides_noselfshadow[i] = R_Shadow_CalcEntitySideMask(shadowentities_noselfshadow[i], &rtlight->matrix_worldtolight, &radiustolight, borderbias));
3895                 }
3896
3897                 //Con_Printf("distance %f lodlinear %i (lod %i) size %i\n", distance, lodlinear, r_shadow_shadowmaplod, size);
3898
3899                 // render shadow casters into 6 sided depth texture
3900                 for (side = 0;side < 6;side++) if (receivermask & (1 << side))
3901                 {
3902                         R_Shadow_RenderMode_ShadowMap(side, true, size);
3903                         if (! (castermask & (1 << side))) continue;
3904                         if (numsurfaces)
3905                                 R_Shadow_DrawWorldShadow_ShadowMap(numsurfaces, surfacelist, shadowtrispvs, surfacesides);
3906                         for (i = 0;i < numshadowentities;i++) if (entitysides[i] & (1 << side))
3907                                 R_Shadow_DrawEntityShadow(shadowentities[i]);
3908                 }
3909
3910                 if (numlightentities_noselfshadow)
3911                 {
3912                         // render lighting using the depth texture as shadowmap
3913                         // draw lighting in the unmasked areas
3914                         R_Shadow_RenderMode_Lighting(false, false, true);
3915                         for (i = 0;i < numlightentities_noselfshadow;i++)
3916                                 R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3917                 }
3918
3919                 // render shadow casters into 6 sided depth texture
3920                 if (numshadowentities_noselfshadow)
3921                 {
3922                         for (side = 0;side < 6;side++) if ((receivermask & castermask) & (1 << side))
3923                         {
3924                                 R_Shadow_RenderMode_ShadowMap(side, false, size);
3925                                 for (i = 0;i < numshadowentities_noselfshadow;i++) if (entitysides_noselfshadow[i] & (1 << side))
3926                                         R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3927                         }
3928                 }
3929
3930                 // render lighting using the depth texture as shadowmap
3931                 // draw lighting in the unmasked areas
3932                 R_Shadow_RenderMode_Lighting(false, false, true);
3933                 // draw lighting in the unmasked areas
3934                 if (numsurfaces)
3935                         R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3936                 for (i = 0;i < numlightentities;i++)
3937                         R_Shadow_DrawEntityLight(lightentities[i]);
3938         }
3939         else if (castshadows && vid.stencil)
3940         {
3941                 // draw stencil shadow volumes to mask off pixels that are in shadow
3942                 // so that they won't receive lighting
3943                 GL_Scissor(r_shadow_lightscissor[0], r_shadow_lightscissor[1], r_shadow_lightscissor[2], r_shadow_lightscissor[3]);
3944                 R_Shadow_ClearStencil();
3945
3946                 if (numsurfaces)
3947                         R_Shadow_DrawWorldShadow_ShadowVolume(numsurfaces, surfacelist, shadowtrispvs);
3948                 for (i = 0;i < numshadowentities;i++)
3949                         R_Shadow_DrawEntityShadow(shadowentities[i]);
3950
3951                 // draw lighting in the unmasked areas
3952                 R_Shadow_RenderMode_Lighting(true, false, false);
3953                 for (i = 0;i < numlightentities_noselfshadow;i++)
3954                         R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3955
3956                 for (i = 0;i < numshadowentities_noselfshadow;i++)
3957                         R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]);
3958
3959                 // draw lighting in the unmasked areas
3960                 R_Shadow_RenderMode_Lighting(true, false, false);
3961                 if (numsurfaces)
3962                         R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3963                 for (i = 0;i < numlightentities;i++)
3964                         R_Shadow_DrawEntityLight(lightentities[i]);
3965         }
3966         else
3967         {
3968                 // draw lighting in the unmasked areas
3969                 R_Shadow_RenderMode_Lighting(false, false, false);
3970                 if (numsurfaces)
3971                         R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs);
3972                 for (i = 0;i < numlightentities;i++)
3973                         R_Shadow_DrawEntityLight(lightentities[i]);
3974                 for (i = 0;i < numlightentities_noselfshadow;i++)
3975                         R_Shadow_DrawEntityLight(lightentities_noselfshadow[i]);
3976         }
3977
3978         if (r_shadow_usingdeferredprepass)
3979         {
3980                 // when rendering deferred lighting, we simply rasterize the box
3981                 if (castshadows && (r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAP2D || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPRECTANGLE || r_shadow_shadowmode == R_SHADOW_SHADOWMODE_SHADOWMAPCUBESIDE))
3982                         R_Shadow_RenderMode_DrawDeferredLight(false, true);
3983                 else if (castshadows && vid.stencil)
3984                         R_Shadow_RenderMode_DrawDeferredLight(true, false);
3985                 else
3986                         R_Shadow_RenderMode_DrawDeferredLight(false, false);
3987         }
3988 }
3989
3990 static void R_Shadow_FreeDeferred(void)
3991 {
3992         if (r_shadow_prepassgeometryfbo)
3993                 qglDeleteFramebuffersEXT(1, &r_shadow_prepassgeometryfbo);CHECKGLERROR
3994         r_shadow_prepassgeometryfbo = 0;
3995
3996         if (r_shadow_prepasslightingfbo)
3997                 qglDeleteFramebuffersEXT(1, &r_shadow_prepasslightingfbo);CHECKGLERROR
3998         r_shadow_prepasslightingfbo = 0;
3999
4000         if (r_shadow_prepassgeometrydepthtexture)
4001                 R_FreeTexture(r_shadow_prepassgeometrydepthtexture);
4002         r_shadow_prepassgeometrydepthtexture = NULL;
4003
4004         if (r_shadow_prepassgeometrynormalmaptexture)
4005                 R_FreeTexture(r_shadow_prepassgeometrynormalmaptexture);
4006         r_shadow_prepassgeometrynormalmaptexture = NULL;
4007
4008         if (r_shadow_prepasslightingdiffusetexture)
4009                 R_FreeTexture(r_shadow_prepasslightingdiffusetexture);
4010         r_shadow_prepasslightingdiffusetexture = NULL;
4011
4012         if (r_shadow_prepasslightingspeculartexture)
4013                 R_FreeTexture(r_shadow_prepasslightingspeculartexture);
4014         r_shadow_prepasslightingspeculartexture = NULL;
4015 }
4016
4017 void R_Shadow_DrawPrepass(void)
4018 {
4019         int i;
4020         int flag;
4021         int lnum;
4022         size_t lightindex;
4023         dlight_t *light;
4024         size_t range;
4025         entity_render_t *ent;
4026
4027         GL_AlphaTest(false);
4028         R_Mesh_ColorPointer(NULL, 0, 0);
4029         R_Mesh_ResetTextureState();
4030         GL_DepthMask(true);
4031         GL_ColorMask(1,1,1,1);
4032         GL_BlendFunc(GL_ONE, GL_ZERO);
4033         GL_Color(1,1,1,1);
4034         GL_DepthTest(true);
4035         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepassgeometryfbo);CHECKGLERROR
4036         qglClearColor(0.5f,0.5f,0.5f,1.0f);CHECKGLERROR
4037         GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);CHECKGLERROR
4038
4039         if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawPrepass)
4040                 r_refdef.scene.worldmodel->DrawPrepass(r_refdef.scene.worldentity);
4041         if (r_timereport_active)
4042                 R_TimeReport("prepassgeometry");
4043
4044         for (i = 0;i < r_refdef.scene.numentities;i++)
4045         {
4046                 if (!r_refdef.viewcache.entityvisible[i])
4047                         continue;
4048                 ent = r_refdef.scene.entities[i];
4049                 if (ent->model && ent->model->DrawPrepass != NULL)
4050                         ent->model->DrawPrepass(ent);
4051         }
4052
4053         GL_DepthMask(false);
4054         GL_ColorMask(1,1,1,1);
4055         GL_Color(1,1,1,1);
4056         GL_DepthTest(true);
4057         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
4058         qglClearColor(0.0f,0.0f,0.0f,0.0f);CHECKGLERROR
4059         GL_Clear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
4060         if (r_refdef.fogenabled)
4061                 qglClearColor(r_refdef.fogcolor[0],r_refdef.fogcolor[1],r_refdef.fogcolor[2],0);CHECKGLERROR
4062
4063         R_Shadow_RenderMode_Begin();
4064
4065         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4066         if (r_shadow_debuglight.integer >= 0)
4067         {
4068                 lightindex = r_shadow_debuglight.integer;
4069                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4070                 if (light && (light->flags & flag))
4071                         R_Shadow_DrawLight(&light->rtlight);
4072         }
4073         else
4074         {
4075                 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4076                 for (lightindex = 0;lightindex < range;lightindex++)
4077                 {
4078                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4079                         if (light && (light->flags & flag))
4080                                 R_Shadow_DrawLight(&light->rtlight);
4081                 }
4082         }
4083         if (r_refdef.scene.rtdlight)
4084                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4085                         R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4086
4087         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);CHECKGLERROR
4088         if (r_refdef.fogenabled)
4089                 qglClearColor(r_refdef.fogcolor[0],r_refdef.fogcolor[1],r_refdef.fogcolor[2],0);CHECKGLERROR
4090
4091         R_Shadow_RenderMode_End();
4092
4093         if (r_timereport_active)
4094                 R_TimeReport("prepasslights");
4095 }
4096
4097 void R_Shadow_DrawLightSprites(void);
4098 void R_Shadow_PrepareLights(void)
4099 {
4100         int flag;
4101         int lnum;
4102         size_t lightindex;
4103         dlight_t *light;
4104         size_t range;
4105         float f;
4106         GLenum status;
4107
4108         if (r_shadow_shadowmapmaxsize != bound(1, r_shadow_shadowmapping_maxsize.integer, (int)vid.maxtexturesize_2d / 4) ||
4109                 (r_shadow_shadowmode != R_SHADOW_SHADOWMODE_STENCIL) != (r_shadow_shadowmapping.integer || r_shadow_deferred.integer) ||
4110                 r_shadow_shadowmapvsdct != (r_shadow_shadowmapping_vsdct.integer != 0) ||
4111                 r_shadow_shadowmaptexturetype != r_shadow_shadowmapping_texturetype.integer ||
4112                 r_shadow_shadowmapfilterquality != r_shadow_shadowmapping_filterquality.integer ||
4113                 r_shadow_shadowmapdepthbits != r_shadow_shadowmapping_depthbits.integer ||
4114                 r_shadow_shadowmapborder != bound(0, r_shadow_shadowmapping_bordersize.integer, 16))
4115                 R_Shadow_FreeShadowMaps();
4116
4117         switch (vid.renderpath)
4118         {
4119         case RENDERPATH_GL20:
4120                 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)
4121                 {
4122                         r_shadow_usingdeferredprepass = false;
4123                         if (r_shadow_prepass_width)
4124                                 R_Shadow_FreeDeferred();
4125                         r_shadow_prepass_width = r_shadow_prepass_height = 0;
4126                         break;
4127                 }
4128
4129                 if (r_shadow_prepass_width != vid.width || r_shadow_prepass_height != vid.height)
4130                 {
4131                         R_Shadow_FreeDeferred();
4132
4133                         r_shadow_usingdeferredprepass = true;
4134                         r_shadow_prepass_width = vid.width;
4135                         r_shadow_prepass_height = vid.height;
4136                         r_shadow_prepassgeometrydepthtexture = R_LoadTextureShadowMapRectangle(r_shadow_texturepool, "prepassgeometrydepthmap", vid.width, vid.height, 24, false);
4137                         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);
4138                         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);
4139                         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);
4140
4141                         // set up the geometry pass fbo (depth + normalmap)
4142                         qglGenFramebuffersEXT(1, &r_shadow_prepassgeometryfbo);CHECKGLERROR
4143                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepassgeometryfbo);CHECKGLERROR
4144                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrydepthtexture), 0);CHECKGLERROR
4145                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrynormalmaptexture), 0);CHECKGLERROR
4146                         // render depth into one texture and normalmap into the other
4147                         qglDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);CHECKGLERROR
4148                         qglReadBuffer(GL_NONE);CHECKGLERROR
4149                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4150                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4151                         {
4152                                 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4153                                 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4154                                 r_shadow_usingdeferredprepass = false;
4155                         }
4156
4157                         // set up the lighting pass fbo (diffuse + specular)
4158                         qglGenFramebuffersEXT(1, &r_shadow_prepasslightingfbo);CHECKGLERROR
4159                         qglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, r_shadow_prepasslightingfbo);CHECKGLERROR
4160                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepassgeometrydepthtexture), 0);CHECKGLERROR
4161                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepasslightingdiffusetexture), 0);CHECKGLERROR
4162                         qglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_RECTANGLE_ARB, R_GetTexture(r_shadow_prepasslightingspeculartexture), 0);CHECKGLERROR
4163                         // render diffuse into one texture and specular into another,
4164                         // with depth and normalmap bound as textures,
4165                         // with depth bound as attachment as well
4166                         qglDrawBuffersARB(2, r_shadow_prepasslightingdrawbuffers);CHECKGLERROR
4167                         qglReadBuffer(GL_NONE);CHECKGLERROR
4168                         status = qglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);CHECKGLERROR
4169                         if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
4170                         {
4171                                 Con_Printf("R_PrepareRTLights: glCheckFramebufferStatusEXT returned %i\n", status);
4172                                 Cvar_SetValueQuick(&r_shadow_deferred, 0);
4173                                 r_shadow_usingdeferredprepass = false;
4174                         }
4175                 }
4176                 break;
4177         case RENDERPATH_GL13:
4178         case RENDERPATH_GL11:
4179                 r_shadow_usingdeferredprepass = false;
4180                 break;
4181         }
4182
4183         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);
4184
4185         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4186         if (r_shadow_debuglight.integer >= 0)
4187         {
4188                 lightindex = r_shadow_debuglight.integer;
4189                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4190                 if (light && (light->flags & flag))
4191                         R_Shadow_PrepareLight(&light->rtlight);
4192         }
4193         else
4194         {
4195                 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4196                 for (lightindex = 0;lightindex < range;lightindex++)
4197                 {
4198                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4199                         if (light && (light->flags & flag))
4200                                 R_Shadow_PrepareLight(&light->rtlight);
4201                 }
4202         }
4203         if (r_refdef.scene.rtdlight)
4204         {
4205                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4206                         R_Shadow_PrepareLight(r_refdef.scene.lights[lnum]);
4207         }
4208         else if(gl_flashblend.integer)
4209         {
4210                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4211                 {
4212                         rtlight_t *rtlight = r_refdef.scene.lights[lnum];
4213                         f = (rtlight->style >= 0 ? r_refdef.scene.lightstylevalue[rtlight->style] : 1) * r_shadow_lightintensityscale.value;
4214                         VectorScale(rtlight->color, f, rtlight->currentcolor);
4215                 }
4216         }
4217
4218         if (r_editlights.integer)
4219                 R_Shadow_DrawLightSprites();
4220 }
4221
4222 void R_Shadow_DrawLights(void)
4223 {
4224         int flag;
4225         int lnum;
4226         size_t lightindex;
4227         dlight_t *light;
4228         size_t range;
4229
4230         R_Shadow_RenderMode_Begin();
4231
4232         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4233         if (r_shadow_debuglight.integer >= 0)
4234         {
4235                 lightindex = r_shadow_debuglight.integer;
4236                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4237                 if (light && (light->flags & flag))
4238                         R_Shadow_DrawLight(&light->rtlight);
4239         }
4240         else
4241         {
4242                 range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4243                 for (lightindex = 0;lightindex < range;lightindex++)
4244                 {
4245                         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4246                         if (light && (light->flags & flag))
4247                                 R_Shadow_DrawLight(&light->rtlight);
4248                 }
4249         }
4250         if (r_refdef.scene.rtdlight)
4251                 for (lnum = 0;lnum < r_refdef.scene.numlights;lnum++)
4252                         R_Shadow_DrawLight(r_refdef.scene.lights[lnum]);
4253
4254         R_Shadow_RenderMode_End();
4255 }
4256
4257 extern const float r_screenvertex3f[12];
4258 extern void R_SetupView(qboolean allowwaterclippingplane);
4259 extern void R_ResetViewRendering3D(void);
4260 extern void R_ResetViewRendering2D(void);
4261 extern cvar_t r_shadows;
4262 extern cvar_t r_shadows_darken;
4263 extern cvar_t r_shadows_drawafterrtlighting;
4264 extern cvar_t r_shadows_castfrombmodels;
4265 extern cvar_t r_shadows_throwdistance;
4266 extern cvar_t r_shadows_throwdirection;
4267 void R_DrawModelShadows(void)
4268 {
4269         int i;
4270         float relativethrowdistance;
4271         entity_render_t *ent;
4272         vec3_t relativelightorigin;
4273         vec3_t relativelightdirection;
4274         vec3_t relativeshadowmins, relativeshadowmaxs;
4275         vec3_t tmp, shadowdir;
4276
4277         if (!r_refdef.scene.numentities || !vid.stencil)
4278                 return;
4279
4280         CHECKGLERROR
4281         R_ResetViewRendering3D();
4282         //GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
4283         //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4284         R_Shadow_RenderMode_Begin();
4285         R_Shadow_RenderMode_ActiveLight(NULL);
4286         r_shadow_lightscissor[0] = r_refdef.view.x;
4287         r_shadow_lightscissor[1] = vid.height - r_refdef.view.y - r_refdef.view.height;
4288         r_shadow_lightscissor[2] = r_refdef.view.width;
4289         r_shadow_lightscissor[3] = r_refdef.view.height;
4290         R_Shadow_RenderMode_StencilShadowVolumes(false);
4291
4292         // get shadow dir
4293         if (r_shadows.integer == 2)
4294         {
4295                 Math_atov(r_shadows_throwdirection.string, shadowdir);
4296                 VectorNormalize(shadowdir);
4297         }
4298
4299         R_Shadow_ClearStencil();
4300
4301         for (i = 0;i < r_refdef.scene.numentities;i++)
4302         {
4303                 ent = r_refdef.scene.entities[i];
4304
4305                 // cast shadows from anything of the map (submodels are optional)
4306                 if (ent->model && ent->model->DrawShadowVolume != NULL && (!ent->model->brush.submodel || r_shadows_castfrombmodels.integer) && (ent->flags & RENDER_SHADOW))
4307                 {
4308                         relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix);
4309                         VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance);
4310                         VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance);
4311                         if (r_shadows.integer == 2) // 2: simpler mode, throw shadows always in same direction
4312                                 Matrix4x4_Transform3x3(&ent->inversematrix, shadowdir, relativelightdirection);
4313                         else
4314                         {
4315                                 if(ent->entitynumber != 0)
4316                                 {
4317                                         // networked entity - might be attached in some way (then we should use the parent's light direction, to not tear apart attached entities)
4318                                         int entnum, entnum2, recursion;
4319                                         entnum = entnum2 = ent->entitynumber;
4320                                         for(recursion = 32; recursion > 0; --recursion)
4321                                         {
4322                                                 entnum2 = cl.entities[entnum].state_current.tagentity;
4323                                                 if(entnum2 >= 1 && entnum2 < cl.num_entities && cl.entities_active[entnum2])
4324                                                         entnum = entnum2;
4325                                                 else
4326                                                         break;
4327                                         }
4328                                         if(recursion && recursion != 32) // if we followed a valid non-empty attachment chain
4329                                         {
4330                                                 VectorNegate(cl.entities[entnum].render.modellight_lightdir, relativelightdirection);
4331                                                 // transform into modelspace of OUR entity
4332                                                 Matrix4x4_Transform3x3(&cl.entities[entnum].render.matrix, relativelightdirection, tmp);
4333                                                 Matrix4x4_Transform3x3(&ent->inversematrix, tmp, relativelightdirection);
4334                                         }
4335                                         else
4336                                                 VectorNegate(ent->modellight_lightdir, relativelightdirection);
4337                                 }
4338                                 else
4339                                         VectorNegate(ent->modellight_lightdir, relativelightdirection);
4340                         }
4341
4342                         VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin);
4343                         RSurf_ActiveModelEntity(ent, false, false, false);
4344                         ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->sortedmodelsurfaces, relativeshadowmins, relativeshadowmaxs);
4345                         rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
4346                 }
4347         }
4348
4349         // not really the right mode, but this will disable any silly stencil features
4350         R_Shadow_RenderMode_End();
4351
4352         // set up ortho view for rendering this pass
4353         //GL_Scissor(r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
4354         //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4355         //GL_ScissorTest(true);
4356         //R_Mesh_Matrix(&identitymatrix);
4357         //R_Mesh_ResetTextureState();
4358         R_ResetViewRendering2D();
4359         R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
4360         R_Mesh_ColorPointer(NULL, 0, 0);
4361         R_SetupGenericShader(false);
4362
4363         // set up a darkening blend on shadowed areas
4364         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
4365         //GL_DepthRange(0, 1);
4366         //GL_DepthTest(false);
4367         //GL_DepthMask(false);
4368         //GL_PolygonOffset(0, 0);CHECKGLERROR
4369         GL_Color(0, 0, 0, r_shadows_darken.value);
4370         //GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4371         //qglDepthFunc(GL_ALWAYS);CHECKGLERROR
4372         qglEnable(GL_STENCIL_TEST);CHECKGLERROR
4373         qglStencilMask(~0);CHECKGLERROR
4374         qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
4375         qglStencilFunc(GL_NOTEQUAL, 128, ~0);CHECKGLERROR
4376
4377         // apply the blend to the shadowed areas
4378         R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4379
4380         // restore the viewport
4381         R_SetViewport(&r_refdef.view.viewport);
4382
4383         // restore other state to normal
4384         //R_Shadow_RenderMode_End();
4385 }
4386
4387 void R_BeginCoronaQuery(rtlight_t *rtlight, float scale, qboolean usequery)
4388 {
4389         float zdist;
4390         vec3_t centerorigin;
4391         float vertex3f[12];
4392         // if it's too close, skip it
4393         if (VectorLength(rtlight->currentcolor) < (1.0f / 256.0f))
4394                 return;
4395         zdist = (DotProduct(rtlight->shadoworigin, r_refdef.view.forward) - DotProduct(r_refdef.view.origin, r_refdef.view.forward));
4396         if (zdist < 32)
4397                 return;
4398         if (usequery && r_numqueries + 2 <= r_maxqueries)
4399         {
4400                 rtlight->corona_queryindex_allpixels = r_queries[r_numqueries++];
4401                 rtlight->corona_queryindex_visiblepixels = r_queries[r_numqueries++];
4402                 // 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
4403                 VectorMA(r_refdef.view.origin, zdist, r_refdef.view.forward, centerorigin);
4404
4405                 CHECKGLERROR
4406                 // NOTE: GL_DEPTH_TEST must be enabled or ATI won't count samples, so use qglDepthFunc instead
4407                 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_allpixels);
4408                 qglDepthFunc(GL_ALWAYS);
4409                 R_CalcSprite_Vertex3f(vertex3f, centerorigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4410                 R_Mesh_VertexPointer(vertex3f, 0, 0);
4411                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4412                 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
4413                 qglDepthFunc(GL_LEQUAL);
4414                 qglBeginQueryARB(GL_SAMPLES_PASSED_ARB, rtlight->corona_queryindex_visiblepixels);
4415                 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4416                 R_Mesh_VertexPointer(vertex3f, 0, 0);
4417                 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, polygonelement3s, 0, 0);
4418                 qglEndQueryARB(GL_SAMPLES_PASSED_ARB);
4419                 CHECKGLERROR
4420         }
4421         rtlight->corona_visibility = bound(0, (zdist - 32) / 32, 1);
4422 }
4423
4424 static float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
4425
4426 void R_DrawCorona(rtlight_t *rtlight, float cscale, float scale)
4427 {
4428         vec3_t color;
4429         GLint allpixels = 0, visiblepixels = 0;
4430         // now we have to check the query result
4431         if (rtlight->corona_queryindex_visiblepixels)
4432         {
4433                 CHECKGLERROR
4434                 qglGetQueryObjectivARB(rtlight->corona_queryindex_visiblepixels, GL_QUERY_RESULT_ARB, &visiblepixels);
4435                 qglGetQueryObjectivARB(rtlight->corona_queryindex_allpixels, GL_QUERY_RESULT_ARB, &allpixels);
4436                 CHECKGLERROR
4437                 //Con_Printf("%i of %i pixels\n", (int)visiblepixels, (int)allpixels);
4438                 if (visiblepixels < 1 || allpixels < 1)
4439                         return;
4440                 rtlight->corona_visibility *= bound(0, (float)visiblepixels / (float)allpixels, 1);
4441                 cscale *= rtlight->corona_visibility;
4442         }
4443         else
4444         {
4445                 // FIXME: these traces should scan all render entities instead of cl.world
4446                 if (CL_TraceLine(r_refdef.view.origin, rtlight->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction < 1)
4447                         return;
4448         }
4449         VectorScale(rtlight->currentcolor, cscale, color);
4450         if (VectorLength(color) > (1.0f / 256.0f))
4451         {
4452                 float vertex3f[12];
4453                 qboolean negated = (color[0] + color[1] + color[2] < 0) && vid.support.ext_blend_subtract;
4454                 if(negated)
4455                 {
4456                         VectorNegate(color, color);
4457                         qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
4458                 }
4459                 R_CalcSprite_Vertex3f(vertex3f, rtlight->shadoworigin, r_refdef.view.right, r_refdef.view.up, scale, -scale, -scale, scale);
4460                 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);
4461                 R_DrawCustomSurface(r_shadow_lightcorona, &identitymatrix, MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4462                 if(negated)
4463                         qglBlendEquationEXT(GL_FUNC_ADD_EXT);
4464         }
4465 }
4466
4467 void R_Shadow_DrawCoronas(void)
4468 {
4469         int i, flag;
4470         qboolean usequery;
4471         size_t lightindex;
4472         dlight_t *light;
4473         rtlight_t *rtlight;
4474         size_t range;
4475         if (r_coronas.value < (1.0f / 256.0f) && !gl_flashblend.integer)
4476                 return;
4477         if (r_waterstate.renderingscene)
4478                 return;
4479         flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
4480         R_Mesh_Matrix(&identitymatrix);
4481
4482         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4483
4484         // check occlusion of coronas
4485         // use GL_ARB_occlusion_query if available
4486         // otherwise use raytraces
4487         r_numqueries = 0;
4488         usequery = vid.support.arb_occlusion_query && r_coronas_occlusionquery.integer;
4489         if (usequery)
4490         {
4491                 GL_ColorMask(0,0,0,0);
4492                 if (r_maxqueries < (range + r_refdef.scene.numlights) * 2)
4493                 if (r_maxqueries < MAX_OCCLUSION_QUERIES)
4494                 {
4495                         i = r_maxqueries;
4496                         r_maxqueries = (range + r_refdef.scene.numlights) * 4;
4497                         r_maxqueries = min(r_maxqueries, MAX_OCCLUSION_QUERIES);
4498                         CHECKGLERROR
4499                         qglGenQueriesARB(r_maxqueries - i, r_queries + i);
4500                         CHECKGLERROR
4501                 }
4502                 RSurf_ActiveWorldEntity();
4503                 GL_BlendFunc(GL_ONE, GL_ZERO);
4504                 GL_CullFace(GL_NONE);
4505                 GL_DepthMask(false);
4506                 GL_DepthRange(0, 1);
4507                 GL_PolygonOffset(0, 0);
4508                 GL_DepthTest(true);
4509                 R_Mesh_ColorPointer(NULL, 0, 0);
4510                 R_Mesh_ResetTextureState();
4511                 R_SetupGenericShader(false);
4512         }
4513         for (lightindex = 0;lightindex < range;lightindex++)
4514         {
4515                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4516                 if (!light)
4517                         continue;
4518                 rtlight = &light->rtlight;
4519                 rtlight->corona_visibility = 0;
4520                 rtlight->corona_queryindex_visiblepixels = 0;
4521                 rtlight->corona_queryindex_allpixels = 0;
4522                 if (!(rtlight->flags & flag))
4523                         continue;
4524                 if (rtlight->corona <= 0)
4525                         continue;
4526                 if (r_shadow_debuglight.integer >= 0 && r_shadow_debuglight.integer != (int)lightindex)
4527                         continue;
4528                 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
4529         }
4530         for (i = 0;i < r_refdef.scene.numlights;i++)
4531         {
4532                 rtlight = r_refdef.scene.lights[i];
4533                 rtlight->corona_visibility = 0;
4534                 rtlight->corona_queryindex_visiblepixels = 0;
4535                 rtlight->corona_queryindex_allpixels = 0;
4536                 if (!(rtlight->flags & flag))
4537                         continue;
4538                 if (rtlight->corona <= 0)
4539                         continue;
4540                 R_BeginCoronaQuery(rtlight, rtlight->radius * rtlight->coronasizescale * r_coronas_occlusionsizescale.value, usequery);
4541         }
4542         if (usequery)
4543                 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
4544
4545         // now draw the coronas using the query data for intensity info
4546         for (lightindex = 0;lightindex < range;lightindex++)
4547         {
4548                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4549                 if (!light)
4550                         continue;
4551                 rtlight = &light->rtlight;
4552                 if (rtlight->corona_visibility <= 0)
4553                         continue;
4554                 R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
4555         }
4556         for (i = 0;i < r_refdef.scene.numlights;i++)
4557         {
4558                 rtlight = r_refdef.scene.lights[i];
4559                 if (rtlight->corona_visibility <= 0)
4560                         continue;
4561                 if (gl_flashblend.integer)
4562                         R_DrawCorona(rtlight, rtlight->corona, rtlight->radius * rtlight->coronasizescale * 2.0f);
4563                 else
4564                         R_DrawCorona(rtlight, rtlight->corona * r_coronas.value * 0.25f, rtlight->radius * rtlight->coronasizescale);
4565         }
4566 }
4567
4568
4569
4570 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
4571 typedef struct suffixinfo_s
4572 {
4573         char *suffix;
4574         qboolean flipx, flipy, flipdiagonal;
4575 }
4576 suffixinfo_t;
4577 static suffixinfo_t suffix[3][6] =
4578 {
4579         {
4580                 {"px",   false, false, false},
4581                 {"nx",   false, false, false},
4582                 {"py",   false, false, false},
4583                 {"ny",   false, false, false},
4584                 {"pz",   false, false, false},
4585                 {"nz",   false, false, false}
4586         },
4587         {
4588                 {"posx", false, false, false},
4589                 {"negx", false, false, false},
4590                 {"posy", false, false, false},
4591                 {"negy", false, false, false},
4592                 {"posz", false, false, false},
4593                 {"negz", false, false, false}
4594         },
4595         {
4596                 {"rt",    true, false,  true},
4597                 {"lf",   false,  true,  true},
4598                 {"ft",    true,  true, false},
4599                 {"bk",   false, false, false},
4600                 {"up",    true, false,  true},
4601                 {"dn",    true, false,  true}
4602         }
4603 };
4604
4605 static int componentorder[4] = {0, 1, 2, 3};
4606
4607 rtexture_t *R_Shadow_LoadCubemap(const char *basename)
4608 {
4609         int i, j, cubemapsize;
4610         unsigned char *cubemappixels, *image_buffer;
4611         rtexture_t *cubemaptexture;
4612         char name[256];
4613         // must start 0 so the first loadimagepixels has no requested width/height
4614         cubemapsize = 0;
4615         cubemappixels = NULL;
4616         cubemaptexture = NULL;
4617         // keep trying different suffix groups (posx, px, rt) until one loads
4618         for (j = 0;j < 3 && !cubemappixels;j++)
4619         {
4620                 // load the 6 images in the suffix group
4621                 for (i = 0;i < 6;i++)
4622                 {
4623                         // generate an image name based on the base and and suffix
4624                         dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
4625                         // load it
4626                         if ((image_buffer = loadimagepixelsbgra(name, false, false)))
4627                         {
4628                                 // an image loaded, make sure width and height are equal
4629                                 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
4630                                 {
4631                                         // if this is the first image to load successfully, allocate the cubemap memory
4632                                         if (!cubemappixels && image_width >= 1)
4633                                         {
4634                                                 cubemapsize = image_width;
4635                                                 // note this clears to black, so unavailable sides are black
4636                                                 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
4637                                         }
4638                                         // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
4639                                         if (cubemappixels)
4640                                                 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);
4641                                 }
4642                                 else
4643                                         Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
4644                                 // free the image
4645                                 Mem_Free(image_buffer);
4646                         }
4647                 }
4648         }
4649         // if a cubemap loaded, upload it
4650         if (cubemappixels)
4651         {
4652                 if (developer_loading.integer)
4653                         Con_Printf("loading cubemap \"%s\"\n", basename);
4654
4655                 if (!r_shadow_filters_texturepool)
4656                         r_shadow_filters_texturepool = R_AllocTexturePool();
4657                 cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, TEXF_PRECACHE | (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR, NULL);
4658                 Mem_Free(cubemappixels);
4659         }
4660         else
4661         {
4662                 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
4663                 if (developer_loading.integer)
4664                 {
4665                         Con_Printf("(tried tried images ");
4666                         for (j = 0;j < 3;j++)
4667                                 for (i = 0;i < 6;i++)
4668                                         Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
4669                         Con_Print(" and was unable to find any of them).\n");
4670                 }
4671         }
4672         return cubemaptexture;
4673 }
4674
4675 rtexture_t *R_Shadow_Cubemap(const char *basename)
4676 {
4677         int i;
4678         for (i = 0;i < numcubemaps;i++)
4679                 if (!strcasecmp(cubemaps[i].basename, basename))
4680                         return cubemaps[i].texture ? cubemaps[i].texture : r_texture_whitecube;
4681         if (i >= MAX_CUBEMAPS)
4682                 return r_texture_whitecube;
4683         numcubemaps++;
4684         strlcpy(cubemaps[i].basename, basename, sizeof(cubemaps[i].basename));
4685         cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename);
4686         return cubemaps[i].texture;
4687 }
4688
4689 void R_Shadow_FreeCubemaps(void)
4690 {
4691         int i;
4692         for (i = 0;i < numcubemaps;i++)
4693         {
4694                 if (developer_loading.integer)
4695                         Con_Printf("unloading cubemap \"%s\"\n", cubemaps[i].basename);
4696                 if (cubemaps[i].texture)
4697                         R_FreeTexture(cubemaps[i].texture);
4698         }
4699
4700         numcubemaps = 0;
4701         R_FreeTexturePool(&r_shadow_filters_texturepool);
4702 }
4703
4704 dlight_t *R_Shadow_NewWorldLight(void)
4705 {
4706         return (dlight_t *)Mem_ExpandableArray_AllocRecord(&r_shadow_worldlightsarray);
4707 }
4708
4709 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)
4710 {
4711         matrix4x4_t matrix;
4712         // validate parameters
4713         if (style < 0 || style >= MAX_LIGHTSTYLES)
4714         {
4715                 Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES);
4716                 style = 0;
4717         }
4718         if (!cubemapname)
4719                 cubemapname = "";
4720
4721         // copy to light properties
4722         VectorCopy(origin, light->origin);
4723         light->angles[0] = angles[0] - 360 * floor(angles[0] / 360);
4724         light->angles[1] = angles[1] - 360 * floor(angles[1] / 360);
4725         light->angles[2] = angles[2] - 360 * floor(angles[2] / 360);
4726         /*
4727         light->color[0] = max(color[0], 0);
4728         light->color[1] = max(color[1], 0);
4729         light->color[2] = max(color[2], 0);
4730         */
4731         light->color[0] = color[0];
4732         light->color[1] = color[1];
4733         light->color[2] = color[2];
4734         light->radius = max(radius, 0);
4735         light->style = style;
4736         light->shadow = shadowenable;
4737         light->corona = corona;
4738         strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname));
4739         light->coronasizescale = coronasizescale;
4740         light->ambientscale = ambientscale;
4741         light->diffusescale = diffusescale;
4742         light->specularscale = specularscale;
4743         light->flags = flags;
4744
4745         // update renderable light data
4746         Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius);
4747         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);
4748 }
4749
4750 void R_Shadow_FreeWorldLight(dlight_t *light)
4751 {
4752         if (r_shadow_selectedlight == light)
4753                 r_shadow_selectedlight = NULL;
4754         R_RTLight_Uncompile(&light->rtlight);
4755         Mem_ExpandableArray_FreeRecord(&r_shadow_worldlightsarray, light);
4756 }
4757
4758 void R_Shadow_ClearWorldLights(void)
4759 {
4760         size_t lightindex;
4761         dlight_t *light;
4762         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4763         for (lightindex = 0;lightindex < range;lightindex++)
4764         {
4765                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4766                 if (light)
4767                         R_Shadow_FreeWorldLight(light);
4768         }
4769         r_shadow_selectedlight = NULL;
4770         R_Shadow_FreeCubemaps();
4771 }
4772
4773 void R_Shadow_SelectLight(dlight_t *light)
4774 {
4775         if (r_shadow_selectedlight)
4776                 r_shadow_selectedlight->selected = false;
4777         r_shadow_selectedlight = light;
4778         if (r_shadow_selectedlight)
4779                 r_shadow_selectedlight->selected = true;
4780 }
4781
4782 void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
4783 {
4784         // this is never batched (there can be only one)
4785         float vertex3f[12];
4786         R_CalcSprite_Vertex3f(vertex3f, r_editlights_cursorlocation, r_refdef.view.right, r_refdef.view.up, EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, -EDLIGHTSPRSIZE, EDLIGHTSPRSIZE);
4787         RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4788         R_DrawCustomSurface(r_editlights_sprcursor, &identitymatrix, MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4789 }
4790
4791 void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
4792 {
4793         float intensity;
4794         float s;
4795         vec3_t spritecolor;
4796         skinframe_t *skinframe;
4797         float vertex3f[12];
4798
4799         // this is never batched (due to the ent parameter changing every time)
4800         // so numsurfaces == 1 and surfacelist[0] == lightnumber
4801         const dlight_t *light = (dlight_t *)ent;
4802         s = EDLIGHTSPRSIZE;
4803
4804         R_CalcSprite_Vertex3f(vertex3f, light->origin, r_refdef.view.right, r_refdef.view.up, s, -s, -s, s);
4805
4806         intensity = 0.5f;
4807         VectorScale(light->color, intensity, spritecolor);
4808         if (VectorLength(spritecolor) < 0.1732f)
4809                 VectorSet(spritecolor, 0.1f, 0.1f, 0.1f);
4810         if (VectorLength(spritecolor) > 1.0f)
4811                 VectorNormalize(spritecolor);
4812
4813         // draw light sprite
4814         if (light->cubemapname[0] && !light->shadow)
4815                 skinframe = r_editlights_sprcubemapnoshadowlight;
4816         else if (light->cubemapname[0])
4817                 skinframe = r_editlights_sprcubemaplight;
4818         else if (!light->shadow)
4819                 skinframe = r_editlights_sprnoshadowlight;
4820         else
4821                 skinframe = r_editlights_sprlight;
4822
4823         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);
4824         R_DrawCustomSurface(skinframe, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4825
4826         // draw selection sprite if light is selected
4827         if (light->selected)
4828         {
4829                 RSurf_ActiveCustomEntity(&identitymatrix, &identitymatrix, 0, 0, 1, 1, 1, 1, 4, vertex3f, spritetexcoord2f, NULL, NULL, NULL, NULL, 2, polygonelement3i, polygonelement3s, false, false);
4830                 R_DrawCustomSurface(r_editlights_sprselection, &identitymatrix, MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOCULLFACE, 0, 4, 0, 2, false, false);
4831                 // VorteX todo: add normalmode/realtime mode light overlay sprites?
4832         }
4833 }
4834
4835 void R_Shadow_DrawLightSprites(void)
4836 {
4837         size_t lightindex;
4838         dlight_t *light;
4839         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4840         for (lightindex = 0;lightindex < range;lightindex++)
4841         {
4842                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4843                 if (light)
4844                         R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSprite_TransparentCallback, (entity_render_t *)light, 5, &light->rtlight);
4845         }
4846         R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursor_TransparentCallback, NULL, 0, NULL);
4847 }
4848
4849 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color)
4850 {
4851         unsigned int range;
4852         dlight_t *light;
4853         rtlight_t *rtlight;
4854         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
4855         if (lightindex >= range)
4856                 return -1;
4857         light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4858         if (!light)
4859                 return 0;
4860         rtlight = &light->rtlight;
4861         //if (!(rtlight->flags & flag))
4862         //      return 0;
4863         VectorCopy(rtlight->shadoworigin, origin);
4864         *radius = rtlight->radius;
4865         VectorCopy(rtlight->color, color);
4866         return 1;
4867 }
4868
4869 void R_Shadow_SelectLightInView(void)
4870 {
4871         float bestrating, rating, temp[3];
4872         dlight_t *best;
4873         size_t lightindex;
4874         dlight_t *light;
4875         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
4876         best = NULL;
4877         bestrating = 0;
4878         for (lightindex = 0;lightindex < range;lightindex++)
4879         {
4880                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
4881                 if (!light)
4882                         continue;
4883                 VectorSubtract(light->origin, r_refdef.view.origin, temp);
4884                 rating = (DotProduct(temp, r_refdef.view.forward) / sqrt(DotProduct(temp, temp)));
4885                 if (rating >= 0.95)
4886                 {
4887                         rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp)));
4888                         if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1.0f)
4889                         {
4890                                 bestrating = rating;
4891                                 best = light;
4892                         }
4893                 }
4894         }
4895         R_Shadow_SelectLight(best);
4896 }
4897
4898 void R_Shadow_LoadWorldLights(void)
4899 {
4900         int n, a, style, shadow, flags;
4901         char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH];
4902         float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale;
4903         if (cl.worldmodel == NULL)
4904         {
4905                 Con_Print("No map loaded.\n");
4906                 return;
4907         }
4908         FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
4909         strlcat (name, ".rtlights", sizeof (name));
4910         lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
4911         if (lightsstring)
4912         {
4913                 s = lightsstring;
4914                 n = 0;
4915                 while (*s)
4916                 {
4917                         t = s;
4918                         /*
4919                         shadow = true;
4920                         for (;COM_Parse(t, true) && strcmp(
4921                         if (COM_Parse(t, true))
4922                         {
4923                                 if (com_token[0] == '!')
4924                                 {
4925                                         shadow = false;
4926                                         origin[0] = atof(com_token+1);
4927                                 }
4928                                 else
4929                                         origin[0] = atof(com_token);
4930                                 if (Com_Parse(t
4931                         }
4932                         */
4933                         t = s;
4934                         while (*s && *s != '\n' && *s != '\r')
4935                                 s++;
4936                         if (!*s)
4937                                 break;
4938                         tempchar = *s;
4939                         shadow = true;
4940                         // check for modifier flags
4941                         if (*t == '!')
4942                         {
4943                                 shadow = false;
4944                                 t++;
4945                         }
4946                         *s = 0;
4947 #if _MSC_VER >= 1400
4948 #define sscanf sscanf_s
4949 #endif
4950                         cubemapname[sizeof(cubemapname)-1] = 0;
4951 #if MAX_QPATH != 128
4952 #error update this code if MAX_QPATH changes
4953 #endif
4954                         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
4955 #if _MSC_VER >= 1400
4956 , sizeof(cubemapname)
4957 #endif
4958 , &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags);
4959                         *s = tempchar;
4960                         if (a < 18)
4961                                 flags = LIGHTFLAG_REALTIMEMODE;
4962                         if (a < 17)
4963                                 specularscale = 1;
4964                         if (a < 16)
4965                                 diffusescale = 1;
4966                         if (a < 15)
4967                                 ambientscale = 0;
4968                         if (a < 14)
4969                                 coronasizescale = 0.25f;
4970                         if (a < 13)
4971                                 VectorClear(angles);
4972                         if (a < 10)
4973                                 corona = 0;
4974                         if (a < 9 || !strcmp(cubemapname, "\"\""))
4975                                 cubemapname[0] = 0;
4976                         // remove quotes on cubemapname
4977                         if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"')
4978                         {
4979                                 size_t namelen;
4980                                 namelen = strlen(cubemapname) - 2;
4981                                 memmove(cubemapname, cubemapname + 1, namelen);
4982                                 cubemapname[namelen] = '\0';
4983                         }
4984                         if (a < 8)
4985                         {
4986                                 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);
4987                                 break;
4988                         }
4989                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
4990                         if (*s == '\r')
4991                                 s++;
4992                         if (*s == '\n')
4993                                 s++;
4994                         n++;
4995                 }
4996                 if (*s)
4997                         Con_Printf("invalid rtlights file \"%s\"\n", name);
4998                 Mem_Free(lightsstring);
4999         }
5000 }
5001
5002 void R_Shadow_SaveWorldLights(void)
5003 {
5004         size_t lightindex;
5005         dlight_t *light;
5006         size_t bufchars, bufmaxchars;
5007         char *buf, *oldbuf;
5008         char name[MAX_QPATH];
5009         char line[MAX_INPUTLINE];
5010         size_t range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked, assuming the dpsnprintf mess doesn't screw it up...
5011         // I hate lines which are 3 times my screen size :( --blub
5012         if (!range)
5013                 return;
5014         if (cl.worldmodel == NULL)
5015         {
5016                 Con_Print("No map loaded.\n");
5017                 return;
5018         }
5019         FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
5020         strlcat (name, ".rtlights", sizeof (name));
5021         bufchars = bufmaxchars = 0;
5022         buf = NULL;
5023         for (lightindex = 0;lightindex < range;lightindex++)
5024         {
5025                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5026                 if (!light)
5027                         continue;
5028                 if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE)
5029                         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);
5030                 else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2])
5031                         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]);
5032                 else
5033                         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);
5034                 if (bufchars + strlen(line) > bufmaxchars)
5035                 {
5036                         bufmaxchars = bufchars + strlen(line) + 2048;
5037                         oldbuf = buf;
5038                         buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
5039                         if (oldbuf)
5040                         {
5041                                 if (bufchars)
5042                                         memcpy(buf, oldbuf, bufchars);
5043                                 Mem_Free(oldbuf);
5044                         }
5045                 }
5046                 if (strlen(line))
5047                 {
5048                         memcpy(buf + bufchars, line, strlen(line));
5049                         bufchars += strlen(line);
5050                 }
5051         }
5052         if (bufchars)
5053                 FS_WriteFile(name, buf, (fs_offset_t)bufchars);
5054         if (buf)
5055                 Mem_Free(buf);
5056 }
5057
5058 void R_Shadow_LoadLightsFile(void)
5059 {
5060         int n, a, style;
5061         char tempchar, *lightsstring, *s, *t, name[MAX_QPATH];
5062         float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias;
5063         if (cl.worldmodel == NULL)
5064         {
5065                 Con_Print("No map loaded.\n");
5066                 return;
5067         }
5068         FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
5069         strlcat (name, ".lights", sizeof (name));
5070         lightsstring = (char *)FS_LoadFile(name, tempmempool, false, NULL);
5071         if (lightsstring)
5072         {
5073                 s = lightsstring;
5074                 n = 0;
5075                 while (*s)
5076                 {
5077                         t = s;
5078                         while (*s && *s != '\n' && *s != '\r')
5079                                 s++;
5080                         if (!*s)
5081                                 break;
5082                         tempchar = *s;
5083                         *s = 0;
5084                         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);
5085                         *s = tempchar;
5086                         if (a < 14)
5087                         {
5088                                 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);
5089                                 break;
5090                         }
5091                         radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f));
5092                         radius = bound(15, radius, 4096);
5093                         VectorScale(color, (2.0f / (8388608.0f)), color);
5094                         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5095                         if (*s == '\r')
5096                                 s++;
5097                         if (*s == '\n')
5098                                 s++;
5099                         n++;
5100                 }
5101                 if (*s)
5102                         Con_Printf("invalid lights file \"%s\"\n", name);
5103                 Mem_Free(lightsstring);
5104         }
5105 }
5106
5107 // tyrlite/hmap2 light types in the delay field
5108 typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t;
5109
5110 void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void)
5111 {
5112         int entnum, style, islight, skin, pflags, effects, type, n;
5113         char *entfiledata;
5114         const char *data;
5115         float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4];
5116         char key[256], value[MAX_INPUTLINE];
5117
5118         if (cl.worldmodel == NULL)
5119         {
5120                 Con_Print("No map loaded.\n");
5121                 return;
5122         }
5123         // try to load a .ent file first
5124         FS_StripExtension (cl.worldmodel->name, key, sizeof (key));
5125         strlcat (key, ".ent", sizeof (key));
5126         data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true, NULL);
5127         // and if that is not found, fall back to the bsp file entity string
5128         if (!data)
5129                 data = cl.worldmodel->brush.entities;
5130         if (!data)
5131                 return;
5132         for (entnum = 0;COM_ParseToken_Simple(&data, false, false) && com_token[0] == '{';entnum++)
5133         {
5134                 type = LIGHTTYPE_MINUSX;
5135                 origin[0] = origin[1] = origin[2] = 0;
5136                 originhack[0] = originhack[1] = originhack[2] = 0;
5137                 angles[0] = angles[1] = angles[2] = 0;
5138                 color[0] = color[1] = color[2] = 1;
5139                 light[0] = light[1] = light[2] = 1;light[3] = 300;
5140                 overridecolor[0] = overridecolor[1] = overridecolor[2] = 1;
5141                 fadescale = 1;
5142                 lightscale = 1;
5143                 style = 0;
5144                 skin = 0;
5145                 pflags = 0;
5146                 effects = 0;
5147                 islight = false;
5148                 while (1)
5149                 {
5150                         if (!COM_ParseToken_Simple(&data, false, false))
5151                                 break; // error
5152                         if (com_token[0] == '}')
5153                                 break; // end of entity
5154                         if (com_token[0] == '_')
5155                                 strlcpy(key, com_token + 1, sizeof(key));
5156                         else
5157                                 strlcpy(key, com_token, sizeof(key));
5158                         while (key[strlen(key)-1] == ' ') // remove trailing spaces
5159                                 key[strlen(key)-1] = 0;
5160                         if (!COM_ParseToken_Simple(&data, false, false))
5161                                 break; // error
5162                         strlcpy(value, com_token, sizeof(value));
5163
5164                         // now that we have the key pair worked out...
5165                         if (!strcmp("light", key))
5166                         {
5167                                 n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]);
5168                                 if (n == 1)
5169                                 {
5170                                         // quake
5171                                         light[0] = vec[0] * (1.0f / 256.0f);
5172                                         light[1] = vec[0] * (1.0f / 256.0f);
5173                                         light[2] = vec[0] * (1.0f / 256.0f);
5174                                         light[3] = vec[0];
5175                                 }
5176                                 else if (n == 4)
5177                                 {
5178                                         // halflife
5179                                         light[0] = vec[0] * (1.0f / 255.0f);
5180                                         light[1] = vec[1] * (1.0f / 255.0f);
5181                                         light[2] = vec[2] * (1.0f / 255.0f);
5182                                         light[3] = vec[3];
5183                                 }
5184                         }
5185                         else if (!strcmp("delay", key))
5186                                 type = atoi(value);
5187                         else if (!strcmp("origin", key))
5188                                 sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]);
5189                         else if (!strcmp("angle", key))
5190                                 angles[0] = 0, angles[1] = atof(value), angles[2] = 0;
5191                         else if (!strcmp("angles", key))
5192                                 sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]);
5193                         else if (!strcmp("color", key))
5194                                 sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]);
5195                         else if (!strcmp("wait", key))
5196                                 fadescale = atof(value);
5197                         else if (!strcmp("classname", key))
5198                         {
5199                                 if (!strncmp(value, "light", 5))
5200                                 {
5201                                         islight = true;
5202                                         if (!strcmp(value, "light_fluoro"))
5203                                         {
5204                                                 originhack[0] = 0;
5205                                                 originhack[1] = 0;
5206                                                 originhack[2] = 0;
5207                                                 overridecolor[0] = 1;
5208                                                 overridecolor[1] = 1;
5209                                                 overridecolor[2] = 1;
5210                                         }
5211                                         if (!strcmp(value, "light_fluorospark"))
5212                                         {
5213                                                 originhack[0] = 0;
5214                                                 originhack[1] = 0;
5215                                                 originhack[2] = 0;
5216                                                 overridecolor[0] = 1;
5217                                                 overridecolor[1] = 1;
5218                                                 overridecolor[2] = 1;
5219                                         }
5220                                         if (!strcmp(value, "light_globe"))
5221                                         {
5222                                                 originhack[0] = 0;
5223                                                 originhack[1] = 0;
5224                                                 originhack[2] = 0;
5225                                                 overridecolor[0] = 1;
5226                                                 overridecolor[1] = 0.8;
5227                                                 overridecolor[2] = 0.4;
5228                                         }
5229                                         if (!strcmp(value, "light_flame_large_yellow"))
5230                                         {
5231                                                 originhack[0] = 0;
5232                                                 originhack[1] = 0;
5233                                                 originhack[2] = 0;
5234                                                 overridecolor[0] = 1;
5235                                                 overridecolor[1] = 0.5;
5236                                                 overridecolor[2] = 0.1;
5237                                         }
5238                                         if (!strcmp(value, "light_flame_small_yellow"))
5239                                         {
5240                                                 originhack[0] = 0;
5241                                                 originhack[1] = 0;
5242                                                 originhack[2] = 0;
5243                                                 overridecolor[0] = 1;
5244                                                 overridecolor[1] = 0.5;
5245                                                 overridecolor[2] = 0.1;
5246                                         }
5247                                         if (!strcmp(value, "light_torch_small_white"))
5248                                         {
5249                                                 originhack[0] = 0;
5250                                                 originhack[1] = 0;
5251                                                 originhack[2] = 0;
5252                                                 overridecolor[0] = 1;
5253                                                 overridecolor[1] = 0.5;
5254                                                 overridecolor[2] = 0.1;
5255                                         }
5256                                         if (!strcmp(value, "light_torch_small_walltorch"))
5257                                         {
5258                                                 originhack[0] = 0;
5259                                                 originhack[1] = 0;
5260                                                 originhack[2] = 0;
5261                                                 overridecolor[0] = 1;
5262                                                 overridecolor[1] = 0.5;
5263                                                 overridecolor[2] = 0.1;
5264                                         }
5265                                 }
5266                         }
5267                         else if (!strcmp("style", key))
5268                                 style = atoi(value);
5269                         else if (!strcmp("skin", key))
5270                                 skin = (int)atof(value);
5271                         else if (!strcmp("pflags", key))
5272                                 pflags = (int)atof(value);
5273                         else if (!strcmp("effects", key))
5274                                 effects = (int)atof(value);
5275                         else if (cl.worldmodel->type == mod_brushq3)
5276                         {
5277                                 if (!strcmp("scale", key))
5278                                         lightscale = atof(value);
5279                                 if (!strcmp("fade", key))
5280                                         fadescale = atof(value);
5281                         }
5282                 }
5283                 if (!islight)
5284                         continue;
5285                 if (lightscale <= 0)
5286                         lightscale = 1;
5287                 if (fadescale <= 0)
5288                         fadescale = 1;
5289                 if (color[0] == color[1] && color[0] == color[2])
5290                 {
5291                         color[0] *= overridecolor[0];
5292                         color[1] *= overridecolor[1];
5293                         color[2] *= overridecolor[2];
5294                 }
5295                 radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale;
5296                 color[0] = color[0] * light[0];
5297                 color[1] = color[1] * light[1];
5298                 color[2] = color[2] * light[2];
5299                 switch (type)
5300                 {
5301                 case LIGHTTYPE_MINUSX:
5302                         break;
5303                 case LIGHTTYPE_RECIPX:
5304                         radius *= 2;
5305                         VectorScale(color, (1.0f / 16.0f), color);
5306                         break;
5307                 case LIGHTTYPE_RECIPXX:
5308                         radius *= 2;
5309                         VectorScale(color, (1.0f / 16.0f), color);
5310                         break;
5311                 default:
5312                 case LIGHTTYPE_NONE:
5313                         break;
5314                 case LIGHTTYPE_SUN:
5315                         break;
5316                 case LIGHTTYPE_MINUSXX:
5317                         break;
5318                 }
5319                 VectorAdd(origin, originhack, origin);
5320                 if (radius >= 1)
5321                         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);
5322         }
5323         if (entfiledata)
5324                 Mem_Free(entfiledata);
5325 }
5326
5327
5328 void R_Shadow_SetCursorLocationForView(void)
5329 {
5330         vec_t dist, push;
5331         vec3_t dest, endpos;
5332         trace_t trace;
5333         VectorMA(r_refdef.view.origin, r_editlights_cursordistance.value, r_refdef.view.forward, dest);
5334         trace = CL_TraceLine(r_refdef.view.origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
5335         if (trace.fraction < 1)
5336         {
5337                 dist = trace.fraction * r_editlights_cursordistance.value;
5338                 push = r_editlights_cursorpushback.value;
5339                 if (push > dist)
5340                         push = dist;
5341                 push = -push;
5342                 VectorMA(trace.endpos, push, r_refdef.view.forward, endpos);
5343                 VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos);
5344         }
5345         else
5346         {
5347                 VectorClear( endpos );
5348         }
5349         r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5350         r_editlights_cursorlocation[1] = floor(endpos[1] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5351         r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value;
5352 }
5353
5354 void R_Shadow_UpdateWorldLightSelection(void)
5355 {
5356         if (r_editlights.integer)
5357         {
5358                 R_Shadow_SetCursorLocationForView();
5359                 R_Shadow_SelectLightInView();
5360         }
5361         else
5362                 R_Shadow_SelectLight(NULL);
5363 }
5364
5365 void R_Shadow_EditLights_Clear_f(void)
5366 {
5367         R_Shadow_ClearWorldLights();
5368 }
5369
5370 void R_Shadow_EditLights_Reload_f(void)
5371 {
5372         if (!cl.worldmodel)
5373                 return;
5374         strlcpy(r_shadow_mapname, cl.worldmodel->name, sizeof(r_shadow_mapname));
5375         R_Shadow_ClearWorldLights();
5376         R_Shadow_LoadWorldLights();
5377         if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5378         {
5379                 R_Shadow_LoadLightsFile();
5380                 if (!Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray))
5381                         R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5382         }
5383 }
5384
5385 void R_Shadow_EditLights_Save_f(void)
5386 {
5387         if (!cl.worldmodel)
5388                 return;
5389         R_Shadow_SaveWorldLights();
5390 }
5391
5392 void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void)
5393 {
5394         R_Shadow_ClearWorldLights();
5395         R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
5396 }
5397
5398 void R_Shadow_EditLights_ImportLightsFile_f(void)
5399 {
5400         R_Shadow_ClearWorldLights();
5401         R_Shadow_LoadLightsFile();
5402 }
5403
5404 void R_Shadow_EditLights_Spawn_f(void)
5405 {
5406         vec3_t color;
5407         if (!r_editlights.integer)
5408         {
5409                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5410                 return;
5411         }
5412         if (Cmd_Argc() != 1)
5413         {
5414                 Con_Print("r_editlights_spawn does not take parameters\n");
5415                 return;
5416         }
5417         color[0] = color[1] = color[2] = 1;
5418         R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE);
5419 }
5420
5421 void R_Shadow_EditLights_Edit_f(void)
5422 {
5423         vec3_t origin, angles, color;
5424         vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale;
5425         int style, shadows, flags, normalmode, realtimemode;
5426         char cubemapname[MAX_INPUTLINE];
5427         if (!r_editlights.integer)
5428         {
5429                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5430                 return;
5431         }
5432         if (!r_shadow_selectedlight)
5433         {
5434                 Con_Print("No selected light.\n");
5435                 return;
5436         }
5437         VectorCopy(r_shadow_selectedlight->origin, origin);
5438         VectorCopy(r_shadow_selectedlight->angles, angles);
5439         VectorCopy(r_shadow_selectedlight->color, color);
5440         radius = r_shadow_selectedlight->radius;
5441         style = r_shadow_selectedlight->style;
5442         if (r_shadow_selectedlight->cubemapname)
5443                 strlcpy(cubemapname, r_shadow_selectedlight->cubemapname, sizeof(cubemapname));
5444         else
5445                 cubemapname[0] = 0;
5446         shadows = r_shadow_selectedlight->shadow;
5447         corona = r_shadow_selectedlight->corona;
5448         coronasizescale = r_shadow_selectedlight->coronasizescale;
5449         ambientscale = r_shadow_selectedlight->ambientscale;
5450         diffusescale = r_shadow_selectedlight->diffusescale;
5451         specularscale = r_shadow_selectedlight->specularscale;
5452         flags = r_shadow_selectedlight->flags;
5453         normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0;
5454         realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0;
5455         if (!strcmp(Cmd_Argv(1), "origin"))
5456         {
5457                 if (Cmd_Argc() != 5)
5458                 {
5459                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5460                         return;
5461                 }
5462                 origin[0] = atof(Cmd_Argv(2));
5463                 origin[1] = atof(Cmd_Argv(3));
5464                 origin[2] = atof(Cmd_Argv(4));
5465         }
5466         else if (!strcmp(Cmd_Argv(1), "originx"))
5467         {
5468                 if (Cmd_Argc() != 3)
5469                 {
5470                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5471                         return;
5472                 }
5473                 origin[0] = atof(Cmd_Argv(2));
5474         }
5475         else if (!strcmp(Cmd_Argv(1), "originy"))
5476         {
5477                 if (Cmd_Argc() != 3)
5478                 {
5479                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5480                         return;
5481                 }
5482                 origin[1] = atof(Cmd_Argv(2));
5483         }
5484         else if (!strcmp(Cmd_Argv(1), "originz"))
5485         {
5486                 if (Cmd_Argc() != 3)
5487                 {
5488                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5489                         return;
5490                 }
5491                 origin[2] = atof(Cmd_Argv(2));
5492         }
5493         else if (!strcmp(Cmd_Argv(1), "move"))
5494         {
5495                 if (Cmd_Argc() != 5)
5496                 {
5497                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5498                         return;
5499                 }
5500                 origin[0] += atof(Cmd_Argv(2));
5501                 origin[1] += atof(Cmd_Argv(3));
5502                 origin[2] += atof(Cmd_Argv(4));
5503         }
5504         else if (!strcmp(Cmd_Argv(1), "movex"))
5505         {
5506                 if (Cmd_Argc() != 3)
5507                 {
5508                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5509                         return;
5510                 }
5511                 origin[0] += atof(Cmd_Argv(2));
5512         }
5513         else if (!strcmp(Cmd_Argv(1), "movey"))
5514         {
5515                 if (Cmd_Argc() != 3)
5516                 {
5517                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5518                         return;
5519                 }
5520                 origin[1] += atof(Cmd_Argv(2));
5521         }
5522         else if (!strcmp(Cmd_Argv(1), "movez"))
5523         {
5524                 if (Cmd_Argc() != 3)
5525                 {
5526                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5527                         return;
5528                 }
5529                 origin[2] += atof(Cmd_Argv(2));
5530         }
5531         else if (!strcmp(Cmd_Argv(1), "angles"))
5532         {
5533                 if (Cmd_Argc() != 5)
5534                 {
5535                         Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1));
5536                         return;
5537                 }
5538                 angles[0] = atof(Cmd_Argv(2));
5539                 angles[1] = atof(Cmd_Argv(3));
5540                 angles[2] = atof(Cmd_Argv(4));
5541         }
5542         else if (!strcmp(Cmd_Argv(1), "anglesx"))
5543         {
5544                 if (Cmd_Argc() != 3)
5545                 {
5546                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5547                         return;
5548                 }
5549                 angles[0] = atof(Cmd_Argv(2));
5550         }
5551         else if (!strcmp(Cmd_Argv(1), "anglesy"))
5552         {
5553                 if (Cmd_Argc() != 3)
5554                 {
5555                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5556                         return;
5557                 }
5558                 angles[1] = atof(Cmd_Argv(2));
5559         }
5560         else if (!strcmp(Cmd_Argv(1), "anglesz"))
5561         {
5562                 if (Cmd_Argc() != 3)
5563                 {
5564                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5565                         return;
5566                 }
5567                 angles[2] = atof(Cmd_Argv(2));
5568         }
5569         else if (!strcmp(Cmd_Argv(1), "color"))
5570         {
5571                 if (Cmd_Argc() != 5)
5572                 {
5573                         Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1));
5574                         return;
5575                 }
5576                 color[0] = atof(Cmd_Argv(2));
5577                 color[1] = atof(Cmd_Argv(3));
5578                 color[2] = atof(Cmd_Argv(4));
5579         }
5580         else if (!strcmp(Cmd_Argv(1), "radius"))
5581         {
5582                 if (Cmd_Argc() != 3)
5583                 {
5584                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5585                         return;
5586                 }
5587                 radius = atof(Cmd_Argv(2));
5588         }
5589         else if (!strcmp(Cmd_Argv(1), "colorscale"))
5590         {
5591                 if (Cmd_Argc() == 3)
5592                 {
5593                         double scale = atof(Cmd_Argv(2));
5594                         color[0] *= scale;
5595                         color[1] *= scale;
5596                         color[2] *= scale;
5597                 }
5598                 else
5599                 {
5600                         if (Cmd_Argc() != 5)
5601                         {
5602                                 Con_Printf("usage: r_editlights_edit %s red green blue  (OR grey instead of red green blue)\n", Cmd_Argv(1));
5603                                 return;
5604                         }
5605                         color[0] *= atof(Cmd_Argv(2));
5606                         color[1] *= atof(Cmd_Argv(3));
5607                         color[2] *= atof(Cmd_Argv(4));
5608                 }
5609         }
5610         else if (!strcmp(Cmd_Argv(1), "radiusscale") || !strcmp(Cmd_Argv(1), "sizescale"))
5611         {
5612                 if (Cmd_Argc() != 3)
5613                 {
5614                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5615                         return;
5616                 }
5617                 radius *= atof(Cmd_Argv(2));
5618         }
5619         else if (!strcmp(Cmd_Argv(1), "style"))
5620         {
5621                 if (Cmd_Argc() != 3)
5622                 {
5623                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5624                         return;
5625                 }
5626                 style = atoi(Cmd_Argv(2));
5627         }
5628         else if (!strcmp(Cmd_Argv(1), "cubemap"))
5629         {
5630                 if (Cmd_Argc() > 3)
5631                 {
5632                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5633                         return;
5634                 }
5635                 if (Cmd_Argc() == 3)
5636                         strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname));
5637                 else
5638                         cubemapname[0] = 0;
5639         }
5640         else if (!strcmp(Cmd_Argv(1), "shadows"))
5641         {
5642                 if (Cmd_Argc() != 3)
5643                 {
5644                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5645                         return;
5646                 }
5647                 shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5648         }
5649         else if (!strcmp(Cmd_Argv(1), "corona"))
5650         {
5651                 if (Cmd_Argc() != 3)
5652                 {
5653                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5654                         return;
5655                 }
5656                 corona = atof(Cmd_Argv(2));
5657         }
5658         else if (!strcmp(Cmd_Argv(1), "coronasize"))
5659         {
5660                 if (Cmd_Argc() != 3)
5661                 {
5662                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5663                         return;
5664                 }
5665                 coronasizescale = atof(Cmd_Argv(2));
5666         }
5667         else if (!strcmp(Cmd_Argv(1), "ambient"))
5668         {
5669                 if (Cmd_Argc() != 3)
5670                 {
5671                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5672                         return;
5673                 }
5674                 ambientscale = atof(Cmd_Argv(2));
5675         }
5676         else if (!strcmp(Cmd_Argv(1), "diffuse"))
5677         {
5678                 if (Cmd_Argc() != 3)
5679                 {
5680                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5681                         return;
5682                 }
5683                 diffusescale = atof(Cmd_Argv(2));
5684         }
5685         else if (!strcmp(Cmd_Argv(1), "specular"))
5686         {
5687                 if (Cmd_Argc() != 3)
5688                 {
5689                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5690                         return;
5691                 }
5692                 specularscale = atof(Cmd_Argv(2));
5693         }
5694         else if (!strcmp(Cmd_Argv(1), "normalmode"))
5695         {
5696                 if (Cmd_Argc() != 3)
5697                 {
5698                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5699                         return;
5700                 }
5701                 normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5702         }
5703         else if (!strcmp(Cmd_Argv(1), "realtimemode"))
5704         {
5705                 if (Cmd_Argc() != 3)
5706                 {
5707                         Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1));
5708                         return;
5709                 }
5710                 realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2));
5711         }
5712         else
5713         {
5714                 Con_Print("usage: r_editlights_edit [property] [value]\n");
5715                 Con_Print("Selected light's properties:\n");
5716                 Con_Printf("Origin       : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
5717                 Con_Printf("Angles       : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
5718                 Con_Printf("Color        : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
5719                 Con_Printf("Radius       : %f\n", r_shadow_selectedlight->radius);
5720                 Con_Printf("Corona       : %f\n", r_shadow_selectedlight->corona);
5721                 Con_Printf("Style        : %i\n", r_shadow_selectedlight->style);
5722                 Con_Printf("Shadows      : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");
5723                 Con_Printf("Cubemap      : %s\n", r_shadow_selectedlight->cubemapname);
5724                 Con_Printf("CoronaSize   : %f\n", r_shadow_selectedlight->coronasizescale);
5725                 Con_Printf("Ambient      : %f\n", r_shadow_selectedlight->ambientscale);
5726                 Con_Printf("Diffuse      : %f\n", r_shadow_selectedlight->diffusescale);
5727                 Con_Printf("Specular     : %f\n", r_shadow_selectedlight->specularscale);
5728                 Con_Printf("NormalMode   : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");
5729                 Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");
5730                 return;
5731         }
5732         flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0);
5733         R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags);
5734 }
5735
5736 void R_Shadow_EditLights_EditAll_f(void)
5737 {
5738         size_t lightindex;
5739         dlight_t *light;
5740         size_t range;
5741
5742         if (!r_editlights.integer)
5743         {
5744                 Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n");
5745                 return;
5746         }
5747
5748         // EditLights doesn't seem to have a "remove" command or something so:
5749         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5750         for (lightindex = 0;lightindex < range;lightindex++)
5751         {
5752                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5753                 if (!light)
5754                         continue;
5755                 R_Shadow_SelectLight(light);
5756                 R_Shadow_EditLights_Edit_f();
5757         }
5758 }
5759
5760 void R_Shadow_EditLights_DrawSelectedLightProperties(void)
5761 {
5762         int lightnumber, lightcount;
5763         size_t lightindex, range;
5764         dlight_t *light;
5765         float x, y;
5766         char temp[256];
5767         if (!r_editlights.integer)
5768                 return;
5769         x = vid_conwidth.value - 240;
5770         y = 5;
5771         DrawQ_Pic(x-5, y-5, NULL, 250, 155, 0, 0, 0, 0.75, 0);
5772         lightnumber = -1;
5773         lightcount = 0;
5774         range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
5775         for (lightindex = 0;lightindex < range;lightindex++)
5776         {
5777                 light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
5778                 if (!light)
5779                         continue;
5780                 if (light == r_shadow_selectedlight)
5781                         lightnumber = lightindex;
5782                 lightcount++;
5783         }
5784         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;
5785         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;
5786         y += 8;
5787         if (r_shadow_selectedlight == NULL)
5788                 return;
5789         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;
5790         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;
5791         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;
5792         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;
5793         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;
5794         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;
5795         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;
5796         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;
5797         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;
5798         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;
5799         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;
5800         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;
5801         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;
5802         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;
5803         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;
5804 }
5805
5806 void R_Shadow_EditLights_ToggleShadow_f(void)
5807 {
5808         if (!r_editlights.integer)
5809         {
5810                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5811                 return;
5812         }
5813         if (!r_shadow_selectedlight)
5814         {
5815                 Con_Print("No selected light.\n");
5816                 return;
5817         }
5818         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);
5819 }
5820
5821 void R_Shadow_EditLights_ToggleCorona_f(void)
5822 {
5823         if (!r_editlights.integer)
5824         {
5825                 Con_Print("Cannot spawn light when not in editing mode.  Set r_editlights to 1.\n");
5826                 return;
5827         }
5828         if (!r_shadow_selectedlight)
5829         {
5830                 Con_Print("No selected light.\n");
5831                 return;
5832         }
5833         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);
5834 }
5835
5836 void R_Shadow_EditLights_Remove_f(void)
5837 {
5838         if (!r_editlights.integer)
5839         {
5840                 Con_Print("Cannot remove light when not in editing mode.  Set r_editlights to 1.\n");
5841                 return;
5842         }
5843         if (!r_shadow_selectedlight)
5844         {
5845                 Con_Print("No selected light.\n");
5846                 return;
5847         }
5848         R_Shadow_FreeWorldLight(r_shadow_selectedlight);
5849         r_shadow_selectedlight = NULL;
5850 }
5851
5852 void R_Shadow_EditLights_Help_f(void)
5853 {
5854         Con_Print(
5855 "Documentation on r_editlights system:\n"
5856 "Settings:\n"
5857 "r_editlights : enable/disable editing mode\n"
5858 "r_editlights_cursordistance : maximum distance of cursor from eye\n"
5859 "r_editlights_cursorpushback : push back cursor this far from surface\n"
5860 "r_editlights_cursorpushoff : push cursor off surface this far\n"
5861 "r_editlights_cursorgrid : snap cursor to grid of this size\n"
5862 "r_editlights_quakelightsizescale : imported quake light entity size scaling\n"
5863 "Commands:\n"
5864 "r_editlights_help : this help\n"
5865 "r_editlights_clear : remove all lights\n"
5866 "r_editlights_reload : reload .rtlights, .lights file, or entities\n"
5867 "r_editlights_save : save to .rtlights file\n"
5868 "r_editlights_spawn : create a light with default settings\n"
5869 "r_editlights_edit command : edit selected light - more documentation below\n"
5870 "r_editlights_remove : remove selected light\n"
5871 "r_editlights_toggleshadow : toggles on/off selected light's shadow property\n"
5872 "r_editlights_importlightentitiesfrommap : reload light entities\n"
5873 "r_editlights_importlightsfile : reload .light file (produced by hlight)\n"
5874 "Edit commands:\n"
5875 "origin x y z : set light location\n"
5876 "originx x: set x component of light location\n"
5877 "originy y: set y component of light location\n"
5878 "originz z: set z component of light location\n"
5879 "move x y z : adjust light location\n"
5880 "movex x: adjust x component of light location\n"
5881 "movey y: adjust y component of light location\n"
5882 "movez z: adjust z component of light location\n"
5883 "angles x y z : set light angles\n"
5884 "anglesx x: set x component of light angles\n"
5885 "anglesy y: set y component of light angles\n"
5886 "anglesz z: set z component of light angles\n"
5887 "color r g b : set color of light (can be brighter than 1 1 1)\n"
5888 "radius radius : set radius (size) of light\n"
5889 "colorscale grey : multiply color of light (1 does nothing)\n"
5890 "colorscale r g b : multiply color of light (1 1 1 does nothing)\n"
5891 "radiusscale scale : multiply radius (size) of light (1 does nothing)\n"
5892 "sizescale scale : multiply radius (size) of light (1 does nothing)\n"
5893 "style style : set lightstyle of light (flickering patterns, switches, etc)\n"
5894 "cubemap basename : set filter cubemap of light (not yet supported)\n"
5895 "shadows 1/0 : turn on/off shadows\n"
5896 "corona n : set corona intensity\n"
5897 "coronasize n : set corona size (0-1)\n"
5898 "ambient n : set ambient intensity (0-1)\n"
5899 "diffuse n : set diffuse intensity (0-1)\n"
5900 "specular n : set specular intensity (0-1)\n"
5901 "normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n"
5902 "realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n"
5903 "<nothing> : print light properties to console\n"
5904         );
5905 }
5906
5907 void R_Shadow_EditLights_CopyInfo_f(void)
5908 {
5909         if (!r_editlights.integer)
5910         {
5911                 Con_Print("Cannot copy light info when not in editing mode.  Set r_editlights to 1.\n");
5912                 return;
5913         }
5914         if (!r_shadow_selectedlight)
5915         {
5916                 Con_Print("No selected light.\n");
5917                 return;
5918         }
5919         VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles);
5920         VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color);
5921         r_shadow_bufferlight.radius = r_shadow_selectedlight->radius;
5922         r_shadow_bufferlight.style = r_shadow_selectedlight->style;
5923         if (r_shadow_selectedlight->cubemapname)
5924                 strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname));
5925         else
5926                 r_shadow_bufferlight.cubemapname[0] = 0;
5927         r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;
5928         r_shadow_bufferlight.corona = r_shadow_selectedlight->corona;
5929         r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale;
5930         r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale;
5931         r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale;
5932         r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale;
5933         r_shadow_bufferlight.flags = r_shadow_selectedlight->flags;
5934 }
5935
5936 void R_Shadow_EditLights_PasteInfo_f(void)
5937 {
5938         if (!r_editlights.integer)
5939         {
5940                 Con_Print("Cannot paste light info when not in editing mode.  Set r_editlights to 1.\n");
5941                 return;
5942         }
5943         if (!r_shadow_selectedlight)
5944         {
5945                 Con_Print("No selected light.\n");
5946                 return;
5947         }
5948         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);
5949 }
5950
5951 void R_Shadow_EditLights_Init(void)
5952 {
5953         Cvar_RegisterVariable(&r_editlights);
5954         Cvar_RegisterVariable(&r_editlights_cursordistance);
5955         Cvar_RegisterVariable(&r_editlights_cursorpushback);
5956         Cvar_RegisterVariable(&r_editlights_cursorpushoff);
5957         Cvar_RegisterVariable(&r_editlights_cursorgrid);
5958         Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
5959         Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
5960         Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
5961         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)");
5962         Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
5963         Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
5964         Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
5965         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)");
5966         Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
5967         Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
5968         Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
5969         Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
5970         Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
5971         Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
5972         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)");
5973 }
5974
5975
5976
5977 /*
5978 =============================================================================
5979
5980 LIGHT SAMPLING
5981
5982 =============================================================================
5983 */
5984
5985 void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const vec3_t p, int dynamic)
5986 {
5987         VectorClear(diffusecolor);
5988         VectorClear(diffusenormal);
5989
5990         if (!r_fullbright.integer && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.LightPoint)
5991         {
5992                 ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_refdef.scene.ambient;
5993                 r_refdef.scene.worldmodel->brush.LightPoint(r_refdef.scene.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
5994         }
5995         else
5996                 VectorSet(ambientcolor, 1, 1, 1);
5997
5998         if (dynamic)
5999         {
6000                 int i;
6001                 float f, v[3];
6002                 rtlight_t *light;
6003                 for (i = 0;i < r_refdef.scene.numlights;i++)
6004                 {
6005                         light = r_refdef.scene.lights[i];
6006                         Matrix4x4_Transform(&light->matrix_worldtolight, p, v);
6007                         f = 1 - VectorLength2(v);
6008                         if (f > 0 && CL_TraceLine(p, light->shadoworigin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1)
6009                                 VectorMA(ambientcolor, f, light->currentcolor, ambientcolor);
6010                 }
6011         }
6012 }